@oimdb/core 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -8,7 +8,7 @@ type TOIMAnyEntitySlot<TPk extends TOIMPk> = TOIMEntitySlot<object, TPk>;
 type TOIMEntitySlotResolver<TPk extends TOIMPk> = (pk: TPk) => TOIMAnyEntitySlot<TPk> | undefined;
 
 declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TOIMPk> {
-    abstract setOneByPk(pk: TPk, entity: TEntity): void;
+    abstract setOneByPk(pk: TPk, entity: TEntity): TOIMEntitySlot<TEntity, TPk>;
     abstract getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     abstract getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     abstract getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
@@ -23,6 +23,74 @@ declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TO
     abstract destroy(): void;
 }
 
+type TOIMEventHandler<T> = (payload: T) => void;
+
+declare class OIMEventEmitter<T extends Record<string, unknown>> {
+    private buckets;
+    hasHandlers<K extends keyof T>(event: K): boolean;
+    private getOrCreateBucket;
+    /**
+     * Compacts the handlers array by removing null entries (tombstones) left by handler removal.
+     * Rebuilds the indexByHandler map with updated indices and resets the tombstone count.
+     * This reduces array fragmentation and improves iteration performance.
+     */
+    private compactBucket;
+    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): () => void;
+    emit<K extends keyof T>(event: K, payload: T[K]): void;
+    off<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
+    offAll<K extends keyof T>(event?: K): void;
+}
+
+/**
+ * Payload for index update events containing the keys that were modified */
+interface TOIMIndexUpdatePayload<TKey> {
+    keys: readonly TKey[];
+}
+
+/**
+ * Comparator function for index primary key arrays.
+ * Returns true if the arrays are considered equal, false if they differ. */
+type TOIMIndexComparator<TPk extends TOIMPk> = (existingPks: readonly TPk[], newPks: readonly TPk[]) => boolean;
+
+interface IOIMIndexStore<TKey, TBucket> {
+    setOneByKey(key: TKey, bucket: TBucket): void;
+    removeOneByKey(key: TKey): void;
+    removeManyByKeys(keys: readonly TKey[]): void;
+    getOneByKey(key: TKey): TBucket | undefined;
+    getManyByKeys(keys: readonly TKey[]): Map<TKey, TBucket>;
+    getAllKeys(): TKey[];
+    getAll(): Map<TKey, TBucket>;
+    countAll(): number;
+    clear(): void;
+}
+declare abstract class OIMIndex<TKey extends TOIMPk, TPk extends TOIMPk, TBucket extends Iterable<TOIMAnyEntitySlot<TPk>>> {
+    protected readonly comparePks?: TOIMIndexComparator<TPk>;
+    protected readonly store: IOIMIndexStore<TKey, TBucket>;
+    readonly emitter: OIMEventEmitter<{
+        0: TOIMIndexUpdatePayload<TKey>;
+    }>;
+    constructor(store: IOIMIndexStore<TKey, TBucket>, comparePks?: TOIMIndexComparator<TPk>);
+    protected abstract getBucketSize(bucket: TBucket): number;
+    hasKey(key: TKey): boolean;
+    getKeys(): readonly TKey[];
+    getKeySize(key: TKey): number;
+    get size(): number;
+    get isEmpty(): boolean;
+    getEntitiesByKey<TEntity extends object = object>(key: TKey): TEntity[];
+    getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, TEntity[]>;
+    getMetrics(): {
+        totalKeys: number;
+        totalPks: number;
+        averagePksPerKey: number;
+        maxBucketSize: number;
+        minBucketSize: number;
+    };
+    destroy(): void;
+    protected emitUpdate(keys: TKey[]): void;
+    protected emitUpdateOne(key: TKey): void;
+    protected slotsToEntities<TEntity extends object>(slots: Iterable<TOIMAnyEntitySlot<TPk>>): TEntity[];
+}
+
 declare abstract class OIMIndexStoreSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
     abstract setOneByKey(key: TKey, slots: Set<TOIMAnyEntitySlot<TPk>>): void;
     abstract removeOneByKey(key: TKey): void;
@@ -47,24 +115,6 @@ declare abstract class OIMIndexStoreArrayBased<TKey extends TOIMPk, TPk extends
     abstract clear(): void;
 }
 
-type TOIMEventHandler<T> = (payload: T) => void;
-
-declare class OIMEventEmitter<T extends Record<string, unknown>> {
-    private buckets;
-    hasHandlers<K extends keyof T>(event: K): boolean;
-    private getOrCreateBucket;
-    /**
-     * Compacts the handlers array by removing null entries (tombstones) left by handler removal.
-     * Rebuilds the indexByHandler map with updated indices and resets the tombstone count.
-     * This reduces array fragmentation and improves iteration performance.
-     */
-    private compactBucket;
-    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): () => void;
-    emit<K extends keyof T>(event: K, payload: T[K]): void;
-    off<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
-    offAll<K extends keyof T>(event?: K): void;
-}
-
 declare enum EOIMEventQueueSchedulerEventType {
     FLUSH = 0
 }
@@ -91,182 +141,32 @@ declare abstract class OIMEventQueueScheduler {
     protected flush(): void;
 }
 
-/**
- * Payload for index update events containing the keys that were modified */
-interface TOIMIndexUpdatePayload<TKey> {
-    keys: readonly TKey[];
-}
-
-/**
- * Comparator function for index primary key arrays.
- * Returns true if the arrays are considered equal, false if they differ. */
-type TOIMIndexComparator<TPk extends TOIMPk> = (existingPks: readonly TPk[], newPks: readonly TPk[]) => boolean;
-
-/**
- * Abstract base class for Set-based index types.
- * Provides common functionality and event system for key-to-PKs mappings using Set storage.
- */
-declare abstract class OIMIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
-    protected readonly comparePks?: TOIMIndexComparator<TPk>;
-    protected readonly store: OIMIndexStoreSetBased<TKey, TPk>;
-    protected resolveSlot?: TOIMEntitySlotResolver<TPk>;
-    private readonly fallbackSlots;
-    readonly emitter: OIMEventEmitter<{
-        0: TOIMIndexUpdatePayload<TKey>;
-    }>;
+declare abstract class OIMIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndex<TKey, TPk, Set<TOIMAnyEntitySlot<TPk>>> {
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TKey, TPk>;
-        resolveSlot?: TOIMEntitySlotResolver<TPk>;
     });
-    /**
-     * Get primary keys for multiple index keys
-     */
-    getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
-    setSlotResolver(resolveSlot: TOIMEntitySlotResolver<TPk>): void;
-    /**
-     * @deprecated Use getPksByKey instead
-     * Get primary keys for a specific index key
-     */
-    getPks(key: TKey): Set<TPk>;
-    /**
-     * Get primary keys for a specific index key
-     */
+    protected getBucketSize(bucket: Set<TOIMAnyEntitySlot<TPk>>): number;
     getPksByKey(key: TKey): Set<TPk>;
+    getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
     getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, ReadonlySet<TOIMAnyEntitySlot<TPk>>>;
-    /**
-     * Check if an index key exists
-     */
-    hasKey(key: TKey): boolean;
-    /**
-     * Get all index keys
-     */
-    getKeys(): readonly TKey[];
-    /**
-     * Get the number of primary keys for a specific index key
-     */
-    getKeySize(key: TKey): number;
-    /**
-     * Get total number of index keys
-     */
-    get size(): number;
-    /**
-     * Check if the index is empty
-     */
-    get isEmpty(): boolean;
-    /**
-     * Get performance metrics for monitoring and debugging
-     */
-    getMetrics(): {
-        totalKeys: number;
-        totalPks: number;
-        averagePksPerKey: number;
-        maxBucketSize: number;
-        minBucketSize: number;
-    };
-    /**
-     * Clean up event listeners when index is no longer needed
-     */
-    destroy(): void;
-    /**
-     * Set primary keys for a specific index key with optional comparison.
-     * If comparator is provided and returns true (no changes), skip the update.
-     */
-    protected setPksWithComparison(key: TKey, newPks: Set<TPk>): boolean;
-    protected setSlotsWithComparison(key: TKey, newSlots: Set<TOIMAnyEntitySlot<TPk>>): boolean;
-    protected resolveSlots(pks: Iterable<TPk>): Set<TOIMAnyEntitySlot<TPk>>;
-    protected getOrCreateSlot(pk: TPk): TOIMAnyEntitySlot<TPk>;
     protected slotsToPks(slots: Iterable<TOIMAnyEntitySlot<TPk>>): Set<TPk>;
-    /**
-     * Emit update event with changed keys
-     */
-    protected emitUpdate(keys: TKey[]): void;
-    /**
-     * Emit update event for a single key (fast-path override point).
-     */
-    protected emitUpdateOne(key: TKey): void;
+    protected setSlotsWithComparison(key: TKey, newSlots: Set<TOIMAnyEntitySlot<TPk>>): boolean;
 }
 
-/**
- * Abstract base class for Array-based index types.
- * Provides common functionality and event system for key-to-PKs mappings using Array storage.
- */
-declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> {
-    protected readonly comparePks?: TOIMIndexComparator<TPk>;
-    protected readonly store: OIMIndexStoreArrayBased<TKey, TPk>;
-    protected resolveSlot?: TOIMEntitySlotResolver<TPk>;
-    private readonly fallbackSlots;
-    readonly emitter: OIMEventEmitter<{
-        0: TOIMIndexUpdatePayload<TKey>;
-    }>;
+declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndex<TKey, TPk, TOIMAnyEntitySlot<TPk>[]> {
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreArrayBased<TKey, TPk>;
-        resolveSlot?: TOIMEntitySlotResolver<TPk>;
     });
-    /**
-     * Get primary keys for multiple index keys
-     */
-    getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
-    setSlotResolver(resolveSlot: TOIMEntitySlotResolver<TPk>): void;
-    /**
-     * Get primary keys for a specific index key
-     */
+    protected getBucketSize(bucket: TOIMAnyEntitySlot<TPk>[]): number;
     getPksByKey(key: TKey): TPk[];
+    getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
     getSlotsByKey(key: TKey): readonly TOIMAnyEntitySlot<TPk>[];
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, readonly TOIMAnyEntitySlot<TPk>[]>;
-    /**
-     * Check if an index key exists
-     */
-    hasKey(key: TKey): boolean;
-    /**
-     * Get all index keys
-     */
-    getKeys(): readonly TKey[];
-    /**
-     * Get the number of primary keys for a specific index key
-     */
-    getKeySize(key: TKey): number;
-    /**
-     * Get total number of index keys
-     */
-    get size(): number;
-    /**
-     * Check if the index is empty
-     */
-    get isEmpty(): boolean;
-    /**
-     * Get performance metrics for monitoring and debugging
-     */
-    getMetrics(): {
-        totalKeys: number;
-        totalPks: number;
-        averagePksPerKey: number;
-        maxBucketSize: number;
-        minBucketSize: number;
-    };
-    /**
-     * Clean up event listeners when index is no longer needed
-     */
-    destroy(): void;
-    /**
-     * Set primary keys for a specific index key with optional comparison.
-     * If comparator is provided and returns true (no changes), skip the update.
-     */
-    protected setPksWithComparison(key: TKey, newPks: TPk[]): boolean;
-    protected setSlotsWithComparison(key: TKey, newSlots: TOIMAnyEntitySlot<TPk>[]): boolean;
-    protected resolveSlots(pks: readonly TPk[]): TOIMAnyEntitySlot<TPk>[];
-    protected getOrCreateSlot(pk: TPk): TOIMAnyEntitySlot<TPk>;
     protected slotsToPks(slots: readonly TOIMAnyEntitySlot<TPk>[]): TPk[];
-    /**
-     * Emit update event with changed keys
-     */
-    protected emitUpdate(keys: TKey[]): void;
-    /**
-     * Emit update event for a single key (fast-path override point).
-     */
-    protected emitUpdateOne(key: TKey): void;
+    protected setSlotsWithComparison(key: TKey, newSlots: TOIMAnyEntitySlot<TPk>[]): boolean;
 }
 
 /**
@@ -392,14 +292,12 @@ interface IOIMKeyedSubscription<TKey extends TOIMPk> {
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
 }
 
-declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> implements IOIMKeyedSubscription<TKey> {
+declare abstract class OIMReactiveIndex<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndex<TKey, TPk, Iterable<TOIMAnyEntitySlot<TPk>>>> implements IOIMKeyedSubscription<TKey> {
     readonly index: TIndex;
     protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
     constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
-    getPksByKey(key: TKey): Set<TPk>;
-    getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
-    getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
-    getSlotsByKeys(keys: readonly TKey[]): Map<TKey, ReadonlySet<TOIMAnyEntitySlot<TPk>>>;
+    getEntitiesByKey<TEntity extends object = object>(key: TKey): TEntity[];
+    getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, TEntity[]>;
     hasKey(key: TKey): boolean;
     getKeys(): readonly TKey[];
     getKeySize(key: TKey): number;
@@ -427,39 +325,20 @@ declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends
     destroy(): void;
 }
 
-declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> implements IOIMKeyedSubscription<TKey> {
-    readonly index: TIndex;
-    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
+declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
+    getPksByKey(key: TKey): Set<TPk>;
+    getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
+    getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
+    getSlotsByKeys(keys: readonly TKey[]): Map<TKey, ReadonlySet<TOIMAnyEntitySlot<TPk>>>;
+}
+
+declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
     constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
     getPksByKey(key: TKey): TPk[];
     getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
     getSlotsByKey(key: TKey): readonly TOIMAnyEntitySlot<TPk>[];
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, readonly TOIMAnyEntitySlot<TPk>[]>;
-    hasKey(key: TKey): boolean;
-    getKeys(): readonly TKey[];
-    getKeySize(key: TKey): number;
-    get size(): number;
-    get isEmpty(): boolean;
-    getMetrics(): {
-        totalKeys: number;
-        totalPks: number;
-        averagePksPerKey: number;
-        maxBucketSize: number;
-        minBucketSize: number;
-    };
-    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
-    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
-    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
-    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
-    hasSubscriptions(): boolean;
-    getHandlerCount(key: TKey): number;
-    getSubscriptionMetrics(): {
-        totalKeys: number;
-        totalHandlers: number;
-        averageHandlersPerKey: number;
-        queueLength: number;
-    };
-    destroy(): void;
 }
 
 declare abstract class OIMObjectStore<TKey extends string | number | symbol, TValue> {
@@ -504,9 +383,9 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
-    upsertOneByPk(pk: TPk, entity: Partial<TEntity>): void;
-    upsertOne(entity: TEntity | Partial<TEntity>): void;
-    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    upsertOneByPk(pk: TPk, entity: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertOne(entity: TEntity | Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): TOIMEntitySlot<TEntity, TPk>[];
     removeOne(entity: TEntity): void;
     removeMany(entities: TEntity[]): void;
     removeOneByPk(pk: TPk): void;
@@ -515,8 +394,8 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     countAll(): number;
     getAll(): TEntity[];
     getAllPks(): TPk[];
-    protected upsertOneWithoutNotifications(entity: TEntity | Partial<TEntity>): TPk;
-    protected upsertOneWithoutNotificationsByPk(pk: TPk, entity: Partial<TEntity> | TEntity): void;
+    protected upsertOneWithoutNotifications(entity: TEntity | Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    protected upsertOneWithoutNotificationsByPk(pk: TPk, entity: Partial<TEntity> | TEntity): TOIMEntitySlot<TEntity, TPk>;
     destroy(): void;
 }
 
@@ -543,9 +422,9 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk>
         queueLength: number;
     };
     subscribeOnAnyUpdate(handler: (pks: readonly TPk[]) => void): () => void;
-    upsertOneByPk(pk: TPk, entity: Partial<TEntity>): void;
-    upsertOne(entity: TEntity | Partial<TEntity>): void;
-    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    upsertOneByPk(pk: TPk, entity: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertOne(entity: TEntity | Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): TOIMEntitySlot<TEntity, TPk>[];
     removeOne(entity: TEntity): void;
     removeMany(entities: TEntity[]): void;
     removeOneByPk(pk: TPk): void;
@@ -559,52 +438,256 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk>
     destroy(): void;
 }
 
-/**
- * Payload type for update events that contain keys */
-type TOIMUpdatePayload<TKey> = {
-    keys: readonly TKey[];
+type TOIMCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreSetBased<TKey, TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreArrayBased<TKey, TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMCollectionOrderedIndexOptions<TEntity extends object, TPk extends TOIMPk> = {
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+};
+type TOIMCollectionOrderedListCommandStreamOptions<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object> = {
+    index?: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMRelationsSetIndexOptions<TKey extends TOIMPk, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreSetBased<TKey, TPk>;
+    };
+};
+type TOIMRelationsArrayIndexOptions<TKey extends TOIMPk, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreArrayBased<TKey, TPk>;
+    };
+};
+type TOIMRelationsOrderedListOptions<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object> = {
+    index?: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
 };
+type TOIMDerivedIndexKeySelector<TEntity extends object, TKey extends TOIMPk> = (entity: TEntity) => TKey | readonly TKey[] | undefined | null;
+type TOIMDerivedCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+    selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>;
+    /**
+     * Build initial index state from existing collection slots.
+     * Defaults to true.
+     */
+    buildInitial?: boolean;
+    indexOptions?: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>['indexOptions'];
+};
+type TOIMRelationsDerivedSetIndexOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = Omit<TOIMDerivedCollectionIndexSetBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
+type TOIMDerivedEntityOrderValue = string | number | bigint | boolean;
+type TOIMDerivedEntityOrderSelector<TEntity extends object> = (entity: TEntity) => TOIMDerivedEntityOrderValue;
+type TOIMDerivedEntityComparator<TEntity extends object> = (a: TEntity, b: TEntity) => number;
+type TOIMDerivedCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+    selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>;
+    /**
+     * Build initial index state from existing collection slots.
+     * Defaults to true.
+     */
+    buildInitial?: boolean;
+    /**
+     * Sort entities inside each derived index key. Takes priority over orderBy.
+     */
+    compareEntities?: TOIMDerivedEntityComparator<TEntity>;
+    /**
+     * Convenience ordering selector for common ordered-list cases.
+     */
+    orderBy?: TOIMDerivedEntityOrderSelector<TEntity>;
+    indexOptions?: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>['indexOptions'];
+};
+type TOIMRelationsDerivedArrayIndexOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = Omit<TOIMDerivedCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
 
-type TOIMObjectOptions<TKey extends string, TValue> = {
-    store?: OIMObjectStore<TKey, TValue>;
+/**
+ * Manual ordered Array-based index.
+ *
+ * Unlike generic Array-based indexes, this class is explicitly ordered:
+ * - preserves order
+ * - allows O(1) append (`push`)
+ * - supports `move` and `removeAt` without computing diffs
+ * - stores slots directly; collection-bound variants resolve PKs before writes
+ *
+ * It emits UPDATE events per key on every successful mutation.
+ */
+declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TItemKey extends TOIMPk> extends OIMIndexArrayBased<TKey, TItemKey> {
+    clear(key?: TKey): void;
+    pushSlot(key: TKey, slot: TOIMAnyEntitySlot<TItemKey>): number;
+    insertSlotAt(key: TKey, index: number, slot: TOIMAnyEntitySlot<TItemKey>): number;
+    removeAt(key: TKey, index: number): TOIMAnyEntitySlot<TItemKey> | undefined;
+    move(key: TKey, fromIndex: number, toIndex: number): TOIMAnyEntitySlot<TItemKey> | undefined;
+    resetSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TItemKey>[]): void;
+    private getOrCreateList;
+}
+
+/**
+ * Collection-bound ordered Array-based index.
+ *
+ * Raw ordered indexes store slots. This variant provides PK writes and resolves
+ * them to canonical collection slots at construction-bound write time.
+ */
+declare class OIMCollectionIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMIndexManualOrderedArrayBased<TKey, TPk> {
+    private readonly resolveSlot;
+    constructor(opts: TOIMCollectionOrderedIndexOptions<TEntity, TPk>);
+    push(key: TKey, pk: TPk): number;
+    insertAt(key: TKey, index: number, pk: TPk): number;
+    reset(key: TKey, pks: readonly TPk[]): void;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
+    resolvePk(pk: TPk): TOIMAnyEntitySlot<TPk>;
+    private resolveSlots;
+    private resolveRequiredSlot;
+}
+
+type TOIMOrderedListCommand<TPk extends TOIMPk, TEntity extends object = object> = {
+    type: 'insert';
+    pk: TPk;
+    slot: TOIMEntitySlot<TEntity, TPk>;
+    index: number;
+} | {
+    type: 'remove';
+    pk: TPk;
+    slot: TOIMEntitySlot<TEntity, TPk>;
+    index: number;
+} | {
+    type: 'move';
+    pk: TPk;
+    slot: TOIMEntitySlot<TEntity, TPk>;
+    fromIndex: number;
+    toIndex: number;
+} | {
+    /**
+     * Replace the whole list for this key (preferred name).
+     */
+    type: 'set';
+    pks: readonly TPk[];
+    slots: readonly TOIMEntitySlot<TEntity, TPk>[];
 };
 
-/** It's like a store - but with event emitter */
-declare class OIMObject<TKey extends string, TValue> {
-    readonly emitter: OIMEventEmitter<{
-        0: TOIMUpdatePayload<TKey>;
-    }>;
-    protected readonly store: OIMObjectStore<TKey, TValue>;
-    constructor(opts?: TOIMObjectOptions<TKey, TValue>);
-    setProperty(key: TKey, value: TValue): void;
-    merge(draft: Partial<Record<TKey, TValue>>): void;
-    delete(key: TKey): void;
-    get(key: TKey): TValue | undefined;
-    getAll(): Record<TKey, TValue>;
-    clear(): void;
-    count(): number;
-    keys(): TKey[];
-    values(): TValue[];
-    entries(): [TKey, TValue][];
+/**
+ * Slot-first ordered-list command stream.
+ *
+ * Use this when you already have slots and want incremental commands for an
+ * imperative renderer. For PK writes bound to a collection, use
+ * `OIMCollectionOrderedListCommandStream`.
+ */
+declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> {
+    readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
+    private readonly unsubscribeAfterFlush;
+    private readonly unsubscribeFromIndexEmitter;
+    protected isInWrite: boolean;
+    private readonly commandsByKey;
+    /** Underlying slot-first ordered index. */
+    readonly index: OIMIndexManualOrderedArrayBased<TKey, TPk>;
+    constructor(queue: OIMEventQueue, index?: OIMIndexManualOrderedArrayBased<TKey, TPk>);
+    getPksByKey(key: TKey): readonly TPk[];
+    getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
+    getEntitiesByKey(key: TKey): TEntity[];
+    hasKey(key: TKey): boolean;
+    getKeys(): readonly TKey[];
+    pushSlot(key: TKey, slot: TOIMEntitySlot<TEntity, TPk>): void;
+    insertSlotAt(key: TKey, index: number, slot: TOIMEntitySlot<TEntity, TPk>): void;
+    removeAt(key: TKey, index: number): void;
+    move(key: TKey, fromIndex: number, toIndex: number): void;
+    setSlots(key: TKey, slots: readonly TOIMEntitySlot<TEntity, TPk>[]): void;
+    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TPk, TEntity>[];
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TPk, TEntity>[];
+    clear(key?: TKey): void;
     destroy(): void;
+    private readonly onAfterFlush;
+    private readonly onIndexUpdate;
+    protected withWrite(fn: () => void): void;
+    protected appendCommand(key: TKey, cmd: TOIMOrderedListCommand<TPk, TEntity>): void;
+    protected appendSetCommand(key: TKey, slots: readonly TOIMEntitySlot<TEntity, TPk>[]): void;
+    protected createSetCommand(slots: readonly TOIMEntitySlot<TEntity, TPk>[]): TOIMOrderedListCommand<TPk, TEntity>;
 }
 
-declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<TKey, TValue> implements IOIMKeyedSubscription<TKey> {
-    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
-    constructor(queue: OIMEventQueue, opts?: TOIMObjectOptions<TKey, TValue>);
-    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
-    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
-    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
-    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
-    hasSubscriptions(): boolean;
-    getHandlerCount(key: TKey): number;
-    getMetrics(): {
-        totalKeys: number;
-        totalHandlers: number;
-        averageHandlersPerKey: number;
-        queueLength: number;
-    };
-    destroy(): void;
+/**
+ * Collection-bound ordered-list command stream.
+ *
+ * Public writes use PKs, internally they resolve to canonical collection slots.
+ */
+declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMOrderedListCommandStream<TKey, TPk, TEntity> {
+    readonly index: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionOrderedListCommandStreamOptions<TKey, TPk, TEntity>);
+    push(key: TKey, pk: TPk): void;
+    insertAt(key: TKey, index: number, pk: TPk): void;
+    set(key: TKey, pks: readonly TPk[]): void;
+    getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
+    getEntitiesByKey(key: TKey): TEntity[];
+    private resolvePk;
+}
+
+/**
+ * Manual Array-based index that allows direct manipulation of key-to-primary-keys mappings.
+ * Extends the abstract OIMIndexArrayBased with manual control methods and optional comparison.
+ */
+declare class OIMIndexManualArrayBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexArrayBased<TIndexKey, TPk> {
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreArrayBased<TIndexKey, TPk>;
+    });
+    setSlots(key: TIndexKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
+    /**
+     * Clear all primary keys for a specific index key, or all keys if no key specified
+     */
+    clear(key?: TIndexKey): void;
+}
+
+declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexArrayBased<TKey, TPk, OIMIndexManualArrayBased<TKey, TPk>> {
+    constructor(queue: OIMEventQueue, opts?: {
+        indexOptions?: {
+            comparePks?: TOIMIndexComparator<TPk>;
+            store?: OIMIndexStoreArrayBased<TKey, TPk>;
+        };
+    });
+    setSlots(key: TKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
+    clear(key?: TKey): void;
+}
+
+/**
+ * Collection-bound reactive Array-based index.
+ *
+ * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
+ * through the collection binding supplied at construction time.
+ */
+declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualArrayBased<TKey, TPk> {
+    private readonly resolveSlot;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
+    setPks(key: TKey, pks: readonly TPk[]): void;
+    addPks(key: TKey, pks: readonly TPk[]): void;
+    removePks(key: TKey, pks: readonly TPk[]): void;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
+    private resolveSlots;
+    private resolveRequiredSlot;
 }
 
 /**
@@ -615,22 +698,8 @@ declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMP
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
-        resolveSlot?: TOIMEntitySlotResolver<TPk>;
     });
-    /**
-     * Set primary keys for a specific index key, replacing any existing values.
-     * Uses optional comparator to skip updates if PKs haven't actually changed.
-     */
-    setPks(key: TIndexKey, pks: TPk[]): void;
     setSlots(key: TIndexKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
-    /**
-     * Add primary keys to a specific index key
-     */
-    addPks(key: TIndexKey, pks: readonly TPk[]): void;
-    /**
-     * Remove primary keys from a specific index key
-     */
-    removePks(key: TIndexKey, pks: readonly TPk[]): void;
     /**
      * Clear all primary keys for a specific index key, or all keys if no key specified
      */
@@ -642,74 +711,146 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TO
         indexOptions?: {
             comparePks?: TOIMIndexComparator<TPk>;
             store?: OIMIndexStoreSetBased<TKey, TPk>;
-            resolveSlot?: TOIMEntitySlotResolver<TPk>;
         };
     });
-    setPks(key: TKey, pks: TPk[]): void;
     setSlots(key: TKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
+    clear(key?: TKey): void;
+}
+
+/**
+ * Collection-bound reactive Set-based index.
+ *
+ * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
+ * through the collection binding supplied at construction time.
+ */
+declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TKey, TPk> {
+    private readonly resolveSlot;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>);
+    setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
+    private resolveSlots;
+    private resolveRequiredSlot;
+}
+
+/**
+ * Collection-bound Set-based index derived from entity data.
+ *
+ * The collection remains the source of truth. This index listens to collection
+ * updates and maintains key membership automatically.
+ */
+declare class OIMDerivedCollectionIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity> {
+    private readonly collection;
+    private readonly selectIndexKeys;
+    private readonly unsubscribeFromCollection;
+    private readonly keysByPk;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts: TOIMDerivedCollectionIndexSetBasedOptions<TEntity, TKey, TPk>);
+    rebuildFromCollection(): void;
     clear(key?: TKey): void;
+    destroy(): void;
+    private readonly onCollectionUpdate;
+    private syncPk;
+    private normalizeKeys;
 }
 
 /**
- * Manual Array-based index that allows direct manipulation of key-to-primary-keys mappings.
- * Extends the abstract OIMIndexArrayBased with manual control methods and optional comparison.
+ * Collection-bound Array-based index derived from entity data.
+ *
+ * It maintains ordered per-key arrays automatically from collection updates.
+ * Use `orderBy` or `compareEntities` when list order matters.
  */
-declare class OIMIndexManualArrayBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexArrayBased<TIndexKey, TPk> {
-    constructor(options?: {
-        comparePks?: TOIMIndexComparator<TPk>;
-        store?: OIMIndexStoreArrayBased<TIndexKey, TPk>;
-        resolveSlot?: TOIMEntitySlotResolver<TPk>;
-    });
-    /**
-     * Set primary keys for a specific index key, replacing any existing values.
-     * Uses optional comparator to skip updates if PKs haven't actually changed.
-     */
-    setPks(key: TIndexKey, pks: TPk[]): void;
-    setSlots(key: TIndexKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
-    /**
-     * Add primary keys to a specific index key
-     */
-    addPks(key: TIndexKey, pks: readonly TPk[]): void;
-    /**
-     * Remove primary keys from a specific index key
-     */
-    removePks(key: TIndexKey, pks: readonly TPk[]): void;
-    /**
-     * Clear all primary keys for a specific index key, or all keys if no key specified
-     */
-    clear(key?: TIndexKey): void;
+declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity> {
+    private readonly collection;
+    private readonly selectIndexKeys;
+    private readonly compareEntities?;
+    private readonly orderBy?;
+    private readonly unsubscribeFromCollection;
+    private readonly keysByPk;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts: TOIMDerivedCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
+    rebuildFromCollection(): void;
+    clear(key?: TKey): void;
+    destroy(): void;
+    private readonly onCollectionUpdate;
+    private trackPkKeys;
+    private rebuildKey;
+    private sortSlots;
+    private normalizeKeys;
 }
 
-declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexArrayBased<TKey, TPk, OIMIndexManualArrayBased<TKey, TPk>> {
-    constructor(queue: OIMEventQueue, opts?: {
-        indexOptions?: {
-            comparePks?: TOIMIndexComparator<TPk>;
-            store?: OIMIndexStoreArrayBased<TKey, TPk>;
-            resolveSlot?: TOIMEntitySlotResolver<TPk>;
-        };
-    });
-    setPks(key: TKey, pks: TPk[]): void;
-    setSlots(key: TKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
-    addPks(key: TKey, pks: readonly TPk[]): void;
-    removePks(key: TKey, pks: readonly TPk[]): void;
-    clear(key?: TKey): void;
+/**
+ * Factory helper for collection-bound indexes.
+ *
+ * It does not store indexes inside the collection. It only keeps the common
+ * `queue + collection` binding in one place, so related structures can be
+ * created next to the collection with less generic noise.
+ */
+declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMPk> {
+    readonly queue: OIMEventQueue;
+    readonly collection: OIMReactiveCollection<TEntity, TPk>;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>);
+    setBasedIndex<TKey extends TOIMPk = string>(opts?: TOIMRelationsSetIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity>;
+    derivedSetIndex<TKey extends TOIMPk = string>(selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>, opts?: TOIMRelationsDerivedSetIndexOptions<TEntity, TKey, TPk>): OIMDerivedCollectionIndexSetBased<TKey, TPk, TEntity>;
+    arrayBasedIndex<TKey extends TOIMPk = string>(opts?: TOIMRelationsArrayIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity>;
+    derivedArrayIndex<TKey extends TOIMPk = string>(selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>, opts?: TOIMRelationsDerivedArrayIndexOptions<TEntity, TKey, TPk>): OIMDerivedCollectionIndexArrayBased<TKey, TPk, TEntity>;
+    orderedIndex<TKey extends TOIMPk = string>(): OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
+    orderedList<TKey extends TOIMPk = string>(opts?: TOIMRelationsOrderedListOptions<TKey, TPk, TEntity>): OIMCollectionOrderedListCommandStream<TKey, TPk, TEntity>;
 }
+declare function createOIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMPk>(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>): OIMCollectionIndexFactory<TEntity, TPk>;
 
-type TOIMReactiveIndex<TIndexKey extends TOIMPk, TPk extends TOIMPk> = OIMReactiveIndexSetBased<TIndexKey, TPk, any> | OIMReactiveIndexArrayBased<TIndexKey, TPk, any>;
-declare class OIMRICollection<TEntity extends object, TPk extends TOIMPk, TIndexName extends string = string, TIndexMap extends Record<TIndexName, TOIMReactiveIndex<any, TPk>> = Record<TIndexName, TOIMReactiveIndex<any, TPk>>> extends OIMReactiveCollection<TEntity, TPk> {
-    readonly indexes: TIndexMap;
-    constructor(queue: OIMEventQueue, opts: {
-        collectionOpts?: TOIMCollectionOptions<TEntity, TPk>;
-        indexes?: TIndexMap;
-    });
+/**
+ * Payload type for update events that contain keys */
+type TOIMUpdatePayload<TKey> = {
+    keys: readonly TKey[];
+};
+
+type TOIMObjectOptions<TKey extends string, TValue> = {
+    store?: OIMObjectStore<TKey, TValue>;
+};
+
+/** It's like a store - but with event emitter */
+declare class OIMObject<TKey extends string, TValue> {
+    readonly emitter: OIMEventEmitter<{
+        0: TOIMUpdatePayload<TKey>;
+    }>;
+    protected readonly store: OIMObjectStore<TKey, TValue>;
+    constructor(opts?: TOIMObjectOptions<TKey, TValue>);
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
+}
+
+declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<TKey, TValue> implements IOIMKeyedSubscription<TKey> {
+    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
+    constructor(queue: OIMEventQueue, opts?: TOIMObjectOptions<TKey, TValue>);
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(key: TKey): number;
+    getMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
+    destroy(): void;
 }
 
 declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TOIMPk> extends OIMCollectionStore<TEntity, TPk> {
     protected readonly slots: Map<TPk, TOIMEntitySlot<TEntity, TPk>>;
-    setOneByPk(pk: TPk, entity: TEntity): void;
-    setManyByPks(pks: readonly TPk[], entities: TEntity[]): void;
+    setOneByPk(pk: TPk, entity: TEntity): TOIMEntitySlot<TEntity, TPk>;
+    setManyByPks(pks: readonly TPk[], entities: TEntity[]): TOIMEntitySlot<TEntity, TPk>[];
     getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
@@ -841,16 +982,107 @@ declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMPk> {
     }, TPk>;
 }
 
+/**
+ * Computative runtime that schedules derived computations by levels and runs them
+ * on `queue.flush()` boundary (AFTER_FLUSH).
+ */
+declare class OIMComputeRuntime {
+    readonly queue: OIMEventQueue;
+    private isFlushScheduled;
+    private isFlushing;
+    private minLevel;
+    private maxLevel;
+    private readonly dirtyByLevel;
+    private readonly afterFlushTasks;
+    constructor(queue: OIMEventQueue);
+    /**
+     * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
+     * ordered by `level` ascending.
+     */
+    schedule(task: () => void, level?: number): () => void;
+    /**
+     * Run once at the start of the next runtime flush (i.e. after queue.flush()).
+     * Useful for resubscribing dependencies exactly once per source flush.
+     */
+    scheduleAfterFlush(task: () => void): () => void;
+    private flush;
+}
+
+interface IOIMSelectorComputedDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
+interface IOIMSelectorSourceDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare abstract class OIMSelector<TValue> {
+    protected readonly runtime: OIMComputeRuntime;
+    protected readonly sourceDeps: readonly IOIMSelectorSourceDependency[];
+    protected readonly computedDeps: readonly IOIMSelectorComputedDependency[];
+    private readonly listeners;
+    private sourceUnsubscribers;
+    private computedUnsubscribers;
+    private dequeueResubscribe?;
+    private isResubscribeEnqueued;
+    private isTemporarilyUnsubscribedForFlush;
+    private isDeliveryEnqueued;
+    private dequeueDelivery?;
+    private hasLastValue;
+    private lastValue;
+    protected get queue(): OIMEventQueue;
+    protected constructor(runtime: OIMComputeRuntime, sourceDeps: readonly IOIMSelectorSourceDependency[], computedDeps?: readonly IOIMSelectorComputedDependency[]);
+    abstract getValue(): TValue;
+    /**
+     * Start watching this selector. The callback is called immediately with the current value,
+     * then coalesced and delivered on `queue.flush()` when the selector invalidates.
+     */
+    watch(onValue: (value: TValue) => void): () => void;
+    protected areEqual(prev: TValue, next: TValue): boolean;
+    private readonly onSourceInvalidate;
+    private readonly onComputedInvalidate;
+    private readonly deliver;
+    private setLastValue;
+    private subscribeToDeps;
+    private unsubscribeFromSourceDeps;
+    private unsubscribeFromAllDeps;
+    private ensureResubscribeAfterFlush;
+    private readonly onAfterFlush;
+}
+
+type TOIMCollectionEntitySelector<TEntity extends object> = OIMSelector<TEntity | undefined>;
+type TOIMCollectionEntitiesSelector<TEntity extends object> = OIMSelector<readonly (TEntity | undefined)[]>;
+
+declare class OIMCollectionSelectors<TEntity extends object, TPk extends TOIMPk> {
+    private readonly collection;
+    readonly runtime: OIMComputeRuntime;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>);
+    byPk(pk: TPk): TOIMCollectionEntitySelector<TEntity>;
+    byPks(pks: readonly TPk[]): TOIMCollectionEntitiesSelector<TEntity>;
+    entitiesBySetIndexKey<TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(index: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
+    entitiesByArrayIndexKey<TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(index: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
+}
+
+type TOIMReactiveCollectionFactoryOptions<TEntity extends object, TPk extends TOIMPk> = TOIMCollectionOptions<TEntity, TPk>;
+type TOIMCollectionContext<TEntity extends object, TPk extends TOIMPk> = {
+    queue: OIMEventQueue;
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    indexFactory: OIMCollectionIndexFactory<TEntity, TPk>;
+    select: OIMCollectionSelectors<TEntity, TPk>;
+};
+
+declare function createOIMCollectionContext<TEntity extends object, TPk extends TOIMPk>(queue: OIMEventQueue, opts?: TOIMReactiveCollectionFactoryOptions<TEntity, TPk>): TOIMCollectionContext<TEntity, TPk>;
+
 type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
 /**
- * Wrapper around `OIMCollection` that tracks "changed fields" per entity PK.
+ * Tracks changed fields per entity PK for an `OIMCollection`.
  *
- * Important: to get field-level info, you must perform writes through this wrapper.
+ * Important: to get field-level info, perform writes through this object.
  *
- * DX: if the underlying collection is mutated directly (bypassing this wrapper), we detect it
- * via collection update events and infer changed fields by diffing the last observed entity snapshot.
+ * DX: if the underlying collection is mutated directly, we detect it via collection
+ * update events and infer changed fields by diffing the last observed entity snapshot.
  */
-declare class OIMCollectionChangedFieldsWrapper<TEntity extends object, TPk extends TOIMPk> {
+declare class OIMCollectionChangedFields<TEntity extends object, TPk extends TOIMPk> {
     readonly collection: OIMCollection<TEntity, TPk>;
     private readonly selectPk;
     private readonly unsubscribeAfterFlush;
@@ -876,9 +1108,9 @@ declare class OIMCollectionChangedFieldsWrapper<TEntity extends object, TPk exte
          */
         selectPk?: (entity: TEntity | Partial<TEntity>) => TPk;
     });
-    upsertOneByPk(pk: TPk, patch: Partial<TEntity>): void;
-    upsertOne(entity: TEntity | Partial<TEntity>): void;
-    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    upsertOneByPk(pk: TPk, patch: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertOne(entity: TEntity | Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): TOIMEntitySlot<TEntity, TPk>[];
     getChangedFieldsByPk(pk: TPk): ReadonlySet<TOIMFieldKey<TEntity>>;
     consumeChangedFieldsByPk(pk: TPk): Set<TOIMFieldKey<TEntity>>;
     getChangedPksByField(field: TOIMFieldKey<TEntity>): ReadonlySet<TPk>;
@@ -895,91 +1127,6 @@ declare class OIMCollectionChangedFieldsWrapper<TEntity extends object, TPk exte
     private trackPatch;
 }
 
-/**
- * Manual ordered Array-based index.
- *
- * Unlike `OIMIndexManualArrayBased.addPks/removePks`, this class is explicitly ordered:
- * - preserves order
- * - allows O(1) append (`push`)
- * - supports `move` and `removeAt` without computing diffs
- *
- * It emits UPDATE events per key on every successful mutation.
- */
-declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TItemKey extends TOIMPk> extends OIMIndexArrayBased<TKey, TItemKey> {
-    clear(key?: TKey): void;
-    push(key: TKey, itemKey: TItemKey): number;
-    insertAt(key: TKey, index: number, itemKey: TItemKey): void;
-    removeAt(key: TKey, index: number): TItemKey | undefined;
-    move(key: TKey, fromIndex: number, toIndex: number): TItemKey | undefined;
-    reset(key: TKey, itemKeys: readonly TItemKey[]): void;
-    private getOrCreateList;
-}
-
-type TOIMOrderedListCommand<TPk extends TOIMPk> = {
-    type: 'add';
-    key: TPk;
-    index: number;
-} | {
-    type: 'remove';
-    key: TPk;
-    index: number;
-} | {
-    type: 'move';
-    key: TPk;
-    fromIndex: number;
-    toIndex: number;
-} | {
-    /**
-     * Replace the whole list for this key (preferred name).
-     */
-    type: 'set';
-    keys: readonly TPk[];
-};
-
-/**
- * Ordered-list wrapper that stores arrays per key and emits a per-key command stream.
- *
- * This is designed for imperative renderers: instead of diffing the full list on each update,
- * you subscribe to `commandsEventEmitter` on a single list key and apply commands sequentially.
- *
- * Notes:
- * - Commands are buffered per key and delivered batched per queue flush.
- * - Order of commands is preserved.
- * - A future optimizer can collapse the command buffer into `set(...)` if needed.
- */
-declare class OIMOrderedListIndexCommandStreamWrapper<TKey extends TOIMPk, TItemKey extends TOIMPk> {
-    readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
-    private readonly unsubscribeAfterFlush;
-    private readonly unsubscribeFromIndexEmitter;
-    private isInWrite;
-    private readonly commandsByKey;
-    /** Underlying ordered index (source of truth for the list). */
-    readonly index: OIMIndexManualOrderedArrayBased<TKey, TItemKey>;
-    constructor(queue: OIMEventQueue, index?: OIMIndexManualOrderedArrayBased<TKey, TItemKey>);
-    getPksByKey(key: TKey): readonly TItemKey[];
-    hasKey(key: TKey): boolean;
-    getKeys(): readonly TKey[];
-    push(key: TKey, itemKey: TItemKey): void;
-    removeAt(key: TKey, index: number): void;
-    move(key: TKey, fromIndex: number, toIndex: number): void;
-    set(key: TKey, keys: readonly TItemKey[]): void;
-    /**
-     * Read-only peek at buffered commands without clearing them.
-     */
-    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TItemKey>[];
-    /**
-     * Drain buffered commands for a key, preserving order.
-     * Intended usage: call inside a `commandsEventEmitter.subscribeOnKey(key, ...)` handler.
-     */
-    consumeCommands(key: TKey): TOIMOrderedListCommand<TItemKey>[];
-    clear(key?: TKey): void;
-    destroy(): void;
-    private readonly onAfterFlush;
-    private readonly onIndexUpdate;
-    private withWrite;
-    private appendCommand;
-}
-
 /**
  * Animation frame-based scheduler that executes flushes synchronized with the browser's repaint cycle.
  * Ideal for UI-related updates that need to be synchronized with rendering.
@@ -1034,13 +1181,14 @@ declare class OIMEventQueueSchedulerTimeout extends OIMEventQueueScheduler {
     cancel(): void;
 }
 
+type TOIMImmediateSchedulerHandle = ReturnType<typeof setImmediate> | ReturnType<typeof setTimeout> | 1;
 /**
  * Immediate-based scheduler that executes flushes using setImmediate or fallback mechanisms.
  * Provides faster execution than setTimeout(0) in Node.js environments.
  * Falls back to setTimeout(0) in browsers and MessageChannel in modern browsers for better performance.
  */
 declare class OIMEventQueueSchedulerImmediate extends OIMEventQueueScheduler {
-    protected immediateId?: number;
+    protected immediateId?: TOIMImmediateSchedulerHandle;
     protected readonly useSetImmediate: boolean;
     protected readonly useMessageChannel: boolean;
     protected messageChannel?: MessageChannel;
@@ -1096,19 +1244,13 @@ type TOIMIndexKey = string | number | bigint;
 type TOIMIndexOptionsSetBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> = {
     comparePks?: TOIMIndexComparator<TPk>;
     store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
-    resolveSlot?: TOIMEntitySlotResolver<TPk>;
 };
 /**
  * Configuration options for Array-based index instances */
 type TOIMIndexOptionsArrayBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> = {
     comparePks?: TOIMIndexComparator<TPk>;
     store?: OIMIndexStoreArrayBased<TIndexKey, TPk>;
-    resolveSlot?: TOIMEntitySlotResolver<TPk>;
 };
-/**
- * @deprecated Use TOIMIndexOptionsSetBased or TOIMIndexOptionsArrayBased instead
- * Configuration options for index instances */
-type TOIMIndexOptions<TIndexKey extends TOIMPk, TPk extends TOIMPk> = TOIMIndexOptionsSetBased<TIndexKey, TPk>;
 
 type TOIMIndexPksUpdatePayload<TKey extends TOIMPk, TPk extends TOIMPk> = {
     key: TKey;
@@ -1142,32 +1284,6 @@ type TOIMComputedUpdatePayload<TKey extends TOIMPk> = {
     keys: readonly TKey[];
 };
 
-/**
- * Computative runtime that schedules derived computations by levels and runs them
- * on `queue.flush()` boundary (AFTER_FLUSH).
- */
-declare class OIMComputativeRuntime {
-    readonly queue: OIMEventQueue;
-    private isFlushScheduled;
-    private isFlushing;
-    private minLevel;
-    private maxLevel;
-    private readonly dirtyByLevel;
-    private readonly afterFlushTasks;
-    constructor(queue: OIMEventQueue);
-    /**
-     * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
-     * ordered by `level` ascending.
-     */
-    schedule(task: () => void, level?: number): () => void;
-    /**
-     * Run once at the start of the next runtime flush (i.e. after queue.flush()).
-     * Useful for resubscribing dependencies exactly once per source flush.
-     */
-    scheduleAfterFlush(task: () => void): () => void;
-    private flush;
-}
-
 type TOIMComputedKey$2 = 'value';
 declare class OIMComputed<TValue> {
     readonly emitter: OIMEventEmitter<{
@@ -1177,12 +1293,15 @@ declare class OIMComputed<TValue> {
     private readonly runtime;
     private readonly compute;
     private readonly compare;
-    private readonly deps;
+    private readonly _deps;
     private value;
     private hasValue;
     private isDirty;
     private readonly effect;
-    constructor(runtime: OIMComputativeRuntime, opts: TOIMComputedOptions<TValue>);
+    constructor(runtime: OIMComputeRuntime, opts: TOIMComputedOptions<TValue>);
+    get needsRecompute(): boolean;
+    get isReady(): boolean;
+    get deps(): readonly IOIMEffectDependency[];
     get(): TValue;
     getIfReady(): TValue | undefined;
     destroy(): void;
@@ -1221,7 +1340,7 @@ declare class OIMEffect {
     private isScheduled;
     private dequeueScheduled?;
     private readonly runTask;
-    constructor(runtime: OIMComputativeRuntime, opts: TOIMEffectOptions);
+    constructor(runtime: OIMComputeRuntime, opts: TOIMEffectOptions);
     destroy(): void;
     private onSourceInvalidate;
     private onComputedInvalidate;
@@ -1234,10 +1353,10 @@ declare class OIMEffect {
 }
 
 declare class OIMEffectDependencyKeyed<TKey extends TOIMPk> implements IOIMEffectDependency {
-    private readonly subscription;
+    readonly source: IOIMKeyedSubscription<TKey>;
     private readonly key;
     private readonly keys;
-    constructor(subscription: IOIMKeyedSubscription<TKey>, keyOrKeys: TKey | readonly TKey[]);
+    constructor(source: IOIMKeyedSubscription<TKey>, keyOrKeys: TKey | readonly TKey[]);
     subscribe(onUpdate: () => void): () => void;
 }
 
@@ -1245,6 +1364,7 @@ declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implem
     private readonly dep;
     constructor(object: OIMReactiveObject<TKey, TValue>, key: TKey);
     constructor(object: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
+    get source(): OIMReactiveObject<TKey, TValue>;
     subscribe(onUpdate: () => void): () => void;
 }
 
@@ -1252,6 +1372,7 @@ declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk ext
     private readonly dep;
     constructor(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
     constructor(collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
+    get source(): OIMReactiveCollection<TEntity, TPk>;
     subscribe(onUpdate: () => void): () => void;
 }
 
@@ -1259,6 +1380,7 @@ declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMPk> implements IOIM
     private readonly dep;
     constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
     constructor(index: IOIMKeyedSubscription<TKey>, keys: readonly TKey[]);
+    get source(): IOIMKeyedSubscription<TKey>;
     subscribe(onUpdate: () => void): () => void;
 }
 
@@ -1273,64 +1395,22 @@ type TOIMComputedLike = {
  * Effect dependency on a computed.
  */
 declare class OIMEffectDependencyComputed implements IOIMEffectDependency {
-    private readonly computed;
-    constructor(computed: TOIMComputedLike);
-    subscribe(onUpdate: () => void): () => void;
-}
-
-interface IOIMSelectorComputedDependency {
-    subscribe(onUpdate: () => void): () => void;
-}
-
-interface IOIMSelectorSourceDependency {
+    readonly source: TOIMComputedLike;
+    constructor(source: TOIMComputedLike);
     subscribe(onUpdate: () => void): () => void;
 }
 
-declare abstract class OIMSelector<TValue> {
-    protected readonly runtime: OIMComputativeRuntime;
-    protected readonly sourceDeps: readonly IOIMSelectorSourceDependency[];
-    protected readonly computedDeps: readonly IOIMSelectorComputedDependency[];
-    private readonly listeners;
-    private sourceUnsubscribers;
-    private computedUnsubscribers;
-    private dequeueResubscribe?;
-    private isResubscribeEnqueued;
-    private isTemporarilyUnsubscribedForFlush;
-    private isDeliveryEnqueued;
-    private dequeueDelivery?;
-    private hasLastValue;
-    private lastValue;
-    protected get queue(): OIMEventQueue;
-    protected constructor(runtime: OIMComputativeRuntime, sourceDeps: readonly IOIMSelectorSourceDependency[], computedDeps?: readonly IOIMSelectorComputedDependency[]);
-    abstract getValue(): TValue;
-    /**
-     * Start watching this selector. The callback is called immediately with the current value,
-     * then coalesced and delivered on `queue.flush()` when the selector invalidates.
-     */
-    watch(onValue: (value: TValue) => void): () => void;
-    protected areEqual(prev: TValue, next: TValue): boolean;
-    private readonly onSourceInvalidate;
-    private readonly onComputedInvalidate;
-    private readonly deliver;
-    private setLastValue;
-    private subscribeToDeps;
-    private unsubscribeFromSourceDeps;
-    private unsubscribeFromAllDeps;
-    private ensureResubscribeAfterFlush;
-    private readonly onAfterFlush;
-}
-
 declare class OIMCollectionByPkSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<TEntity | undefined> {
     private readonly collection;
     private readonly pk;
-    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
     getValue(): TEntity | undefined;
 }
 
 declare class OIMCollectionByPksSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<readonly (TEntity | undefined)[]> {
     private readonly collection;
     private readonly pks;
-    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
     getValue(): readonly (TEntity | undefined)[];
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
@@ -1338,14 +1418,14 @@ declare class OIMCollectionByPksSelector<TEntity extends object, TPk extends TOI
 declare class OIMObjectValueByKeySelector<TKey extends string, TValue> extends OIMSelector<TValue | undefined> {
     private readonly obj;
     private readonly key;
-    constructor(runtime: OIMComputativeRuntime, obj: OIMReactiveObject<TKey, TValue>, key: TKey);
+    constructor(runtime: OIMComputeRuntime, obj: OIMReactiveObject<TKey, TValue>, key: TKey);
     getValue(): TValue | undefined;
 }
 
 declare class OIMObjectValuesByKeysSelector<TKey extends string, TValue> extends OIMSelector<readonly (TValue | undefined)[]> {
     private readonly obj;
     private readonly keys;
-    constructor(runtime: OIMComputativeRuntime, obj: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
+    constructor(runtime: OIMComputeRuntime, obj: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
     getValue(): readonly (TValue | undefined)[];
     protected areEqual(prev: readonly (TValue | undefined)[], next: readonly (TValue | undefined)[]): boolean;
 }
@@ -1353,14 +1433,14 @@ declare class OIMObjectValuesByKeysSelector<TKey extends string, TValue> extends
 declare class OIMIndexPksByKeySetBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<Set<TPk>> {
     private readonly reactiveIndex;
     private readonly key;
-    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
+    constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
     getValue(): Set<TPk>;
 }
 
 declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly key;
-    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
+    constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
     getValue(): readonly TPk[];
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
@@ -1368,7 +1448,7 @@ declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMPk, TPk extend
 declare class OIMIndexPksByKeysSetBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly keys;
-    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
+    constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
     getValue(): readonly TPk[];
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
@@ -1376,7 +1456,7 @@ declare class OIMIndexPksByKeysSetBasedSelector<TKey extends TOIMPk, TPk extends
 declare class OIMIndexPksByKeysArrayBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly keys;
-    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
+    constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
     getValue(): readonly TPk[];
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
@@ -1385,7 +1465,7 @@ declare class OIMEntitiesByIndexKeySetBasedSelector<TEntity extends object, TPk
     private readonly collection;
     private readonly reactiveIndex;
     private readonly key;
-    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
     getValue(): readonly (TEntity | undefined)[];
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
@@ -1394,9 +1474,9 @@ declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TP
     private readonly collection;
     private readonly reactiveIndex;
     private readonly key;
-    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
     getValue(): readonly (TEntity | undefined)[];
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFieldsWrapper, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputativeRuntime, OIMComputed, OIMDBSettings, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListIndexCommandStreamWrapper, OIMPkSelectorFactory, OIMRICollection, OIMReactiveCollection, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMAnyEntitySlot, type TOIMCollectionOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotResolver, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptions, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload };
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMIndexStore, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandStream, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMAnyEntitySlot, type TOIMCollectionContext, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionIndexArrayBasedOptions, type TOIMDerivedCollectionIndexSetBasedOptions, type TOIMDerivedEntityComparator, type TOIMDerivedEntityOrderSelector, type TOIMDerivedEntityOrderValue, type TOIMDerivedIndexKeySelector, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotResolver, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createOIMCollectionContext, createOIMCollectionIndexFactory };