@oimdb/core 3.9.0 → 3.11.0

package/dist/index.d.cts

@@ -90,9 +90,9 @@ declare class OIMEventEmitter<T extends Record<string, unknown>> {
 
 /**
  * Payload for index update events containing the keys that were modified */
-interface TOIMIndexUpdatePayload<TKey> {
+type TOIMIndexUpdatePayload<TKey> = {
     keys: readonly TKey[];
-}
+};
 
 /**
  * Comparator function for index primary key arrays.
@@ -297,6 +297,19 @@ declare abstract class OIMEventQueueScheduler {
      * Trigger a flush event. Should be called by subclasses when they execute the scheduled flush.
      */
     protected flush(): void;
+    /**
+     * Detach a Node timer handle from the event loop, returning it unchanged.
+     *
+     * A pending flush must never be a reason for a process to stay alive: if
+     * nothing else is running there is no UI left to update, and the flush is
+     * moot. Without this a scheduled-but-not-yet-run flush keeps Node awake —
+     * which is why a test suite that leaves a queue scheduled reports
+     * "a worker process has failed to exit gracefully".
+     *
+     * In the browser `setTimeout` returns a number, which has no `unref`, so the
+     * call is guarded and the handle passes straight through.
+     */
+    protected unref<THandle>(handle: THandle): THandle;
 }
 
 declare abstract class OIMIndexSetBased<TKey extends TOIMKey, TPk extends TOIMKey> extends OIMIndex<TKey, TPk, Set<TOIMAnyEntitySlot<TPk>>> {
@@ -384,18 +397,34 @@ type TOIMEventQueueOptions = {
      * If not provided, flush() must be called manually.
      */
     scheduler?: OIMEventQueueScheduler;
+    /**
+     * Handler for an error thrown by a task during flush. When set, the queue
+     * treats the error as handled — it is NOT re-raised out of `flush()`. When
+     * NOT set, the error propagates (loud by default: uncaught in async/scheduled
+     * mode, thrown to the caller of a manual `flush()`).
+     *
+     * Either way the queue's own state is always restored (one failing task never
+     * wedges the queue) and a `FLUSH_ERROR` event is emitted for tooling.
+     */
+    onError?: (error: unknown) => void;
 };
 
-declare enum EOIMEventQueueEventType {
-    AFTER_FLUSH = 0,
-    BEFORE_FLUSH = 1
-}
+/** Payload of the `EOIMEventQueueEventType.FLUSH_ERROR` event. */
+type TOIMFlushError = {
+    /** The value a queue task threw (not necessarily an `Error`). */
+    error: unknown;
+};
 
 /**
  * Event queue that can optionally integrate with a scheduler for automatic flushing.
  */
 declare class OIMEventQueue {
-    readonly emitter: OIMEventEmitter<Record<EOIMEventQueueEventType, void>>;
+    readonly emitter: OIMEventEmitter<{
+        1: void;
+        0: void;
+        2: TOIMFlushError;
+    }>;
+    protected readonly onError?: (error: unknown) => void;
     protected tasks: Set<() => void>;
     protected tasksSpare: Set<() => void>;
     protected flushing?: Set<() => void>;
@@ -414,10 +443,14 @@ declare class OIMEventQueue {
     cancel(fn: () => void): void;
     get isInFlush(): boolean;
     /**
-     * Execute all pending tasks.
+     * Execute the tasks pending at the moment the flush starts — a single pass,
+     * not a drain-to-empty.
      *
-     * This flush drains until the queue is empty. If tasks enqueue more tasks, they will be
-     * executed within the same flush.
+     * The pending set is swapped out for an empty spare up front and the flush
+     * iterates that captured set. Tasks enqueued during the flush land in the
+     * fresh set and run on the NEXT flush, not this one. (Contrast
+     * `OIMComputeRuntime.flush()`, which re-reads its bucket per level and so
+     * does drain same-level tasks scheduled mid-flush.)
      */
     flush(): void;
     /**
@@ -476,6 +509,8 @@ declare class OIMCarrierKeyedEmitter<TKey extends TOIMKey, TCarrier extends IOIM
     private readonly subscribedCarriers;
     private dirtyCarriers;
     private isFlushEnqueued;
+    private multiCarrierSubscriptions;
+    private deliveredPool?;
     constructor(queue: OIMEventQueue, carrierProvider: IOIMCarrierProvider<TKey, TCarrier>);
     subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
@@ -771,7 +806,6 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMKey>
     protected readonly updateEmitter: OIMCarrierKeyedEmitter<TPk, TOIMEntitySlot<TEntity, TPk>>;
     private readonly anyUpdateHandlers;
     private readonly pendingAnyUpdatePks;
-    private isAnyUpdateClearPending;
     private isAnyUpdateScheduled;
     constructor(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>);
     subscribeOnKey(pk: TPk, handler: TOIMEventHandler<void>): () => void;
@@ -788,8 +822,8 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMKey>
         queueLength: number;
     };
     subscribeOnAnyUpdate(handler: (pks: readonly TPk[]) => void): () => void;
-    private notifyLegacy;
-    private notifyLegacyMany;
+    private notifyBatch;
+    private notifyBatchMany;
     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>[];
@@ -800,7 +834,6 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMKey>
     clear(): void;
     private trackAnyUpdatePk;
     private trackAnyUpdatePks;
-    private trackAnyUpdateClear;
     private ensureAnyUpdateEnqueued;
     private readonly runAnyUpdate;
     destroy(): void;
@@ -1135,6 +1168,7 @@ declare abstract class OIMOrderedListCommandBuffer<TKey extends TOIMKey, TItem>
     readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
     private readonly unsubscribeAfterFlush;
     protected readonly commandsByKey: Map<TKey, TOIMOrderedListCommand<TItem>[]>;
+    private readonly staleResetKeys;
     constructor(queue: OIMEventQueue);
     /** Current ordered items for `key` (the driver's backing order). */
     abstract getItemsByKey(key: TKey): readonly TItem[];
@@ -1143,6 +1177,13 @@ declare abstract class OIMOrderedListCommandBuffer<TKey extends TOIMKey, TItem>
     consumeCommands(key: TKey): TOIMOrderedListCommand<TItem>[];
     destroy(): void;
     private readonly onAfterFlush;
+    /**
+     * Rebuild a deferred leading `reset` from the current order, once, at read
+     * time. All the post-reset edits that were folded in are already reflected
+     * in the driver's backing order, so a single rebuild here is equivalent to
+     * having recomputed the reset on each of those edits.
+     */
+    private materializeStaleReset;
     protected appendCommand(key: TKey, cmd: TOIMOrderedListCommand<TItem>): void;
     protected appendResetCommand(key: TKey, items: readonly TItem[]): void;
     protected createResetCommand(items: readonly TItem[]): TOIMOrderedListCommand<TItem>;
@@ -1725,6 +1766,45 @@ declare class OIMCollectionIndexFactory<TEntity extends object, TPk extends TOIM
 }
 declare function createOIMCollectionIndexFactory<TEntity extends object, TPk extends TOIMKey>(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>): OIMCollectionIndexFactory<TEntity, TPk>;
 
+type TOIMDerivedCollectionOptions<TDerived extends object, TPk extends TOIMKey> = {
+    /**
+     * Skip a downstream update when a source change leaves the re-derived entity
+     * equal. Default `Object.is` (a fresh object each derive → always different,
+     * so it propagates every source change; pass a shallow/field compare to
+     * memoize finer).
+     */
+    compare?: (a: TDerived, b: TDerived) => boolean;
+    /** Custom store — pass a trie-driven store when the source PK is composite. */
+    store?: OIMCollectionStore<TDerived, TPk>;
+    /** Build from the source's current contents at construction (default true). */
+    buildInitial?: boolean;
+};
+/**
+ * A reactive collection whose entities are derived one-to-one from a source
+ * collection: `derived[pk] = derive(source[pk])`, keyed by the SOURCE pk. It
+ * listens to the source and keeps itself in sync — add / update / remove.
+ *
+ * It is a first-class `OIMReactiveCollection`, so it can be indexed, selected,
+ * and derived-from again (join → join). Maintenance runs on the source's
+ * synchronous UPDATE channel, so a chain of derivations stays consistent within
+ * the same flush; delivery to keyed subscribers is batched on flush as usual.
+ *
+ * Parallels `OIMDerivedCollectionIndex*`: the source stays the single source of
+ * truth, and this needs no compute runtime — it is driven purely by the source's
+ * update events.
+ */
+declare class OIMDerivedCollection<TSource extends object, TDerived extends object, TPk extends TOIMKey> extends OIMReactiveCollection<TDerived, TPk> {
+    private readonly source;
+    private readonly derive;
+    private readonly compareDerived;
+    private readonly unsubscribeFromSource;
+    constructor(queue: OIMEventQueue, source: OIMReactiveCollection<TSource, TPk>, derive: (entity: TSource, pk: TPk) => TDerived, opts?: TOIMDerivedCollectionOptions<TDerived, TPk>);
+    rebuildFromSource(): void;
+    destroy(): void;
+    private readonly onSourceUpdate;
+    private syncPk;
+}
+
 /**
  * Payload type for update events that contain keys */
 type TOIMUpdatePayload<TKey> = {
@@ -2285,9 +2365,18 @@ declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMKey>
     }, TPk>;
 }
 
+interface IOIMEffectDependency {
+    subscribe(onUpdate: () => void): () => void;
+}
+
 /**
  * Computative runtime that schedules derived computations by levels and runs them
  * on `queue.flush()` boundary (AFTER_FLUSH).
+ *
+ * Buckets are held in an array indexed by topological level (levels are dense
+ * small non-negative ints), not a `Map` — so the hot schedule/drain path indexes
+ * directly with no hashing. The per-level `Set`s are POOLED: kept in their slot
+ * and `.clear()`ed between flushes rather than re-allocated.
  */
 declare class OIMComputeRuntime {
     readonly queue: OIMEventQueue;
@@ -2297,7 +2386,36 @@ declare class OIMComputeRuntime {
     private maxLevel;
     private readonly dirtyByLevel;
     private readonly afterFlushTasks;
+    private readonly levelByComputed;
+    private readonly unsubscribeFromQueue;
+    private _isDestroyed;
     constructor(queue: OIMEventQueue);
+    /**
+     * Whether {@link destroy} has run. A destroyed runtime is detached from its
+     * queue and must not be reused — `getOIMComputeRuntime` reads this to hand
+     * out a fresh runtime instead of a dead one.
+     */
+    get isDestroyed(): boolean;
+    /**
+     * Detach from the queue and drop everything pending.
+     *
+     * Without this the AFTER_FLUSH subscription lives as long as the queue does,
+     * even once every computed / effect on this runtime is gone — harmless (the
+     * handler early-returns) but impossible to unwind. Destroying does NOT
+     * destroy the nodes scheduled on it; destroy them first, then the runtime.
+     * Idempotent.
+     */
+    destroy(): void;
+    /**
+     * Topological depth for a node with these dependencies: one above the deepest
+     * computed dependency (source-only → 0). The engine owns this — callers pass
+     * their dependencies and get back a level, they never compute it themselves.
+     */
+    computeLevel(deps: readonly IOIMEffectDependency[]): number;
+    /** Record a computed's depth so its dependents can look it up. */
+    registerLevel(computed: object, level: number): void;
+    /** The recorded topological depth of a computed (0 if unknown). Introspection. */
+    getLevel(computed: object): number;
     /**
      * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
      * ordered by `level` ascending.
@@ -2309,6 +2427,7 @@ declare class OIMComputeRuntime {
      */
     scheduleAfterFlush(task: () => void): () => void;
     private flush;
+    private recomputePendingRange;
 }
 
 interface IOIMSelectorComputedDependency {
@@ -2377,12 +2496,160 @@ declare class OIMCollectionSelectors<TEntity extends object, TPk extends TOIMKey
     entitiesBySetGlobalIndex<TIndex extends OIMGlobalIndexSetBased<TPk>>(index: OIMReactiveGlobalIndexSetBased<TPk, TIndex>): TOIMCollectionEntitiesSelector<TEntity>;
 }
 
+type TOIMComputedOptions<TValue> = {
+    compute: () => TValue;
+    deps?: readonly IOIMEffectDependency[];
+    compare?: (a: TValue, b: TValue) => boolean;
+};
+
+type TOIMComputedUpdatePayload<TKey extends TOIMKey> = {
+    keys: readonly TKey[];
+};
+
+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: OIMComputeRuntime, opts: TOIMComputedOptions<TValue>);
+    get needsRecompute(): boolean;
+    get isReady(): boolean;
+    get deps(): readonly IOIMEffectDependency[];
+    get(): TValue;
+    getIfReady(): TValue | undefined;
+    destroy(): void;
+    private recomputeAndEmitIfChanged;
+}
+
+declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMKey> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
+    get source(): OIMReactiveCollection<TEntity, TPk>;
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMKey> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
+    get source(): IOIMKeyedSubscription<TKey>;
+    subscribe(onUpdate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(object: OIMReactiveObject<TKey, TValue>, key: TKey);
+    get source(): OIMReactiveObject<TKey, TValue>;
+    subscribe(onUpdate: () => void): () => void;
+}
+
+type TOIMComputedKey$1 = 'value';
+type TOIMComputedLike = {
+    emitter: OIMEventEmitter<{
+        update: TOIMComputedUpdatePayload<TOIMComputedKey$1>;
+    }>;
+    updateEventEmitter: OIMUpdateEventEmitter<TOIMComputedKey$1>;
+};
+/**
+ * Effect dependency on a computed. Carries the computed itself (`source`) so the
+ * runtime can look up its topological depth — the level lives in the runtime,
+ * not on this dependency.
+ */
+declare class OIMEffectDependencyComputed implements IOIMEffectDependency {
+    readonly source: TOIMComputedLike;
+    constructor(source: TOIMComputedLike);
+    subscribe(onUpdate: () => void): () => void;
+}
+
+/**
+ * Dependency builders for `computed` / `effect`. They pick the right wrapper for
+ * each source type so you never instantiate `OIMEffectDependency…` by hand:
+ *
+ * ```ts
+ * kit.computed(
+ *   [on.collection(users, 'u1'), on.index(byRole, 'admin'), on.computed(orderCount)],
+ *   () => …,
+ * );
+ * ```
+ */
+declare const on: {
+    /** Depend on one PK of a collection. */
+    collection: <TEntity extends object, TPk extends TOIMKey>(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk) => OIMEffectDependencyKeyedCollection<TEntity, TPk>;
+    /** Depend on one key of an index. */
+    index: <TKey extends TOIMKey>(index: IOIMKeyedSubscription<TKey>, key: TKey) => OIMEffectDependencyKeyedIndex<TKey>;
+    /** Depend on one key of a reactive object. */
+    object: <TKey extends string, TValue>(object: OIMReactiveObject<TKey, TValue>, key: TKey) => OIMEffectDependencyKeyedObject<TKey, TValue>;
+    /** Depend on another computed. */
+    computed: <TValue>(computed: OIMComputed<TValue>) => OIMEffectDependencyComputed;
+};
+
+type TOIMEffectOptions = {
+    deps?: readonly IOIMEffectDependency[];
+    onUpdate?: () => void;
+    run: () => void;
+};
+
+declare class OIMEffect {
+    private readonly runtime;
+    private readonly onUpdate?;
+    private readonly run;
+    private readonly deps;
+    /**
+     * Topological depth, owned by the runtime — one above the deepest computed
+     * dependency (source-only effects are `0`). Passed to `runtime.schedule` so
+     * this node runs only after everything it depends on. Internal: nodes never
+     * expose their own level.
+     */
+    private readonly level;
+    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: OIMComputeRuntime, opts: TOIMEffectOptions, level?: number);
+    destroy(): void;
+    private onSourceInvalidate;
+    private onComputedInvalidate;
+    private runOnce;
+    private subscribeToDeps;
+    private unsubscribeFromSourceDeps;
+    private unsubscribeFromAllDeps;
+    private ensureResubscribeAfterFlush;
+    private readonly onAfterFlush;
+}
+
 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>;
+    /** Dependency builders for `computed` / `effect` (no manual wrapper classes). */
+    on: typeof on;
+    /**
+     * Create a computed on the queue's shared runtime and add it to `scope`.
+     * Deps come from `on.*` and may reference any source sharing the queue.
+     */
+    computed: <TValue>(deps: readonly IOIMEffectDependency[], compute: () => TValue, options?: {
+        compare?: (a: TValue, b: TValue) => boolean;
+    }) => OIMComputed<TValue>;
+    /** Create an effect on the queue's shared runtime and add it to `scope`. */
+    effect: (deps: readonly IOIMEffectDependency[], run: () => void, options?: {
+        onUpdate?: () => void;
+    }) => OIMEffect;
     /**
      * Dispose scope owning the kit's collection. `add()` indexes/streams/
      * subscriptions you create off the kit, then `destroy()` tears them all down
@@ -2396,6 +2663,51 @@ type TOIMCollectionKit<TEntity extends object, TPk extends TOIMKey> = {
 
 declare function createOIMCollectionKit<TEntity extends object, TPk extends TOIMKey>(queue: OIMEventQueue, opts?: TOIMReactiveCollectionFactoryOptions<TEntity, TPk>): TOIMCollectionKit<TEntity, TPk>;
 
+/**
+ * The ONE compute runtime for a queue. Every computed / effect / selector that
+ * shares a queue must share a runtime — they form one dependency graph, and
+ * levels + scheduling live per-runtime. Created lazily on first use and cached
+ * (per queue, garbage-collected with it), so cross-collection computeds all
+ * schedule on the same topological pass.
+ *
+ * A runtime that was destroyed is replaced rather than handed back: it is
+ * detached from the queue and would never drain again.
+ *
+ * See `peekOIMComputeRuntime` to read without creating, and
+ * `setOIMComputeRuntime` to install your own.
+ */
+declare function getOIMComputeRuntime(queue: OIMEventQueue): OIMComputeRuntime;
+
+/**
+ * The runtime already attached to `queue`, or `undefined` — WITHOUT creating one.
+ *
+ * The read-only counterpart of `getOIMComputeRuntime`, for code that must not
+ * change what it observes: devtools asking "does this queue even have a compute
+ * graph", teardown checking whether there is anything to destroy, assertions in
+ * tests. A runtime that has been destroyed reads as `undefined`, matching what
+ * `getOIMComputeRuntime` would then replace — so a caller cannot get hold of a
+ * detached runtime through this door either.
+ */
+declare function peekOIMComputeRuntime(queue: OIMEventQueue): OIMComputeRuntime | undefined;
+
+/**
+ * Install `runtime` as the one runtime for `queue`, replacing whatever was there.
+ *
+ * The injection seam for a subclassed runtime — an instrumented one that records
+ * levels and drain order, a profiling one, a test double. Call it BEFORE anything
+ * touches the queue's compute graph: nodes capture their runtime at construction,
+ * so swapping afterwards leaves the existing ones on the old instance and splits
+ * the dependency graph in two, which is exactly the glitch the one-runtime-per-
+ * queue rule exists to prevent.
+ *
+ * `runtime.queue` must be `queue` — a runtime drains on its own queue's
+ * AFTER_FLUSH, so a mismatched pair would never run.
+ *
+ * Replacing does NOT destroy the previous runtime: whoever installs a replacement
+ * decides whether the old one still has live nodes on it.
+ */
+declare function setOIMComputeRuntime(queue: OIMEventQueue, runtime: OIMComputeRuntime): void;
+
 type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
 /**
  * Tracks changed fields per entity PK for an `OIMCollection`.
@@ -2894,6 +3206,18 @@ declare enum EOIMIndexEventType {
     UPDATE = 0
 }
 
+declare enum EOIMEventQueueEventType {
+    AFTER_FLUSH = 0,
+    BEFORE_FLUSH = 1,
+    /**
+     * A task threw during flush. Emitted once per failing task, ALWAYS (whether
+     * or not an `onError` handler is installed) — an observation channel for
+     * tooling (devtools / MCP). It does not replace the error being raised: with
+     * no `onError` handler the error still propagates out of `flush()`.
+     */
+    FLUSH_ERROR = 2
+}
+
 declare enum EOIMObjectEventType {
     UPDATE = 0
 }
@@ -2931,88 +3255,17 @@ declare class OIMDBSettings {
     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 TOIMKey> = {
-    keys: readonly TKey[];
-};
-
-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: OIMComputeRuntime, opts: TOIMComputedOptions<TValue>);
-    get needsRecompute(): boolean;
-    get isReady(): boolean;
-    get deps(): readonly IOIMEffectDependency[];
-    get(): TValue;
-    getIfReady(): TValue | undefined;
-    destroy(): void;
-    private recomputeAndEmitIfChanged;
-}
-
 declare enum EOIMComputedEventType {
     UPDATE = "update"
 }
 
-type TOIMComputedKey$1 = 'value';
+type TOIMComputedKey = 'value';
 interface IOIMComputedEventSource {
     emitter: OIMEventEmitter<{
-        [EOIMComputedEventType.UPDATE]: TOIMComputedUpdatePayload<TOIMComputedKey$1>;
+        [EOIMComputedEventType.UPDATE]: TOIMComputedUpdatePayload<TOIMComputedKey>;
     }>;
 }
 
-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: OIMComputeRuntime, opts: TOIMEffectOptions);
-    destroy(): void;
-    private onSourceInvalidate;
-    private onComputedInvalidate;
-    private runOnce;
-    private subscribeToDeps;
-    private unsubscribeFromSourceDeps;
-    private unsubscribeFromAllDeps;
-    private ensureResubscribeAfterFlush;
-    private readonly onAfterFlush;
-}
-
 /**
  * Depends on updates to ONE key of a keyed source. The key argument is the whole
  * key — a composite key `[a, b]` is one key, never split — so there is no
@@ -3026,43 +3279,6 @@ declare class OIMEffectDependencyKeyed<TKey extends TOIMKey> implements IOIMEffe
     subscribe(onUpdate: () => void): () => void;
 }
 
-declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implements IOIMEffectDependency {
-    private readonly dep;
-    constructor(object: OIMReactiveObject<TKey, TValue>, key: TKey);
-    get source(): OIMReactiveObject<TKey, TValue>;
-    subscribe(onUpdate: () => void): () => void;
-}
-
-declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMKey> implements IOIMEffectDependency {
-    private readonly dep;
-    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
-    get source(): OIMReactiveCollection<TEntity, TPk>;
-    subscribe(onUpdate: () => void): () => void;
-}
-
-declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMKey> implements IOIMEffectDependency {
-    private readonly dep;
-    constructor(index: IOIMKeyedSubscription<TKey>, key: TKey);
-    get source(): IOIMKeyedSubscription<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 {
-    readonly source: TOIMComputedLike;
-    constructor(source: TOIMComputedLike);
-    subscribe(onUpdate: () => void): () => void;
-}
-
 declare class OIMCollectionByPkSelector<TEntity extends object, TPk extends TOIMKey> extends OIMSelector<TEntity | undefined> {
     private readonly collection;
     private readonly pk;
@@ -3158,4 +3374,4 @@ declare class OIMEntitiesByGlobalIndexArrayBasedSelector<TEntity extends object,
     protected areEqual(prev: readonly (TEntity | undefined)[], next: readonly (TEntity | undefined)[]): boolean;
 }
 
-export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierBucketStore, type IOIMCarrierProvider, type IOIMComputedEventSource, type IOIMDisposable, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMGlobalIndexSlotSource, type IOIMIndexSlotSource, type IOIMIndexStore, type IOIMKeyedMap, type IOIMKeyedSet, type IOIMKeyedUpdateEmitter, type IOIMOrderedListCommandSource, type IOIMPkCodec, type IOIMSingleUpdateEmitter, type IOIMSubscribable, type IOIMSubscription, OIMBucketCarrierProvider, OIMCarrierKeyedEmitter, OIMCarrierSingleEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMCollectionStoreTrieDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollectionGlobalIndexArrayBased, OIMDerivedCollectionGlobalIndexSetBased, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMDisposeScope, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByGlobalIndexArrayBasedSelector, OIMEntitiesByGlobalIndexSetBasedSelector, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerSync, OIMEventQueueSchedulerTimeout, OIMGlobalIndex, OIMGlobalIndexArrayBased, OIMGlobalIndexManualArrayBased, OIMGlobalIndexManualSetBased, OIMGlobalIndexSetBased, OIMGlobalIndexSlotMap, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexSlotMap, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMIndexStoreTrieDrivenArrayBased, OIMIndexStoreTrieDrivenSetBased, OIMKeyPathCarrierProvider, OIMKeyedBucketArrayBased, OIMKeyedBucketSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandBuffer, OIMOrderedListCommandStream, OIMOrderedListCommandStreamDiffDriven, OIMOrderedListMappedCommandStream, OIMPkCodecKeyPath, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionGlobalIndexManualArrayBased, OIMReactiveCollectionGlobalIndexManualSetBased, OIMReactiveCollectionIndexCompositeTrieArrayBased, OIMReactiveCollectionIndexCompositeTrieSetBased, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveGlobalIndex, OIMReactiveGlobalIndexArrayBased, OIMReactiveGlobalIndexManualArrayBased, OIMReactiveGlobalIndexManualSetBased, OIMReactiveGlobalIndexSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, OIMTrieMap, OIMTrieSet, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionGlobalIndexArrayBasedOptions, type TOIMCollectionGlobalIndexSetBasedOptions, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexCompositeArrayBasedOptions, type TOIMCollectionIndexCompositeSetBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionGlobalIndexArrayBasedOptions, type TOIMDerivedCollectionGlobalIndexSetBasedOptions, type TOIMDerivedCollectionIndexArrayBasedOptions, type TOIMDerivedCollectionIndexSetBasedOptions, type TOIMDerivedEntityComparator, type TOIMDerivedEntityOrderSelector, type TOIMDerivedEntityOrderValue, type TOIMDerivedIndexKeySelector, type TOIMDisposable, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotGetter, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMGlobalIndexFilter, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMKey, type TOIMKeyPath, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMOrderedListDiffOptions, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsCompositeArrayIndexOptions, type TOIMRelationsCompositeSetIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedGlobalArrayIndexOptions, type TOIMRelationsDerivedGlobalSetIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsGlobalArrayIndexOptions, type TOIMRelationsGlobalSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createInPlaceEntityUpdater, createMergeEntityUpdater, createOIMCollectionIndexFactory, createOIMCollectionKit, createOIMDisposeScope, createOIMGlobalIndexSlotMap, createOIMIndexSlotMap, createOIMOrderedListCommandStreamDiffDriven, createOIMOrderedListMappedCommandStream, diffOrderedListByPk };
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, type IOIMCarrierBucketStore, type IOIMCarrierProvider, type IOIMComputedEventSource, type IOIMDisposable, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, type IOIMGlobalIndexSlotSource, type IOIMIndexSlotSource, type IOIMIndexStore, type IOIMKeyedMap, type IOIMKeyedSet, type IOIMKeyedUpdateEmitter, type IOIMOrderedListCommandSource, type IOIMPkCodec, type IOIMSingleUpdateEmitter, type IOIMSubscribable, type IOIMSubscription, OIMBucketCarrierProvider, OIMCarrierKeyedEmitter, OIMCarrierSingleEmitter, OIMCollection, OIMCollectionByPkSelector, OIMCollectionByPksSelector, OIMCollectionChangedFields, OIMCollectionIndexFactory, OIMCollectionIndexManualOrderedArrayBased, OIMCollectionOrderedListCommandStream, OIMCollectionSelectors, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMCollectionStoreTrieDriven, OIMComparatorFactory, OIMComputeRuntime, OIMComputed, OIMDBSettings, OIMDerivedCollection, OIMDerivedCollectionGlobalIndexArrayBased, OIMDerivedCollectionGlobalIndexSetBased, OIMDerivedCollectionIndexArrayBased, OIMDerivedCollectionIndexSetBased, OIMDisposeScope, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntitiesByGlobalIndexArrayBasedSelector, OIMEntitiesByGlobalIndexSetBasedSelector, OIMEntitiesByIndexKeyArrayBasedSelector, OIMEntitiesByIndexKeySetBasedSelector, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerSync, OIMEventQueueSchedulerTimeout, OIMGlobalIndex, OIMGlobalIndexArrayBased, OIMGlobalIndexManualArrayBased, OIMGlobalIndexManualSetBased, OIMGlobalIndexSetBased, OIMGlobalIndexSlotMap, OIMIndex, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexPksByKeyArrayBasedSelector, OIMIndexPksByKeySetBasedSelector, OIMIndexPksByKeysArrayBasedSelector, OIMIndexPksByKeysSetBasedSelector, OIMIndexSetBased, OIMIndexSlotMap, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMIndexStoreTrieDrivenArrayBased, OIMIndexStoreTrieDrivenSetBased, OIMKeyPathCarrierProvider, OIMKeyedBucketArrayBased, OIMKeyedBucketSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMObjectValueByKeySelector, OIMObjectValuesByKeysSelector, OIMOrderedListCommandBuffer, OIMOrderedListCommandStream, OIMOrderedListCommandStreamDiffDriven, OIMOrderedListMappedCommandStream, OIMPkCodecKeyPath, OIMPkSelectorFactory, OIMReactiveCollection, OIMReactiveCollectionGlobalIndexManualArrayBased, OIMReactiveCollectionGlobalIndexManualSetBased, OIMReactiveCollectionIndexCompositeTrieArrayBased, OIMReactiveCollectionIndexCompositeTrieSetBased, OIMReactiveCollectionIndexManualArrayBased, OIMReactiveCollectionIndexManualSetBased, OIMReactiveGlobalIndex, OIMReactiveGlobalIndexArrayBased, OIMReactiveGlobalIndexManualArrayBased, OIMReactiveGlobalIndexManualSetBased, OIMReactiveGlobalIndexSetBased, OIMReactiveIndex, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMSelector, OIMTrieMap, OIMTrieSet, type TOIMAnyEntitySlot, type TOIMCollectionEntitiesSelector, type TOIMCollectionEntitySelector, type TOIMCollectionGlobalIndexArrayBasedOptions, type TOIMCollectionGlobalIndexSetBasedOptions, type TOIMCollectionIndexArrayBasedOptions, type TOIMCollectionIndexCompositeArrayBasedOptions, type TOIMCollectionIndexCompositeSetBasedOptions, type TOIMCollectionIndexSetBasedOptions, type TOIMCollectionKit, type TOIMCollectionOptions, type TOIMCollectionOrderedIndexOptions, type TOIMCollectionOrderedListCommandStreamOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMDerivedCollectionGlobalIndexArrayBasedOptions, type TOIMDerivedCollectionGlobalIndexSetBasedOptions, type TOIMDerivedCollectionIndexArrayBasedOptions, type TOIMDerivedCollectionIndexSetBasedOptions, type TOIMDerivedCollectionOptions, type TOIMDerivedEntityComparator, type TOIMDerivedEntityOrderSelector, type TOIMDerivedEntityOrderValue, type TOIMDerivedIndexKeySelector, type TOIMDisposable, type TOIMEffectOptions, type TOIMEntitySlot, type TOIMEntitySlotGetter, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMFlushError, type TOIMGlobalIndexFilter, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMKey, type TOIMKeyPath, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMOrderedListDiffOptions, type TOIMPk, type TOIMPkSelector, type TOIMReactiveCollectionFactoryOptions, type TOIMRelationsArrayIndexOptions, type TOIMRelationsCompositeArrayIndexOptions, type TOIMRelationsCompositeSetIndexOptions, type TOIMRelationsDerivedArrayIndexOptions, type TOIMRelationsDerivedGlobalArrayIndexOptions, type TOIMRelationsDerivedGlobalSetIndexOptions, type TOIMRelationsDerivedSetIndexOptions, type TOIMRelationsGlobalArrayIndexOptions, type TOIMRelationsGlobalSetIndexOptions, type TOIMRelationsOrderedListOptions, type TOIMRelationsSetIndexOptions, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdatePayload, createInPlaceEntityUpdater, createMergeEntityUpdater, createOIMCollectionIndexFactory, createOIMCollectionKit, createOIMDisposeScope, createOIMGlobalIndexSlotMap, createOIMIndexSlotMap, createOIMOrderedListCommandStreamDiffDriven, createOIMOrderedListMappedCommandStream, diffOrderedListByPk, getOIMComputeRuntime, on, peekOIMComputeRuntime, setOIMComputeRuntime };