@oimdb/core 1.3.1 → 1.4.1

package/dist/index.d.cts

@@ -10,6 +10,7 @@ declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TO
     abstract getAllPks(): TPk[];
     abstract countAll(): number;
     abstract clear(): void;
+    abstract destroy(): void;
 }
 
 declare abstract class OIMIndexStoreSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
@@ -40,9 +41,15 @@ type TOIMEventHandler<T> = (payload: T) => void;
 
 declare class OIMEventEmitter<T extends Record<string, unknown>> {
     private buckets;
+    hasHandlers<K extends keyof T>(event: K): boolean;
     private getOrCreateBucket;
+    /**
+     * Compacts the handlers array by removing null entries (tombstones) left by handler removal.
+     * Rebuilds the indexByHandler map with updated indices and resets the tombstone count.
+     * This reduces array fragmentation and improves iteration performance.
+     */
     private compactBucket;
-    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
+    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): () => void;
     emit<K extends keyof T>(event: K, payload: T[K]): void;
     off<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
     offAll<K extends keyof T>(event?: K): void;
@@ -155,6 +162,10 @@ declare abstract class OIMIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk>
      * Emit update event with changed keys
      */
     protected emitUpdate(keys: TKey[]): void;
+    /**
+     * Emit update event for a single key (fast-path override point).
+     */
+    protected emitUpdateOne(key: TKey): void;
 }
 
 /**
@@ -222,78 +233,10 @@ declare abstract class OIMIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMP
      * Emit update event with changed keys
      */
     protected emitUpdate(keys: TKey[]): void;
-}
-
-/**
- * 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.
- */
-declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexSetBased<TIndexKey, TPk> {
-    constructor(options?: {
-        comparePks?: TOIMIndexComparator<TPk>;
-        store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
-    });
     /**
-     * Set primary keys for a specific index key, replacing any existing values.
-     * Uses optional comparator to skip updates if PKs haven't actually changed.
+     * Emit update event for a single key (fast-path override point).
      */
-    setPks(key: TIndexKey, pks: TPk[]): void;
-    /**
-     * Add primary keys to a specific index key
-     */
-    addPks(key: TIndexKey, pks: readonly TPk[]): void;
-    /**
-     * Remove primary keys from a specific index key
-     */
-    removePks(key: TIndexKey, pks: readonly TPk[]): void;
-    /**
-     * Clear all primary keys for a specific index key, or all keys if no key specified
-     */
-    clear(key?: TIndexKey): void;
-}
-
-/**
- * Static class containing OIMDB settings and constants.
- * Provides access to configuration values used throughout the library.
- */
-declare class OIMDBSettings {
-    /**
-     * Fixed key used in the manual index to store updated keys set in coalescers.
-     * This constant is exported so users can create their own indexes and pass them to coalescers.
-     */
-    static readonly UPDATED_KEYS_INDEX_KEY: "__updatedKeys__";
-}
-
-/**
- * Base abstract coalescer that groups updates by keys and emits consolidated events.
- * Designed to be extended for different entity types (collections, indexes, etc.).
- * Uses SetBased indexes for efficient key tracking.
- */
-declare abstract class OIMUpdateEventCoalescer<TKey extends TOIMPk> {
-    readonly emitter: OIMEventEmitter<{
-        0: void;
-        1: void;
-        2: void;
-    }>;
-    protected readonly updatedKeysIndex: OIMIndexManualSetBased<typeof OIMDBSettings.UPDATED_KEYS_INDEX_KEY, TKey>;
-    private hasEmittedChanges;
-    constructor(index?: OIMIndexManualSetBased<typeof OIMDBSettings.UPDATED_KEYS_INDEX_KEY, TKey>);
-    /**
-     * Get the set of keys that have been updated since last clear
-     */
-    getUpdatedKeys(): Set<TKey>;
-    /**
-     * Clear all updated keys and reset the changed state
-     */
-    clearUpdatedKeys(): void;
-    /**
-     * Add keys to the updated set and emit HAS_CHANGES event if needed
-     */
-    protected addUpdatedKeys(keys: readonly TKey[]): void;
-    /**
-     * Clean up event listeners when coalescer is no longer needed
-     */
-    abstract destroy(): void;
+    protected emitUpdateOne(key: TKey): void;
 }
 
 /**
@@ -318,18 +261,26 @@ declare enum EOIMEventQueueEventType {
  */
 declare class OIMEventQueue {
     readonly emitter: OIMEventEmitter<Record<EOIMEventQueueEventType, void>>;
-    protected queue: (() => void)[];
+    protected tasks: Set<() => void>;
     protected readonly scheduler?: OIMEventQueueScheduler;
     protected flushBound?: () => void;
+    protected isFlushing: boolean;
     constructor(options?: TOIMEventQueueOptions);
     /**
-     * Add a function to the queue. If scheduler is configured and autoSchedule is enabled,
-     * automatically schedules a flush operation.
+     * Enqueue a one-shot task to be executed on the next flush.
+     * Returns a dequeue function that can be called to cancel the task before it runs.
      */
-    enqueue(fn: () => void): void;
+    enqueue(fn: () => void): () => void;
+    get isInFlush(): boolean;
     /**
-     * Execute all queued functions and clear the queue.
-     * This method is safe to call multiple times and handles reentrancy.
+     * Dequeue (cancel) a previously enqueued task by its dequeue function.
+     */
+    dequeue(dequeueFn: () => void): void;
+    /**
+     * Execute all pending tasks.
+     *
+     * This flush drains until the queue is empty. If tasks enqueue more tasks, they will be
+     * executed within the same flush.
      */
     flush(): void;
     /**
@@ -344,29 +295,44 @@ declare class OIMEventQueue {
      * Clear the queue without executing functions and cancel any scheduled flush.
      */
     clear(): void;
+    protected ensureScheduled(): void;
     /**
      * Clean up scheduler subscription when queue is no longer needed.
      */
     destroy(): void;
 }
 
-/**
- * Options for creating an update event emitter */
-type TOIMUpdateEventEmitterOptions<TKey extends TOIMPk> = {
-    coalescer: OIMUpdateEventCoalescer<TKey>;
-    queue: OIMEventQueue;
-};
-
+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> {
     protected keyHandlers: Map<TKey, Set<TOIMEventHandler<void>>>;
-    protected coalescer: OIMUpdateEventCoalescer<TKey>;
     protected queue: OIMEventQueue;
-    constructor(opts: TOIMUpdateEventEmitterOptions<TKey>);
-    protected handleHasChanges: () => void;
+    private readonly deliveryMode;
+    private isFlushEnqueued;
+    private dequeueFlush?;
+    private updatedKeys;
+    private isAfterFlushDeliveryScheduled;
+    private unsubscribeAfterFlushDelivery?;
+    constructor(queue: OIMEventQueue, deliveryMode?: TOIMUpdateEventEmitterDeliveryMode);
+    /**
+     * Mark keys as updated and schedule delivery.
+     *
+     * If there are no subscriptions, this is a no-op and does not allocate or retain keys.
+     */
+    markUpdatedKeys(keys: readonly TKey[]): void;
+    markUpdatedKey(key: TKey): void;
+    markAllUpdated(): void;
+    protected readonly onFlush: () => void;
+    private deliverImmediate;
+    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;
     destroy(): void;
     /**
      * Get performance metrics for monitoring and debugging
@@ -391,34 +357,15 @@ declare class OIMUpdateEventEmitter<TKey extends TOIMPk> {
     unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
 }
 
-declare enum EOIMIndexEventType {
-    UPDATE = 0
-}
-
-/**
- * Index-specific coalescer that tracks index key updates and emits consolidated change events.
- * Takes an event emitter directly instead of the whole index to avoid circular dependencies.
- */
-declare class OIMUpdateEventCoalescerIndex<TIndexKey extends TOIMPk> extends OIMUpdateEventCoalescer<TIndexKey> {
-    private readonly indexEmitter;
-    constructor(indexEmitter: OIMEventEmitter<{
-        [EOIMIndexEventType.UPDATE]: TOIMIndexUpdatePayload<TIndexKey>;
-    }>);
-    destroy(): void;
-    /**
-     * When the index is updated, we keep track of the updated keys.
-     */
-    private handleUpdate;
+interface IOIMKeyedSubscription<TKey extends TOIMPk> {
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
 }
 
-declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> {
+declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>> implements IOIMKeyedSubscription<TKey> {
     readonly index: TIndex;
-    readonly updateEventEmitter: OIMUpdateEventEmitter<TKey>;
-    readonly coalescer: OIMUpdateEventCoalescerIndex<TKey>;
-    constructor(queue: OIMEventQueue, opts?: {
-        index: TIndex;
-    });
-    protected abstract createDefaultIndex(): TIndex;
+    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
     getPksByKey(key: TKey): Set<TPk>;
     getPksByKeys(keys: readonly TKey[]): Map<TKey, Set<TPk>>;
     hasKey(key: TKey): boolean;
@@ -433,17 +380,25 @@ declare abstract class OIMReactiveIndexSetBased<TKey extends TOIMPk, TPk extends
         maxBucketSize: number;
         minBucketSize: number;
     };
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(key: TKey): number;
+    getSubscriptionMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
     destroy(): void;
 }
 
-declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> {
+declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> implements IOIMKeyedSubscription<TKey> {
     readonly index: TIndex;
-    readonly updateEventEmitter: OIMUpdateEventEmitter<TKey>;
-    readonly coalescer: OIMUpdateEventCoalescerIndex<TKey>;
-    constructor(queue: OIMEventQueue, opts?: {
-        index: TIndex;
-    });
-    protected abstract createDefaultIndex(): TIndex;
+    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
+    constructor(queue: OIMEventQueue, createIndex: (updateEmitter: OIMUpdateEventEmitter<TKey>) => TIndex);
     getPksByKey(key: TKey): TPk[];
     getPksByKeys(keys: readonly TKey[]): Map<TKey, TPk[]>;
     hasKey(key: TKey): boolean;
@@ -458,9 +413,35 @@ declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk exten
         maxBucketSize: number;
         minBucketSize: number;
     };
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(key: TKey): number;
+    getSubscriptionMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
     destroy(): void;
 }
 
+declare abstract class OIMObjectStore<TKey extends string | number | symbol, TValue> {
+    abstract setProperty(key: TKey, value: TValue): void;
+    abstract merge(draft: Partial<Record<TKey, TValue>>): void;
+    abstract delete(key: TKey): void;
+    abstract get(key: TKey): TValue | undefined;
+    abstract getAll(): Record<TKey, TValue>;
+    abstract clear(): void;
+    abstract count(): number;
+    abstract keys(): TKey[];
+    abstract values(): TValue[];
+    abstract entries(): [TKey, TValue][];
+    abstract destroy(): void;
+}
+
 type TOIMPkSelector<TEntity extends object, TPk extends TOIMPk> = (entity: TEntity) => TPk;
 
 type TOIMEntityUpdater<TEntity extends object> = (draft: Partial<TEntity>, prevEntity: TEntity) => TEntity;
@@ -480,7 +461,7 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     readonly emitter: OIMEventEmitter<{
         0: TOIMCollectionUpdatePayload<TPk>;
     }>;
-    protected readonly selectPk: TOIMPkSelector<TEntity, TPk>;
+    readonly selectPk: TOIMPkSelector<TEntity, TPk>;
     protected readonly store: OIMCollectionStore<TEntity, TPk>;
     protected readonly updateEntity: TOIMEntityUpdater<TEntity>;
     constructor(opts?: TOIMCollectionOptions<TEntity, TPk>);
@@ -499,39 +480,131 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     getAllPks(): TPk[];
     protected upsertOneWithoutNotifications(entity: TEntity | Partial<TEntity>): TPk;
     protected upsertOneWithoutNotificationsByPk(pk: TPk, entity: Partial<TEntity> | TEntity): void;
+    destroy(): void;
 }
 
-declare enum EOIMCollectionEventType {
-    UPDATE = 0
+declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk> extends OIMCollection<TEntity, TPk> implements IOIMKeyedSubscription<TPk> {
+    private readonly queue;
+    protected readonly updateEmitter: OIMUpdateEventEmitter<TPk>;
+    private readonly anyUpdateHandlers;
+    private pendingAnyUpdatePks;
+    private isAnyUpdateClearPending;
+    private isAnyUpdateScheduled;
+    private dequeueAnyUpdate?;
+    constructor(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>);
+    subscribeOnKey(pk: TPk, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(pks: readonly TPk[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(pk: TPk, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(pks: readonly TPk[], handler: TOIMEventHandler<void>): void;
+    destroySubscriptions(): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(pk: TPk): number;
+    getMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
+    subscribeOnAnyUpdate(handler: (pks: readonly TPk[]) => void): () => void;
+    upsertOneByPk(pk: TPk, entity: Partial<TEntity>): void;
+    upsertOne(entity: TEntity | Partial<TEntity>): void;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    removeOne(entity: TEntity): void;
+    removeMany(entities: TEntity[]): void;
+    removeOneByPk(pk: TPk): void;
+    removeManyByPks(pks: readonly TPk[]): void;
+    clear(): void;
+    private trackAnyUpdatePk;
+    private trackAnyUpdatePks;
+    private trackAnyUpdateClear;
+    private ensureAnyUpdateEnqueued;
+    private readonly runAnyUpdate;
+    destroy(): void;
 }
 
 /**
- * Collection-specific coalescer that tracks primary key updates and emits consolidated change events.
- * Takes an event emitter directly instead of the whole collection to avoid circular dependencies.
- */
-declare class OIMUpdateEventCoalescerCollection<TPk extends TOIMPk> extends OIMUpdateEventCoalescer<TPk> {
-    private readonly collectionEmitter;
-    constructor(collectionEmitter: OIMEventEmitter<{
-        [EOIMCollectionEventType.UPDATE]: TOIMCollectionUpdatePayload<TPk>;
-    }>);
+ * Payload type for update events that contain keys */
+type TOIMUpdatePayload<TKey> = {
+    keys: readonly TKey[];
+};
+
+type TOIMObjectOptions<TKey extends string, TValue> = {
+    store?: OIMObjectStore<TKey, TValue>;
+};
+
+/** It's like a store - but with event emitter */
+declare class OIMObject<TKey extends string, TValue> {
+    readonly emitter: OIMEventEmitter<{
+        0: TOIMUpdatePayload<TKey>;
+    }>;
+    protected readonly store: OIMObjectStore<TKey, TValue>;
+    constructor(opts?: TOIMObjectOptions<TKey, TValue>);
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
     destroy(): void;
-    /**
-     * When the collection is updated, we keep track of the updated pks.
-     */
-    private handleUpdate;
 }
 
-declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk> extends OIMCollection<TEntity, TPk> {
-    readonly updateEventEmitter: OIMUpdateEventEmitter<TPk>;
-    readonly coalescer: OIMUpdateEventCoalescerCollection<TPk>;
-    constructor(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>);
+declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<TKey, TValue> implements IOIMKeyedSubscription<TKey> {
+    protected readonly updateEmitter: OIMUpdateEventEmitter<TKey>;
+    constructor(queue: OIMEventQueue, opts?: TOIMObjectOptions<TKey, TValue>);
+    subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
+    unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
+    hasSubscriptions(): boolean;
+    getHandlerCount(key: TKey): number;
+    getMetrics(): {
+        totalKeys: number;
+        totalHandlers: number;
+        averageHandlersPerKey: number;
+        queueLength: number;
+    };
+    destroy(): void;
+}
+
+/**
+ * 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.
+ */
+declare class OIMIndexManualSetBased<TIndexKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexSetBased<TIndexKey, TPk> {
+    constructor(options?: {
+        comparePks?: TOIMIndexComparator<TPk>;
+        store?: OIMIndexStoreSetBased<TIndexKey, TPk>;
+    });
+    /**
+     * Set primary keys for a specific index key, replacing any existing values.
+     * Uses optional comparator to skip updates if PKs haven't actually changed.
+     */
+    setPks(key: TIndexKey, pks: TPk[]): void;
+    /**
+     * Add primary keys to a specific index key
+     */
+    addPks(key: TIndexKey, pks: readonly TPk[]): void;
+    /**
+     * Remove primary keys from a specific index key
+     */
+    removePks(key: TIndexKey, pks: readonly TPk[]): void;
+    /**
+     * Clear all primary keys for a specific index key, or all keys if no key specified
+     */
+    clear(key?: TIndexKey): void;
 }
 
 declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexSetBased<TKey, TPk, OIMIndexManualSetBased<TKey, TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
-        index: OIMIndexManualSetBased<TKey, TPk>;
+        indexOptions?: {
+            comparePks?: TOIMIndexComparator<TPk>;
+            store?: OIMIndexStoreSetBased<TKey, TPk>;
+        };
     });
-    protected createDefaultIndex(): OIMIndexManualSetBased<TKey, TPk>;
     setPks(key: TKey, pks: TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
@@ -568,9 +641,11 @@ declare class OIMIndexManualArrayBased<TIndexKey extends TOIMPk, TPk extends TOI
 
 declare class OIMReactiveIndexManualArrayBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexArrayBased<TKey, TPk, OIMIndexManualArrayBased<TKey, TPk>> {
     constructor(queue: OIMEventQueue, opts?: {
-        index: OIMIndexManualArrayBased<TKey, TPk>;
+        indexOptions?: {
+            comparePks?: TOIMIndexComparator<TPk>;
+            store?: OIMIndexStoreArrayBased<TKey, TPk>;
+        };
     });
-    protected createDefaultIndex(): OIMIndexManualArrayBased<TKey, TPk>;
     setPks(key: TKey, pks: TPk[]): void;
     addPks(key: TKey, pks: readonly TPk[]): void;
     removePks(key: TKey, pks: readonly TPk[]): void;
@@ -598,6 +673,44 @@ declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TO
     countAll(): number;
     clear(): void;
     getAllPks(): TPk[];
+    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;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
+}
+
+/**
+ * Record-driven store (plain object) for OIMObject.
+ *
+ * Note: object keys are strings at runtime, so this store is limited to string keys
+ * for type-safety and predictable semantics.
+ */
+declare class OIMObjectStoreRecordDriven<TKey extends string, TValue> extends OIMObjectStore<TKey, TValue> {
+    protected properties: Record<TKey, TValue>;
+    constructor(initial?: Partial<Record<TKey, TValue>>);
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
 }
 
 declare class OIMIndexStoreMapDrivenSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexStoreSetBased<TKey, TPk> {
@@ -680,6 +793,145 @@ declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMPk> {
     }, TPk>;
 }
 
+type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
+/**
+ * Wrapper around `OIMCollection` that tracks "changed fields" per entity PK.
+ *
+ * Important: to get field-level info, you must perform writes through this wrapper.
+ *
+ * DX: if the underlying collection is mutated directly (bypassing this wrapper), we detect it
+ * via collection update events and infer changed fields by diffing the last observed entity snapshot.
+ */
+declare class OIMCollectionChangedFieldsWrapper<TEntity extends object, TPk extends TOIMPk> {
+    readonly collection: OIMCollection<TEntity, TPk>;
+    private readonly selectPk;
+    private readonly unsubscribeAfterFlush;
+    private readonly unsubscribeFromCollectionEmitter;
+    private isInWrite;
+    private readonly lastEntitySnapshotByPk;
+    /**
+     * Emits updates scoped by PK. Subscribe, then read state via `getChangedFieldsByPk(...)`
+     * or drain via `consumeChangedFieldsByPk(...)`.
+     */
+    readonly changedPksEventEmitter: OIMUpdateEventEmitter<TPk>;
+    /**
+     * Emits updates scoped by field name. Subscribe, then read state via
+     * `getChangedPksByField(...)` or drain via `consumeChangedPksByField(...)`.
+     */
+    readonly changedFieldsEventEmitter: OIMUpdateEventEmitter<TOIMFieldKey<TEntity>>;
+    private readonly changedFieldsByPk;
+    private readonly changedPksByField;
+    constructor(queue: OIMEventQueue, collection: OIMCollection<TEntity, TPk>, opts?: {
+        /**
+         * Optional PK selector for convenience APIs like `upsertOne(...)`.
+         * If not provided, only `upsertOneByPk(...)` should be used.
+         */
+        selectPk?: (entity: TEntity | Partial<TEntity>) => TPk;
+    });
+    upsertOneByPk(pk: TPk, patch: Partial<TEntity>): void;
+    upsertOne(entity: TEntity | Partial<TEntity>): void;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    getChangedFieldsByPk(pk: TPk): ReadonlySet<TOIMFieldKey<TEntity>>;
+    consumeChangedFieldsByPk(pk: TPk): Set<TOIMFieldKey<TEntity>>;
+    getChangedPksByField(field: TOIMFieldKey<TEntity>): ReadonlySet<TPk>;
+    consumeChangedPksByField(field: TOIMFieldKey<TEntity>): Set<TPk>;
+    clear(): void;
+    destroy(): void;
+    private readonly onAfterFlush;
+    private readonly onCollectionUpdate;
+    private withWrite;
+    private trackExternalMutationByPk;
+    private diffChangedKeys;
+    private updateEntitySnapshot;
+    private trackChangedKeys;
+    private trackPatch;
+}
+
+/**
+ * Manual ordered Array-based index.
+ *
+ * Unlike `OIMIndexManualArrayBased.addPks/removePks`, this class is explicitly ordered:
+ * - preserves order
+ * - allows O(1) append (`push`)
+ * - supports `move` and `removeAt` without computing diffs
+ *
+ * It emits UPDATE events per key on every successful mutation.
+ */
+declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TItemKey extends TOIMPk> extends OIMIndexArrayBased<TKey, TItemKey> {
+    clear(key?: TKey): void;
+    push(key: TKey, itemKey: TItemKey): number;
+    insertAt(key: TKey, index: number, itemKey: TItemKey): void;
+    removeAt(key: TKey, index: number): TItemKey | undefined;
+    move(key: TKey, fromIndex: number, toIndex: number): TItemKey | undefined;
+    reset(key: TKey, itemKeys: readonly TItemKey[]): void;
+    private getOrCreateList;
+}
+
+type TOIMOrderedListCommand<TPk extends TOIMPk> = {
+    type: 'add';
+    key: TPk;
+    index: number;
+} | {
+    type: 'remove';
+    key: TPk;
+    index: number;
+} | {
+    type: 'move';
+    key: TPk;
+    fromIndex: number;
+    toIndex: number;
+} | {
+    /**
+     * Replace the whole list for this key (preferred name).
+     */
+    type: 'set';
+    keys: readonly TPk[];
+};
+
+/**
+ * Ordered-list wrapper that stores arrays per key and emits a per-key command stream.
+ *
+ * This is designed for imperative renderers: instead of diffing the full list on each update,
+ * you subscribe to `commandsEventEmitter` on a single list key and apply commands sequentially.
+ *
+ * Notes:
+ * - Commands are buffered per key and delivered batched per queue flush.
+ * - Order of commands is preserved.
+ * - A future optimizer can collapse the command buffer into `set(...)` if needed.
+ */
+declare class OIMOrderedListIndexCommandStreamWrapper<TKey extends TOIMPk, TItemKey extends TOIMPk> {
+    readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
+    private readonly unsubscribeAfterFlush;
+    private readonly unsubscribeFromIndexEmitter;
+    private isInWrite;
+    private readonly commandsByKey;
+    /** Underlying ordered index (source of truth for the list). */
+    readonly index: OIMIndexManualOrderedArrayBased<TKey, TItemKey>;
+    constructor(queue: OIMEventQueue, index?: OIMIndexManualOrderedArrayBased<TKey, TItemKey>);
+    getPksByKey(key: TKey): readonly TItemKey[];
+    hasKey(key: TKey): boolean;
+    getKeys(): readonly TKey[];
+    push(key: TKey, itemKey: TItemKey): void;
+    removeAt(key: TKey, index: number): void;
+    move(key: TKey, fromIndex: number, toIndex: number): void;
+    set(key: TKey, keys: readonly TItemKey[]): void;
+    /**
+     * Read-only peek at buffered commands without clearing them.
+     */
+    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TItemKey>[];
+    /**
+     * Drain buffered commands for a key, preserving order.
+     * Intended usage: call inside a `commandsEventEmitter.subscribeOnKey(key, ...)` handler.
+     */
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TItemKey>[];
+    clear(key?: TKey): void;
+    destroy(): void;
+    private readonly onAfterFlush;
+    private readonly onIndexUpdate;
+    private withWrite;
+    private appendCommand;
+}
+
 /**
  * Animation frame-based scheduler that executes flushes synchronized with the browser's repaint cycle.
  * Ideal for UI-related updates that need to be synchronized with rendering.
@@ -777,12 +1029,16 @@ declare class OIMEventQueueSchedulerFactory {
     static createImmediate(): OIMEventQueueSchedulerImmediate;
 }
 
-/**
- * Event types for update coalescers */
-declare enum EOIMUpdateEventCoalescerEventType {
-    HAS_CHANGES = 0,
-    BEFORE_FLUSH = 1,
-    AFTER_FLUSH = 2
+declare enum EOIMCollectionEventType {
+    UPDATE = 0
+}
+
+declare enum EOIMIndexEventType {
+    UPDATE = 0
+}
+
+declare enum EOIMObjectEventType {
+    UPDATE = 0
 }
 
 type TOIMIndexKey = string | number | bigint;
@@ -810,9 +1066,287 @@ type TOIMIndexPksUpdatePayload<TKey extends TOIMPk, TPk extends TOIMPk> = {
 };
 
 /**
- * Payload type for update events that contain keys */
-type TOIMUpdatePayload<TKey> = {
+ * Static class containing OIMDB settings and constants.
+ * Provides access to configuration values used throughout the library.
+ */
+declare class OIMDBSettings {
+    /**
+     * Fixed key used in the manual index to store updated keys set in coalescers.
+     * This constant is exported so users can create their own indexes and pass them to coalescers.
+     */
+    static readonly UPDATED_KEYS_INDEX_KEY: "__updatedKeys__";
+    static readonly FLUSHING_KEYS_INDEX_KEY: "__flushingKeys__";
+}
+
+interface IOIMEffectDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
+type TOIMComputedOptions<TValue> = {
+    compute: () => TValue;
+    deps?: readonly IOIMEffectDependency[];
+    compare?: (a: TValue, b: TValue) => boolean;
+};
+
+type TOIMComputedUpdatePayload<TKey extends TOIMPk> = {
     keys: readonly TKey[];
 };
 
-export { EOIMCollectionEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMUpdateEventCoalescerEventType, type IOIMEventQueueSchedulerEvents, OIMCollection, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMDBSettings, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualSetBased, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMPkSelectorFactory, OIMRICollection, OIMReactiveCollection, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMUpdateEventCoalescer, OIMUpdateEventCoalescerCollection, OIMUpdateEventCoalescerIndex, OIMUpdateEventEmitter, type TOIMCollectionOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptions, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMPk, type TOIMPkSelector, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdateEventEmitterOptions, type TOIMUpdatePayload };
+/**
+ * Computative runtime that schedules derived computations by levels and runs them
+ * on `queue.flush()` boundary (AFTER_FLUSH).
+ */
+declare class OIMComputativeRuntime {
+    readonly queue: OIMEventQueue;
+    private isFlushScheduled;
+    private isFlushing;
+    private minLevel;
+    private maxLevel;
+    private readonly dirtyByLevel;
+    private readonly afterFlushTasks;
+    constructor(queue: OIMEventQueue);
+    /**
+     * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
+     * ordered by `level` ascending.
+     */
+    schedule(task: () => void, level?: number): () => void;
+    /**
+     * Run once at the start of the next runtime flush (i.e. after queue.flush()).
+     * Useful for resubscribing dependencies exactly once per source flush.
+     */
+    scheduleAfterFlush(task: () => void): () => void;
+    private flush;
+}
+
+type TOIMComputedKey$2 = 'value';
+declare class OIMComputed<TValue> {
+    readonly emitter: OIMEventEmitter<{
+        update: TOIMComputedUpdatePayload<TOIMComputedKey$2>;
+    }>;
+    readonly updateEventEmitter: OIMUpdateEventEmitter<TOIMComputedKey$2>;
+    private readonly runtime;
+    private readonly compute;
+    private readonly compare;
+    private readonly deps;
+    private value;
+    private hasValue;
+    private isDirty;
+    private readonly effect;
+    constructor(runtime: OIMComputativeRuntime, opts: TOIMComputedOptions<TValue>);
+    get(): TValue;
+    getIfReady(): TValue | undefined;
+    destroy(): void;
+    private recomputeAndEmitIfChanged;
+}
+
+declare enum EOIMComputedEventType {
+    UPDATE = "update"
+}
+
+type TOIMComputedKey$1 = 'value';
+interface IOIMComputedEventSource {
+    emitter: OIMEventEmitter<{
+        [EOIMComputedEventType.UPDATE]: TOIMComputedUpdatePayload<TOIMComputedKey$1>;
+    }>;
+}
+
+type TOIMEffectOptions = {
+    deps?: readonly IOIMEffectDependency[];
+    onUpdate?: () => void;
+    run: () => void;
+};
+
+declare class OIMEffect {
+    private readonly runtime;
+    private readonly onUpdate?;
+    private readonly run;
+    private readonly deps;
+    private readonly sourceDeps;
+    private readonly computedDeps;
+    private sourceUnsubscribers;
+    private computedUnsubscribers;
+    private dequeueResubscribe?;
+    private isResubscribeEnqueued;
+    private isTemporarilyUnsubscribedForFlush;
+    private isScheduled;
+    private dequeueScheduled?;
+    private readonly runTask;
+    constructor(runtime: OIMComputativeRuntime, opts: TOIMEffectOptions);
+    destroy(): void;
+    private onSourceInvalidate;
+    private onComputedInvalidate;
+    private runOnce;
+    private subscribeToDeps;
+    private unsubscribeFromSourceDeps;
+    private unsubscribeFromAllDeps;
+    private ensureResubscribeAfterFlush;
+    private readonly onAfterFlush;
+}
+
+declare class OIMEffectDependencyKeyed<TKey extends TOIMPk> implements IOIMEffectDependency {
+    private readonly subscription;
+    private readonly key;
+    private readonly keys;
+    constructor(subscription: IOIMKeyedSubscription<TKey>, keyOrKeys: TKey | readonly TKey[]);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(object: OIMReactiveObject<TKey, TValue>, key: TKey);
+    constructor(object: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMPk> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
+    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMPk> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
+    constructor(index: IOIMKeyedSubscription<TKey>, keys: readonly TKey[]);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+type TOIMComputedKey = 'value';
+type TOIMComputedLike = {
+    emitter: OIMEventEmitter<{
+        update: TOIMComputedUpdatePayload<TOIMComputedKey>;
+    }>;
+    updateEventEmitter: OIMUpdateEventEmitter<TOIMComputedKey>;
+};
+/**
+ * Effect dependency on a computed.
+ */
+declare class OIMEffectDependencyComputed implements IOIMEffectDependency {
+    private readonly computed;
+    constructor(computed: TOIMComputedLike);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+interface IOIMSelectorComputedDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
+interface IOIMSelectorSourceDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare abstract class OIMSelector<TValue> {
+    protected readonly runtime: OIMComputativeRuntime;
+    protected readonly sourceDeps: readonly IOIMSelectorSourceDependency[];
+    protected readonly computedDeps: readonly IOIMSelectorComputedDependency[];
+    private readonly listeners;
+    private sourceUnsubscribers;
+    private computedUnsubscribers;
+    private dequeueResubscribe?;
+    private isResubscribeEnqueued;
+    private isTemporarilyUnsubscribedForFlush;
+    private isDeliveryEnqueued;
+    private dequeueDelivery?;
+    private hasLastValue;
+    private lastValue;
+    protected get queue(): OIMEventQueue;
+    protected constructor(runtime: OIMComputativeRuntime, sourceDeps: readonly IOIMSelectorSourceDependency[], computedDeps?: readonly IOIMSelectorComputedDependency[]);
+    abstract getValue(): TValue;
+    /**
+     * Start watching this selector. The callback is called immediately with the current value,
+     * then coalesced and delivered on `queue.flush()` when the selector invalidates.
+     */
+    watch(onValue: (value: TValue) => void): () => void;
+    protected areEqual(prev: TValue, next: TValue): boolean;
+    private readonly onSourceInvalidate;
+    private readonly onComputedInvalidate;
+    private readonly deliver;
+    private setLastValue;
+    private subscribeToDeps;
+    private unsubscribeFromSourceDeps;
+    private unsubscribeFromAllDeps;
+    private ensureResubscribeAfterFlush;
+    private readonly onAfterFlush;
+}
+
+declare class OIMCollectionByPkSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<TEntity | undefined> {
+    private readonly collection;
+    private readonly pk;
+    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
+    getValue(): TEntity | undefined;
+}
+
+declare class OIMCollectionByPksSelector<TEntity extends object, TPk extends TOIMPk> extends OIMSelector<readonly (TEntity | undefined)[]> {
+    private readonly collection;
+    private readonly pks;
+    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
+    getValue(): readonly (TEntity | undefined)[];
+    protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
+}
+
+declare class OIMObjectValueByKeySelector<TKey extends string, TValue> extends OIMSelector<TValue | undefined> {
+    private readonly obj;
+    private readonly key;
+    constructor(runtime: OIMComputativeRuntime, obj: OIMReactiveObject<TKey, TValue>, key: TKey);
+    getValue(): TValue | undefined;
+}
+
+declare class OIMObjectValuesByKeysSelector<TKey extends string, TValue> extends OIMSelector<readonly (TValue | undefined)[]> {
+    private readonly obj;
+    private readonly keys;
+    constructor(runtime: OIMComputativeRuntime, obj: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
+    getValue(): readonly (TValue | undefined)[];
+    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>> {
+    private readonly reactiveIndex;
+    private readonly key;
+    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
+    getValue(): Set<TPk>;
+}
+
+declare class OIMIndexPksByKeyArrayBasedSelector<TKey extends TOIMPk, TPk extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly TPk[]> {
+    private readonly reactiveIndex;
+    private readonly key;
+    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
+    getValue(): readonly TPk[];
+    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[]> {
+    private readonly reactiveIndex;
+    private readonly keys;
+    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
+    getValue(): readonly TPk[];
+    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[]> {
+    private readonly reactiveIndex;
+    private readonly keys;
+    constructor(runtime: OIMComputativeRuntime, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]);
+    getValue(): readonly TPk[];
+    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)[]> {
+    private readonly collection;
+    private readonly reactiveIndex;
+    private readonly key;
+    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey);
+    getValue(): readonly (TEntity | undefined)[];
+    protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
+}
+
+declare class OIMEntitiesByIndexKeyArrayBasedSelector<TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>> extends OIMSelector<readonly (TEntity | undefined)[]> {
+    private readonly collection;
+    private readonly reactiveIndex;
+    private readonly key;
+    constructor(runtime: OIMComputativeRuntime, collection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey);
+    getValue(): readonly (TEntity | undefined)[];
+    protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
+}
+
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFieldsWrapper, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputativeRuntime, OIMComputed, OIMDBSettings, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListIndexCommandStreamWrapper, OIMPkSelectorFactory, OIMRICollection, OIMReactiveCollection, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, type TOIMCollectionOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMEffectOptions, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptions, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload };