@oimdb/core 3.6.0 → 3.8.0

package/dist/index.d.cts

@@ -1,6 +1,33 @@
 type TOIMPk = string | number;
 
-type TOIMEntitySlot<TEntity extends object, TPk extends TOIMPk> = {
+/**
+ * A composite index key: an ordered, arbitrary-length tuple of primitive
+ * segments. Unlike a stringified `"a|b|c"` key it keeps each segment's own
+ * type and identity (so `1` and `"1"` stay distinct and no separator can
+ * collide), and unlike a native object/array Map key it is matched by content,
+ * not reference — a freshly built `[a, b, c]` resolves to the same bucket as a
+ * previously stored `[a, b, c]`.
+ *
+ * Backed at runtime by a trie (`OIMTrieMap`): lookup walks one native-Map level
+ * per segment, so it is O(arity) — effectively O(1) for a fixed arity — and
+ * never allocates or hashes a string key.
+ */
+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
+ * (`TOIMKeyPath`).
+ *
+ * It exists purely to widen the generic bound from `TOIMPk` to also admit
+ * `TOIMKeyPath`, so the composite (trie-backed) index can reuse the exact same
+ * emitter / reactive-index machinery. It is a compile-time bound only — nothing
+ * branches on it at runtime, and primitive-keyed nodes keep their native-Map
+ * fast path untouched.
+ */
+type TOIMKey = TOIMPk | TOIMKeyPath;
+
+type TOIMEntitySlot<TEntity extends object, TPk extends TOIMKey> = {
     pk: TPk;
     item: TEntity | undefined;
     /**
@@ -11,10 +38,73 @@ type TOIMEntitySlot<TEntity extends object, TPk extends TOIMPk> = {
      */
     subscribers?: Set<() => void>;
 };
-type TOIMAnyEntitySlot<TPk extends TOIMPk> = TOIMEntitySlot<object, TPk>;
-type TOIMEntitySlotResolver<TPk extends TOIMPk> = (pk: TPk) => TOIMAnyEntitySlot<TPk> | undefined;
+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;
+}
 
-declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TOIMPk> {
+/**
+ * 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;
+}
+
+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;
     /**
@@ -70,7 +160,7 @@ interface TOIMIndexUpdatePayload<TKey> {
 /**
  * Comparator function for index primary key arrays.
  * Returns true if the arrays are considered equal, false if they differ. */
-type TOIMIndexComparator<TPk extends TOIMPk> = (existingPks: readonly TPk[], newPks: readonly TPk[]) => boolean;
+type TOIMIndexComparator<TPk extends TOIMKey> = (existingPks: readonly TPk[], newPks: readonly TPk[]) => boolean;
 
 interface IOIMIndexStore<TKey, TBucket> {
     setOneByKey(key: TKey, bucket: TBucket): void;
@@ -83,7 +173,7 @@ interface IOIMIndexStore<TKey, TBucket> {
     countAll(): number;
     clear(): void;
 }
-declare abstract class OIMIndex<TKey extends TOIMPk, TPk extends TOIMPk, TBucket extends Iterable<TOIMAnyEntitySlot<TPk>>> {
+declare abstract class OIMIndex<TKey extends TOIMKey, TPk extends TOIMKey, TBucket extends Iterable<TOIMAnyEntitySlot<TPk>>> {
     protected readonly comparePks?: TOIMIndexComparator<TPk>;
     protected readonly store: IOIMIndexStore<TKey, TBucket>;
     readonly emitter: OIMEventEmitter<{
@@ -119,28 +209,112 @@ declare abstract class OIMIndex<TKey extends TOIMPk, TPk extends TOIMPk, TBucket
     protected slotsToEntities<TEntity extends object>(slots: Iterable<TOIMAnyEntitySlot<TPk>>): (TEntity | undefined)[];
 }
 
-declare abstract class OIMIndexStoreSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
+/**
+ * A carrier that can hold per-key subscribers directly on itself, so the keyed
+ * emitter delivers without a per-key map lookup. Implemented by the entity slot
+ * (collection carrier) and the index bucket (index carrier).
+ */
+interface IOIMSubscribable {
+    subscribers?: Set<() => void>;
+    /**
+     * Dirty-batch membership flag, owned by the keyed emitter. `true` while the
+     * carrier sits in the pending flush batch — lets the emitter dedup marks with
+     * an O(1) boolean check instead of a `Set` identity-hash lookup. Reset to
+     * `false` as the carrier is delivered (or on flush teardown). Do not read or
+     * write outside the emitter.
+     */
+    dirty?: boolean;
+}
+
+/**
+ * A set-based index bucket that is ALSO its own subscription carrier AND holds
+ * its own pk→slot membership.
+ *
+ * It extends `Set<slot>`, so every reader that treats a bucket as a `Set`
+ * (iteration, `size`, `has`, `add`, `delete`) is unchanged — a `Set` subclass is
+ * a `Set`. On top of that:
+ *  - it carries `subscribers` + `dirty` (`IOIMSubscribable`) and its own `key`,
+ *    so the keyed emitter delivers straight off the bucket the writer already
+ *    holds — O(1), no key→carrier map/trie (bucket-as-carrier);
+ *  - it carries an optional `membership` (pk → slot) so pk-oriented writes
+ *    (`setPks`/`addPks`/`removePks`) dedup and remove by pk WITHOUT a second
+ *    key-indexed structure. One `getOrReserveBucket` walk now serves both the
+ *    slots and the membership — halving the trie walks for a composite key.
+ */
+declare class OIMKeyedBucketSetBased<TKey extends TOIMKey, TPk extends TOIMKey> extends Set<TOIMAnyEntitySlot<TPk>> implements IOIMSubscribable {
+    readonly key: TKey;
+    subscribers?: Set<() => void>;
+    dirty?: boolean;
+    membership?: IOIMKeyedMap<TPk, TOIMAnyEntitySlot<TPk>>;
+    constructor(key: TKey);
+    hasSubscribers(): boolean;
+    /** Clearing the slot set also clears the pk membership — they stay in sync. */
+    clear(): void;
+}
+
+declare abstract class OIMIndexStoreSetBased<TKey extends TOIMKey, TPk extends TOIMKey> {
     abstract setOneByKey(key: TKey, slots: Set<TOIMAnyEntitySlot<TPk>>): void;
     abstract removeOneByKey(key: TKey): void;
     abstract removeManyByKeys(keys: readonly TKey[]): void;
+    /** The live bucket for `key` (undefined if none / empty-reserved). */
     abstract getOneByKey(key: TKey): Set<TOIMAnyEntitySlot<TPk>> | undefined;
     abstract getManyByKeys(keys: readonly TKey[]): Map<TKey, Set<TOIMAnyEntitySlot<TPk>>>;
     abstract getAllKeys(): TKey[];
     abstract getAll(): Map<TKey, Set<TOIMAnyEntitySlot<TPk>>>;
     abstract countAll(): number;
     abstract clear(): void;
+    /** Bucket for `key` (live or reserved), creating a reserved empty one if none. */
+    abstract getOrReserveBucket(key: TKey): OIMKeyedBucketSetBased<TKey, TPk>;
+    /** Existing bucket (live or reserved) without creating one — for delivery. */
+    abstract findBucket(key: TKey): OIMKeyedBucketSetBased<TKey, TPk> | undefined;
+    /** Promote a now-non-empty bucket into the live set. */
+    abstract retainBucket(bucket: OIMKeyedBucketSetBased<TKey, TPk>): void;
+    /** A now-empty bucket: keep it (reserved) if subscribed, else drop it. */
+    abstract releaseBucket(bucket: OIMKeyedBucketSetBased<TKey, TPk>): void;
+    /** Last subscriber left: drop the key's bucket if it is empty & unsubscribed. */
+    abstract dropIfReserved(key: TKey): void;
 }
 
-declare abstract class OIMIndexStoreArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> {
+/**
+ * An array-based (ordered) index bucket that is ALSO its own subscription
+ * carrier — the array counterpart of `OIMKeyedBucketSetBased`.
+ *
+ * It extends `Array<slot>`, so every reader that treats a bucket as an ordered
+ * slot array (iteration, `length`, index access, `push`, `filter`) is unchanged.
+ * On top of that it carries `subscribers` + `dirty` (`IOIMSubscribable`) and its
+ * own `key`, so the keyed emitter delivers straight off the bucket the writer
+ * already holds (O(1), no key→carrier lookup).
+ *
+ * `Symbol.species` is `Array`, so derived arrays (`filter`/`slice`/`map`) are
+ * plain arrays — never stray carrier buckets.
+ */
+declare class OIMKeyedBucketArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> extends Array<TOIMAnyEntitySlot<TPk>> implements IOIMSubscribable {
+    readonly key: TKey;
+    subscribers?: Set<() => void>;
+    dirty?: boolean;
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(key: TKey);
+    hasSubscribers(): boolean;
+    /** Empty the bucket in place (Array has no `clear`). */
+    clear(): void;
+}
+
+declare abstract class OIMIndexStoreArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> {
     abstract setOneByKey(key: TKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
     abstract removeOneByKey(key: TKey): void;
     abstract removeManyByKeys(keys: readonly TKey[]): void;
+    /** The live bucket for `key` (undefined if none / empty-reserved). */
     abstract getOneByKey(key: TKey): TOIMAnyEntitySlot<TPk>[] | undefined;
     abstract getManyByKeys(keys: readonly TKey[]): Map<TKey, TOIMAnyEntitySlot<TPk>[]>;
     abstract getAllKeys(): TKey[];
     abstract getAll(): Map<TKey, TOIMAnyEntitySlot<TPk>[]>;
     abstract countAll(): number;
     abstract clear(): void;
+    abstract getOrReserveBucket(key: TKey): OIMKeyedBucketArrayBased<TKey, TPk>;
+    abstract findBucket(key: TKey): OIMKeyedBucketArrayBased<TKey, TPk> | undefined;
+    abstract retainBucket(bucket: OIMKeyedBucketArrayBased<TKey, TPk>): void;
+    abstract releaseBucket(bucket: OIMKeyedBucketArrayBased<TKey, TPk>): void;
+    abstract dropIfReserved(key: TKey): void;
 }
 
 declare enum EOIMEventQueueSchedulerEventType {
@@ -169,7 +343,12 @@ declare abstract class OIMEventQueueScheduler {
     protected flush(): void;
 }
 
-declare abstract class OIMIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndex<TKey, TPk, Set<TOIMAnyEntitySlot<TPk>>> {
+declare abstract class OIMIndexSetBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndex<TKey, TPk, Set<TOIMAnyEntitySlot<TPk>>> {
+    /**
+     * The same store as the base `store`, narrowed to the set-based contract so
+     * the carrier-bucket lifecycle methods (`getOrReserveBucket`, …) are visible.
+     */
+    protected readonly setStore: OIMIndexStoreSetBased<TKey, TPk>;
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TKey, TPk>;
@@ -180,10 +359,16 @@ declare abstract class OIMIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk>
     getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, ReadonlySet<TOIMAnyEntitySlot<TPk>>>;
     protected slotsToPks(slots: Iterable<TOIMAnyEntitySlot<TPk>>): Set<TPk>;
-    protected setSlotsWithComparison(key: TKey, newSlots: Set<TOIMAnyEntitySlot<TPk>>): boolean;
+    /**
+     * True if a comparator is set and considers `bucket`'s current pks equal to
+     * `newSlots` — i.e. a `setSlots` would be a no-op and should not emit.
+     */
+    protected bucketMatchesComparator(bucket: ReadonlySet<TOIMAnyEntitySlot<TPk>>, newSlots: ReadonlySet<TOIMAnyEntitySlot<TPk>>): boolean;
 }
 
-declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndex<TKey, TPk, TOIMAnyEntitySlot<TPk>[]> {
+declare abstract class OIMIndexArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndex<TKey, TPk, TOIMAnyEntitySlot<TPk>[]> {
+    /** The same store as `store`, narrowed to expose the carrier-bucket lifecycle. */
+    protected readonly arrayStore: OIMIndexStoreArrayBased<TKey, TPk>;
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreArrayBased<TKey, TPk>;
@@ -194,7 +379,11 @@ declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMP
     getSlotsByKey(key: TKey): readonly TOIMAnyEntitySlot<TPk>[];
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, readonly TOIMAnyEntitySlot<TPk>[]>;
     protected slotsToPks(slots: readonly TOIMAnyEntitySlot<TPk>[]): TPk[];
-    protected setSlotsWithComparison(key: TKey, newSlots: TOIMAnyEntitySlot<TPk>[]): boolean;
+    /**
+     * True if a comparator is set and considers `bucket`'s pks equal to
+     * `newSlots` — i.e. a `setSlots` would be a no-op and should not emit.
+     */
+    protected bucketMatchesComparator(bucket: readonly TOIMAnyEntitySlot<TPk>[], newSlots: readonly TOIMAnyEntitySlot<TPk>[]): boolean;
 }
 
 /**
@@ -206,13 +395,18 @@ declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMP
  * against this interface lets either back the node without leaking the carrier
  * generic into the node's signatures.
  */
-interface IOIMKeyedUpdateEmitter<TKey extends TOIMPk> {
+interface IOIMKeyedUpdateEmitter<TKey extends TOIMKey> {
     subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
     unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
     unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
     markUpdatedKey(key: TKey): void;
     markUpdatedKeys(keys: readonly TKey[]): void;
+    /**
+     * Fast path: mark a carrier the writer already holds (an entity slot or an
+     * index bucket), skipping the key→carrier lookup entirely. O(1).
+     */
+    markUpdatedCarrier(carrier: IOIMSubscribable): void;
     hasSubscriptions(): boolean;
     getHandlerCount(key: TKey): number;
     getMetrics(): {
@@ -289,15 +483,97 @@ declare class OIMEventQueue {
     destroy(): void;
 }
 
-interface IOIMKeyedSubscription<TKey extends TOIMPk> {
+/**
+ * Resolves a key to its carrier — the object that holds the key's subscribers.
+ * `getOrReserveCarrier` is used on subscribe (creates the carrier if absent so a
+ * subscription can exist before its data); `findCarrier` resolves an existing
+ * carrier for delivery/unsubscribe without creating one.
+ *
+ * Collection carrier = the entity slot (by pk); index carrier = the bucket
+ * (by index key).
+ */
+interface IOIMCarrierResolver<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
+     * 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
+     * elsewhere (e.g. the collection's slots) leave this unset.
+     */
+    onCarrierEmptied?(carrier: TCarrier): void;
+}
+/**
+ * Keyed (per-key) pub/sub that stores handlers ON the carrier object
+ * (`carrier.subscribers`) instead of a `Map<key, handlers>`. The hot path —
+ * marking a written carrier dirty and delivering — needs no per-key map lookup
+ * or hashing: the writer already holds the carrier.
+ *
+ * Same public surface as `OIMUpdateEventEmitter` (queue delivery) plus a fast
+ * `markUpdatedCarrier(carrier)`, so it is a drop-in for the collection's and
+ * index's keyed emitter. Reused with carrier = slot (collection) or carrier =
+ * bucket (index).
+ */
+declare class OIMCarrierKeyedEmitter<TKey extends TOIMKey, TCarrier extends IOIMSubscribable> implements IOIMKeyedUpdateEmitter<TKey> {
+    private readonly queue;
+    private readonly resolver;
+    private readonly subscribedCarriers;
+    private dirtyCarriers;
+    private isFlushEnqueued;
+    constructor(queue: OIMEventQueue, resolver: IOIMCarrierResolver<TKey, TCarrier>);
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
+    private addHandler;
+    private removeHandler;
+    /** Fast path: the writer already holds the carrier. */
+    markUpdatedCarrier(carrier: TCarrier): void;
+    markUpdatedKey(key: TKey): void;
+    markUpdatedKeys(keys: readonly TKey[]): void;
+    markAllUpdated(): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(key: TKey): number;
+    getMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
+    destroy(): void;
+    private assertNotInFlush;
+    private scheduleFlush;
+    private readonly onFlush;
+    private notify;
+}
+
+/**
+ * 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
+ * prune it from the key→carrier map when its last subscriber leaves.
+ */
+interface IOIMKeyCarrier<TKey extends TOIMKey> extends IOIMSubscribable {
+    key: TKey;
+}
+
+interface IOIMKeyedSubscription<TKey extends TOIMKey> {
     subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
 }
 
-declare abstract class OIMReactiveIndex<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndex<TKey, TPk, Iterable<TOIMAnyEntitySlot<TPk>>>> implements IOIMKeyedSubscription<TKey> {
+declare abstract class OIMReactiveIndex<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndex<TKey, TPk, Iterable<TOIMAnyEntitySlot<TPk>>>> implements IOIMKeyedSubscription<TKey> {
     readonly index: TIndex;
     protected readonly updateEmitter: IOIMKeyedUpdateEmitter<TKey>;
-    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex);
+    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
+     * index (its fast path is unchanged). A composite (trie-backed) index
+     * passes a resolver that keys carriers by key path instead. Called once
+     * at construction — no per-operation cost.
+     */
+    createResolver?: () => IOIMCarrierResolver<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;
@@ -327,16 +603,16 @@ declare abstract class OIMReactiveIndex<TKey extends TOIMPk, TPk extends TOIMPk,
     destroy(): void;
 }
 
-declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
-    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex);
+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>>);
     getPksByKey(key: TKey): Set<TPk>;
     getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
     getSlotsByKey(key: TKey): ReadonlySet<TOIMAnyEntitySlot<TPk>>;
     getSlotsByKeys(keys: readonly TKey[]): Map<TKey, ReadonlySet<TOIMAnyEntitySlot<TPk>>>;
 }
 
-declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMReactiveIndex<TKey, TPk, TIndex> {
-    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMKeyedUpdateEmitter<TKey>) => TIndex);
+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>>);
     getPksByKey(key: TKey): TPk[];
     getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
     getSlotsByKey(key: TKey): readonly TOIMAnyEntitySlot<TPk>[];
@@ -364,7 +640,7 @@ declare abstract class OIMObjectStore<TKey extends string | number | symbol, TVa
  * 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> {
+declare abstract class OIMGlobalIndex<TPk extends TOIMKey> {
     protected readonly comparePks?: TOIMIndexComparator<TPk>;
     readonly emitter: OIMEventEmitter<{
         0: void;
@@ -392,7 +668,7 @@ declare abstract class OIMGlobalIndex<TPk extends TOIMPk> {
  * bucket over the whole collection. Mirrors {@link OIMIndexSetBased} minus the
  * key.
  */
-declare abstract class OIMGlobalIndexSetBased<TPk extends TOIMPk> extends OIMGlobalIndex<TPk> {
+declare abstract class OIMGlobalIndexSetBased<TPk extends TOIMKey> extends OIMGlobalIndex<TPk> {
     protected slots: Set<TOIMAnyEntitySlot<TPk>>;
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
@@ -410,7 +686,7 @@ declare abstract class OIMGlobalIndexSetBased<TPk extends TOIMPk> extends OIMGlo
  * 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> {
+declare abstract class OIMGlobalIndexArrayBased<TPk extends TOIMKey> extends OIMGlobalIndex<TPk> {
     protected slots: TOIMAnyEntitySlot<TPk>[];
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
@@ -451,7 +727,7 @@ interface IOIMSingleUpdateEmitter extends IOIMSubscription {
  * and directly satisfies `IOIMSelectorSourceDependency`. Mirrors
  * {@link OIMReactiveIndex} minus the key.
  */
-declare abstract class OIMReactiveGlobalIndex<TPk extends TOIMPk, TIndex extends OIMGlobalIndex<TPk>> implements IOIMSubscription {
+declare abstract class OIMReactiveGlobalIndex<TPk extends TOIMKey, TIndex extends OIMGlobalIndex<TPk>> implements IOIMSubscription {
     readonly index: TIndex;
     protected readonly updateEmitter: IOIMSingleUpdateEmitter;
     constructor(queue: OIMEventQueue, createIndex: (updateEmitter: IOIMSingleUpdateEmitter) => TIndex);
@@ -466,40 +742,47 @@ declare abstract class OIMReactiveGlobalIndex<TPk extends TOIMPk, TIndex extends
     destroy(): void;
 }
 
-declare abstract class OIMReactiveGlobalIndexSetBased<TPk extends TOIMPk, TIndex extends OIMGlobalIndexSetBased<TPk>> extends OIMReactiveGlobalIndex<TPk, TIndex> {
+declare abstract class OIMReactiveGlobalIndexSetBased<TPk extends TOIMKey, 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> {
+declare abstract class OIMReactiveGlobalIndexArrayBased<TPk extends TOIMKey, 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 TOIMPkSelector<TEntity extends object, TPk extends TOIMKey> = (entity: TEntity) => TPk;
 
 type TOIMEntityUpdater<TEntity extends object> = (draft: Partial<TEntity>, prevEntity: TEntity) => TEntity;
 
-type TOIMCollectionOptions<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMCollectionOptions<TEntity extends object, TPk extends TOIMKey> = {
     selectPk?: TOIMPkSelector<TEntity, TPk>;
+    /**
+     * Backing store. Defaults to `OIMCollectionStoreMapDriven` (native-`Map`,
+     * primitive PKs). For a composite PK path, pass
+     * `new OIMCollectionStoreTrieDriven()`.
+     */
     store?: OIMCollectionStore<TEntity, TPk>;
     updateEntity?: TOIMEntityUpdater<TEntity>;
 };
 
-type TOIMCollectionUpdatePayload<TPk extends TOIMPk> = {
+type TOIMCollectionUpdatePayload<TPk extends TOIMKey> = {
     pks: readonly TPk[];
 };
 
 /** It's like a store - but with event emitter */
-declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
+declare class OIMCollection<TEntity extends object, TPk extends TOIMKey> {
     readonly emitter: OIMEventEmitter<{
         0: TOIMCollectionUpdatePayload<TPk>;
     }>;
     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[];
@@ -523,92 +806,11 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     destroy(): void;
 }
 
-/**
- * A carrier that can hold per-key subscribers directly on itself, so the keyed
- * emitter delivers without a per-key map lookup. Implemented by the entity slot
- * (collection carrier) and the index bucket (index carrier).
- */
-interface IOIMSubscribable {
-    subscribers?: Set<() => void>;
-    /**
-     * Dirty-batch membership flag, owned by the keyed emitter. `true` while the
-     * carrier sits in the pending flush batch — lets the emitter dedup marks with
-     * an O(1) boolean check instead of a `Set` identity-hash lookup. Reset to
-     * `false` as the carrier is delivered (or on flush teardown). Do not read or
-     * write outside the emitter.
-     */
-    dirty?: boolean;
-}
-
-/**
- * Resolves a key to its carrier — the object that holds the key's subscribers.
- * `getOrReserveCarrier` is used on subscribe (creates the carrier if absent so a
- * subscription can exist before its data); `findCarrier` resolves an existing
- * carrier for delivery/unsubscribe without creating one.
- *
- * Collection carrier = the entity slot (by pk); index carrier = the bucket
- * (by index key).
- */
-interface IOIMCarrierResolver<TKey extends TOIMPk, TCarrier> {
-    getOrReserveCarrier(key: TKey): TCarrier;
-    findCarrier(key: TKey): TCarrier | undefined;
-    /**
-     * Optional: called when a carrier loses its last subscriber, so a resolver
-     * 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
-     * elsewhere (e.g. the collection's slots) leave this unset.
-     */
-    onCarrierEmptied?(carrier: TCarrier): void;
-}
-/**
- * Keyed (per-key) pub/sub that stores handlers ON the carrier object
- * (`carrier.subscribers`) instead of a `Map<key, handlers>`. The hot path —
- * marking a written carrier dirty and delivering — needs no per-key map lookup
- * or hashing: the writer already holds the carrier.
- *
- * Same public surface as `OIMUpdateEventEmitter` (queue delivery) plus a fast
- * `markUpdatedCarrier(carrier)`, so it is a drop-in for the collection's and
- * index's keyed emitter. Reused with carrier = slot (collection) or carrier =
- * bucket (index).
- */
-declare class OIMCarrierKeyedEmitter<TKey extends TOIMPk, TCarrier extends IOIMSubscribable> implements IOIMKeyedUpdateEmitter<TKey> {
-    private readonly queue;
-    private readonly resolver;
-    private readonly subscribedCarriers;
-    private dirtyCarriers;
-    private isFlushEnqueued;
-    constructor(queue: OIMEventQueue, resolver: IOIMCarrierResolver<TKey, TCarrier>);
-    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
-    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
-    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
-    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
-    private addHandler;
-    private removeHandler;
-    /** Fast path: the writer already holds the carrier. */
-    markUpdatedCarrier(carrier: TCarrier): void;
-    markUpdatedKey(key: TKey): void;
-    markUpdatedKeys(keys: readonly TKey[]): void;
-    markAllUpdated(): void;
-    hasSubscriptions(): boolean;
-    getHandlerCount(key: TKey): number;
-    getMetrics(): {
-        totalKeys: number;
-        totalHandlers: number;
-        averageHandlersPerKey: number;
-        queueLength: number;
-    };
-    destroy(): void;
-    private assertNotInFlush;
-    private scheduleFlush;
-    private readonly onFlush;
-    private notify;
-}
-
-declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk> extends OIMCollection<TEntity, TPk> implements IOIMKeyedSubscription<TPk> {
+declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMKey> extends OIMCollection<TEntity, TPk> implements IOIMKeyedSubscription<TPk> {
     private readonly queue;
     protected readonly updateEmitter: OIMCarrierKeyedEmitter<TPk, TOIMEntitySlot<TEntity, TPk>>;
     private readonly anyUpdateHandlers;
-    private pendingAnyUpdatePks;
+    private readonly pendingAnyUpdatePks;
     private isAnyUpdateClearPending;
     private isAnyUpdateScheduled;
     constructor(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>);
@@ -644,7 +846,7 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk>
     destroy(): void;
 }
 
-type TOIMCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TKey, TPk>;
@@ -656,7 +858,7 @@ type TOIMCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOI
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 });
-type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreArrayBased<TKey, TPk>;
@@ -668,14 +870,14 @@ type TOIMCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends T
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 });
-type TOIMCollectionOrderedIndexOptions<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMCollectionOrderedIndexOptions<TEntity extends object, TPk extends TOIMKey> = {
     collection: OIMReactiveCollection<TEntity, TPk>;
     resolveSlot?: never;
 } | {
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 };
-type TOIMCollectionOrderedListCommandStreamOptions<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object> = {
+type TOIMCollectionOrderedListCommandStreamOptions<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object> = {
     index?: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
 } & ({
     collection: OIMReactiveCollection<TEntity, TPk>;
@@ -684,23 +886,69 @@ type TOIMCollectionOrderedListCommandStreamOptions<TKey extends TOIMPk, TPk exte
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 });
-type TOIMRelationsSetIndexOptions<TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMRelationsSetIndexOptions<TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreSetBased<TKey, TPk>;
     };
 };
-type TOIMRelationsArrayIndexOptions<TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMRelationsArrayIndexOptions<TKey extends TOIMKey, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreArrayBased<TKey, TPk>;
     };
 };
-type TOIMRelationsOrderedListOptions<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object> = {
+/**
+ * Options for a composite (trie-backed) Set-based index. Its key is a
+ * `TOIMKeyPath` — an arbitrary-length tuple of primitive segments — looked up by
+ * content in O(arity). The store defaults to `OIMIndexStoreTrieDrivenSetBased`.
+ */
+type TOIMCollectionIndexCompositeSetBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreSetBased<TOIMKeyPath, TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMRelationsCompositeSetIndexOptions<TPk extends TOIMKey> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreSetBased<TOIMKeyPath, TPk>;
+    };
+};
+/**
+ * Options for a composite (trie-backed) Array-based (ordered) index. Its key is
+ * a `TOIMKeyPath`, looked up by content in O(arity). The store defaults to
+ * `OIMIndexStoreTrieDrivenArrayBased`.
+ */
+type TOIMCollectionIndexCompositeArrayBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreArrayBased<TOIMKeyPath, TPk>;
+    };
+} & ({
+    collection: OIMReactiveCollection<TEntity, TPk>;
+    resolveSlot?: never;
+} | {
+    collection?: never;
+    resolveSlot: TOIMEntitySlotResolver<TPk>;
+});
+type TOIMRelationsCompositeArrayIndexOptions<TPk extends TOIMKey> = {
+    indexOptions?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreArrayBased<TOIMKeyPath, TPk>;
+    };
+};
+type TOIMRelationsOrderedListOptions<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object> = {
     index?: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
 };
-type TOIMDerivedIndexKeySelector<TEntity extends object, TKey extends TOIMPk> = (entity: TEntity) => TKey | readonly TKey[] | undefined | null;
-type TOIMDerivedCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMDerivedIndexKeySelector<TEntity extends object, TKey extends TOIMKey> = (entity: TEntity) => TKey | readonly TKey[] | undefined | null;
+type TOIMDerivedCollectionIndexSetBasedOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = {
     selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>;
     /**
      * Build initial index state from existing collection slots.
@@ -709,11 +957,11 @@ type TOIMDerivedCollectionIndexSetBasedOptions<TEntity extends object, TKey exte
     buildInitial?: boolean;
     indexOptions?: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>['indexOptions'];
 };
-type TOIMRelationsDerivedSetIndexOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = Omit<TOIMDerivedCollectionIndexSetBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
+type TOIMRelationsDerivedSetIndexOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = Omit<TOIMDerivedCollectionIndexSetBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
 type TOIMDerivedEntityOrderValue = string | number | bigint | boolean;
 type TOIMDerivedEntityOrderSelector<TEntity extends object> = (entity: TEntity) => TOIMDerivedEntityOrderValue;
 type TOIMDerivedEntityComparator<TEntity extends object> = (a: TEntity, b: TEntity) => number;
-type TOIMDerivedCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMDerivedCollectionIndexArrayBasedOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = {
     selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>;
     /**
      * Build initial index state from existing collection slots.
@@ -730,7 +978,7 @@ type TOIMDerivedCollectionIndexArrayBasedOptions<TEntity extends object, TKey ex
     orderBy?: TOIMDerivedEntityOrderSelector<TEntity>;
     indexOptions?: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>['indexOptions'];
 };
-type TOIMRelationsDerivedArrayIndexOptions<TEntity extends object, TKey extends TOIMPk, TPk extends TOIMPk> = Omit<TOIMDerivedCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
+type TOIMRelationsDerivedArrayIndexOptions<TEntity extends object, TKey extends TOIMKey, TPk extends TOIMKey> = Omit<TOIMDerivedCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>, 'selectIndexKeys'>;
 
 /**
  * Manual ordered Array-based index.
@@ -743,9 +991,10 @@ type TOIMRelationsDerivedArrayIndexOptions<TEntity extends object, TKey extends
  *
  * 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.
+ * into position-addressed commands is the command stream's job. Mutations happen
+ * on the store's stable carrier bucket in place (via `arrayStore`).
  */
-declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexArrayBased<TKey, TPk> {
+declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndexArrayBased<TKey, TPk> {
     clear(key?: TKey): void;
     pushSlot(key: TKey, slot: TOIMAnyEntitySlot<TPk>): number;
     insertSlotAt(key: TKey, index: number, slot: TOIMAnyEntitySlot<TPk>): number;
@@ -765,7 +1014,6 @@ declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends T
      */
     moveRange(key: TKey, from: number, to: number, count: number): number;
     resetSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
-    private getOrCreateList;
 }
 
 /**
@@ -774,7 +1022,7 @@ declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends T
  * Raw ordered indexes store slots. This variant provides PK writes and resolves
  * them to canonical collection slots at construction-bound write time.
  */
-declare class OIMCollectionIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMIndexManualOrderedArrayBased<TKey, TPk> {
+declare class OIMCollectionIndexManualOrderedArrayBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMIndexManualOrderedArrayBased<TKey, TPk> {
     private readonly resolveSlot;
     constructor(opts: TOIMCollectionOrderedIndexOptions<TEntity, TPk>);
     push(key: TKey, pk: TPk): number;
@@ -792,7 +1040,7 @@ type TOIMUpdateEventEmitterDeliveryMode = 'queue' | 'after_flush' | 'immediate';
  * Universal event emitter that handles subscriptions and notifications for any key type.
  * Optimized for performance with adaptive algorithms and memory management.
  */
-declare class OIMUpdateEventEmitter<TKey extends TOIMPk> {
+declare class OIMUpdateEventEmitter<TKey extends TOIMKey> {
     protected keyHandlers: Map<TKey, Set<TOIMEventHandler<void>>>;
     protected queue: OIMEventQueue;
     private readonly deliveryMode;
@@ -895,7 +1143,7 @@ type TOIMOrderedListCommand<TItem> = {
  * payload, so `consumeCommands(key)` must be called inside the `handler`, before
  * the buffer for that key is cleared.
  */
-interface IOIMOrderedListCommandSource<TKey extends TOIMPk, TItem> {
+interface IOIMOrderedListCommandSource<TKey extends TOIMKey, TItem> {
     /**
      * Subscribe to per-key command notifications. The handler receives no
      * payload — pull the commands with {@link consumeCommands} synchronously.
@@ -924,7 +1172,7 @@ interface IOIMOrderedListCommandSource<TKey extends TOIMPk, TItem> {
  * 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> {
+declare abstract class OIMOrderedListCommandBuffer<TKey extends TOIMKey, TItem> implements IOIMOrderedListCommandSource<TKey, TItem> {
     readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
     private readonly unsubscribeAfterFlush;
     protected readonly commandsByKey: Map<TKey, TOIMOrderedListCommand<TItem>[]>;
@@ -955,7 +1203,7 @@ declare abstract class OIMOrderedListCommandBuffer<TKey extends TOIMPk, TItem> i
  * 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>> {
+declare class OIMOrderedListCommandStream<TKey extends TOIMKey, TPk extends TOIMKey, 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>);
@@ -990,7 +1238,7 @@ declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMP
  * 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> {
+declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMOrderedListCommandStream<TKey, TPk, TEntity> {
     readonly index: OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionOrderedListCommandStreamOptions<TKey, TPk, TEntity>);
     push(key: TKey, pk: TPk): void;
@@ -1004,28 +1252,37 @@ declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMPk, TPk ext
 }
 
 /**
- * Manual Array-based index that allows direct manipulation of key-to-primary-keys mappings.
- * Extends the abstract OIMIndexArrayBased with manual control methods and optional comparison.
+ * Manual Array-based (ordered) index with direct key→slots control.
+ *
+ * Buckets are stable carrier buckets owned by the store (`getOrReserveBucket`):
+ * a write mutates the SAME bucket in place and then calls `emitBucketChanged`,
+ * so the reactive subclass delivers straight off that bucket in O(1). Emptied
+ * buckets are released (kept only while subscribed).
  */
-declare class OIMIndexManualArrayBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexArrayBased<TIndexKey, TPk> {
+declare class OIMIndexManualArrayBased<TIndexKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndexArrayBased<TIndexKey, TPk> {
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
         store?: OIMIndexStoreArrayBased<TIndexKey, TPk>;
     });
     setSlots(key: TIndexKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
     /**
-     * Appends pre-deduplicated slots to a key's bucket IN PLACE (no copy of the
-     * existing bucket) and emits once. Callers own dedup (so this stays O(added),
-     * not O(bucket)); used by collection-bound indexes for fast `addPks`.
+     * Appends pre-deduplicated slots to a key's bucket IN PLACE and emits once.
+     * O(added); callers own dedup.
      */
     appendSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     /**
-     * Clear all primary keys for a specific index key, or all keys if no key specified
+     * Clear all primary keys for a specific index key, or all keys if none given.
      */
     clear(key?: TIndexKey): void;
+    /**
+     * Emit that a bucket changed. Base (non-reactive) path emits by key on the
+     * plain event emitter; the reactive subclass overrides this to mark the
+     * bucket carrier directly (O(1), no key→carrier lookup).
+     */
+    protected emitBucketChanged(bucket: OIMKeyedBucketArrayBased<TIndexKey, TPk>): void;
 }
 
-declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexArrayBased<TKey, TPk, OIMIndexManualArrayBased<TKey, TPk>> {
+declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMReactiveIndexArrayBased<TKey, TPk, OIMIndexManualArrayBased<TKey, TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
         indexOptions?: {
             comparePks?: TOIMIndexComparator<TPk>;
@@ -1043,8 +1300,9 @@ declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends
  * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
  * through the collection binding supplied at construction time.
  */
-declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualArrayBased<TKey, TPk> {
+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;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
     setPks(key: TKey, pks: readonly TPk[]): void;
@@ -1063,18 +1321,35 @@ declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMPk, TP
 }
 
 /**
- * Manual Set-based index that allows direct manipulation of key-to-primary-keys mappings.
- * Extends the abstract OIMIndexSetBased with manual control methods and optional comparison.
+ * Manual Set-based index with direct key→slots control.
+ *
+ * Buckets are stable carrier buckets owned by the store (`getOrReserveBucket`):
+ * a write mutates the SAME bucket in place and then calls `emitBucketChanged`,
+ * so the reactive subclass delivers straight off that bucket in O(1). Emptied
+ * buckets are released (kept only while subscribed); the store keeps a
+ * subscribed-but-empty bucket alive so a subscription survives a key going empty
+ * and re-filling.
  */
-declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexSetBased<TIndexKey, TPk> {
+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;
+    removePks(key: TIndexKey, pks: readonly TPk[]): void;
+    /**
+     * The bucket's pk → slot membership, lazily created and seeded from the
+     * bucket's current slots (so it stays correct even if slots were written
+     * through the lower-level `setSlots` path).
+     */
+    private membershipOf;
+    private replaceBucketContents;
     /**
-     * Adds slots to a key's bucket IN PLACE (no copy of the existing Set) and
-     * emits once. O(added). Used by collection-bound indexes for fast `addPks`.
+     * Adds slots to a key's bucket IN PLACE and emits once. O(added).
      */
     addSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     /**
@@ -1082,17 +1357,29 @@ declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMP
      */
     removeSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     /**
-     * Clear all primary keys for a specific index key, or all keys if no key specified
+     * Clear all primary keys for a specific index key, or all keys if none given.
      */
     clear(key?: TIndexKey): void;
+    /**
+     * Emit that a bucket changed. Base (non-reactive) path emits by key on the
+     * plain event emitter; the reactive subclass overrides this to mark the
+     * bucket carrier directly (O(1), no key→carrier lookup).
+     */
+    protected emitBucketChanged(bucket: OIMKeyedBucketSetBased<TIndexKey, TPk>): void;
 }
 
-declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexSetBased<TKey, TPk, OIMIndexManualSetBased<TKey, TPk>> {
+declare class OIMReactiveIndexManualSetBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMReactiveIndexSetBased<TKey, TPk, OIMIndexManualSetBased<TKey, TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
         indexOptions?: {
             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;
@@ -1104,23 +1391,74 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TO
  * Collection-bound reactive Set-based index.
  *
  * PK writes (`setPks`/`addPks`/`removePks`) resolve canonical entity slots
- * through the collection binding supplied at construction time.
+ * through the collection binding and delegate to the underlying index, which
+ * keeps each key's pk→slot membership ON the bucket itself — so a write touches
+ * the key's store bucket exactly once (no separate membership map/trie).
  */
-declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TKey, TPk> {
+declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TKey, TPk> {
     private readonly resolveSlot;
-    private readonly slotByPk;
+    private readonly resolveRequiredSlot;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>);
     setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
-    clear(key?: TKey): void;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): (TItem | undefined)[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
+}
+
+/**
+ * Collection-bound reactive Set-based index keyed by a composite key path
+ * (`TOIMKeyPath`) — an arbitrary-length tuple of primitive segments, e.g.
+ * `[userId, projectId, role]`.
+ *
+ * Composite counterpart of `OIMReactiveCollectionIndexManualSetBased`: same
+ * manual `setPks`/`addPks`/`removePks` surface and collection slot resolution,
+ * but every key is a path matched by content in O(arity). Because the pk→slot
+ * membership lives ON the store bucket (not a separate key-indexed structure), a
+ * pk-write walks the key-path trie exactly once — for both the bucket and its
+ * membership. The full path is the lookup unit (no partial/prefix queries);
+ * subscriptions deliver per full path off the bucket carrier.
+ *
+ * The primitive-keyed indexes are untouched and keep their native-`Map` fast
+ * 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;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexCompositeSetBasedOptions<TEntity, TPk>);
+    setPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    addPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    removePks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TOIMKeyPath): (TItem | undefined)[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TOIMKeyPath[]): Map<TOIMKeyPath, (TItem | undefined)[]>;
+}
+
+/**
+ * Collection-bound reactive Array-based (ordered) index keyed by a composite key
+ * path (`TOIMKeyPath`). The array counterpart of
+ * `OIMReactiveCollectionIndexCompositeTrieSetBased`: same manual
+ * `setPks`/`addPks`/`removePks` surface and collection slot resolution, but keys
+ * are ordered slot arrays and each key is a path matched by content in O(arity).
+ *
+ * Primitive-keyed indexes keep their native-`Map` fast path — the trie cost is
+ * 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 pksByKey;
+    constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexCompositeArrayBasedOptions<TEntity, TPk>);
+    setPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    addPks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    removePks(key: TOIMKeyPath, pks: readonly TPk[]): void;
+    clear(key?: TOIMKeyPath): void;
     /**
-     * The pk→slot map for a key, lazily seeded from the current bucket so it
-     * stays correct even if slots were set through a lower-level path.
+     * The membership set for a key path, lazily seeded from the current bucket so
+     * it stays correct even if slots were set through a lower-level path.
      */
     private membershipOf;
-    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): (TItem | undefined)[];
-    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
+    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;
 }
 
@@ -1130,7 +1468,7 @@ declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMPk, TPk
  * The collection remains the source of truth. This index listens to collection
  * updates and maintains key membership automatically.
  */
-declare class OIMDerivedCollectionIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity> {
+declare class OIMDerivedCollectionIndexSetBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity> {
     private readonly collection;
     private readonly selectIndexKeys;
     private readonly unsubscribeFromCollection;
@@ -1150,7 +1488,7 @@ declare class OIMDerivedCollectionIndexSetBased<TKey extends TOIMPk, TPk extends
  * It maintains ordered per-key arrays automatically from collection updates.
  * Use `orderBy` or `compareEntities` when list order matters.
  */
-declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity> {
+declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMKey, TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity> {
     private readonly collection;
     private readonly selectIndexKeys;
     private readonly compareEntities?;
@@ -1171,7 +1509,7 @@ declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMPk, TPk exten
  * 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> {
+declare class OIMGlobalIndexManualArrayBased<TPk extends TOIMKey> extends OIMGlobalIndexArrayBased<TPk> {
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
     });
@@ -1188,7 +1526,7 @@ declare class OIMGlobalIndexManualArrayBased<TPk extends TOIMPk> extends OIMGlob
  * 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>> {
+declare class OIMReactiveGlobalIndexManualArrayBased<TPk extends TOIMKey> extends OIMReactiveGlobalIndexArrayBased<TPk, OIMGlobalIndexManualArrayBased<TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
         indexOptions?: {
             comparePks?: TOIMIndexComparator<TPk>;
@@ -1204,7 +1542,7 @@ declare class OIMReactiveGlobalIndexManualArrayBased<TPk extends TOIMPk> extends
  * 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> = {
+type TOIMCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
     };
@@ -1215,7 +1553,7 @@ type TOIMCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk exte
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 });
-type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
     };
@@ -1226,7 +1564,7 @@ type TOIMCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extend
     collection?: never;
     resolveSlot: TOIMEntitySlotResolver<TPk>;
 });
-type TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     /** Build initial state from existing collection slots. Defaults to true. */
     buildInitial?: boolean;
     /** Sort the list. Takes priority over `orderBy`. */
@@ -1239,7 +1577,7 @@ type TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity extends object, T
         comparePks?: TOIMIndexComparator<TPk>;
     };
 };
-type TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk extends TOIMKey> = {
     /** Build initial state from existing collection slots. Defaults to true. */
     buildInitial?: boolean;
     /** Include predicate. Defaults to "entity exists". */
@@ -1248,18 +1586,18 @@ type TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity extends object, TPk
         comparePks?: TOIMIndexComparator<TPk>;
     };
 };
-type TOIMRelationsGlobalArrayIndexOptions<TPk extends TOIMPk> = {
+type TOIMRelationsGlobalArrayIndexOptions<TPk extends TOIMKey> = {
     indexOptions?: {
         comparePks?: TOIMIndexComparator<TPk>;
     };
 };
-type TOIMRelationsGlobalSetIndexOptions<TPk extends TOIMPk> = {
+type TOIMRelationsGlobalSetIndexOptions<TPk extends TOIMKey> = {
     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>;
+type TOIMRelationsDerivedGlobalArrayIndexOptions<TEntity extends object, TPk extends TOIMKey> = TOIMDerivedCollectionGlobalIndexArrayBasedOptions<TEntity, TPk>;
+type TOIMRelationsDerivedGlobalSetIndexOptions<TEntity extends object, TPk extends TOIMKey> = TOIMDerivedCollectionGlobalIndexSetBasedOptions<TEntity, TPk>;
 
 /**
  * Collection-bound reactive array-based keyless index.
@@ -1269,7 +1607,7 @@ type TOIMRelationsDerivedGlobalSetIndexOptions<TEntity extends object, TPk exten
  * 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> {
+declare class OIMReactiveCollectionGlobalIndexManualArrayBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveGlobalIndexManualArrayBased<TPk> {
     private readonly resolveSlot;
     private readonly membership;
     private membershipSeeded;
@@ -1288,7 +1626,7 @@ declare class OIMReactiveCollectionGlobalIndexManualArrayBased<TPk extends TOIMP
  * 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> {
+declare class OIMGlobalIndexManualSetBased<TPk extends TOIMKey> extends OIMGlobalIndexSetBased<TPk> {
     constructor(options?: {
         comparePks?: TOIMIndexComparator<TPk>;
     });
@@ -1304,7 +1642,7 @@ declare class OIMGlobalIndexManualSetBased<TPk extends TOIMPk> extends OIMGlobal
  * 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>> {
+declare class OIMReactiveGlobalIndexManualSetBased<TPk extends TOIMKey> extends OIMReactiveGlobalIndexSetBased<TPk, OIMGlobalIndexManualSetBased<TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
         indexOptions?: {
             comparePks?: TOIMIndexComparator<TPk>;
@@ -1324,7 +1662,7 @@ declare class OIMReactiveGlobalIndexManualSetBased<TPk extends TOIMPk> extends O
  * 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> {
+declare class OIMReactiveCollectionGlobalIndexManualSetBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveGlobalIndexManualSetBased<TPk> {
     private readonly resolveSlot;
     private readonly membership;
     private membershipSeeded;
@@ -1346,7 +1684,7 @@ declare class OIMReactiveCollectionGlobalIndexManualSetBased<TPk extends TOIMPk,
  * {@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> {
+declare class OIMDerivedCollectionGlobalIndexArrayBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveCollectionGlobalIndexManualArrayBased<TPk, TEntity> {
     private readonly collection;
     private readonly compareEntities?;
     private readonly orderBy?;
@@ -1369,7 +1707,7 @@ declare class OIMDerivedCollectionGlobalIndexArrayBased<TPk extends TOIMPk, TEnt
  * (default: "entity exists"). Mirrors {@link OIMDerivedCollectionIndexSetBased}
  * minus the key.
  */
-declare class OIMDerivedCollectionGlobalIndexSetBased<TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveCollectionGlobalIndexManualSetBased<TPk, TEntity> {
+declare class OIMDerivedCollectionGlobalIndexSetBased<TPk extends TOIMKey, TEntity extends object = object> extends OIMReactiveCollectionGlobalIndexManualSetBased<TPk, TEntity> {
     private readonly collection;
     private readonly filter?;
     private readonly unsubscribeFromCollection;
@@ -1388,14 +1726,28 @@ declare class OIMDerivedCollectionGlobalIndexSetBased<TPk extends TOIMPk, TEntit
  * `queue + collection` binding in one place, so related structures can be
  * created next to the collection with less generic noise.
  */
-declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMPk> {
+declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMKey> {
     readonly queue: OIMEventQueue;
     readonly collection: OIMReactiveCollection<TEntity, TPk>;
     constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>);
-    setBasedIndex<TKey extends TOIMPk = string>(opts?: TOIMRelationsSetIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity>;
-    derivedSetIndex<TKey extends TOIMPk = string>(selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>, opts?: TOIMRelationsDerivedSetIndexOptions<TEntity, TKey, TPk>): OIMDerivedCollectionIndexSetBased<TKey, TPk, TEntity>;
-    arrayBasedIndex<TKey extends TOIMPk = string>(opts?: TOIMRelationsArrayIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity>;
-    derivedArrayIndex<TKey extends TOIMPk = string>(selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>, opts?: TOIMRelationsDerivedArrayIndexOptions<TEntity, TKey, TPk>): OIMDerivedCollectionIndexArrayBased<TKey, TPk, TEntity>;
+    setBasedIndex<TKey extends TOIMKey = string>(opts?: TOIMRelationsSetIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualSetBased<TKey, TPk, TEntity>;
+    /**
+     * Composite (trie-backed) manual Set-based index keyed by an
+     * arbitrary-length key path, e.g. `setPks([userId, projectId, role], pks)`.
+     * Key paths are matched by content in O(arity) — no string concatenation,
+     * no separator collisions, each segment keeps its type. Primitive-keyed
+     * indexes are unaffected and keep their native-`Map` fast path.
+     */
+    compositeSetIndex(opts?: TOIMRelationsCompositeSetIndexOptions<TPk>): OIMReactiveCollectionIndexCompositeTrieSetBased<TPk, TEntity>;
+    /**
+     * Composite (trie-backed) manual Array-based (ordered) index keyed by an
+     * arbitrary-length key path, e.g. `setPks([channelId, threadId], pks)`.
+     * Ordered counterpart of `compositeSetIndex`.
+     */
+    compositeArrayIndex(opts?: TOIMRelationsCompositeArrayIndexOptions<TPk>): OIMReactiveCollectionIndexCompositeTrieArrayBased<TPk, TEntity>;
+    derivedSetIndex<TKey extends TOIMKey = string>(selectIndexKeys: TOIMDerivedIndexKeySelector<TEntity, TKey>, opts?: TOIMRelationsDerivedSetIndexOptions<TEntity, TKey, TPk>): OIMDerivedCollectionIndexSetBased<TKey, TPk, TEntity>;
+    arrayBasedIndex<TKey extends TOIMKey = string>(opts?: TOIMRelationsArrayIndexOptions<TKey, TPk>): OIMReactiveCollectionIndexManualArrayBased<TKey, TPk, TEntity>;
+    derivedArrayIndex<TKey extends TOIMKey = 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`.
@@ -1410,10 +1762,10 @@ declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIM
     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>;
+    orderedIndex<TKey extends TOIMKey = string>(): OIMCollectionIndexManualOrderedArrayBased<TKey, TPk, TEntity>;
+    orderedList<TKey extends TOIMKey = string>(opts?: TOIMRelationsOrderedListOptions<TKey, TPk, TEntity>): OIMCollectionOrderedListCommandStream<TKey, TPk, TEntity>;
 }
-declare function createOIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMPk>(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>): OIMCollectionIndexFactory<TEntity, TPk>;
+declare function createOIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMKey>(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>): OIMCollectionIndexFactory<TEntity, TPk>;
 
 /**
  * Payload type for update events that contain keys */
@@ -1479,7 +1831,15 @@ declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<T
     destroy(): void;
 }
 
-declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TOIMPk> extends OIMCollectionStore<TEntity, TPk> {
+/**
+ * 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.
+ */
+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>;
@@ -1501,6 +1861,76 @@ 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;
+    /** Number of stored paths (terminal nodes), not the number of trie nodes. */
+    get size(): number;
+    set(path: readonly TSegment[], value: TValue): void;
+    get(path: readonly TSegment[]): TValue | undefined;
+    has(path: readonly TSegment[]): boolean;
+    delete(path: readonly TSegment[]): boolean;
+    clear(): void;
+    /** Depth-first iteration over `[path, value]` for every stored path. */
+    entries(): IterableIterator<[TSegment[], TValue]>;
+    keys(): IterableIterator<TSegment[]>;
+    values(): IterableIterator<TValue>;
+    private findNode;
+}
+
+/**
+ * Composite-PK collection store: keys slots by a `TOIMKeyPath` via a trie, so a
+ * freshly built `[a, b]` resolves to the same slot as one stored earlier, and
+ * `slot.pk` is interned to one canonical reference per logical key (downstream
+ * native `Set<slot.pk>` stay correct).
+ *
+ * It is a SEPARATE class from `OIMCollectionStoreMapDriven` on purpose: each
+ * store's `.get`/`.set` call sites see exactly one container shape (all-`Map`
+ * there, all-trie here), so a process running both primitive and composite
+ * collections keeps both hot paths monomorphic — no shared-class inline-cache
+ * 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>[];
+    getSlotByPk(pk: TOIMKeyPath): TOIMEntitySlot<TEntity, TOIMKeyPath> | undefined;
+    findSlotByPk(pk: TOIMKeyPath): TOIMEntitySlot<TEntity, TOIMKeyPath> | undefined;
+    private hasSubscribers;
+    getSlotsByPks(pks: readonly TOIMKeyPath[]): TOIMEntitySlot<TEntity, TOIMKeyPath>[];
+    getAllSlots(): TOIMEntitySlot<TEntity, TOIMKeyPath>[];
+    removeOneByPk(pk: TOIMKeyPath): void;
+    removeManyByPks(pks: readonly TOIMKeyPath[]): void;
+    getOneByPk(pk: TOIMKeyPath): TEntity | undefined;
+    getManyByPks(pks: readonly TOIMKeyPath[]): TEntity[];
+    getAll(): TEntity[];
+    countAll(): number;
+    clear(): void;
+    getAllPks(): TOIMKeyPath[];
+    destroy(): void;
+}
+
 declare class OIMObjectStoreMapDriven<TKey extends TOIMPk, TValue> extends OIMObjectStore<TKey, TValue> {
     protected readonly properties: Map<TKey, TValue>;
     setProperty(key: TKey, value: TValue): void;
@@ -1538,8 +1968,14 @@ declare class OIMObjectStoreRecordDriven<TKey extends string, TValue> extends OI
     destroy(): void;
 }
 
-declare class OIMIndexStoreMapDrivenSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexStoreSetBased<TKey, TPk> {
-    protected readonly slots: Map<TKey, Set<TOIMAnyEntitySlot<TPk>>>;
+declare class OIMIndexStoreMapDrivenSetBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndexStoreSetBased<TKey, TPk> {
+    protected readonly slots: Map<TKey, OIMKeyedBucketSetBased<TKey, TPk>>;
+    protected readonly reservedBuckets: Map<TKey, OIMKeyedBucketSetBased<TKey, TPk>>;
+    getOrReserveBucket(key: TKey): OIMKeyedBucketSetBased<TKey, TPk>;
+    findBucket(key: TKey): OIMKeyedBucketSetBased<TKey, TPk> | undefined;
+    retainBucket(bucket: OIMKeyedBucketSetBased<TKey, TPk>): void;
+    releaseBucket(bucket: OIMKeyedBucketSetBased<TKey, TPk>): void;
+    dropIfReserved(key: TKey): void;
     setOneByKey(key: TKey, slots: Set<TOIMAnyEntitySlot<TPk>>): void;
     removeOneByKey(key: TKey): void;
     removeManyByKeys(keys: readonly TKey[]): void;
@@ -1551,8 +1987,14 @@ declare class OIMIndexStoreMapDrivenSetBased<TKey extends TOIMPk, TPk extends TO
     clear(): void;
 }
 
-declare class OIMIndexStoreMapDrivenArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexStoreArrayBased<TKey, TPk> {
-    protected readonly slots: Map<TKey, TOIMAnyEntitySlot<TPk>[]>;
+declare class OIMIndexStoreMapDrivenArrayBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndexStoreArrayBased<TKey, TPk> {
+    protected readonly slots: Map<TKey, OIMKeyedBucketArrayBased<TKey, TPk>>;
+    protected readonly reservedBuckets: Map<TKey, OIMKeyedBucketArrayBased<TKey, TPk>>;
+    getOrReserveBucket(key: TKey): OIMKeyedBucketArrayBased<TKey, TPk>;
+    findBucket(key: TKey): OIMKeyedBucketArrayBased<TKey, TPk> | undefined;
+    retainBucket(bucket: OIMKeyedBucketArrayBased<TKey, TPk>): void;
+    releaseBucket(bucket: OIMKeyedBucketArrayBased<TKey, TPk>): void;
+    dropIfReserved(key: TKey): void;
     setOneByKey(key: TKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
     removeOneByKey(key: TKey): void;
     removeManyByKeys(keys: readonly TKey[]): void;
@@ -1564,6 +2006,106 @@ declare class OIMIndexStoreMapDrivenArrayBased<TKey extends TOIMPk, TPk extends
     clear(): void;
 }
 
+/**
+ * Set-based index store keyed by a composite key path (`TOIMKeyPath`), backed by
+ * a trie (`OIMTrieMap`) instead of a native `Map`. Key paths are matched by
+ * content in O(arity) without building a string key. Buckets are carrier buckets
+ * with the same live/reserved lifecycle as the Map-driven store.
+ */
+declare class OIMIndexStoreTrieDrivenSetBased<TPk extends TOIMKey> extends OIMIndexStoreSetBased<TOIMKeyPath, TPk> {
+    protected readonly slots: OIMTrieMap<TOIMPk, OIMKeyedBucketSetBased<TOIMKeyPath, TPk>>;
+    protected readonly reservedBuckets: OIMTrieMap<TOIMPk, OIMKeyedBucketSetBased<TOIMKeyPath, TPk>>;
+    getOrReserveBucket(key: TOIMKeyPath): OIMKeyedBucketSetBased<TOIMKeyPath, TPk>;
+    findBucket(key: TOIMKeyPath): OIMKeyedBucketSetBased<TOIMKeyPath, TPk> | undefined;
+    retainBucket(bucket: OIMKeyedBucketSetBased<TOIMKeyPath, TPk>): void;
+    releaseBucket(bucket: OIMKeyedBucketSetBased<TOIMKeyPath, TPk>): void;
+    dropIfReserved(key: TOIMKeyPath): void;
+    setOneByKey(key: TOIMKeyPath, slots: Set<TOIMAnyEntitySlot<TPk>>): void;
+    removeOneByKey(key: TOIMKeyPath): void;
+    removeManyByKeys(keys: readonly TOIMKeyPath[]): void;
+    getOneByKey(key: TOIMKeyPath): Set<TOIMAnyEntitySlot<TPk>> | undefined;
+    getManyByKeys(keys: readonly TOIMKeyPath[]): Map<TOIMKeyPath, Set<TOIMAnyEntitySlot<TPk>>>;
+    getAllKeys(): TOIMKeyPath[];
+    getAll(): Map<TOIMKeyPath, Set<TOIMAnyEntitySlot<TPk>>>;
+    countAll(): number;
+    clear(): void;
+}
+
+/**
+ * Array-based (ordered) index store keyed by a composite key path
+ * (`TOIMKeyPath`), backed by a trie (`OIMTrieMap`). The array counterpart of
+ * `OIMIndexStoreTrieDrivenSetBased`: each key path maps to an ordered carrier
+ * bucket (`OIMKeyedBucketArrayBased`) with the same live/reserved lifecycle,
+ * matched by content in O(arity) without building a string key.
+ */
+declare class OIMIndexStoreTrieDrivenArrayBased<TPk extends TOIMKey> extends OIMIndexStoreArrayBased<TOIMKeyPath, TPk> {
+    protected readonly slots: OIMTrieMap<TOIMPk, OIMKeyedBucketArrayBased<TOIMKeyPath, TPk>>;
+    protected readonly reservedBuckets: OIMTrieMap<TOIMPk, OIMKeyedBucketArrayBased<TOIMKeyPath, TPk>>;
+    getOrReserveBucket(key: TOIMKeyPath): OIMKeyedBucketArrayBased<TOIMKeyPath, TPk>;
+    findBucket(key: TOIMKeyPath): OIMKeyedBucketArrayBased<TOIMKeyPath, TPk> | undefined;
+    retainBucket(bucket: OIMKeyedBucketArrayBased<TOIMKeyPath, TPk>): void;
+    releaseBucket(bucket: OIMKeyedBucketArrayBased<TOIMKeyPath, TPk>): void;
+    dropIfReserved(key: TOIMKeyPath): void;
+    setOneByKey(key: TOIMKeyPath, slots: TOIMAnyEntitySlot<TPk>[]): void;
+    removeOneByKey(key: TOIMKeyPath): void;
+    removeManyByKeys(keys: readonly TOIMKeyPath[]): void;
+    getOneByKey(key: TOIMKeyPath): TOIMAnyEntitySlot<TPk>[] | undefined;
+    getManyByKeys(keys: readonly TOIMKeyPath[]): Map<TOIMKeyPath, TOIMAnyEntitySlot<TPk>[]>;
+    getAllKeys(): TOIMKeyPath[];
+    getAll(): Map<TOIMKeyPath, TOIMAnyEntitySlot<TPk>[]>;
+    countAll(): number;
+    clear(): void;
+}
+
+/**
+ * Composite-key counterpart of `OIMKeyedCarrierResolver`: 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.
+ *
+ * Carriers are created on first subscribe (`getOrReserveCarrier`) and pruned
+ * 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>> {
+    private readonly carriers;
+    getOrReserveCarrier(key: TOIMKeyPath): IOIMKeyCarrier<TOIMKeyPath>;
+    findCarrier(key: TOIMKeyPath): IOIMKeyCarrier<TOIMKeyPath> | undefined;
+    onCarrierEmptied(carrier: IOIMKeyCarrier<TOIMKeyPath>): void;
+}
+
+/**
+ * The bucket-lifecycle surface a carrier resolver 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.
+ */
+interface IOIMCarrierBucketStore<TKey extends TOIMKey, TBucket extends IOIMSubscribable> {
+    getOrReserveBucket(key: TKey): TBucket;
+    findBucket(key: TKey): TBucket | undefined;
+    dropIfReserved(key: TKey): void;
+}
+/**
+ * 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
+ * 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.
+ *
+ * `getOrReserveCarrier` creates a reserved (empty) bucket so a subscription can
+ * 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 & {
+    readonly key: TKey;
+}> implements IOIMCarrierResolver<TKey, TBucket> {
+    private readonly store;
+    constructor(store: IOIMCarrierBucketStore<TKey, TBucket>);
+    getOrReserveCarrier(key: TKey): TBucket;
+    findCarrier(key: TKey): TBucket | undefined;
+    onCarrierEmptied(carrier: TBucket): void;
+}
+
 type TOIMComparator<TEntity extends object> = (a: TEntity, b: TEntity) => boolean;
 
 declare class OIMComparatorFactory<TEntity extends object> {
@@ -1642,22 +2184,22 @@ declare class OIMIndexComparatorFactory {
      * Create an element-wise comparator that checks arrays for strict equality.
      * Compares array lengths and each element using strict equality (===).
      */
-    static createElementWiseComparator<TPk extends TOIMPk>(): TOIMIndexComparator<TPk>;
+    static createElementWiseComparator<TPk extends TOIMKey>(): TOIMIndexComparator<TPk>;
     /**
      * Create a set-based comparator that checks if arrays contain the same elements.
      * Order doesn't matter, only the presence of elements.
      */
-    static createSetBasedComparator<TPk extends TOIMPk>(): TOIMIndexComparator<TPk>;
+    static createSetBasedComparator<TPk extends TOIMKey>(): TOIMIndexComparator<TPk>;
     /**
      * Create a shallow comparator that only checks array references.
      * Fastest but only works if you're reusing the same array instances.
      */
-    static createShallowComparator<TPk extends TOIMPk>(): TOIMIndexComparator<TPk>;
+    static createShallowComparator<TPk extends TOIMKey>(): TOIMIndexComparator<TPk>;
     /**
      * Create a no-comparison comparator that always returns false (always updates).
      * Useful for disabling comparison while keeping the same interface.
      */
-    static createAlwaysUpdateComparator<TPk extends TOIMPk>(): TOIMIndexComparator<TPk>;
+    static createAlwaysUpdateComparator<TPk extends TOIMKey>(): TOIMIndexComparator<TPk>;
 }
 
 declare class OIMMap2Keys<K1, K2, V> {
@@ -1671,7 +2213,133 @@ declare class OIMMap2Keys<K1, K2, V> {
     clear(): void;
 }
 
-declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMPk> {
+/**
+ * Anything with a `destroy()` teardown. `destroy(): void` is the de-facto
+ * convention across oimdb (collections, indexes, objects, emitters, effects,
+ * computed, streams); this interface just names it so a dispose scope can hold
+ * them uniformly.
+ */
+interface IOIMDisposable {
+    destroy(): void;
+}
+
+/**
+ * A unit of teardown a dispose scope can hold: either an object with `destroy()`
+ * (collection, index, object, stream, effect, computed…) or a bare unsubscribe
+ * function — the `() => void` returned by `subscribeOnKey`, `emitter.on`,
+ * `selector.watch`, `runtime.schedule`, etc. Many resources (selectors, per-key
+ * subscriptions, scheduler tasks) expose ONLY the function form.
+ */
+type TOIMDisposable = IOIMDisposable | (() => void);
+
+/**
+ * Collects disposables and tears them ALL down at once, in reverse registration
+ * (LIFO) order — so dependents are disposed before the things they depend on
+ * (indexes/streams/selectors before the collection, the collection before the
+ * queue). This is the correct teardown order in oimdb, and doing it by hand is
+ * the classic source of leaks and use-after-destroy bugs.
+ *
+ * Register as you build, capturing the value inline:
+ *
+ * ```ts
+ * const scope = new OIMDisposeScope();
+ * const queue = scope.add(new OIMEventQueue());
+ * const users = scope.add(new OIMReactiveCollection(queue, { selectPk: u => u.id }));
+ * const byTeam = scope.add(users.indexFactory.setBasedIndex());
+ * scope.add(selector.watch(v => render(v)));   // bare unsubscribe fn also works
+ * // …later, one call tears everything down, LIFO:
+ * scope.destroy();
+ * ```
+ *
+ * Accepts both `{ destroy(): void }` objects and bare `() => void` unsubscribe
+ * functions (selectors, per-key subscriptions and scheduler tasks only expose
+ * the latter). Idempotent; every registered item is disposed even if one throws
+ * (the first error is rethrown afterwards). Nestable via `child()`.
+ */
+declare class OIMDisposeScope implements IOIMDisposable {
+    private readonly disposables;
+    private disposed;
+    /** Number of not-yet-disposed items currently held. */
+    get size(): number;
+    get isDisposed(): boolean;
+    /**
+     * Register a disposable (object with `destroy()` or an unsubscribe function)
+     * and return it unchanged, so it can be captured inline. If the scope is
+     * already disposed the item is disposed immediately, so nothing leaks.
+     */
+    add<T extends TOIMDisposable>(disposable: T): T;
+    /** A nested scope, itself registered here — dispose it early or with the parent. */
+    child(): OIMDisposeScope;
+    /**
+     * Dispose everything in reverse registration order, then clear. Idempotent.
+     * If any `destroy()`/unsubscribe throws, the rest are still disposed and the
+     * first error is rethrown once teardown completes.
+     */
+    destroy(): void;
+    private disposeOne;
+}
+declare function createOIMDisposeScope(): OIMDisposeScope;
+
+/**
+ * Trie-backed Set of composite key paths — the `Set` counterpart of
+ * `OIMTrieMap`. Membership is by content, so a freshly built `[a, b]` is the
+ * same member as one added earlier. Implemented over an `OIMTrieMap<TOIMPk,
+ * true>` to reuse its terminal-flagged nodes and empty-branch pruning.
+ */
+declare class OIMTrieSet implements IOIMKeyedSet<TOIMKeyPath> {
+    private readonly map;
+    get size(): number;
+    add(key: TOIMKeyPath): void;
+    has(key: TOIMKeyPath): boolean;
+    delete(key: TOIMKeyPath): boolean;
+    values(): IterableIterator<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.
+ *
+ * There is intentionally NO default codec for composite keys: a hidden
+ * `JSON.stringify` would silently couple correctness to key order / escaping.
+ * Callers pass one explicitly (`OIMPkCodecKeyPath` is a ready opt-in for paths).
+ */
+interface IOIMPkCodec<TPk extends TOIMKey> {
+    encode(pk: TPk): string;
+    decode(encoded: string): TPk;
+}
+
+/**
+ * Opt-in `IOIMPkCodec` for composite key paths at serialization boundaries. Uses
+ * a JSON array encoding, which is collision-safe (a segment containing the
+ * delimiter cannot forge a boundary the way `"a|b"` concatenation can) and
+ * preserves each segment's JSON type, so `decode(encode(pk))` round-trips
+ * `string`/`number` segments exactly.
+ *
+ * It is NOT a default — pass it explicitly where a boundary needs to key a
+ * composite PK by string (Redux state, persist storage, snapshots).
+ */
+declare class OIMPkCodecKeyPath implements IOIMPkCodec<TOIMKeyPath> {
+    encode(pk: TOIMKeyPath): string;
+    decode(encoded: string): TOIMKeyPath;
+}
+
+declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMKey> {
     createIdSelector(): TOIMPkSelector<TEntity & {
         id: TPk;
     }, TPk>;
@@ -1748,29 +2416,45 @@ declare abstract class OIMSelector<TValue> {
 type TOIMCollectionEntitySelector<TEntity extends object> = OIMSelector<TEntity | undefined>;
 type TOIMCollectionEntitiesSelector<TEntity extends object> = OIMSelector<readonly (TEntity | undefined)[]>;
 
-declare class OIMCollectionSelectors<TEntity extends object, TPk extends TOIMPk> {
+declare class OIMCollectionSelectors<TEntity extends object, TPk extends TOIMKey> {
     private readonly collection;
     readonly runtime: OIMComputeRuntime;
     constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>);
     byPk(pk: TPk): TOIMCollectionEntitySelector<TEntity>;
     byPks(pks: readonly TPk[]): TOIMCollectionEntitiesSelector<TEntity>;
-    entitiesBySetIndexKey<TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(index: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
-    entitiesByArrayIndexKey<TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(index: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
+    entitiesBySetIndexKey<TKey extends TOIMKey, TIndex extends OIMIndexSetBased<TKey, TPk>>(index: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
+    entitiesByArrayIndexKey<TKey extends TOIMKey, TIndex extends OIMIndexArrayBased<TKey, TPk>>(index: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey): TOIMCollectionEntitiesSelector<TEntity>;
+    /**
+     * Entities of a composite (key-path) set-based index for one key path, e.g.
+     * `entitiesByCompositeSetIndexKey(index, [projectId, role])`.
+     */
+    entitiesByCompositeSetIndexKey<TIndex extends OIMIndexSetBased<TOIMKeyPath, TPk>>(index: OIMReactiveIndexSetBased<TOIMKeyPath, TPk, TIndex>, key: TOIMKeyPath): TOIMCollectionEntitiesSelector<TEntity>;
+    /** Entities of a composite (key-path) array-based index for one key path. */
+    entitiesByCompositeArrayIndexKey<TIndex extends OIMIndexArrayBased<TOIMKeyPath, TPk>>(index: OIMReactiveIndexArrayBased<TOIMKeyPath, TPk, TIndex>, key: TOIMKeyPath): 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>;
-type TOIMCollectionKit<TEntity extends object, TPk extends TOIMPk> = {
+type TOIMReactiveCollectionFactoryOptions<TEntity extends object, TPk extends TOIMKey> = TOIMCollectionOptions<TEntity, TPk>;
+type TOIMCollectionKit<TEntity extends object, TPk extends TOIMKey> = {
     queue: OIMEventQueue;
     collection: OIMReactiveCollection<TEntity, TPk>;
     indexFactory: OIMCollectionIndexFactory<TEntity, TPk>;
     select: OIMCollectionSelectors<TEntity, TPk>;
+    /**
+     * Dispose scope owning the kit's collection. `add()` indexes/streams/
+     * subscriptions you create off the kit, then `destroy()` tears them all down
+     * in reverse order. Does NOT own the `queue` (it is passed in and may be
+     * shared) — destroy the queue yourself when nothing else uses it.
+     */
+    scope: OIMDisposeScope;
+    /** Tear down the kit's scope (collection + everything added to it). */
+    destroy: () => void;
 };
 
-declare function createOIMCollectionKit<TEntity extends object, TPk extends TOIMPk>(queue: OIMEventQueue, opts?: TOIMReactiveCollectionFactoryOptions<TEntity, TPk>): TOIMCollectionKit<TEntity, TPk>;
+declare function createOIMCollectionKit<TEntity extends object, TPk extends TOIMKey>(queue: OIMEventQueue, opts?: TOIMReactiveCollectionFactoryOptions<TEntity, TPk>): TOIMCollectionKit<TEntity, TPk>;
 
 type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
 /**
@@ -1781,7 +2465,7 @@ type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
  * DX: if the underlying collection is mutated directly, we detect it via collection
  * update events and infer changed fields by diffing the last observed entity snapshot.
  */
-declare class OIMCollectionChangedFields<TEntity extends object, TPk extends TOIMPk> {
+declare class OIMCollectionChangedFields<TEntity extends object, TPk extends TOIMKey> {
     readonly collection: OIMCollection<TEntity, TPk>;
     private readonly selectPk;
     private readonly unsubscribeAfterFlush;
@@ -1866,7 +2550,7 @@ declare class OIMCollectionChangedFields<TEntity extends object, TPk extends TOI
  * 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> {
+declare class OIMOrderedListMappedCommandStream<TKey extends TOIMKey, TOut, TIn> implements IOIMOrderedListCommandSource<TKey, TOut> {
     private readonly source;
     private readonly create;
     /** Per-key positional mirror of the mapped elements. */
@@ -1902,7 +2586,7 @@ declare class OIMOrderedListMappedCommandStream<TKey extends TOIMPk, TOut, TIn>
  * });
  * ```
  */
-declare function createOIMOrderedListMappedCommandStream<TKey extends TOIMPk, TIn, TOut>(source: IOIMOrderedListCommandSource<TKey, TIn>, create: (item: TIn) => TOut): OIMOrderedListMappedCommandStream<TKey, TOut, TIn>;
+declare function createOIMOrderedListMappedCommandStream<TKey extends TOIMKey, 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:
@@ -1912,7 +2596,7 @@ declare function createOIMOrderedListMappedCommandStream<TKey extends TOIMPk, TI
  * `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> {
+interface IOIMIndexSlotSource<TKey extends TOIMKey, TPk extends TOIMKey> extends IOIMKeyedSubscription<TKey> {
     getSlotsByKey(key: TKey): Iterable<TOIMAnyEntitySlot<TPk>>;
 }
 
@@ -1928,14 +2612,14 @@ interface IOIMIndexSlotSource<TKey extends TOIMPk, TPk extends TOIMPk> extends I
  * 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`.
+ * resources that need explicit teardown (DOM nodes, subscriptions), drive an
+ * ordered command stream instead — its `remove` / `set` / `reset` commands are
+ * the exact removal signal you tear down on.
  *
  * 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> {
+declare class OIMIndexSlotMap<TKey extends TOIMKey, TPk extends TOIMKey, TMapped> {
     private readonly index;
     private readonly create;
     private readonly cache;
@@ -1974,7 +2658,77 @@ declare class OIMIndexSlotMap<TKey extends TOIMPk, TPk extends TOIMPk, TMapped>
  * }
  * ```
  */
-declare function createOIMIndexSlotMap<TKey extends TOIMPk, TPk extends TOIMPk, TMapped>(index: IOIMIndexSlotSource<TKey, TPk>, create: (slot: TOIMAnyEntitySlot<TPk>) => TMapped): OIMIndexSlotMap<TKey, TPk, TMapped>;
+declare function createOIMIndexSlotMap<TKey extends TOIMKey, TPk extends TOIMKey, TMapped>(index: IOIMIndexSlotSource<TKey, TPk>, create: (slot: TOIMAnyEntitySlot<TPk>) => TMapped): OIMIndexSlotMap<TKey, TPk, TMapped>;
+
+/**
+ * Minimal read/subscribe surface a keyless (whole-collection) index exposes for
+ * slot mapping: iterate all slots and subscribe to the single bucket's changes.
+ * The keyless counterpart of {@link IOIMIndexSlotSource}.
+ *
+ * Both `OIMReactiveGlobalIndexSetBased` (slots as a `ReadonlySet`) and
+ * `OIMReactiveGlobalIndexArrayBased` (slots as a `readonly` array) satisfy it
+ * structurally — a `Set` and an array are both `Iterable`.
+ */
+interface IOIMGlobalIndexSlotSource<TPk extends TOIMKey> extends IOIMSubscription {
+    getSlots(): Iterable<TOIMAnyEntitySlot<TPk>>;
+}
+
+/**
+ * Stable slot→object memo over a keyless (whole-collection) set/array index —
+ * the keyless counterpart of {@link OIMIndexSlotMap}.
+ *
+ * `create(slot)` runs once per canonical slot; every later read returns the
+ * **same** object reference for the same slot, so a consumer can re-read on each
+ * notification and still hand reference-equal objects to `React.memo` /
+ * `Object.is` diffing, or reuse the same view-model.
+ *
+ * The cache is a `WeakMap` keyed by the slot object, so a mapped object is
+ * reclaimed by GC once its slot is dropped. There is no teardown callback and
+ * none is needed for plain values; if your mapped objects hold resources needing
+ * explicit cleanup, drive an ordered command stream (whose `remove` / `set` /
+ * `reset` commands are the exact removal signal) instead.
+ *
+ * Thin wrapper: no queue, no standing subscription of its own — `subscribe` is a
+ * passthrough to the index.
+ */
+declare class OIMGlobalIndexSlotMap<TPk extends TOIMKey, TMapped> {
+    private readonly index;
+    private readonly create;
+    private readonly cache;
+    constructor(index: IOIMGlobalIndexSlotSource<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 in the index, with stable references. For a
+     * set-based global index the order is unspecified (as the set is); for an
+     * array-based one it follows the index order.
+     */
+    getAll(): 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 — both
+     * levels hand back stable references and each `create` runs once per slot.
+     */
+    map<TNext>(create: (mapped: TMapped) => TNext): OIMGlobalIndexSlotMap<TPk, TNext>;
+    /** Subscribe to the index's changes — passthrough to the index. */
+    subscribe(handler: TOIMEventHandler<void>): () => void;
+}
+
+/**
+ * Map the slots of a keyless (whole-collection) set/array index to stable
+ * per-slot objects — the keyless counterpart of `createOIMIndexSlotMap`.
+ *
+ * ```ts
+ * const everyone = users.indexFactory.derivedSetGlobalIndex();
+ * const rows = createOIMGlobalIndexSlotMap(everyone, (slot) => makeRow(slot.item));
+ *
+ * rows.subscribe(render);
+ * function render() {
+ *   for (const row of rows.getAll()) { /* same instance per slot *\/ }
+ * }
+ * ```
+ */
+declare function createOIMGlobalIndexSlotMap<TPk extends TOIMKey, TMapped>(index: IOIMGlobalIndexSlotSource<TPk>, create: (slot: TOIMAnyEntitySlot<TPk>) => TMapped): OIMGlobalIndexSlotMap<TPk, TMapped>;
 
 /**
  * Options for {@link OIMOrderedListCommandStreamDiffDriven}.
@@ -2012,7 +2766,7 @@ type TOIMOrderedListDiffOptions = {
  * 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 {
+declare function diffOrderedListByPk<TPk extends TOIMKey, TItem extends {
     pk: TPk;
 }>(prev: readonly TItem[], next: readonly TItem[]): TOIMOrderedListCommand<TItem>[];
 
@@ -2034,7 +2788,7 @@ declare function diffOrderedListByPk<TPk extends TOIMPk, TItem extends {
  * `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>> {
+declare class OIMOrderedListCommandStreamDiffDriven<TKey extends TOIMKey, TPk extends TOIMKey, 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;
@@ -2064,7 +2818,7 @@ declare class OIMOrderedListCommandStreamDiffDriven<TKey extends TOIMPk, TPk ext
  * );
  * ```
  */
-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>;
+declare function createOIMOrderedListCommandStreamDiffDriven<TKey extends TOIMKey, TPk extends TOIMKey, 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.
@@ -2208,18 +2962,18 @@ type TOIMIndexKey = string | number | bigint;
 
 /**
  * Configuration options for Set-based index instances */
-type TOIMIndexOptionsSetBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMIndexOptionsSetBased<TIndexKey extends TOIMKey, TPk extends TOIMKey> = {
     comparePks?: TOIMIndexComparator<TPk>;
     store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
 };
 /**
  * Configuration options for Array-based index instances */
-type TOIMIndexOptionsArrayBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMIndexOptionsArrayBased<TIndexKey extends TOIMKey, TPk extends TOIMKey> = {
     comparePks?: TOIMIndexComparator<TPk>;
     store?: OIMIndexStoreArrayBased<TIndexKey, TPk>;
 };
 
-type TOIMIndexPksUpdatePayload<TKey extends TOIMPk, TPk extends TOIMPk> = {
+type TOIMIndexPksUpdatePayload<TKey extends TOIMKey, TPk extends TOIMKey> = {
     key: TKey;
     pks: readonly TPk[];
 };
@@ -2247,7 +3001,7 @@ type TOIMComputedOptions<TValue> = {
     compare?: (a: TValue, b: TValue) => boolean;
 };
 
-type TOIMComputedUpdatePayload<TKey extends TOIMPk> = {
+type TOIMComputedUpdatePayload<TKey extends TOIMKey> = {
     keys: readonly TKey[];
 };
 
@@ -2319,7 +3073,7 @@ declare class OIMEffect {
     private readonly onAfterFlush;
 }
 
-declare class OIMEffectDependencyKeyed<TKey extends TOIMPk> implements IOIMEffectDependency {
+declare class OIMEffectDependencyKeyed<TKey extends TOIMKey> implements IOIMEffectDependency {
     readonly source: IOIMKeyedSubscription<TKey>;
     private readonly key;
     private readonly keys;
@@ -2335,7 +3089,7 @@ declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implem
     subscribe(onUpdate: () => void): () => void;
 }
 
-declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMPk> implements IOIMEffectDependency {
+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[]);
@@ -2343,7 +3097,7 @@ declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk ext
     subscribe(onUpdate: () => void): () => void;
 }
 
-declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMPk> implements IOIMEffectDependency {
+declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMKey> implements IOIMEffectDependency {
     private readonly dep;
     constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
     constructor(index: IOIMKeyedSubscription<TKey>, keys: readonly TKey[]);
@@ -2367,14 +3121,14 @@ declare class OIMEffectDependencyComputed implements IOIMEffectDependency {
     subscribe(onUpdate: () => void): () => void;
 }
 
-declare class OIMCollectionByPkSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<TEntity | undefined> {
+declare class OIMCollectionByPkSelector<TEntity extends object, TPk extends TOIMKey> extends OIMSelector<TEntity | undefined> {
     private readonly collection;
     private readonly pk;
     constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
     getValue(): TEntity | undefined;
 }
 
-declare class OIMCollectionByPksSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<readonly (TEntity | undefined)[]> {
+declare class OIMCollectionByPksSelector<TEntity extends object, TPk extends TOIMKey> extends OIMSelector<readonly (TEntity | undefined)[]> {
     private readonly collection;
     private readonly pks;
     constructor(runtime: OIMComputeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
@@ -2397,14 +3151,14 @@ declare class OIMObjectValuesByKeysSelector<TKey extends string, TValue> extends
     protected areEqual(prev: readonly (TValue | undefined)[], next: readonly (TValue | undefined)[]): boolean;
 }
 
-declare class OIMIndexPksByKeySetBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<Set<TPk>> {
+declare class OIMIndexPksByKeySetBasedSelector<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<Set<TPk>> {
     private readonly reactiveIndex;
     private readonly key;
     constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
     getValue(): Set<TPk>;
 }
 
-declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
+declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly key;
     constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
@@ -2412,7 +3166,7 @@ declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMPk, TPk extend
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
 
-declare class OIMIndexPksByKeysSetBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
+declare class OIMIndexPksByKeysSetBasedSelector<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly keys;
     constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
@@ -2420,7 +3174,7 @@ declare class OIMIndexPksByKeysSetBasedSelector<TKey extends TOIMPk, TPk extends
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
 
-declare class OIMIndexPksByKeysArrayBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
+declare class OIMIndexPksByKeysArrayBasedSelector<TKey extends TOIMKey, TPk extends TOIMKey, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
     private readonly reactiveIndex;
     private readonly keys;
     constructor(runtime: OIMComputeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
@@ -2428,7 +3182,7 @@ declare class OIMIndexPksByKeysArrayBasedSelector<TKey extends TOIMPk, TPk exten
     protected areEqual(prev: readonly TPk[], next: readonly TPk[]): boolean;
 }
 
-declare class OIMEntitiesByIndexKeySetBasedSelector<TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+declare class OIMEntitiesByIndexKeySetBasedSelector<TEntity extends object, TPk extends TOIMKey, TKey extends TOIMKey, TIndex extends OIMIndexSetBased<TKey, TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
     private readonly collection;
     private readonly reactiveIndex;
     private readonly key;
@@ -2437,7 +3191,7 @@ declare class OIMEntitiesByIndexKeySetBasedSelector<TEntity extends object, TPk
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TPk extends TOIMKey, TKey extends TOIMKey, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
     private readonly collection;
     private readonly reactiveIndex;
     private readonly key;
@@ -2446,7 +3200,7 @@ declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TP
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-declare class OIMEntitiesByGlobalIndexSetBasedSelector<TEntity extends object, TPk extends TOIMPk, TIndex extends OIMGlobalIndexSetBased<TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+declare class OIMEntitiesByGlobalIndexSetBasedSelector<TEntity extends object, TPk extends TOIMKey, 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>);
@@ -2454,7 +3208,7 @@ declare class OIMEntitiesByGlobalIndexSetBasedSelector<TEntity extends object, T
     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)[]> {
+declare class OIMEntitiesByGlobalIndexArrayBasedSelector<TEntity extends object, TPk extends TOIMKey, 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>);
@@ -2462,4 +3216,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 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 };
+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 };