@oimdb/core 3.3.0 → 3.5.0

package/README.md

@@ -318,16 +318,20 @@ cardsByDeck.commandsEventEmitter.subscribeOnKey('deck1', () => {
     for (const command of commands) {
         switch (command.type) {
             case 'insert':
-                // Insert command.pk / command.slot.item at command.index
+                // Insert command.item (the slot; entity is command.item.item)
+                // at command.index
                 break;
             case 'remove':
-                // Remove command.pk from command.index
+                // Remove command.count ?? 1 elements starting at command.index
                 break;
             case 'move':
-                // Move command.pk from command.fromIndex to command.toIndex
+                // Move command.count ?? 1 elements from command.from to command.to
                 break;
             case 'set':
-                // Replace the whole list with command.pks or command.slots
+                // Replace the single element at command.index with command.item
+                break;
+            case 'reset':
+                // Replace the whole list with command.items (slots)
                 break;
         }
     }
@@ -1546,7 +1550,16 @@ Collection-bound ordered Array-based index. Use this when ordered PK writes shou
 - `getEntitiesByKey(key: TKey): (TEntity | undefined)[]` - Returns entities from canonical slots (holes are `undefined`)
 
 #### `OIMOrderedListCommandStream<TKey, TPk, TEntity>`
-Slot-first ordered per-key list with a command stream for imperative consumers. It stores data in an `OIMIndexManualOrderedArrayBased` and emits `TOIMOrderedListCommand` batches through `commandsEventEmitter`.
+Slot-first ordered per-key list with a command stream for imperative consumers. It stores data in an `OIMIndexManualOrderedArrayBased` and emits position-addressed `TOIMOrderedListCommand<Slot>` batches through `commandsEventEmitter`. Each command's `item` is the entity slot (read the entity via `item.item`):
+
+```typescript
+type TOIMOrderedListCommand<TItem> =
+    | { type: 'insert'; index: number; item: TItem }
+    | { type: 'remove'; index: number; count?: number }   // count may be > 1
+    | { type: 'move'; from: number; to: number; count?: number }
+    | { type: 'set'; index: number; item: TItem }          // replace one element
+    | { type: 'reset'; items: readonly TItem[] };          // replace whole list
+```
 
 **Constructor:**
 ```typescript
@@ -1560,14 +1573,17 @@ new OIMOrderedListCommandStream(
 - `index: OIMIndexManualOrderedArrayBased<TKey, TPk>` - Underlying ordered index and source of truth
 - `commandsEventEmitter: OIMUpdateEventEmitter<TKey>` - Key-specific command notifications delivered after queue flush
 
-**Methods:**
-- `setSlots(key: TKey, slots: readonly TOIMEntitySlot<TEntity, TPk>[]): void` - Replace the whole ordered list and emit a `set` command
-- `pushSlot(key: TKey, slot: TOIMEntitySlot<TEntity, TPk>): void` - Append a slot and emit an `insert` command
-- `insertSlotAt(key: TKey, index: number, slot: TOIMEntitySlot<TEntity, TPk>): void` - Insert a slot and emit an `insert` command
+**Methods:** (`Slot` = `TOIMEntitySlot<TEntity, TPk>`)
+- `setSlots(key: TKey, slots: readonly Slot[]): void` - Replace the whole ordered list and emit a `reset` command
+- `pushSlot(key: TKey, slot: Slot): void` - Append a slot and emit an `insert` command
+- `insertSlotAt(key: TKey, index: number, slot: Slot): void` - Insert a slot and emit an `insert` command
+- `setSlotAt(key: TKey, index: number, slot: Slot): void` - Replace the slot at `index` in place and emit a `set` command
 - `removeAt(key: TKey, index: number): void` - Remove by index and emit a `remove` command
+- `removeRange(key: TKey, index: number, count: number): void` - Remove `count` consecutive elements from `index` and emit a `remove` command with `count`
 - `move(key: TKey, fromIndex: number, toIndex: number): void` - Move within the list and emit a `move` command
-- `consumeCommands(key: TKey): TOIMOrderedListCommand<TPk, TEntity>[]` - Read buffered commands for a key inside the notification handler
-- `getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TPk, TEntity>[]` - Peek at buffered commands without clearing them
+- `moveRange(key: TKey, from: number, to: number, count: number): void` - Move `count` consecutive elements and emit a `move` command with `count` (`to` is post-extraction space)
+- `consumeCommands(key: TKey): TOIMOrderedListCommand<Slot>[]` - Read buffered commands for a key inside the notification handler
+- `getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<Slot>[]` - Peek at buffered commands without clearing them
 - `getPksByKey(key: TKey): readonly TPk[]` - Read the current ordered list
 - `getSlotsByKey(key: TKey): readonly TOIMEntitySlot<TEntity, TPk>[]` - Read current ordered slots
 - `getEntitiesByKey(key: TKey): (TEntity | undefined)[]` - Read current ordered entities (holes are `undefined`)
@@ -1575,10 +1591,11 @@ new OIMOrderedListCommandStream(
 - `destroy(): void` - Dispose subscriptions and clear state
 
 #### `OIMCollectionOrderedListCommandStream<TKey, TPk, TEntity>`
-Collection-bound ordered-list command stream. Public writes use PKs, commands include both `pk`/`pks` and canonical `slot`/`slots`.
+Collection-bound ordered-list command stream. Public writes use PKs that resolve to canonical collection slots; emitted commands carry the slot as `item` (entity via `item.item`).
 
 **Methods:**
-- `set(key: TKey, pks: readonly TPk[]): void` - Replace the whole ordered list from PKs
+- `set(key: TKey, pks: readonly TPk[]): void` - Replace the whole ordered list from PKs (emits `reset`)
+- `setAt(key: TKey, index: number, pk: TPk): void` - Replace the element at `index` with the slot for `pk` (emits `set`)
 - `push(key: TKey, pk: TPk): void` - Append a PK
 - `insertAt(key: TKey, index: number, pk: TPk): void` - Insert a PK
 - all read/command methods from `OIMOrderedListCommandStream`

package/dist/index.cjs

@@ -83,6 +83,7 @@ __export(index_exports, {
   OIMObjectValueByKeySelector: () => OIMObjectValueByKeySelector,
   OIMObjectValuesByKeysSelector: () => OIMObjectValuesByKeysSelector,
   OIMOrderedListCommandStream: () => OIMOrderedListCommandStream,
+  OIMOrderedListMappedCommandStream: () => OIMOrderedListMappedCommandStream,
   OIMPkSelectorFactory: () => OIMPkSelectorFactory,
   OIMReactiveCollection: () => OIMReactiveCollection,
   OIMReactiveCollectionIndexManualArrayBased: () => OIMReactiveCollectionIndexManualArrayBased,
@@ -95,8 +96,10 @@ __export(index_exports, {
   OIMReactiveObject: () => OIMReactiveObject,
   OIMSelector: () => OIMSelector,
   createInPlaceEntityUpdater: () => createInPlaceEntityUpdater,
+  createMergeEntityUpdater: () => createMergeEntityUpdater,
   createOIMCollectionIndexFactory: () => createOIMCollectionIndexFactory,
-  createOIMCollectionKit: () => createOIMCollectionKit
+  createOIMCollectionKit: () => createOIMCollectionKit,
+  createOIMOrderedListMappedCommandStream: () => createOIMOrderedListMappedCommandStream
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -967,12 +970,15 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   }
 };
 
+// src/core/createMergeEntityUpdater.ts
+function createMergeEntityUpdater() {
+  return (draft, prev) => ({ ...prev, ...draft });
+}
+
 // src/core/OIMEntityUpdaterFactory.ts
 var OIMEntityUpdaterFactory = class {
   createMergeEntityUpdater() {
-    return (draft, prev) => {
-      return { ...prev, ...draft };
-    };
+    return createMergeEntityUpdater();
   }
 };
 
@@ -1291,6 +1297,22 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
     this.emitUpdate([key]);
     return removed;
   }
+  /**
+   * Remove up to `count` consecutive slots starting at `index`.
+   * Returns the number actually removed (clamped to bounds; 0 if nothing).
+   */
+  removeRange(key, index, count) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return 0;
+    if (index < 0 || index >= list.length || count <= 0) return 0;
+    const actual = Math.min(count, list.length - index);
+    list.splice(index, actual);
+    if (list.length === 0) {
+      this.store.removeOneByKey(key);
+    }
+    this.emitUpdate([key]);
+    return actual;
+  }
   move(key, fromIndex, toIndex) {
     const list = this.store.getOneByKey(key);
     if (!list) return void 0;
@@ -1303,6 +1325,32 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
     this.emitUpdate([key]);
     return slot;
   }
+  /** Replace the slot at `index` in place. Returns the safe index, or -1. */
+  setSlotAt(key, index, slot) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return -1;
+    if (index < 0 || index >= list.length) return -1;
+    list[index] = slot;
+    this.emitUpdate([key]);
+    return index;
+  }
+  /**
+   * Move up to `count` consecutive slots from `from` to `to`. `to` is in the
+   * coordinate space *after* the block is extracted (same as single `move`).
+   * Returns the number actually moved (0 if a no-op / out of bounds).
+   */
+  moveRange(key, from, to, count) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return 0;
+    if (from < 0 || from >= list.length || count <= 0) return 0;
+    const actual = Math.min(count, list.length - from);
+    const insertAt = Math.max(0, Math.min(to, list.length - actual));
+    if (insertAt === from) return 0;
+    const block = list.splice(from, actual);
+    list.splice(insertAt, 0, ...block);
+    this.emitUpdate([key]);
+    return actual;
+  }
   resetSlots(key, slots) {
     if (slots.length === 0) {
       if (this.store.getOneByKey(key) !== void 0) {
@@ -1513,15 +1561,15 @@ var OIMUpdateEventEmitter = class {
     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 (flushingKeys.size === this.keyHandlers.size) {
+      this.keyHandlers.forEach((handlers, key) => {
+        if (!flushingKeys.has(key)) return;
         if (!handlers || handlers.size === 0) return;
         this.notifyHandlers(handlers);
       });
     } else {
-      this.keyHandlers.forEach((handlers, key) => {
-        if (!flushingKeys.has(key)) return;
+      flushingKeys.forEach((key) => {
+        const handlers = this.keyHandlers.get(key);
         if (!handlers || handlers.size === 0) return;
         this.notifyHandlers(handlers);
       });
@@ -1633,7 +1681,7 @@ var OIMOrderedListCommandStream = class {
       if (payload.keys.length === 0) return;
       for (let i = 0; i < payload.keys.length; i++) {
         const key = payload.keys[i];
-        this.appendSetCommand(key, this.getSlotsByKey(key));
+        this.appendResetCommand(key, this.getSlotsByKey(key));
       }
     };
     this.commandsEventEmitter = new OIMUpdateEventEmitter(
@@ -1658,6 +1706,14 @@ var OIMOrderedListCommandStream = class {
       key
     );
   }
+  /** {@link IOIMOrderedListCommandSource} — alias of {@link getSlotsByKey}. */
+  getItemsByKey(key) {
+    return this.getSlotsByKey(key);
+  }
+  /** {@link IOIMOrderedListCommandSource} — per-key command subscription. */
+  subscribeCommands(key, handler) {
+    return this.commandsEventEmitter.subscribeOnKey(key, handler);
+  }
   getEntitiesByKey(key) {
     return this.index.getEntitiesByKey(key);
   }
@@ -1670,12 +1726,7 @@ var OIMOrderedListCommandStream = class {
   pushSlot(key, slot) {
     this.withWrite(() => {
       const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        pk: slot.pk,
-        slot,
-        index
-      });
+      this.appendCommand(key, { type: "insert", index, item: slot });
     });
   }
   insertSlotAt(key, index, slot) {
@@ -1683,9 +1734,20 @@ var OIMOrderedListCommandStream = class {
       const safeIndex = this.index.insertSlotAt(key, index, slot);
       this.appendCommand(key, {
         type: "insert",
-        pk: slot.pk,
-        slot,
-        index: safeIndex
+        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
       });
     });
   }
@@ -1693,12 +1755,15 @@ var OIMOrderedListCommandStream = class {
     this.withWrite(() => {
       const slot = this.index.removeAt(key, index);
       if (slot === void 0) return;
-      this.appendCommand(key, {
-        type: "remove",
-        pk: slot.pk,
-        slot,
-        index
-      });
+      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 });
     });
   }
   move(key, fromIndex, toIndex) {
@@ -1707,17 +1772,26 @@ var OIMOrderedListCommandStream = class {
       if (slot === void 0) return;
       this.appendCommand(key, {
         type: "move",
-        pk: slot.pk,
-        slot,
-        fromIndex,
-        toIndex
+        from: fromIndex,
+        to: toIndex
       });
     });
   }
+  /**
+   * Move `count` consecutive elements from `from` to `to`; emits `move` with
+   * `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 });
+    });
+  }
   setSlots(key, slots) {
     this.withWrite(() => {
       this.index.resetSlots(key, slots);
-      this.appendSetCommand(key, slots);
+      this.appendResetCommand(key, slots);
     });
   }
   getBufferedCommands(key) {
@@ -1761,26 +1835,21 @@ var OIMOrderedListCommandStream = class {
       cmds = [];
       this.commandsByKey.set(key, cmds);
     }
-    if (cmd.type === "set") {
+    if (cmd.type === "reset") {
       cmds.length = 0;
       cmds.push(cmd);
-    } else if (cmds.length > 0 && cmds[0].type === "set") {
-      const slots = this.getSlotsByKey(key);
-      cmds[0] = this.createSetCommand(slots);
+    } else if (cmds.length > 0 && cmds[0].type === "reset") {
+      cmds[0] = this.createResetCommand(this.getSlotsByKey(key));
     } else {
       cmds.push(cmd);
     }
     this.commandsEventEmitter.markUpdatedKeys([key]);
   }
-  appendSetCommand(key, slots) {
-    this.appendCommand(key, this.createSetCommand(slots));
+  appendResetCommand(key, slots) {
+    this.appendCommand(key, this.createResetCommand(slots));
   }
-  createSetCommand(slots) {
-    return {
-      type: "set",
-      pks: slots.map((slot) => slot.pk),
-      slots
-    };
+  createResetCommand(slots) {
+    return { type: "reset", items: slots };
   }
 };
 
@@ -1797,12 +1866,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     this.withWrite(() => {
       const slot = this.resolvePk(pk);
       const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        pk,
-        slot,
-        index
-      });
+      this.appendCommand(key, { type: "insert", index, item: slot });
     });
   }
   insertAt(key, index, pk) {
@@ -1811,9 +1875,21 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
       const safeIndex = this.index.insertSlotAt(key, index, slot);
       this.appendCommand(key, {
         type: "insert",
-        pk,
-        slot,
-        index: safeIndex
+        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
       });
     });
   }
@@ -1821,7 +1897,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     this.withWrite(() => {
       const slots = pks.map((pk) => this.resolvePk(pk));
       this.index.resetSlots(key, slots);
-      this.appendSetCommand(key, slots);
+      this.appendResetCommand(key, slots);
     });
   }
   getSlotsByKey(key) {
@@ -3400,20 +3476,27 @@ var OIMCollectionChangedFields = class {
   constructor(queue, collection, opts) {
     this.isInWrite = false;
     this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
+    // PKs written through this wrapper during the current flush. Their fields are
+    // already tracked accurately via trackPatch, so the flush-time external-write
+    // handler skips them — no redundant diff + snapshot re-clone. Cleared per flush.
+    this.writtenThroughThisFlush = /* @__PURE__ */ new Set();
     this.changedFieldsByPk = /* @__PURE__ */ new Map();
     this.changedPksByField = /* @__PURE__ */ new Map();
     this.onAfterFlush = () => {
       this.clear();
+      this.writtenThroughThisFlush.clear();
     };
     this.onCollectionUpdate = (payload) => {
       if (this.isInWrite) return;
       if (payload.pks.length === 0) return;
       for (let i = 0; i < payload.pks.length; i++) {
         const pk = payload.pks[i];
+        if (this.writtenThroughThisFlush.has(pk)) continue;
         this.trackExternalMutationByPk(pk);
       }
     };
     this.collection = collection;
+    this.detectExternalMutations = opts?.detectExternalMutations !== false;
     this.selectPk = opts?.selectPk ?? (() => {
       throw new Error(
         `[OIMCollectionChangedFields]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
@@ -3428,15 +3511,17 @@ var OIMCollectionChangedFields = class {
       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
-    );
+    if (this.detectExternalMutations) {
+      const maybeReactive = collection;
+      this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
+        this.onCollectionUpdate({
+          pks
+        });
+      }) : collection.emitter.on(
+        0 /* UPDATE */,
+        this.onCollectionUpdate
+      );
+    }
   }
   upsertOneByPk(pk, patch) {
     const slot = this.withWrite(() => {
@@ -3492,7 +3577,7 @@ var OIMCollectionChangedFields = class {
     this.changedPksEventEmitter.destroy();
     this.changedFieldsEventEmitter.destroy();
     this.unsubscribeAfterFlush();
-    this.unsubscribeFromCollectionEmitter();
+    this.unsubscribeFromCollectionEmitter?.();
     this.clear();
   }
   withWrite(fn) {
@@ -3534,6 +3619,8 @@ var OIMCollectionChangedFields = class {
     return changed;
   }
   updateEntitySnapshot(pk) {
+    if (!this.detectExternalMutations) return;
+    this.writtenThroughThisFlush.add(pk);
     const entity = this.collection.getOneByPk(pk);
     if (!entity) {
       this.lastEntitySnapshotByPk.delete(pk);
@@ -3573,6 +3660,162 @@ var OIMCollectionChangedFields = class {
   }
 };
 
+// src/modules/wrapper/index/OIMOrderedListMappedCommandStream.ts
+var OIMOrderedListMappedCommandStream = class _OIMOrderedListMappedCommandStream {
+  constructor(source, opts) {
+    /** 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 = opts.create;
+    this.destroyItem = opts.destroy;
+  }
+  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(opts) {
+    return new _OIMOrderedListMappedCommandStream(
+      this,
+      opts
+    );
+  }
+  destroy() {
+    this.sourceUnsubscribers.forEach((unsubscribe) => unsubscribe());
+    this.sourceUnsubscribers.clear();
+    if (this.destroyItem) {
+      this.mirror.forEach(
+        (items) => items.forEach((item) => this.destroyItem(item))
+      );
+    }
+    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;
+          const removed = mirror.splice(cmd.index, count);
+          if (this.destroyItem) {
+            for (let r = 0; r < removed.length; r++) {
+              this.destroyItem(removed[r]);
+            }
+          }
+          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);
+          const replaced = mirror.splice(cmd.index, 1, mapped);
+          if (this.destroyItem && replaced.length > 0) {
+            this.destroyItem(replaced[0]);
+          }
+          out.push({ type: "set", index: cmd.index, item: mapped });
+          break;
+        }
+        case "reset": {
+          if (this.destroyItem) {
+            for (let r = 0; r < mirror.length; r++) {
+              this.destroyItem(mirror[r]);
+            }
+          }
+          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, opts) {
+  return new OIMOrderedListMappedCommandStream(source, opts);
+}
+
 // src/core/event-queue-scheduler/OIMEventQueueSchedulerAnimationFrame.ts
 var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler {
   constructor() {
@@ -4206,6 +4449,7 @@ var OIMIndexPksByKeysArrayBasedSelector = class extends OIMSelector {
   OIMObjectValueByKeySelector,
   OIMObjectValuesByKeysSelector,
   OIMOrderedListCommandStream,
+  OIMOrderedListMappedCommandStream,
   OIMPkSelectorFactory,
   OIMReactiveCollection,
   OIMReactiveCollectionIndexManualArrayBased,
@@ -4218,6 +4462,8 @@ var OIMIndexPksByKeysArrayBasedSelector = class extends OIMSelector {
   OIMReactiveObject,
   OIMSelector,
   createInPlaceEntityUpdater,
+  createMergeEntityUpdater,
   createOIMCollectionIndexFactory,
-  createOIMCollectionKit
+  createOIMCollectionKit,
+  createOIMOrderedListMappedCommandStream
 });