@oimdb/core 3.8.0 → 3.10.0

package/dist/index.d.ts

@@ -16,7 +16,7 @@ type TOIMKeyPath = readonly TOIMPk[];
 
 /**
  * The key bound shared by every keyed node (index, keyed emitter, carrier
- * resolver): either a single primitive PK (`TOIMPk`) or a composite key path
+ * provider): either a single primitive PK (`TOIMPk`) or a composite key path
  * (`TOIMKeyPath`).
  *
  * It exists purely to widen the generic bound from `TOIMPk` to also admit
@@ -39,72 +39,9 @@ type TOIMEntitySlot<TEntity extends object, TPk extends TOIMKey> = {
     subscribers?: Set<() => void>;
 };
 type TOIMAnyEntitySlot<TPk extends TOIMKey> = TOIMEntitySlot<object, TPk>;
-type TOIMEntitySlotResolver<TPk extends TOIMKey> = (pk: TPk) => TOIMAnyEntitySlot<TPk> | undefined;
-
-/**
- * The Map surface the PK / index-key axis needs, abstracted so the concrete
- * keying strategy is pluggable. A native `Map` satisfies this interface
- * structurally (so the primitive default is a plain `Map`, zero wrapper), while
- * a composite key uses a trie-backed implementation (`OIMTrieMap`) that matches
- * array keys by content instead of by reference.
- */
-interface IOIMKeyedMap<TKey, TValue> {
-    get(key: TKey): TValue | undefined;
-    set(key: TKey, value: TValue): void;
-    has(key: TKey): boolean;
-    delete(key: TKey): boolean;
-    readonly size: number;
-    keys(): IterableIterator<TKey>;
-    entries(): IterableIterator<[TKey, TValue]>;
-    values(): IterableIterator<TValue>;
-    clear(): void;
-}
-
-/**
- * The Set surface the PK / index-key axis needs, abstracted so the concrete
- * keying strategy is pluggable. A native `Set` satisfies this interface
- * structurally (primitive default is a plain `Set`, zero wrapper); a composite
- * key uses a trie-backed implementation matching array keys by content.
- */
-interface IOIMKeyedSet<TKey> {
-    add(key: TKey): void;
-    has(key: TKey): boolean;
-    delete(key: TKey): boolean;
-    readonly size: number;
-    values(): IterableIterator<TKey>;
-    clear(): void;
-}
-
-/**
- * Owns "how a key is stored, compared, and identified" for one keying axis
- * (a collection's PK, or an index's key). It is the single seam every PK-keyed
- * `Map`/`Set` on the hot path goes through, so the whole engine is agnostic to
- * whether the key is a primitive or a composite path.
- *
- * - `OIMKeyDomainNative` (default): native `Map`/`Set`, `canonicalize` is
- *   identity — byte-for-byte the current behavior and cost for primitive keys.
- * - `OIMKeyDomainTrie`: trie-backed `Map`/`Set` matching array keys by content,
- *   and `canonicalize` interns each logical key to one stable reference so that
- *   downstream native `Set<slot.pk>` keep working by reference.
- */
-interface IOIMKeyDomain<TKey extends TOIMKey> {
-    createMap<TValue>(): IOIMKeyedMap<TKey, TValue>;
-    createSet(): IOIMKeyedSet<TKey>;
-    /**
-     * Returns the canonical reference for a logical key. Native domain returns
-     * the key unchanged; a composite domain interns it so equal-content keys
-     * share one reference (making reference-keyed structures downstream correct).
-     */
-    canonicalize(key: TKey): TKey;
-}
+type TOIMEntitySlotGetter<TPk extends TOIMKey> = (pk: TPk) => TOIMAnyEntitySlot<TPk> | undefined;
 
 declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TOIMKey> {
-    /**
-     * The keying strategy for this store's PKs. Every PK-keyed structure built
-     * off a collection (indexes, wrappers) reads it so the whole engine keys PKs
-     * the same way — native `Map` for primitives, trie for composite paths.
-     */
-    abstract get keyDomain(): IOIMKeyDomain<TPk>;
     abstract setOneByPk(pk: TPk, entity: TEntity): TOIMEntitySlot<TEntity, TPk>;
     abstract getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     /**
@@ -226,6 +163,25 @@ interface IOIMSubscribable {
     dirty?: boolean;
 }
 
+/**
+ * The Map surface the PK / index-key axis needs, abstracted so the concrete
+ * keying strategy is pluggable. A native `Map` satisfies this interface
+ * structurally (so the primitive default is a plain `Map`, zero wrapper), while
+ * a composite key uses a trie-backed implementation (`OIMTrieMap`) that matches
+ * array keys by content instead of by reference.
+ */
+interface IOIMKeyedMap<TKey, TValue> {
+    get(key: TKey): TValue | undefined;
+    set(key: TKey, value: TValue): void;
+    has(key: TKey): boolean;
+    delete(key: TKey): boolean;
+    readonly size: number;
+    keys(): IterableIterator<TKey>;
+    entries(): IterableIterator<[TKey, TValue]>;
+    values(): IterableIterator<TValue>;
+    clear(): void;
+}
+
 /**
  * A set-based index bucket that is ALSO its own subscription carrier AND holds
  * its own pk→slot membership.
@@ -428,18 +384,34 @@ type TOIMEventQueueOptions = {
      * If not provided, flush() must be called manually.
      */
     scheduler?: OIMEventQueueScheduler;
+    /**
+     * Handler for an error thrown by a task during flush. When set, the queue
+     * treats the error as handled — it is NOT re-raised out of `flush()`. When
+     * NOT set, the error propagates (loud by default: uncaught in async/scheduled
+     * mode, thrown to the caller of a manual `flush()`).
+     *
+     * Either way the queue's own state is always restored (one failing task never
+     * wedges the queue) and a `FLUSH_ERROR` event is emitted for tooling.
+     */
+    onError?: (error: unknown) => void;
 };
 
-declare enum EOIMEventQueueEventType {
-    AFTER_FLUSH = 0,
-    BEFORE_FLUSH = 1
-}
+/** Payload of the `EOIMEventQueueEventType.FLUSH_ERROR` event. */
+type TOIMFlushError = {
+    /** The value a queue task threw (not necessarily an `Error`). */
+    error: unknown;
+};
 
 /**
  * Event queue that can optionally integrate with a scheduler for automatic flushing.
  */
 declare class OIMEventQueue {
-    readonly emitter: OIMEventEmitter<Record<EOIMEventQueueEventType, void>>;
+    readonly emitter: OIMEventEmitter<{
+        1: void;
+        0: void;
+        2: TOIMFlushError;
+    }>;
+    protected readonly onError?: (error: unknown) => void;
     protected tasks: Set<() => void>;
     protected tasksSpare: Set<() => void>;
     protected flushing?: Set<() => void>;
@@ -492,13 +464,13 @@ declare class OIMEventQueue {
  * Collection carrier = the entity slot (by pk); index carrier = the bucket
  * (by index key).
  */
-interface IOIMCarrierResolver<TKey extends TOIMKey, TCarrier> {
+interface IOIMCarrierProvider<TKey extends TOIMKey, TCarrier> {
     getOrReserveCarrier(key: TKey): TCarrier;
     findCarrier(key: TKey): TCarrier | undefined;
     /**
-     * Optional: called when a carrier loses its last subscriber, so a resolver
+     * Optional: called when a carrier loses its last subscriber, so a carrierProvider
      * that owns standalone carriers (e.g. the index's key→carrier map) can prune
-     * it and not leak the key space. Resolvers whose carriers are owned
+     * it and not leak the key space. Providers whose carriers are owned
      * elsewhere (e.g. the collection's slots) leave this unset.
      */
     onCarrierEmptied?(carrier: TCarrier): void;
@@ -516,11 +488,11 @@ interface IOIMCarrierResolver<TKey extends TOIMKey, TCarrier> {
  */
 declare class OIMCarrierKeyedEmitter<TKey extends TOIMKey, TCarrier extends IOIMSubscribable> implements IOIMKeyedUpdateEmitter<TKey> {
     private readonly queue;
-    private readonly resolver;
+    private readonly carrierProvider;
     private readonly subscribedCarriers;
     private dirtyCarriers;
     private isFlushEnqueued;
-    constructor(queue: OIMEventQueue, resolver: IOIMCarrierResolver<TKey, TCarrier>);
+    constructor(queue: OIMEventQueue, carrierProvider: IOIMCarrierProvider<TKey, TCarrier>);
     subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
     unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
@@ -550,7 +522,7 @@ declare class OIMCarrierKeyedEmitter<TKey extends TOIMKey, TCarrier extends IOIM
 /**
  * Carrier for a single index key: holds that key's subscribers + dirty flag
  * (via `IOIMSubscribable`) so the keyed emitter delivers straight off the
- * carrier with no per-key map lookup. Carries its own `key` so the resolver can
+ * carrier with no per-key map lookup. Carries its own `key` so the provider can
  * prune it from the key→carrier map when its last subscriber leaves.
  */
 interface IOIMKeyCarrier<TKey extends TOIMKey> extends IOIMSubscribable {
@@ -567,13 +539,13 @@ declare abstract class OIMReactiveIndex<TKey extends TOIMKey, TPk extends TOIMKe
     protected readonly updateEmitter: IOIMKeyedUpdateEmitter<TKey>;
     constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex, 
     /**
-     * How to build the key→carrier resolver backing the keyed emitter.
-     * Defaults to the native-`Map` resolver used by every primitive-keyed
+     * How to build the key→carrier carrierProvider backing the keyed emitter.
+     * Defaults to the native-`Map` carrierProvider used by every primitive-keyed
      * index (its fast path is unchanged). A composite (trie-backed) index
-     * passes a resolver that keys carriers by key path instead. Called once
+     * passes a carrierProvider that keys carriers by key path instead. Called once
      * at construction — no per-operation cost.
      */
-    createResolver?: () => IOIMCarrierResolver<TKey, IOIMKeyCarrier<TKey>>);
+    createCarrierProvider?: () => IOIMCarrierProvider<TKey, IOIMKeyCarrier<TKey>>);
     getEntitiesByKey<TEntity extends object = object>(key: TKey): (TEntity | undefined)[];
     getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, (TEntity | undefined)[]>;
     hasKey(key: TKey): boolean;
@@ -604,7 +576,7 @@ declare abstract class OIMReactiveIndex<TKey extends TOIMKey, TPk extends TOIMKe
 }
 
 declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
-    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex, createResolver?: () => IOIMCarrierResolver<TKey, IOIMKeyCarrier<TKey>>);
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex, createCarrierProvider?: () => IOIMCarrierProvider<TKey, IOIMKeyCarrier<TKey>>);
     getPksByKey(key: TKey): Set<TPk>;
     getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
     getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
@@ -612,7 +584,7 @@ declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMKey, TPk extend
 }
 
 declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
-    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex, createResolver?: () => IOIMCarrierResolver<TKey, IOIMKeyCarrier<TKey>>);
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex, createCarrierProvider?: () => IOIMCarrierProvider<TKey, IOIMKeyCarrier<TKey>>);
     getPksByKey(key: TKey): TPk[];
     getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
     getSlotsByKey(key: TKey): readonly TOIMAnyEntitySlot<TPk>[];
@@ -713,7 +685,7 @@ interface IOIMSubscription {
  * 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.
+ * key parameter, no provider, and no per-key map.
  */
 interface IOIMSingleUpdateEmitter extends IOIMSubscription {
     markUpdated(): void;
@@ -723,7 +695,7 @@ interface IOIMSingleUpdateEmitter extends IOIMSubscription {
 
 /**
  * Reactive wrapper around a keyless {@link OIMGlobalIndex}. Owns a single-carrier
- * emitter (no resolver, no key→carrier map), so `subscribe(handler)` is keyless
+ * emitter (no provider, no key→carrier map), so `subscribe(handler)` is keyless
  * and directly satisfies `IOIMSelectorSourceDependency`. Mirrors
  * {@link OIMReactiveIndex} minus the key.
  */
@@ -781,13 +753,17 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMKey> {
     readonly selectPk: TOIMPkSelector<TEntity, TPk>;
     protected readonly store: OIMCollectionStore<TEntity, TPk>;
     protected readonly updateEntity: TOIMEntityUpdater<TEntity>;
-    /** The collection's PK keying strategy — read by indexes and wrappers. */
-    get keyDomain(): IOIMKeyDomain<TPk>;
     constructor(opts?: TOIMCollectionOptions<TEntity, TPk>);
     getOneByPk(pk: TPk): TEntity | undefined;
     getManyByPks(pks: readonly TPk[]): TEntity[];
     getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     getOrReserveSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk>;
+    /**
+     * The existing slot for `pk` (live or reserved) WITHOUT creating one — used
+     * by indexes to resolve a pk to its canonical slot for removal (delete by
+     * reference), with no side effect for a pk that is not present.
+     */
+    findSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
     upsertOneByPk(pk: TPk, entity: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
@@ -853,10 +829,10 @@ type TOIMCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOI
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
@@ -865,26 +841,26 @@ type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends T
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMCollectionOrderedIndexOptions<TEntity extends object, TPk extends TOIMKey> = {
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 };
 type TOIMCollectionOrderedListCommandStreamOptions<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object> = {
     index?: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMRelationsSetIndexOptions<TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
@@ -910,10 +886,10 @@ type TOIMCollectionIndexCompositeSetBasedOptions<TEntity extends object, TPk ext
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMRelationsCompositeSetIndexOptions<TPk extends TOIMKey> = {
     indexOptions?: {
@@ -933,10 +909,10 @@ type TOIMCollectionIndexCompositeArrayBasedOptions<TEntity extends object, TPk e
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMRelationsCompositeArrayIndexOptions<TPk extends TOIMKey> = {
     indexOptions?: {
@@ -1023,16 +999,15 @@ declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMKey, TPk extends
  * them to canonical collection slots at construction-bound write time.
  */
 declare class OIMCollectionIndexManualOrderedArrayBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMIndexManualOrderedArrayBased<TKey, TPk> {
-    private readonly resolveSlot;
+    private readonly getSlot;
     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 | undefined)[];
     getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
-    resolvePk(pk: TPk): TOIMAnyEntitySlot<TPk>;
-    private resolveSlots;
-    private resolveRequiredSlot;
+    getRequiredSlot(pk: TPk): TOIMAnyEntitySlot<TPk>;
+    private getRequiredSlots;
 }
 
 type TOIMUpdateEventEmitterDeliveryMode = 'queue' | 'after_flush' | 'immediate';
@@ -1248,7 +1223,7 @@ declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMKey, TPk ex
     set(key: TKey, pks: readonly TPk[]): void;
     getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
     getEntitiesByKey(key: TKey): (TEntity | undefined)[];
-    private resolvePk;
+    private getRequiredSlot;
 }
 
 /**
@@ -1301,9 +1276,9 @@ declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMKey, TPk extends
  * through the collection binding supplied at construction time.
  */
 declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveIndexManualArrayBased<TKey, TPk> {
-    private readonly resolveSlot;
-    private readonly pkDomain;
-    private readonly pksByKey;
+    private readonly getSlot;
+    private readonly findSlotForRemoval;
+    private readonly slotsByKey;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
     setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
@@ -1316,8 +1291,8 @@ declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMKey, T
     private membershipOf;
     getEntitiesByKey<TItem extends object = TEntity>(key: TKey): (TItem | undefined)[];
     getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
-    private resolveSlots;
-    private resolveRequiredSlot;
+    private getSlotsOrTransient;
+    private getSlotOrTransient;
 }
 
 /**
@@ -1331,15 +1306,18 @@ declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMKey, T
  * and re-filling.
  */
 declare class OIMIndexManualSetBased<TIndexKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndexSetBased<TIndexKey, TPk> {
-    protected readonly pkDomain: IOIMKeyDomain<TPk>;
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
-        pkDomain?: IOIMKeyDomain<TPk>;
     });
     setSlots(key: TIndexKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
-    setPks(key: TIndexKey, pks: readonly TPk[], resolveSlot: (pk: TPk) => TOIMAnyEntitySlot<TPk>): void;
-    addPks(key: TIndexKey, pks: readonly TPk[], resolveSlot: (pk: TPk) => TOIMAnyEntitySlot<TPk>): void;
+    setPks(key: TIndexKey, pks: readonly TPk[], getSlot: (pk: TPk) => TOIMAnyEntitySlot<TPk>): void;
+    addPks(key: TIndexKey, pks: readonly TPk[], getSlot: (pk: TPk) => TOIMAnyEntitySlot<TPk>): void;
+    /**
+     * Removes by pk. `pks` must be canonical `slot.pk` references (membership is
+     * keyed by them): for primitive pks that is just the pk; a collection-bound
+     * composite index canonicalizes raw pks to `slot.pk` before calling this.
+     */
     removePks(key: TIndexKey, pks: readonly TPk[]): void;
     /**
      * The bucket's pk → slot membership, lazily created and seeded from the
@@ -1374,12 +1352,6 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMKey, TPk extends T
             comparePks?: TOIMIndexComparator<TPk>;
             store?: OIMIndexStoreSetBased<TKey, TPk>;
         };
-        /**
-         * PK key domain for the per-bucket membership — native for primitive
-         * PKs, trie for a composite-PK collection. Threaded from the bound
-         * collection's `keyDomain`.
-         */
-        pkDomain?: IOIMKeyDomain<TPk>;
     });
     setSlots(key: TKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
     addSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
@@ -1396,9 +1368,10 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMKey, TPk extends T
  * the key's store bucket exactly once (no separate membership map/trie).
  */
 declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TKey, TPk> {
-    private readonly resolveSlot;
-    private readonly resolveRequiredSlot;
+    private readonly getSlot;
+    private readonly getSlotOrTransient;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>);
+    private readonly findSlotForRemoval;
     setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
@@ -1423,9 +1396,10 @@ declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMKey, TPk
  * path — the trie cost is paid only by this opt-in index.
  */
 declare class OIMReactiveCollectionIndexCompositeTrieSetBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TOIMKeyPath, TPk> {
-    private readonly resolveSlot;
-    private readonly resolveRequiredSlot;
+    private readonly getSlot;
+    private readonly getSlotOrTransient;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexCompositeSetBasedOptions<TEntity, TPk>);
+    private readonly findSlotForRemoval;
     setPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
     addPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
     removePks(key: TOIMKeyPath, pks: readonly TPk[]): void;
@@ -1444,7 +1418,7 @@ declare class OIMReactiveCollectionIndexCompositeTrieSetBased<TPk extends TOIMKe
  * paid only by this opt-in index.
  */
 declare class OIMReactiveCollectionIndexCompositeTrieArrayBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveIndexManualArrayBased<TOIMKeyPath, TPk> {
-    private readonly resolveSlot;
+    private readonly getSlot;
     private readonly pksByKey;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexCompositeArrayBasedOptions<TEntity, TPk>);
     setPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
@@ -1458,8 +1432,8 @@ declare class OIMReactiveCollectionIndexCompositeTrieArrayBased<TPk extends TOIM
     private membershipOf;
     getEntitiesByKey<TItem extends object = TEntity>(key: TOIMKeyPath): (TItem | undefined)[];
     getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TOIMKeyPath[]): Map<TOIMKeyPath, (TItem | undefined)[]>;
-    private resolveSlots;
-    private resolveRequiredSlot;
+    private getSlotsOrTransient;
+    private getSlotOrTransient;
 }
 
 /**
@@ -1548,10 +1522,10 @@ type TOIMCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk exte
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     indexOptions?: {
@@ -1559,10 +1533,10 @@ type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extend
     };
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
-    resolveSlot?: never;
+    getSlot?: never;
 } | {
     collection?: never;
-    resolveSlot: TOIMEntitySlotResolver<TPk>;
+    getSlot: TOIMEntitySlotGetter<TPk>;
 });
 type TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     /** Build initial state from existing collection slots. Defaults to true. */
@@ -1608,7 +1582,7 @@ type TOIMRelationsDerivedGlobalSetIndexOptions<TEntity extends object, TPk exten
  * key (one bucket instead of a per-key map).
  */
 declare class OIMReactiveCollectionGlobalIndexManualArrayBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveGlobalIndexManualArrayBased<TPk> {
-    private readonly resolveSlot;
+    private readonly getSlot;
     private readonly membership;
     private membershipSeeded;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionGlobalIndexArrayBasedOptions<TEntity, TPk>);
@@ -1618,8 +1592,8 @@ declare class OIMReactiveCollectionGlobalIndexManualArrayBased<TPk extends TOIMK
     clear(): void;
     private membershipOf;
     getEntities<TItem extends object = TEntity>(): (TItem | undefined)[];
-    private resolveSlots;
-    private resolveRequiredSlot;
+    private getSlotsOrTransient;
+    private getSlotOrTransient;
 }
 
 /**
@@ -1663,7 +1637,7 @@ declare class OIMReactiveGlobalIndexManualSetBased<TPk extends TOIMKey> extends
  * {@link OIMReactiveCollectionIndexManualSetBased} minus the key.
  */
 declare class OIMReactiveCollectionGlobalIndexManualSetBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveGlobalIndexManualSetBased<TPk> {
-    private readonly resolveSlot;
+    private readonly getSlot;
     private readonly membership;
     private membershipSeeded;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionGlobalIndexSetBasedOptions<TEntity, TPk>);
@@ -1673,7 +1647,7 @@ declare class OIMReactiveCollectionGlobalIndexManualSetBased<TPk extends TOIMKey
     clear(): void;
     private membershipOf;
     getEntities<TItem extends object = TEntity>(): (TItem | undefined)[];
-    private resolveRequiredSlot;
+    private getSlotOrTransient;
 }
 
 /**
@@ -1835,11 +1809,9 @@ declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<T
  * Native-`Map` collection store for primitive PKs. The hot path is a plain
  * `Map` — this class NEVER holds a trie, so its `.get`/`.set` call sites stay
  * monomorphic even in a process that also runs composite-PK collections (those
- * use `OIMCollectionStoreTrieDriven`). Byte-for-byte the pre-seam behavior; the
- * only addition is a shared native `keyDomain` object the indexes read.
+ * use `OIMCollectionStoreTrieDriven`). Byte-for-byte the pre-seam behavior.
  */
 declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TOIMKey> extends OIMCollectionStore<TEntity, TPk> {
-    readonly keyDomain: IOIMKeyDomain<TPk>;
     protected readonly slots: Map<TPk, TOIMEntitySlot<TEntity, TPk>>;
     protected readonly reservedSlots: Map<TPk, TOIMEntitySlot<TEntity, TPk>>;
     setOneByPk(pk: TPk, entity: TEntity): TOIMEntitySlot<TEntity, TPk>;
@@ -1861,23 +1833,6 @@ declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TO
     destroy(): void;
 }
 
-/**
- * Key domain for composite key paths (`TOIMKeyPath`) — the trie counterpart of
- * `OIMKeyDomainNative`. Maps/Sets are trie-backed (match array keys by content),
- * and `canonicalize` interns each logical key into one stable reference via a
- * shared pool, so a collection's `slot.pk` is a single reference per logical key
- * and every downstream native `Set<slot.pk>`/`Map<slot.pk>` stays correct.
- *
- * Object-key support later: swap in a `keyToSegments` that sorts object entries;
- * nothing else here or at the call sites changes.
- */
-declare class OIMKeyDomainTrie implements IOIMKeyDomain<TOIMKeyPath> {
-    private readonly pool;
-    createMap<TValue>(): IOIMKeyedMap<TOIMKeyPath, TValue>;
-    createSet(): IOIMKeyedSet<TOIMKeyPath>;
-    canonicalize(key: TOIMKeyPath): TOIMKeyPath;
-}
-
 declare class OIMTrieMap<TSegment, TValue> {
     private readonly root;
     private _size;
@@ -1908,10 +1863,8 @@ declare class OIMTrieMap<TSegment, TValue> {
  * pollution. Method bodies mirror the Map store.
  */
 declare class OIMCollectionStoreTrieDriven<TEntity extends object> extends OIMCollectionStore<TEntity, TOIMKeyPath> {
-    readonly keyDomain: IOIMKeyDomain<TOIMKeyPath>;
     protected readonly slots: OIMTrieMap<TOIMPk, TOIMEntitySlot<TEntity, TOIMKeyPath>>;
     protected readonly reservedSlots: OIMTrieMap<TOIMPk, TOIMEntitySlot<TEntity, TOIMKeyPath>>;
-    constructor(keyDomain?: OIMKeyDomainTrie);
     setOneByPk(pk: TOIMKeyPath, entity: TEntity): TOIMEntitySlot<TEntity, TOIMKeyPath>;
     getOrReserveSlotByPk(pk: TOIMKeyPath): TOIMEntitySlot<TEntity, TOIMKeyPath>;
     setManyByPks(pks: readonly TOIMKeyPath[], entities: TEntity[]): TOIMEntitySlot<TEntity, TOIMKeyPath>[];
@@ -2058,7 +2011,7 @@ declare class OIMIndexStoreTrieDrivenArrayBased<TPk extends TOIMKey> extends OIM
 }
 
 /**
- * Composite-key counterpart of `OIMKeyedCarrierResolver`: backs the index keyed
+ * Composite-key counterpart of `OIMKeyedCarrierProvider`: backs the index keyed
  * emitter for key paths. Maps each key path to a carrier holding that path's
  * subscribers + dirty flag, via a trie (`OIMTrieMap`) so a freshly built
  * `[a, b, c]` resolves to the same carrier as the one subscribed earlier.
@@ -2067,7 +2020,7 @@ declare class OIMIndexStoreTrieDrivenArrayBased<TPk extends TOIMKey> extends OIM
  * when their last subscriber leaves (`onCarrierEmptied`) — the trie drops the
  * empty branch, so a churning key-path space does not leak carriers.
  */
-declare class OIMKeyPathCarrierResolver implements IOIMCarrierResolver<TOIMKeyPath, IOIMKeyCarrier<TOIMKeyPath>> {
+declare class OIMKeyPathCarrierProvider implements IOIMCarrierProvider<TOIMKeyPath, IOIMKeyCarrier<TOIMKeyPath>> {
     private readonly carriers;
     getOrReserveCarrier(key: TOIMKeyPath): IOIMKeyCarrier<TOIMKeyPath>;
     findCarrier(key: TOIMKeyPath): IOIMKeyCarrier<TOIMKeyPath> | undefined;
@@ -2075,7 +2028,7 @@ declare class OIMKeyPathCarrierResolver implements IOIMCarrierResolver<TOIMKeyPa
 }
 
 /**
- * The bucket-lifecycle surface a carrier resolver needs from an index store —
+ * The bucket-lifecycle surface a carrier provider needs from an index store —
  * implemented by both the set-based and array-based stores. `getOrReserveBucket`
  * creates a reserved (empty) bucket so a subscription can exist before its data;
  * `dropIfReserved` prunes such a bucket once its last subscriber leaves.
@@ -2087,7 +2040,7 @@ interface IOIMCarrierBucketStore<TKey extends TOIMKey, TBucket extends IOIMSubsc
 }
 /**
  * Resolves an index key to its carrier — where the carrier IS the index bucket,
- * owned by the store. Mirrors the collection's slot-based resolver: subscribers
+ * owned by the store. Mirrors the collection's slot-based provider: subscribers
  * live on the bucket, so on a write the reactive index marks the bucket it just
  * touched in O(1) with no key→carrier map/trie. Works uniformly for primitive
  * (Map) and composite (trie) stores, and for set- and array-based buckets.
@@ -2096,9 +2049,9 @@ interface IOIMCarrierBucketStore<TKey extends TOIMKey, TBucket extends IOIMSubsc
  * exist before its data; `onCarrierEmptied` drops such a bucket once its last
  * subscriber leaves and it holds no slots.
  */
-declare class OIMBucketCarrierResolver<TKey extends TOIMKey, TBucket extends IOIMSubscribable & {
+declare class OIMBucketCarrierProvider<TKey extends TOIMKey, TBucket extends IOIMSubscribable & {
     readonly key: TKey;
-}> implements IOIMCarrierResolver<TKey, TBucket> {
+}> implements IOIMCarrierProvider<TKey, TBucket> {
     private readonly store;
     constructor(store: IOIMCarrierBucketStore<TKey, TBucket>);
     getOrReserveCarrier(key: TKey): TBucket;
@@ -2146,7 +2099,7 @@ declare function createMergeEntityUpdater<TEntity extends object>(): TOIMEntityU
 /**
  * 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
+ * delivering — needs no provider, 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
@@ -2280,6 +2233,21 @@ declare class OIMDisposeScope implements IOIMDisposable {
 }
 declare function createOIMDisposeScope(): OIMDisposeScope;
 
+/**
+ * The Set surface the PK / index-key axis needs, abstracted so the concrete
+ * keying strategy is pluggable. A native `Set` satisfies this interface
+ * structurally (primitive default is a plain `Set`, zero wrapper); a composite
+ * key uses a trie-backed implementation matching array keys by content.
+ */
+interface IOIMKeyedSet<TKey> {
+    add(key: TKey): void;
+    has(key: TKey): boolean;
+    delete(key: TKey): boolean;
+    readonly size: number;
+    values(): IterableIterator<TKey>;
+    clear(): void;
+}
+
 /**
  * Trie-backed Set of composite key paths — the `Set` counterpart of
  * `OIMTrieMap`. Membership is by content, so a freshly built `[a, b]` is the
@@ -2296,24 +2264,12 @@ declare class OIMTrieSet implements IOIMKeyedSet<TOIMKeyPath> {
     clear(): void;
 }
 
-/**
- * Default key domain for primitive keys (`string | number`): plain native
- * `Map`/`Set` and identity `canonicalize`. A native `Map`/`Set` structurally
- * satisfies `IOIMKeyedMap`/`IOIMKeyedSet`, so there is no wrapper and no
- * indirection — the hot path is byte-for-byte what it was before the seam.
- */
-declare class OIMKeyDomainNative<TKey extends TOIMKey> implements IOIMKeyDomain<TKey> {
-    createMap<TValue>(): IOIMKeyedMap<TKey, TValue>;
-    createSet(): IOIMKeyedSet<TKey>;
-    canonicalize(key: TKey): TKey;
-}
-
 /**
  * Projects a PK to/from a string, for the serialization boundaries that can only
  * key state by a string: the Redux adapter (state object keyed by id), persist
  * storage, JSON snapshots. In-memory core never needs this — it keys PKs by
- * content via `IOIMKeyDomain` — but a composite PK path cannot be a string key,
- * so those boundaries require a codec.
+ * content via a trie — but a composite PK path cannot be a string key, so those
+ * boundaries require a codec.
  *
  * There is intentionally NO default codec for composite keys: a hidden
  * `JSON.stringify` would silently couple correctness to key order / escaping.
@@ -2954,6 +2910,18 @@ declare enum EOIMIndexEventType {
     UPDATE = 0
 }
 
+declare enum EOIMEventQueueEventType {
+    AFTER_FLUSH = 0,
+    BEFORE_FLUSH = 1,
+    /**
+     * A task threw during flush. Emitted once per failing task, ALWAYS (whether
+     * or not an `onError` handler is installed) — an observation channel for
+     * tooling (devtools / MCP). It does not replace the error being raised: with
+     * no `onError` handler the error still propagates out of `flush()`.
+     */
+    FLUSH_ERROR = 2
+}
+
 declare enum EOIMObjectEventType {
     UPDATE = 0
 }
@@ -3073,18 +3041,22 @@ declare class OIMEffect {
     private readonly onAfterFlush;
 }
 
+/**
+ * Depends on updates to ONE key of a keyed source. The key argument is the whole
+ * key — a composite key `[a, b]` is one key, never split — so there is no
+ * `key | key[]` ambiguity to guess at. To depend on several keys, use several
+ * dependencies (an effect already takes a `deps` array).
+ */
 declare class OIMEffectDependencyKeyed<TKey extends TOIMKey> implements IOIMEffectDependency {
     readonly source: IOIMKeyedSubscription<TKey>;
     private readonly key;
-    private readonly keys;
-    constructor(source: IOIMKeyedSubscription<TKey>, keyOrKeys: TKey | readonly TKey[]);
+    constructor(source: IOIMKeyedSubscription<TKey>, key: TKey);
     subscribe(onUpdate: () => void): () => void;
 }
 
 declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implements IOIMEffectDependency {
     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;
 }
@@ -3092,7 +3064,6 @@ declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implem
 declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMKey> implements IOIMEffectDependency {
     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;
 }
@@ -3100,7 +3071,6 @@ declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk ext
 declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMKey> implements IOIMEffectDependency {
     private readonly dep;
     constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
-    constructor(index: IOIMKeyedSubscription<TKey>, keys: readonly TKey[]);
     get source(): IOIMKeyedSubscription<TKey>;
     subscribe(onUpdate: () => void): () => void;
 }
@@ -3216,4 +3186,4 @@ declare class OIMEntitiesByGlobalIndexArrayBasedSelector<TEntity extends object,
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierBucketStore, type IOIMCarrierResolver, type IOIMComputedEventSource, type IOIMDisposable, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMGlobalIndexSlotSource, type IOIMIndexSlotSource, type IOIMIndexStore, type IOIMKeyDomain, type IOIMKeyedMap, type IOIMKeyedSet, type IOIMKeyedUpdateEmitter, type IOIMOrderedListCommandSource, type IOIMPkCodec, type IOIMSingleUpdateEmitter, type IOIMSubscribable, type IOIMSubscription, OIMBucketCarrierResolver, OIMCarrierKeyedEmitter, OIMCarrierSingleEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMCollectionStoreTrieDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionGlobalIndexArrayBased, OIMDerivedCollectionGlobalIndexSetBased, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMDisposeScope, 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, OIMGlobalIndexSlotMap, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexSlotMap, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMIndexStoreTrieDrivenArrayBased, OIMIndexStoreTrieDrivenSetBased, OIMKeyDomainNative, OIMKeyDomainTrie, OIMKeyPathCarrierResolver, OIMKeyedBucketArrayBased, OIMKeyedBucketSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandBuffer, OIMOrderedListCommandStream, OIMOrderedListCommandStreamDiffDriven, OIMOrderedListMappedCommandStream, OIMPkCodecKeyPath, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionGlobalIndexManualArrayBased, OIMReactiveCollectionGlobalIndexManualSetBased, OIMReactiveCollectionIndexCompositeTrieArrayBased, OIMReactiveCollectionIndexCompositeTrieSetBased, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveGlobalIndex, OIMReactiveGlobalIndexArrayBased, OIMReactiveGlobalIndexManualArrayBased, OIMReactiveGlobalIndexManualSetBased, OIMReactiveGlobalIndexSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, OIMTrieMap, OIMTrieSet, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionGlobalIndexArrayBasedOptions, type TOIMCollectionGlobalIndexSetBasedOptions, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexCompositeArrayBasedOptions, type TOIMCollectionIndexCompositeSetBasedOptions, 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 TOIMDisposable, 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 TOIMKey, type TOIMKeyPath, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMOrderedListDiffOptions, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsCompositeArrayIndexOptions, type TOIMRelationsCompositeSetIndexOptions, 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, createOIMDisposeScope, createOIMGlobalIndexSlotMap, createOIMIndexSlotMap, createOIMOrderedListCommandStreamDiffDriven, createOIMOrderedListMappedCommandStream, diffOrderedListByPk };
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierBucketStore, type IOIMCarrierProvider, type IOIMComputedEventSource, type IOIMDisposable, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMGlobalIndexSlotSource, type IOIMIndexSlotSource, type IOIMIndexStore, type IOIMKeyedMap, type IOIMKeyedSet, type IOIMKeyedUpdateEmitter, type IOIMOrderedListCommandSource, type IOIMPkCodec, type IOIMSingleUpdateEmitter, type IOIMSubscribable, type IOIMSubscription, OIMBucketCarrierProvider, OIMCarrierKeyedEmitter, OIMCarrierSingleEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMCollectionStoreTrieDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionGlobalIndexArrayBased, OIMDerivedCollectionGlobalIndexSetBased, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMDisposeScope, 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, OIMGlobalIndexSlotMap, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexSlotMap, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMIndexStoreTrieDrivenArrayBased, OIMIndexStoreTrieDrivenSetBased, OIMKeyPathCarrierProvider, OIMKeyedBucketArrayBased, OIMKeyedBucketSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandBuffer, OIMOrderedListCommandStream, OIMOrderedListCommandStreamDiffDriven, OIMOrderedListMappedCommandStream, OIMPkCodecKeyPath, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionGlobalIndexManualArrayBased, OIMReactiveCollectionGlobalIndexManualSetBased, OIMReactiveCollectionIndexCompositeTrieArrayBased, OIMReactiveCollectionIndexCompositeTrieSetBased, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveGlobalIndex, OIMReactiveGlobalIndexArrayBased, OIMReactiveGlobalIndexManualArrayBased, OIMReactiveGlobalIndexManualSetBased, OIMReactiveGlobalIndexSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, OIMTrieMap, OIMTrieSet, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionGlobalIndexArrayBasedOptions, type TOIMCollectionGlobalIndexSetBasedOptions, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexCompositeArrayBasedOptions, type TOIMCollectionIndexCompositeSetBasedOptions, 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 TOIMDisposable, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotGetter, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMFlushError, type TOIMGlobalIndexFilter, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMKey, type TOIMKeyPath, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMOrderedListDiffOptions, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsCompositeArrayIndexOptions, type TOIMRelationsCompositeSetIndexOptions, 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, createOIMDisposeScope, createOIMGlobalIndexSlotMap, createOIMIndexSlotMap, createOIMOrderedListCommandStreamDiffDriven, createOIMOrderedListMappedCommandStream, diffOrderedListByPk };