@oimdb/core 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -524,265 +524,198 @@ var OIMIndexArrayBased = class extends OIMIndex {
   }
 };
 
-// src/enums/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(queue, deliveryMode = "queue") {
-    this.keyHandlers = /* @__PURE__ */ new Map();
+// src/core/OIMCarrierKeyedEmitter.ts
+var OIMCarrierKeyedEmitter = class {
+  constructor(queue, resolver) {
+    // Carriers with at least one subscriber — for markAllUpdated / metrics.
+    this.subscribedCarriers = /* @__PURE__ */ new Set();
+    // Pending flush batch. A plain array + a `carrier.dirty` flag for dedup —
+    // marking is the hottest write-path op, and pushing to an array with a
+    // boolean check is ~4x cheaper than a `Set` identity-hash add. The flag
+    // doubles as membership: a carrier is in this array iff `carrier.dirty`.
+    this.dirtyCarriers = [];
     this.isFlushEnqueued = false;
-    this.updatedKeys = /* @__PURE__ */ new Set();
-    this.isAfterFlushDeliveryScheduled = false;
-    // Stable handler reference to avoid allocating a new closure on every HAS_CHANGES.
     this.onFlush = () => {
       this.isFlushEnqueued = false;
       this.dequeueFlush = void 0;
-      if (this.keyHandlers.size === 0) {
-        this.updatedKeys.clear();
-        return;
+      if (this.dirtyCarriers.length === 0) return;
+      const flushing = this.dirtyCarriers;
+      this.dirtyCarriers = [];
+      let i = 0;
+      try {
+        for (; i < flushing.length; i++) {
+          flushing[i].dirty = false;
+          this.notify(flushing[i]);
+        }
+      } finally {
+        for (; i < flushing.length; i++) flushing[i].dirty = false;
       }
-      this.runSinglePass();
-    };
-    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
-      );
-    }
+    this.resolver = resolver;
   }
-  /**
-   * Mark keys as updated and schedule delivery.
-   *
-   * If there are no subscriptions, this is a no-op and does not allocate or retain keys.
-   */
-  markUpdatedKeys(keys) {
-    if (keys.length === 0) return;
-    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
-      throw new Error(
-        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
-      );
+  subscribeOnKey(key, handler) {
+    const carrier = this.resolver.getOrReserveCarrier(key);
+    this.addHandler(carrier, handler);
+    return () => this.removeHandler(carrier, handler);
+  }
+  subscribeOnKeys(keys, handler) {
+    const carriers = [];
+    for (let i = 0; i < keys.length; i++) {
+      const carrier = this.resolver.getOrReserveCarrier(keys[i]);
+      this.addHandler(carrier, handler);
+      carriers.push(carrier);
     }
-    if (this.keyHandlers.size === 0) return;
-    let didAddAny = false;
+    return () => {
+      for (let i = 0; i < carriers.length; i++) {
+        this.removeHandler(carriers[i], handler);
+      }
+    };
+  }
+  unsubscribeFromKey(key, handler) {
+    const carrier = this.resolver.findCarrier(key);
+    if (carrier) this.removeHandler(carrier, handler);
+  }
+  unsubscribeFromKeys(keys, handler) {
     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;
+      this.unsubscribeFromKey(keys[i], handler);
     }
-    if (!didAddAny) return;
-    if (this.deliveryMode === "immediate") {
-      this.deliverImmediate();
-      return;
+  }
+  addHandler(carrier, handler) {
+    let subscribers = carrier.subscribers;
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      carrier.subscribers = subscribers;
     }
-    if (this.deliveryMode === "after_flush") {
-      this.isAfterFlushDeliveryScheduled = true;
-      return;
+    subscribers.add(handler);
+    this.subscribedCarriers.add(carrier);
+  }
+  removeHandler(carrier, handler) {
+    const subscribers = carrier.subscribers;
+    if (!subscribers) return;
+    subscribers.delete(handler);
+    if (subscribers.size === 0) {
+      this.subscribedCarriers.delete(carrier);
+      this.resolver.onCarrierEmptied?.(carrier);
     }
-    if (this.isFlushEnqueued) return;
-    this.isFlushEnqueued = true;
-    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  /** Fast path: the writer already holds the carrier. */
+  markUpdatedCarrier(carrier) {
+    this.assertNotInFlush();
+    const subscribers = carrier.subscribers;
+    if (!subscribers || subscribers.size === 0) return;
+    if (carrier.dirty) return;
+    carrier.dirty = true;
+    this.dirtyCarriers.push(carrier);
+    this.scheduleFlush();
   }
   markUpdatedKey(key) {
-    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
-      throw new Error(
-        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
-      );
-    }
-    if (this.keyHandlers.size === 0) return;
-    const handlers = this.keyHandlers.get(key);
-    if (!handlers || handlers.size === 0) return;
-    this.updatedKeys.add(key);
-    if (this.deliveryMode === "immediate") {
-      this.deliverImmediate();
-      return;
-    }
-    if (this.deliveryMode === "after_flush") {
-      this.isAfterFlushDeliveryScheduled = true;
-      return;
-    }
-    if (this.isFlushEnqueued) return;
-    this.isFlushEnqueued = true;
-    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+    const carrier = this.resolver.findCarrier(key);
+    if (carrier) this.markUpdatedCarrier(carrier);
+    else this.assertNotInFlush();
+  }
+  markUpdatedKeys(keys) {
+    for (let i = 0; i < keys.length; i++) this.markUpdatedKey(keys[i]);
   }
   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()."
-      );
+    this.assertNotInFlush();
+    if (this.subscribedCarriers.size === 0) return;
+    this.subscribedCarriers.forEach((carrier) => {
+      if (carrier.dirty) return;
+      carrier.dirty = true;
+      this.dirtyCarriers.push(carrier);
+    });
+    this.scheduleFlush();
+  }
+  hasSubscriptions() {
+    return this.subscribedCarriers.size > 0;
+  }
+  getHandlerCount(key) {
+    return this.resolver.findCarrier(key)?.subscribers?.size ?? 0;
+  }
+  getMetrics() {
+    let totalHandlers = 0;
+    this.subscribedCarriers.forEach((carrier) => {
+      totalHandlers += carrier.subscribers?.size ?? 0;
+    });
+    const totalKeys = this.subscribedCarriers.size;
+    return {
+      totalKeys,
+      totalHandlers,
+      averageHandlersPerKey: totalKeys > 0 ? totalHandlers / totalKeys : 0,
+      queueLength: this.dirtyCarriers.length
+    };
+  }
+  destroy() {
+    if (this.dequeueFlush) {
+      this.dequeueFlush();
+      this.dequeueFlush = void 0;
     }
-    if (this.keyHandlers.size === 0) return;
-    this.keyHandlers.forEach((_handlers, key) => {
-      this.updatedKeys.add(key);
+    this.subscribedCarriers.forEach((carrier) => {
+      carrier.subscribers?.clear();
+      carrier.subscribers = void 0;
     });
-    if (this.deliveryMode === "immediate") {
-      this.deliverImmediate();
-      return;
+    this.subscribedCarriers.clear();
+    for (let i = 0; i < this.dirtyCarriers.length; i++) {
+      this.dirtyCarriers[i].dirty = false;
     }
-    if (this.deliveryMode === "after_flush") {
-      this.isAfterFlushDeliveryScheduled = true;
-      return;
+    this.dirtyCarriers = [];
+    this.isFlushEnqueued = false;
+  }
+  assertNotInFlush() {
+    if (this.queue.isInFlush) {
+      throw new Error(
+        "OIMCarrierKeyedEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
     }
+  }
+  scheduleFlush() {
     if (this.isFlushEnqueued) return;
     this.isFlushEnqueued = true;
     this.dequeueFlush = this.queue.enqueue(this.onFlush);
   }
-  deliverImmediate() {
-    this.runSinglePass();
-  }
-  /**
-   * Notifies all handlers for a key. The overwhelmingly common case is a
-   * single subscriber per key (one component per pk), handled without any
-   * allocation. For multiple subscribers a snapshot is taken so a handler may
-   * (un)subscribe during iteration without corrupting the walk.
-   */
-  notifyHandlers(handlers) {
-    if (handlers.size === 1) {
-      const only = handlers.values().next().value;
+  notify(carrier) {
+    const subscribers = carrier.subscribers;
+    if (!subscribers || subscribers.size === 0) return;
+    if (subscribers.size === 1) {
+      const only = subscribers.values().next().value;
       if (only) only();
       return;
     }
     const snapshot = [];
-    handlers.forEach((h) => snapshot.push(h));
+    subscribers.forEach((h) => snapshot.push(h));
     for (let i = 0; i < snapshot.length; i++) {
       const handler = snapshot[i];
-      if (handlers.has(handler)) handler();
-    }
-  }
-  /**
-   * Deliver updated keys and notify handlers once.
-   * Re-entrant updates during delivery are forbidden and will throw in markUpdatedKeys().
-   */
-  runSinglePass() {
-    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;
-        this.notifyHandlers(handlers);
-      });
-    } else {
-      this.keyHandlers.forEach((handlers, key) => {
-        if (!flushingKeys.has(key)) return;
-        if (!handlers || handlers.size === 0) return;
-        this.notifyHandlers(handlers);
-      });
-    }
-  }
-  destroy() {
-    if (this.dequeueFlush) {
-      this.dequeueFlush();
-      this.dequeueFlush = void 0;
-    }
-    if (this.unsubscribeAfterFlushDelivery) {
-      this.unsubscribeAfterFlushDelivery();
-      this.unsubscribeAfterFlushDelivery = void 0;
+      if (subscribers.has(handler)) handler();
     }
-    this.keyHandlers.forEach((handlers) => handlers.clear());
-    this.keyHandlers.clear();
-    this.updatedKeys.clear();
-  }
-  /**
-   * Get performance metrics for monitoring and debugging
-   */
-  getMetrics() {
-    let totalHandlers = 0;
-    this.keyHandlers.forEach((handlers) => {
-      totalHandlers += handlers.size;
-    });
-    return {
-      totalKeys: this.keyHandlers.size,
-      totalHandlers,
-      averageHandlersPerKey: this.keyHandlers.size > 0 ? totalHandlers / this.keyHandlers.size : 0,
-      queueLength: this.queue.length
-    };
-  }
-  /**
-   * Check if there are any active subscriptions
-   */
-  hasSubscriptions() {
-    return this.keyHandlers.size > 0;
   }
-  /**
-   * Get the number of handlers for a specific key
-   */
-  getHandlerCount(key) {
-    return this.keyHandlers.get(key)?.size ?? 0;
-  }
-  subscribeOnKey(key, handler) {
-    let handlers = this.keyHandlers.get(key);
-    if (!handlers) {
-      handlers = /* @__PURE__ */ new Set();
-      this.keyHandlers.set(key, handlers);
-    }
-    handlers.add(handler);
-    return () => {
-      this.unsubscribeFromKey(key, handler);
-    };
+};
+
+// src/core/OIMKeyedCarrierResolver.ts
+var OIMKeyedCarrierResolver = class {
+  constructor() {
+    this.carriers = /* @__PURE__ */ new Map();
   }
-  unsubscribeFromKey(key, handler) {
-    const handlers = this.keyHandlers.get(key);
-    if (!handlers) return;
-    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;
+  getOrReserveCarrier(key) {
+    let carrier = this.carriers.get(key);
+    if (!carrier) {
+      carrier = { key };
+      this.carriers.set(key, carrier);
     }
+    return carrier;
   }
-  subscribeOnKeys(keys, handler) {
-    const subscribedKeys = [];
-    for (const key of keys) {
-      let handlers = this.keyHandlers.get(key);
-      if (!handlers) {
-        handlers = /* @__PURE__ */ new Set();
-        this.keyHandlers.set(key, handlers);
-      }
-      if (!handlers.has(handler)) {
-        handlers.add(handler);
-        subscribedKeys.push(key);
-      }
-    }
-    return () => {
-      for (const key of subscribedKeys) {
-        this.unsubscribeFromKey(key, handler);
-      }
-    };
+  findCarrier(key) {
+    return this.carriers.get(key);
   }
-  unsubscribeFromKeys(keys, handler) {
-    for (const key of keys) {
-      this.unsubscribeFromKey(key, handler);
-    }
+  onCarrierEmptied(carrier) {
+    this.carriers.delete(carrier.key);
   }
 };
 
 // src/abstract/OIMReactiveIndex.ts
 var OIMReactiveIndex = class {
   constructor(queue, createIndex) {
-    this.updateEmitter = new OIMUpdateEventEmitter(queue);
+    this.updateEmitter = new OIMCarrierKeyedEmitter(queue, new OIMKeyedCarrierResolver());
     this.index = createIndex(this.updateEmitter);
   }
   getEntitiesByKey(key) {
@@ -1150,154 +1083,7 @@ var OIMCollection = class {
   }
   destroy() {
     this.store.destroy();
-    this.emitter.offAll();
-  }
-};
-
-// src/core/OIMCarrierKeyedEmitter.ts
-var OIMCarrierKeyedEmitter = class {
-  constructor(queue, resolver) {
-    // Carriers with at least one subscriber — for markAllUpdated / metrics.
-    this.subscribedCarriers = /* @__PURE__ */ new Set();
-    this.dirtyCarriers = /* @__PURE__ */ new Set();
-    this.isFlushEnqueued = false;
-    this.onFlush = () => {
-      this.isFlushEnqueued = false;
-      this.dequeueFlush = void 0;
-      if (this.dirtyCarriers.size === 0) return;
-      const flushing = this.dirtyCarriers;
-      this.dirtyCarriers = /* @__PURE__ */ new Set();
-      flushing.forEach((carrier) => this.notify(carrier));
-    };
-    this.queue = queue;
-    this.resolver = resolver;
-  }
-  subscribeOnKey(key, handler) {
-    const carrier = this.resolver.getOrReserveCarrier(key);
-    this.addHandler(carrier, handler);
-    return () => this.removeHandler(carrier, handler);
-  }
-  subscribeOnKeys(keys, handler) {
-    const carriers = [];
-    for (let i = 0; i < keys.length; i++) {
-      const carrier = this.resolver.getOrReserveCarrier(keys[i]);
-      this.addHandler(carrier, handler);
-      carriers.push(carrier);
-    }
-    return () => {
-      for (let i = 0; i < carriers.length; i++) {
-        this.removeHandler(carriers[i], handler);
-      }
-    };
-  }
-  unsubscribeFromKey(key, handler) {
-    const carrier = this.resolver.findCarrier(key);
-    if (carrier) this.removeHandler(carrier, handler);
-  }
-  unsubscribeFromKeys(keys, handler) {
-    for (let i = 0; i < keys.length; i++) {
-      this.unsubscribeFromKey(keys[i], handler);
-    }
-  }
-  addHandler(carrier, handler) {
-    let subscribers = carrier.subscribers;
-    if (!subscribers) {
-      subscribers = /* @__PURE__ */ new Set();
-      carrier.subscribers = subscribers;
-    }
-    subscribers.add(handler);
-    this.subscribedCarriers.add(carrier);
-  }
-  removeHandler(carrier, handler) {
-    const subscribers = carrier.subscribers;
-    if (!subscribers) return;
-    subscribers.delete(handler);
-    if (subscribers.size === 0) {
-      this.subscribedCarriers.delete(carrier);
-    }
-  }
-  /** Fast path: the writer already holds the carrier. */
-  markUpdatedCarrier(carrier) {
-    this.assertNotInFlush();
-    const subscribers = carrier.subscribers;
-    if (!subscribers || subscribers.size === 0) return;
-    this.dirtyCarriers.add(carrier);
-    this.scheduleFlush();
-  }
-  markUpdatedKey(key) {
-    const carrier = this.resolver.findCarrier(key);
-    if (carrier) this.markUpdatedCarrier(carrier);
-    else this.assertNotInFlush();
-  }
-  markUpdatedKeys(keys) {
-    for (let i = 0; i < keys.length; i++) this.markUpdatedKey(keys[i]);
-  }
-  markAllUpdated() {
-    this.assertNotInFlush();
-    if (this.subscribedCarriers.size === 0) return;
-    this.subscribedCarriers.forEach(
-      (carrier) => this.dirtyCarriers.add(carrier)
-    );
-    this.scheduleFlush();
-  }
-  hasSubscriptions() {
-    return this.subscribedCarriers.size > 0;
-  }
-  getHandlerCount(key) {
-    return this.resolver.findCarrier(key)?.subscribers?.size ?? 0;
-  }
-  getMetrics() {
-    let totalHandlers = 0;
-    this.subscribedCarriers.forEach((carrier) => {
-      totalHandlers += carrier.subscribers?.size ?? 0;
-    });
-    const totalKeys = this.subscribedCarriers.size;
-    return {
-      totalKeys,
-      totalHandlers,
-      averageHandlersPerKey: totalKeys > 0 ? totalHandlers / totalKeys : 0,
-      queueLength: this.dirtyCarriers.size
-    };
-  }
-  destroy() {
-    if (this.dequeueFlush) {
-      this.dequeueFlush();
-      this.dequeueFlush = void 0;
-    }
-    this.subscribedCarriers.forEach((carrier) => {
-      carrier.subscribers?.clear();
-      carrier.subscribers = void 0;
-    });
-    this.subscribedCarriers.clear();
-    this.dirtyCarriers.clear();
-    this.isFlushEnqueued = false;
-  }
-  assertNotInFlush() {
-    if (this.queue.isInFlush) {
-      throw new Error(
-        "OIMCarrierKeyedEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
-      );
-    }
-  }
-  scheduleFlush() {
-    if (this.isFlushEnqueued) return;
-    this.isFlushEnqueued = true;
-    this.dequeueFlush = this.queue.enqueue(this.onFlush);
-  }
-  notify(carrier) {
-    const subscribers = carrier.subscribers;
-    if (!subscribers || subscribers.size === 0) return;
-    if (subscribers.size === 1) {
-      const only = subscribers.values().next().value;
-      if (only) only();
-      return;
-    }
-    const snapshot = [];
-    subscribers.forEach((h) => snapshot.push(h));
-    for (let i = 0; i < snapshot.length; i++) {
-      const handler = snapshot[i];
-      if (subscribers.has(handler)) handler();
-    }
+    this.emitter.offAll();
   }
 };
 
@@ -1583,6 +1369,261 @@ var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrde
   }
 };
 
+// src/enums/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(queue, deliveryMode = "queue") {
+    this.keyHandlers = /* @__PURE__ */ new Map();
+    this.isFlushEnqueued = false;
+    this.updatedKeys = /* @__PURE__ */ new Set();
+    this.isAfterFlushDeliveryScheduled = false;
+    // Stable handler reference to avoid allocating a new closure on every HAS_CHANGES.
+    this.onFlush = () => {
+      this.isFlushEnqueued = false;
+      this.dequeueFlush = void 0;
+      if (this.keyHandlers.size === 0) {
+        this.updatedKeys.clear();
+        return;
+      }
+      this.runSinglePass();
+    };
+    this.onAfterFlush = () => {
+      if (!this.isAfterFlushDeliveryScheduled) return;
+      this.isAfterFlushDeliveryScheduled = false;
+      this.deliverImmediate();
+    };
+    this.queue = queue;
+    this.deliveryMode = deliveryMode;
+    if (this.deliveryMode === "after_flush") {
+      this.unsubscribeAfterFlushDelivery = this.queue.emitter.on(
+        0 /* AFTER_FLUSH */,
+        this.onAfterFlush
+      );
+    }
+  }
+  /**
+   * Mark keys as updated and schedule delivery.
+   *
+   * If there are no subscriptions, this is a no-op and does not allocate or retain keys.
+   */
+  markUpdatedKeys(keys) {
+    if (keys.length === 0) return;
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    let didAddAny = false;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const handlers = this.keyHandlers.get(key);
+      if (!handlers || handlers.size === 0) continue;
+      this.updatedKeys.add(key);
+      didAddAny = true;
+    }
+    if (!didAddAny) return;
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  markUpdatedKey(key) {
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    const handlers = this.keyHandlers.get(key);
+    if (!handlers || handlers.size === 0) return;
+    this.updatedKeys.add(key);
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  markAllUpdated() {
+    if (this.deliveryMode === "queue" && this.queue.isInFlush) {
+      throw new Error(
+        "OIMUpdateEventEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+    if (this.keyHandlers.size === 0) return;
+    this.keyHandlers.forEach((_handlers, key) => {
+      this.updatedKeys.add(key);
+    });
+    if (this.deliveryMode === "immediate") {
+      this.deliverImmediate();
+      return;
+    }
+    if (this.deliveryMode === "after_flush") {
+      this.isAfterFlushDeliveryScheduled = true;
+      return;
+    }
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.dequeueFlush = this.queue.enqueue(this.onFlush);
+  }
+  deliverImmediate() {
+    this.runSinglePass();
+  }
+  /**
+   * Notifies all handlers for a key. The overwhelmingly common case is a
+   * single subscriber per key (one component per pk), handled without any
+   * allocation. For multiple subscribers a snapshot is taken so a handler may
+   * (un)subscribe during iteration without corrupting the walk.
+   */
+  notifyHandlers(handlers) {
+    if (handlers.size === 1) {
+      const only = handlers.values().next().value;
+      if (only) only();
+      return;
+    }
+    const snapshot = [];
+    handlers.forEach((h) => snapshot.push(h));
+    for (let i = 0; i < snapshot.length; i++) {
+      const handler = snapshot[i];
+      if (handlers.has(handler)) handler();
+    }
+  }
+  /**
+   * Deliver updated keys and notify handlers once.
+   * Re-entrant updates during delivery are forbidden and will throw in markUpdatedKeys().
+   */
+  runSinglePass() {
+    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;
+        this.notifyHandlers(handlers);
+      });
+    } else {
+      this.keyHandlers.forEach((handlers, key) => {
+        if (!flushingKeys.has(key)) return;
+        if (!handlers || handlers.size === 0) return;
+        this.notifyHandlers(handlers);
+      });
+    }
+  }
+  destroy() {
+    if (this.dequeueFlush) {
+      this.dequeueFlush();
+      this.dequeueFlush = void 0;
+    }
+    if (this.unsubscribeAfterFlushDelivery) {
+      this.unsubscribeAfterFlushDelivery();
+      this.unsubscribeAfterFlushDelivery = void 0;
+    }
+    this.keyHandlers.forEach((handlers) => handlers.clear());
+    this.keyHandlers.clear();
+    this.updatedKeys.clear();
+  }
+  /**
+   * Get performance metrics for monitoring and debugging
+   */
+  getMetrics() {
+    let totalHandlers = 0;
+    this.keyHandlers.forEach((handlers) => {
+      totalHandlers += handlers.size;
+    });
+    return {
+      totalKeys: this.keyHandlers.size,
+      totalHandlers,
+      averageHandlersPerKey: this.keyHandlers.size > 0 ? totalHandlers / this.keyHandlers.size : 0,
+      queueLength: this.queue.length
+    };
+  }
+  /**
+   * Check if there are any active subscriptions
+   */
+  hasSubscriptions() {
+    return this.keyHandlers.size > 0;
+  }
+  /**
+   * Get the number of handlers for a specific key
+   */
+  getHandlerCount(key) {
+    return this.keyHandlers.get(key)?.size ?? 0;
+  }
+  subscribeOnKey(key, handler) {
+    let handlers = this.keyHandlers.get(key);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.keyHandlers.set(key, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      this.unsubscribeFromKey(key, handler);
+    };
+  }
+  unsubscribeFromKey(key, handler) {
+    const handlers = this.keyHandlers.get(key);
+    if (!handlers) return;
+    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) {
+    const subscribedKeys = [];
+    for (const key of keys) {
+      let handlers = this.keyHandlers.get(key);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this.keyHandlers.set(key, handlers);
+      }
+      if (!handlers.has(handler)) {
+        handlers.add(handler);
+        subscribedKeys.push(key);
+      }
+    }
+    return () => {
+      for (const key of subscribedKeys) {
+        this.unsubscribeFromKey(key, handler);
+      }
+    };
+  }
+  unsubscribeFromKeys(keys, handler) {
+    for (const key of keys) {
+      this.unsubscribeFromKey(key, handler);
+    }
+  }
+};
+
 // src/modules/wrapper/index/OIMOrderedListCommandStream.ts
 var OIMOrderedListCommandStream = class {
   constructor(queue, index) {