Can I combine multiple (sorted) collections together, keeping relative item indices when new items are added?

[RoVaDePi]

I want to add multiple (sorted) collections together, I managed to get this mostly working with .Or() but if any of the collections get a new item it just gets appended to the end of the composite collection, which is not what I expect or want...

_sourceList1 = new SourceList<string>();
_sourceList2 = new SourceList<string>();
//add some random strings to both lists
_sourceList1
  .Connect()
  .Sort(SortExpressionComparer<string>.Ascending(s => s))
  .Or(_sourceList2
    .Connect()
    .Sort(SortExpressionComparer<string>.Descending(s => s)))
  .Bind(out var sortedListsCombined1)
  .Subscribe();

Initial output is what I expect, eg:

List 1 item a
List 1 item b
List 1 item c
List 2 item c
List 2 item b
List 2 item a

However, if I now add a new item _sourceList2.Add("List 2 item d"); it just ends up at the end of the collection, eg:

List 1 item a
List 1 item b
List 1 item c
List 2 item c
List 2 item b
List 2 item a
List 2 item d

I have tried alternatives:

var orList = new SourceList<IObservable<IChangeSet<string>>>();
orList.Add(_sourceList1
    .Connect()
    .Sort(SortExpressionComparer<string>.Ascending(s => s)));
orList.Add(_sourceList2
    .Connect()
    .Sort(SortExpressionComparer<string>.Descending(s => s)));
orList.Or().Bind(out var sortedListsCombined2).Subscribe();

and

_sourceList1
.Connect()
.Sort(SortExpressionComparer<string>.Ascending(s => s))
.Merge(_sourceList2
    .Connect()
    .Sort(SortExpressionComparer<string>.Descending(s => s)))
.Bind(out var sortedListsMerged).Subscribe();

But none of them seem to keep the correct index (though .Merge() seems to keep some index)
See also visual example:

(red items are newly added)
Source code can be found here:
https://github.com/RoDePi/DynamicDataOrderedOr

[RoVaDePi]

I tried another variant, using TransformMany, but this also doesn't seem to keep the relative indices.
For reference:

var sourceLists = new SourceList<IObservableList<string>>();
sourceLists.AddRange(new[]
{
    _sourceList1.Connect().Sort(SortExpressionComparer<string>.Ascending(s => s)).AsObservableList(),
    _sourceList2.Connect().Sort(SortExpressionComparer<string>.Descending(s => s)).AsObservableList()
});
_cleanUp.Add(sourceLists
    .Connect()
    .TransformMany(sl => sl)
    .Bind(out var sortedListsTransformMany)
    .Subscribe());
SortedListsTransformMany = sortedListsTransformMany;

[tomasfil]

You could try something like this:

public class SortedChunkedCollection<T>
{
    private readonly ISourceList<ChunkedItem<T>> _sourceList = new SourceList<ChunkedItem<T>>();

    public SortedChunkedCollection(params ISourceList<T>[] sourceLists)
    {
        // Subscribe to changes in each source list and add items with their source index
        for (int i = 0; i < sourceLists.Length; i++)
        {
            var sourceList = sourceLists[i];
            sourceList.Connect()
                .Subscribe(changeSet =>
                {
                    foreach (var item in changeSet)
                    {
                        _sourceList.Add(new ChunkedItem<T>(item, i));
                    }
                });
        }

        // Sort the combined collection by source index, then by item
        _sourceList.Connect()
            .Sort(SortExpressionComparer<ChunkedItem<T>>.Ascending(item => item.SourceIndex).ThenBy(item => item.Item))
            .Transform(item => item.Item)
            .Bind(out sortedCollection)
            .Subscribe();
    }

    public ReadOnlyObservableCollection<T> SortedCollection => sortedCollection ;
    private readonly ReadOnlyObservableCollection<T> sortedCollection;

    private class ChunkedItem<TItem>
    {
        public TItem Item { get; }
        public int SourceIndex { get; }

        public ChunkedItem(TItem item, int sourceIndex)
        {
            Item = item;
            SourceIndex = sourceIndex;
        }
    }
}

you can extend it by any extension you need.