@oimdb/core 1.4.0 → 1.5.0

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) {
@@ -145,58 +150,75 @@ var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
 var OIMIndexStoreMapDrivenSetBased = class extends OIMIndexStoreSetBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexSetBased.ts
 var OIMIndexSetBased = class {
   constructor(options = {}) {
+    this.fallbackSlots = /* @__PURE__ */ new Map();
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
     this.store = options.store ?? new OIMIndexStoreMapDrivenSetBased();
+    this.resolveSlot = options.resolveSlot;
   }
   /**
    * Get primary keys for multiple index keys
    */
   getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
+  }
+  setSlotResolver(resolveSlot) {
+    this.resolveSlot = resolveSlot;
+    const allSlots = this.store.getAll();
+    for (const [key, slots] of allSlots) {
+      this.store.setOneByKey(
+        key,
+        this.resolveSlots(this.slotsToPks(slots))
+      );
+    }
   }
   /**
    * @deprecated Use getPksByKey instead
@@ -209,8 +231,15 @@ var OIMIndexSetBased = class {
    * Get primary keys for a specific index key
    */
   getPksByKey(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet : /* @__PURE__ */ new Set();
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? this.slotsToPks(slotsSet) : /* @__PURE__ */ new Set();
+  }
+  getSlotsByKey(key) {
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? slotsSet : /* @__PURE__ */ new Set();
+  }
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
   /**
    * Check if an index key exists
@@ -228,8 +257,8 @@ var OIMIndexSetBased = class {
    * Get the number of primary keys for a specific index key
    */
   getKeySize(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet.size : 0;
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? slotsSet.size : 0;
   }
   /**
    * Get total number of index keys
@@ -251,10 +280,10 @@ var OIMIndexSetBased = class {
     let maxBucketSize = 0;
     let minBucketSize = Infinity;
     const allPks = this.store.getAll();
-    for (const pksSet of allPks.values()) {
-      totalPks += pksSet.size;
-      maxBucketSize = Math.max(maxBucketSize, pksSet.size);
-      minBucketSize = Math.min(minBucketSize, pksSet.size);
+    for (const slotsSet of allPks.values()) {
+      totalPks += slotsSet.size;
+      maxBucketSize = Math.max(maxBucketSize, slotsSet.size);
+      minBucketSize = Math.min(minBucketSize, slotsSet.size);
     }
     return {
       totalKeys: allPks.size,
@@ -276,92 +305,147 @@ var OIMIndexSetBased = class {
    * If comparator is provided and returns true (no changes), skip the update.
    */
   setPksWithComparison(key, newPks) {
+    return this.setSlotsWithComparison(key, this.resolveSlots(newPks));
+  }
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksSet = this.store.getOneByKey(key);
-      if (existingPksSet && existingPksSet.size === newPks.size) {
-        const existingPksArray = existingPksSet.size > 0 ? [...existingPksSet] : [];
-        const newPksArray = newPks.size > 0 ? [...newPks] : [];
+      const existingSlotsSet = this.store.getOneByKey(key);
+      if (existingSlotsSet && existingSlotsSet.size === newSlots.size) {
+        const existingPksArray = Array.from(
+          this.slotsToPks(existingSlotsSet)
+        );
+        const newPksArray = Array.from(this.slotsToPks(newSlots));
         if (this.comparePks(existingPksArray, newPksArray)) {
           return false;
         }
-      } else if (!existingPksSet && newPks.size === 0) {
+      } else if (!existingSlotsSet && newSlots.size === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
+  resolveSlots(pks) {
+    const slots = /* @__PURE__ */ new Set();
+    for (const pk of pks) slots.add(this.getOrCreateSlot(pk));
+    return slots;
+  }
+  getOrCreateSlot(pk) {
+    const resolved = this.resolveSlot?.(pk);
+    if (resolved) return resolved;
+    let fallback = this.fallbackSlots.get(pk);
+    if (!fallback) {
+      fallback = { pk, item: void 0 };
+      this.fallbackSlots.set(pk, fallback);
+    }
+    return fallback;
+  }
+  slotsToPks(slots) {
+    const pks = /* @__PURE__ */ new Set();
+    for (const slot of slots) pks.add(slot.pk);
+    return pks;
+  }
   /**
    * Emit update event with changed keys
    */
   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
 var OIMIndexStoreMapDrivenArrayBased = class extends OIMIndexStoreArrayBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexArrayBased.ts
 var OIMIndexArrayBased = class {
   constructor(options = {}) {
+    this.fallbackSlots = /* @__PURE__ */ new Map();
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
     this.store = options.store ?? new OIMIndexStoreMapDrivenArrayBased();
+    this.resolveSlot = options.resolveSlot;
   }
   /**
    * Get primary keys for multiple index keys
    */
   getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
+  }
+  setSlotResolver(resolveSlot) {
+    this.resolveSlot = resolveSlot;
+    const allSlots = this.store.getAll();
+    for (const [key, slots] of allSlots) {
+      this.store.setOneByKey(
+        key,
+        slots.map((slot) => this.getOrCreateSlot(slot.pk))
+      );
+    }
   }
   /**
    * Get primary keys for a specific index key
    */
   getPksByKey(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray : [];
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? this.slotsToPks(slotsArray) : [];
+  }
+  getSlotsByKey(key) {
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? slotsArray : [];
+  }
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
   /**
    * Check if an index key exists
@@ -379,8 +463,8 @@ var OIMIndexArrayBased = class {
    * Get the number of primary keys for a specific index key
    */
   getKeySize(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray.length : 0;
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? slotsArray.length : 0;
   }
   /**
    * Get total number of index keys
@@ -402,10 +486,10 @@ var OIMIndexArrayBased = class {
     let maxBucketSize = 0;
     let minBucketSize = Infinity;
     const allPks = this.store.getAll();
-    for (const pksArray of allPks.values()) {
-      totalPks += pksArray.length;
-      maxBucketSize = Math.max(maxBucketSize, pksArray.length);
-      minBucketSize = Math.min(minBucketSize, pksArray.length);
+    for (const slotsArray of allPks.values()) {
+      totalPks += slotsArray.length;
+      maxBucketSize = Math.max(maxBucketSize, slotsArray.length);
+      minBucketSize = Math.min(minBucketSize, slotsArray.length);
     }
     return {
       totalKeys: allPks.size,
@@ -427,64 +511,83 @@ var OIMIndexArrayBased = class {
    * If comparator is provided and returns true (no changes), skip the update.
    */
   setPksWithComparison(key, newPks) {
+    return this.setSlotsWithComparison(key, this.resolveSlots(newPks));
+  }
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksArray = this.store.getOneByKey(key);
-      if (existingPksArray && existingPksArray.length === newPks.length) {
-        if (this.comparePks(existingPksArray, newPks)) {
+      const existingSlotsArray = this.store.getOneByKey(key);
+      if (existingSlotsArray && existingSlotsArray.length === newSlots.length) {
+        if (this.comparePks(
+          this.slotsToPks(existingSlotsArray),
+          this.slotsToPks(newSlots)
+        )) {
           return false;
         }
-      } else if (!existingPksArray && newPks.length === 0) {
+      } else if (!existingSlotsArray && newSlots.length === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
+  resolveSlots(pks) {
+    const slots = [];
+    slots.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      slots[i] = this.getOrCreateSlot(pks[i]);
+    }
+    return slots;
+  }
+  getOrCreateSlot(pk) {
+    const resolved = this.resolveSlot?.(pk);
+    if (resolved) return resolved;
+    let fallback = this.fallbackSlots.get(pk);
+    if (!fallback) {
+      fallback = { pk, item: void 0 };
+      this.fallbackSlots.set(pk, fallback);
+    }
+    return fallback;
+  }
+  slotsToPks(slots) {
+    const pks = [];
+    pks.length = slots.length;
+    for (let i = 0; i < slots.length; i++) pks[i] = slots[i].pk;
+    return pks;
+  }
   /**
    * Emit update event with changed keys
    */
   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) {
-    this.keyHandlersBeforeFlush = /* @__PURE__ */ new Map();
+  constructor(queue, deliveryMode = "queue") {
     this.keyHandlers = /* @__PURE__ */ new Map();
-    this.isDestroyed = false;
-    this.isDispatching = false;
-    this.isInPrePhase = false;
-    this.hasPendingDuringPrePhase = false;
     this.isFlushEnqueued = false;
-    this.handleHasChanges = () => {
-      if (this.isDispatching && this.isInPrePhase) {
-        this.hasPendingDuringPrePhase = true;
-        return;
-      }
-      if (this.isFlushEnqueued) return;
-      this.isFlushEnqueued = true;
-      this.queue.enqueue(this.onFlush);
-    };
+    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;
-      if (this.isDestroyed) {
-        this.coalescer.clearUpdatedKeys();
-        this.coalescer.clearFlushingUpdatedKeys();
-        return;
-      }
-      if (this.keyHandlers.size === 0 && this.keyHandlersBeforeFlush.size === 0) {
-        this.coalescer.clearUpdatedKeys();
+      this.dequeueFlush = void 0;
+      if (this.keyHandlers.size === 0) {
+        this.updatedKeys.clear();
         return;
       }
       const makeHandlerSnapshot = (handlers) => {
@@ -492,95 +595,133 @@ var OIMUpdateEventEmitter = class {
         handlers.forEach((h) => snapshot.push(h));
         return snapshot;
       };
-      try {
-        this.isDispatching = true;
-        this.isInPrePhase = true;
-        this.hasPendingDuringPrePhase = false;
-        const allKeysForNormalPhase = this.runPrePhaseDrain(makeHandlerSnapshot);
-        this.isInPrePhase = false;
-        this.runHandlersPhase(allKeysForNormalPhase, makeHandlerSnapshot);
-      } finally {
-        this.isInPrePhase = false;
-        this.isDispatching = false;
-      }
+      this.runSinglePass(makeHandlerSnapshot);
     };
-    this.coalescer = opts.coalescer;
-    this.coalescer.emitter.on(
-      0 /* HAS_CHANGES */,
-      this.handleHasChanges
-    );
-    this.queue = opts.queue;
+    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
+      );
+    }
   }
   /**
-   * Helps to run computed values etc.
+   * Mark keys as updated and schedule delivery.
+   *
+   * If there are no subscriptions, this is a no-op and does not allocate or retain keys.
    */
-  runPrePhaseDrain(makeHandlerSnapshot) {
-    const allKeysForNormalPhase = /* @__PURE__ */ new Set();
-    let hasMorePreWork = true;
-    while (hasMorePreWork) {
-      this.coalescer.markUpdatedKeysAsFlushing();
-      const flushingKeys = this.coalescer.getFlushingUpdatedKeys();
-      flushingKeys.forEach((key) => allKeysForNormalPhase.add(key));
-      try {
-        if (this.keyHandlersBeforeFlush.size > 0) {
-          if (flushingKeys.size * 2 < this.keyHandlersBeforeFlush.size) {
-            flushingKeys.forEach((key) => {
-              if (this.isDestroyed) return;
-              const handlers = this.keyHandlersBeforeFlush.get(key);
-              if (!handlers || handlers.size === 0) return;
-              const handlerSnapshot = makeHandlerSnapshot(handlers);
-              for (let i = 0; i < handlerSnapshot.length; i++) {
-                if (this.isDestroyed) return;
-                const handler = handlerSnapshot[i];
-                if (handlers.has(handler)) handler();
-              }
-            });
-          } else {
-            this.keyHandlersBeforeFlush.forEach((handlers, key) => {
-              if (this.isDestroyed) return;
-              if (!flushingKeys.has(key)) return;
-              if (!handlers || handlers.size === 0) return;
-              const handlerSnapshot = makeHandlerSnapshot(handlers);
-              for (let i = 0; i < handlerSnapshot.length; i++) {
-                if (this.isDestroyed) return;
-                const handler = handlerSnapshot[i];
-                if (handlers.has(handler)) handler();
-              }
-            });
-          }
-        }
-      } finally {
-        this.coalescer.clearFlushingUpdatedKeys();
-      }
-      const nextHasMorePreWork = this.hasPendingDuringPrePhase || this.coalescer.getUpdatedKeys().size > 0;
-      this.hasPendingDuringPrePhase = false;
-      hasMorePreWork = nextHasMorePreWork;
+  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;
     }
-    return allKeysForNormalPhase;
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
   }
-  runHandlersPhase(allKeysForNormalPhase, makeHandlerSnapshot) {
-    if (this.keyHandlers.size === 0 || allKeysForNormalPhase.size === 0)
+  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 (allKeysForNormalPhase.size * 2 < this.keyHandlers.size) {
-      allKeysForNormalPhase.forEach((key) => {
-        if (this.isDestroyed) 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++) {
-          if (this.isDestroyed) return;
           const handler = handlerSnapshot[i];
           if (handlers.has(handler)) handler();
         }
       });
     } else {
       this.keyHandlers.forEach((handlers, key) => {
-        if (this.isDestroyed) return;
-        if (!allKeysForNormalPhase.has(key)) return;
+        if (!flushingKeys.has(key)) return;
         if (!handlers || handlers.size === 0) return;
         const handlerSnapshot = makeHandlerSnapshot(handlers);
         for (let i = 0; i < handlerSnapshot.length; i++) {
-          if (this.isDestroyed) return;
           const handler = handlerSnapshot[i];
           if (handlers.has(handler)) handler();
         }
@@ -588,14 +729,17 @@ var OIMUpdateEventEmitter = class {
     }
   }
   destroy() {
-    if (this.isDestroyed) return;
-    this.isDestroyed = true;
-    this.coalescer.emitter.off(
-      0 /* HAS_CHANGES */,
-      this.handleHasChanges
-    );
-    this.keyHandlersBeforeFlush.clear();
+    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
@@ -616,32 +760,13 @@ var OIMUpdateEventEmitter = class {
    * Check if there are any active subscriptions
    */
   hasSubscriptions() {
-    return this.keyHandlers.size > 0 || this.keyHandlersBeforeFlush.size > 0;
+    return this.keyHandlers.size > 0;
   }
   /**
    * Get the number of handlers for a specific key
    */
   getHandlerCount(key) {
-    return (this.keyHandlers.get(key)?.size ?? 0) + (this.keyHandlersBeforeFlush.get(key)?.size ?? 0);
-  }
-  subscribeOnKeyBeforeFlush(key, handler) {
-    let handlers = this.keyHandlersBeforeFlush.get(key);
-    if (!handlers) {
-      handlers = /* @__PURE__ */ new Set();
-      this.keyHandlersBeforeFlush.set(key, handlers);
-    }
-    handlers.add(handler);
-    return () => {
-      this.unsubscribeFromKeyBeforeFlush(key, handler);
-    };
-  }
-  unsubscribeFromKeyBeforeFlush(key, handler) {
-    const handlers = this.keyHandlersBeforeFlush.get(key);
-    if (!handlers) return;
-    handlers.delete(handler);
-    if (handlers.size === 0) {
-      this.keyHandlersBeforeFlush.delete(key);
-    }
+    return this.keyHandlers.get(key)?.size ?? 0;
   }
   subscribeOnKey(key, handler) {
     let handlers = this.keyHandlers.get(key);
@@ -660,6 +785,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) {
@@ -681,30 +815,6 @@ var OIMUpdateEventEmitter = class {
       }
     };
   }
-  subscribeOnKeysBeforeFlush(keys, handler) {
-    const subscribedKeys = [];
-    for (const key of keys) {
-      let handlers = this.keyHandlersBeforeFlush.get(key);
-      if (!handlers) {
-        handlers = /* @__PURE__ */ new Set();
-        this.keyHandlersBeforeFlush.set(key, handlers);
-      }
-      if (!handlers.has(handler)) {
-        handlers.add(handler);
-        subscribedKeys.push(key);
-      }
-    }
-    return () => {
-      for (const key of subscribedKeys) {
-        this.unsubscribeFromKeyBeforeFlush(key, handler);
-      }
-    };
-  }
-  unsubscribeFromKeysBeforeFlush(keys, handler) {
-    for (const key of keys) {
-      this.unsubscribeFromKeyBeforeFlush(key, handler);
-    }
-  }
   unsubscribeFromKeys(keys, handler) {
     for (const key of keys) {
       this.unsubscribeFromKey(key, handler);
@@ -712,203 +822,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__";
-OIMDBSettings.FLUSHING_KEYS_INDEX_KEY = "__flushingKeys__";
-
-// src/core/OIMUpdateEventCoalescer.ts
-var OIMUpdateEventCoalescer = class {
-  constructor(index, flushingIndex) {
-    this.emitter = new OIMEventEmitter();
-    this.hasEmittedChanges = false;
-    this.updatedKeysIndex = index ?? new OIMIndexManualSetBased({
-      store: new OIMIndexStoreMapDrivenSetBased()
-    });
-    this.flushingUpdatedKeysIndex = flushingIndex ?? 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
-    );
-  }
-  getFlushingUpdatedKeys() {
-    return this.flushingUpdatedKeysIndex.getPksByKey(
-      OIMDBSettings.FLUSHING_KEYS_INDEX_KEY
-    );
-  }
-  markUpdatedKeysAsFlushing() {
-    this.flushingUpdatedKeysIndex.setPks(
-      OIMDBSettings.FLUSHING_KEYS_INDEX_KEY,
-      Array.from(this.getUpdatedKeys())
-    );
-    this.clearUpdatedKeys();
-  }
-  /**
-   * 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
-    );
-  }
-  clearFlushingUpdatedKeys() {
-    this.flushingUpdatedKeysIndex.setPks(
-      OIMDBSettings.FLUSHING_KEYS_INDEX_KEY,
-      []
-    );
-  }
-  /**
-   * 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);
@@ -916,6 +834,12 @@ var OIMReactiveIndexSetBased = class {
   getPksByKeys(keys) {
     return this.index.getPksByKeys(keys);
   }
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
+  }
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
+  }
   hasKey(key) {
     return this.index.hasKey(key);
   }
@@ -934,24 +858,38 @@ var OIMReactiveIndexSetBased = class {
   getMetrics() {
     return this.index.getMetrics();
   }
-  destroy() {
-    this.updateEventEmitter.destroy();
-    this.coalescer.destroy();
-    this.index.destroy();
+  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);
@@ -959,6 +897,12 @@ var OIMReactiveIndexArrayBased = class {
   getPksByKeys(keys) {
     return this.index.getPksByKeys(keys);
   }
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
+  }
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
+  }
   hasKey(key) {
     return this.index.hasKey(key);
   }
@@ -977,9 +921,29 @@ 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.updateEventEmitter.destroy();
-    this.coalescer.destroy();
+    this.updateEmitter.destroy();
     this.index.destroy();
   }
 };
@@ -999,26 +963,52 @@ var OIMPkSelectorFactory = class {
 var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   constructor() {
     super(...arguments);
-    this.entities = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
   setOneByPk(pk, entity) {
-    this.entities.set(pk, entity);
+    const slot = this.slots.get(pk);
+    if (slot) {
+      slot.item = entity;
+    } else {
+      this.slots.set(pk, { pk, item: entity });
+    }
   }
   setManyByPks(pks, entities) {
     for (let i = 0; i < pks.length; i++) {
-      this.entities.set(pks[i], entities[i]);
+      this.setOneByPk(pks[i], entities[i]);
+    }
+  }
+  getSlotByPk(pk) {
+    return this.slots.get(pk);
+  }
+  getSlotsByPks(pks) {
+    const result = [];
+    result.length = pks.length;
+    let writeIndex = 0;
+    for (let i = 0; i < pks.length; i++) {
+      const slot = this.slots.get(pks[i]);
+      if (slot !== void 0) {
+        result[writeIndex++] = slot;
+      }
     }
+    result.length = writeIndex;
+    return result;
+  }
+  getAllSlots() {
+    return Array.from(this.slots.values());
   }
   removeOneByPk(pk) {
-    this.entities.delete(pk);
+    const slot = this.slots.get(pk);
+    if (slot) slot.item = void 0;
+    this.slots.delete(pk);
   }
   removeManyByPks(pks) {
     for (const pk of pks) {
-      this.entities.delete(pk);
+      this.removeOneByPk(pk);
     }
   }
   getOneByPk(pk) {
-    return this.entities.get(pk);
+    return this.slots.get(pk)?.item;
   }
   getManyByPks(pks) {
     const result = [];
@@ -1034,16 +1024,23 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
     return result;
   }
   getAll() {
-    return Array.from(this.entities.values());
+    const result = [];
+    for (const slot of this.slots.values()) {
+      if (slot.item !== void 0) result.push(slot.item);
+    }
+    return result;
   }
   countAll() {
-    return this.entities.size;
+    return this.slots.size;
   }
   clear() {
-    this.entities.clear();
+    for (const slot of this.slots.values()) {
+      slot.item = void 0;
+    }
+    this.slots.clear();
   }
   getAllPks() {
-    return Array.from(this.entities.keys());
+    return Array.from(this.slots.keys());
   }
   destroy() {
     this.clear();
@@ -1079,6 +1076,15 @@ var OIMCollection = class {
   getManyByPks(pks) {
     return this.store.getManyByPks(pks);
   }
+  getSlotByPk(pk) {
+    return this.store.getSlotByPk(pk);
+  }
+  getSlotsByPks(pks) {
+    return this.store.getSlotsByPks(pks);
+  }
+  getAllSlots() {
+    return this.store.getAllSlots();
+  }
   upsertOneByPk(pk, entity) {
     this.upsertOneWithoutNotificationsByPk(pk, entity);
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
@@ -1151,47 +1157,139 @@ var OIMCollection = class {
   }
 };
 
-// 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.emitter.offAll();
-    this.clearUpdatedKeys();
-  }
-};
-
 // src/core/OIMReactiveCollection.ts
 var OIMReactiveCollection = class extends OIMCollection {
   constructor(queue, opts) {
     super(opts);
-    this.coalescer = new OIMUpdateEventCoalescerCollection(
-      this.emitter
+    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");
+  }
+  subscribeOnKey(pk, handler) {
+    return this.updateEmitter.subscribeOnKey(pk, handler);
+  }
+  subscribeOnKeys(pks, handler) {
+    return this.updateEmitter.subscribeOnKeys(pks, handler);
+  }
+  unsubscribeFromKey(pk, handler) {
+    this.updateEmitter.unsubscribeFromKey(pk, handler);
+  }
+  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.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  upsertOne(entity) {
+    const pk = this.upsertOneWithoutNotifications(entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  upsertMany(entities) {
+    const pks = entities.map(
+      (entity) => this.upsertOneWithoutNotifications(entity)
     );
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
-    });
+    this.emitter.emit(0 /* UPDATE */, { pks });
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  removeOne(entity) {
+    const pk = this.selectPk(entity);
+    this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  removeMany(entities) {
+    const pks = entities.map(this.selectPk);
+    this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  removeOneByPk(pk) {
+    this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    this.updateEmitter.markUpdatedKey(pk);
+    this.trackAnyUpdatePk(pk);
+  }
+  removeManyByPks(pks) {
+    this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
+    this.updateEmitter.markUpdatedKeys(pks);
+    this.trackAnyUpdatePks(pks);
+  }
+  clear() {
+    this.store.clear();
+    this.emitter.emit(0 /* UPDATE */, { pks: [] });
+    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.updateEventEmitter.destroy();
-    this.coalescer.destroy();
+    this.updateEmitter.destroy();
+    if (this.dequeueAnyUpdate) {
+      this.dequeueAnyUpdate();
+      this.dequeueAnyUpdate = void 0;
+    }
+    this.anyUpdateHandlers.clear();
+    this.pendingAnyUpdatePks.clear();
     super.destroy();
   }
 };
@@ -1291,54 +1389,158 @@ var OIMObject = class {
   }
 };
 
-// src/core/OIMUpdateEventCoalescerObject.ts
-var OIMUpdateEventCoalescerObject = class extends OIMUpdateEventCoalescer {
-  constructor(objectEmitter) {
-    super();
-    this.objectEmitter = objectEmitter;
-    /**
-     * When the object is updated, we keep track of the updated keys.
-     */
-    this.handleUpdate = (payload) => {
-      this.addUpdatedKeys(payload.keys);
-    };
-    this.objectEmitter.on(0 /* UPDATE */, this.handleUpdate);
-  }
-  destroy() {
-    this.objectEmitter.off(0 /* UPDATE */, this.handleUpdate);
-    this.emitter.offAll();
-    this.clearUpdatedKeys();
-  }
-};
-
 // src/core/OIMReactiveObject.ts
 var OIMReactiveObject = class extends OIMObject {
   constructor(queue, opts) {
     super(opts);
-    this.coalescer = new OIMUpdateEventCoalescerObject(this.emitter);
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
+    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.updateEventEmitter.destroy();
-    this.coalescer.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);
+    }
+  }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, new Set(slots));
+    if (hasChanges) {
+      this.emitUpdateOne(key);
+    }
+  }
+  /**
+   * Add primary keys to a specific index key
+   */
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    let slotsSet = this.store.getOneByKey(key);
+    if (!slotsSet) {
+      slotsSet = /* @__PURE__ */ new Set();
+      this.store.setOneByKey(key, slotsSet);
+    }
+    const pksSet = this.slotsToPks(slotsSet);
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (!pksSet.has(pk)) {
+        pksSet.add(pk);
+        slotsSet.add(this.getOrCreateSlot(pk));
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.store.setOneByKey(key, slotsSet);
+      this.emitUpdateOne(key);
+    }
+  }
+  /**
+   * Remove primary keys from a specific index key
+   */
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const slotsSet = this.store.getOneByKey(key);
+    if (!slotsSet) return;
+    let hasChanges = false;
+    const pksToRemove = new Set(pks);
+    for (const slot of Array.from(slotsSet)) {
+      if (pksToRemove.has(slot.pk) && slotsSet.delete(slot)) {
+        hasChanges = true;
+      }
+    }
+    if (slotsSet.size === 0) {
+      this.store.removeOneByKey(key);
+      hasChanges = true;
+    } else if (hasChanges) {
+      this.store.setOneByKey(key, slotsSet);
+    }
+    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, opts);
-  }
-  createDefaultIndex() {
-    return new OIMIndexManualSetBased();
+    super(queue, (updateEmitter) => {
+      return new OIMIndexManualSetBasedReactive(
+        updateEmitter,
+        opts?.indexOptions
+      );
+    });
   }
   setPks(key, pks) {
     this.index.setPks(key, pks);
   }
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
+  }
   addPks(key, pks) {
     this.index.addPks(key, pks);
   }
@@ -1362,7 +1564,13 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
   setPks(key, pks) {
     const hasChanges = this.setPksWithComparison(key, pks);
     if (hasChanges) {
-      this.emitUpdate([key]);
+      this.emitUpdateOne(key);
+    }
+  }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, slots);
+    if (hasChanges) {
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1370,22 +1578,24 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
    */
   addPks(key, pks) {
     if (pks.length === 0) return;
-    let pksArray = this.store.getOneByKey(key);
-    if (!pksArray) {
-      pksArray = [];
-      this.store.setOneByKey(key, pksArray);
+    let slotsArray = this.store.getOneByKey(key);
+    if (!slotsArray) {
+      slotsArray = [];
+      this.store.setOneByKey(key, slotsArray);
     }
-    const pksSet = new Set(pksArray);
+    const pksSet = new Set(slotsArray.map((slot) => slot.pk));
     let hasChanges = false;
+    const nextSlots = slotsArray.slice();
     for (const pk of pks) {
       if (!pksSet.has(pk)) {
         pksSet.add(pk);
+        nextSlots.push(this.getOrCreateSlot(pk));
         hasChanges = true;
       }
     }
     if (hasChanges) {
-      this.store.setOneByKey(key, Array.from(pksSet));
-      this.emitUpdate([key]);
+      this.store.setOneByKey(key, nextSlots);
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1393,18 +1603,18 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
    */
   removePks(key, pks) {
     if (pks.length === 0) return;
-    const pksArray = this.store.getOneByKey(key);
-    if (!pksArray) return;
+    const slotsArray = this.store.getOneByKey(key);
+    if (!slotsArray) return;
     const pksSet = new Set(pks);
-    const filtered = pksArray.filter((pk) => !pksSet.has(pk));
-    const hasChanges = filtered.length !== pksArray.length;
+    const filtered = slotsArray.filter((slot) => !pksSet.has(slot.pk));
+    const hasChanges = filtered.length !== slotsArray.length;
     if (hasChanges) {
       if (filtered.length === 0) {
         this.store.removeOneByKey(key);
       } else {
         this.store.setOneByKey(key, filtered);
       }
-      this.emitUpdate([key]);
+      this.emitUpdateOne(key);
     }
   }
   /**
@@ -1420,23 +1630,40 @@ 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);
   }
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
+  }
   addPks(key, pks) {
     this.index.addPks(key, pks);
   }
@@ -1453,6 +1680,10 @@ var OIMRICollection = class extends OIMReactiveCollection {
   constructor(queue, opts) {
     super(queue, opts.collectionOpts);
     this.indexes = opts.indexes || {};
+    const indexes = Object.values(this.indexes);
+    for (const index of indexes) {
+      index.index.setSlotResolver((pk) => this.getSlotByPk(pk));
+    }
   }
 };
 
@@ -1521,20 +1752,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.pendingSchedule = false;
     this.scheduler = options.scheduler;
     if (this.scheduler) {
       this.flushBound = () => this.flush();
@@ -1545,62 +1768,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) return;
-    if (this.isFlushing) {
-      this.pendingSchedule = true;
-      return;
-    }
-    if (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;
   }
   /**
-   * Execute all queued functions and clear the queue.
-   * This method is safe to call multiple times and handles reentrancy.
+   * Dequeue (cancel) a previously enqueued task by its dequeue function.
    */
-  flush() {
-    if (this.queue.length === 0) return;
-    this.scheduler?.cancel();
+  dequeue(dequeueFn) {
+    dequeueFn();
+  }
+  /**
+   * 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() {
+    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.emitter.emit(0 /* AFTER_FLUSH */, void 0);
     this.isFlushing = false;
-    if (this.scheduler && this.pendingSchedule && this.queue.length > 0) {
-      this.pendingSchedule = false;
-      this.scheduler.schedule();
-    } else {
-      this.pendingSchedule = 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.
    */
@@ -1714,56 +1951,75 @@ var OIMMap2Keys = class {
   }
 };
 
-// src/modules/wrapper/OIMUpdateEventCoalescerManual.ts
-var OIMUpdateEventCoalescerManual = class extends OIMUpdateEventCoalescer {
-  markUpdatedKeys(keys) {
-    if (keys.length === 0) return;
-    this.addUpdatedKeys(keys);
-  }
-  destroy() {
-    this.emitter.offAll();
-    this.updatedKeysIndex.destroy();
-    this.flushingUpdatedKeysIndex.destroy();
-  }
-};
-
 // 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.changedPksCoalescer = new OIMUpdateEventCoalescerManual();
-    this.changedPksEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.changedPksCoalescer,
-      queue
-    });
-    this.changedFieldsCoalescer = new OIMUpdateEventCoalescerManual();
-    this.changedFieldsEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.changedFieldsCoalescer,
-      queue
-    });
+    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.trackPatch(pk, patch);
-    this.collection.upsertOneByPk(pk, patch);
+    this.withWrite(() => {
+      this.trackPatch(pk, patch);
+      this.collection.upsertOneByPk(pk, patch);
+    });
+    this.updateEntitySnapshot(pk);
   }
   upsertOne(entity) {
-    const pk = this.selectPk(entity);
-    this.trackPatch(pk, entity);
-    this.collection.upsertOne(entity);
-  }
-  upsertMany(entities) {
-    for (const entity of entities) {
+    this.withWrite(() => {
       const pk = this.selectPk(entity);
       this.trackPatch(pk, entity);
-    }
-    this.collection.upsertMany(entities);
+      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();
@@ -1771,8 +2027,7 @@ var OIMCollectionChangedFieldsWrapper = class {
   consumeChangedFieldsByPk(pk) {
     const existing = this.changedFieldsByPk.get(pk);
     if (!existing) return /* @__PURE__ */ new Set();
-    this.changedFieldsByPk.delete(pk);
-    return existing;
+    return new Set(existing);
   }
   getChangedPksByField(field) {
     return this.changedPksByField.get(field) ?? /* @__PURE__ */ new Set();
@@ -1780,8 +2035,7 @@ var OIMCollectionChangedFieldsWrapper = class {
   consumeChangedPksByField(field) {
     const existing = this.changedPksByField.get(field);
     if (!existing) return /* @__PURE__ */ new Set();
-    this.changedPksByField.delete(field);
-    return existing;
+    return new Set(existing);
   }
   clear() {
     this.changedFieldsByPk.clear();
@@ -1790,18 +2044,60 @@ var OIMCollectionChangedFieldsWrapper = class {
   destroy() {
     this.changedPksEventEmitter.destroy();
     this.changedFieldsEventEmitter.destroy();
-    this.changedPksCoalescer.destroy();
-    this.changedFieldsCoalescer.destroy();
+    this.unsubscribeAfterFlush();
+    this.unsubscribeFromCollectionEmitter();
     this.clear();
   }
-  trackPatch(pk, patch) {
-    if (pk === void 0 || pk === null || pk === "") {
-      throw new Error(
-        `[OIMCollectionChangedFieldsWrapper]: PK is required to track changes.`
-      );
+  withWrite(fn) {
+    if (this.isInWrite) {
+      fn();
+      return;
     }
-    const keys = Object.keys(patch);
-    if (keys.length === 0) 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();
@@ -1816,8 +2112,18 @@ var OIMCollectionChangedFieldsWrapper = class {
       }
       fieldPks.add(pk);
     }
-    this.changedPksCoalescer.markUpdatedKeys([pk]);
-    this.changedFieldsCoalescer.markUpdatedKeys(keys);
+    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);
   }
 };
 
@@ -1840,14 +2146,14 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
   push(key, itemKey) {
     const list = this.getOrCreateList(key);
     const index = list.length;
-    list.push(itemKey);
+    list.push(this.getOrCreateSlot(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);
+    list.splice(safeIndex, 0, this.getOrCreateSlot(itemKey));
     this.emitUpdate([key]);
   }
   removeAt(key, index) {
@@ -1859,19 +2165,19 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
       this.store.removeOneByKey(key);
     }
     this.emitUpdate([key]);
-    return removed;
+    return removed?.pk;
   }
   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];
+    if (fromIndex === toIndex) return list[fromIndex]?.pk;
     const [itemKey] = list.splice(fromIndex, 1);
     if (itemKey === void 0) return void 0;
     list.splice(toIndex, 0, itemKey);
     this.emitUpdate([key]);
-    return itemKey;
+    return itemKey.pk;
   }
   reset(key, itemKeys) {
     if (itemKeys.length === 0) {
@@ -1881,7 +2187,7 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
       }
       return;
     }
-    this.store.setOneByKey(key, Array.from(itemKeys));
+    this.store.setOneByKey(key, this.resolveSlots(itemKeys));
     this.emitUpdate([key]);
   }
   getOrCreateList(key) {
@@ -1897,13 +2203,33 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
 // src/modules/wrapper/index/OIMOrderedListIndexCommandStreamWrapper.ts
 var OIMOrderedListIndexCommandStreamWrapper = class {
   constructor(queue, index) {
+    this.isInWrite = false;
     this.commandsByKey = /* @__PURE__ */ new Map();
-    this.coalescer = new OIMUpdateEventCoalescerManual();
-    this.commandsEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue
-    });
+    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);
@@ -1915,27 +2241,35 @@ var OIMOrderedListIndexCommandStreamWrapper = class {
     return this.index.getKeys();
   }
   push(key, itemKey) {
-    const index = this.index.push(key, itemKey);
-    this.appendCommand(key, { type: "add", key: itemKey, index });
+    this.withWrite(() => {
+      const index = this.index.push(key, itemKey);
+      this.appendCommand(key, { type: "add", key: itemKey, index });
+    });
   }
   removeAt(key, index) {
-    const itemKey = this.index.removeAt(key, index);
-    if (itemKey === void 0) return;
-    this.appendCommand(key, { type: "remove", key: itemKey, 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) {
-    const itemKey = this.index.move(key, fromIndex, toIndex);
-    if (itemKey === void 0) return;
-    this.appendCommand(key, {
-      type: "move",
-      key: itemKey,
-      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
+      });
     });
   }
-  reset(key, keys) {
-    this.index.reset(key, keys);
-    this.appendCommand(key, { type: "reset", keys });
+  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.
@@ -1950,8 +2284,7 @@ var OIMOrderedListIndexCommandStreamWrapper = class {
   consumeCommands(key) {
     const cmds = this.commandsByKey.get(key);
     if (!cmds || cmds.length === 0) return [];
-    this.commandsByKey.delete(key);
-    return cmds;
+    return cmds.slice();
   }
   clear(key) {
     if (key === void 0) {
@@ -1964,17 +2297,38 @@ var OIMOrderedListIndexCommandStreamWrapper = class {
   }
   destroy() {
     this.commandsEventEmitter.destroy();
-    this.coalescer.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);
     }
-    cmds.push(cmd);
-    this.coalescer.markUpdatedKeys([key]);
+    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]);
   }
 };
 
@@ -2147,159 +2501,160 @@ var OIMEventQueueSchedulerFactory = class {
   }
 };
 
+// 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(queue, opts) {
-    this.unsubscribers = [];
-    this.isDestroyed = false;
-    this.isInFlush = false;
-    this.hasRunInThisFlush = false;
+  constructor(runtime, opts) {
+    this.sourceDeps = [];
+    this.computedDeps = [];
+    this.sourceUnsubscribers = [];
+    this.computedUnsubscribers = [];
+    this.isResubscribeEnqueued = false;
+    this.isTemporarilyUnsubscribedForFlush = false;
     this.isScheduled = false;
-    this.handleQueueBeforeFlush = () => {
-      this.isInFlush = true;
-      this.hasRunInThisFlush = false;
-    };
-    this.handleQueueAfterFlush = () => {
-      this.isInFlush = false;
-      this.hasRunInThisFlush = false;
-    };
     this.runTask = () => {
       this.isScheduled = false;
-      if (this.isDestroyed) return;
+      this.dequeueScheduled = void 0;
       this.runOnce();
     };
-    this.invalidate = () => {
-      if (this.isDestroyed) return;
-      this.onInvalidate?.();
-      if (this.isInFlush) {
-        if (this.hasRunInThisFlush) return;
-        this.hasRunInThisFlush = true;
-        this.runOnce();
-        return;
+    this.onSourceInvalidate = () => {
+      this.onUpdate?.();
+      if (!this.isTemporarilyUnsubscribedForFlush) {
+        this.isTemporarilyUnsubscribedForFlush = true;
+        this.unsubscribeFromSourceDeps();
+        this.ensureResubscribeAfterFlush();
       }
       if (this.isScheduled) return;
       this.isScheduled = true;
-      this.queue.enqueue(this.runTask);
+      this.dequeueScheduled = this.runtime.schedule(this.runTask);
     };
-    this.queue = queue;
-    this.phase = opts.phase;
-    this.onInvalidate = opts.onInvalidate;
+    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 ?? [];
-    this.queue.emitter.on(
-      1 /* BEFORE_FLUSH */,
-      this.handleQueueBeforeFlush
-    );
-    this.queue.emitter.on(
-      0 /* AFTER_FLUSH */,
-      this.handleQueueAfterFlush
-    );
     for (const dep of this.deps) {
-      this.unsubscribers.push(dep.subscribe(this.phase, this.invalidate));
+      if (dep instanceof OIMEffectDependencyComputed) {
+        this.computedDeps.push(dep);
+      } else {
+        this.sourceDeps.push(dep);
+      }
     }
+    this.subscribeToDeps();
   }
   destroy() {
-    if (this.isDestroyed) return;
-    this.isDestroyed = true;
-    for (const unsubscribe of this.unsubscribers) unsubscribe();
-    this.unsubscribers = [];
-    this.queue.emitter.off(
-      1 /* BEFORE_FLUSH */,
-      this.handleQueueBeforeFlush
-    );
-    this.queue.emitter.off(
-      0 /* AFTER_FLUSH */,
-      this.handleQueueAfterFlush
-    );
+    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() {
-    if (this.isDestroyed) return;
     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/effect/enum/EOIMEffectPhase.ts
-var EOIMEffectPhase = /* @__PURE__ */ ((EOIMEffectPhase2) => {
-  EOIMEffectPhase2["PRE"] = "pre";
-  EOIMEffectPhase2["HANDLERS"] = "handlers";
-  return EOIMEffectPhase2;
-})(EOIMEffectPhase || {});
-
 // src/modules/computed/enum/EOIMComputedEventType.ts
 var EOIMComputedEventType = /* @__PURE__ */ ((EOIMComputedEventType2) => {
   EOIMComputedEventType2["UPDATE"] = "update";
   return EOIMComputedEventType2;
 })(EOIMComputedEventType || {});
 
-// src/modules/computed/core/OIMUpdateEventCoalescerComputed.ts
-var OIMUpdateEventCoalescerComputed = class extends OIMUpdateEventCoalescer {
-  constructor(computedEmitter) {
-    super();
-    this.computedEmitter = computedEmitter;
-    this.handleUpdate = (payload) => {
-      this.addUpdatedKeys(payload.keys);
-    };
-    this.computedEmitter.on(
-      "update" /* UPDATE */,
-      this.handleUpdate
-    );
-  }
-  destroy() {
-    this.computedEmitter.off(
-      "update" /* UPDATE */,
-      this.handleUpdate
-    );
-    this.emitter.offAll();
-    this.clearUpdatedKeys();
-  }
-};
-
 // src/modules/computed/core/OIMComputed.ts
 var OIMComputed = class {
-  constructor(queue, opts) {
+  constructor(runtime, opts) {
     this.emitter = new OIMEventEmitter();
     this.hasValue = false;
     this.isDirty = true;
-    this.isInFlush = false;
-    this.hasRecomputedInThisFlush = false;
-    this.handleQueueBeforeFlush = () => {
-      this.isInFlush = true;
-      this.hasRecomputedInThisFlush = false;
-    };
-    this.handleQueueAfterFlush = () => {
-      this.isInFlush = false;
-      this.hasRecomputedInThisFlush = false;
-    };
-    this.queue = queue;
+    this.runtime = runtime;
     this.compute = opts.compute;
     this.compare = opts.compare ?? Object.is;
     this.deps = opts.deps ?? [];
-    this.coalescer = new OIMUpdateEventCoalescerComputed(
-      this.emitter
-    );
-    this.updateEventEmitter = new OIMUpdateEventEmitter({
-      coalescer: this.coalescer,
-      queue: this.queue
-    });
-    this.queue.emitter.on(
-      1 /* BEFORE_FLUSH */,
-      this.handleQueueBeforeFlush
+    this.updateEventEmitter = new OIMUpdateEventEmitter(
+      this.runtime.queue,
+      "immediate"
     );
-    this.queue.emitter.on(
-      0 /* AFTER_FLUSH */,
-      this.handleQueueAfterFlush
-    );
-    this.effect = new OIMEffect(this.queue, {
+    this.effect = new OIMEffect(this.runtime, {
       deps: this.deps,
-      phase: "pre" /* PRE */,
-      onInvalidate: () => {
+      onUpdate: () => {
         this.isDirty = true;
       },
       run: () => {
-        if (this.isInFlush) {
-          if (this.hasRecomputedInThisFlush) return;
-          this.hasRecomputedInThisFlush = true;
-        }
         this.recomputeAndEmitIfChanged();
       }
     });
@@ -2313,16 +2668,7 @@ var OIMComputed = class {
   }
   destroy() {
     this.effect.destroy();
-    this.queue.emitter.off(
-      1 /* BEFORE_FLUSH */,
-      this.handleQueueBeforeFlush
-    );
-    this.queue.emitter.off(
-      0 /* AFTER_FLUSH */,
-      this.handleQueueAfterFlush
-    );
     this.updateEventEmitter.destroy();
-    this.coalescer.destroy();
     this.emitter.offAll();
   }
   recomputeAndEmitIfChanged() {
@@ -2338,6 +2684,7 @@ var OIMComputed = class {
     this.emitter.emit("update" /* UPDATE */, {
       keys: ["value"]
     });
+    this.updateEventEmitter.markUpdatedKey("value");
   }
 };
 
@@ -2346,31 +2693,21 @@ function isReadonlyArray(value) {
   return Array.isArray(value);
 }
 var OIMEffectDependencyKeyed = class {
-  constructor(updateEventEmitter, keyOrKeys) {
-    this.updateEventEmitter = updateEventEmitter;
+  constructor(subscription, keyOrKeys) {
+    this.subscription = subscription;
     if (isReadonlyArray(keyOrKeys)) {
       this.keys = keyOrKeys;
     } else {
       this.key = keyOrKeys;
     }
   }
-  subscribe(phase, onInvalidate) {
-    const isPre = phase === "pre" /* PRE */;
+  subscribe(onUpdate) {
     if (this.keys !== void 0) {
-      return isPre ? this.updateEventEmitter.subscribeOnKeysBeforeFlush(
-        this.keys,
-        onInvalidate
-      ) : this.updateEventEmitter.subscribeOnKeys(
-        this.keys,
-        onInvalidate
-      );
+      return this.subscription.subscribeOnKeys(this.keys, onUpdate);
     }
     if (this.key === void 0) return () => {
     };
-    return isPre ? this.updateEventEmitter.subscribeOnKeyBeforeFlush(
-      this.key,
-      onInvalidate
-    ) : this.updateEventEmitter.subscribeOnKey(this.key, onInvalidate);
+    return this.subscription.subscribeOnKey(this.key, onUpdate);
   }
 };
 
@@ -2378,12 +2715,12 @@ var OIMEffectDependencyKeyed = class {
 var OIMEffectDependencyKeyedObject = class {
   constructor(object, keyOrKeys) {
     this.dep = new OIMEffectDependencyKeyed(
-      object.updateEventEmitter,
+      object,
       keyOrKeys
     );
   }
-  subscribe(phase, onInvalidate) {
-    return this.dep.subscribe(phase, onInvalidate);
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
 };
 
@@ -2391,12 +2728,12 @@ var OIMEffectDependencyKeyedObject = class {
 var OIMEffectDependencyKeyedCollection = class {
   constructor(collection, pkOrPks) {
     this.dep = new OIMEffectDependencyKeyed(
-      collection.updateEventEmitter,
+      collection,
       pkOrPks
     );
   }
-  subscribe(phase, onInvalidate) {
-    return this.dep.subscribe(phase, onInvalidate);
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
 };
 
@@ -2404,44 +2741,609 @@ var OIMEffectDependencyKeyedCollection = class {
 var OIMEffectDependencyKeyedIndex = class {
   constructor(index, keyOrKeys) {
     this.dep = new OIMEffectDependencyKeyed(
-      index.updateEventEmitter,
+      index,
       keyOrKeys
     );
   }
-  subscribe(phase, onInvalidate) {
-    return this.dep.subscribe(phase, onInvalidate);
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
 };
 
-// src/modules/effect/core/OIMEffectDependencyComputed.ts
-var OIMEffectDependencyComputed = class {
-  constructor(computed) {
-    this.computed = computed;
+// 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.getSlotsByKey(this.key),
+        (slot) => slot.pk
+      );
+      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 = [];
+    };
   }
-  subscribe(phase, onInvalidate) {
-    if (phase === "pre" /* PRE */) {
-      return this.computed.emitter.on("update", onInvalidate);
+  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;
+    this.reactiveIndex.index.setSlotResolver(
+      (pk) => this.collection.getSlotByPk(pk)
+    );
+  }
+  getValue() {
+    const slots = this.reactiveIndex.getSlotsByKey(this.key);
+    const entities = [];
+    entities.length = slots.size;
+    let writeIndex = 0;
+    for (const slot of slots) {
+      entities[writeIndex++] = slot.item;
     }
-    return this.computed.updateEventEmitter.subscribeOnKey(
-      "value",
-      onInvalidate
+    return entities;
+  }
+  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.getSlotsByKey(this.key).map((slot) => slot.pk);
+      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;
+    this.reactiveIndex.index.setSlotResolver(
+      (pk) => this.collection.getSlotByPk(pk)
     );
   }
+  getValue() {
+    const slots = this.reactiveIndex.getSlotsByKey(this.key);
+    const entities = [];
+    entities.length = slots.length;
+    for (let i = 0; i < slots.length; i++) {
+      entities[i] = slots[i].item;
+    }
+    return entities;
+  }
+  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,
-  EOIMEffectPhase,
   EOIMEventQueueEventType,
   EOIMEventQueueSchedulerEventType,
   EOIMIndexEventType,
   EOIMObjectEventType,
-  EOIMUpdateEventCoalescerEventType,
   OIMCollection,
+  OIMCollectionByPkSelector,
+  OIMCollectionByPksSelector,
   OIMCollectionChangedFieldsWrapper,
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
+  OIMComputativeRuntime,
   OIMComputed,
   OIMDBSettings,
   OIMEffect,
@@ -2450,6 +3352,8 @@ export {
   OIMEffectDependencyKeyedCollection,
   OIMEffectDependencyKeyedIndex,
   OIMEffectDependencyKeyedObject,
+  OIMEntitiesByIndexKeyArrayBasedSelector,
+  OIMEntitiesByIndexKeySetBasedSelector,
   OIMEntityUpdaterFactory,
   OIMEventEmitter,
   OIMEventQueue,
@@ -2464,6 +3368,10 @@ export {
   OIMIndexManualArrayBased,
   OIMIndexManualOrderedArrayBased,
   OIMIndexManualSetBased,
+  OIMIndexPksByKeyArrayBasedSelector,
+  OIMIndexPksByKeySetBasedSelector,
+  OIMIndexPksByKeysArrayBasedSelector,
+  OIMIndexPksByKeysSetBasedSelector,
   OIMIndexSetBased,
   OIMIndexStoreArrayBased,
   OIMIndexStoreMapDrivenArrayBased,
@@ -2474,6 +3382,8 @@ export {
   OIMObjectStore,
   OIMObjectStoreMapDriven,
   OIMObjectStoreRecordDriven,
+  OIMObjectValueByKeySelector,
+  OIMObjectValuesByKeysSelector,
   OIMOrderedListIndexCommandStreamWrapper,
   OIMPkSelectorFactory,
   OIMRICollection,
@@ -2483,11 +3393,5 @@ export {
   OIMReactiveIndexManualSetBased,
   OIMReactiveIndexSetBased,
   OIMReactiveObject,
-  OIMUpdateEventCoalescer,
-  OIMUpdateEventCoalescerCollection,
-  OIMUpdateEventCoalescerComputed,
-  OIMUpdateEventCoalescerIndex,
-  OIMUpdateEventCoalescerManual,
-  OIMUpdateEventCoalescerObject,
-  OIMUpdateEventEmitter
+  OIMSelector
 };