@oimdb/core 2.1.0 → 3.0.0

package/dist/index.d.ts

@@ -3,6 +3,13 @@ type TOIMPk = string | number;
 type TOIMEntitySlot<TEntity extends object, TPk extends TOIMPk> = {
     pk: TPk;
     item: TEntity | undefined;
+    /**
+     * Per-pk subscribers, attached lazily by the slot-based keyed emitter so
+     * notification needs no per-key map lookup. The slot is retained while this
+     * is non-empty (even with `item: undefined`) so a subscription survives a
+     * remove → re-add of its entity. Undefined when nothing is subscribed.
+     */
+    subscribers?: Set<() => void>;
 };
 type TOIMAnyEntitySlot<TPk extends TOIMPk> = TOIMEntitySlot<object, TPk>;
 type TOIMEntitySlotResolver<TPk extends TOIMPk> = (pk: TPk) => TOIMAnyEntitySlot<TPk> | undefined;
@@ -10,6 +17,19 @@ type TOIMEntitySlotResolver<TPk extends TOIMPk> = (pk: TPk) => TOIMAnyEntitySlot
 declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TOIMPk> {
     abstract setOneByPk(pk: TPk, entity: TEntity): TOIMEntitySlot<TEntity, TPk>;
     abstract getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
+    /**
+     * Returns the canonical slot for `pk`, creating a reserved empty slot
+     * (`item: undefined`) if no entity exists yet. The reserved slot is a stable
+     * reference that fills in when the entity is later written, so indexes can
+     * hold it ahead of the entity's arrival without crashing.
+     */
+    abstract getOrReserveSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk>;
+    /**
+     * Returns the existing slot for `pk` (live or reserved) without creating
+     * one. Used by the slot-based emitter to resolve a slot for delivery /
+     * unsubscribe without side effects.
+     */
+    abstract findSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
     abstract getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     abstract getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
     abstract removeOneByPk(pk: TPk): void;
@@ -76,8 +96,8 @@ declare abstract class OIMIndex<TKey extends TOIMPk, TPk extends TOIMPk, TBucket
     getKeySize(key: TKey): number;
     get size(): number;
     get isEmpty(): boolean;
-    getEntitiesByKey<TEntity extends object = object>(key: TKey): TEntity[];
-    getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, TEntity[]>;
+    getEntitiesByKey<TEntity extends object = object>(key: TKey): (TEntity | undefined)[];
+    getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, (TEntity | undefined)[]>;
     getMetrics(): {
         totalKeys: number;
         totalPks: number;
@@ -88,7 +108,15 @@ declare abstract class OIMIndex<TKey extends TOIMPk, TPk extends TOIMPk, TBucket
     destroy(): void;
     protected emitUpdate(keys: TKey[]): void;
     protected emitUpdateOne(key: TKey): void;
-    protected slotsToEntities<TEntity extends object>(slots: Iterable<TOIMAnyEntitySlot<TPk>>): TEntity[];
+    /**
+     * Maps a bucket's slots to entities, preserving positional holes: a slot
+     * whose entity is not present yet (reserved by an index ahead of its data)
+     * or was removed yields `undefined` at its position rather than being
+     * dropped. This keeps the result aligned with `getPksByKey`, so callers can
+     * render a per-item loading/placeholder state instead of a silently shorter
+     * list.
+     */
+    protected slotsToEntities<TEntity extends object>(slots: Iterable<TOIMAnyEntitySlot<TPk>>): (TEntity | undefined)[];
 }
 
 declare abstract class OIMIndexStoreSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
@@ -257,12 +285,19 @@ declare class OIMUpdateEventEmitter<TKey extends TOIMPk> {
     markAllUpdated(): void;
     protected readonly onFlush: () => void;
     private deliverImmediate;
+    /**
+     * Notifies all handlers for a key. The overwhelmingly common case is a
+     * single subscriber per key (one component per pk), handled without any
+     * allocation. For multiple subscribers a snapshot is taken so a handler may
+     * (un)subscribe during iteration without corrupting the walk.
+     */
+    private notifyHandlers;
     private readonly onAfterFlush;
     /**
      * Deliver updated keys and notify handlers once.
      * Re-entrant updates during delivery are forbidden and will throw in markUpdatedKeys().
      */
-    protected runSinglePass(makeHandlerSnapshot: (handlers: Set<TOIMEventHandler<void>>) => TOIMEventHandler<void>[]): void;
+    protected runSinglePass(): void;
     destroy(): void;
     /**
      * Get performance metrics for monitoring and debugging
@@ -296,8 +331,8 @@ declare abstract class OIMReactiveIndex<TKey extends TOIMPk, TPk extends TOIMPk,
     readonly index: TIndex;
     protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
     constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
-    getEntitiesByKey<TEntity extends object = object>(key: TKey): TEntity[];
-    getEntitiesByKeys<TEntity extends object = object>(keys: readonly TKey[]): Map<TKey, TEntity[]>;
+    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;
     getKeys(): readonly TKey[];
     getKeySize(key: TKey): number;
@@ -381,6 +416,7 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     getOneByPk(pk: TPk): TEntity | undefined;
     getManyByPks(pks: readonly TPk[]): TEntity[];
     getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
+    getOrReserveSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk>;
     getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
     upsertOneByPk(pk: TPk, entity: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
@@ -399,9 +435,76 @@ 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>;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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> {
+    private readonly queue;
+    private readonly resolver;
+    private readonly subscribedCarriers;
+    private dirtyCarriers;
+    private isFlushEnqueued;
+    private dequeueFlush?;
+    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> {
     private readonly queue;
-    protected readonly updateEmitter: OIMUpdateEventEmitter<TPk>;
+    protected readonly updateEmitter: OIMCarrierKeyedEmitter<TPk, TOIMEntitySlot<TEntity, TPk>>;
     private readonly anyUpdateHandlers;
     private pendingAnyUpdatePks;
     private isAnyUpdateClearPending;
@@ -422,6 +525,8 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk>
         queueLength: number;
     };
     subscribeOnAnyUpdate(handler: (pks: readonly TPk[]) => void): () => void;
+    private notifyLegacy;
+    private notifyLegacyMany;
     upsertOneByPk(pk: TPk, entity: Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
     upsertOne(entity: TEntity | Partial<TEntity>): TOIMEntitySlot<TEntity, TPk>;
     upsertMany(entities: (TEntity | Partial<TEntity>)[]): TOIMEntitySlot<TEntity, TPk>[];
@@ -559,8 +664,8 @@ declare class OIMCollectionIndexManualOrderedArrayBased<TKey extends TOIMPk, TPk
     push(key: TKey, pk: TPk): number;
     insertAt(key: TKey, index: number, pk: TPk): number;
     reset(key: TKey, pks: readonly TPk[]): void;
-    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
-    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): (TItem | undefined)[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
     resolvePk(pk: TPk): TOIMAnyEntitySlot<TPk>;
     private resolveSlots;
     private resolveRequiredSlot;
@@ -609,7 +714,7 @@ declare class OIMOrderedListCommandStream<TKey extends TOIMPk, TPk extends TOIMP
     constructor(queue: OIMEventQueue, index?: OIMIndexManualOrderedArrayBased<TKey, TPk>);
     getPksByKey(key: TKey): readonly TPk[];
     getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
-    getEntitiesByKey(key: TKey): TEntity[];
+    getEntitiesByKey(key: TKey): (TEntity | undefined)[];
     hasKey(key: TKey): boolean;
     getKeys(): readonly TKey[];
     pushSlot(key: TKey, slot: TOIMEntitySlot<TEntity, TPk>): void;
@@ -641,7 +746,7 @@ declare class OIMCollectionOrderedListCommandStream<TKey extends TOIMPk, TPk ext
     insertAt(key: TKey, index: number, pk: TPk): void;
     set(key: TKey, pks: readonly TPk[]): void;
     getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[];
-    getEntitiesByKey(key: TKey): TEntity[];
+    getEntitiesByKey(key: TKey): (TEntity | undefined)[];
     private resolvePk;
 }
 
@@ -655,6 +760,12 @@ declare class OIMIndexManualArrayBased<TIndexKey extends TOIMPk, TPk extends TOI
         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`.
+     */
+    appendSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     /**
      * Clear all primary keys for a specific index key, or all keys if no key specified
      */
@@ -669,6 +780,7 @@ declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends
         };
     });
     setSlots(key: TKey, slots: TOIMAnyEntitySlot<TPk>[]): void;
+    appendSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     clear(key?: TKey): void;
 }
 
@@ -680,12 +792,19 @@ declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends
  */
 declare class OIMReactiveCollectionIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualArrayBased<TKey, TPk> {
     private readonly resolveSlot;
+    private readonly pksByKey;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
     setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
-    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
-    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
+    clear(key?: TKey): void;
+    /**
+     * The membership set for a key, 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)[]>;
     private resolveSlots;
     private resolveRequiredSlot;
 }
@@ -700,6 +819,15 @@ declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMP
         store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
     });
     setSlots(key: TIndexKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
+    /**
+     * 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`.
+     */
+    addSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    /**
+     * Removes slots from a key's bucket IN PLACE (O(removed)) and emits once.
+     */
+    removeSlots(key: TIndexKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     /**
      * Clear all primary keys for a specific index key, or all keys if no key specified
      */
@@ -714,6 +842,8 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TO
         };
     });
     setSlots(key: TKey, slots: Iterable<TOIMAnyEntitySlot<TPk>>): void;
+    addSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
+    removeSlots(key: TKey, slots: readonly TOIMAnyEntitySlot<TPk>[]): void;
     clear(key?: TKey): void;
 }
 
@@ -725,13 +855,19 @@ declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TO
  */
 declare class OIMReactiveCollectionIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TEntity extends object = object> extends OIMReactiveIndexManualSetBased<TKey, TPk> {
     private readonly resolveSlot;
+    private readonly slotByPk;
     constructor(queue: OIMEventQueue, opts: TOIMCollectionIndexSetBasedOptions<TEntity, TKey, TPk>);
     setPks(key: TKey, pks: readonly TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
-    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): TItem[];
-    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, TItem[]>;
-    private resolveSlots;
+    clear(key?: TKey): 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.
+     */
+    private membershipOf;
+    getEntitiesByKey<TItem extends object = TEntity>(key: TKey): (TItem | undefined)[];
+    getEntitiesByKeys<TItem extends object = TEntity>(keys: readonly TKey[]): Map<TKey, (TItem | undefined)[]>;
     private resolveRequiredSlot;
 }
 
@@ -768,13 +904,12 @@ declare class OIMDerivedCollectionIndexArrayBased<TKey extends TOIMPk, TPk exten
     private readonly orderBy?;
     private readonly unsubscribeFromCollection;
     private readonly keysByPk;
+    private readonly orderValueByPk;
     constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts: TOIMDerivedCollectionIndexArrayBasedOptions<TEntity, TKey, TPk>);
     rebuildFromCollection(): void;
     clear(key?: TKey): void;
     destroy(): void;
     private readonly onCollectionUpdate;
-    private trackPkKeys;
-    private rebuildKey;
     private sortSlots;
     private normalizeKeys;
 }
@@ -849,9 +984,13 @@ declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<T
 
 declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TOIMPk> extends OIMCollectionStore<TEntity, 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>;
+    getOrReserveSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk>;
     setManyByPks(pks: readonly TPk[], entities: TEntity[]): TOIMEntitySlot<TEntity, TPk>[];
     getSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
+    findSlotByPk(pk: TPk): TOIMEntitySlot<TEntity, TPk> | undefined;
+    private hasSubscribers;
     getSlotsByPks(pks: readonly TPk[]): TOIMEntitySlot<TEntity, TPk>[];
     getAllSlots(): TOIMEntitySlot<TEntity, TPk>[];
     removeOneByPk(pk: TPk): void;
@@ -938,6 +1077,21 @@ declare class OIMEntityUpdaterFactory<TEntity extends object> {
     createMergeEntityUpdater(): TOIMEntityUpdater<TEntity>;
 }
 
+/**
+ * Entity updater that mutates the existing entity in place instead of building a
+ * new merged object. It skips the per-update allocation/copy of the default
+ * merge updater (`{ ...prev, ...draft }`), which is the single biggest data-layer
+ * cost on update-heavy workloads.
+ *
+ * Pair it with a signal-driven binding (re-read the entity on the keyed
+ * notification, e.g. `@oimdb/react`'s `*Signal` hooks): since the stored entity
+ * reference stays stable across updates, reference-comparison bindings
+ * (React's `Object.is` / `useSyncExternalStore`, `React.memo` on entities,
+ * prev/next diffing, time-travel) will NOT see the change. Use only where every
+ * reader is subscription-driven.
+ */
+declare function createInPlaceEntityUpdater<TEntity extends object>(): TOIMEntityUpdater<TEntity>;
+
 /**
  * Factory for creating index comparators.
  * Provides common comparison strategies for primary key arrays.
@@ -1479,4 +1633,4 @@ declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TP
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMIndexStore, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandStream, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionIndexArrayBasedOptions, type TOIMDerivedCollectionIndexSetBasedOptions, type TOIMDerivedEntityComparator, type TOIMDerivedEntityOrderSelector, type TOIMDerivedEntityOrderValue, type TOIMDerivedIndexKeySelector, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotResolver, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createOIMCollectionIndexFactory, createOIMCollectionKit };
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierResolver, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMIndexStore, type IOIMSubscribable, OIMCarrierKeyedEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandStream, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionIndexArrayBasedOptions, type TOIMDerivedCollectionIndexSetBasedOptions, type TOIMDerivedEntityComparator, type TOIMDerivedEntityOrderSelector, type TOIMDerivedEntityOrderValue, type TOIMDerivedIndexKeySelector, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotResolver, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createInPlaceEntityUpdater, createOIMCollectionIndexFactory, createOIMCollectionKit };