@oimdb/core 3.4.0 → 3.6.0

package/dist/index.js

@@ -708,6 +708,254 @@ var OIMReactiveIndexArrayBased = class extends OIMReactiveIndex {
 var OIMObjectStore = class {
 };
 
+// src/abstract/OIMGlobalIndex.ts
+var OIMGlobalIndex = class {
+  constructor(comparePks) {
+    this.emitter = new OIMEventEmitter();
+    this.comparePks = comparePks;
+  }
+  get isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * Materializes the bucket to entities, preserving positional holes: a slot
+   * whose entity is not present yet (or was removed) yields `undefined` at its
+   * position rather than being dropped — mirroring {@link OIMIndex}.
+   */
+  getEntities() {
+    const entities = [];
+    for (const slot of this.iterateSlots()) {
+      entities.push(slot.item);
+    }
+    return entities;
+  }
+  getMetrics() {
+    return { totalPks: this.size };
+  }
+  destroy() {
+    this.emitter.offAll();
+    this.clearBucket();
+  }
+  emitUpdate() {
+    this.emitter.emit(0 /* UPDATE */, void 0);
+  }
+};
+
+// src/abstract/OIMGlobalIndexSetBased.ts
+var OIMGlobalIndexSetBased = class extends OIMGlobalIndex {
+  constructor(options = {}) {
+    super(options.comparePks);
+    this.slots = /* @__PURE__ */ new Set();
+  }
+  get size() {
+    return this.slots.size;
+  }
+  iterateSlots() {
+    return this.slots;
+  }
+  clearBucket() {
+    this.slots.clear();
+  }
+  getPks() {
+    return this.slotsToPks(this.slots);
+  }
+  getSlots() {
+    return this.slots;
+  }
+  slotsToPks(slots) {
+    const pks = /* @__PURE__ */ new Set();
+    for (const slot of slots) pks.add(slot.pk);
+    return pks;
+  }
+  setSlotsWithComparison(newSlots) {
+    if (this.comparePks && this.slots.size === newSlots.size) {
+      if (this.comparePks(
+        Array.from(this.slotsToPks(this.slots)),
+        Array.from(this.slotsToPks(newSlots))
+      )) {
+        return false;
+      }
+    }
+    this.slots = newSlots;
+    return true;
+  }
+};
+
+// src/abstract/OIMGlobalIndexArrayBased.ts
+var OIMGlobalIndexArrayBased = class extends OIMGlobalIndex {
+  constructor(options = {}) {
+    super(options.comparePks);
+    this.slots = [];
+  }
+  get size() {
+    return this.slots.length;
+  }
+  iterateSlots() {
+    return this.slots;
+  }
+  clearBucket() {
+    this.slots = [];
+  }
+  getPks() {
+    return this.slotsToPks(this.slots);
+  }
+  getSlots() {
+    return this.slots;
+  }
+  slotsToPks(slots) {
+    const pks = [];
+    pks.length = slots.length;
+    for (let i = 0; i < slots.length; i++) pks[i] = slots[i].pk;
+    return pks;
+  }
+  setSlotsWithComparison(newSlots) {
+    if (this.comparePks && this.slots.length === newSlots.length) {
+      if (this.comparePks(
+        this.slotsToPks(this.slots),
+        this.slotsToPks(newSlots)
+      )) {
+        return false;
+      }
+    }
+    this.slots = newSlots;
+    return true;
+  }
+};
+
+// src/core/OIMCarrierSingleEmitter.ts
+var OIMCarrierSingleEmitter = class {
+  constructor(queue) {
+    this.dirty = false;
+    this.isFlushEnqueued = false;
+    this.onFlush = () => {
+      this.isFlushEnqueued = false;
+      if (!this.dirty) return;
+      this.dirty = false;
+      this.notify();
+    };
+    this.queue = queue;
+  }
+  subscribe(handler) {
+    let subscribers = this.subscribers;
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      this.subscribers = subscribers;
+    }
+    subscribers.add(handler);
+    return () => {
+      this.subscribers?.delete(handler);
+    };
+  }
+  markUpdated() {
+    this.assertNotInFlush();
+    if (!this.subscribers || this.subscribers.size === 0) return;
+    if (this.dirty) return;
+    this.dirty = true;
+    this.scheduleFlush();
+  }
+  hasSubscriptions() {
+    return !!this.subscribers && this.subscribers.size > 0;
+  }
+  getMetrics() {
+    return {
+      totalHandlers: this.subscribers?.size ?? 0,
+      queueLength: this.dirty ? 1 : 0
+    };
+  }
+  destroy() {
+    if (this.isFlushEnqueued) {
+      this.queue.cancel(this.onFlush);
+      this.isFlushEnqueued = false;
+    }
+    this.subscribers?.clear();
+    this.subscribers = void 0;
+    this.dirty = false;
+  }
+  assertNotInFlush() {
+    if (this.queue.isInFlush) {
+      throw new Error(
+        "OIMCarrierSingleEmitter: updates during queue.flush() are not allowed. Finish all writes before calling queue.flush()."
+      );
+    }
+  }
+  scheduleFlush() {
+    if (this.isFlushEnqueued) return;
+    this.isFlushEnqueued = true;
+    this.queue.enqueue(this.onFlush);
+  }
+  notify() {
+    const subscribers = this.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();
+    }
+  }
+};
+
+// src/abstract/OIMReactiveGlobalIndex.ts
+var OIMReactiveGlobalIndex = class {
+  constructor(queue, createIndex) {
+    this.updateEmitter = new OIMCarrierSingleEmitter(queue);
+    this.index = createIndex(this.updateEmitter);
+  }
+  getEntities() {
+    return this.index.getEntities();
+  }
+  get size() {
+    return this.index.size;
+  }
+  get isEmpty() {
+    return this.index.isEmpty;
+  }
+  subscribe(handler) {
+    return this.updateEmitter.subscribe(handler);
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getMetrics() {
+    return this.index.getMetrics();
+  }
+  destroy() {
+    this.updateEmitter.destroy();
+    this.index.destroy();
+  }
+};
+
+// src/abstract/OIMReactiveGlobalIndexSetBased.ts
+var OIMReactiveGlobalIndexSetBased = class extends OIMReactiveGlobalIndex {
+  constructor(queue, createIndex) {
+    super(queue, createIndex);
+  }
+  getPks() {
+    return this.index.getPks();
+  }
+  getSlots() {
+    return this.index.getSlots();
+  }
+};
+
+// src/abstract/OIMReactiveGlobalIndexArrayBased.ts
+var OIMReactiveGlobalIndexArrayBased = class extends OIMReactiveGlobalIndex {
+  constructor(queue, createIndex) {
+    super(queue, createIndex);
+  }
+  getPks() {
+    return this.index.getPks();
+  }
+  getSlots() {
+    return this.index.getSlots();
+  }
+};
+
 // src/core/OIMPkSelectorFactory.ts
 var OIMPkSelectorFactory = class {
   createIdSelector() {
@@ -1151,7 +1399,7 @@ var OIMReactiveCollection = class extends OIMCollection {
   }
 };
 
-// src/modules/wrapper/index/OIMIndexManualOrderedArrayBased.ts
+// src/core/OIMIndexManualOrderedArrayBased.ts
 var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
   clear(key) {
     if (key === void 0) {
@@ -1267,7 +1515,7 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
   }
 };
 
-// src/modules/wrapper/index/OIMCollectionIndexManualOrderedArrayBased.ts
+// src/core/OIMCollectionIndexManualOrderedArrayBased.ts
 var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrderedArrayBased {
   constructor(opts) {
     super();
@@ -1563,35 +1811,67 @@ var OIMUpdateEventEmitter = class {
   }
 };
 
-// src/modules/wrapper/index/OIMOrderedListCommandStream.ts
-var OIMOrderedListCommandStream = class {
-  constructor(queue, index) {
-    this.isInWrite = false;
+// src/abstract/OIMOrderedListCommandBuffer.ts
+var OIMOrderedListCommandBuffer = class {
+  constructor(queue) {
     this.commandsByKey = /* @__PURE__ */ new Map();
     this.onAfterFlush = () => {
       this.commandsByKey.clear();
     };
-    this.onIndexUpdate = (payload) => {
-      if (this.isInWrite) return;
-      if (payload.keys.length === 0) return;
-      for (let i = 0; i < payload.keys.length; i++) {
-        const key = payload.keys[i];
-        this.appendResetCommand(key, this.getSlotsByKey(key));
-      }
-    };
     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
-    );
+  }
+  subscribeCommands(key, handler) {
+    return this.commandsEventEmitter.subscribeOnKey(key, handler);
+  }
+  getBufferedCommands(key) {
+    return this.commandsByKey.get(key) ?? [];
+  }
+  consumeCommands(key) {
+    const cmds = this.commandsByKey.get(key);
+    if (!cmds || cmds.length === 0) return [];
+    return cmds.slice();
+  }
+  destroy() {
+    this.commandsEventEmitter.destroy();
+    this.unsubscribeAfterFlush();
+    this.commandsByKey.clear();
+  }
+  appendCommand(key, cmd) {
+    let cmds = this.commandsByKey.get(key);
+    if (!cmds) {
+      cmds = [];
+      this.commandsByKey.set(key, cmds);
+    }
+    if (cmd.type === "reset") {
+      cmds.length = 0;
+      cmds.push(cmd);
+    } else if (cmds.length > 0 && cmds[0].type === "reset") {
+      cmds[0] = this.createResetCommand(this.getItemsByKey(key));
+    } else {
+      cmds.push(cmd);
+    }
+    this.commandsEventEmitter.markUpdatedKeys([key]);
+  }
+  appendResetCommand(key, items) {
+    this.appendCommand(key, this.createResetCommand(items));
+  }
+  createResetCommand(items) {
+    return { type: "reset", items };
+  }
+};
+
+// src/modules/wrapper/index/OIMOrderedListCommandStream.ts
+var OIMOrderedListCommandStream = class extends OIMOrderedListCommandBuffer {
+  constructor(queue, index) {
+    super(queue);
+    this.index = index ?? new OIMIndexManualOrderedArrayBased();
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -1601,6 +1881,10 @@ var OIMOrderedListCommandStream = class {
       key
     );
   }
+  /** {@link OIMOrderedListCommandBuffer.getItemsByKey} — the slots in order. */
+  getItemsByKey(key) {
+    return this.getSlotsByKey(key);
+  }
   getEntitiesByKey(key) {
     return this.index.getEntitiesByKey(key);
   }
@@ -1611,57 +1895,46 @@ var OIMOrderedListCommandStream = class {
     return this.index.getKeys();
   }
   pushSlot(key, slot) {
-    this.withWrite(() => {
-      const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, { type: "insert", index, item: slot });
-    });
+    const index = this.index.pushSlot(key, slot);
+    this.appendCommand(key, { type: "insert", index, item: slot });
   }
   insertSlotAt(key, index, slot) {
-    this.withWrite(() => {
-      const safeIndex = this.index.insertSlotAt(key, index, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        index: safeIndex,
-        item: slot
-      });
+    const safeIndex = this.index.insertSlotAt(key, index, slot);
+    this.appendCommand(key, {
+      type: "insert",
+      index: safeIndex,
+      item: slot
     });
   }
   /** Replace the slot at `index` in place. */
   setSlotAt(key, index, slot) {
-    this.withWrite(() => {
-      const safeIndex = this.index.setSlotAt(key, index, slot);
-      if (safeIndex < 0) return;
-      this.appendCommand(key, {
-        type: "set",
-        index: safeIndex,
-        item: slot
-      });
+    const safeIndex = this.index.setSlotAt(key, index, slot);
+    if (safeIndex < 0) return;
+    this.appendCommand(key, {
+      type: "set",
+      index: safeIndex,
+      item: slot
     });
   }
   removeAt(key, index) {
-    this.withWrite(() => {
-      const slot = this.index.removeAt(key, index);
-      if (slot === void 0) return;
-      this.appendCommand(key, { type: "remove", index });
-    });
+    const slot = this.index.removeAt(key, index);
+    if (slot === void 0) return;
+    this.appendCommand(key, { type: "remove", index });
   }
   /** Remove `count` consecutive elements from `index`; emits `remove` with `count`. */
   removeRange(key, index, count) {
-    this.withWrite(() => {
-      const removed = this.index.removeRange(key, index, count);
-      if (removed <= 0) return;
-      this.appendCommand(key, { type: "remove", index, count: removed });
-    });
+    const removed = this.index.removeRange(key, index, count);
+    if (removed <= 0) return;
+    this.appendCommand(key, { type: "remove", index, count: removed });
   }
   move(key, fromIndex, toIndex) {
-    this.withWrite(() => {
-      const slot = this.index.move(key, fromIndex, toIndex);
-      if (slot === void 0) return;
-      this.appendCommand(key, {
-        type: "move",
-        from: fromIndex,
-        to: toIndex
-      });
+    if (fromIndex === toIndex) return;
+    const slot = this.index.move(key, fromIndex, toIndex);
+    if (slot === void 0) return;
+    this.appendCommand(key, {
+      type: "move",
+      from: fromIndex,
+      to: toIndex
     });
   }
   /**
@@ -1669,74 +1942,31 @@ var OIMOrderedListCommandStream = class {
    * `count`. `to` is in the post-extraction coordinate space (as single `move`).
    */
   moveRange(key, from, to, count) {
-    this.withWrite(() => {
-      const moved = this.index.moveRange(key, from, to, count);
-      if (moved <= 0) return;
-      this.appendCommand(key, { type: "move", from, to, count: moved });
-    });
+    const moved = this.index.moveRange(key, from, to, count);
+    if (moved <= 0) return;
+    this.appendCommand(key, { type: "move", from, to, count: moved });
   }
   setSlots(key, slots) {
-    this.withWrite(() => {
-      this.index.resetSlots(key, slots);
-      this.appendResetCommand(key, slots);
-    });
-  }
-  getBufferedCommands(key) {
-    return this.commandsByKey.get(key) ?? [];
-  }
-  consumeCommands(key) {
-    const cmds = this.commandsByKey.get(key);
-    if (!cmds || cmds.length === 0) return [];
-    return cmds.slice();
+    this.index.resetSlots(key, slots);
+    this.appendResetCommand(key, slots);
   }
   clear(key) {
     if (key === void 0) {
-      this.index.destroy();
-      this.commandsByKey.clear();
+      const keys = this.getKeys().slice();
+      if (keys.length === 0) return;
+      this.index.clear();
+      for (let i = 0; i < keys.length; i++) {
+        this.appendResetCommand(keys[i], []);
+      }
       return;
     }
+    if (!this.index.hasKey(key)) return;
     this.index.clear(key);
-    this.commandsByKey.delete(key);
+    this.appendResetCommand(key, []);
   }
   destroy() {
-    this.commandsEventEmitter.destroy();
-    this.unsubscribeAfterFlush();
-    this.unsubscribeFromIndexEmitter();
-    this.clear();
-  }
-  withWrite(fn) {
-    if (this.isInWrite) {
-      fn();
-      return;
-    }
-    this.isInWrite = true;
-    try {
-      fn();
-    } finally {
-      this.isInWrite = false;
-    }
-  }
-  appendCommand(key, cmd) {
-    let cmds = this.commandsByKey.get(key);
-    if (!cmds) {
-      cmds = [];
-      this.commandsByKey.set(key, cmds);
-    }
-    if (cmd.type === "reset") {
-      cmds.length = 0;
-      cmds.push(cmd);
-    } else if (cmds.length > 0 && cmds[0].type === "reset") {
-      cmds[0] = this.createResetCommand(this.getSlotsByKey(key));
-    } else {
-      cmds.push(cmd);
-    }
-    this.commandsEventEmitter.markUpdatedKeys([key]);
-  }
-  appendResetCommand(key, slots) {
-    this.appendCommand(key, this.createResetCommand(slots));
-  }
-  createResetCommand(slots) {
-    return { type: "reset", items: slots };
+    this.index.destroy();
+    super.destroy();
   }
 };
 
@@ -1750,42 +1980,34 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     this.index = index;
   }
   push(key, pk) {
-    this.withWrite(() => {
-      const slot = this.resolvePk(pk);
-      const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, { type: "insert", index, item: slot });
-    });
+    const slot = this.resolvePk(pk);
+    const index = this.index.pushSlot(key, slot);
+    this.appendCommand(key, { type: "insert", index, item: slot });
   }
   insertAt(key, index, pk) {
-    this.withWrite(() => {
-      const slot = this.resolvePk(pk);
-      const safeIndex = this.index.insertSlotAt(key, index, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        index: safeIndex,
-        item: slot
-      });
+    const slot = this.resolvePk(pk);
+    const safeIndex = this.index.insertSlotAt(key, index, slot);
+    this.appendCommand(key, {
+      type: "insert",
+      index: safeIndex,
+      item: slot
     });
   }
   /** Replace the element at `index` with the slot for `pk`, in place. */
   setAt(key, index, pk) {
-    this.withWrite(() => {
-      const slot = this.resolvePk(pk);
-      const safeIndex = this.index.setSlotAt(key, index, slot);
-      if (safeIndex < 0) return;
-      this.appendCommand(key, {
-        type: "set",
-        index: safeIndex,
-        item: slot
-      });
+    const slot = this.resolvePk(pk);
+    const safeIndex = this.index.setSlotAt(key, index, slot);
+    if (safeIndex < 0) return;
+    this.appendCommand(key, {
+      type: "set",
+      index: safeIndex,
+      item: slot
     });
   }
   set(key, pks) {
-    this.withWrite(() => {
-      const slots = pks.map((pk) => this.resolvePk(pk));
-      this.index.resetSlots(key, slots);
-      this.appendResetCommand(key, slots);
-    });
+    const slots = pks.map((pk) => this.resolvePk(pk));
+    this.index.resetSlots(key, slots);
+    this.appendResetCommand(key, slots);
   }
   getSlotsByKey(key) {
     return this.index.getSlotsByKey(
@@ -1796,7 +2018,9 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     return this.index.getEntitiesByKey(key);
   }
   resolvePk(pk) {
-    return this.index.resolvePk(pk);
+    return this.index.resolvePk(
+      pk
+    );
   }
 };
 
@@ -2393,7 +2617,445 @@ var OIMDerivedCollectionIndexArrayBased = class extends OIMReactiveCollectionInd
       seen.add(key);
       result.push(key);
     }
-    return result;
+    return result;
+  }
+};
+
+// src/core/OIMGlobalIndexManualArrayBased.ts
+var OIMGlobalIndexManualArrayBased = class extends OIMGlobalIndexArrayBased {
+  constructor(options = {}) {
+    super(options);
+  }
+  setSlots(slots) {
+    if (this.setSlotsWithComparison(slots)) this.emitUpdate();
+  }
+  /**
+   * Appends pre-deduplicated slots to the bucket IN PLACE and emits once.
+   * O(added). Callers own dedup (used by collection-bound `addPks`).
+   */
+  appendSlots(slots) {
+    if (slots.length === 0) return;
+    for (let i = 0; i < slots.length; i++) this.slots.push(slots[i]);
+    this.emitUpdate();
+  }
+  clear() {
+    if (this.slots.length > 0) {
+      this.slots = [];
+      this.emitUpdate();
+    }
+  }
+};
+
+// src/core/OIMReactiveGlobalIndexManualArrayBased.ts
+var OIMGlobalIndexManualArrayBasedReactive = class extends OIMGlobalIndexManualArrayBased {
+  constructor(updateEmitter, opts) {
+    super(opts);
+    this.updateEmitter = updateEmitter;
+  }
+  emitUpdate() {
+    this.updateEmitter.markUpdated();
+  }
+};
+var OIMReactiveGlobalIndexManualArrayBased = class extends OIMReactiveGlobalIndexArrayBased {
+  constructor(queue, opts) {
+    super(
+      queue,
+      (updateEmitter) => new OIMGlobalIndexManualArrayBasedReactive(
+        updateEmitter,
+        opts?.indexOptions
+      )
+    );
+  }
+  setSlots(slots) {
+    this.index.setSlots(slots);
+  }
+  appendSlots(slots) {
+    this.index.appendSlots(slots);
+  }
+  clear() {
+    this.index.clear();
+  }
+};
+
+// src/core/OIMReactiveCollectionGlobalIndexManualArrayBased.ts
+var OIMReactiveCollectionGlobalIndexManualArrayBased = class extends OIMReactiveGlobalIndexManualArrayBased {
+  constructor(queue, opts) {
+    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    super(queue, { indexOptions: opts.indexOptions });
+    // Single pk membership set for O(1) `addPks` dedup. Lazily seeded from the
+    // bucket so it stays correct even after a raw `setSlots` (e.g. derived
+    // rebuild), matching the keyed index's `membershipOf`.
+    this.membership = /* @__PURE__ */ new Set();
+    this.membershipSeeded = false;
+    this.resolveSlot = resolveSlot;
+  }
+  setPks(pks) {
+    this.membership.clear();
+    for (let i = 0; i < pks.length; i++) this.membership.add(pks[i]);
+    this.membershipSeeded = true;
+    super.setSlots(this.resolveSlots(pks));
+  }
+  addPks(pks) {
+    if (pks.length === 0) return;
+    const membership = this.membershipOf();
+    const newSlots = [];
+    for (const pk of pks) {
+      if (membership.has(pk)) continue;
+      membership.add(pk);
+      newSlots.push(this.resolveRequiredSlot(pk));
+    }
+    if (newSlots.length > 0) super.appendSlots(newSlots);
+  }
+  removePks(pks) {
+    if (pks.length === 0) return;
+    const membership = this.membershipOf();
+    if (membership.size === 0) return;
+    const pksToRemove = new Set(pks);
+    const existingSlots = this.index.getSlots();
+    const nextSlots = existingSlots.filter(
+      (slot) => !pksToRemove.has(slot.pk)
+    );
+    if (nextSlots.length === existingSlots.length) return;
+    for (let i = 0; i < pks.length; i++) membership.delete(pks[i]);
+    if (nextSlots.length === 0) this.clear();
+    else super.setSlots(nextSlots);
+  }
+  clear() {
+    this.membership.clear();
+    this.membershipSeeded = false;
+    super.clear();
+  }
+  membershipOf() {
+    if (!this.membershipSeeded) {
+      this.membership.clear();
+      const existing = this.index.getSlots();
+      for (let i = 0; i < existing.length; i++) {
+        this.membership.add(existing[i].pk);
+      }
+      this.membershipSeeded = true;
+    }
+    return this.membership;
+  }
+  getEntities() {
+    return super.getEntities();
+  }
+  resolveSlots(pks) {
+    const slots = [];
+    slots.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      slots[i] = this.resolveRequiredSlot(pks[i]);
+    }
+    return slots;
+  }
+  resolveRequiredSlot(pk) {
+    const slot = this.resolveSlot(pk);
+    if (!slot) return { pk, item: void 0 };
+    return slot;
+  }
+};
+
+// src/core/OIMGlobalIndexManualSetBased.ts
+var OIMGlobalIndexManualSetBased = class extends OIMGlobalIndexSetBased {
+  constructor(options = {}) {
+    super(options);
+  }
+  setSlots(slots) {
+    if (this.setSlotsWithComparison(new Set(slots))) this.emitUpdate();
+  }
+  /** Adds slots IN PLACE (O(added)) and emits once if anything changed. */
+  addSlots(slots) {
+    if (slots.length === 0) return;
+    let changed = false;
+    for (let i = 0; i < slots.length; i++) {
+      if (!this.slots.has(slots[i])) {
+        this.slots.add(slots[i]);
+        changed = true;
+      }
+    }
+    if (changed) this.emitUpdate();
+  }
+  /** Removes slots IN PLACE (O(removed)) and emits once if anything changed. */
+  removeSlots(slots) {
+    if (slots.length === 0) return;
+    let changed = false;
+    for (let i = 0; i < slots.length; i++) {
+      if (this.slots.delete(slots[i])) changed = true;
+    }
+    if (changed) this.emitUpdate();
+  }
+  clear() {
+    if (this.slots.size > 0) {
+      this.slots.clear();
+      this.emitUpdate();
+    }
+  }
+};
+
+// src/core/OIMReactiveGlobalIndexManualSetBased.ts
+var OIMGlobalIndexManualSetBasedReactive = class extends OIMGlobalIndexManualSetBased {
+  constructor(updateEmitter, opts) {
+    super(opts);
+    this.updateEmitter = updateEmitter;
+  }
+  emitUpdate() {
+    this.updateEmitter.markUpdated();
+  }
+};
+var OIMReactiveGlobalIndexManualSetBased = class extends OIMReactiveGlobalIndexSetBased {
+  constructor(queue, opts) {
+    super(
+      queue,
+      (updateEmitter) => new OIMGlobalIndexManualSetBasedReactive(
+        updateEmitter,
+        opts?.indexOptions
+      )
+    );
+  }
+  setSlots(slots) {
+    this.index.setSlots(slots);
+  }
+  addSlots(slots) {
+    this.index.addSlots(slots);
+  }
+  removeSlots(slots) {
+    this.index.removeSlots(slots);
+  }
+  clear() {
+    this.index.clear();
+  }
+};
+
+// src/core/OIMReactiveCollectionGlobalIndexManualSetBased.ts
+var OIMReactiveCollectionGlobalIndexManualSetBased = class extends OIMReactiveGlobalIndexManualSetBased {
+  constructor(queue, opts) {
+    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    super(queue, { indexOptions: opts.indexOptions });
+    this.membership = /* @__PURE__ */ new Map();
+    this.membershipSeeded = false;
+    this.resolveSlot = resolveSlot;
+  }
+  setPks(pks) {
+    this.membership.clear();
+    const slots = [];
+    for (let i = 0; i < pks.length; i++) {
+      const pk = pks[i];
+      const slot = this.resolveRequiredSlot(pk);
+      if (!this.membership.has(pk)) this.membership.set(pk, slot);
+      slots.push(slot);
+    }
+    this.membershipSeeded = true;
+    super.setSlots(slots);
+  }
+  addPks(pks) {
+    if (pks.length === 0) return;
+    const membership = this.membershipOf();
+    const newSlots = [];
+    for (const pk of pks) {
+      if (membership.has(pk)) continue;
+      const slot = this.resolveRequiredSlot(pk);
+      membership.set(pk, slot);
+      newSlots.push(slot);
+    }
+    if (newSlots.length > 0) super.addSlots(newSlots);
+  }
+  removePks(pks) {
+    if (pks.length === 0) return;
+    const membership = this.membershipOf();
+    if (membership.size === 0) return;
+    const removed = [];
+    for (const pk of pks) {
+      const slot = membership.get(pk);
+      if (slot) {
+        membership.delete(pk);
+        removed.push(slot);
+      }
+    }
+    if (removed.length === 0) return;
+    super.removeSlots(removed);
+  }
+  clear() {
+    this.membership.clear();
+    this.membershipSeeded = false;
+    super.clear();
+  }
+  membershipOf() {
+    if (!this.membershipSeeded) {
+      this.membership.clear();
+      for (const slot of this.index.getSlots()) {
+        this.membership.set(slot.pk, slot);
+      }
+      this.membershipSeeded = true;
+    }
+    return this.membership;
+  }
+  getEntities() {
+    return super.getEntities();
+  }
+  resolveRequiredSlot(pk) {
+    const slot = this.resolveSlot(pk);
+    if (!slot) return { pk, item: void 0 };
+    return slot;
+  }
+};
+
+// src/core/OIMDerivedCollectionGlobalIndexArrayBased.ts
+var OIMDerivedCollectionGlobalIndexArrayBased = class extends OIMReactiveCollectionGlobalIndexManualArrayBased {
+  constructor(queue, collection, opts) {
+    super(queue, { collection, indexOptions: opts.indexOptions });
+    this.presentPks = /* @__PURE__ */ new Set();
+    // Last known sort value per pk (only with `orderBy`), so an update touching
+    // an unrelated field can skip re-sorting when the value is unchanged.
+    this.orderValueByPk = /* @__PURE__ */ new Map();
+    this.onCollectionUpdate = (pks) => {
+      if (pks.length === 0) {
+        this.rebuildFromCollection();
+        return;
+      }
+      const ordered = !!(this.compareEntities || this.orderBy);
+      let needsSort = false;
+      for (const pk of pks) {
+        const prev = this.presentPks.has(pk);
+        const slot = this.collection.getSlotByPk(pk);
+        const entity = slot?.item;
+        const next = entity !== void 0 && (!this.filter || this.filter(entity));
+        let orderChanged = false;
+        if (this.orderBy) {
+          if (!next || entity === void 0) {
+            this.orderValueByPk.delete(pk);
+          } else {
+            const value = this.orderBy(entity);
+            orderChanged = !this.orderValueByPk.has(pk) || this.orderValueByPk.get(pk) !== value;
+            this.orderValueByPk.set(pk, value);
+          }
+        } else if (this.compareEntities && next) {
+          orderChanged = true;
+        }
+        if (prev && !next) {
+          super.removePks([pk]);
+          this.presentPks.delete(pk);
+        } else if (!prev && next) {
+          super.addPks([pk]);
+          this.presentPks.add(pk);
+          if (ordered) needsSort = true;
+        } else if (prev && next && orderChanged) {
+          needsSort = true;
+        }
+      }
+      if (ordered && needsSort) {
+        super.setSlots(this.sortSlots(this.index.getSlots()));
+      }
+    };
+    this.collection = collection;
+    this.compareEntities = opts.compareEntities;
+    this.orderBy = opts.orderBy;
+    this.filter = opts.filter;
+    this.unsubscribeFromCollection = collection.emitter.on(
+      0 /* UPDATE */,
+      (payload) => this.onCollectionUpdate(payload.pks)
+    );
+    if (opts.buildInitial !== false) {
+      this.rebuildFromCollection();
+    }
+  }
+  rebuildFromCollection() {
+    this.presentPks.clear();
+    this.orderValueByPk.clear();
+    super.clear();
+    const slots = [];
+    for (const slot of this.collection.getAllSlots()) {
+      if (slot.item === void 0) continue;
+      if (this.filter && !this.filter(slot.item)) continue;
+      this.presentPks.add(slot.pk);
+      if (this.orderBy) {
+        this.orderValueByPk.set(slot.pk, this.orderBy(slot.item));
+      }
+      slots.push(slot);
+    }
+    super.setSlots(this.sortSlots(slots));
+  }
+  clear() {
+    this.presentPks.clear();
+    this.orderValueByPk.clear();
+    super.clear();
+  }
+  destroy() {
+    this.unsubscribeFromCollection();
+    this.presentPks.clear();
+    this.orderValueByPk.clear();
+    super.destroy();
+  }
+  sortSlots(slots) {
+    if (!this.compareEntities && !this.orderBy) return slots.slice();
+    return slots.slice().sort((a, b) => {
+      const aItem = a.item;
+      const bItem = b.item;
+      if (aItem === void 0 || bItem === void 0) return 0;
+      if (this.compareEntities) {
+        return this.compareEntities(aItem, bItem);
+      }
+      const aValue = this.orderBy(aItem);
+      const bValue = this.orderBy(bItem);
+      if (aValue < bValue) return -1;
+      if (aValue > bValue) return 1;
+      return 0;
+    });
+  }
+};
+
+// src/core/OIMDerivedCollectionGlobalIndexSetBased.ts
+var OIMDerivedCollectionGlobalIndexSetBased = class extends OIMReactiveCollectionGlobalIndexManualSetBased {
+  constructor(queue, collection, opts) {
+    super(queue, { collection, indexOptions: opts.indexOptions });
+    this.presentPks = /* @__PURE__ */ new Set();
+    this.onCollectionUpdate = (pks) => {
+      if (pks.length === 0) {
+        this.rebuildFromCollection();
+        return;
+      }
+      for (const pk of pks) {
+        const prev = this.presentPks.has(pk);
+        const slot = this.collection.getSlotByPk(pk);
+        const entity = slot?.item;
+        const next = entity !== void 0 && (!this.filter || this.filter(entity));
+        if (prev && !next) {
+          super.removePks([pk]);
+          this.presentPks.delete(pk);
+        } else if (!prev && next) {
+          super.addPks([pk]);
+          this.presentPks.add(pk);
+        }
+      }
+    };
+    this.collection = collection;
+    this.filter = opts.filter;
+    this.unsubscribeFromCollection = collection.emitter.on(
+      0 /* UPDATE */,
+      (payload) => this.onCollectionUpdate(payload.pks)
+    );
+    if (opts.buildInitial !== false) {
+      this.rebuildFromCollection();
+    }
+  }
+  rebuildFromCollection() {
+    this.presentPks.clear();
+    super.clear();
+    const slots = /* @__PURE__ */ new Set();
+    for (const slot of this.collection.getAllSlots()) {
+      if (slot.item === void 0) continue;
+      if (this.filter && !this.filter(slot.item)) continue;
+      this.presentPks.add(slot.pk);
+      slots.add(slot);
+    }
+    super.setSlots(slots);
+  }
+  clear() {
+    this.presentPks.clear();
+    super.clear();
+  }
+  destroy() {
+    this.unsubscribeFromCollection();
+    this.presentPks.clear();
+    super.destroy();
   }
 };
 
@@ -2439,6 +3101,52 @@ var OIMCollectionIndexFactory = class {
       }
     );
   }
+  /**
+   * Keyless (whole-collection / "all") manual array-based index. No key —
+   * write pks directly with `setPks`/`addPks`/`removePks`.
+   */
+  arrayBasedGlobalIndex(opts = {}) {
+    return new OIMReactiveCollectionGlobalIndexManualArrayBased(this.queue, {
+      collection: this.collection,
+      indexOptions: opts.indexOptions
+    });
+  }
+  /** Keyless (whole-collection) manual set-based index. */
+  setBasedGlobalIndex(opts = {}) {
+    return new OIMReactiveCollectionGlobalIndexManualSetBased(this.queue, {
+      collection: this.collection,
+      indexOptions: opts.indexOptions
+    });
+  }
+  /**
+   * Keyless ordered list auto-derived from the whole collection. Pass
+   * `orderBy`/`compareEntities` for order, `filter` to include a subset.
+   */
+  derivedArrayGlobalIndex(opts = {}) {
+    return new OIMDerivedCollectionGlobalIndexArrayBased(
+      this.queue,
+      this.collection,
+      {
+        buildInitial: opts.buildInitial,
+        compareEntities: opts.compareEntities,
+        orderBy: opts.orderBy,
+        filter: opts.filter,
+        indexOptions: opts.indexOptions
+      }
+    );
+  }
+  /** Keyless set auto-derived from the whole collection. */
+  derivedSetGlobalIndex(opts = {}) {
+    return new OIMDerivedCollectionGlobalIndexSetBased(
+      this.queue,
+      this.collection,
+      {
+        buildInitial: opts.buildInitial,
+        filter: opts.filter,
+        indexOptions: opts.indexOptions
+      }
+    );
+  }
   orderedIndex() {
     return new OIMCollectionIndexManualOrderedArrayBased({
       collection: this.collection
@@ -3316,6 +4024,137 @@ var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
   }
 };
 
+// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByGlobalIndexArrayBased.ts
+var OIMSelectorSourceDependencyEntitiesByGlobalIndexArrayBased = class {
+  constructor(collection, reactiveIndex) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = this.reactiveIndex.getPks();
+      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.subscribe(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/OIMEntitiesByGlobalIndexArrayBasedSelector.ts
+var OIMEntitiesByGlobalIndexArrayBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByGlobalIndexArrayBased(collection, reactiveIndex)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+  }
+  getValue() {
+    const pks = this.reactiveIndex.getPks();
+    const entities = [];
+    entities.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      entities[i] = this.collection.getOneByPk(pks[i]);
+    }
+    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/OIMSelectorSourceDependencyEntitiesByGlobalIndexSetBased.ts
+var OIMSelectorSourceDependencyEntitiesByGlobalIndexSetBased = class {
+  constructor(collection, reactiveIndex) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = Array.from(this.reactiveIndex.getPks());
+      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.subscribe(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/OIMEntitiesByGlobalIndexSetBasedSelector.ts
+var OIMEntitiesByGlobalIndexSetBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByGlobalIndexSetBased(collection, reactiveIndex)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+  }
+  getValue() {
+    const pks = this.reactiveIndex.getPks();
+    const entities = [];
+    entities.length = pks.size;
+    let writeIndex = 0;
+    for (const pk of pks) {
+      entities[writeIndex++] = this.collection.getOneByPk(pk);
+    }
+    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/dx/OIMCollectionSelectors.ts
 var OIMCollectionSelectors = class {
   constructor(queue, collection) {
@@ -3348,6 +4187,22 @@ var OIMCollectionSelectors = class {
       key
     );
   }
+  /** Entities of a keyless (whole-collection) array-based index, ordered. */
+  entitiesByArrayGlobalIndex(index) {
+    return new OIMEntitiesByGlobalIndexArrayBasedSelector(
+      this.runtime,
+      this.collection,
+      index
+    );
+  }
+  /** Entities of a keyless (whole-collection) set-based index. */
+  entitiesBySetGlobalIndex(index) {
+    return new OIMEntitiesByGlobalIndexSetBasedSelector(
+      this.runtime,
+      this.collection,
+      index
+    );
+  }
 };
 
 // src/dx/OIMCollectionKit.ts
@@ -3547,6 +4402,359 @@ var OIMCollectionChangedFields = class {
   }
 };
 
+// src/modules/wrapper/index/OIMOrderedListMappedCommandStream.ts
+var OIMOrderedListMappedCommandStream = class _OIMOrderedListMappedCommandStream {
+  constructor(source, create) {
+    /** Per-key positional mirror of the mapped elements. */
+    this.mirror = /* @__PURE__ */ new Map();
+    /** Mapped commands produced for the current delivery, per key. */
+    this.buffer = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.sourceUnsubscribers = /* @__PURE__ */ new Map();
+    this.source = source;
+    this.create = create;
+  }
+  subscribeCommands(key, handler) {
+    this.ensureWired(key);
+    let subs = this.subscribers.get(key);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscribers.set(key, subs);
+    }
+    subs.add(handler);
+    return () => {
+      const current = this.subscribers.get(key);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(key);
+    };
+  }
+  consumeCommands(key) {
+    const cmds = this.buffer.get(key);
+    if (!cmds || cmds.length === 0) return [];
+    return cmds.slice();
+  }
+  getItemsByKey(key) {
+    this.ensureWired(key);
+    return this.mirror.get(key) ?? [];
+  }
+  /** Map this source again, chaining the projection. */
+  map(create) {
+    return new _OIMOrderedListMappedCommandStream(
+      this,
+      create
+    );
+  }
+  destroy() {
+    this.sourceUnsubscribers.forEach((unsubscribe) => unsubscribe());
+    this.sourceUnsubscribers.clear();
+    this.mirror.clear();
+    this.buffer.clear();
+    this.subscribers.clear();
+  }
+  /** Build the initial mirror and subscribe to the source once per key. */
+  ensureWired(key) {
+    if (this.mirror.has(key)) return;
+    const items = this.source.getItemsByKey(key);
+    this.mirror.set(key, items.map((item) => this.create(item)));
+    const unsubscribe = this.source.subscribeCommands(
+      key,
+      () => this.onSourceCommands(key)
+    );
+    this.sourceUnsubscribers.set(key, unsubscribe);
+  }
+  onSourceCommands(key) {
+    const cmds = this.source.consumeCommands(key);
+    if (cmds.length === 0) return;
+    let mirror = this.mirror.get(key);
+    if (!mirror) {
+      mirror = [];
+      this.mirror.set(key, mirror);
+    }
+    const out = [];
+    for (let i = 0; i < cmds.length; i++) {
+      const cmd = cmds[i];
+      switch (cmd.type) {
+        case "insert": {
+          const mapped = this.create(cmd.item);
+          mirror.splice(cmd.index, 0, mapped);
+          out.push({
+            type: "insert",
+            index: cmd.index,
+            item: mapped
+          });
+          break;
+        }
+        case "remove": {
+          const count = cmd.count ?? 1;
+          mirror.splice(cmd.index, count);
+          out.push({ type: "remove", index: cmd.index, count });
+          break;
+        }
+        case "move": {
+          const count = cmd.count ?? 1;
+          const segment = mirror.splice(cmd.from, count);
+          mirror.splice(cmd.to, 0, ...segment);
+          out.push({
+            type: "move",
+            from: cmd.from,
+            to: cmd.to,
+            count
+          });
+          break;
+        }
+        case "set": {
+          const mapped = this.create(cmd.item);
+          mirror.splice(cmd.index, 1, mapped);
+          out.push({ type: "set", index: cmd.index, item: mapped });
+          break;
+        }
+        case "reset": {
+          const mapped = cmd.items.map((item) => this.create(item));
+          mirror = mapped;
+          this.mirror.set(key, mapped);
+          out.push({ type: "reset", items: mapped });
+          break;
+        }
+      }
+    }
+    this.buffer.set(key, out);
+    try {
+      const subs = this.subscribers.get(key);
+      if (subs && subs.size > 0) {
+        const snapshot = Array.from(subs);
+        for (let s = 0; s < snapshot.length; s++) {
+          const handler = snapshot[s];
+          if (subs.has(handler)) handler();
+        }
+      }
+    } finally {
+      this.buffer.delete(key);
+    }
+  }
+};
+
+// src/modules/wrapper/index/createOIMOrderedListMappedCommandStream.ts
+function createOIMOrderedListMappedCommandStream(source, create) {
+  return new OIMOrderedListMappedCommandStream(
+    source,
+    create
+  );
+}
+
+// src/modules/wrapper/index/OIMIndexSlotMap.ts
+var OIMIndexSlotMap = class _OIMIndexSlotMap {
+  constructor(index, create) {
+    this.cache = /* @__PURE__ */ new WeakMap();
+    this.index = index;
+    this.create = create;
+  }
+  /** The mapped object for a slot, created once and cached by slot identity. */
+  get(slot) {
+    let mapped = this.cache.get(slot);
+    if (mapped === void 0 && !this.cache.has(slot)) {
+      mapped = this.create(slot);
+      this.cache.set(slot, mapped);
+    }
+    return mapped;
+  }
+  /**
+   * Mapped objects for every slot under `key`, with stable references. For a
+   * set-based index the order is unspecified (as the set is); for an
+   * array-based index it follows the index order.
+   */
+  getByKey(key) {
+    const result = [];
+    for (const slot of this.index.getSlotsByKey(key)) {
+      result.push(this.get(slot));
+    }
+    return result;
+  }
+  /**
+   * Chain another projection. `map(f)` returns a slot map over the SAME index
+   * whose objects are `f(this.get(slot))`, cached by slot identity — so both
+   * levels hand back stable references and each `create` runs once per slot.
+   * Mirrors the command stream's `.map()`.
+   */
+  map(create) {
+    return new _OIMIndexSlotMap(
+      this.index,
+      (slot) => create(this.get(slot))
+    );
+  }
+  /** Subscribe to a key's changes — passthrough to the index. */
+  subscribeOnKey(key, handler) {
+    return this.index.subscribeOnKey(key, handler);
+  }
+  /** Subscribe to several keys — passthrough to the index. */
+  subscribeOnKeys(keys, handler) {
+    return this.index.subscribeOnKeys(keys, handler);
+  }
+};
+
+// src/modules/wrapper/index/createOIMIndexSlotMap.ts
+function createOIMIndexSlotMap(index, create) {
+  return new OIMIndexSlotMap(index, create);
+}
+
+// src/modules/wrapper/index/diffOrderedListByPk.ts
+function diffOrderedListByPk(prev, next) {
+  const commands = [];
+  const working = prev.slice();
+  const nextPks = /* @__PURE__ */ new Set();
+  for (let i = 0; i < next.length; i++) nextPks.add(next[i].pk);
+  for (let i = working.length - 1; i >= 0; i--) {
+    if (!nextPks.has(working[i].pk)) {
+      commands.push({ type: "remove", index: i });
+      working.splice(i, 1);
+    }
+  }
+  const workingPos = /* @__PURE__ */ new Map();
+  for (let i = 0; i < working.length; i++) workingPos.set(working[i].pk, i);
+  const commonNextJ = [];
+  const seq = [];
+  for (let j = 0; j < next.length; j++) {
+    const p = workingPos.get(next[j].pk);
+    if (p !== void 0) {
+      commonNextJ.push(j);
+      seq.push(p);
+    }
+  }
+  const anchorJ = /* @__PURE__ */ new Set();
+  for (const s of longestIncreasingSubsequence(seq)) {
+    anchorJ.add(commonNextJ[s]);
+  }
+  for (let j = next.length - 1; j >= 0; j--) {
+    if (anchorJ.has(j)) continue;
+    const target = next[j];
+    const refIdx = j + 1 < next.length ? indexByPk(working, next[j + 1].pk) : working.length;
+    const p = indexByPk(working, target.pk);
+    if (p === -1) {
+      commands.push({ type: "insert", index: refIdx, item: target });
+      working.splice(refIdx, 0, target);
+    } else {
+      const to = p < refIdx ? refIdx - 1 : refIdx;
+      if (p !== to) {
+        commands.push({ type: "move", from: p, to });
+        working.splice(p, 1);
+        working.splice(to, 0, target);
+      }
+    }
+  }
+  return commands;
+}
+function indexByPk(items, pk) {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].pk === pk) return i;
+  }
+  return -1;
+}
+function longestIncreasingSubsequence(seq) {
+  const n = seq.length;
+  if (n === 0) return [];
+  const predecessor = new Array(n).fill(-1);
+  const tails = [];
+  for (let i = 0; i < n; i++) {
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (seq[tails[mid]] < seq[i]) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo > 0) predecessor[i] = tails[lo - 1];
+    if (lo === tails.length) tails.push(i);
+    else tails[lo] = i;
+  }
+  const result = [];
+  let k = tails[tails.length - 1];
+  while (k !== -1) {
+    result.push(k);
+    k = predecessor[k];
+  }
+  result.reverse();
+  return result;
+}
+
+// src/modules/wrapper/index/OIMOrderedListCommandStreamDiffDriven.ts
+var OIMOrderedListCommandStreamDiffDriven = class extends OIMOrderedListCommandBuffer {
+  constructor(queue, index, opts) {
+    super(queue);
+    this.prevByKey = /* @__PURE__ */ new Map();
+    this.indexUnsubscribeByKey = /* @__PURE__ */ new Map();
+    this.index = index;
+    this.resetThreshold = opts?.resetThreshold ?? 0;
+  }
+  getItemsByKey(key) {
+    this.ensureWired(key);
+    return this.currentSlots(key);
+  }
+  subscribeCommands(key, handler) {
+    this.ensureWired(key);
+    return super.subscribeCommands(key, handler);
+  }
+  destroy() {
+    this.indexUnsubscribeByKey.forEach((unsubscribe) => unsubscribe());
+    this.indexUnsubscribeByKey.clear();
+    this.prevByKey.clear();
+    super.destroy();
+  }
+  currentSlots(key) {
+    return this.index.getSlotsByKey(key);
+  }
+  /** Snapshot the current order and subscribe to the index once per key. */
+  ensureWired(key) {
+    if (this.indexUnsubscribeByKey.has(key)) return;
+    this.prevByKey.set(key, this.currentSlots(key).slice());
+    const unsubscribe = this.index.subscribeOnKey(
+      key,
+      () => this.onIndexChange(key)
+    );
+    this.indexUnsubscribeByKey.set(key, unsubscribe);
+  }
+  onIndexChange(key) {
+    const prev = this.prevByKey.get(key) ?? [];
+    const next = this.currentSlots(key);
+    this.emitDiff(key, prev, next);
+    this.prevByKey.set(key, next.slice());
+  }
+  emitDiff(key, prev, next) {
+    if (sameOrderByPk(prev, next)) return;
+    const commons = countCommonPks(prev, next);
+    const larger = Math.max(prev.length, next.length);
+    const wholeChange = prev.length === 0 || next.length === 0 || commons === 0 || this.resetThreshold > 0 && commons / larger < this.resetThreshold;
+    if (wholeChange) {
+      this.appendResetCommand(key, next);
+      return;
+    }
+    const commands = diffOrderedListByPk(prev, next);
+    for (let i = 0; i < commands.length; i++) {
+      this.appendCommand(key, commands[i]);
+    }
+  }
+};
+function sameOrderByPk(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].pk !== b[i].pk) return false;
+  }
+  return true;
+}
+function countCommonPks(prev, next) {
+  const prevPks = /* @__PURE__ */ new Set();
+  for (let i = 0; i < prev.length; i++) prevPks.add(prev[i].pk);
+  let common = 0;
+  for (let i = 0; i < next.length; i++) {
+    if (prevPks.has(next[i].pk)) common++;
+  }
+  return common;
+}
+
+// src/modules/wrapper/index/createOIMOrderedListCommandStreamDiffDriven.ts
+function createOIMOrderedListCommandStreamDiffDriven(queue, index, opts) {
+  return new OIMOrderedListCommandStreamDiffDriven(queue, index, opts);
+}
+
 // src/core/event-queue-scheduler/OIMEventQueueSchedulerAnimationFrame.ts
 var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler {
   constructor() {
@@ -3671,6 +4879,15 @@ var OIMEventQueueSchedulerImmediate = class extends OIMEventQueueScheduler {
   }
 };
 
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerSync.ts
+var OIMEventQueueSchedulerSync = class extends OIMEventQueueScheduler {
+  schedule() {
+    this.flush();
+  }
+  cancel() {
+  }
+};
+
 // src/core/event-queue-scheduler/OIMEventQueueSchedulerFactory.ts
 var OIMEventQueueSchedulerFactory = class {
   /**
@@ -3688,6 +4905,8 @@ var OIMEventQueueSchedulerFactory = class {
       }
       case "immediate":
         return new OIMEventQueueSchedulerImmediate();
+      case "sync":
+        return new OIMEventQueueSchedulerSync();
       default:
         throw new Error(`Unknown scheduler type: ${type}`);
     }
@@ -3711,11 +4930,18 @@ var OIMEventQueueSchedulerFactory = class {
     return new OIMEventQueueSchedulerTimeout(delay);
   }
   /**
-   * Create an immediate scheduler (fastest execution).
+   * Create an immediate scheduler (setImmediate / MessageChannel / setTimeout(0)).
    */
   static createImmediate() {
     return new OIMEventQueueSchedulerImmediate();
   }
+  /**
+   * Create a synchronous scheduler — flushes in the same call stack, no
+   * batching. Debug/diagnostic use only (see {@link OIMEventQueueSchedulerSync}).
+   */
+  static createSync() {
+    return new OIMEventQueueSchedulerSync();
+  }
 };
 
 // src/constants/OIMDBSettings.ts
@@ -4123,6 +5349,7 @@ export {
   EOIMIndexEventType,
   EOIMObjectEventType,
   OIMCarrierKeyedEmitter,
+  OIMCarrierSingleEmitter,
   OIMCollection,
   OIMCollectionByPkSelector,
   OIMCollectionByPksSelector,
@@ -4137,6 +5364,8 @@ export {
   OIMComputeRuntime,
   OIMComputed,
   OIMDBSettings,
+  OIMDerivedCollectionGlobalIndexArrayBased,
+  OIMDerivedCollectionGlobalIndexSetBased,
   OIMDerivedCollectionIndexArrayBased,
   OIMDerivedCollectionIndexSetBased,
   OIMEffect,
@@ -4145,6 +5374,8 @@ export {
   OIMEffectDependencyKeyedCollection,
   OIMEffectDependencyKeyedIndex,
   OIMEffectDependencyKeyedObject,
+  OIMEntitiesByGlobalIndexArrayBasedSelector,
+  OIMEntitiesByGlobalIndexSetBasedSelector,
   OIMEntitiesByIndexKeyArrayBasedSelector,
   OIMEntitiesByIndexKeySetBasedSelector,
   OIMEntityUpdaterFactory,
@@ -4155,7 +5386,13 @@ export {
   OIMEventQueueSchedulerFactory,
   OIMEventQueueSchedulerImmediate,
   OIMEventQueueSchedulerMicrotask,
+  OIMEventQueueSchedulerSync,
   OIMEventQueueSchedulerTimeout,
+  OIMGlobalIndex,
+  OIMGlobalIndexArrayBased,
+  OIMGlobalIndexManualArrayBased,
+  OIMGlobalIndexManualSetBased,
+  OIMGlobalIndexSetBased,
   OIMIndex,
   OIMIndexArrayBased,
   OIMIndexComparatorFactory,
@@ -4167,6 +5404,7 @@ export {
   OIMIndexPksByKeysArrayBasedSelector,
   OIMIndexPksByKeysSetBasedSelector,
   OIMIndexSetBased,
+  OIMIndexSlotMap,
   OIMIndexStoreArrayBased,
   OIMIndexStoreMapDrivenArrayBased,
   OIMIndexStoreMapDrivenSetBased,
@@ -4178,11 +5416,21 @@ export {
   OIMObjectStoreRecordDriven,
   OIMObjectValueByKeySelector,
   OIMObjectValuesByKeysSelector,
+  OIMOrderedListCommandBuffer,
   OIMOrderedListCommandStream,
+  OIMOrderedListCommandStreamDiffDriven,
+  OIMOrderedListMappedCommandStream,
   OIMPkSelectorFactory,
   OIMReactiveCollection,
+  OIMReactiveCollectionGlobalIndexManualArrayBased,
+  OIMReactiveCollectionGlobalIndexManualSetBased,
   OIMReactiveCollectionIndexManualArrayBased,
   OIMReactiveCollectionIndexManualSetBased,
+  OIMReactiveGlobalIndex,
+  OIMReactiveGlobalIndexArrayBased,
+  OIMReactiveGlobalIndexManualArrayBased,
+  OIMReactiveGlobalIndexManualSetBased,
+  OIMReactiveGlobalIndexSetBased,
   OIMReactiveIndex,
   OIMReactiveIndexArrayBased,
   OIMReactiveIndexManualArrayBased,
@@ -4193,5 +5441,9 @@ export {
   createInPlaceEntityUpdater,
   createMergeEntityUpdater,
   createOIMCollectionIndexFactory,
-  createOIMCollectionKit
+  createOIMCollectionKit,
+  createOIMIndexSlotMap,
+  createOIMOrderedListCommandStreamDiffDriven,
+  createOIMOrderedListMappedCommandStream,
+  diffOrderedListByPk
 };