@oimdb/core 1.3.1 → 1.4.1

package/dist/index.js

@@ -15,6 +15,11 @@ var OIMEventEmitter = class {
   constructor() {
     this.buckets = {};
   }
+  hasHandlers(event) {
+    const bucket = this.buckets[event];
+    if (!bucket) return false;
+    return bucket.indexByHandler.size > 0;
+  }
   getOrCreateBucket(event) {
     let bucket = this.buckets[event];
     if (!bucket) {
@@ -28,39 +33,40 @@ var OIMEventEmitter = class {
     }
     return bucket;
   }
+  /**
+   * Compacts the handlers array by removing null entries (tombstones) left by handler removal.
+   * Rebuilds the indexByHandler map with updated indices and resets the tombstone count.
+   * This reduces array fragmentation and improves iteration performance.
+   */
   compactBucket(bucket) {
     const handlers = bucket.handlers;
     const length = handlers.length;
     const newHandlers = [];
     bucket.indexByHandler.clear();
-    if (bucket.tombstoneCount < length >> 2) {
-      newHandlers.length = length - bucket.tombstoneCount;
-    }
-    let writeIndex = 0;
     for (let i = 0; i < length; i++) {
       const handler = handlers[i];
       if (handler) {
-        newHandlers[writeIndex] = handler;
+        const writeIndex = newHandlers.length;
+        newHandlers.push(handler);
         bucket.indexByHandler.set(handler, writeIndex);
-        writeIndex++;
       }
     }
-    if (newHandlers.length !== writeIndex) {
-      newHandlers.length = writeIndex;
-    }
     bucket.handlers = newHandlers;
     bucket.tombstoneCount = 0;
   }
   on(event, handler) {
     const bucket = this.getOrCreateBucket(event);
-    if (bucket.indexByHandler.has(handler))
-      return;
+    if (bucket.indexByHandler.has(handler)) {
+      return () => {
+        this.off(event, handler);
+      };
+    }
     const index = bucket.handlers.length;
     bucket.handlers.push(handler);
-    bucket.indexByHandler.set(
-      handler,
-      index
-    );
+    bucket.indexByHandler.set(handler, index);
+    return () => {
+      this.off(event, handler);
+    };
   }
   emit(event, payload) {
     const bucket = this.buckets[event];
@@ -75,10 +81,11 @@ var OIMEventEmitter = class {
     }
     bucket.isEmitting--;
     if (bucket.isEmitting === 0 && bucket.tombstoneCount > 0) {
-      if (bucket.tombstoneCount >= length >> 1) {
-        this.compactBucket(bucket);
-      } else if (length === bucket.tombstoneCount) {
+      const currentLength = bucket.handlers.length;
+      if (bucket.tombstoneCount === currentLength) {
         delete this.buckets[event];
+      } else if (bucket.tombstoneCount >= currentLength >> 1) {
+        this.compactBucket(bucket);
       }
     }
   }
@@ -92,10 +99,10 @@ var OIMEventEmitter = class {
     bucket.indexByHandler.delete(handler);
     if (bucket.isEmitting === 0) {
       const length = bucket.handlers.length;
-      if (bucket.tombstoneCount >= length >> 1) {
-        this.compactBucket(bucket);
-      } else if (length === bucket.tombstoneCount) {
+      if (bucket.tombstoneCount === length) {
         delete this.buckets[event];
+      } else if (bucket.tombstoneCount >= length >> 1) {
+        this.compactBucket(bucket);
       }
     }
   }
@@ -295,6 +302,12 @@ var OIMIndexSetBased = class {
   emitUpdate(keys) {
     this.emitter.emit(0 /* UPDATE */, { keys });
   }
+  /**
+   * Emit update event for a single key (fast-path override point).
+   */
+  emitUpdateOne(key) {
+    this.emitUpdate([key]);
+  }
 };
 
 // src/core/OIMIndexStoreMapDrivenArrayBased.ts
@@ -444,70 +457,195 @@ var OIMIndexArrayBased = class {
   emitUpdate(keys) {
     this.emitter.emit(0 /* UPDATE */, { keys });
   }
+  /**
+   * Emit update event for a single key (fast-path override point).
+   */
+  emitUpdateOne(key) {
+    this.emitUpdate([key]);
+  }
 };
 
-// src/enum/EOIMUpdateEventCoalescerEventType.ts
-var EOIMUpdateEventCoalescerEventType = /* @__PURE__ */ ((EOIMUpdateEventCoalescerEventType2) => {
-  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["HAS_CHANGES"] = 0] = "HAS_CHANGES";
-  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
-  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["AFTER_FLUSH"] = 2] = "AFTER_FLUSH";
-  return EOIMUpdateEventCoalescerEventType2;
-})(EOIMUpdateEventCoalescerEventType || {});
+// src/enum/EOIMEventQueueEventType.ts
+var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
+  return EOIMEventQueueEventType2;
+})(EOIMEventQueueEventType || {});
 
 // src/core/OIMUpdateEventEmitter.ts
 var OIMUpdateEventEmitter = class {
-  constructor(opts) {
+  constructor(queue, deliveryMode = "queue") {
     this.keyHandlers = /* @__PURE__ */ new Map();
-    this.handleHasChanges = () => {
-      this.queue.enqueue(() => {
-        const updatedKeys = this.coalescer.getUpdatedKeys();
-        if (this.keyHandlers.size === 0) {
-          this.coalescer.clearUpdatedKeys();
-          return;
+    this.isFlushEnqueued = false;
+    this.updatedKeys = /* @__PURE__ */ new Set();
+    this.isAfterFlushDeliveryScheduled = false;
+    // Stable handler reference to avoid allocating a new closure on every HAS_CHANGES.
+    this.onFlush = () => {
+      this.isFlushEnqueued = false;
+      this.dequeueFlush = void 0;
+      if (this.keyHandlers.size === 0) {
+        this.updatedKeys.clear();
+        return;
+      }
+      const makeHandlerSnapshot = (handlers) => {
+        const snapshot = [];
+        handlers.forEach((h) => snapshot.push(h));
+        return snapshot;
+      };
+      this.runSinglePass(makeHandlerSnapshot);
+    };
+    this.onAfterFlush = () => {
+      if (!this.isAfterFlushDeliveryScheduled) return;
+      this.isAfterFlushDeliveryScheduled = false;
+      this.deliverImmediate();
+    };
+    this.queue = queue;
+    this.deliveryMode = deliveryMode;
+    if (this.deliveryMode === "after_flush") {
+      this.unsubscribeAfterFlushDelivery = this.queue.emitter.on(
+        0 /* AFTER_FLUSH */,
+        this.onAfterFlush
+      );
+    }
+  }
+  /**
+   * Mark keys as updated and schedule delivery.
+   *
+   * If there are no subscriptions, this is a no-op and does not allocate or retain keys.
+   */
+  markUpdatedKeys(keys) {
+    if (keys.length === 0) return;
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    let didAddAny = false;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const handlers = this.keyHandlers.get(key);
+      if (!handlers || handlers.size === 0) continue;
+      this.updatedKeys.add(key);
+      didAddAny = true;
+    }
+    if (!didAddAny) return;
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  markUpdatedKey(key) {
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    const handlers = this.keyHandlers.get(key);
+    if (!handlers || handlers.size === 0) return;
+    this.updatedKeys.add(key);
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  markAllUpdated() {
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    this.keyHandlers.forEach((_handlers, key) => {
+      this.updatedKeys.add(key);
+    });
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  deliverImmediate() {
+    const makeHandlerSnapshot = (handlers) => {
+      const snapshot = [];
+      handlers.forEach((h) => snapshot.push(h));
+      return snapshot;
+    };
+    this.runSinglePass(makeHandlerSnapshot);
+  }
+  /**
+   * Deliver updated keys and notify handlers once.
+   * Re-entrant updates during delivery are forbidden and will throw in markUpdatedKeys().
+   */
+  runSinglePass(makeHandlerSnapshot) {
+    if (this.updatedKeys.size === 0) return;
+    const flushingKeys = this.updatedKeys;
+    this.updatedKeys = /* @__PURE__ */ new Set();
+    if (this.keyHandlers.size === 0 || flushingKeys.size === 0) return;
+    if (flushingKeys.size * 2 < this.keyHandlers.size) {
+      flushingKeys.forEach((key) => {
+        const handlers = this.keyHandlers.get(key);
+        if (!handlers || handlers.size === 0) return;
+        const handlerSnapshot = makeHandlerSnapshot(handlers);
+        for (let i = 0; i < handlerSnapshot.length; i++) {
+          const handler = handlerSnapshot[i];
+          if (handlers.has(handler)) handler();
         }
-        if (updatedKeys.size * 2 < this.keyHandlers.size) {
-          for (const key of updatedKeys.values()) {
-            const handlers = this.keyHandlers.get(key);
-            if (handlers) {
-              for (const handler of handlers) {
-                handler();
-              }
-            }
-          }
-        } else {
-          for (const [key, handlers] of this.keyHandlers) {
-            if (updatedKeys.has(key)) {
-              for (const handler of handlers) {
-                handler();
-              }
-            }
-          }
+      });
+    } else {
+      this.keyHandlers.forEach((handlers, key) => {
+        if (!flushingKeys.has(key)) return;
+        if (!handlers || handlers.size === 0) return;
+        const handlerSnapshot = makeHandlerSnapshot(handlers);
+        for (let i = 0; i < handlerSnapshot.length; i++) {
+          const handler = handlerSnapshot[i];
+          if (handlers.has(handler)) handler();
         }
-        this.coalescer.clearUpdatedKeys();
       });
-    };
-    this.coalescer = opts.coalescer;
-    this.coalescer.emitter.on(
-      0 /* HAS_CHANGES */,
-      this.handleHasChanges
-    );
-    this.queue = opts.queue;
+    }
   }
   destroy() {
-    this.coalescer.emitter.off(
-      0 /* HAS_CHANGES */,
-      this.handleHasChanges
-    );
+    if (this.dequeueFlush) {
+      this.dequeueFlush();
+      this.dequeueFlush = void 0;
+    }
+    if (this.unsubscribeAfterFlushDelivery) {
+      this.unsubscribeAfterFlushDelivery();
+      this.unsubscribeAfterFlushDelivery = void 0;
+    }
+    this.keyHandlers.forEach((handlers) => handlers.clear());
     this.keyHandlers.clear();
+    this.updatedKeys.clear();
   }
   /**
    * Get performance metrics for monitoring and debugging
    */
   getMetrics() {
     let totalHandlers = 0;
-    for (const handlers of this.keyHandlers.values()) {
+    this.keyHandlers.forEach((handlers) => {
       totalHandlers += handlers.size;
-    }
+    });
     return {
       totalKeys: this.keyHandlers.size,
       totalHandlers,
@@ -544,6 +682,15 @@ var OIMUpdateEventEmitter = class {
     handlers.delete(handler);
     if (handlers.size === 0) {
       this.keyHandlers.delete(key);
+      this.updatedKeys.delete(key);
+    }
+    if (this.keyHandlers.size === 0) {
+      this.updatedKeys.clear();
+      if (this.dequeueFlush) {
+        this.dequeueFlush();
+        this.dequeueFlush = void 0;
+      }
+      this.isFlushEnqueued = false;
     }
   }
   subscribeOnKeys(keys, handler) {
@@ -572,181 +719,11 @@ var OIMUpdateEventEmitter = class {
   }
 };
 
-// src/core/OIMIndexManualSetBased.ts
-var OIMIndexManualSetBased = class extends OIMIndexSetBased {
-  constructor(options = {}) {
-    super(options);
-  }
-  /**
-   * Set primary keys for a specific index key, replacing any existing values.
-   * Uses optional comparator to skip updates if PKs haven't actually changed.
-   */
-  setPks(key, pks) {
-    const hasChanges = this.setPksWithComparison(key, new Set(pks));
-    if (hasChanges) {
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Add primary keys to a specific index key
-   */
-  addPks(key, pks) {
-    if (pks.length === 0) return;
-    let pksSet = this.store.getOneByKey(key);
-    if (!pksSet) {
-      pksSet = /* @__PURE__ */ new Set();
-      this.store.setOneByKey(key, pksSet);
-    }
-    let hasChanges = false;
-    for (const pk of pks) {
-      if (!pksSet.has(pk)) {
-        pksSet.add(pk);
-        hasChanges = true;
-      }
-    }
-    if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Remove primary keys from a specific index key
-   */
-  removePks(key, pks) {
-    if (pks.length === 0) return;
-    const pksSet = this.store.getOneByKey(key);
-    if (!pksSet) return;
-    let hasChanges = false;
-    for (const pk of pks) {
-      if (pksSet.delete(pk)) {
-        hasChanges = true;
-      }
-    }
-    if (pksSet.size === 0) {
-      this.store.removeOneByKey(key);
-      hasChanges = true;
-    } else if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
-    }
-    if (hasChanges) {
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Clear all primary keys for a specific index key, or all keys if no key specified
-   */
-  clear(key) {
-    if (key === void 0) {
-      const allKeys = this.store.getAllKeys();
-      if (allKeys.length > 0) {
-        this.store.clear();
-        this.emitUpdate(allKeys);
-      }
-    } else {
-      if (this.store.getOneByKey(key) !== void 0) {
-        this.store.removeOneByKey(key);
-        this.emitUpdate([key]);
-      }
-    }
-  }
-};
-
-// src/const/OIMDBSettings.ts
-var OIMDBSettings = class {
-};
-/**
- * Fixed key used in the manual index to store updated keys set in coalescers.
- * This constant is exported so users can create their own indexes and pass them to coalescers.
- */
-OIMDBSettings.UPDATED_KEYS_INDEX_KEY = "__updatedKeys__";
-
-// src/core/OIMUpdateEventCoalescer.ts
-var OIMUpdateEventCoalescer = class {
-  constructor(index) {
-    this.emitter = new OIMEventEmitter();
-    this.hasEmittedChanges = false;
-    this.updatedKeysIndex = index ?? new OIMIndexManualSetBased({
-      store: new OIMIndexStoreMapDrivenSetBased()
-    });
-    if (!this.updatedKeysIndex.hasKey(OIMDBSettings.UPDATED_KEYS_INDEX_KEY)) {
-      this.updatedKeysIndex.setPks(
-        OIMDBSettings.UPDATED_KEYS_INDEX_KEY,
-        []
-      );
-    }
-  }
-  /**
-   * Get the set of keys that have been updated since last clear
-   */
-  getUpdatedKeys() {
-    return this.updatedKeysIndex.getPksByKey(
-      OIMDBSettings.UPDATED_KEYS_INDEX_KEY
-    );
-  }
-  /**
-   * Clear all updated keys and reset the changed state
-   */
-  clearUpdatedKeys() {
-    this.emitter.emit(
-      1 /* BEFORE_FLUSH */,
-      void 0
-    );
-    this.updatedKeysIndex.setPks(OIMDBSettings.UPDATED_KEYS_INDEX_KEY, []);
-    this.hasEmittedChanges = false;
-    this.emitter.emit(
-      2 /* AFTER_FLUSH */,
-      void 0
-    );
-  }
-  /**
-   * Add keys to the updated set and emit HAS_CHANGES event if needed
-   */
-  addUpdatedKeys(keys) {
-    this.updatedKeysIndex.addPks(
-      OIMDBSettings.UPDATED_KEYS_INDEX_KEY,
-      keys
-    );
-    if (!this.hasEmittedChanges) {
-      this.hasEmittedChanges = true;
-      this.emitter.emit(
-        0 /* HAS_CHANGES */,
-        void 0
-      );
-    }
-  }
-};
-
-// src/core/OIMUpdateEventCoalescerIndex.ts
-var OIMUpdateEventCoalescerIndex = class extends OIMUpdateEventCoalescer {
-  constructor(indexEmitter) {
-    super();
-    this.indexEmitter = indexEmitter;
-    /**
-     * When the index is updated, we keep track of the updated keys.
-     */
-    this.handleUpdate = (payload) => {
-      this.addUpdatedKeys(payload.keys);
-    };
-    this.indexEmitter.on(0 /* UPDATE */, this.handleUpdate);
-  }
-  destroy() {
-    this.indexEmitter.off(0 /* UPDATE */, this.handleUpdate);
-    this.emitter.offAll();
-    this.clearUpdatedKeys();
-  }
-};
-
 // src/abstract/OIMReactiveIndexSetBased.ts
 var OIMReactiveIndexSetBased = class {
-  constructor(queue, opts) {
-    this.index = opts?.index ?? this.createDefaultIndex();
-    this.coalescer = new OIMUpdateEventCoalescerIndex(
-      this.index.emitter
-    );
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
-    });
+  constructor(queue, createIndex) {
+    this.updateEmitter = new OIMUpdateEventEmitter(queue);
+    this.index = createIndex(this.updateEmitter);
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -772,22 +749,38 @@ var OIMReactiveIndexSetBased = class {
   getMetrics() {
     return this.index.getMetrics();
   }
+  subscribeOnKey(key, handler) {
+    return this.updateEmitter.subscribeOnKey(key, handler);
+  }
+  subscribeOnKeys(keys, handler) {
+    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  }
+  unsubscribeFromKey(key, handler) {
+    this.updateEmitter.unsubscribeFromKey(key, handler);
+  }
+  unsubscribeFromKeys(keys, handler) {
+    this.updateEmitter.unsubscribeFromKeys(keys, handler);
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getHandlerCount(key) {
+    return this.updateEmitter.getHandlerCount(key);
+  }
+  getSubscriptionMetrics() {
+    return this.updateEmitter.getMetrics();
+  }
   destroy() {
+    this.updateEmitter.destroy();
     this.index.destroy();
   }
 };
 
 // src/abstract/OIMReactiveIndexArrayBased.ts
 var OIMReactiveIndexArrayBased = class {
-  constructor(queue, opts) {
-    this.index = opts?.index ?? this.createDefaultIndex();
-    this.coalescer = new OIMUpdateEventCoalescerIndex(
-      this.index.emitter
-    );
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
-    });
+  constructor(queue, createIndex) {
+    this.updateEmitter = new OIMUpdateEventEmitter(queue);
+    this.index = createIndex(this.updateEmitter);
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -813,11 +806,37 @@ var OIMReactiveIndexArrayBased = class {
   getMetrics() {
     return this.index.getMetrics();
   }
+  subscribeOnKey(key, handler) {
+    return this.updateEmitter.subscribeOnKey(key, handler);
+  }
+  subscribeOnKeys(keys, handler) {
+    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  }
+  unsubscribeFromKey(key, handler) {
+    this.updateEmitter.unsubscribeFromKey(key, handler);
+  }
+  unsubscribeFromKeys(keys, handler) {
+    this.updateEmitter.unsubscribeFromKeys(keys, handler);
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getHandlerCount(key) {
+    return this.updateEmitter.getHandlerCount(key);
+  }
+  getSubscriptionMetrics() {
+    return this.updateEmitter.getMetrics();
+  }
   destroy() {
+    this.updateEmitter.destroy();
     this.index.destroy();
   }
 };
 
+// src/abstract/OIMObjectStore.ts
+var OIMObjectStore = class {
+};
+
 // src/core/OIMPkSelectorFactory.ts
 var OIMPkSelectorFactory = class {
   createIdSelector() {
@@ -875,6 +894,9 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   getAllPks() {
     return Array.from(this.entities.keys());
   }
+  destroy() {
+    this.clear();
+  }
 };
 
 // src/core/OIMEntityUpdaterFactory.ts
@@ -972,31 +994,9 @@ var OIMCollection = class {
       this.store.setOneByPk(pk, entity);
     }
   }
-};
-
-// src/core/OIMUpdateEventCoalescerCollection.ts
-var OIMUpdateEventCoalescerCollection = class extends OIMUpdateEventCoalescer {
-  constructor(collectionEmitter) {
-    super();
-    this.collectionEmitter = collectionEmitter;
-    /**
-     * When the collection is updated, we keep track of the updated pks.
-     */
-    this.handleUpdate = (payload) => {
-      this.addUpdatedKeys(payload.pks);
-    };
-    this.collectionEmitter.on(
-      0 /* UPDATE */,
-      this.handleUpdate
-    );
-  }
   destroy() {
-    this.collectionEmitter.off(
-      0 /* UPDATE */,
-      this.handleUpdate
-    );
+    this.store.destroy();
     this.emitter.offAll();
-    this.clearUpdatedKeys();
   }
 };
 
@@ -1004,28 +1004,367 @@ var OIMUpdateEventCoalescerCollection = class extends OIMUpdateEventCoalescer {
 var OIMReactiveCollection = class extends OIMCollection {
   constructor(queue, opts) {
     super(opts);
-    this.coalescer = new OIMUpdateEventCoalescerCollection(
-      this.emitter
-    );
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
-    });
+    this.anyUpdateHandlers = /* @__PURE__ */ new Set();
+    this.pendingAnyUpdatePks = /* @__PURE__ */ new Set();
+    this.isAnyUpdateClearPending = false;
+    this.isAnyUpdateScheduled = false;
+    this.runAnyUpdate = () => {
+      if (!this.isAnyUpdateScheduled) return;
+      this.isAnyUpdateScheduled = false;
+      this.dequeueAnyUpdate = void 0;
+      const pks = this.isAnyUpdateClearPending ? [] : Array.from(this.pendingAnyUpdatePks);
+      this.pendingAnyUpdatePks.clear();
+      this.isAnyUpdateClearPending = false;
+      const snapshot = Array.from(this.anyUpdateHandlers);
+      for (let i = 0; i < snapshot.length; i++) snapshot[i](pks);
+    };
+    this.queue = queue;
+    this.updateEmitter = new OIMUpdateEventEmitter(queue, "queue");
   }
-};
-
-// src/core/OIMReactiveIndexManualSetBased.ts
-var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
-  constructor(queue, opts) {
-    super(queue, opts);
+  subscribeOnKey(pk, handler) {
+    return this.updateEmitter.subscribeOnKey(pk, handler);
   }
-  createDefaultIndex() {
-    return new OIMIndexManualSetBased();
+  subscribeOnKeys(pks, handler) {
+    return this.updateEmitter.subscribeOnKeys(pks, handler);
   }
-  setPks(key, pks) {
-    this.index.setPks(key, pks);
+  unsubscribeFromKey(pk, handler) {
+    this.updateEmitter.unsubscribeFromKey(pk, handler);
   }
-  addPks(key, pks) {
+  unsubscribeFromKeys(pks, handler) {
+    this.updateEmitter.unsubscribeFromKeys(pks, handler);
+  }
+  destroySubscriptions() {
+    this.updateEmitter.destroy();
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getHandlerCount(pk) {
+    return this.updateEmitter.getHandlerCount(pk);
+  }
+  getMetrics() {
+    return this.updateEmitter.getMetrics();
+  }
+  subscribeOnAnyUpdate(handler) {
+    this.anyUpdateHandlers.add(handler);
+    return () => {
+      this.anyUpdateHandlers.delete(handler);
+    };
+  }
+  upsertOneByPk(pk, entity) {
+    this.upsertOneWithoutNotificationsByPk(pk, entity);
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  upsertOne(entity) {
+    const pk = this.upsertOneWithoutNotifications(entity);
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  upsertMany(entities) {
+    const pks = entities.map(
+      (entity) => this.upsertOneWithoutNotifications(entity)
+    );
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  removeOne(entity) {
+    const pk = this.selectPk(entity);
+    this.store.removeOneByPk(pk);
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  removeMany(entities) {
+    const pks = entities.map(this.selectPk);
+    this.store.removeManyByPks(pks);
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  removeOneByPk(pk) {
+    this.store.removeOneByPk(pk);
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  removeManyByPks(pks) {
+    this.store.removeManyByPks(pks);
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  clear() {
+    this.store.clear();
+    this.updateEmitter.markAllUpdated();
+    this.trackAnyUpdateClear();
+  }
+  trackAnyUpdatePk(pk) {
+    if (this.anyUpdateHandlers.size === 0) return;
+    this.pendingAnyUpdatePks.add(pk);
+    this.ensureAnyUpdateEnqueued();
+  }
+  trackAnyUpdatePks(pks) {
+    if (this.anyUpdateHandlers.size === 0) return;
+    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() {
+    if (this.isAnyUpdateScheduled) return;
+    this.isAnyUpdateScheduled = true;
+    this.dequeueAnyUpdate = this.queue.enqueue(this.runAnyUpdate);
+  }
+  destroy() {
+    this.updateEmitter.destroy();
+    if (this.dequeueAnyUpdate) {
+      this.dequeueAnyUpdate();
+      this.dequeueAnyUpdate = void 0;
+    }
+    this.anyUpdateHandlers.clear();
+    this.pendingAnyUpdatePks.clear();
+    super.destroy();
+  }
+};
+
+// src/core/OIMObjectStoreRecordDriven.ts
+var OIMObjectStoreRecordDriven = class extends OIMObjectStore {
+  constructor(initial) {
+    super();
+    this.properties = Object.assign(/* @__PURE__ */ Object.create(null), initial ?? {});
+  }
+  setProperty(key, value) {
+    this.properties[key] = value;
+  }
+  merge(draft) {
+    Object.assign(this.properties, draft);
+  }
+  delete(key) {
+    delete this.properties[key];
+  }
+  get(key) {
+    return this.properties[key];
+  }
+  getAll() {
+    return { ...this.properties };
+  }
+  clear() {
+    this.properties = /* @__PURE__ */ Object.create(null);
+  }
+  count() {
+    return Object.keys(this.properties).length;
+  }
+  keys() {
+    return Object.keys(this.properties);
+  }
+  values() {
+    return Object.values(this.properties);
+  }
+  entries() {
+    return Object.entries(this.properties);
+  }
+  destroy() {
+    this.clear();
+  }
+};
+
+// src/enum/EOIMObjectEventType.ts
+var EOIMObjectEventType = /* @__PURE__ */ ((EOIMObjectEventType2) => {
+  EOIMObjectEventType2[EOIMObjectEventType2["UPDATE"] = 0] = "UPDATE";
+  return EOIMObjectEventType2;
+})(EOIMObjectEventType || {});
+
+// src/core/OIMObject.ts
+var OIMObject = class {
+  constructor(opts) {
+    this.emitter = new OIMEventEmitter();
+    this.store = opts?.store ?? new OIMObjectStoreRecordDriven();
+  }
+  setProperty(key, value) {
+    this.store.setProperty(key, value);
+    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
+  }
+  merge(draft) {
+    this.store.merge(draft);
+    this.emitter.emit(0 /* UPDATE */, {
+      keys: Object.keys(draft)
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  getAll() {
+    return this.store.getAll();
+  }
+  clear() {
+    this.store.clear();
+    this.emitter.emit(0 /* UPDATE */, { keys: [] });
+  }
+  count() {
+    return this.store.count();
+  }
+  keys() {
+    return this.store.keys();
+  }
+  values() {
+    return this.store.values();
+  }
+  entries() {
+    return this.store.entries();
+  }
+  destroy() {
+    this.store.destroy();
+    this.emitter.offAll();
+  }
+};
+
+// src/core/OIMReactiveObject.ts
+var OIMReactiveObject = class extends OIMObject {
+  constructor(queue, opts) {
+    super(opts);
+    this.updateEmitter = new OIMUpdateEventEmitter(queue, "queue");
+    this.emitter.on(0 /* UPDATE */, (payload) => {
+      this.updateEmitter.markUpdatedKeys(payload.keys);
+    });
+  }
+  subscribeOnKey(key, handler) {
+    return this.updateEmitter.subscribeOnKey(key, handler);
+  }
+  subscribeOnKeys(keys, handler) {
+    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  }
+  unsubscribeFromKey(key, handler) {
+    this.updateEmitter.unsubscribeFromKey(key, handler);
+  }
+  unsubscribeFromKeys(keys, handler) {
+    this.updateEmitter.unsubscribeFromKeys(keys, handler);
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getHandlerCount(key) {
+    return this.updateEmitter.getHandlerCount(key);
+  }
+  getMetrics() {
+    return this.updateEmitter.getMetrics();
+  }
+  destroy() {
+    this.updateEmitter.destroy();
+    super.destroy();
+  }
+};
+
+// src/core/OIMIndexManualSetBased.ts
+var OIMIndexManualSetBased = class extends OIMIndexSetBased {
+  constructor(options = {}) {
+    super(options);
+  }
+  /**
+   * Set primary keys for a specific index key, replacing any existing values.
+   * Uses optional comparator to skip updates if PKs haven't actually changed.
+   */
+  setPks(key, pks) {
+    const hasChanges = this.setPksWithComparison(key, new Set(pks));
+    if (hasChanges) {
+      this.emitUpdateOne(key);
+    }
+  }
+  /**
+   * Add primary keys to a specific index key
+   */
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    let pksSet = this.store.getOneByKey(key);
+    if (!pksSet) {
+      pksSet = /* @__PURE__ */ new Set();
+      this.store.setOneByKey(key, pksSet);
+    }
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (!pksSet.has(pk)) {
+        pksSet.add(pk);
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.store.setOneByKey(key, pksSet);
+      this.emitUpdateOne(key);
+    }
+  }
+  /**
+   * Remove primary keys from a specific index key
+   */
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const pksSet = this.store.getOneByKey(key);
+    if (!pksSet) return;
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (pksSet.delete(pk)) {
+        hasChanges = true;
+      }
+    }
+    if (pksSet.size === 0) {
+      this.store.removeOneByKey(key);
+      hasChanges = true;
+    } else if (hasChanges) {
+      this.store.setOneByKey(key, pksSet);
+    }
+    if (hasChanges) {
+      this.emitUpdateOne(key);
+    }
+  }
+  /**
+   * Clear all primary keys for a specific index key, or all keys if no key specified
+   */
+  clear(key) {
+    if (key === void 0) {
+      const allKeys = this.store.getAllKeys();
+      if (allKeys.length > 0) {
+        this.store.clear();
+        this.emitUpdate(allKeys);
+      }
+    } else {
+      if (this.store.getOneByKey(key) !== void 0) {
+        this.store.removeOneByKey(key);
+        this.emitUpdateOne(key);
+      }
+    }
+  }
+};
+
+// src/core/OIMReactiveIndexManualSetBased.ts
+var OIMIndexManualSetBasedReactive = class extends OIMIndexManualSetBased {
+  constructor(updateEmitter, opts) {
+    super(opts);
+    this.updateEmitter = updateEmitter;
+  }
+  emitUpdate(keys) {
+    this.updateEmitter.markUpdatedKeys(keys);
+  }
+  emitUpdateOne(key) {
+    this.updateEmitter.markUpdatedKey(key);
+  }
+};
+var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
+  constructor(queue, opts) {
+    super(queue, (updateEmitter) => {
+      return new OIMIndexManualSetBasedReactive(
+        updateEmitter,
+        opts?.indexOptions
+      );
+    });
+  }
+  setPks(key, pks) {
+    this.index.setPks(key, pks);
+  }
+  addPks(key, pks) {
     this.index.addPks(key, pks);
   }
   removePks(key, pks) {
@@ -1048,7 +1387,7 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
   setPks(key, pks) {
     const hasChanges = this.setPksWithComparison(key, pks);
     if (hasChanges) {
-      this.emitUpdate([key]);
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1071,7 +1410,7 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
     }
     if (hasChanges) {
       this.store.setOneByKey(key, Array.from(pksSet));
-      this.emitUpdate([key]);
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1090,7 +1429,7 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
       } else {
         this.store.setOneByKey(key, filtered);
       }
-      this.emitUpdate([key]);
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1106,19 +1445,33 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
     } else {
       if (this.store.getOneByKey(key) !== void 0) {
         this.store.removeOneByKey(key);
-        this.emitUpdate([key]);
+        this.emitUpdateOne(key);
       }
     }
   }
 };
 
 // src/core/OIMReactiveIndexManualArrayBased.ts
+var OIMIndexManualArrayBasedReactive = class extends OIMIndexManualArrayBased {
+  constructor(updateEmitter, opts) {
+    super(opts);
+    this.updateEmitter = updateEmitter;
+  }
+  emitUpdate(keys) {
+    this.updateEmitter.markUpdatedKeys(keys);
+  }
+  emitUpdateOne(key) {
+    this.updateEmitter.markUpdatedKey(key);
+  }
+};
 var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased {
   constructor(queue, opts) {
-    super(queue, opts);
-  }
-  createDefaultIndex() {
-    return new OIMIndexManualArrayBased();
+    super(queue, (updateEmitter) => {
+      return new OIMIndexManualArrayBasedReactive(
+        updateEmitter,
+        opts?.indexOptions
+      );
+    });
   }
   setPks(key, pks) {
     this.index.setPks(key, pks);
@@ -1142,6 +1495,53 @@ var OIMRICollection = class extends OIMReactiveCollection {
   }
 };
 
+// src/core/OIMObjectStoreMapDriven.ts
+var OIMObjectStoreMapDriven = class extends OIMObjectStore {
+  constructor() {
+    super(...arguments);
+    this.properties = /* @__PURE__ */ new Map();
+  }
+  setProperty(key, value) {
+    this.properties.set(key, value);
+  }
+  merge(draft) {
+    for (const key in draft) {
+      if (!Object.prototype.hasOwnProperty.call(draft, key)) continue;
+      this.properties.set(
+        key,
+        draft[key]
+      );
+    }
+  }
+  delete(key) {
+    this.properties.delete(key);
+  }
+  get(key) {
+    return this.properties.get(key);
+  }
+  getAll() {
+    return Object.fromEntries(this.properties.entries());
+  }
+  clear() {
+    this.properties.clear();
+  }
+  count() {
+    return this.properties.size;
+  }
+  keys() {
+    return Array.from(this.properties.keys());
+  }
+  values() {
+    return Array.from(this.properties.values());
+  }
+  entries() {
+    return Array.from(this.properties.entries());
+  }
+  destroy() {
+    this.properties.clear();
+  }
+};
+
 // src/core/OIMComparatorFactory.ts
 var OIMComparatorFactory = class {
   createShallowComparator() {
@@ -1160,18 +1560,12 @@ var OIMComparatorFactory = class {
   }
 };
 
-// src/enum/EOIMEventQueueEventType.ts
-var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
-  EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
-  EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
-  return EOIMEventQueueEventType2;
-})(EOIMEventQueueEventType || {});
-
 // src/core/OIMEventQueue.ts
 var OIMEventQueue = class {
   constructor(options = {}) {
     this.emitter = new OIMEventEmitter();
-    this.queue = [];
+    this.tasks = /* @__PURE__ */ new Set();
+    this.isFlushing = false;
     this.scheduler = options.scheduler;
     if (this.scheduler) {
       this.flushBound = () => this.flush();
@@ -1182,48 +1576,76 @@ var OIMEventQueue = class {
     }
   }
   /**
-   * Add a function to the queue. If scheduler is configured and autoSchedule is enabled,
-   * automatically schedules a flush operation.
+   * Enqueue a one-shot task to be executed on the next flush.
+   * Returns a dequeue function that can be called to cancel the task before it runs.
    */
   enqueue(fn) {
-    this.queue.push(fn);
-    if (this.scheduler && this.queue.length === 1) {
-      this.scheduler.schedule();
-    }
+    let isActive = true;
+    const task = () => {
+      if (!isActive) return;
+      fn();
+    };
+    this.tasks.add(task);
+    this.ensureScheduled();
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      this.tasks.delete(task);
+    };
+  }
+  get isInFlush() {
+    return this.isFlushing;
+  }
+  /**
+   * Dequeue (cancel) a previously enqueued task by its dequeue function.
+   */
+  dequeue(dequeueFn) {
+    dequeueFn();
   }
   /**
-   * Execute all queued functions and clear the queue.
-   * This method is safe to call multiple times and handles reentrancy.
+   * Execute all pending tasks.
+   *
+   * This flush drains until the queue is empty. If tasks enqueue more tasks, they will be
+   * executed within the same flush.
    */
   flush() {
-    if (this.queue.length === 0) return;
+    this.scheduler?.cancel();
+    this.isFlushing = true;
     this.emitter.emit(1 /* BEFORE_FLUSH */, void 0);
-    const currentQueue = this.queue.slice();
-    this.queue.length = 0;
-    for (let i = 0; i < currentQueue.length; i++) {
-      currentQueue[i]();
+    const snapshot = Array.from(this.tasks);
+    this.tasks.clear();
+    for (let i = 0; i < snapshot.length; i++) {
+      snapshot[i]();
     }
+    this.isFlushing = false;
     this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
   }
   /**
    * Get the current number of queued functions.
    */
   get length() {
-    return this.queue.length;
+    return this.tasks.size;
   }
   /**
    * Check if the queue is empty.
    */
   get isEmpty() {
-    return this.queue.length === 0;
+    return this.tasks.size === 0;
   }
   /**
    * Clear the queue without executing functions and cancel any scheduled flush.
    */
   clear() {
-    this.queue.length = 0;
+    this.tasks.clear();
     this.scheduler?.cancel();
   }
+  ensureScheduled() {
+    if (!this.scheduler) return;
+    if (this.isFlushing) return;
+    if (this.tasks.size === 1) {
+      this.scheduler.schedule();
+    }
+  }
   /**
    * Clean up scheduler subscription when queue is no longer needed.
    */
@@ -1271,7 +1693,7 @@ var OIMIndexComparatorFactory = class {
       if (existingSet.size !== newSet.size || existingSet.size !== existingPks.length) {
         return false;
       }
-      for (const pk of existingSet) {
+      for (const pk of Array.from(existingSet)) {
         if (!newSet.has(pk)) {
           return false;
         }
@@ -1337,9 +1759,390 @@ var OIMMap2Keys = class {
   }
 };
 
-// src/core/event-queue-scheduler/OIMEventQueueSchedulerAnimationFrame.ts
-var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler {
-  constructor() {
+// src/modules/wrapper/collection/OIMCollectionChangedFieldsWrapper.ts
+var OIMCollectionChangedFieldsWrapper = class {
+  constructor(queue, collection, opts) {
+    this.isInWrite = false;
+    this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
+    this.changedFieldsByPk = /* @__PURE__ */ new Map();
+    this.changedPksByField = /* @__PURE__ */ new Map();
+    this.onAfterFlush = () => {
+      this.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];
+        this.trackExternalMutationByPk(pk);
+      }
+    };
+    this.collection = collection;
+    this.selectPk = opts?.selectPk ?? (() => {
+      throw new Error(
+        `[OIMCollectionChangedFieldsWrapper]: 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
+    );
+    const maybeReactive = collection;
+    this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
+      this.onCollectionUpdate({
+        pks
+      });
+    }) : collection.emitter.on(
+      0 /* UPDATE */,
+      this.onCollectionUpdate
+    );
+  }
+  upsertOneByPk(pk, patch) {
+    this.withWrite(() => {
+      this.trackPatch(pk, patch);
+      this.collection.upsertOneByPk(pk, patch);
+    });
+    this.updateEntitySnapshot(pk);
+  }
+  upsertOne(entity) {
+    this.withWrite(() => {
+      const pk = this.selectPk(entity);
+      this.trackPatch(pk, entity);
+      this.collection.upsertOne(entity);
+    });
+    this.updateEntitySnapshot(this.selectPk(entity));
+  }
+  upsertMany(entities) {
+    const pks = [];
+    this.withWrite(() => {
+      for (const entity of entities) {
+        const pk = this.selectPk(entity);
+        pks.push(pk);
+        this.trackPatch(pk, entity);
+      }
+      this.collection.upsertMany(entities);
+    });
+    for (let i = 0; i < pks.length; i++) this.updateEntitySnapshot(pks[i]);
+  }
+  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();
+    this.clear();
+  }
+  withWrite(fn) {
+    if (this.isInWrite) {
+      fn();
+      return;
+    }
+    this.isInWrite = true;
+    try {
+      fn();
+    } finally {
+      this.isInWrite = false;
+    }
+  }
+  trackExternalMutationByPk(pk) {
+    const prev = this.lastEntitySnapshotByPk.get(pk);
+    const next = this.collection.getOneByPk(pk);
+    const changedKeys = this.diffChangedKeys(prev, next);
+    this.updateEntitySnapshot(pk);
+    if (changedKeys.length > 0) {
+      this.trackChangedKeys(pk, changedKeys);
+    } else {
+      this.changedPksEventEmitter.markUpdatedKeys([pk]);
+    }
+  }
+  diffChangedKeys(prev, next) {
+    if (!prev && !next) return [];
+    if (!prev && next) return Object.keys(next);
+    if (prev && !next) return Object.keys(prev);
+    const prevObj = prev;
+    const nextObj = next;
+    const keys = /* @__PURE__ */ new Set();
+    Object.keys(prevObj).forEach((k) => keys.add(k));
+    Object.keys(nextObj).forEach((k) => keys.add(k));
+    const changed = [];
+    keys.forEach((k) => {
+      if (prevObj[k] !== nextObj[k])
+        changed.push(k);
+    });
+    return changed;
+  }
+  updateEntitySnapshot(pk) {
+    const entity = this.collection.getOneByPk(pk);
+    if (!entity) {
+      this.lastEntitySnapshotByPk.delete(pk);
+      return;
+    }
+    this.lastEntitySnapshotByPk.set(pk, {
+      ...entity
+    });
+  }
+  trackChangedKeys(pk, keys) {
+    let pkFields = this.changedFieldsByPk.get(pk);
+    if (!pkFields) {
+      pkFields = /* @__PURE__ */ new Set();
+      this.changedFieldsByPk.set(pk, pkFields);
+    }
+    for (const key of keys) {
+      pkFields.add(key);
+      let fieldPks = this.changedPksByField.get(key);
+      if (!fieldPks) {
+        fieldPks = /* @__PURE__ */ new Set();
+        this.changedPksByField.set(key, fieldPks);
+      }
+      fieldPks.add(pk);
+    }
+    this.changedPksEventEmitter.markUpdatedKeys([pk]);
+    this.changedFieldsEventEmitter.markUpdatedKeys(keys);
+  }
+  trackPatch(pk, patch) {
+    if (pk === void 0 || pk === null || pk === "") {
+      throw new Error(
+        `[OIMCollectionChangedFieldsWrapper]: PK is required to track changes.`
+      );
+    }
+    const keys = Object.keys(patch);
+    if (keys.length === 0) return;
+    this.trackChangedKeys(pk, keys);
+  }
+};
+
+// src/modules/wrapper/index/OIMIndexManualOrderedArrayBased.ts
+var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
+  clear(key) {
+    if (key === void 0) {
+      const keys = this.getKeys();
+      if (keys.length > 0) {
+        this.store.clear();
+        this.emitUpdate(Array.from(keys));
+      }
+      return;
+    }
+    if (this.store.getOneByKey(key) !== void 0) {
+      this.store.removeOneByKey(key);
+      this.emitUpdate([key]);
+    }
+  }
+  push(key, itemKey) {
+    const list = this.getOrCreateList(key);
+    const index = list.length;
+    list.push(itemKey);
+    this.emitUpdate([key]);
+    return index;
+  }
+  insertAt(key, index, itemKey) {
+    const list = this.getOrCreateList(key);
+    const safeIndex = Math.max(0, Math.min(index, list.length));
+    list.splice(safeIndex, 0, itemKey);
+    this.emitUpdate([key]);
+  }
+  removeAt(key, index) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return void 0;
+    if (index < 0 || index >= list.length) return void 0;
+    const [removed] = list.splice(index, 1);
+    if (list.length === 0) {
+      this.store.removeOneByKey(key);
+    }
+    this.emitUpdate([key]);
+    return removed;
+  }
+  move(key, fromIndex, toIndex) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return void 0;
+    if (fromIndex < 0 || fromIndex >= list.length) return void 0;
+    if (toIndex < 0 || toIndex >= list.length) return void 0;
+    if (fromIndex === toIndex) return list[fromIndex];
+    const [itemKey] = list.splice(fromIndex, 1);
+    if (itemKey === void 0) return void 0;
+    list.splice(toIndex, 0, itemKey);
+    this.emitUpdate([key]);
+    return itemKey;
+  }
+  reset(key, itemKeys) {
+    if (itemKeys.length === 0) {
+      if (this.store.getOneByKey(key) !== void 0) {
+        this.store.removeOneByKey(key);
+        this.emitUpdate([key]);
+      }
+      return;
+    }
+    this.store.setOneByKey(key, Array.from(itemKeys));
+    this.emitUpdate([key]);
+  }
+  getOrCreateList(key) {
+    let list = this.store.getOneByKey(key);
+    if (!list) {
+      list = [];
+      this.store.setOneByKey(key, list);
+    }
+    return list;
+  }
+};
+
+// src/modules/wrapper/index/OIMOrderedListIndexCommandStreamWrapper.ts
+var OIMOrderedListIndexCommandStreamWrapper = class {
+  constructor(queue, index) {
+    this.isInWrite = false;
+    this.commandsByKey = /* @__PURE__ */ new Map();
+    this.onAfterFlush = () => {
+      this.commandsByKey.clear();
+    };
+    this.onIndexUpdate = (payload) => {
+      if (this.isInWrite) return;
+      if (payload.keys.length === 0) return;
+      for (let i = 0; i < payload.keys.length; i++) {
+        const key = payload.keys[i];
+        const list = this.index.getPksByKey(key);
+        this.appendCommand(key, { type: "set", keys: Array.from(list) });
+      }
+    };
+    this.commandsEventEmitter = new OIMUpdateEventEmitter(
+      queue,
+      "after_flush"
+    );
+    this.index = index ?? new OIMIndexManualOrderedArrayBased();
+    this.unsubscribeAfterFlush = queue.emitter.on(
+      0 /* AFTER_FLUSH */,
+      this.onAfterFlush
+    );
+    this.unsubscribeFromIndexEmitter = this.index.emitter.on(
+      0 /* UPDATE */,
+      this.onIndexUpdate
+    );
+  }
+  getPksByKey(key) {
+    return this.index.getPksByKey(key);
+  }
+  hasKey(key) {
+    return this.index.hasKey(key);
+  }
+  getKeys() {
+    return this.index.getKeys();
+  }
+  push(key, itemKey) {
+    this.withWrite(() => {
+      const index = this.index.push(key, itemKey);
+      this.appendCommand(key, { type: "add", key: itemKey, index });
+    });
+  }
+  removeAt(key, index) {
+    this.withWrite(() => {
+      const itemKey = this.index.removeAt(key, index);
+      if (itemKey === void 0) return;
+      this.appendCommand(key, { type: "remove", key: itemKey, index });
+    });
+  }
+  move(key, fromIndex, toIndex) {
+    this.withWrite(() => {
+      const itemKey = this.index.move(key, fromIndex, toIndex);
+      if (itemKey === void 0) return;
+      this.appendCommand(key, {
+        type: "move",
+        key: itemKey,
+        fromIndex,
+        toIndex
+      });
+    });
+  }
+  set(key, keys) {
+    this.withWrite(() => {
+      this.index.reset(key, keys);
+      this.appendCommand(key, { type: "set", keys });
+    });
+  }
+  /**
+   * Read-only peek at buffered commands without clearing them.
+   */
+  getBufferedCommands(key) {
+    return this.commandsByKey.get(key) ?? [];
+  }
+  /**
+   * Drain buffered commands for a key, preserving order.
+   * Intended usage: call inside a `commandsEventEmitter.subscribeOnKey(key, ...)` handler.
+   */
+  consumeCommands(key) {
+    const cmds = this.commandsByKey.get(key);
+    if (!cmds || cmds.length === 0) return [];
+    return cmds.slice();
+  }
+  clear(key) {
+    if (key === void 0) {
+      this.index.destroy();
+      this.commandsByKey.clear();
+      return;
+    }
+    this.index.clear(key);
+    this.commandsByKey.delete(key);
+  }
+  destroy() {
+    this.commandsEventEmitter.destroy();
+    this.unsubscribeAfterFlush();
+    this.unsubscribeFromIndexEmitter();
+    this.clear();
+  }
+  withWrite(fn) {
+    if (this.isInWrite) {
+      fn();
+      return;
+    }
+    this.isInWrite = true;
+    try {
+      fn();
+    } finally {
+      this.isInWrite = false;
+    }
+  }
+  appendCommand(key, cmd) {
+    let cmds = this.commandsByKey.get(key);
+    if (!cmds) {
+      cmds = [];
+      this.commandsByKey.set(key, cmds);
+    }
+    if (cmd.type === "set") {
+      cmds.length = 0;
+      cmds.push(cmd);
+    } else if (cmds.length > 0 && cmds[0].type === "set") {
+      const setCmd = cmds[0];
+      setCmd.keys = Array.from(this.index.getPksByKey(key));
+    } else {
+      cmds.push(cmd);
+    }
+    this.commandsEventEmitter.markUpdatedKeys([key]);
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerAnimationFrame.ts
+var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler {
+  constructor() {
     super();
     this.useRequestAnimationFrame = typeof requestAnimationFrame !== "undefined";
   }
@@ -1505,17 +2308,842 @@ var OIMEventQueueSchedulerFactory = class {
     return new OIMEventQueueSchedulerImmediate();
   }
 };
+
+// src/const/OIMDBSettings.ts
+var OIMDBSettings = class {
+};
+/**
+ * Fixed key used in the manual index to store updated keys set in coalescers.
+ * This constant is exported so users can create their own indexes and pass them to coalescers.
+ */
+OIMDBSettings.UPDATED_KEYS_INDEX_KEY = "__updatedKeys__";
+OIMDBSettings.FLUSHING_KEYS_INDEX_KEY = "__flushingKeys__";
+
+// src/modules/effect/core/OIMEffectDependencyComputed.ts
+var OIMEffectDependencyComputed = class {
+  constructor(computed) {
+    this.computed = computed;
+  }
+  subscribe(onUpdate) {
+    return this.computed.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/enum/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() {
+    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
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
+var OIMEffectDependencyKeyed = class {
+  constructor(subscription, keyOrKeys) {
+    this.subscription = subscription;
+    if (isReadonlyArray(keyOrKeys)) {
+      this.keys = keyOrKeys;
+    } else {
+      this.key = keyOrKeys;
+    }
+  }
+  subscribe(onUpdate) {
+    if (this.keys !== void 0) {
+      return this.subscription.subscribeOnKeys(this.keys, onUpdate);
+    }
+    if (this.key === void 0) return () => {
+    };
+    return this.subscription.subscribeOnKey(this.key, onUpdate);
+  }
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedObject.ts
+var OIMEffectDependencyKeyedObject = class {
+  constructor(object, keyOrKeys) {
+    this.dep = new OIMEffectDependencyKeyed(
+      object,
+      keyOrKeys
+    );
+  }
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
+  }
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedCollection.ts
+var OIMEffectDependencyKeyedCollection = class {
+  constructor(collection, pkOrPks) {
+    this.dep = new OIMEffectDependencyKeyed(
+      collection,
+      pkOrPks
+    );
+  }
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
+  }
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
+var OIMEffectDependencyKeyedIndex = class {
+  constructor(index, keyOrKeys) {
+    this.dep = new OIMEffectDependencyKeyed(
+      index,
+      keyOrKeys
+    );
+  }
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
+  }
+};
+
+// src/modules/selector/core/OIMSelector.ts
+var OIMSelector = class {
+  constructor(runtime, sourceDeps, computedDeps = []) {
+    this.runtime = runtime;
+    this.sourceDeps = sourceDeps;
+    this.computedDeps = computedDeps;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.sourceUnsubscribers = [];
+    this.computedUnsubscribers = [];
+    this.isResubscribeEnqueued = false;
+    this.isTemporarilyUnsubscribedForFlush = false;
+    this.isDeliveryEnqueued = false;
+    this.hasLastValue = false;
+    this.onSourceInvalidate = () => {
+      if (this.listeners.size === 0) return;
+      if (!this.isTemporarilyUnsubscribedForFlush) {
+        this.isTemporarilyUnsubscribedForFlush = true;
+        this.unsubscribeFromSourceDeps();
+        this.ensureResubscribeAfterFlush();
+      }
+      if (this.isDeliveryEnqueued) return;
+      this.isDeliveryEnqueued = true;
+      this.dequeueDelivery = this.runtime.schedule(this.deliver);
+    };
+    this.onComputedInvalidate = () => {
+      if (this.listeners.size === 0) return;
+      if (this.isDeliveryEnqueued) return;
+      this.isDeliveryEnqueued = true;
+      this.dequeueDelivery = this.runtime.schedule(this.deliver);
+    };
+    this.deliver = () => {
+      this.isDeliveryEnqueued = false;
+      this.dequeueDelivery = void 0;
+      if (this.listeners.size === 0) return;
+      const next = this.getValue();
+      if (this.hasLastValue && this.areEqual(this.lastValue, next)) return;
+      this.setLastValue(next);
+      const snapshot = Array.from(this.listeners);
+      for (let i = 0; i < snapshot.length; i++) {
+        const listener = snapshot[i];
+        if (this.listeners.has(listener)) listener(next);
+      }
+    };
+    this.onAfterFlush = () => {
+      if (!this.isResubscribeEnqueued) return;
+      this.isResubscribeEnqueued = false;
+      this.dequeueResubscribe = void 0;
+      if (this.listeners.size === 0) return;
+      this.isTemporarilyUnsubscribedForFlush = false;
+      if (this.sourceUnsubscribers.length === 0) {
+        for (const dep of this.sourceDeps) {
+          this.sourceUnsubscribers.push(
+            dep.subscribe(this.onSourceInvalidate)
+          );
+        }
+      }
+    };
+  }
+  get queue() {
+    return this.runtime.queue;
+  }
+  /**
+   * Start watching this selector. The callback is called immediately with the current value,
+   * then coalesced and delivered on `queue.flush()` when the selector invalidates.
+   */
+  watch(onValue) {
+    this.listeners.add(onValue);
+    if (this.listeners.size === 1) {
+      this.subscribeToDeps();
+    }
+    const current = this.getValue();
+    this.setLastValue(current);
+    onValue(current);
+    return () => {
+      this.listeners.delete(onValue);
+      if (this.listeners.size > 0) return;
+      this.unsubscribeFromAllDeps();
+      if (this.dequeueResubscribe) {
+        this.dequeueResubscribe();
+        this.dequeueResubscribe = void 0;
+      }
+      this.isResubscribeEnqueued = false;
+      this.isTemporarilyUnsubscribedForFlush = false;
+      if (this.dequeueDelivery) {
+        this.dequeueDelivery();
+        this.dequeueDelivery = void 0;
+      }
+      this.isDeliveryEnqueued = false;
+      this.hasLastValue = false;
+    };
+  }
+  areEqual(prev, next) {
+    return Object.is(prev, next);
+  }
+  setLastValue(value) {
+    this.lastValue = value;
+    this.hasLastValue = true;
+  }
+  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 unsub of this.sourceUnsubscribers) unsub();
+    this.sourceUnsubscribers = [];
+  }
+  unsubscribeFromAllDeps() {
+    this.unsubscribeFromSourceDeps();
+    if (this.computedUnsubscribers.length === 0) return;
+    for (const unsub of this.computedUnsubscribers) unsub();
+    this.computedUnsubscribers = [];
+  }
+  ensureResubscribeAfterFlush() {
+    if (this.isResubscribeEnqueued) return;
+    this.isResubscribeEnqueued = true;
+    this.dequeueResubscribe = this.runtime.scheduleAfterFlush(
+      this.onAfterFlush
+    );
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKey.ts
+var OIMSelectorSourceDependencyUpdateEventEmitterKey = class {
+  constructor(subscription, key) {
+    this.subscription = subscription;
+    this.key = key;
+  }
+  subscribe(onUpdate) {
+    return this.subscription.subscribeOnKey(this.key, onUpdate);
+  }
+};
+
+// src/modules/selector/core/OIMCollectionByPkSelector.ts
+var OIMCollectionByPkSelector = class extends OIMSelector {
+  constructor(runtime, collection, pk) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
+        collection,
+        pk
+      )
+    ]);
+    this.collection = collection;
+    this.pk = pk;
+  }
+  getValue() {
+    return this.collection.getOneByPk(this.pk);
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKeys.ts
+var OIMSelectorSourceDependencyUpdateEventEmitterKeys = class {
+  constructor(subscription, keys) {
+    this.subscription = subscription;
+    this.keys = keys;
+  }
+  subscribe(onUpdate) {
+    return this.subscription.subscribeOnKeys(this.keys, onUpdate);
+  }
+};
+
+// src/modules/selector/core/OIMCollectionByPksSelector.ts
+var OIMCollectionByPksSelector = class extends OIMSelector {
+  constructor(runtime, collection, pks) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
+        collection,
+        pks
+      )
+    ]);
+    this.collection = collection;
+    this.pks = pks;
+  }
+  getValue() {
+    return this.pks.map((pk) => this.collection.getOneByPk(pk));
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++) {
+      if (prev[i] !== next[i]) return false;
+    }
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMObjectValueByKeySelector.ts
+var OIMObjectValueByKeySelector = class extends OIMSelector {
+  constructor(runtime, obj, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
+        obj,
+        key
+      )
+    ]);
+    this.obj = obj;
+    this.key = key;
+  }
+  getValue() {
+    return this.obj.get(this.key);
+  }
+};
+
+// src/modules/selector/core/OIMObjectValuesByKeysSelector.ts
+var OIMObjectValuesByKeysSelector = class extends OIMSelector {
+  constructor(runtime, obj, keys) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
+        obj,
+        keys
+      )
+    ]);
+    this.obj = obj;
+    this.keys = keys;
+  }
+  getValue() {
+    return this.keys.map((k) => this.obj.get(k));
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++) {
+      if (prev[i] !== next[i]) return false;
+    }
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMIndexPksByKeySetBasedSelector.ts
+var OIMIndexPksByKeySetBasedSelector = class extends OIMSelector {
+  constructor(runtime, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
+        reactiveIndex,
+        key
+      )
+    ]);
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+  }
+  getValue() {
+    return this.reactiveIndex.getPksByKey(this.key);
+  }
+};
+
+// src/modules/selector/core/OIMIndexPksByKeyArrayBasedSelector.ts
+var OIMIndexPksByKeyArrayBasedSelector = class extends OIMSelector {
+  constructor(runtime, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
+        reactiveIndex,
+        key
+      )
+    ]);
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+  }
+  getValue() {
+    return this.reactiveIndex.getPksByKey(this.key);
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++)
+      if (prev[i] !== next[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMIndexPksByKeysSetBasedSelector.ts
+var OIMIndexPksByKeysSetBasedSelector = class extends OIMSelector {
+  constructor(runtime, reactiveIndex, keys) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
+        reactiveIndex,
+        keys
+      )
+    ]);
+    this.reactiveIndex = reactiveIndex;
+    this.keys = keys;
+  }
+  getValue() {
+    return this.keys.map((key) => Array.from(this.reactiveIndex.getPksByKey(key))).flat();
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++)
+      if (prev[i] !== next[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMIndexPksByKeysArrayBasedSelector.ts
+var OIMIndexPksByKeysArrayBasedSelector = class extends OIMSelector {
+  constructor(runtime, reactiveIndex, keys) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
+        reactiveIndex,
+        keys
+      )
+    ]);
+    this.reactiveIndex = reactiveIndex;
+    this.keys = keys;
+  }
+  getValue() {
+    return this.keys.map((key) => this.reactiveIndex.getPksByKey(key)).flat();
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++)
+      if (prev[i] !== next[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByIndexKeySetBased.ts
+var OIMSelectorSourceDependencyEntitiesByIndexKeySetBased = class {
+  constructor(collection, reactiveIndex, key) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = Array.from(
+        this.reactiveIndex.getPksByKey(this.key)
+      );
+      if (this.sameArray(this.currentPks, nextPks)) return;
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = nextPks;
+      if (this.currentPks.length === 0) return;
+      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
+    };
+    const onIndexUpdate = () => {
+      resubscribeCollection();
+      onUpdate();
+    };
+    resubscribeCollection();
+    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
+      this.key,
+      onIndexUpdate
+    );
+    return () => {
+      unsubscribeFromIndex();
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = [];
+    };
+  }
+  sameArray(a, b) {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMEntitiesByIndexKeySetBasedSelector.ts
+var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByIndexKeySetBased(collection, reactiveIndex, key)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+  }
+  getValue() {
+    const pks = Array.from(this.reactiveIndex.getPksByKey(this.key));
+    return pks.map((pk) => this.collection.getOneByPk(pk));
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++)
+      if (prev[i] !== next[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased.ts
+var OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased = class {
+  constructor(collection, reactiveIndex, key) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = this.reactiveIndex.getPksByKey(this.key);
+      if (this.sameArray(this.currentPks, nextPks)) return;
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = nextPks;
+      if (this.currentPks.length === 0) return;
+      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
+    };
+    const onIndexUpdate = () => {
+      resubscribeCollection();
+      onUpdate();
+    };
+    resubscribeCollection();
+    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
+      this.key,
+      onIndexUpdate
+    );
+    return () => {
+      unsubscribeFromIndex();
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = [];
+    };
+  }
+  sameArray(a, b) {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMEntitiesByIndexKeyArrayBasedSelector.ts
+var OIMEntitiesByIndexKeyArrayBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased(collection, reactiveIndex, key)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+  }
+  getValue() {
+    const pks = this.reactiveIndex.getPksByKey(this.key);
+    return pks.map((pk) => this.collection.getOneByPk(pk));
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++)
+      if (prev[i] !== next[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/computative/core/OIMComputativeRuntime.ts
+var OIMComputativeRuntime = class {
+  constructor(queue) {
+    this.queue = queue;
+    this.isFlushScheduled = false;
+    this.isFlushing = false;
+    this.minLevel = Infinity;
+    this.maxLevel = -Infinity;
+    this.dirtyByLevel = /* @__PURE__ */ new Map();
+    this.afterFlushTasks = /* @__PURE__ */ new Set();
+    this.queue.emitter.on(0 /* AFTER_FLUSH */, () => {
+      if (!this.isFlushScheduled) return;
+      this.flush();
+    });
+  }
+  /**
+   * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
+   * ordered by `level` ascending.
+   */
+  schedule(task, level = 0) {
+    let isActive = true;
+    const wrapped = () => {
+      if (!isActive) return;
+      task();
+    };
+    let bucket = this.dirtyByLevel.get(level);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.dirtyByLevel.set(level, bucket);
+    }
+    bucket.add(wrapped);
+    if (level < this.minLevel) this.minLevel = level;
+    if (level > this.maxLevel) this.maxLevel = level;
+    if (!this.isFlushing) this.isFlushScheduled = true;
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      bucket.delete(wrapped);
+    };
+  }
+  /**
+   * Run once at the start of the next runtime flush (i.e. after queue.flush()).
+   * Useful for resubscribing dependencies exactly once per source flush.
+   */
+  scheduleAfterFlush(task) {
+    let isActive = true;
+    const wrapped = () => {
+      if (!isActive) return;
+      task();
+    };
+    this.afterFlushTasks.add(wrapped);
+    if (!this.isFlushing) this.isFlushScheduled = true;
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      this.afterFlushTasks.delete(wrapped);
+    };
+  }
+  flush() {
+    this.isFlushScheduled = false;
+    if (this.dirtyByLevel.size === 0 && this.afterFlushTasks.size === 0)
+      return;
+    this.isFlushing = true;
+    try {
+      if (this.afterFlushTasks.size > 0) {
+        const snapshot = Array.from(this.afterFlushTasks);
+        this.afterFlushTasks.clear();
+        for (let i = 0; i < snapshot.length; i++) snapshot[i]();
+      }
+      if (this.dirtyByLevel.size === 0) 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 snapshot = Array.from(bucket);
+          for (let i = 0; i < snapshot.length; i++) snapshot[i]();
+        }
+        if (this.maxLevel > max) max = this.maxLevel;
+        level++;
+      }
+    } 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;
+      }
+    }
+  }
+};
 export {
   EOIMCollectionEventType,
+  EOIMComputedEventType,
   EOIMEventQueueEventType,
   EOIMEventQueueSchedulerEventType,
   EOIMIndexEventType,
-  EOIMUpdateEventCoalescerEventType,
+  EOIMObjectEventType,
   OIMCollection,
+  OIMCollectionByPkSelector,
+  OIMCollectionByPksSelector,
+  OIMCollectionChangedFieldsWrapper,
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
+  OIMComputativeRuntime,
+  OIMComputed,
   OIMDBSettings,
+  OIMEffect,
+  OIMEffectDependencyComputed,
+  OIMEffectDependencyKeyed,
+  OIMEffectDependencyKeyedCollection,
+  OIMEffectDependencyKeyedIndex,
+  OIMEffectDependencyKeyedObject,
+  OIMEntitiesByIndexKeyArrayBasedSelector,
+  OIMEntitiesByIndexKeySetBasedSelector,
   OIMEntityUpdaterFactory,
   OIMEventEmitter,
   OIMEventQueue,
@@ -1528,13 +3156,25 @@ export {
   OIMIndexArrayBased,
   OIMIndexComparatorFactory,
   OIMIndexManualArrayBased,
+  OIMIndexManualOrderedArrayBased,
   OIMIndexManualSetBased,
+  OIMIndexPksByKeyArrayBasedSelector,
+  OIMIndexPksByKeySetBasedSelector,
+  OIMIndexPksByKeysArrayBasedSelector,
+  OIMIndexPksByKeysSetBasedSelector,
   OIMIndexSetBased,
   OIMIndexStoreArrayBased,
   OIMIndexStoreMapDrivenArrayBased,
   OIMIndexStoreMapDrivenSetBased,
   OIMIndexStoreSetBased,
   OIMMap2Keys,
+  OIMObject,
+  OIMObjectStore,
+  OIMObjectStoreMapDriven,
+  OIMObjectStoreRecordDriven,
+  OIMObjectValueByKeySelector,
+  OIMObjectValuesByKeysSelector,
+  OIMOrderedListIndexCommandStreamWrapper,
   OIMPkSelectorFactory,
   OIMRICollection,
   OIMReactiveCollection,
@@ -1542,8 +3182,6 @@ export {
   OIMReactiveIndexManualArrayBased,
   OIMReactiveIndexManualSetBased,
   OIMReactiveIndexSetBased,
-  OIMUpdateEventCoalescer,
-  OIMUpdateEventCoalescerCollection,
-  OIMUpdateEventCoalescerIndex,
-  OIMUpdateEventEmitter
+  OIMReactiveObject,
+  OIMSelector
 };