@oimdb/core 3.4.0 → 3.6.0

package/dist/index.d.ts

@@ -357,6 +357,127 @@ declare abstract class OIMObjectStore<TKey extends string | number | symbol, TVa
     abstract destroy(): void;
 }
 
+/**
+ * Keyless base index: a single bucket of entity slots over the whole collection
+ * ("all"), with no key dimension. Mirrors {@link OIMIndex} but holds ONE bucket
+ * directly instead of a `Map<key, bucket>`, so there is no key parameter
+ * anywhere on its surface. Concrete shape (ordered array vs unordered set) is
+ * added by {@link OIMGlobalIndexArrayBased} / {@link OIMGlobalIndexSetBased}.
+ */
+declare abstract class OIMGlobalIndex<TPk extends TOIMPk> {
+    protected readonly comparePks?: TOIMIndexComparator<TPk>;
+    readonly emitter: OIMEventEmitter<{
+        0: void;
+    }>;
+    constructor(comparePks?: TOIMIndexComparator<TPk>);
+    protected abstract iterateSlots(): Iterable<TOIMAnyEntitySlot<TPk>>;
+    protected abstract clearBucket(): void;
+    abstract get size(): number;
+    get isEmpty(): boolean;
+    /**
+     * Materializes the bucket to entities, preserving positional holes: a slot
+     * whose entity is not present yet (or was removed) yields `undefined` at its
+     * position rather than being dropped — mirroring {@link OIMIndex}.
+     */
+    getEntities<TEntity extends object = object>(): (TEntity | undefined)[];
+    getMetrics(): {
+        totalPks: number;
+    };
+    destroy(): void;
+    protected emitUpdate(): void;
+}
+
+/**
+ * Set-based (unordered, deduped) keyless index. Holds a single `Set<slot>`
+ * bucket over the whole collection. Mirrors {@link OIMIndexSetBased} minus the
+ * key.
+ */
+declare abstract class OIMGlobalIndexSetBased<TPk extends TOIMPk> extends OIMGlobalIndex<TPk> {
+    protected slots: Set<TOIMAnyEntitySlot<TPk>>;
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    });
+    get size(): number;
+    protected iterateSlots(): Iterable<TOIMAnyEntitySlot<TPk>>;
+    protected clearBucket(): void;
+    getPks(): Set<TPk>;
+    getSlots(): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
+    protected slotsToPks(slots: Iterable<TOIMAnyEntitySlot<TPk>>): Set<TPk>;
+    protected setSlotsWithComparison(newSlots: Set<TOIMAnyEntitySlot<TPk>>): boolean;
+}
+
+/**
+ * Array-based (ordered) keyless index. Holds a single `slot[]` bucket over the
+ * whole collection. Mirrors {@link OIMIndexArrayBased} minus the key.
+ */
+declare abstract class OIMGlobalIndexArrayBased<TPk extends TOIMPk> extends OIMGlobalIndex<TPk> {
+    protected slots: TOIMAnyEntitySlot<TPk>[];
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    });
+    get size(): number;
+    protected iterateSlots(): Iterable<TOIMAnyEntitySlot<TPk>>;
+    protected clearBucket(): void;
+    getPks(): TPk[];
+    getSlots(): readonly TOIMAnyEntitySlot<TPk>[];
+    protected slotsToPks(slots: readonly TOIMAnyEntitySlot<TPk>[]): TPk[];
+    protected setSlotsWithComparison(newSlots: TOIMAnyEntitySlot<TPk>[]): boolean;
+}
+
+/**
+ * Keyless subscription surface — the counterpart of {@link IOIMKeyedSubscription}
+ * for a single (whole-collection) reactive node. A subscriber is notified on
+ * `queue.flush()` whenever the node's one bucket changes; there is no key.
+ */
+interface IOIMSubscription {
+    subscribe(handler: TOIMEventHandler<void>): () => void;
+}
+
+/**
+ * The keyless pub/sub surface a reactive Global node needs from its update
+ * emitter: subscribe + a batched "mark updated" delivery. The counterpart of
+ * {@link IOIMKeyedUpdateEmitter}, but for exactly one carrier — so there is no
+ * key parameter, no resolver, and no per-key map.
+ */
+interface IOIMSingleUpdateEmitter extends IOIMSubscription {
+    markUpdated(): void;
+    hasSubscriptions(): boolean;
+    destroy(): void;
+}
+
+/**
+ * Reactive wrapper around a keyless {@link OIMGlobalIndex}. Owns a single-carrier
+ * emitter (no resolver, no key→carrier map), so `subscribe(handler)` is keyless
+ * and directly satisfies `IOIMSelectorSourceDependency`. Mirrors
+ * {@link OIMReactiveIndex} minus the key.
+ */
+declare abstract class OIMReactiveGlobalIndex<TPk extends TOIMPk, TIndex extends OIMGlobalIndex<TPk>> implements IOIMSubscription {
+    readonly index: TIndex;
+    protected readonly updateEmitter: IOIMSingleUpdateEmitter;
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMSingleUpdateEmitter) => TIndex);
+    getEntities<TEntity extends object = object>(): (TEntity | undefined)[];
+    get size(): number;
+    get isEmpty(): boolean;
+    subscribe(handler: TOIMEventHandler<void>): () => void;
+    hasSubscriptions(): boolean;
+    getMetrics(): {
+        totalPks: number;
+    };
+    destroy(): void;
+}
+
+declare abstract class OIMReactiveGlobalIndexSetBased<TPk extends TOIMPk, TIndex extends OIMGlobalIndexSetBased<TPk>> extends OIMReactiveGlobalIndex<TPk, TIndex> {
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMSingleUpdateEmitter) => TIndex);
+    getPks(): Set<TPk>;
+    getSlots(): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
+}
+
+declare abstract class OIMReactiveGlobalIndexArrayBased<TPk extends TOIMPk, TIndex extends OIMGlobalIndexArrayBased<TPk>> extends OIMReactiveGlobalIndex<TPk, TIndex> {
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMSingleUpdateEmitter) => TIndex);
+    getPks(): TPk[];
+    getSlots(): readonly TOIMAnyEntitySlot<TPk>[];
+}
+
 type TOIMPkSelector<TEntity extends object, TPk extends TOIMPk> = (entity: TEntity) => TPk;
 
 type TOIMEntityUpdater<TEntity extends object> = (draft: Partial<TEntity>, prevEntity: TEntity) => TEntity;
@@ -620,28 +741,30 @@ type TOIMRelationsDerivedArrayIndexOptions<TEntity extends object, TKey extends
  * - 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.
+ * It emits UPDATE events per key on every successful mutation. It is a plain
+ * data structure: it knows nothing about "commands" — turning its mutations
+ * into position-addressed commands is the command stream's job.
  */
-declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TItemKey extends TOIMPk> extends OIMIndexArrayBased<TKey, TItemKey> {
+declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexArrayBased<TKey, TPk> {
     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;
+    pushSlot(key: TKey, slot: TOIMAnyEntitySlot<TPk>): number;
+    insertSlotAt(key: TKey, index: number, slot: TOIMAnyEntitySlot<TPk>): number;
+    removeAt(key: TKey, index: number): TOIMAnyEntitySlot<TPk> | undefined;
     /**
      * Remove up to `count` consecutive slots starting at `index`.
      * Returns the number actually removed (clamped to bounds; 0 if nothing).
      */
     removeRange(key: TKey, index: number, count: number): number;
-    move(key: TKey, fromIndex: number, toIndex: number): TOIMAnyEntitySlot<TItemKey> | undefined;
+    move(key: TKey, fromIndex: number, toIndex: number): TOIMAnyEntitySlot<TPk> | undefined;
     /** Replace the slot at `index` in place. Returns the safe index, or -1. */
-    setSlotAt(key: TKey, index: number, slot: TOIMAnyEntitySlot<TItemKey>): number;
+    setSlotAt(key: TKey, index: number, slot: TOIMAnyEntitySlot<TPk>): number;
     /**
      * Move up to `count` consecutive slots from `from` to `to`. `to` is in the
      * coordinate space *after* the block is extracted (same as single `move`).
      * Returns the number actually moved (0 if a no-op / out of bounds).
      */
     moveRange(key: TKey, from: number, to: number, count: number): number;
-    resetSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TItemKey>[]): void;
+    resetSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     private getOrCreateList;
 }
 
@@ -760,24 +883,86 @@ type TOIMOrderedListCommand<TItem> = {
 };
 
 /**
- * Slot-first ordered-list command stream.
+ * Read/consume side of an ordered-list command stream, generic over the element
+ * type it carries.
+ *
+ * The concrete stream stores entity slots (`TItem = TOIMEntitySlot<...>`); a
+ * mapped source ({@link OIMOrderedListMappedCommandStream}) carries whatever the
+ * mapping produces. A consumer that depends on this interface works unchanged
+ * against either — raw or mapped.
  *
- * Emits position-addressed {@link TOIMOrderedListCommand}s whose `item` is the
- * entity slot. Use this when you already have slots and want incremental
- * commands for an imperative renderer. For PK writes bound to a collection, use
- * `OIMCollectionOrderedListCommandStream`.
+ * Consumption is pull-based and synchronous: the notification carries no
+ * payload, so `consumeCommands(key)` must be called inside the `handler`, before
+ * the buffer for that key is cleared.
  */
-declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> {
+interface IOIMOrderedListCommandSource<TKey extends TOIMPk, TItem> {
+    /**
+     * Subscribe to per-key command notifications. The handler receives no
+     * payload — pull the commands with {@link consumeCommands} synchronously.
+     * Returns an unsubscribe function.
+     */
+    subscribeCommands(key: TKey, handler: () => void): () => void;
+    /** Drain the commands buffered for `key` this delivery (a copy). */
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TItem>[];
+    /** Current ordered items for `key` — the initial state before any command. */
+    getItemsByKey(key: TKey): readonly TItem[];
+}
+
+/**
+ * Abstract base for position-addressed ordered-list command streams.
+ *
+ * Holds the machinery that is independent of what *produces* the commands:
+ * per-key command buffering with reset-coalescing, `after_flush` delivery via
+ * {@link commandsEventEmitter}, and the pull-based consume/subscribe surface
+ * ({@link IOIMOrderedListCommandSource}). The driver lives in the subclass:
+ * `OIMOrderedListCommandStream` appends commands from imperative writers;
+ * `OIMOrderedListCommandStreamDiffDriven` appends them by diffing a reactive
+ * index.
+ *
+ * {@link getItemsByKey} is abstract — each driver reads the current order from
+ * its own backing (a manual ordered index, or an external reactive index). It is
+ * consulted only on the cold reset-coalescing path, so it stays off the hot
+ * append path.
+ */
+declare abstract class OIMOrderedListCommandBuffer<TKey extends TOIMPk, TItem> implements IOIMOrderedListCommandSource<TKey, TItem> {
     readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
     private readonly unsubscribeAfterFlush;
-    private readonly unsubscribeFromIndexEmitter;
-    protected isInWrite: boolean;
-    private readonly commandsByKey;
+    protected readonly commandsByKey: Map<TKey, TOIMOrderedListCommand<TItem>[]>;
+    constructor(queue: OIMEventQueue);
+    /** Current ordered items for `key` (the driver's backing order). */
+    abstract getItemsByKey(key: TKey): readonly TItem[];
+    subscribeCommands(key: TKey, handler: () => void): () => void;
+    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TItem>[];
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TItem>[];
+    destroy(): void;
+    private readonly onAfterFlush;
+    protected appendCommand(key: TKey, cmd: TOIMOrderedListCommand<TItem>): void;
+    protected appendResetCommand(key: TKey, items: readonly TItem[]): void;
+    protected createResetCommand(items: readonly TItem[]): TOIMOrderedListCommand<TItem>;
+}
+
+/**
+ * Slot-first ordered-list command stream.
+ *
+ * Emits position-addressed commands whose `item` is the entity slot, driven by
+ * its own writer methods (`pushSlot`, `move`, `removeAt`, …) — each mutates the
+ * backing ordered index and records the matching command. Write through the
+ * stream (not the index directly) to have your edits recorded. For PK writes
+ * bound to a collection, use `OIMCollectionOrderedListCommandStream`; to derive
+ * commands from an existing reactive index instead of writing them, use
+ * `OIMOrderedListCommandStreamDiffDriven`.
+ *
+ * Command buffering, `after_flush` delivery and the consume/subscribe surface
+ * come from {@link OIMOrderedListCommandBuffer}.
+ */
+declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMOrderedListCommandBuffer<TKey, TOIMEntitySlot<TEntity, TPk>> {
     /** 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>[];
+    /** {@link OIMOrderedListCommandBuffer.getItemsByKey} — the slots in order. */
+    getItemsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
     getEntitiesByKey(key: TKey): (TEntity | undefined)[];
     hasKey(key: TKey): boolean;
     getKeys(): readonly TKey[];
@@ -795,22 +980,15 @@ declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMP
      */
     moveRange(key: TKey, from: number, to: number, count: number): void;
     setSlots(key: TKey, slots: readonly TOIMEntitySlot<TEntity, TPk>[]): void;
-    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TOIMEntitySlot<TEntity, TPk>>[];
-    consumeCommands(key: TKey): TOIMOrderedListCommand<TOIMEntitySlot<TEntity, TPk>>[];
     clear(key?: TKey): void;
     destroy(): void;
-    private readonly onAfterFlush;
-    private readonly onIndexUpdate;
-    protected withWrite(fn: () => void): void;
-    protected appendCommand(key: TKey, cmd: TOIMOrderedListCommand<TOIMEntitySlot<TEntity, TPk>>): void;
-    protected appendResetCommand(key: TKey, slots: readonly TOIMEntitySlot<TEntity, TPk>[]): void;
-    protected createResetCommand(slots: readonly TOIMEntitySlot<TEntity, TPk>[]): TOIMOrderedListCommand<TOIMEntitySlot<TEntity, TPk>>;
 }
 
 /**
  * Collection-bound ordered-list command stream.
  *
- * Public writes use PKs, internally they resolve to canonical collection slots.
+ * Public writes use PKs; they resolve to canonical collection slots (throwing on
+ * an unresolvable pk) before mutating the index and recording the command.
  */
 declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMOrderedListCommandStream<TKey, TPk, TEntity> {
     readonly index: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
@@ -989,6 +1167,220 @@ declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMPk, TPk exten
     private normalizeKeys;
 }
 
+/**
+ * Manual array-based keyless index — direct raw-slot control of the single
+ * ordered bucket. Mirrors {@link OIMIndexManualArrayBased} minus the key.
+ */
+declare class OIMGlobalIndexManualArrayBased<TPk extends TOIMPk> extends OIMGlobalIndexArrayBased<TPk> {
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    });
+    setSlots(slots: TOIMAnyEntitySlot<TPk>[]): void;
+    /**
+     * Appends pre-deduplicated slots to the bucket IN PLACE and emits once.
+     * O(added). Callers own dedup (used by collection-bound `addPks`).
+     */
+    appendSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    clear(): void;
+}
+
+/**
+ * Reactive manual array-based keyless index — raw-slot writes bridged to a
+ * single-carrier emitter. Mirrors {@link OIMReactiveIndexManualArrayBased}.
+ */
+declare class OIMReactiveGlobalIndexManualArrayBased<TPk extends TOIMPk> extends OIMReactiveGlobalIndexArrayBased<TPk, OIMGlobalIndexManualArrayBased<TPk>> {
+    constructor(queue: OIMEventQueue, opts?: {
+        indexOptions?: {
+            comparePks?: TOIMIndexComparator<TPk>;
+        };
+    });
+    setSlots(slots: TOIMAnyEntitySlot<TPk>[]): void;
+    appendSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    clear(): void;
+}
+
+/**
+ * Predicate deciding whether an entity belongs to a derived Global index.
+ * Defaults to "the entity exists" (`item !== undefined`) when omitted.
+ */
+type TOIMGlobalIndexFilter<TEntity extends object> = (entity: TEntity) => boolean;
+type TOIMCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+    /** Build initial state from existing collection slots. Defaults to true. */
+    buildInitial?: boolean;
+    /** Sort the list. Takes priority over `orderBy`. */
+    compareEntities?: TOIMDerivedEntityComparator<TEntity>;
+    /** Convenience ordering selector for common ordered-list cases. */
+    orderBy?: TOIMDerivedEntityOrderSelector<TEntity>;
+    /** Include predicate. Defaults to "entity exists". */
+    filter?: TOIMGlobalIndexFilter<TEntity>;
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+};
+type TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+    /** Build initial state from existing collection slots. Defaults to true. */
+    buildInitial?: boolean;
+    /** Include predicate. Defaults to "entity exists". */
+    filter?: TOIMGlobalIndexFilter<TEntity>;
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+};
+type TOIMRelationsGlobalArrayIndexOptions<TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+};
+type TOIMRelationsGlobalSetIndexOptions<TPk extends TOIMPk> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    };
+};
+type TOIMRelationsDerivedGlobalArrayIndexOptions<TEntity extends object, TPk extends TOIMPk> = TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity, TPk>;
+type TOIMRelationsDerivedGlobalSetIndexOptions<TEntity extends object, TPk extends TOIMPk> = TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity, TPk>;
+
+/**
+ * Collection-bound reactive array-based keyless index.
+ *
+ * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
+ * through the collection binding. A single `membership` set gives O(1) `addPks`
+ * dedup. Mirrors {@link OIMReactiveCollectionIndexManualArrayBased} minus the
+ * key (one bucket instead of a per-key map).
+ */
+declare class OIMReactiveCollectionGlobalIndexManualArrayBased<TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveGlobalIndexManualArrayBased<TPk> {
+    private readonly resolveSlot;
+    private readonly membership;
+    private membershipSeeded;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionGlobalIndexArrayBasedOptions<TEntity, TPk>);
+    setPks(pks: readonly TPk[]): void;
+    addPks(pks: readonly TPk[]): void;
+    removePks(pks: readonly TPk[]): void;
+    clear(): void;
+    private membershipOf;
+    getEntities<TItem extends object = TEntity>(): (TItem | undefined)[];
+    private resolveSlots;
+    private resolveRequiredSlot;
+}
+
+/**
+ * Manual set-based keyless index — direct raw-slot control of the single
+ * unordered bucket. Mirrors {@link OIMIndexManualSetBased} minus the key.
+ */
+declare class OIMGlobalIndexManualSetBased<TPk extends TOIMPk> extends OIMGlobalIndexSetBased<TPk> {
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+    });
+    setSlots(slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
+    /** Adds slots IN PLACE (O(added)) and emits once if anything changed. */
+    addSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    /** Removes slots IN PLACE (O(removed)) and emits once if anything changed. */
+    removeSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    clear(): void;
+}
+
+/**
+ * Reactive manual set-based keyless index — raw-slot writes bridged to a
+ * single-carrier emitter. Mirrors {@link OIMReactiveIndexManualSetBased}.
+ */
+declare class OIMReactiveGlobalIndexManualSetBased<TPk extends TOIMPk> extends OIMReactiveGlobalIndexSetBased<TPk, OIMGlobalIndexManualSetBased<TPk>> {
+    constructor(queue: OIMEventQueue, opts?: {
+        indexOptions?: {
+            comparePks?: TOIMIndexComparator<TPk>;
+        };
+    });
+    setSlots(slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
+    addSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    removeSlots(slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    clear(): void;
+}
+
+/**
+ * Collection-bound reactive set-based keyless index.
+ *
+ * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
+ * through the collection binding. A single pk→slot `membership` map gives O(1)
+ * add (dedup) and O(1) remove. Mirrors
+ * {@link OIMReactiveCollectionIndexManualSetBased} minus the key.
+ */
+declare class OIMReactiveCollectionGlobalIndexManualSetBased<TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveGlobalIndexManualSetBased<TPk> {
+    private readonly resolveSlot;
+    private readonly membership;
+    private membershipSeeded;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionGlobalIndexSetBasedOptions<TEntity, TPk>);
+    setPks(pks: readonly TPk[]): void;
+    addPks(pks: readonly TPk[]): void;
+    removePks(pks: readonly TPk[]): void;
+    clear(): void;
+    private membershipOf;
+    getEntities<TItem extends object = TEntity>(): (TItem | undefined)[];
+    private resolveRequiredSlot;
+}
+
+/**
+ * Keyless array-based index derived from the whole collection.
+ *
+ * Auto-maintains a single ordered list of every entity that passes `filter`
+ * (default: "entity exists"), sorted by `orderBy`/`compareEntities`. Mirrors
+ * {@link OIMDerivedCollectionIndexArrayBased}, but membership is a single
+ * boolean set (`presentPks`) instead of a per-pk key-set.
+ */
+declare class OIMDerivedCollectionGlobalIndexArrayBased<TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionGlobalIndexManualArrayBased<TPk, TEntity> {
+    private readonly collection;
+    private readonly compareEntities?;
+    private readonly orderBy?;
+    private readonly filter?;
+    private readonly unsubscribeFromCollection;
+    private readonly presentPks;
+    private readonly orderValueByPk;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts: TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity, TPk>);
+    rebuildFromCollection(): void;
+    clear(): void;
+    destroy(): void;
+    private readonly onCollectionUpdate;
+    private sortSlots;
+}
+
+/**
+ * Keyless set-based index derived from the whole collection.
+ *
+ * Auto-maintains a single unordered set of every entity that passes `filter`
+ * (default: "entity exists"). Mirrors {@link OIMDerivedCollectionIndexSetBased}
+ * minus the key.
+ */
+declare class OIMDerivedCollectionGlobalIndexSetBased<TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionGlobalIndexManualSetBased<TPk, TEntity> {
+    private readonly collection;
+    private readonly filter?;
+    private readonly unsubscribeFromCollection;
+    private readonly presentPks;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts: TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity, TPk>);
+    rebuildFromCollection(): void;
+    clear(): void;
+    destroy(): void;
+    private readonly onCollectionUpdate;
+}
+
 /**
  * Factory helper for collection-bound indexes.
  *
@@ -1004,6 +1396,20 @@ declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIM
     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>;
+    /**
+     * Keyless (whole-collection / "all") manual array-based index. No key —
+     * write pks directly with `setPks`/`addPks`/`removePks`.
+     */
+    arrayBasedGlobalIndex(opts?: TOIMRelationsGlobalArrayIndexOptions<TPk>): OIMReactiveCollectionGlobalIndexManualArrayBased<TPk, TEntity>;
+    /** Keyless (whole-collection) manual set-based index. */
+    setBasedGlobalIndex(opts?: TOIMRelationsGlobalSetIndexOptions<TPk>): OIMReactiveCollectionGlobalIndexManualSetBased<TPk, TEntity>;
+    /**
+     * Keyless ordered list auto-derived from the whole collection. Pass
+     * `orderBy`/`compareEntities` for order, `filter` to include a subset.
+     */
+    derivedArrayGlobalIndex(opts?: TOIMRelationsDerivedGlobalArrayIndexOptions<TEntity, TPk>): OIMDerivedCollectionGlobalIndexArrayBased<TPk, TEntity>;
+    /** Keyless set auto-derived from the whole collection. */
+    derivedSetGlobalIndex(opts?: TOIMRelationsDerivedGlobalSetIndexOptions<TEntity, TPk>): OIMDerivedCollectionGlobalIndexSetBased<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>;
 }
@@ -1195,6 +1601,38 @@ declare function createInPlaceEntityUpdater<TEntity extends object>(): TOIMEntit
  */
 declare function createMergeEntityUpdater<TEntity extends object>(): TOIMEntityUpdater<TEntity>;
 
+/**
+ * Keyless (single-carrier) pub/sub. The emitter IS the carrier: it holds one
+ * subscriber set and one dirty flag, so the hot path — marking updated and
+ * delivering — needs no resolver, no `Map`, no per-key hashing, and no
+ * `dirtyCarriers[]` batch (there is only ever one carrier).
+ *
+ * This is the {@link OIMCarrierKeyedEmitter} analogue for a whole-collection
+ * ("Global") reactive index. Every op here is strictly cheaper than its keyed
+ * counterpart: `subscribe` is one `Set.add` (no `getOrReserveCarrier`),
+ * `markUpdated` is a flag flip + a single `queue.enqueue` (no map lookup, no
+ * array push).
+ */
+declare class OIMCarrierSingleEmitter implements IOIMSingleUpdateEmitter {
+    private readonly queue;
+    private subscribers?;
+    private dirty;
+    private isFlushEnqueued;
+    constructor(queue: OIMEventQueue);
+    subscribe(handler: TOIMEventHandler<void>): () => void;
+    markUpdated(): void;
+    hasSubscriptions(): boolean;
+    getMetrics(): {
+        totalHandlers: number;
+        queueLength: number;
+    };
+    destroy(): void;
+    private assertNotInFlush;
+    private scheduleFlush;
+    private readonly onFlush;
+    private notify;
+}
+
 /**
  * Factory for creating index comparators.
  * Provides common comparison strategies for primary key arrays.
@@ -1318,6 +1756,10 @@ declare class OIMCollectionSelectors<TEntity extends object, TPk extends TOIMPk>
     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>;
+    /** Entities of a keyless (whole-collection) array-based index, ordered. */
+    entitiesByArrayGlobalIndex<TIndex extends OIMGlobalIndexArrayBased<TPk>>(index: OIMReactiveGlobalIndexArrayBased<TPk, TIndex>): TOIMCollectionEntitiesSelector<TEntity>;
+    /** Entities of a keyless (whole-collection) set-based index. */
+    entitiesBySetGlobalIndex<TIndex extends OIMGlobalIndexSetBased<TPk>>(index: OIMReactiveGlobalIndexSetBased<TPk, TIndex>): TOIMCollectionEntitiesSelector<TEntity>;
 }
 
 type TOIMReactiveCollectionFactoryOptions<TEntity extends object, TPk extends TOIMPk> = TOIMCollectionOptions<TEntity, TPk>;
@@ -1398,6 +1840,232 @@ declare class OIMCollectionChangedFields<TEntity extends object, TPk extends TOI
     private trackPatch;
 }
 
+/**
+ * Projects an ordered-list command source element-wise, re-emitting the same
+ * position-addressed commands with `item` replaced by `create(item)`.
+ *
+ * It rides the source's batching: there is no queue and no independent
+ * scheduling. On each source notification it pulls the source commands,
+ * translates them (running `create` and updating a positional mirror of the
+ * mapped elements), and notifies its own subscribers synchronously — so the
+ * source's `after_flush` semantics carry through.
+ *
+ * Identity is positional: a `move` reorders the *same* mapped references in the
+ * mirror, so the mapped element is preserved across moves and never recreated.
+ * `create` runs on `insert` / `set` / `reset` / initial build.
+ *
+ * There is no teardown callback by design: the leaving element is already the
+ * `remove` / `reset` / `set` command a consumer applies against its own mirror,
+ * so any DOM/resource cleanup belongs there — a `destroy` hook would only be
+ * duplicating a signal the consumer already receives.
+ *
+ * Wiring to the source for a key is lazy (on first `subscribeCommands` or
+ * `getItemsByKey`) and lives until `destroy()`; subscriber churn does not
+ * create mapped elements.
+ *
+ * The output is itself an {@link IOIMOrderedListCommandSource}, so maps chain:
+ * `source.map(...)` → `.map(...)`.
+ */
+declare class OIMOrderedListMappedCommandStream<TKey extends TOIMPk, TOut, TIn> implements IOIMOrderedListCommandSource<TKey, TOut> {
+    private readonly source;
+    private readonly create;
+    /** Per-key positional mirror of the mapped elements. */
+    private readonly mirror;
+    /** Mapped commands produced for the current delivery, per key. */
+    private readonly buffer;
+    private readonly subscribers;
+    private readonly sourceUnsubscribers;
+    constructor(source: IOIMOrderedListCommandSource<TKey, TIn>, create: (item: TIn) => TOut);
+    subscribeCommands(key: TKey, handler: () => void): () => void;
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TOut>[];
+    getItemsByKey(key: TKey): readonly TOut[];
+    /** Map this source again, chaining the projection. */
+    map<TNext>(create: (item: TOut) => TNext): OIMOrderedListMappedCommandStream<TKey, TNext, TOut>;
+    destroy(): void;
+    /** Build the initial mirror and subscribe to the source once per key. */
+    private ensureWired;
+    private onSourceCommands;
+}
+
+/**
+ * Map an ordered-list command source element-wise. The result is itself a
+ * source, so it can be mapped again (or via its `.map()` method).
+ *
+ * ```ts
+ * const nodes = createOIMOrderedListMappedCommandStream(stream, (slot) =>
+ *     engine.makeNode(slot.item)
+ * );
+ * nodes.subscribeCommands(key, () => {
+ *     for (const cmd of nodes.consumeCommands(key)) {
+ *         // cmd.item is your node; tear it down on `remove` / `set` / `reset`
+ *     }
+ * });
+ * ```
+ */
+declare function createOIMOrderedListMappedCommandStream<TKey extends TOIMPk, TIn, TOut>(source: IOIMOrderedListCommandSource<TKey, TIn>, create: (item: TIn) => TOut): OIMOrderedListMappedCommandStream<TKey, TOut, TIn>;
+
+/**
+ * Minimal read/subscribe surface a keyed index exposes for slot mapping:
+ * iterate the slots under a key and subscribe to that key's changes.
+ *
+ * Both `OIMReactiveIndexSetBased` (slots as a `ReadonlySet`) and
+ * `OIMReactiveIndexArrayBased` (slots as a `readonly` array) satisfy it
+ * structurally — a `Set` and an array are both `Iterable`.
+ */
+interface IOIMIndexSlotSource<TKey extends TOIMPk, TPk extends TOIMPk> extends IOIMKeyedSubscription<TKey> {
+    getSlotsByKey(key: TKey): Iterable<TOIMAnyEntitySlot<TPk>>;
+}
+
+/**
+ * Stable slot→object memo over a keyed set/array index.
+ *
+ * `create(slot)` runs once per canonical slot; every later read for the same
+ * slot returns the **same** object reference. That lets a consumer re-read a
+ * key's members on each notification and still hand reference-equal objects to
+ * `React.memo` / `Object.is` diffing, or reuse the same view-model instance.
+ *
+ * Identity is the slot object (which a collection-bound index keeps canonical
+ * and shared per pk). The cache is a `WeakMap`, so a mapped object is reclaimed
+ * by GC once its slot is dropped and unreferenced — there is no lifecycle
+ * callback and none is needed for plain values. If your mapped objects hold
+ * resources that need explicit teardown (DOM nodes, subscriptions), use the
+ * ordered command stream (`createOIMOrderedListMappedCommandStream`), which has
+ * an exact removal signal to drive `destroy`.
+ *
+ * This is a thin wrapper: it holds no queue and no standing subscription of its
+ * own — `subscribeOnKey` is a passthrough to the index.
+ */
+declare class OIMIndexSlotMap<TKey extends TOIMPk, TPk extends TOIMPk, TMapped> {
+    private readonly index;
+    private readonly create;
+    private readonly cache;
+    constructor(index: IOIMIndexSlotSource<TKey, TPk>, create: (slot: TOIMAnyEntitySlot<TPk>) => TMapped);
+    /** The mapped object for a slot, created once and cached by slot identity. */
+    get(slot: TOIMAnyEntitySlot<TPk>): TMapped;
+    /**
+     * Mapped objects for every slot under `key`, with stable references. For a
+     * set-based index the order is unspecified (as the set is); for an
+     * array-based index it follows the index order.
+     */
+    getByKey(key: TKey): TMapped[];
+    /**
+     * Chain another projection. `map(f)` returns a slot map over the SAME index
+     * whose objects are `f(this.get(slot))`, cached by slot identity — so both
+     * levels hand back stable references and each `create` runs once per slot.
+     * Mirrors the command stream's `.map()`.
+     */
+    map<TNext>(create: (mapped: TMapped) => TNext): OIMIndexSlotMap<TKey, TPk, TNext>;
+    /** Subscribe to a key's changes — passthrough to the index. */
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    /** Subscribe to several keys — passthrough to the index. */
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+}
+
+/**
+ * Map the slots of a keyed set/array index to stable per-slot objects.
+ *
+ * ```ts
+ * const usersByTeam = users.indexFactory.derivedSetIndex((u) => u.teamId);
+ * const rows = createOIMIndexSlotMap(usersByTeam, (slot) => makeRow(slot.item));
+ *
+ * rows.subscribeOnKey('team1', render);
+ * function render() {
+ *   for (const row of rows.getByKey('team1')) { /* same instance per slot *\/ }
+ * }
+ * ```
+ */
+declare function createOIMIndexSlotMap<TKey extends TOIMPk, TPk extends TOIMPk, TMapped>(index: IOIMIndexSlotSource<TKey, TPk>, create: (slot: TOIMAnyEntitySlot<TPk>) => TMapped): OIMIndexSlotMap<TKey, TPk, TMapped>;
+
+/**
+ * Options for {@link OIMOrderedListCommandStreamDiffDriven}.
+ */
+type TOIMOrderedListDiffOptions = {
+    /**
+     * Fraction of shared pks below which a whole `reset` is emitted instead of
+     * fine-grained insert/move/remove commands (when most of a bucket changed,
+     * a reset is cheaper than a pile of edits). Range `(0, 1)`.
+     *
+     * Default `0` — always diff. An unchanged order (same pks in the same
+     * positions) still yields zero commands regardless of this value.
+     */
+    resetThreshold?: number;
+};
+
+/**
+ * Diff two ordered lists of pk-identified items into position-addressed
+ * commands (`insert` / `remove` / `move`) that transform `prev` into `next`.
+ *
+ * Identity is `item.pk`; content is not compared (a reordered same-pk item is a
+ * `move`, never recreated). Correctness is by construction: commands are emitted
+ * against a working copy that mirrors what a consumer applying them holds, so
+ * `applyCommands(prev, diffOrderedListByPk(prev, next))` equals `next` by pk.
+ *
+ * Moves are minimal. A longest-increasing-subsequence pass finds the common
+ * items already in relative order — those stay; every other common item moves
+ * exactly once, so the move count is `commonCount − LIS` (the optimum). This is
+ * the standard keyed reconciliation used by imperative DOM renderers: each
+ * non-anchor item is placed immediately before the already-positioned item to
+ * its right (`next[j + 1]`), processed right → left.
+ *
+ * It intentionally does NOT emit `reset`; callers decide when a whole reset is
+ * cheaper (see `OIMOrderedListCommandStreamDiffDriven`). Complexity is O(n·m)
+ * worst case (an index scan per placed item), acceptable for the moderate bucket
+ * sizes indexes produce, where it runs only on an actual change.
+ */
+declare function diffOrderedListByPk<TPk extends TOIMPk, TItem extends {
+    pk: TPk;
+}>(prev: readonly TItem[], next: readonly TItem[]): TOIMOrderedListCommand<TItem>[];
+
+/**
+ * Ordered-list command stream driven by an existing reactive **array-based**
+ * index (derived or manual). Instead of imperative writers, it diffs the
+ * previous per-key order against the new one on every index change and emits the
+ * position-addressed commands that transform one into the other — so a
+ * collection change becomes `insert` / `move` / `remove` (or a `reset`) that an
+ * imperative renderer can apply, moving nodes instead of rebuilding them.
+ *
+ * It rides the index's batching: the index delivers its coalesced per-key change
+ * during the queue flush; this stream diffs there and buffers commands, which
+ * the shared {@link OIMOrderedListCommandBuffer} delivers at `AFTER_FLUSH` — the
+ * same timing contract as the writer stream.
+ *
+ * Wiring to the index for a key is lazy (first `subscribeCommands` or
+ * `getItemsByKey`) and lives until `destroy()`. The output is an
+ * `IOIMOrderedListCommandSource`, so it consumes exactly like the writer stream
+ * and composes with `createOIMOrderedListMappedCommandStream`.
+ */
+declare class OIMOrderedListCommandStreamDiffDriven<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object, TIndex extends OIMIndexArrayBased<TKey, TPk> = OIMIndexArrayBased<TKey, TPk>> extends OIMOrderedListCommandBuffer<TKey, TOIMEntitySlot<TEntity, TPk>> {
+    private readonly index;
+    private readonly resetThreshold;
+    private readonly prevByKey;
+    private readonly indexUnsubscribeByKey;
+    constructor(queue: OIMEventQueue, index: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, opts?: TOIMOrderedListDiffOptions);
+    getItemsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
+    subscribeCommands(key: TKey, handler: () => void): () => void;
+    destroy(): void;
+    private currentSlots;
+    /** Snapshot the current order and subscribe to the index once per key. */
+    private ensureWired;
+    private onIndexChange;
+    private emitDiff;
+}
+
+/**
+ * Derive an ordered-list command stream from a reactive array-based index — the
+ * index's per-key order changes become position-addressed commands.
+ *
+ * ```ts
+ * const cardsByDeck = cards.indexFactory.derivedArrayIndex(
+ *     (c) => c.deckId, { orderBy: (c) => c.position }
+ * );
+ * const stream = createOIMOrderedListCommandStreamDiffDriven(queue, cardsByDeck);
+ * stream.subscribeCommands('deck1', () =>
+ *     engine.apply(stream.consumeCommands('deck1')) // insert/move/remove
+ * );
+ * ```
+ */
+declare function createOIMOrderedListCommandStreamDiffDriven<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object, TIndex extends OIMIndexArrayBased<TKey, TPk> = OIMIndexArrayBased<TKey, TPk>>(queue: OIMEventQueue, index: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, opts?: TOIMOrderedListDiffOptions): OIMOrderedListCommandStreamDiffDriven<TKey, TPk, TEntity, TIndex>;
+
 /**
  * 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.
@@ -1414,7 +2082,7 @@ declare class OIMEventQueueSchedulerAnimationFrame extends OIMEventQueueSchedule
 /**
  * Available scheduler types for event queue configuration.
  */
-type TOIMSchedulerType = 'microtask' | 'animationFrame' | 'timeout' | 'immediate';
+type TOIMSchedulerType = 'microtask' | 'animationFrame' | 'timeout' | 'immediate' | 'sync';
 
 /**
  * Configuration options for different scheduler types. */
@@ -1425,6 +2093,7 @@ type TOIMSchedulerOptions = {
         delay?: number;
     };
     immediate: never;
+    sync: never;
 };
 
 /**
@@ -1469,6 +2138,28 @@ declare class OIMEventQueueSchedulerImmediate extends OIMEventQueueScheduler {
     cancel(): void;
 }
 
+/**
+ * Synchronous scheduler — flushes immediately, in the same call stack, on the
+ * enqueue that triggers scheduling. It performs NO batching: every write that
+ * schedules a flush is delivered right away.
+ *
+ * This is a DEBUG / diagnostic tool, not a production scheduler. Swap it in at
+ * the root to strip all coalescing and test whether a suspected bug is caused by
+ * batch timing: if the bug disappears under synchronous delivery it is
+ * coalescing-related, if it persists it is not. It automates what manually
+ * calling `queue.flush()` after every write would do.
+ *
+ * Caveats (all inherent to removing batching):
+ * - subscribers observe intermediate, un-coalesced states the batched schedulers
+ *   hide (e.g. a collection updated but its index not yet);
+ * - a cyclic reactive graph that would loop across ticks under an async
+ *   scheduler recurses here and can overflow the stack.
+ */
+declare class OIMEventQueueSchedulerSync extends OIMEventQueueScheduler {
+    schedule(): void;
+    cancel(): void;
+}
+
 /**
  * Factory for creating event queue schedulers.
  * Provides a convenient way to create schedulers with type-safe configuration.
@@ -1491,9 +2182,14 @@ declare class OIMEventQueueSchedulerFactory {
      */
     static createTimeout(delay?: number): OIMEventQueueSchedulerTimeout;
     /**
-     * Create an immediate scheduler (fastest execution).
+     * Create an immediate scheduler (setImmediate / MessageChannel / setTimeout(0)).
      */
     static createImmediate(): OIMEventQueueSchedulerImmediate;
+    /**
+     * Create a synchronous scheduler — flushes in the same call stack, no
+     * batching. Debug/diagnostic use only (see {@link OIMEventQueueSchedulerSync}).
+     */
+    static createSync(): OIMEventQueueSchedulerSync;
 }
 
 declare enum EOIMCollectionEventType {
@@ -1750,4 +2446,20 @@ declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TP
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierResolver, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMIndexStore, type IOIMKeyedUpdateEmitter, type IOIMSubscribable, OIMCarrierKeyedEmitter, 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 TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, 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, createInPlaceEntityUpdater, createMergeEntityUpdater, createOIMCollectionIndexFactory, createOIMCollectionKit };
+declare class OIMEntitiesByGlobalIndexSetBasedSelector<TEntity extends object, TPk extends TOIMPk, TIndex extends OIMGlobalIndexSetBased<TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+    private readonly collection;
+    private readonly reactiveIndex;
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveGlobalIndexSetBased<TPk, TIndex>);
+    getValue(): readonly (TEntity | undefined)[];
+    protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
+}
+
+declare class OIMEntitiesByGlobalIndexArrayBasedSelector<TEntity extends object, TPk extends TOIMPk, TIndex extends OIMGlobalIndexArrayBased<TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+    private readonly collection;
+    private readonly reactiveIndex;
+    constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveGlobalIndexArrayBased<TPk, TIndex>);
+    getValue(): readonly (TEntity | undefined)[];
+    protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
+}
+
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierResolver, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMIndexSlotSource, type IOIMIndexStore, type IOIMKeyedUpdateEmitter, type IOIMOrderedListCommandSource, type IOIMSingleUpdateEmitter, type IOIMSubscribable, type IOIMSubscription, OIMCarrierKeyedEmitter, OIMCarrierSingleEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionGlobalIndexArrayBased, OIMDerivedCollectionGlobalIndexSetBased, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByGlobalIndexArrayBasedSelector, OIMEntitiesByGlobalIndexSetBasedSelector, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerSync, OIMEventQueueSchedulerTimeout, OIMGlobalIndex, OIMGlobalIndexArrayBased, OIMGlobalIndexManualArrayBased, OIMGlobalIndexManualSetBased, OIMGlobalIndexSetBased, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexSlotMap, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandBuffer, OIMOrderedListCommandStream, OIMOrderedListCommandStreamDiffDriven, OIMOrderedListMappedCommandStream, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionGlobalIndexManualArrayBased, OIMReactiveCollectionGlobalIndexManualSetBased, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveGlobalIndex, OIMReactiveGlobalIndexArrayBased, OIMReactiveGlobalIndexManualArrayBased, OIMReactiveGlobalIndexManualSetBased, OIMReactiveGlobalIndexSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionGlobalIndexArrayBasedOptions, type TOIMCollectionGlobalIndexSetBasedOptions, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionGlobalIndexArrayBasedOptions, type TOIMDerivedCollectionGlobalIndexSetBasedOptions, 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 TOIMGlobalIndexFilter, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMOrderedListDiffOptions, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedGlobalArrayIndexOptions, type TOIMRelationsDerivedGlobalSetIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsGlobalArrayIndexOptions, type TOIMRelationsGlobalSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createInPlaceEntityUpdater, createMergeEntityUpdater, createOIMCollectionIndexFactory, createOIMCollectionKit, createOIMIndexSlotMap, createOIMOrderedListCommandStreamDiffDriven, createOIMOrderedListMappedCommandStream, diffOrderedListByPk };