@oimdb/core 3.9.0 → 3.11.0

package/dist/index.js

@@ -225,6 +225,25 @@ var OIMEventQueueScheduler = class {
   flush() {
     this.emitter.emit(0 /* FLUSH */, void 0);
   }
+  /**
+   * 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.
+   */
+  unref(handle) {
+    const maybeUnrefable = handle;
+    if (typeof maybeUnrefable?.unref === "function") {
+      maybeUnrefable.unref();
+    }
+    return handle;
+  }
 };
 
 // src/core/OIMKeyedBucketSetBased.ts
@@ -559,19 +578,28 @@ var OIMCarrierKeyedEmitter = class {
     // doubles as membership: a carrier is in this array iff `carrier.dirty`.
     this.dirtyCarriers = [];
     this.isFlushEnqueued = false;
+    // Number of live subscriptions whose single handler spans 2+ distinct
+    // carriers (a `subscribeOnKeys` over distinct keys). While this is > 0 a
+    // flush coalesces delivery so such a handler fires at most ONCE per flush,
+    // not once per changed carrier — the callback carries no key, so extra
+    // fires are pure waste. At 0 the hot single-subscriber path pays nothing:
+    // no per-flush Set, no membership checks.
+    this.multiCarrierSubscriptions = 0;
     this.onFlush = () => {
       this.isFlushEnqueued = false;
       if (this.dirtyCarriers.length === 0) return;
       const flushing = this.dirtyCarriers;
       this.dirtyCarriers = [];
+      const delivered = this.multiCarrierSubscriptions > 0 ? this.deliveredPool ?? (this.deliveredPool = /* @__PURE__ */ new Set()) : void 0;
       let i = 0;
       try {
         for (; i < flushing.length; i++) {
           flushing[i].dirty = false;
-          this.notify(flushing[i]);
+          this.notify(flushing[i], delivered);
         }
       } finally {
         for (; i < flushing.length; i++) flushing[i].dirty = false;
+        delivered?.clear();
       }
     };
     this.queue = queue;
@@ -589,7 +617,13 @@ var OIMCarrierKeyedEmitter = class {
       this.addHandler(carrier, handler);
       carriers.push(carrier);
     }
+    const spansMultipleCarriers = carriers.length > 1;
+    if (spansMultipleCarriers) this.multiCarrierSubscriptions++;
+    let unsubscribed = false;
     return () => {
+      if (unsubscribed) return;
+      unsubscribed = true;
+      if (spansMultipleCarriers) this.multiCarrierSubscriptions--;
       for (let i = 0; i < carriers.length; i++) {
         this.removeHandler(carriers[i], handler);
       }
@@ -705,19 +739,31 @@ var OIMCarrierKeyedEmitter = class {
     this.isFlushEnqueued = true;
     this.queue.enqueue(this.onFlush);
   }
-  notify(carrier) {
+  notify(carrier, delivered) {
     const subscribers = carrier.subscribers;
     if (!subscribers || subscribers.size === 0) return;
     if (subscribers.size === 1) {
       const only = subscribers.values().next().value;
-      if (only) only();
+      if (!only) return;
+      if (delivered) {
+        const size = delivered.size;
+        delivered.add(only);
+        if (delivered.size === size) return;
+      }
+      only();
       return;
     }
     const snapshot = [];
     subscribers.forEach((h) => snapshot.push(h));
     for (let i = 0; i < snapshot.length; i++) {
       const handler = snapshot[i];
-      if (subscribers.has(handler)) handler();
+      if (!subscribers.has(handler)) continue;
+      if (delivered) {
+        const size = delivered.size;
+        delivered.add(handler);
+        if (delivered.size === size) continue;
+      }
+      handler();
     }
   }
 };
@@ -1339,8 +1385,11 @@ var OIMCollection = class {
     this.emitter.emit(0 /* UPDATE */, { pks });
   }
   clear() {
+    const pks = this.store.getAllPks();
     this.store.clear();
-    this.emitter.emit(0 /* UPDATE */, { pks: [] });
+    if (pks.length > 0) {
+      this.emitter.emit(0 /* UPDATE */, { pks });
+    }
   }
   countAll() {
     return this.store.countAll();
@@ -1382,14 +1431,12 @@ var OIMReactiveCollection = class extends OIMCollection {
     // Only ever holds `slot.pk` (one canonical reference per logical key), so a
     // native `Set` dedups correctly by reference even for composite pks.
     this.pendingAnyUpdatePks = /* @__PURE__ */ new Set();
-    this.isAnyUpdateClearPending = false;
     this.isAnyUpdateScheduled = false;
     this.runAnyUpdate = () => {
       if (!this.isAnyUpdateScheduled) return;
       this.isAnyUpdateScheduled = false;
-      const pks = this.isAnyUpdateClearPending ? [] : Array.from(this.pendingAnyUpdatePks.values());
+      const pks = Array.from(this.pendingAnyUpdatePks.values());
       this.pendingAnyUpdatePks.clear();
-      this.isAnyUpdateClearPending = false;
       const snapshot = Array.from(this.anyUpdateHandlers);
       for (let i = 0; i < snapshot.length; i++) snapshot[i](pks);
     };
@@ -1429,30 +1476,43 @@ var OIMReactiveCollection = class extends OIMCollection {
       this.anyUpdateHandlers.delete(handler);
     };
   }
-  // The legacy `emitter` (EOIMCollectionEventType.UPDATE) coexists with the
-  // keyed `updateEmitter`. Build its payload only when something is actually
-  // subscribed — otherwise every upsert/remove allocates a throwaway
-  // `{ pks }` object (and array) that nobody reads.
-  notifyLegacy(pk) {
+  // Two notification channels coexist on a reactive collection; they serve
+  // different audiences and NEITHER is obsolete:
+  //   • the keyed `updateEmitter` — per-key/per-carrier pings ("did MY key
+  //     change?", payload-less `void`), for leaf subscribers like React hooks
+  //     that declare the keys they care about up front;
+  //   • this `emitter` UPDATE event — the aggregate/batch channel that carries
+  //     the full list of changed pks in one SYNCHRONOUS callback, for
+  //     consumers that do NOT know their keys ahead of time and must re-derive
+  //     over the batch: derived indexes/collections, changed-fields, persist,
+  //     snapshot-manager. `pks` always enumerates exactly what changed — even
+  //     clear() lists every removed key, so an empty array never occurs.
+  // It is not a per-key emitter with fewer features — it is the opposite
+  // shape (enumerated batch, not "my key"), which is why it stays.
+  //
+  // Emit on the batch channel only when something is actually subscribed —
+  // otherwise every upsert/remove allocates a throwaway `{ pks }` object (and
+  // array) that nobody reads.
+  notifyBatch(pk) {
     if (this.emitter.hasHandlers(0 /* UPDATE */)) {
       this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     }
   }
-  notifyLegacyMany(pks) {
+  notifyBatchMany(pks) {
     if (this.emitter.hasHandlers(0 /* UPDATE */)) {
       this.emitter.emit(0 /* UPDATE */, { pks });
     }
   }
   upsertOneByPk(pk, entity) {
     const slot = this.upsertOneWithoutNotificationsByPk(pk, entity);
-    this.notifyLegacy(pk);
+    this.notifyBatch(pk);
     this.updateEmitter.markUpdatedCarrier(slot);
     this.trackAnyUpdatePk(pk);
     return slot;
   }
   upsertOne(entity) {
     const slot = this.upsertOneWithoutNotifications(entity);
-    this.notifyLegacy(slot.pk);
+    this.notifyBatch(slot.pk);
     this.updateEmitter.markUpdatedCarrier(slot);
     this.trackAnyUpdatePk(slot.pk);
     return slot;
@@ -1463,7 +1523,7 @@ var OIMReactiveCollection = class extends OIMCollection {
       (entity) => this.upsertOneWithoutNotifications(entity)
     );
     const pks = slots.map((slot) => slot.pk);
-    this.notifyLegacyMany(pks);
+    this.notifyBatchMany(pks);
     for (let i = 0; i < slots.length; i++) {
       this.updateEmitter.markUpdatedCarrier(slots[i]);
     }
@@ -1473,7 +1533,7 @@ var OIMReactiveCollection = class extends OIMCollection {
   removeOne(entity) {
     const pk = this.selectPk(entity);
     this.store.removeOneByPk(pk);
-    this.notifyLegacy(pk);
+    this.notifyBatch(pk);
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
@@ -1481,30 +1541,32 @@ var OIMReactiveCollection = class extends OIMCollection {
     if (entities.length === 0) return;
     const pks = entities.map(this.selectPk);
     this.store.removeManyByPks(pks);
-    this.notifyLegacyMany(pks);
+    this.notifyBatchMany(pks);
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   removeOneByPk(pk) {
     this.store.removeOneByPk(pk);
-    this.notifyLegacy(pk);
+    this.notifyBatch(pk);
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   removeManyByPks(pks) {
     if (pks.length === 0) return;
     this.store.removeManyByPks(pks);
-    this.notifyLegacyMany(pks);
+    this.notifyBatchMany(pks);
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   clear() {
+    const needsPks = this.emitter.hasHandlers(0 /* UPDATE */) || this.anyUpdateHandlers.size > 0;
+    const pks = needsPks ? this.store.getAllPks() : void 0;
     this.store.clear();
-    if (this.emitter.hasHandlers(0 /* UPDATE */)) {
-      this.emitter.emit(0 /* UPDATE */, { pks: [] });
+    if (pks && pks.length > 0) {
+      this.notifyBatchMany(pks);
+      this.trackAnyUpdatePks(pks);
     }
     this.updateEmitter.markAllUpdated();
-    this.trackAnyUpdateClear();
   }
   trackAnyUpdatePk(pk) {
     if (this.anyUpdateHandlers.size === 0) return;
@@ -1513,14 +1575,9 @@ var OIMReactiveCollection = class extends OIMCollection {
   }
   trackAnyUpdatePks(pks) {
     if (this.anyUpdateHandlers.size === 0) return;
-    for (let i = 0; i < pks.length; i++)
+    for (let i = 0; i < pks.length; i++) {
       this.pendingAnyUpdatePks.add(pks[i]);
-    this.ensureAnyUpdateEnqueued();
-  }
-  trackAnyUpdateClear() {
-    if (this.anyUpdateHandlers.size === 0) return;
-    this.isAnyUpdateClearPending = true;
-    this.pendingAnyUpdatePks.clear();
+    }
     this.ensureAnyUpdateEnqueued();
   }
   ensureAnyUpdateEnqueued() {
@@ -1699,6 +1756,7 @@ var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrde
 var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["FLUSH_ERROR"] = 2] = "FLUSH_ERROR";
   return EOIMEventQueueEventType2;
 })(EOIMEventQueueEventType || {});
 
@@ -1952,8 +2010,13 @@ var OIMUpdateEventEmitter = class {
 var OIMOrderedListCommandBuffer = class {
   constructor(queue) {
     this.commandsByKey = /* @__PURE__ */ new Map();
+    // Keys whose buffered leading `reset` is stale: an edit after the reset
+    // should be folded into it, but we defer the (O(list-size)) rebuild to the
+    // next read instead of redoing it on every subsequent edit in the batch.
+    this.staleResetKeys = /* @__PURE__ */ new Set();
     this.onAfterFlush = () => {
       this.commandsByKey.clear();
+      this.staleResetKeys.clear();
     };
     this.commandsEventEmitter = new OIMUpdateEventEmitter(
       queue,
@@ -1968,9 +2031,11 @@ var OIMOrderedListCommandBuffer = class {
     return this.commandsEventEmitter.subscribeOnKey(key, handler);
   }
   getBufferedCommands(key) {
+    this.materializeStaleReset(key);
     return this.commandsByKey.get(key) ?? [];
   }
   consumeCommands(key) {
+    this.materializeStaleReset(key);
     const cmds = this.commandsByKey.get(key);
     if (!cmds || cmds.length === 0) return [];
     return cmds.slice();
@@ -1979,6 +2044,20 @@ var OIMOrderedListCommandBuffer = class {
     this.commandsEventEmitter.destroy();
     this.unsubscribeAfterFlush();
     this.commandsByKey.clear();
+    this.staleResetKeys.clear();
+  }
+  /**
+   * 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.
+   */
+  materializeStaleReset(key) {
+    if (!this.staleResetKeys.delete(key)) return;
+    const cmds = this.commandsByKey.get(key);
+    if (cmds && cmds.length > 0 && cmds[0].type === "reset") {
+      cmds[0] = this.createResetCommand(this.getItemsByKey(key));
+    }
   }
   appendCommand(key, cmd) {
     let cmds = this.commandsByKey.get(key);
@@ -1989,8 +2068,9 @@ var OIMOrderedListCommandBuffer = class {
     if (cmd.type === "reset") {
       cmds.length = 0;
       cmds.push(cmd);
+      this.staleResetKeys.delete(key);
     } else if (cmds.length > 0 && cmds[0].type === "reset") {
-      cmds[0] = this.createResetCommand(this.getItemsByKey(key));
+      this.staleResetKeys.add(key);
     } else {
       cmds.push(cmd);
     }
@@ -3032,10 +3112,6 @@ var OIMDerivedCollectionIndexSetBased = class extends OIMReactiveCollectionIndex
     });
     this.keysByPk = /* @__PURE__ */ new Map();
     this.onCollectionUpdate = (pks) => {
-      if (pks.length === 0) {
-        this.rebuildFromCollection();
-        return;
-      }
       for (const pk of pks) {
         this.syncPk(pk);
       }
@@ -3137,10 +3213,6 @@ var OIMDerivedCollectionIndexArrayBased = class extends OIMReactiveCollectionInd
     // touching an unrelated field can skip re-sorting when the value is unchanged.
     this.orderValueByPk = /* @__PURE__ */ new Map();
     this.onCollectionUpdate = (pks) => {
-      if (pks.length === 0) {
-        this.rebuildFromCollection();
-        return;
-      }
       const ordered = !!(this.compareEntities || this.orderBy);
       const keysToSort = ordered ? /* @__PURE__ */ new Set() : null;
       for (const pk of pks) {
@@ -3557,10 +3629,6 @@ var OIMDerivedCollectionGlobalIndexArrayBased = class extends OIMReactiveCollect
     // an unrelated field can skip re-sorting when the value is unchanged.
     this.orderValueByPk = /* @__PURE__ */ new Map();
     this.onCollectionUpdate = (pks) => {
-      if (pks.length === 0) {
-        this.rebuildFromCollection();
-        return;
-      }
       const ordered = !!(this.compareEntities || this.orderBy);
       let needsSort = false;
       for (const pk of pks) {
@@ -3658,10 +3726,6 @@ var OIMDerivedCollectionGlobalIndexSetBased = class extends OIMReactiveCollectio
     super(queue, { collection, indexOptions: opts.indexOptions });
     this.presentPks = /* @__PURE__ */ new Set();
     this.onCollectionUpdate = (pks) => {
-      if (pks.length === 0) {
-        this.rebuildFromCollection();
-        return;
-      }
       for (const pk of pks) {
         const prev = this.presentPks.has(pk);
         const slot = this.collection.getSlotByPk(pk);
@@ -3837,6 +3901,55 @@ function createOIMCollectionIndexFactory(queue, collection) {
   return new OIMCollectionIndexFactory(queue, collection);
 }
 
+// src/core/OIMDerivedCollection.ts
+var OIMDerivedCollection = class extends OIMReactiveCollection {
+  constructor(queue, source, derive, opts) {
+    super(queue, {
+      store: opts?.store,
+      // Each sync recomputes the WHOLE derived entity → replace, not merge.
+      updateEntity: (draft) => draft
+    });
+    this.onSourceUpdate = (pks) => {
+      for (let i = 0; i < pks.length; i++) this.syncPk(pks[i]);
+    };
+    this.source = source;
+    this.derive = derive;
+    this.compareDerived = opts?.compare ?? Object.is;
+    this.unsubscribeFromSource = source.emitter.on(
+      0 /* UPDATE */,
+      (payload) => this.onSourceUpdate(payload.pks)
+    );
+    if (opts?.buildInitial !== false) {
+      this.rebuildFromSource();
+    }
+  }
+  rebuildFromSource() {
+    for (const pk of this.getAllPks()) {
+      if (this.source.getOneByPk(pk) === void 0) {
+        this.removeOneByPk(pk);
+      }
+    }
+    for (const slot of this.source.getAllSlots()) {
+      if (slot.item !== void 0) this.syncPk(slot.pk);
+    }
+  }
+  destroy() {
+    this.unsubscribeFromSource();
+    super.destroy();
+  }
+  syncPk(pk) {
+    const sourceEntity = this.source.getOneByPk(pk);
+    if (sourceEntity === void 0) {
+      if (this.getOneByPk(pk) !== void 0) this.removeOneByPk(pk);
+      return;
+    }
+    const next = this.derive(sourceEntity, pk);
+    const prev = this.getOneByPk(pk);
+    if (prev !== void 0 && this.compareDerived(prev, next)) return;
+    this.upsertOneByPk(pk, next);
+  }
+};
+
 // src/core/OIMObjectStoreRecordDriven.ts
 var OIMObjectStoreRecordDriven = class extends OIMObjectStore {
   constructor(initial) {
@@ -3909,8 +4022,11 @@ var OIMObject = class {
     return this.store.getAll();
   }
   clear() {
+    const keys = this.store.keys();
     this.store.clear();
-    this.onUpdatedKeys([]);
+    if (keys.length > 0) {
+      this.onUpdatedKeys(keys);
+    }
   }
   /**
    * Write fan-out hooks. Split single-key vs multi-key so a reactive subclass
@@ -4213,8 +4329,9 @@ var OIMComparatorFactory = class {
       if (ka.length !== kb.length) return true;
       for (let i = 0; i < ka.length; i++) {
         const k = ka[i];
-        if (b[k] !== a[k])
+        if (b[k] !== a[k]) {
           return true;
+        }
       }
       return false;
     };
@@ -4236,6 +4353,7 @@ var OIMEventQueue = class {
     this.tasksSpare = /* @__PURE__ */ new Set();
     this.isFlushing = false;
     this.scheduler = options.scheduler;
+    this.onError = options.onError;
     if (this.scheduler) {
       this.flushBound = () => this.flush();
       this.scheduler.on(
@@ -4263,10 +4381,14 @@ var OIMEventQueue = class {
     return this.isFlushing;
   }
   /**
-   * 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() {
     this.scheduler?.cancel();
@@ -4275,12 +4397,34 @@ var OIMEventQueue = class {
     const flushing = this.tasks;
     this.tasks = this.tasksSpare;
     this.flushing = flushing;
-    for (const task of flushing) task();
-    flushing.clear();
-    this.tasksSpare = flushing;
-    this.flushing = void 0;
-    this.isFlushing = false;
+    let errors;
+    try {
+      for (const task of flushing) {
+        try {
+          task();
+        } catch (error) {
+          (errors ?? (errors = [])).push(error);
+          this.emitter.emit(2 /* FLUSH_ERROR */, {
+            error
+          });
+          this.onError?.(error);
+        }
+      }
+    } finally {
+      flushing.clear();
+      this.tasksSpare = flushing;
+      this.flushing = void 0;
+      this.isFlushing = false;
+    }
     this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
+    if (errors && this.onError === void 0) {
+      if (errors.length === 1) throw errors[0];
+      const AggregateErrorCtor = globalThis.AggregateError;
+      throw AggregateErrorCtor ? new AggregateErrorCtor(
+        errors,
+        "Errors thrown during queue flush"
+      ) : errors[0];
+    }
   }
   /**
    * Get the current number of queued functions.
@@ -4518,20 +4662,92 @@ var OIMPkCodecKeyPath = class {
   }
 };
 
+// src/modules/effect/core/OIMEffectDependencyComputed.ts
+var OIMEffectDependencyComputed = class {
+  constructor(source) {
+    this.source = source;
+  }
+  subscribe(onUpdate) {
+    return this.source.emitter.on("update", onUpdate);
+  }
+};
+
 // src/modules/compute/core/OIMComputeRuntime.ts
 var OIMComputeRuntime = class {
   constructor(queue) {
     this.queue = queue;
     this.isFlushScheduled = false;
     this.isFlushing = false;
+    // Active level range (min > max means nothing pending).
     this.minLevel = Infinity;
     this.maxLevel = -Infinity;
-    this.dirtyByLevel = /* @__PURE__ */ new Map();
+    this.dirtyByLevel = [];
     this.afterFlushTasks = /* @__PURE__ */ new Set();
-    this.queue.emitter.on(0 /* AFTER_FLUSH */, () => {
-      if (!this.isFlushScheduled) return;
-      this.flush();
-    });
+    // Topological depth per computed node — the engine is the ONLY owner of
+    // levels; nodes never expose their own. A node's dependents look up its depth
+    // here (by the computed reference their dependency wraps). Written once at
+    // construction, never on the hot flush path.
+    this.levelByComputed = /* @__PURE__ */ new WeakMap();
+    this._isDestroyed = false;
+    this.unsubscribeFromQueue = this.queue.emitter.on(
+      0 /* AFTER_FLUSH */,
+      () => {
+        if (!this.isFlushScheduled) return;
+        this.flush();
+      }
+    );
+  }
+  /**
+   * 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() {
+    return this._isDestroyed;
+  }
+  /**
+   * 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() {
+    if (this._isDestroyed) return;
+    this._isDestroyed = true;
+    this.unsubscribeFromQueue();
+    for (let i = 0; i < this.dirtyByLevel.length; i++) {
+      this.dirtyByLevel[i]?.clear();
+    }
+    this.afterFlushTasks.clear();
+    this.minLevel = Infinity;
+    this.maxLevel = -Infinity;
+    this.isFlushScheduled = false;
+  }
+  /**
+   * 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) {
+    let max = -1;
+    for (const dep of deps) {
+      if (dep instanceof OIMEffectDependencyComputed) {
+        const depLevel = this.levelByComputed.get(dep.source) ?? 0;
+        if (depLevel > max) max = depLevel;
+      }
+    }
+    return max + 1;
+  }
+  /** Record a computed's depth so its dependents can look it up. */
+  registerLevel(computed, level) {
+    this.levelByComputed.set(computed, level);
+  }
+  /** The recorded topological depth of a computed (0 if unknown). Introspection. */
+  getLevel(computed) {
+    return this.levelByComputed.get(computed) ?? 0;
   }
   /**
    * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
@@ -4543,10 +4759,10 @@ var OIMComputeRuntime = class {
       if (!isActive) return;
       task();
     };
-    let bucket = this.dirtyByLevel.get(level);
-    if (!bucket) {
+    let bucket = this.dirtyByLevel[level];
+    if (bucket === void 0) {
       bucket = /* @__PURE__ */ new Set();
-      this.dirtyByLevel.set(level, bucket);
+      this.dirtyByLevel[level] = bucket;
     }
     bucket.add(wrapped);
     if (level < this.minLevel) this.minLevel = level;
@@ -4578,7 +4794,7 @@ var OIMComputeRuntime = class {
   }
   flush() {
     this.isFlushScheduled = false;
-    if (this.dirtyByLevel.size === 0 && this.afterFlushTasks.size === 0)
+    if (this.minLevel > this.maxLevel && this.afterFlushTasks.size === 0)
       return;
     this.isFlushing = true;
     try {
@@ -4587,15 +4803,15 @@ var OIMComputeRuntime = class {
         this.afterFlushTasks.clear();
         for (let i = 0; i < snapshot.length; i++) snapshot[i]();
       }
-      if (this.dirtyByLevel.size === 0) return;
+      if (this.minLevel > this.maxLevel) return;
       let level = this.minLevel;
       let max = this.maxLevel;
       while (level <= max) {
         for (; ; ) {
-          const bucket = this.dirtyByLevel.get(level);
-          if (!bucket || bucket.size === 0) break;
-          this.dirtyByLevel.delete(level);
+          const bucket = this.dirtyByLevel[level];
+          if (bucket === void 0 || bucket.size === 0) break;
           const snapshot = Array.from(bucket);
+          bucket.clear();
           for (let i = 0; i < snapshot.length; i++) snapshot[i]();
         }
         if (this.maxLevel > max) max = this.maxLevel;
@@ -4603,24 +4819,38 @@ var OIMComputeRuntime = class {
       }
     } finally {
       this.isFlushing = false;
-      if (this.dirtyByLevel.size === 0) {
-        this.minLevel = Infinity;
-        this.maxLevel = -Infinity;
-      } else {
-        let nextMin = Infinity;
-        let nextMax = -Infinity;
-        this.dirtyByLevel.forEach((_bucket, lvl) => {
-          if (lvl < nextMin) nextMin = lvl;
-          if (lvl > nextMax) nextMax = lvl;
-        });
-        this.minLevel = nextMin;
-        this.maxLevel = nextMax;
-        this.isFlushScheduled = true;
+      this.recomputePendingRange();
+    }
+  }
+  recomputePendingRange() {
+    let nextMin = Infinity;
+    let nextMax = -Infinity;
+    const buckets = this.dirtyByLevel;
+    for (let i = 0; i < buckets.length; i++) {
+      const bucket = buckets[i];
+      if (bucket !== void 0 && bucket.size > 0) {
+        if (i < nextMin) nextMin = i;
+        if (i > nextMax) nextMax = i;
       }
     }
+    this.minLevel = nextMin;
+    this.maxLevel = nextMax;
+    if (nextMin <= nextMax) this.isFlushScheduled = true;
   }
 };
 
+// src/dx/oimComputeRuntimeByQueue.ts
+var oimComputeRuntimeByQueue = /* @__PURE__ */ new WeakMap();
+
+// src/dx/getOIMComputeRuntime.ts
+function getOIMComputeRuntime(queue) {
+  const runtime = oimComputeRuntimeByQueue.get(queue);
+  if (runtime !== void 0 && !runtime.isDestroyed) return runtime;
+  const nextRuntime = new OIMComputeRuntime(queue);
+  oimComputeRuntimeByQueue.set(queue, nextRuntime);
+  return nextRuntime;
+}
+
 // src/modules/selector/core/OIMSelector.ts
 var OIMSelector = class {
   constructor(runtime, sourceDeps, computedDeps = []) {
@@ -4881,8 +5111,9 @@ var OIMEntitiesByIndexKeyArrayBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -4952,8 +5183,9 @@ var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -5017,8 +5249,9 @@ var OIMEntitiesByGlobalIndexArrayBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -5083,8 +5316,9 @@ var OIMEntitiesByGlobalIndexSetBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -5093,7 +5327,7 @@ var OIMEntitiesByGlobalIndexSetBasedSelector = class extends OIMSelector {
 var OIMCollectionSelectors = class {
   constructor(queue, collection) {
     this.collection = collection;
-    this.runtime = new OIMComputeRuntime(queue);
+    this.runtime = getOIMComputeRuntime(queue);
   }
   byPk(pk) {
     return new OIMCollectionByPkSelector(this.runtime, this.collection, pk);
@@ -5160,127 +5394,408 @@ var OIMCollectionSelectors = class {
   }
 };
 
-// src/dx/OIMCollectionKit.ts
-function createOIMCollectionKit(queue, opts) {
-  const collection = new OIMReactiveCollection(queue, opts);
-  const indexFactory = new OIMCollectionIndexFactory(queue, collection);
-  const select = new OIMCollectionSelectors(queue, collection);
-  const scope = new OIMDisposeScope();
-  scope.add(collection);
-  return {
-    queue,
-    collection,
-    indexFactory,
-    select,
-    scope,
-    destroy: () => scope.destroy()
-  };
-}
-
-// src/modules/wrapper/collection/OIMCollectionChangedFields.ts
-var OIMCollectionChangedFields = class {
-  constructor(queue, collection, opts) {
-    this.isInWrite = false;
-    this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
-    // PKs written through this wrapper during the current flush. Their fields are
-    // already tracked accurately via trackPatch, so the flush-time external-write
-    // handler skips them — no redundant diff + snapshot re-clone. Cleared per flush.
-    this.writtenThroughThisFlush = /* @__PURE__ */ new Set();
-    this.changedFieldsByPk = /* @__PURE__ */ new Map();
-    this.changedPksByField = /* @__PURE__ */ new Map();
-    this.onAfterFlush = () => {
-      this.clear();
-      this.writtenThroughThisFlush.clear();
-    };
-    this.onCollectionUpdate = (payload) => {
-      if (this.isInWrite) return;
-      if (payload.pks.length === 0) return;
-      for (let i = 0; i < payload.pks.length; i++) {
-        const pk = payload.pks[i];
-        if (this.writtenThroughThisFlush.has(pk)) continue;
-        this.trackExternalMutationByPk(pk);
-      }
-    };
-    this.collection = collection;
-    this.detectExternalMutations = opts?.detectExternalMutations !== false;
-    this.selectPk = opts?.selectPk ?? (() => {
-      throw new Error(
-        `[OIMCollectionChangedFields]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
-      );
-    });
-    this.changedPksEventEmitter = new OIMUpdateEventEmitter(
-      queue,
-      "after_flush"
-    );
-    this.changedFieldsEventEmitter = new OIMUpdateEventEmitter(queue, "after_flush");
-    this.unsubscribeAfterFlush = queue.emitter.on(
-      0 /* AFTER_FLUSH */,
-      this.onAfterFlush
-    );
-    if (this.detectExternalMutations) {
-      const maybeReactive = collection;
-      this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
-        this.onCollectionUpdate({
-          pks
-        });
-      }) : collection.emitter.on(
-        0 /* UPDATE */,
-        this.onCollectionUpdate
-      );
-    }
-  }
-  upsertOneByPk(pk, patch) {
-    const slot = this.withWrite(() => {
-      this.trackPatch(pk, patch);
-      return this.collection.upsertOneByPk(pk, patch);
-    });
-    this.updateEntitySnapshot(pk);
-    return slot;
+// src/modules/effect/core/OIMEffectDependencyKeyed.ts
+var OIMEffectDependencyKeyed = class {
+  constructor(source, key) {
+    this.source = source;
+    this.key = key;
   }
-  upsertOne(entity) {
-    const slot = this.withWrite(() => {
-      const pk = this.selectPk(entity);
-      this.trackPatch(pk, entity);
-      return this.collection.upsertOne(entity);
-    });
-    this.updateEntitySnapshot(slot.pk);
-    return slot;
+  subscribe(onUpdate) {
+    return this.source.subscribeOnKey(this.key, onUpdate);
   }
-  upsertMany(entities) {
-    const pks = [];
-    const slots = this.withWrite(() => {
-      for (const entity of entities) {
-        const pk = this.selectPk(entity);
-        pks.push(pk);
-        this.trackPatch(pk, entity);
-      }
-      return this.collection.upsertMany(entities);
-    });
-    for (let i = 0; i < pks.length; i++) this.updateEntitySnapshot(pks[i]);
-    return slots;
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedCollection.ts
+var OIMEffectDependencyKeyedCollection = class {
+  constructor(collection, pk) {
+    this.dep = new OIMEffectDependencyKeyed(collection, pk);
   }
-  getChangedFieldsByPk(pk) {
-    return this.changedFieldsByPk.get(pk) ?? /* @__PURE__ */ new Set();
+  get source() {
+    return this.dep.source;
   }
-  consumeChangedFieldsByPk(pk) {
-    const existing = this.changedFieldsByPk.get(pk);
-    if (!existing) return /* @__PURE__ */ new Set();
-    return new Set(existing);
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
-  getChangedPksByField(field) {
-    return this.changedPksByField.get(field) ?? /* @__PURE__ */ new Set();
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
+var OIMEffectDependencyKeyedIndex = class {
+  constructor(index, key) {
+    this.dep = new OIMEffectDependencyKeyed(index, key);
   }
-  consumeChangedPksByField(field) {
-    const existing = this.changedPksByField.get(field);
-    if (!existing) return /* @__PURE__ */ new Set();
-    return new Set(existing);
+  get source() {
+    return this.dep.source;
   }
-  clear() {
-    this.changedFieldsByPk.clear();
-    this.changedPksByField.clear();
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
-  destroy() {
-    this.changedPksEventEmitter.destroy();
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedObject.ts
+var OIMEffectDependencyKeyedObject = class {
+  constructor(object, key) {
+    this.dep = new OIMEffectDependencyKeyed(object, key);
+  }
+  get source() {
+    return this.dep.source;
+  }
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
+  }
+};
+
+// src/dx/on.ts
+var on = {
+  /** Depend on one PK of a collection. */
+  collection: (collection, pk) => new OIMEffectDependencyKeyedCollection(collection, pk),
+  /** Depend on one key of an index. */
+  index: (index, key) => new OIMEffectDependencyKeyedIndex(index, key),
+  /** Depend on one key of a reactive object. */
+  object: (object, key) => new OIMEffectDependencyKeyedObject(object, key),
+  /** Depend on another computed. */
+  computed: (computed) => new OIMEffectDependencyComputed(computed)
+};
+
+// src/modules/effect/core/OIMEffect.ts
+var OIMEffect = class {
+  constructor(runtime, opts, level) {
+    this.sourceDeps = [];
+    this.computedDeps = [];
+    this.sourceUnsubscribers = [];
+    this.computedUnsubscribers = [];
+    this.isResubscribeEnqueued = false;
+    this.isTemporarilyUnsubscribedForFlush = false;
+    this.isScheduled = false;
+    this.runTask = () => {
+      this.isScheduled = false;
+      this.dequeueScheduled = void 0;
+      this.runOnce();
+    };
+    this.onSourceInvalidate = () => {
+      this.onUpdate?.();
+      if (!this.isTemporarilyUnsubscribedForFlush) {
+        this.isTemporarilyUnsubscribedForFlush = true;
+        this.unsubscribeFromSourceDeps();
+        this.ensureResubscribeAfterFlush();
+      }
+      if (this.isScheduled) return;
+      this.isScheduled = true;
+      this.dequeueScheduled = this.runtime.schedule(this.runTask, this.level);
+    };
+    this.onComputedInvalidate = () => {
+      this.onUpdate?.();
+      if (this.isScheduled) return;
+      this.isScheduled = true;
+      this.dequeueScheduled = this.runtime.schedule(this.runTask, this.level);
+    };
+    this.onAfterFlush = () => {
+      if (!this.isResubscribeEnqueued) return;
+      this.isResubscribeEnqueued = false;
+      this.dequeueResubscribe = void 0;
+      this.isTemporarilyUnsubscribedForFlush = false;
+      if (this.sourceUnsubscribers.length === 0) {
+        for (const dep of this.sourceDeps) {
+          this.sourceUnsubscribers.push(
+            dep.subscribe(this.onSourceInvalidate)
+          );
+        }
+      }
+    };
+    this.runtime = runtime;
+    this.onUpdate = opts.onUpdate;
+    this.run = opts.run;
+    this.deps = opts.deps ?? [];
+    for (const dep of this.deps) {
+      if (dep instanceof OIMEffectDependencyComputed) {
+        this.computedDeps.push(dep);
+      } else {
+        this.sourceDeps.push(dep);
+      }
+    }
+    this.level = level ?? this.runtime.computeLevel(this.deps);
+    this.subscribeToDeps();
+  }
+  destroy() {
+    if (this.dequeueScheduled) {
+      this.dequeueScheduled();
+      this.dequeueScheduled = void 0;
+    }
+    this.unsubscribeFromAllDeps();
+    if (this.dequeueResubscribe) {
+      this.dequeueResubscribe();
+      this.dequeueResubscribe = void 0;
+    }
+    this.isResubscribeEnqueued = false;
+    this.isTemporarilyUnsubscribedForFlush = false;
+  }
+  runOnce() {
+    this.run();
+  }
+  subscribeToDeps() {
+    if (this.sourceUnsubscribers.length > 0 || this.computedUnsubscribers.length > 0)
+      return;
+    for (const dep of this.sourceDeps) {
+      this.sourceUnsubscribers.push(
+        dep.subscribe(this.onSourceInvalidate)
+      );
+    }
+    for (const dep of this.computedDeps) {
+      this.computedUnsubscribers.push(
+        dep.subscribe(this.onComputedInvalidate)
+      );
+    }
+  }
+  unsubscribeFromSourceDeps() {
+    if (this.sourceUnsubscribers.length === 0) return;
+    for (const unsubscribe of this.sourceUnsubscribers) unsubscribe();
+    this.sourceUnsubscribers = [];
+  }
+  unsubscribeFromAllDeps() {
+    this.unsubscribeFromSourceDeps();
+    if (this.computedUnsubscribers.length === 0) return;
+    for (const unsubscribe of this.computedUnsubscribers) unsubscribe();
+    this.computedUnsubscribers = [];
+  }
+  ensureResubscribeAfterFlush() {
+    if (this.isResubscribeEnqueued) return;
+    this.isResubscribeEnqueued = true;
+    this.dequeueResubscribe = this.runtime.scheduleAfterFlush(
+      this.onAfterFlush
+    );
+  }
+};
+
+// src/modules/computed/enums/EOIMComputedEventType.ts
+var EOIMComputedEventType = /* @__PURE__ */ ((EOIMComputedEventType2) => {
+  EOIMComputedEventType2["UPDATE"] = "update";
+  return EOIMComputedEventType2;
+})(EOIMComputedEventType || {});
+
+// src/modules/computed/core/OIMComputed.ts
+var OIMComputed = class {
+  constructor(runtime, opts) {
+    this.emitter = new OIMEventEmitter();
+    this.hasValue = false;
+    this.isDirty = true;
+    this.runtime = runtime;
+    this.compute = opts.compute;
+    this.compare = opts.compare ?? Object.is;
+    this._deps = opts.deps ?? [];
+    this.updateEventEmitter = new OIMUpdateEventEmitter(
+      this.runtime.queue,
+      "immediate"
+    );
+    const level = this.runtime.computeLevel(this._deps);
+    this.runtime.registerLevel(this, level);
+    this.effect = new OIMEffect(
+      this.runtime,
+      {
+        deps: this._deps,
+        onUpdate: () => {
+          this.isDirty = true;
+        },
+        run: () => {
+          this.recomputeAndEmitIfChanged();
+        }
+      },
+      level
+    );
+  }
+  get needsRecompute() {
+    return this.isDirty;
+  }
+  get isReady() {
+    return this.hasValue;
+  }
+  get deps() {
+    return this._deps;
+  }
+  get() {
+    this.recomputeAndEmitIfChanged();
+    return this.value;
+  }
+  getIfReady() {
+    return this.hasValue ? this.value : void 0;
+  }
+  destroy() {
+    this.effect.destroy();
+    this.updateEventEmitter.destroy();
+    this.emitter.offAll();
+  }
+  recomputeAndEmitIfChanged() {
+    if (!this.isDirty) return;
+    const prev = this.value;
+    const hadPrev = this.hasValue;
+    const next = this.compute();
+    this.value = next;
+    this.hasValue = true;
+    this.isDirty = false;
+    const changed = !hadPrev || !this.compare(prev, next);
+    if (!changed) return;
+    this.emitter.emit("update" /* UPDATE */, {
+      keys: ["value"]
+    });
+    this.updateEventEmitter.markUpdatedKey("value");
+  }
+};
+
+// src/dx/OIMCollectionKit.ts
+function createOIMCollectionKit(queue, opts) {
+  const collection = new OIMReactiveCollection(queue, opts);
+  const indexFactory = new OIMCollectionIndexFactory(queue, collection);
+  const select = new OIMCollectionSelectors(queue, collection);
+  const runtime = getOIMComputeRuntime(queue);
+  const scope = new OIMDisposeScope();
+  scope.add(collection);
+  return {
+    queue,
+    collection,
+    indexFactory,
+    select,
+    on,
+    computed: (deps, compute, options) => {
+      const computed = new OIMComputed(runtime, {
+        deps,
+        compute,
+        compare: options?.compare
+      });
+      scope.add(computed);
+      return computed;
+    },
+    effect: (deps, run, options) => {
+      const effect = new OIMEffect(runtime, {
+        deps,
+        run,
+        onUpdate: options?.onUpdate
+      });
+      scope.add(effect);
+      return effect;
+    },
+    scope,
+    destroy: () => scope.destroy()
+  };
+}
+
+// src/dx/peekOIMComputeRuntime.ts
+function peekOIMComputeRuntime(queue) {
+  const runtime = oimComputeRuntimeByQueue.get(queue);
+  return runtime === void 0 || runtime.isDestroyed ? void 0 : runtime;
+}
+
+// src/dx/setOIMComputeRuntime.ts
+function setOIMComputeRuntime(queue, runtime) {
+  if (runtime.queue !== queue) {
+    throw new Error(
+      "setOIMComputeRuntime: the runtime is attached to a different queue. A runtime drains on its own queue and would never run here."
+    );
+  }
+  oimComputeRuntimeByQueue.set(queue, runtime);
+}
+
+// src/modules/wrapper/collection/OIMCollectionChangedFields.ts
+var OIMCollectionChangedFields = class {
+  constructor(queue, collection, opts) {
+    this.isInWrite = false;
+    this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
+    // PKs written through this wrapper during the current flush. Their fields are
+    // already tracked accurately via trackPatch, so the flush-time external-write
+    // handler skips them — no redundant diff + snapshot re-clone. Cleared per flush.
+    this.writtenThroughThisFlush = /* @__PURE__ */ new Set();
+    this.changedFieldsByPk = /* @__PURE__ */ new Map();
+    this.changedPksByField = /* @__PURE__ */ new Map();
+    this.onAfterFlush = () => {
+      this.clear();
+      this.writtenThroughThisFlush.clear();
+    };
+    this.onCollectionUpdate = (payload) => {
+      if (this.isInWrite) return;
+      if (payload.pks.length === 0) return;
+      for (let i = 0; i < payload.pks.length; i++) {
+        const pk = payload.pks[i];
+        if (this.writtenThroughThisFlush.has(pk)) continue;
+        this.trackExternalMutationByPk(pk);
+      }
+    };
+    this.collection = collection;
+    this.detectExternalMutations = opts?.detectExternalMutations !== false;
+    this.selectPk = opts?.selectPk ?? (() => {
+      throw new Error(
+        `[OIMCollectionChangedFields]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
+      );
+    });
+    this.changedPksEventEmitter = new OIMUpdateEventEmitter(
+      queue,
+      "after_flush"
+    );
+    this.changedFieldsEventEmitter = new OIMUpdateEventEmitter(queue, "after_flush");
+    this.unsubscribeAfterFlush = queue.emitter.on(
+      0 /* AFTER_FLUSH */,
+      this.onAfterFlush
+    );
+    if (this.detectExternalMutations) {
+      const maybeReactive = collection;
+      this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
+        this.onCollectionUpdate({
+          pks
+        });
+      }) : collection.emitter.on(
+        0 /* UPDATE */,
+        this.onCollectionUpdate
+      );
+    }
+  }
+  upsertOneByPk(pk, patch) {
+    const slot = this.withWrite(() => {
+      this.trackPatch(pk, patch);
+      return this.collection.upsertOneByPk(pk, patch);
+    });
+    this.updateEntitySnapshot(pk);
+    return slot;
+  }
+  upsertOne(entity) {
+    const slot = this.withWrite(() => {
+      const pk = this.selectPk(entity);
+      this.trackPatch(pk, entity);
+      return this.collection.upsertOne(entity);
+    });
+    this.updateEntitySnapshot(slot.pk);
+    return slot;
+  }
+  upsertMany(entities) {
+    const pks = [];
+    const slots = this.withWrite(() => {
+      for (const entity of entities) {
+        const pk = this.selectPk(entity);
+        pks.push(pk);
+        this.trackPatch(pk, entity);
+      }
+      return this.collection.upsertMany(entities);
+    });
+    for (let i = 0; i < pks.length; i++) this.updateEntitySnapshot(pks[i]);
+    return slots;
+  }
+  getChangedFieldsByPk(pk) {
+    return this.changedFieldsByPk.get(pk) ?? /* @__PURE__ */ new Set();
+  }
+  consumeChangedFieldsByPk(pk) {
+    const existing = this.changedFieldsByPk.get(pk);
+    if (!existing) return /* @__PURE__ */ new Set();
+    return new Set(existing);
+  }
+  getChangedPksByField(field) {
+    return this.changedPksByField.get(field) ?? /* @__PURE__ */ new Set();
+  }
+  consumeChangedPksByField(field) {
+    const existing = this.changedPksByField.get(field);
+    if (!existing) return /* @__PURE__ */ new Set();
+    return new Set(existing);
+  }
+  clear() {
+    this.changedFieldsByPk.clear();
+    this.changedPksByField.clear();
+  }
+  destroy() {
+    this.changedPksEventEmitter.destroy();
     this.changedFieldsEventEmitter.destroy();
     this.unsubscribeAfterFlush();
     this.unsubscribeFromCollectionEmitter?.();
@@ -5319,8 +5834,9 @@ var OIMCollectionChangedFields = class {
     Object.keys(nextObj).forEach((k) => keys.add(k));
     const changed = [];
     keys.forEach((k) => {
-      if (prevObj[k] !== nextObj[k])
+      if (prevObj[k] !== nextObj[k]) {
         changed.push(k);
+      }
     });
     return changed;
   }
@@ -5486,10 +6002,15 @@ var OIMOrderedListMappedCommandStream = class _OIMOrderedListMappedCommandStream
     try {
       const subs = this.subscribers.get(key);
       if (subs && subs.size > 0) {
-        const snapshot = Array.from(subs);
-        for (let s = 0; s < snapshot.length; s++) {
-          const handler = snapshot[s];
-          if (subs.has(handler)) handler();
+        if (subs.size === 1) {
+          const only = subs.values().next().value;
+          if (only) only();
+        } else {
+          const snapshot = Array.from(subs);
+          for (let s = 0; s < snapshot.length; s++) {
+            const handler = snapshot[s];
+            if (subs.has(handler)) handler();
+          }
         }
       }
     } finally {
@@ -5783,10 +6304,13 @@ var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler
         this.flush();
       });
     } else {
-      this.frameId = setTimeout(() => {
-        this.frameId = void 0;
-        this.flush();
-      }, 16);
+      this.frameId = this.unref(
+        setTimeout(() => {
+          this.frameId = void 0;
+          this.flush();
+        }, 16)
+        // ~60fps
+      );
     }
   }
   cancel() {
@@ -5832,10 +6356,12 @@ var OIMEventQueueSchedulerTimeout = class extends OIMEventQueueScheduler {
   }
   schedule() {
     if (this.timeoutId !== void 0) return;
-    this.timeoutId = setTimeout(() => {
-      this.timeoutId = void 0;
-      this.flush();
-    }, this.delay);
+    this.timeoutId = this.unref(
+      setTimeout(() => {
+        this.timeoutId = void 0;
+        this.flush();
+      }, this.delay)
+    );
   }
   cancel() {
     if (this.timeoutId === void 0) return;
@@ -5869,13 +6395,13 @@ var OIMEventQueueSchedulerImmediate = class extends OIMEventQueueScheduler {
       this.flush();
     };
     if (this.useSetImmediate) {
-      this.immediateId = setImmediate(callback);
+      this.immediateId = this.unref(setImmediate(callback));
     } else if (this.useMessageChannel && this.messageChannel) {
       this.immediateId = 1;
       this.pendingCallback = callback;
       this.messageChannel.port1.postMessage(null);
     } else {
-      this.immediateId = setTimeout(callback, 0);
+      this.immediateId = this.unref(setTimeout(callback, 0));
     }
   }
   cancel() {
@@ -5968,242 +6494,6 @@ var OIMDBSettings = class {
 OIMDBSettings.UPDATED_KEYS_INDEX_KEY = "__updatedKeys__";
 OIMDBSettings.FLUSHING_KEYS_INDEX_KEY = "__flushingKeys__";
 
-// src/modules/effect/core/OIMEffectDependencyComputed.ts
-var OIMEffectDependencyComputed = class {
-  constructor(source) {
-    this.source = source;
-  }
-  subscribe(onUpdate) {
-    return this.source.emitter.on("update", onUpdate);
-  }
-};
-
-// src/modules/effect/core/OIMEffect.ts
-var OIMEffect = class {
-  constructor(runtime, opts) {
-    this.sourceDeps = [];
-    this.computedDeps = [];
-    this.sourceUnsubscribers = [];
-    this.computedUnsubscribers = [];
-    this.isResubscribeEnqueued = false;
-    this.isTemporarilyUnsubscribedForFlush = false;
-    this.isScheduled = false;
-    this.runTask = () => {
-      this.isScheduled = false;
-      this.dequeueScheduled = void 0;
-      this.runOnce();
-    };
-    this.onSourceInvalidate = () => {
-      this.onUpdate?.();
-      if (!this.isTemporarilyUnsubscribedForFlush) {
-        this.isTemporarilyUnsubscribedForFlush = true;
-        this.unsubscribeFromSourceDeps();
-        this.ensureResubscribeAfterFlush();
-      }
-      if (this.isScheduled) return;
-      this.isScheduled = true;
-      this.dequeueScheduled = this.runtime.schedule(this.runTask);
-    };
-    this.onComputedInvalidate = () => {
-      this.onUpdate?.();
-      if (this.isScheduled) return;
-      this.isScheduled = true;
-      this.dequeueScheduled = this.runtime.schedule(this.runTask);
-    };
-    this.onAfterFlush = () => {
-      if (!this.isResubscribeEnqueued) return;
-      this.isResubscribeEnqueued = false;
-      this.dequeueResubscribe = void 0;
-      this.isTemporarilyUnsubscribedForFlush = false;
-      if (this.sourceUnsubscribers.length === 0) {
-        for (const dep of this.sourceDeps) {
-          this.sourceUnsubscribers.push(
-            dep.subscribe(this.onSourceInvalidate)
-          );
-        }
-      }
-    };
-    this.runtime = runtime;
-    this.onUpdate = opts.onUpdate;
-    this.run = opts.run;
-    this.deps = opts.deps ?? [];
-    for (const dep of this.deps) {
-      if (dep instanceof OIMEffectDependencyComputed) {
-        this.computedDeps.push(dep);
-      } else {
-        this.sourceDeps.push(dep);
-      }
-    }
-    this.subscribeToDeps();
-  }
-  destroy() {
-    if (this.dequeueScheduled) {
-      this.dequeueScheduled();
-      this.dequeueScheduled = void 0;
-    }
-    this.unsubscribeFromAllDeps();
-    if (this.dequeueResubscribe) {
-      this.dequeueResubscribe();
-      this.dequeueResubscribe = void 0;
-    }
-    this.isResubscribeEnqueued = false;
-    this.isTemporarilyUnsubscribedForFlush = false;
-  }
-  runOnce() {
-    this.run();
-  }
-  subscribeToDeps() {
-    if (this.sourceUnsubscribers.length > 0 || this.computedUnsubscribers.length > 0)
-      return;
-    for (const dep of this.sourceDeps) {
-      this.sourceUnsubscribers.push(
-        dep.subscribe(this.onSourceInvalidate)
-      );
-    }
-    for (const dep of this.computedDeps) {
-      this.computedUnsubscribers.push(
-        dep.subscribe(this.onComputedInvalidate)
-      );
-    }
-  }
-  unsubscribeFromSourceDeps() {
-    if (this.sourceUnsubscribers.length === 0) return;
-    for (const unsubscribe of this.sourceUnsubscribers) unsubscribe();
-    this.sourceUnsubscribers = [];
-  }
-  unsubscribeFromAllDeps() {
-    this.unsubscribeFromSourceDeps();
-    if (this.computedUnsubscribers.length === 0) return;
-    for (const unsubscribe of this.computedUnsubscribers) unsubscribe();
-    this.computedUnsubscribers = [];
-  }
-  ensureResubscribeAfterFlush() {
-    if (this.isResubscribeEnqueued) return;
-    this.isResubscribeEnqueued = true;
-    this.dequeueResubscribe = this.runtime.scheduleAfterFlush(
-      this.onAfterFlush
-    );
-  }
-};
-
-// src/modules/computed/enums/EOIMComputedEventType.ts
-var EOIMComputedEventType = /* @__PURE__ */ ((EOIMComputedEventType2) => {
-  EOIMComputedEventType2["UPDATE"] = "update";
-  return EOIMComputedEventType2;
-})(EOIMComputedEventType || {});
-
-// src/modules/computed/core/OIMComputed.ts
-var OIMComputed = class {
-  constructor(runtime, opts) {
-    this.emitter = new OIMEventEmitter();
-    this.hasValue = false;
-    this.isDirty = true;
-    this.runtime = runtime;
-    this.compute = opts.compute;
-    this.compare = opts.compare ?? Object.is;
-    this._deps = opts.deps ?? [];
-    this.updateEventEmitter = new OIMUpdateEventEmitter(
-      this.runtime.queue,
-      "immediate"
-    );
-    this.effect = new OIMEffect(this.runtime, {
-      deps: this._deps,
-      onUpdate: () => {
-        this.isDirty = true;
-      },
-      run: () => {
-        this.recomputeAndEmitIfChanged();
-      }
-    });
-  }
-  get needsRecompute() {
-    return this.isDirty;
-  }
-  get isReady() {
-    return this.hasValue;
-  }
-  get deps() {
-    return this._deps;
-  }
-  get() {
-    this.recomputeAndEmitIfChanged();
-    return this.value;
-  }
-  getIfReady() {
-    return this.hasValue ? this.value : void 0;
-  }
-  destroy() {
-    this.effect.destroy();
-    this.updateEventEmitter.destroy();
-    this.emitter.offAll();
-  }
-  recomputeAndEmitIfChanged() {
-    if (!this.isDirty) return;
-    const prev = this.value;
-    const hadPrev = this.hasValue;
-    const next = this.compute();
-    this.value = next;
-    this.hasValue = true;
-    this.isDirty = false;
-    const changed = !hadPrev || !this.compare(prev, next);
-    if (!changed) return;
-    this.emitter.emit("update" /* UPDATE */, {
-      keys: ["value"]
-    });
-    this.updateEventEmitter.markUpdatedKey("value");
-  }
-};
-
-// src/modules/effect/core/OIMEffectDependencyKeyed.ts
-var OIMEffectDependencyKeyed = class {
-  constructor(source, key) {
-    this.source = source;
-    this.key = key;
-  }
-  subscribe(onUpdate) {
-    return this.source.subscribeOnKey(this.key, onUpdate);
-  }
-};
-
-// src/modules/effect/core/OIMEffectDependencyKeyedObject.ts
-var OIMEffectDependencyKeyedObject = class {
-  constructor(object, key) {
-    this.dep = new OIMEffectDependencyKeyed(object, key);
-  }
-  get source() {
-    return this.dep.source;
-  }
-  subscribe(onUpdate) {
-    return this.dep.subscribe(onUpdate);
-  }
-};
-
-// src/modules/effect/core/OIMEffectDependencyKeyedCollection.ts
-var OIMEffectDependencyKeyedCollection = class {
-  constructor(collection, pk) {
-    this.dep = new OIMEffectDependencyKeyed(collection, pk);
-  }
-  get source() {
-    return this.dep.source;
-  }
-  subscribe(onUpdate) {
-    return this.dep.subscribe(onUpdate);
-  }
-};
-
-// src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
-var OIMEffectDependencyKeyedIndex = class {
-  constructor(index, key) {
-    this.dep = new OIMEffectDependencyKeyed(index, key);
-  }
-  get source() {
-    return this.dep.source;
-  }
-  subscribe(onUpdate) {
-    return this.dep.subscribe(onUpdate);
-  }
-};
-
 // src/modules/selector/core/OIMObjectValueByKeySelector.ts
 var OIMObjectValueByKeySelector = class extends OIMSelector {
   constructor(runtime, obj, key) {
@@ -6281,8 +6571,9 @@ var OIMIndexPksByKeyArrayBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -6305,8 +6596,9 @@ var OIMIndexPksByKeysSetBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -6329,8 +6621,9 @@ var OIMIndexPksByKeysArrayBasedSelector = class extends OIMSelector {
   areEqual(prev, next) {
     if (prev === next) return true;
     if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
+    for (let i = 0; i < prev.length; i++) {
       if (prev[i] !== next[i]) return false;
+    }
     return true;
   }
 };
@@ -6359,6 +6652,7 @@ export {
   OIMComputeRuntime,
   OIMComputed,
   OIMDBSettings,
+  OIMDerivedCollection,
   OIMDerivedCollectionGlobalIndexArrayBased,
   OIMDerivedCollectionGlobalIndexSetBased,
   OIMDerivedCollectionIndexArrayBased,
@@ -6454,5 +6748,9 @@ export {
   createOIMIndexSlotMap,
   createOIMOrderedListCommandStreamDiffDriven,
   createOIMOrderedListMappedCommandStream,
-  diffOrderedListByPk
+  diffOrderedListByPk,
+  getOIMComputeRuntime,
+  on,
+  peekOIMComputeRuntime,
+  setOIMComputeRuntime
 };