@oimdb/core 1.4.1 → 2.0.0

package/dist/index.js

@@ -2,14 +2,6 @@
 var OIMCollectionStore = class {
 };
 
-// src/abstract/OIMIndexStoreSetBased.ts
-var OIMIndexStoreSetBased = class {
-};
-
-// src/abstract/OIMIndexStoreArrayBased.ts
-var OIMIndexStoreArrayBased = class {
-};
-
 // src/core/OIMEventEmitter.ts
 var OIMEventEmitter = class {
   constructor() {
@@ -115,7 +107,94 @@ var OIMEventEmitter = class {
   }
 };
 
-// src/enum/EOIMEventQueueSchedulerEventType.ts
+// src/enums/EOIMIndexEventType.ts
+var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
+  EOIMIndexEventType2[EOIMIndexEventType2["UPDATE"] = 0] = "UPDATE";
+  return EOIMIndexEventType2;
+})(EOIMIndexEventType || {});
+
+// src/abstract/OIMIndex.ts
+var OIMIndex = class {
+  constructor(store, comparePks) {
+    this.emitter = new OIMEventEmitter();
+    this.store = store;
+    this.comparePks = comparePks;
+  }
+  hasKey(key) {
+    return this.store.getOneByKey(key) !== void 0;
+  }
+  getKeys() {
+    return this.store.getAllKeys();
+  }
+  getKeySize(key) {
+    const bucket = this.store.getOneByKey(key);
+    return bucket ? this.getBucketSize(bucket) : 0;
+  }
+  get size() {
+    return this.store.countAll();
+  }
+  get isEmpty() {
+    return this.store.countAll() === 0;
+  }
+  getEntitiesByKey(key) {
+    const bucket = this.store.getOneByKey(key);
+    return bucket ? this.slotsToEntities(bucket) : [];
+  }
+  getEntitiesByKeys(keys) {
+    const result = /* @__PURE__ */ new Map();
+    const bucketsByKey = this.store.getManyByKeys(keys);
+    for (const [key, bucket] of bucketsByKey) {
+      result.set(key, this.slotsToEntities(bucket));
+    }
+    return result;
+  }
+  getMetrics() {
+    let totalPks = 0;
+    let maxBucketSize = 0;
+    let minBucketSize = Infinity;
+    const all = this.store.getAll();
+    for (const bucket of all.values()) {
+      const size = this.getBucketSize(bucket);
+      totalPks += size;
+      maxBucketSize = Math.max(maxBucketSize, size);
+      minBucketSize = Math.min(minBucketSize, size);
+    }
+    return {
+      totalKeys: all.size,
+      totalPks,
+      averagePksPerKey: all.size > 0 ? totalPks / all.size : 0,
+      maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
+      minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
+    };
+  }
+  destroy() {
+    this.emitter.offAll();
+    this.store.clear();
+  }
+  emitUpdate(keys) {
+    this.emitter.emit(0 /* UPDATE */, { keys });
+  }
+  emitUpdateOne(key) {
+    this.emitUpdate([key]);
+  }
+  slotsToEntities(slots) {
+    const entities = [];
+    for (const slot of slots) {
+      if (slot.item !== void 0) entities.push(slot.item);
+    }
+    return entities;
+  }
+};
+
+// src/abstract/OIMIndexStoreSetBased.ts
+var OIMIndexStoreSetBased = class {
+};
+
+// src/abstract/OIMIndexStoreArrayBased.ts
+var OIMIndexStoreArrayBased = class {
+};
+
+// src/enums/EOIMEventQueueSchedulerEventType.ts
 var EOIMEventQueueSchedulerEventType = /* @__PURE__ */ ((EOIMEventQueueSchedulerEventType2) => {
   EOIMEventQueueSchedulerEventType2[EOIMEventQueueSchedulerEventType2["FLUSH"] = 0] = "FLUSH";
   return EOIMEventQueueSchedulerEventType2;
@@ -140,332 +219,202 @@ var OIMEventQueueScheduler = class {
   }
 };
 
-// src/enum/EOIMIndexEventType.ts
-var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
-  EOIMIndexEventType2[EOIMIndexEventType2["UPDATE"] = 0] = "UPDATE";
-  return EOIMIndexEventType2;
-})(EOIMIndexEventType || {});
-
 // src/core/OIMIndexStoreMapDrivenSetBased.ts
 var OIMIndexStoreMapDrivenSetBased = class extends OIMIndexStoreSetBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexSetBased.ts
-var OIMIndexSetBased = class {
+var OIMIndexSetBased = class extends OIMIndex {
   constructor(options = {}) {
-    this.emitter = new OIMEventEmitter();
-    this.comparePks = options.comparePks;
-    this.store = options.store ?? new OIMIndexStoreMapDrivenSetBased();
-  }
-  /**
-   * Get primary keys for multiple index keys
-   */
-  getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+    super(
+      options.store ?? new OIMIndexStoreMapDrivenSetBased(),
+      options.comparePks
+    );
   }
-  /**
-   * @deprecated Use getPksByKey instead
-   * Get primary keys for a specific index key
-   */
-  getPks(key) {
-    return this.getPksByKey(key);
+  getBucketSize(bucket) {
+    return bucket.size;
   }
-  /**
-   * Get primary keys for a specific index key
-   */
   getPksByKey(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet : /* @__PURE__ */ new Set();
-  }
-  /**
-   * Check if an index key exists
-   */
-  hasKey(key) {
-    return this.store.getOneByKey(key) !== void 0;
-  }
-  /**
-   * Get all index keys
-   */
-  getKeys() {
-    return this.store.getAllKeys();
-  }
-  /**
-   * Get the number of primary keys for a specific index key
-   */
-  getKeySize(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet.size : 0;
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? this.slotsToPks(slotsSet) : /* @__PURE__ */ new Set();
   }
-  /**
-   * Get total number of index keys
-   */
-  get size() {
-    return this.store.countAll();
+  getPksByKeys(keys) {
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
   }
-  /**
-   * Check if the index is empty
-   */
-  get isEmpty() {
-    return this.store.countAll() === 0;
+  getSlotsByKey(key) {
+    return this.store.getOneByKey(key) ?? /* @__PURE__ */ new Set();
   }
-  /**
-   * Get performance metrics for monitoring and debugging
-   */
-  getMetrics() {
-    let totalPks = 0;
-    let maxBucketSize = 0;
-    let minBucketSize = Infinity;
-    const allPks = this.store.getAll();
-    for (const pksSet of allPks.values()) {
-      totalPks += pksSet.size;
-      maxBucketSize = Math.max(maxBucketSize, pksSet.size);
-      minBucketSize = Math.min(minBucketSize, pksSet.size);
-    }
-    return {
-      totalKeys: allPks.size,
-      totalPks,
-      averagePksPerKey: allPks.size > 0 ? totalPks / allPks.size : 0,
-      maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
-      minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
-    };
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
-  /**
-   * Clean up event listeners when index is no longer needed
-   */
-  destroy() {
-    this.emitter.offAll();
-    this.store.clear();
+  slotsToPks(slots) {
+    const pks = /* @__PURE__ */ new Set();
+    for (const slot of slots) pks.add(slot.pk);
+    return pks;
   }
-  /**
-   * Set primary keys for a specific index key with optional comparison.
-   * If comparator is provided and returns true (no changes), skip the update.
-   */
-  setPksWithComparison(key, newPks) {
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksSet = this.store.getOneByKey(key);
-      if (existingPksSet && existingPksSet.size === newPks.size) {
-        const existingPksArray = existingPksSet.size > 0 ? [...existingPksSet] : [];
-        const newPksArray = newPks.size > 0 ? [...newPks] : [];
-        if (this.comparePks(existingPksArray, newPksArray)) {
+      const existingSlotsSet = this.store.getOneByKey(key);
+      if (existingSlotsSet && existingSlotsSet.size === newSlots.size) {
+        if (this.comparePks(
+          Array.from(this.slotsToPks(existingSlotsSet)),
+          Array.from(this.slotsToPks(newSlots))
+        )) {
           return false;
         }
-      } else if (!existingPksSet && newPks.size === 0) {
+      } else if (!existingSlotsSet && newSlots.size === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
-  /**
-   * Emit update event with changed keys
-   */
-  emitUpdate(keys) {
-    this.emitter.emit(0 /* UPDATE */, { keys });
-  }
-  /**
-   * Emit update event for a single key (fast-path override point).
-   */
-  emitUpdateOne(key) {
-    this.emitUpdate([key]);
-  }
 };
 
 // src/core/OIMIndexStoreMapDrivenArrayBased.ts
 var OIMIndexStoreMapDrivenArrayBased = class extends OIMIndexStoreArrayBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexArrayBased.ts
-var OIMIndexArrayBased = class {
+var OIMIndexArrayBased = class extends OIMIndex {
   constructor(options = {}) {
-    this.emitter = new OIMEventEmitter();
-    this.comparePks = options.comparePks;
-    this.store = options.store ?? new OIMIndexStoreMapDrivenArrayBased();
+    super(
+      options.store ?? new OIMIndexStoreMapDrivenArrayBased(),
+      options.comparePks
+    );
   }
-  /**
-   * Get primary keys for multiple index keys
-   */
-  getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+  getBucketSize(bucket) {
+    return bucket.length;
   }
-  /**
-   * Get primary keys for a specific index key
-   */
   getPksByKey(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray : [];
-  }
-  /**
-   * Check if an index key exists
-   */
-  hasKey(key) {
-    return this.store.getOneByKey(key) !== void 0;
-  }
-  /**
-   * Get all index keys
-   */
-  getKeys() {
-    return this.store.getAllKeys();
-  }
-  /**
-   * Get the number of primary keys for a specific index key
-   */
-  getKeySize(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray.length : 0;
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? this.slotsToPks(slotsArray) : [];
   }
-  /**
-   * Get total number of index keys
-   */
-  get size() {
-    return this.store.countAll();
+  getPksByKeys(keys) {
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
   }
-  /**
-   * Check if the index is empty
-   */
-  get isEmpty() {
-    return this.store.countAll() === 0;
+  getSlotsByKey(key) {
+    return this.store.getOneByKey(key) ?? [];
   }
-  /**
-   * Get performance metrics for monitoring and debugging
-   */
-  getMetrics() {
-    let totalPks = 0;
-    let maxBucketSize = 0;
-    let minBucketSize = Infinity;
-    const allPks = this.store.getAll();
-    for (const pksArray of allPks.values()) {
-      totalPks += pksArray.length;
-      maxBucketSize = Math.max(maxBucketSize, pksArray.length);
-      minBucketSize = Math.min(minBucketSize, pksArray.length);
-    }
-    return {
-      totalKeys: allPks.size,
-      totalPks,
-      averagePksPerKey: allPks.size > 0 ? totalPks / allPks.size : 0,
-      maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
-      minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
-    };
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
-  /**
-   * Clean up event listeners when index is no longer needed
-   */
-  destroy() {
-    this.emitter.offAll();
-    this.store.clear();
+  slotsToPks(slots) {
+    const pks = [];
+    pks.length = slots.length;
+    for (let i = 0; i < slots.length; i++) pks[i] = slots[i].pk;
+    return pks;
   }
-  /**
-   * Set primary keys for a specific index key with optional comparison.
-   * If comparator is provided and returns true (no changes), skip the update.
-   */
-  setPksWithComparison(key, newPks) {
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksArray = this.store.getOneByKey(key);
-      if (existingPksArray && existingPksArray.length === newPks.length) {
-        if (this.comparePks(existingPksArray, newPks)) {
+      const existingSlotsArray = this.store.getOneByKey(key);
+      if (existingSlotsArray && existingSlotsArray.length === newSlots.length) {
+        if (this.comparePks(
+          this.slotsToPks(existingSlotsArray),
+          this.slotsToPks(newSlots)
+        )) {
           return false;
         }
-      } else if (!existingPksArray && newPks.length === 0) {
+      } else if (!existingSlotsArray && newSlots.length === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
-  /**
-   * Emit update event with changed keys
-   */
-  emitUpdate(keys) {
-    this.emitter.emit(0 /* UPDATE */, { keys });
-  }
-  /**
-   * Emit update event for a single key (fast-path override point).
-   */
-  emitUpdateOne(key) {
-    this.emitUpdate([key]);
-  }
 };
 
-// src/enum/EOIMEventQueueEventType.ts
+// src/enums/EOIMEventQueueEventType.ts
 var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
@@ -719,17 +668,17 @@ var OIMUpdateEventEmitter = class {
   }
 };
 
-// src/abstract/OIMReactiveIndexSetBased.ts
-var OIMReactiveIndexSetBased = class {
+// src/abstract/OIMReactiveIndex.ts
+var OIMReactiveIndex = class {
   constructor(queue, createIndex) {
     this.updateEmitter = new OIMUpdateEventEmitter(queue);
     this.index = createIndex(this.updateEmitter);
   }
-  getPksByKey(key) {
-    return this.index.getPksByKey(key);
+  getEntitiesByKey(key) {
+    return this.index.getEntitiesByKey(key);
   }
-  getPksByKeys(keys) {
-    return this.index.getPksByKeys(keys);
+  getEntitiesByKeys(keys) {
+    return this.index.getEntitiesByKeys(keys);
   }
   hasKey(key) {
     return this.index.hasKey(key);
@@ -776,11 +725,10 @@ var OIMReactiveIndexSetBased = class {
   }
 };
 
-// src/abstract/OIMReactiveIndexArrayBased.ts
-var OIMReactiveIndexArrayBased = class {
+// src/abstract/OIMReactiveIndexSetBased.ts
+var OIMReactiveIndexSetBased = class extends OIMReactiveIndex {
   constructor(queue, createIndex) {
-    this.updateEmitter = new OIMUpdateEventEmitter(queue);
-    this.index = createIndex(this.updateEmitter);
+    super(queue, createIndex);
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -788,59 +736,41 @@ var OIMReactiveIndexArrayBased = class {
   getPksByKeys(keys) {
     return this.index.getPksByKeys(keys);
   }
-  hasKey(key) {
-    return this.index.hasKey(key);
-  }
-  getKeys() {
-    return this.index.getKeys();
-  }
-  getKeySize(key) {
-    return this.index.getKeySize(key);
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
   }
-  get size() {
-    return this.index.size;
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
   }
-  get isEmpty() {
-    return this.index.isEmpty;
+};
+
+// src/abstract/OIMReactiveIndexArrayBased.ts
+var OIMReactiveIndexArrayBased = class extends OIMReactiveIndex {
+  constructor(queue, createIndex) {
+    super(queue, createIndex);
   }
-  getMetrics() {
-    return this.index.getMetrics();
+  getPksByKey(key) {
+    return this.index.getPksByKey(key);
   }
-  subscribeOnKey(key, handler) {
-    return this.updateEmitter.subscribeOnKey(key, handler);
+  getPksByKeys(keys) {
+    return this.index.getPksByKeys(keys);
   }
-  subscribeOnKeys(keys, handler) {
-    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
   }
-  unsubscribeFromKey(key, handler) {
-    this.updateEmitter.unsubscribeFromKey(key, handler);
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
   }
-  unsubscribeFromKeys(keys, handler) {
-    this.updateEmitter.unsubscribeFromKeys(keys, handler);
-  }
-  hasSubscriptions() {
-    return this.updateEmitter.hasSubscriptions();
-  }
-  getHandlerCount(key) {
-    return this.updateEmitter.getHandlerCount(key);
-  }
-  getSubscriptionMetrics() {
-    return this.updateEmitter.getMetrics();
-  }
-  destroy() {
-    this.updateEmitter.destroy();
-    this.index.destroy();
-  }
-};
-
-// src/abstract/OIMObjectStore.ts
-var OIMObjectStore = class {
-};
-
-// src/core/OIMPkSelectorFactory.ts
-var OIMPkSelectorFactory = class {
-  createIdSelector() {
-    return (entity) => entity.id;
+};
+
+// src/abstract/OIMObjectStore.ts
+var OIMObjectStore = class {
+};
+
+// src/core/OIMPkSelectorFactory.ts
+var OIMPkSelectorFactory = class {
+  createIdSelector() {
+    return (entity) => entity.id;
   }
 };
 
@@ -848,26 +778,58 @@ var OIMPkSelectorFactory = class {
 var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   constructor() {
     super(...arguments);
-    this.entities = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
   setOneByPk(pk, entity) {
-    this.entities.set(pk, entity);
+    const slot = this.slots.get(pk);
+    if (slot) {
+      slot.item = entity;
+      return slot;
+    } else {
+      const nextSlot = { pk, item: entity };
+      this.slots.set(pk, nextSlot);
+      return nextSlot;
+    }
   }
   setManyByPks(pks, entities) {
+    const slots = [];
+    slots.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      slots[i] = this.setOneByPk(pks[i], entities[i]);
+    }
+    return slots;
+  }
+  getSlotByPk(pk) {
+    return this.slots.get(pk);
+  }
+  getSlotsByPks(pks) {
+    const result = [];
+    result.length = pks.length;
+    let writeIndex = 0;
     for (let i = 0; i < pks.length; i++) {
-      this.entities.set(pks[i], entities[i]);
+      const slot = this.slots.get(pks[i]);
+      if (slot !== void 0) {
+        result[writeIndex++] = slot;
+      }
     }
+    result.length = writeIndex;
+    return result;
+  }
+  getAllSlots() {
+    return Array.from(this.slots.values());
   }
   removeOneByPk(pk) {
-    this.entities.delete(pk);
+    const slot = this.slots.get(pk);
+    if (slot) slot.item = void 0;
+    this.slots.delete(pk);
   }
   removeManyByPks(pks) {
     for (const pk of pks) {
-      this.entities.delete(pk);
+      this.removeOneByPk(pk);
     }
   }
   getOneByPk(pk) {
-    return this.entities.get(pk);
+    return this.slots.get(pk)?.item;
   }
   getManyByPks(pks) {
     const result = [];
@@ -883,16 +845,23 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
     return result;
   }
   getAll() {
-    return Array.from(this.entities.values());
+    const result = [];
+    for (const slot of this.slots.values()) {
+      if (slot.item !== void 0) result.push(slot.item);
+    }
+    return result;
   }
   countAll() {
-    return this.entities.size;
+    return this.slots.size;
   }
   clear() {
-    this.entities.clear();
+    for (const slot of this.slots.values()) {
+      slot.item = void 0;
+    }
+    this.slots.clear();
   }
   getAllPks() {
-    return Array.from(this.entities.keys());
+    return Array.from(this.slots.keys());
   }
   destroy() {
     this.clear();
@@ -908,7 +877,7 @@ var OIMEntityUpdaterFactory = class {
   }
 };
 
-// src/enum/EOIMCollectionEventType.ts
+// src/enums/EOIMCollectionEventType.ts
 var EOIMCollectionEventType = /* @__PURE__ */ ((EOIMCollectionEventType2) => {
   EOIMCollectionEventType2[EOIMCollectionEventType2["UPDATE"] = 0] = "UPDATE";
   return EOIMCollectionEventType2;
@@ -928,19 +897,33 @@ var OIMCollection = class {
   getManyByPks(pks) {
     return this.store.getManyByPks(pks);
   }
+  getSlotByPk(pk) {
+    return this.store.getSlotByPk(pk);
+  }
+  getSlotsByPks(pks) {
+    return this.store.getSlotsByPks(pks);
+  }
+  getAllSlots() {
+    return this.store.getAllSlots();
+  }
   upsertOneByPk(pk, entity) {
-    this.upsertOneWithoutNotificationsByPk(pk, entity);
+    const slot = this.upsertOneWithoutNotificationsByPk(pk, entity);
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    return slot;
   }
   upsertOne(entity) {
-    const pk = this.upsertOneWithoutNotifications(entity);
-    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+    const slot = this.upsertOneWithoutNotifications(entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [slot.pk] });
+    return slot;
   }
   upsertMany(entities) {
-    const pks = entities.map(
+    if (entities.length === 0) return [];
+    const slots = entities.map(
       (entity) => this.upsertOneWithoutNotifications(entity)
     );
+    const pks = slots.map((slot) => slot.pk);
     this.emitter.emit(0 /* UPDATE */, { pks });
+    return slots;
   }
   removeOne(entity) {
     const pk = this.selectPk(entity);
@@ -948,6 +931,7 @@ var OIMCollection = class {
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
   }
   removeMany(entities) {
+    if (entities.length === 0) return;
     const pks = entities.map(this.selectPk);
     this.store.removeManyByPks(pks);
     this.emitter.emit(0 /* UPDATE */, { pks });
@@ -957,6 +941,7 @@ var OIMCollection = class {
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
   }
   removeManyByPks(pks) {
+    if (pks.length === 0) return;
     this.store.removeManyByPks(pks);
     this.emitter.emit(0 /* UPDATE */, { pks });
   }
@@ -975,8 +960,7 @@ var OIMCollection = class {
   }
   upsertOneWithoutNotifications(entity) {
     const pk = this.selectPk(entity);
-    this.upsertOneWithoutNotificationsByPk(pk, entity);
-    return pk;
+    return this.upsertOneWithoutNotificationsByPk(pk, entity);
   }
   upsertOneWithoutNotificationsByPk(pk, entity) {
     if (!pk) {
@@ -986,12 +970,12 @@ var OIMCollection = class {
     }
     const existingEntity = this.store.getOneByPk(pk);
     if (existingEntity) {
-      this.store.setOneByPk(
+      return this.store.setOneByPk(
         pk,
         this.updateEntity(entity, existingEntity)
       );
     } else {
-      this.store.setOneByPk(pk, entity);
+      return this.store.setOneByPk(pk, entity);
     }
   }
   destroy() {
@@ -1052,46 +1036,61 @@ var OIMReactiveCollection = class extends OIMCollection {
     };
   }
   upsertOneByPk(pk, entity) {
-    this.upsertOneWithoutNotificationsByPk(pk, entity);
+    const slot = this.upsertOneWithoutNotificationsByPk(pk, entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
+    return slot;
   }
   upsertOne(entity) {
-    const pk = this.upsertOneWithoutNotifications(entity);
-    this.updateEmitter.markUpdatedKey(pk);
-    this.trackAnyUpdatePk(pk);
+    const slot = this.upsertOneWithoutNotifications(entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [slot.pk] });
+    this.updateEmitter.markUpdatedKey(slot.pk);
+    this.trackAnyUpdatePk(slot.pk);
+    return slot;
   }
   upsertMany(entities) {
-    const pks = entities.map(
+    if (entities.length === 0) return [];
+    const slots = entities.map(
       (entity) => this.upsertOneWithoutNotifications(entity)
     );
+    const pks = slots.map((slot) => slot.pk);
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
+    return slots;
   }
   removeOne(entity) {
     const pk = this.selectPk(entity);
     this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   removeMany(entities) {
+    if (entities.length === 0) return;
     const pks = entities.map(this.selectPk);
     this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   removeOneByPk(pk) {
     this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   removeManyByPks(pks) {
+    if (pks.length === 0) return;
     this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   clear() {
     this.store.clear();
+    this.emitter.emit(0 /* UPDATE */, { pks: [] });
     this.updateEmitter.markAllUpdated();
     this.trackAnyUpdateClear();
   }
@@ -1129,193 +1128,347 @@ var OIMReactiveCollection = class extends OIMCollection {
   }
 };
 
-// src/core/OIMObjectStoreRecordDriven.ts
-var OIMObjectStoreRecordDriven = class extends OIMObjectStore {
-  constructor(initial) {
-    super();
-    this.properties = Object.assign(/* @__PURE__ */ Object.create(null), initial ?? {});
-  }
-  setProperty(key, value) {
-    this.properties[key] = value;
-  }
-  merge(draft) {
-    Object.assign(this.properties, draft);
-  }
-  delete(key) {
-    delete this.properties[key];
-  }
-  get(key) {
-    return this.properties[key];
-  }
-  getAll() {
-    return { ...this.properties };
+// src/modules/wrapper/index/OIMIndexManualOrderedArrayBased.ts
+var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
+  clear(key) {
+    if (key === void 0) {
+      const keys = this.getKeys();
+      if (keys.length > 0) {
+        this.store.clear();
+        this.emitUpdate(Array.from(keys));
+      }
+      return;
+    }
+    if (this.store.getOneByKey(key) !== void 0) {
+      this.store.removeOneByKey(key);
+      this.emitUpdate([key]);
+    }
   }
-  clear() {
-    this.properties = /* @__PURE__ */ Object.create(null);
+  pushSlot(key, slot) {
+    const list = this.getOrCreateList(key);
+    const index = list.length;
+    list.push(slot);
+    this.emitUpdate([key]);
+    return index;
   }
-  count() {
-    return Object.keys(this.properties).length;
+  insertSlotAt(key, index, slot) {
+    const list = this.getOrCreateList(key);
+    const safeIndex = Math.max(0, Math.min(index, list.length));
+    list.splice(safeIndex, 0, slot);
+    this.emitUpdate([key]);
+    return safeIndex;
   }
-  keys() {
-    return Object.keys(this.properties);
+  removeAt(key, index) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return void 0;
+    if (index < 0 || index >= list.length) return void 0;
+    const [removed] = list.splice(index, 1);
+    if (list.length === 0) {
+      this.store.removeOneByKey(key);
+    }
+    this.emitUpdate([key]);
+    return removed;
   }
-  values() {
-    return Object.values(this.properties);
+  move(key, fromIndex, toIndex) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return void 0;
+    if (fromIndex < 0 || fromIndex >= list.length) return void 0;
+    if (toIndex < 0 || toIndex >= list.length) return void 0;
+    if (fromIndex === toIndex) return list[fromIndex];
+    const [slot] = list.splice(fromIndex, 1);
+    if (slot === void 0) return void 0;
+    list.splice(toIndex, 0, slot);
+    this.emitUpdate([key]);
+    return slot;
   }
-  entries() {
-    return Object.entries(this.properties);
+  resetSlots(key, slots) {
+    if (slots.length === 0) {
+      if (this.store.getOneByKey(key) !== void 0) {
+        this.store.removeOneByKey(key);
+        this.emitUpdate([key]);
+      }
+      return;
+    }
+    this.store.setOneByKey(key, slots.slice());
+    this.emitUpdate([key]);
   }
-  destroy() {
-    this.clear();
+  getOrCreateList(key) {
+    let list = this.store.getOneByKey(key);
+    if (!list) {
+      list = [];
+      this.store.setOneByKey(key, list);
+    }
+    return list;
   }
 };
 
-// src/enum/EOIMObjectEventType.ts
-var EOIMObjectEventType = /* @__PURE__ */ ((EOIMObjectEventType2) => {
-  EOIMObjectEventType2[EOIMObjectEventType2["UPDATE"] = 0] = "UPDATE";
-  return EOIMObjectEventType2;
-})(EOIMObjectEventType || {});
-
-// src/core/OIMObject.ts
-var OIMObject = class {
+// src/modules/wrapper/index/OIMCollectionIndexManualOrderedArrayBased.ts
+var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrderedArrayBased {
   constructor(opts) {
-    this.emitter = new OIMEventEmitter();
-    this.store = opts?.store ?? new OIMObjectStoreRecordDriven();
-  }
-  setProperty(key, value) {
-    this.store.setProperty(key, value);
-    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
-  }
-  merge(draft) {
-    this.store.merge(draft);
-    this.emitter.emit(0 /* UPDATE */, {
-      keys: Object.keys(draft)
-    });
-  }
-  delete(key) {
-    this.store.delete(key);
-    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
+    super();
+    this.resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getSlotByPk(pk) : opts.resolveSlot;
   }
-  get(key) {
-    return this.store.get(key);
+  push(key, pk) {
+    return this.pushSlot(key, this.resolveRequiredSlot(pk));
   }
-  getAll() {
-    return this.store.getAll();
+  insertAt(key, index, pk) {
+    return this.insertSlotAt(key, index, this.resolveRequiredSlot(pk));
   }
-  clear() {
-    this.store.clear();
-    this.emitter.emit(0 /* UPDATE */, { keys: [] });
+  reset(key, pks) {
+    this.resetSlots(key, this.resolveSlots(pks));
   }
-  count() {
-    return this.store.count();
+  getEntitiesByKey(key) {
+    return super.getEntitiesByKey(key);
   }
-  keys() {
-    return this.store.keys();
+  getEntitiesByKeys(keys) {
+    return super.getEntitiesByKeys(keys);
   }
-  values() {
-    return this.store.values();
+  resolvePk(pk) {
+    return this.resolveRequiredSlot(pk);
   }
-  entries() {
-    return this.store.entries();
+  resolveSlots(pks) {
+    const slots = [];
+    slots.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      slots[i] = this.resolveRequiredSlot(pks[i]);
+    }
+    return slots;
   }
-  destroy() {
-    this.store.destroy();
-    this.emitter.offAll();
+  resolveRequiredSlot(pk) {
+    const slot = this.resolveSlot(pk);
+    if (!slot) {
+      throw new Error(
+        `[OIMCollectionIndexManualOrderedArrayBased]: Unable to resolve slot for PK "${String(pk)}".`
+      );
+    }
+    return slot;
   }
 };
 
-// src/core/OIMReactiveObject.ts
-var OIMReactiveObject = class extends OIMObject {
-  constructor(queue, opts) {
-    super(opts);
-    this.updateEmitter = new OIMUpdateEventEmitter(queue, "queue");
-    this.emitter.on(0 /* UPDATE */, (payload) => {
-      this.updateEmitter.markUpdatedKeys(payload.keys);
-    });
-  }
-  subscribeOnKey(key, handler) {
-    return this.updateEmitter.subscribeOnKey(key, handler);
+// src/modules/wrapper/index/OIMOrderedListCommandStream.ts
+var OIMOrderedListCommandStream = class {
+  constructor(queue, index) {
+    this.isInWrite = false;
+    this.commandsByKey = /* @__PURE__ */ new Map();
+    this.onAfterFlush = () => {
+      this.commandsByKey.clear();
+    };
+    this.onIndexUpdate = (payload) => {
+      if (this.isInWrite) return;
+      if (payload.keys.length === 0) return;
+      for (let i = 0; i < payload.keys.length; i++) {
+        const key = payload.keys[i];
+        this.appendSetCommand(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
+    );
   }
-  subscribeOnKeys(keys, handler) {
-    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  getPksByKey(key) {
+    return this.index.getPksByKey(key);
   }
-  unsubscribeFromKey(key, handler) {
-    this.updateEmitter.unsubscribeFromKey(key, handler);
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(
+      key
+    );
   }
-  unsubscribeFromKeys(keys, handler) {
-    this.updateEmitter.unsubscribeFromKeys(keys, handler);
+  getEntitiesByKey(key) {
+    return this.index.getEntitiesByKey(key);
   }
-  hasSubscriptions() {
-    return this.updateEmitter.hasSubscriptions();
+  hasKey(key) {
+    return this.index.hasKey(key);
   }
-  getHandlerCount(key) {
-    return this.updateEmitter.getHandlerCount(key);
+  getKeys() {
+    return this.index.getKeys();
   }
-  getMetrics() {
-    return this.updateEmitter.getMetrics();
+  pushSlot(key, slot) {
+    this.withWrite(() => {
+      const index = this.index.pushSlot(key, slot);
+      this.appendCommand(key, {
+        type: "insert",
+        pk: slot.pk,
+        slot,
+        index
+      });
+    });
   }
-  destroy() {
-    this.updateEmitter.destroy();
-    super.destroy();
+  insertSlotAt(key, index, slot) {
+    this.withWrite(() => {
+      const safeIndex = this.index.insertSlotAt(key, index, slot);
+      this.appendCommand(key, {
+        type: "insert",
+        pk: slot.pk,
+        slot,
+        index: safeIndex
+      });
+    });
   }
-};
-
-// src/core/OIMIndexManualSetBased.ts
-var OIMIndexManualSetBased = class extends OIMIndexSetBased {
-  constructor(options = {}) {
-    super(options);
+  removeAt(key, index) {
+    this.withWrite(() => {
+      const slot = this.index.removeAt(key, index);
+      if (slot === void 0) return;
+      this.appendCommand(key, {
+        type: "remove",
+        pk: slot.pk,
+        slot,
+        index
+      });
+    });
   }
-  /**
-   * Set primary keys for a specific index key, replacing any existing values.
-   * Uses optional comparator to skip updates if PKs haven't actually changed.
-   */
-  setPks(key, pks) {
-    const hasChanges = this.setPksWithComparison(key, new Set(pks));
-    if (hasChanges) {
-      this.emitUpdateOne(key);
-    }
+  move(key, fromIndex, toIndex) {
+    this.withWrite(() => {
+      const slot = this.index.move(key, fromIndex, toIndex);
+      if (slot === void 0) return;
+      this.appendCommand(key, {
+        type: "move",
+        pk: slot.pk,
+        slot,
+        fromIndex,
+        toIndex
+      });
+    });
   }
-  /**
-   * Add primary keys to a specific index key
-   */
-  addPks(key, pks) {
-    if (pks.length === 0) return;
-    let pksSet = this.store.getOneByKey(key);
-    if (!pksSet) {
-      pksSet = /* @__PURE__ */ new Set();
-      this.store.setOneByKey(key, pksSet);
+  setSlots(key, slots) {
+    this.withWrite(() => {
+      this.index.resetSlots(key, slots);
+      this.appendSetCommand(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();
+  }
+  clear(key) {
+    if (key === void 0) {
+      this.index.destroy();
+      this.commandsByKey.clear();
+      return;
     }
-    let hasChanges = false;
-    for (const pk of pks) {
-      if (!pksSet.has(pk)) {
-        pksSet.add(pk);
-        hasChanges = true;
-      }
+    this.index.clear(key);
+    this.commandsByKey.delete(key);
+  }
+  destroy() {
+    this.commandsEventEmitter.destroy();
+    this.unsubscribeAfterFlush();
+    this.unsubscribeFromIndexEmitter();
+    this.clear();
+  }
+  withWrite(fn) {
+    if (this.isInWrite) {
+      fn();
+      return;
     }
-    if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
-      this.emitUpdateOne(key);
+    this.isInWrite = true;
+    try {
+      fn();
+    } finally {
+      this.isInWrite = false;
     }
   }
-  /**
-   * Remove primary keys from a specific index key
-   */
-  removePks(key, pks) {
-    if (pks.length === 0) return;
-    const pksSet = this.store.getOneByKey(key);
-    if (!pksSet) return;
-    let hasChanges = false;
-    for (const pk of pks) {
-      if (pksSet.delete(pk)) {
-        hasChanges = true;
-      }
+  appendCommand(key, cmd) {
+    let cmds = this.commandsByKey.get(key);
+    if (!cmds) {
+      cmds = [];
+      this.commandsByKey.set(key, cmds);
     }
-    if (pksSet.size === 0) {
-      this.store.removeOneByKey(key);
-      hasChanges = true;
-    } else if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
+    if (cmd.type === "set") {
+      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 {
+      cmds.push(cmd);
     }
+    this.commandsEventEmitter.markUpdatedKeys([key]);
+  }
+  appendSetCommand(key, slots) {
+    this.appendCommand(key, this.createSetCommand(slots));
+  }
+  createSetCommand(slots) {
+    return {
+      type: "set",
+      pks: slots.map((slot) => slot.pk),
+      slots
+    };
+  }
+};
+
+// src/modules/wrapper/index/OIMCollectionOrderedListCommandStream.ts
+var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandStream {
+  constructor(queue, opts) {
+    const index = opts.index ?? new OIMCollectionIndexManualOrderedArrayBased(
+      opts.collection !== void 0 ? { collection: opts.collection } : { resolveSlot: opts.resolveSlot }
+    );
+    super(queue, index);
+    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",
+        pk,
+        slot,
+        index
+      });
+    });
+  }
+  insertAt(key, index, pk) {
+    this.withWrite(() => {
+      const slot = this.resolvePk(pk);
+      const safeIndex = this.index.insertSlotAt(key, index, slot);
+      this.appendCommand(key, {
+        type: "insert",
+        pk,
+        slot,
+        index: safeIndex
+      });
+    });
+  }
+  set(key, pks) {
+    this.withWrite(() => {
+      const slots = pks.map((pk) => this.resolvePk(pk));
+      this.index.resetSlots(key, slots);
+      this.appendSetCommand(key, slots);
+    });
+  }
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(
+      key
+    );
+  }
+  getEntitiesByKey(key) {
+    return this.index.getEntitiesByKey(key);
+  }
+  resolvePk(pk) {
+    return this.index.resolvePk(pk);
+  }
+};
+
+// src/core/OIMIndexManualArrayBased.ts
+var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
+  constructor(options = {}) {
+    super(options);
+  }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, slots);
     if (hasChanges) {
       this.emitUpdateOne(key);
     }
@@ -1339,8 +1492,8 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
   }
 };
 
-// src/core/OIMReactiveIndexManualSetBased.ts
-var OIMIndexManualSetBasedReactive = class extends OIMIndexManualSetBased {
+// src/core/OIMReactiveIndexManualArrayBased.ts
+var OIMIndexManualArrayBasedReactive = class extends OIMIndexManualArrayBased {
   constructor(updateEmitter, opts) {
     super(opts);
     this.updateEmitter = updateEmitter;
@@ -1352,83 +1505,93 @@ var OIMIndexManualSetBasedReactive = class extends OIMIndexManualSetBased {
     this.updateEmitter.markUpdatedKey(key);
   }
 };
-var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
+var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased {
   constructor(queue, opts) {
     super(queue, (updateEmitter) => {
-      return new OIMIndexManualSetBasedReactive(
+      return new OIMIndexManualArrayBasedReactive(
         updateEmitter,
         opts?.indexOptions
       );
     });
   }
-  setPks(key, pks) {
-    this.index.setPks(key, pks);
-  }
-  addPks(key, pks) {
-    this.index.addPks(key, pks);
-  }
-  removePks(key, pks) {
-    this.index.removePks(key, pks);
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
   }
   clear(key) {
     this.index.clear(key);
   }
 };
 
-// src/core/OIMIndexManualArrayBased.ts
-var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
-  constructor(options = {}) {
-    super(options);
+// src/core/OIMReactiveCollectionIndexManualArrayBased.ts
+var OIMReactiveCollectionIndexManualArrayBased = class extends OIMReactiveIndexManualArrayBased {
+  constructor(queue, opts) {
+    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getSlotByPk(pk) : opts.resolveSlot;
+    super(queue, {
+      indexOptions: opts.indexOptions
+    });
+    this.resolveSlot = resolveSlot;
   }
-  /**
-   * Set primary keys for a specific index key, replacing any existing values.
-   * Uses optional comparator to skip updates if PKs haven't actually changed.
-   */
   setPks(key, pks) {
-    const hasChanges = this.setPksWithComparison(key, pks);
-    if (hasChanges) {
-      this.emitUpdateOne(key);
-    }
+    this.setSlots(key, this.resolveSlots(pks));
   }
-  /**
-   * Add primary keys to a specific index key
-   */
   addPks(key, pks) {
     if (pks.length === 0) return;
-    let pksArray = this.store.getOneByKey(key);
-    if (!pksArray) {
-      pksArray = [];
-      this.store.setOneByKey(key, pksArray);
-    }
-    const pksSet = new Set(pksArray);
+    const existingSlots = this.index.getSlotsByKey(key);
+    const existingPks = new Set(existingSlots.map((slot) => slot.pk));
+    const nextSlots = existingSlots.slice();
     let hasChanges = false;
     for (const pk of pks) {
-      if (!pksSet.has(pk)) {
-        pksSet.add(pk);
-        hasChanges = true;
-      }
-    }
-    if (hasChanges) {
-      this.store.setOneByKey(key, Array.from(pksSet));
-      this.emitUpdateOne(key);
+      if (existingPks.has(pk)) continue;
+      nextSlots.push(this.resolveRequiredSlot(pk));
+      existingPks.add(pk);
+      hasChanges = true;
     }
+    if (hasChanges) this.setSlots(key, nextSlots);
   }
-  /**
-   * Remove primary keys from a specific index key
-   */
   removePks(key, pks) {
     if (pks.length === 0) return;
-    const pksArray = this.store.getOneByKey(key);
-    if (!pksArray) return;
-    const pksSet = new Set(pks);
-    const filtered = pksArray.filter((pk) => !pksSet.has(pk));
-    const hasChanges = filtered.length !== pksArray.length;
+    const pksToRemove = new Set(pks);
+    const existingSlots = this.index.getSlotsByKey(key);
+    const nextSlots = existingSlots.filter(
+      (slot) => !pksToRemove.has(slot.pk)
+    );
+    if (nextSlots.length === existingSlots.length) return;
+    if (nextSlots.length === 0) this.clear(key);
+    else this.setSlots(key, nextSlots);
+  }
+  getEntitiesByKey(key) {
+    return super.getEntitiesByKey(key);
+  }
+  getEntitiesByKeys(keys) {
+    return super.getEntitiesByKeys(keys);
+  }
+  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) {
+      throw new Error(
+        `[OIMReactiveCollectionIndexManualArrayBased]: Unable to resolve slot for PK "${String(pk)}".`
+      );
+    }
+    return slot;
+  }
+};
+
+// src/core/OIMIndexManualSetBased.ts
+var OIMIndexManualSetBased = class extends OIMIndexSetBased {
+  constructor(options = {}) {
+    super(options);
+  }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, new Set(slots));
     if (hasChanges) {
-      if (filtered.length === 0) {
-        this.store.removeOneByKey(key);
-      } else {
-        this.store.setOneByKey(key, filtered);
-      }
       this.emitUpdateOne(key);
     }
   }
@@ -1451,8 +1614,8 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
   }
 };
 
-// src/core/OIMReactiveIndexManualArrayBased.ts
-var OIMIndexManualArrayBasedReactive = class extends OIMIndexManualArrayBased {
+// src/core/OIMReactiveIndexManualSetBased.ts
+var OIMIndexManualSetBasedReactive = class extends OIMIndexManualSetBased {
   constructor(updateEmitter, opts) {
     super(opts);
     this.updateEmitter = updateEmitter;
@@ -1464,303 +1627,1256 @@ var OIMIndexManualArrayBasedReactive = class extends OIMIndexManualArrayBased {
     this.updateEmitter.markUpdatedKey(key);
   }
 };
-var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased {
+var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
   constructor(queue, opts) {
     super(queue, (updateEmitter) => {
-      return new OIMIndexManualArrayBasedReactive(
+      return new OIMIndexManualSetBasedReactive(
         updateEmitter,
         opts?.indexOptions
       );
     });
   }
-  setPks(key, pks) {
-    this.index.setPks(key, pks);
-  }
-  addPks(key, pks) {
-    this.index.addPks(key, pks);
-  }
-  removePks(key, pks) {
-    this.index.removePks(key, pks);
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
   }
   clear(key) {
     this.index.clear(key);
   }
 };
 
-// src/core/OIMRICollection.ts
-var OIMRICollection = class extends OIMReactiveCollection {
+// src/core/OIMReactiveCollectionIndexManualSetBased.ts
+var OIMReactiveCollectionIndexManualSetBased = class extends OIMReactiveIndexManualSetBased {
   constructor(queue, opts) {
-    super(queue, opts.collectionOpts);
-    this.indexes = opts.indexes || {};
-  }
-};
-
-// src/core/OIMObjectStoreMapDriven.ts
-var OIMObjectStoreMapDriven = class extends OIMObjectStore {
-  constructor() {
-    super(...arguments);
-    this.properties = /* @__PURE__ */ new Map();
+    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getSlotByPk(pk) : opts.resolveSlot;
+    super(queue, {
+      indexOptions: opts.indexOptions
+    });
+    this.resolveSlot = resolveSlot;
   }
-  setProperty(key, value) {
-    this.properties.set(key, value);
+  setPks(key, pks) {
+    this.setSlots(key, this.resolveSlots(pks));
   }
-  merge(draft) {
-    for (const key in draft) {
-      if (!Object.prototype.hasOwnProperty.call(draft, key)) continue;
-      this.properties.set(
-        key,
-        draft[key]
-      );
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    const existingSlots = this.index.getSlotsByKey(key);
+    const existingPks = this.index.getPksByKey(key);
+    const nextSlots = new Set(existingSlots);
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (existingPks.has(pk)) continue;
+      const slot = this.resolveRequiredSlot(pk);
+      nextSlots.add(slot);
+      existingPks.add(pk);
+      hasChanges = true;
     }
+    if (hasChanges) this.setSlots(key, nextSlots);
   }
-  delete(key) {
-    this.properties.delete(key);
-  }
-  get(key) {
-    return this.properties.get(key);
-  }
-  getAll() {
-    return Object.fromEntries(this.properties.entries());
-  }
-  clear() {
-    this.properties.clear();
-  }
-  count() {
-    return this.properties.size;
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const pksToRemove = new Set(pks);
+    const existingSlots = this.index.getSlotsByKey(key);
+    const nextSlots = /* @__PURE__ */ new Set();
+    let hasChanges = false;
+    for (const slot of existingSlots) {
+      if (pksToRemove.has(slot.pk)) {
+        hasChanges = true;
+      } else {
+        nextSlots.add(slot);
+      }
+    }
+    if (!hasChanges) return;
+    if (nextSlots.size === 0) this.clear(key);
+    else this.setSlots(key, nextSlots);
   }
-  keys() {
-    return Array.from(this.properties.keys());
+  getEntitiesByKey(key) {
+    return super.getEntitiesByKey(key);
   }
-  values() {
-    return Array.from(this.properties.values());
+  getEntitiesByKeys(keys) {
+    return super.getEntitiesByKeys(keys);
   }
-  entries() {
-    return Array.from(this.properties.entries());
+  resolveSlots(pks) {
+    const slots = /* @__PURE__ */ new Set();
+    for (const pk of pks) slots.add(this.resolveRequiredSlot(pk));
+    return slots;
   }
-  destroy() {
-    this.properties.clear();
+  resolveRequiredSlot(pk) {
+    const slot = this.resolveSlot(pk);
+    if (!slot) {
+      throw new Error(
+        `[OIMReactiveCollectionIndexManualSetBased]: Unable to resolve slot for PK "${String(pk)}".`
+      );
+    }
+    return slot;
   }
 };
 
-// src/core/OIMComparatorFactory.ts
-var OIMComparatorFactory = class {
-  createShallowComparator() {
-    return (a, b) => {
-      if (a === b) return false;
-      const ka = Object.keys(a);
-      const kb = Object.keys(b);
-      if (ka.length !== kb.length) return true;
-      for (let i = 0; i < ka.length; i++) {
-        const k = ka[i];
-        if (b[k] !== a[k])
-          return true;
+// src/core/OIMDerivedCollectionIndexSetBased.ts
+var OIMDerivedCollectionIndexSetBased = class extends OIMReactiveCollectionIndexManualSetBased {
+  constructor(queue, collection, opts) {
+    super(queue, {
+      collection,
+      indexOptions: opts.indexOptions
+    });
+    this.keysByPk = /* @__PURE__ */ new Map();
+    this.onCollectionUpdate = (pks) => {
+      if (pks.length === 0) {
+        this.rebuildFromCollection();
+        return;
+      }
+      for (const pk of pks) {
+        this.syncPk(pk);
       }
-      return false;
     };
+    this.collection = collection;
+    this.selectIndexKeys = opts.selectIndexKeys;
+    this.unsubscribeFromCollection = collection.emitter.on(
+      0 /* UPDATE */,
+      (payload) => this.onCollectionUpdate(payload.pks)
+    );
+    if (opts.buildInitial !== false) {
+      this.rebuildFromCollection();
+    }
+  }
+  rebuildFromCollection() {
+    this.keysByPk.clear();
+    super.clear();
+    const slotsByKey = /* @__PURE__ */ new Map();
+    const slots = this.collection.getAllSlots();
+    for (const slot of slots) {
+      if (slot.item === void 0) continue;
+      const keys = this.normalizeKeys(this.selectIndexKeys(slot.item));
+      if (keys.length === 0) continue;
+      this.keysByPk.set(slot.pk, new Set(keys));
+      for (const key of keys) {
+        let slotsForKey = slotsByKey.get(key);
+        if (!slotsForKey) {
+          slotsForKey = /* @__PURE__ */ new Set();
+          slotsByKey.set(key, slotsForKey);
+        }
+        slotsForKey.add(slot);
+      }
+    }
+    for (const [key, keySlots] of slotsByKey) {
+      this.setSlots(key, keySlots);
+    }
   }
-};
-
-// src/core/OIMEventQueue.ts
-var OIMEventQueue = class {
-  constructor(options = {}) {
-    this.emitter = new OIMEventEmitter();
-    this.tasks = /* @__PURE__ */ new Set();
-    this.isFlushing = false;
-    this.scheduler = options.scheduler;
-    if (this.scheduler) {
-      this.flushBound = () => this.flush();
-      this.scheduler.on(
-        0 /* FLUSH */,
-        this.flushBound
-      );
+  clear(key) {
+    if (key === void 0) {
+      this.keysByPk.clear();
+    } else {
+      for (const keys of this.keysByPk.values()) {
+        keys.delete(key);
+      }
     }
+    super.clear(key);
   }
-  /**
-   * Enqueue a one-shot task to be executed on the next flush.
-   * Returns a dequeue function that can be called to cancel the task before it runs.
-   */
-  enqueue(fn) {
-    let isActive = true;
-    const task = () => {
-      if (!isActive) return;
-      fn();
-    };
-    this.tasks.add(task);
-    this.ensureScheduled();
-    return () => {
-      if (!isActive) return;
-      isActive = false;
-      this.tasks.delete(task);
-    };
+  destroy() {
+    this.unsubscribeFromCollection();
+    this.keysByPk.clear();
+    super.destroy();
   }
-  get isInFlush() {
-    return this.isFlushing;
+  syncPk(pk) {
+    const prevKeys = this.keysByPk.get(pk) ?? /* @__PURE__ */ new Set();
+    const slot = this.collection.getSlotByPk(pk);
+    const entity = slot?.item;
+    const nextKeys = entity === void 0 ? /* @__PURE__ */ new Set() : new Set(this.normalizeKeys(this.selectIndexKeys(entity)));
+    for (const key of prevKeys) {
+      if (!nextKeys.has(key)) {
+        this.removePks(key, [pk]);
+      }
+    }
+    if (entity !== void 0) {
+      for (const key of nextKeys) {
+        if (!prevKeys.has(key)) {
+          this.addPks(key, [pk]);
+        }
+      }
+    }
+    if (nextKeys.size === 0) {
+      this.keysByPk.delete(pk);
+    } else {
+      this.keysByPk.set(pk, nextKeys);
+    }
   }
-  /**
-   * Dequeue (cancel) a previously enqueued task by its dequeue function.
-   */
-  dequeue(dequeueFn) {
-    dequeueFn();
+  normalizeKeys(keys) {
+    if (keys === void 0 || keys === null) return [];
+    const rawKeys = Array.isArray(keys) ? keys : [keys];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of rawKeys) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(key);
+    }
+    return result;
   }
-  /**
-   * Execute all pending tasks.
-   *
-   * This flush drains until the queue is empty. If tasks enqueue more tasks, they will be
-   * executed within the same flush.
-   */
-  flush() {
-    this.scheduler?.cancel();
-    this.isFlushing = true;
-    this.emitter.emit(1 /* BEFORE_FLUSH */, void 0);
-    const snapshot = Array.from(this.tasks);
-    this.tasks.clear();
-    for (let i = 0; i < snapshot.length; i++) {
-      snapshot[i]();
+};
+
+// src/core/OIMDerivedCollectionIndexArrayBased.ts
+var OIMDerivedCollectionIndexArrayBased = class extends OIMReactiveCollectionIndexManualArrayBased {
+  constructor(queue, collection, opts) {
+    super(queue, {
+      collection,
+      indexOptions: opts.indexOptions
+    });
+    this.keysByPk = /* @__PURE__ */ new Map();
+    this.onCollectionUpdate = (pks) => {
+      if (pks.length === 0) {
+        this.rebuildFromCollection();
+        return;
+      }
+      const affectedKeys = /* @__PURE__ */ new Set();
+      for (const pk of pks) {
+        this.trackPkKeys(pk, affectedKeys);
+      }
+      for (const key of affectedKeys) {
+        this.rebuildKey(key);
+      }
+    };
+    this.collection = collection;
+    this.selectIndexKeys = opts.selectIndexKeys;
+    this.compareEntities = opts.compareEntities;
+    this.orderBy = opts.orderBy;
+    this.unsubscribeFromCollection = collection.emitter.on(
+      0 /* UPDATE */,
+      (payload) => this.onCollectionUpdate(payload.pks)
+    );
+    if (opts.buildInitial !== false) {
+      this.rebuildFromCollection();
+    }
+  }
+  rebuildFromCollection() {
+    this.keysByPk.clear();
+    super.clear();
+    const slotsByKey = /* @__PURE__ */ new Map();
+    const slots = this.collection.getAllSlots();
+    for (const slot of slots) {
+      if (slot.item === void 0) continue;
+      const keys = this.normalizeKeys(this.selectIndexKeys(slot.item));
+      if (keys.length === 0) continue;
+      this.keysByPk.set(slot.pk, new Set(keys));
+      for (const key of keys) {
+        let slotsForKey = slotsByKey.get(key);
+        if (!slotsForKey) {
+          slotsForKey = [];
+          slotsByKey.set(key, slotsForKey);
+        }
+        slotsForKey.push(slot);
+      }
+    }
+    for (const [key, keySlots] of slotsByKey) {
+      this.setSlots(key, this.sortSlots(keySlots));
     }
-    this.isFlushing = false;
-    this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
   }
-  /**
-   * Get the current number of queued functions.
-   */
-  get length() {
-    return this.tasks.size;
+  clear(key) {
+    if (key === void 0) {
+      this.keysByPk.clear();
+    } else {
+      for (const keys of this.keysByPk.values()) {
+        keys.delete(key);
+      }
+    }
+    super.clear(key);
   }
-  /**
-   * Check if the queue is empty.
-   */
-  get isEmpty() {
-    return this.tasks.size === 0;
+  destroy() {
+    this.unsubscribeFromCollection();
+    this.keysByPk.clear();
+    super.destroy();
   }
-  /**
-   * Clear the queue without executing functions and cancel any scheduled flush.
-   */
-  clear() {
-    this.tasks.clear();
-    this.scheduler?.cancel();
+  trackPkKeys(pk, affectedKeys) {
+    const prevKeys = this.keysByPk.get(pk) ?? /* @__PURE__ */ new Set();
+    for (const key of prevKeys) affectedKeys.add(key);
+    const slot = this.collection.getSlotByPk(pk);
+    const entity = slot?.item;
+    const nextKeys = entity === void 0 ? /* @__PURE__ */ new Set() : new Set(this.normalizeKeys(this.selectIndexKeys(entity)));
+    for (const key of nextKeys) affectedKeys.add(key);
+    if (nextKeys.size === 0) {
+      this.keysByPk.delete(pk);
+    } else {
+      this.keysByPk.set(pk, nextKeys);
+    }
   }
-  ensureScheduled() {
-    if (!this.scheduler) return;
-    if (this.isFlushing) return;
-    if (this.tasks.size === 1) {
-      this.scheduler.schedule();
+  rebuildKey(key) {
+    const keySlots = [];
+    const slots = this.collection.getAllSlots();
+    for (const slot of slots) {
+      if (slot.item === void 0) continue;
+      const keys = this.keysByPk.get(slot.pk);
+      if (keys?.has(key)) keySlots.push(slot);
+    }
+    if (keySlots.length === 0) {
+      super.clear(key);
+    } else {
+      this.setSlots(key, this.sortSlots(keySlots));
     }
   }
-  /**
-   * Clean up scheduler subscription when queue is no longer needed.
-   */
-  destroy() {
-    if (this.scheduler && this.flushBound) {
-      this.scheduler.off(
-        0 /* FLUSH */,
-        this.flushBound
-      );
+  sortSlots(slots) {
+    if (!this.compareEntities && !this.orderBy) return slots;
+    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;
+    });
+  }
+  normalizeKeys(keys) {
+    if (keys === void 0 || keys === null) return [];
+    const rawKeys = Array.isArray(keys) ? keys : [keys];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of rawKeys) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(key);
     }
-    this.clear();
+    return result;
   }
 };
 
-// src/core/OIMIndexComparatorFactory.ts
-var OIMIndexComparatorFactory = class {
-  /**
-   * Create an element-wise comparator that checks arrays for strict equality.
-   * Compares array lengths and each element using strict equality (===).
-   */
-  static createElementWiseComparator() {
-    return (existingPks, newPks) => {
-      if (existingPks.length !== newPks.length) {
-        return false;
-      }
-      for (let i = 0; i < existingPks.length; i++) {
-        if (existingPks[i] !== newPks[i]) {
-          return false;
-        }
-      }
-      return true;
-    };
+// src/core/OIMCollectionIndexFactory.ts
+var OIMCollectionIndexFactory = class {
+  constructor(queue, collection) {
+    this.queue = queue;
+    this.collection = collection;
   }
-  /**
-   * Create a set-based comparator that checks if arrays contain the same elements.
-   * Order doesn't matter, only the presence of elements.
-   */
-  static createSetBasedComparator() {
-    return (existingPks, newPks) => {
-      if (existingPks.length !== newPks.length) {
-        return false;
-      }
-      const existingSet = new Set(existingPks);
-      const newSet = new Set(newPks);
-      if (existingSet.size !== newSet.size || existingSet.size !== existingPks.length) {
-        return false;
+  setBasedIndex(opts = {}) {
+    return new OIMReactiveCollectionIndexManualSetBased(this.queue, {
+      collection: this.collection,
+      indexOptions: opts.indexOptions
+    });
+  }
+  derivedSetIndex(selectIndexKeys, opts = {}) {
+    return new OIMDerivedCollectionIndexSetBased(
+      this.queue,
+      this.collection,
+      {
+        selectIndexKeys,
+        buildInitial: opts.buildInitial,
+        indexOptions: opts.indexOptions
       }
-      for (const pk of Array.from(existingSet)) {
-        if (!newSet.has(pk)) {
-          return false;
-        }
+    );
+  }
+  arrayBasedIndex(opts = {}) {
+    return new OIMReactiveCollectionIndexManualArrayBased(this.queue, {
+      collection: this.collection,
+      indexOptions: opts.indexOptions
+    });
+  }
+  derivedArrayIndex(selectIndexKeys, opts = {}) {
+    return new OIMDerivedCollectionIndexArrayBased(
+      this.queue,
+      this.collection,
+      {
+        selectIndexKeys,
+        buildInitial: opts.buildInitial,
+        compareEntities: opts.compareEntities,
+        orderBy: opts.orderBy,
+        indexOptions: opts.indexOptions
       }
-      return true;
-    };
+    );
   }
-  /**
-   * Create a shallow comparator that only checks array references.
-   * Fastest but only works if you're reusing the same array instances.
-   */
-  static createShallowComparator() {
-    return (existingPks, newPks) => {
-      return existingPks === newPks;
+  orderedIndex() {
+    return new OIMCollectionIndexManualOrderedArrayBased({
+      collection: this.collection
+    });
+  }
+  orderedList(opts = {}) {
+    return new OIMCollectionOrderedListCommandStream(
+      this.queue,
+      opts.index ? { collection: this.collection, index: opts.index } : { collection: this.collection }
+    );
+  }
+};
+function createOIMCollectionIndexFactory(queue, collection) {
+  return new OIMCollectionIndexFactory(queue, collection);
+}
+
+// src/core/OIMObjectStoreRecordDriven.ts
+var OIMObjectStoreRecordDriven = class extends OIMObjectStore {
+  constructor(initial) {
+    super();
+    this.properties = Object.assign(/* @__PURE__ */ Object.create(null), initial ?? {});
+  }
+  setProperty(key, value) {
+    this.properties[key] = value;
+  }
+  merge(draft) {
+    Object.assign(this.properties, draft);
+  }
+  delete(key) {
+    delete this.properties[key];
+  }
+  get(key) {
+    return this.properties[key];
+  }
+  getAll() {
+    return { ...this.properties };
+  }
+  clear() {
+    this.properties = /* @__PURE__ */ Object.create(null);
+  }
+  count() {
+    return Object.keys(this.properties).length;
+  }
+  keys() {
+    return Object.keys(this.properties);
+  }
+  values() {
+    return Object.values(this.properties);
+  }
+  entries() {
+    return Object.entries(this.properties);
+  }
+  destroy() {
+    this.clear();
+  }
+};
+
+// src/enums/EOIMObjectEventType.ts
+var EOIMObjectEventType = /* @__PURE__ */ ((EOIMObjectEventType2) => {
+  EOIMObjectEventType2[EOIMObjectEventType2["UPDATE"] = 0] = "UPDATE";
+  return EOIMObjectEventType2;
+})(EOIMObjectEventType || {});
+
+// src/core/OIMObject.ts
+var OIMObject = class {
+  constructor(opts) {
+    this.emitter = new OIMEventEmitter();
+    this.store = opts?.store ?? new OIMObjectStoreRecordDriven();
+  }
+  setProperty(key, value) {
+    this.store.setProperty(key, value);
+    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
+  }
+  merge(draft) {
+    this.store.merge(draft);
+    this.emitter.emit(0 /* UPDATE */, {
+      keys: Object.keys(draft)
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+    this.emitter.emit(0 /* UPDATE */, { keys: [key] });
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  getAll() {
+    return this.store.getAll();
+  }
+  clear() {
+    this.store.clear();
+    this.emitter.emit(0 /* UPDATE */, { keys: [] });
+  }
+  count() {
+    return this.store.count();
+  }
+  keys() {
+    return this.store.keys();
+  }
+  values() {
+    return this.store.values();
+  }
+  entries() {
+    return this.store.entries();
+  }
+  destroy() {
+    this.store.destroy();
+    this.emitter.offAll();
+  }
+};
+
+// src/core/OIMReactiveObject.ts
+var OIMReactiveObject = class extends OIMObject {
+  constructor(queue, opts) {
+    super(opts);
+    this.updateEmitter = new OIMUpdateEventEmitter(queue, "queue");
+    this.emitter.on(0 /* UPDATE */, (payload) => {
+      this.updateEmitter.markUpdatedKeys(payload.keys);
+    });
+  }
+  subscribeOnKey(key, handler) {
+    return this.updateEmitter.subscribeOnKey(key, handler);
+  }
+  subscribeOnKeys(keys, handler) {
+    return this.updateEmitter.subscribeOnKeys(keys, handler);
+  }
+  unsubscribeFromKey(key, handler) {
+    this.updateEmitter.unsubscribeFromKey(key, handler);
+  }
+  unsubscribeFromKeys(keys, handler) {
+    this.updateEmitter.unsubscribeFromKeys(keys, handler);
+  }
+  hasSubscriptions() {
+    return this.updateEmitter.hasSubscriptions();
+  }
+  getHandlerCount(key) {
+    return this.updateEmitter.getHandlerCount(key);
+  }
+  getMetrics() {
+    return this.updateEmitter.getMetrics();
+  }
+  destroy() {
+    this.updateEmitter.destroy();
+    super.destroy();
+  }
+};
+
+// src/core/OIMObjectStoreMapDriven.ts
+var OIMObjectStoreMapDriven = class extends OIMObjectStore {
+  constructor() {
+    super(...arguments);
+    this.properties = /* @__PURE__ */ new Map();
+  }
+  setProperty(key, value) {
+    this.properties.set(key, value);
+  }
+  merge(draft) {
+    for (const key in draft) {
+      if (!Object.prototype.hasOwnProperty.call(draft, key)) continue;
+      this.properties.set(
+        key,
+        draft[key]
+      );
+    }
+  }
+  delete(key) {
+    this.properties.delete(key);
+  }
+  get(key) {
+    return this.properties.get(key);
+  }
+  getAll() {
+    return Object.fromEntries(this.properties.entries());
+  }
+  clear() {
+    this.properties.clear();
+  }
+  count() {
+    return this.properties.size;
+  }
+  keys() {
+    return Array.from(this.properties.keys());
+  }
+  values() {
+    return Array.from(this.properties.values());
+  }
+  entries() {
+    return Array.from(this.properties.entries());
+  }
+  destroy() {
+    this.properties.clear();
+  }
+};
+
+// src/core/OIMComparatorFactory.ts
+var OIMComparatorFactory = class {
+  createShallowComparator() {
+    return (a, b) => {
+      if (a === b) return false;
+      const ka = Object.keys(a);
+      const kb = Object.keys(b);
+      if (ka.length !== kb.length) return true;
+      for (let i = 0; i < ka.length; i++) {
+        const k = ka[i];
+        if (b[k] !== a[k])
+          return true;
+      }
+      return false;
+    };
+  }
+};
+
+// src/core/OIMEventQueue.ts
+var OIMEventQueue = class {
+  constructor(options = {}) {
+    this.emitter = new OIMEventEmitter();
+    this.tasks = /* @__PURE__ */ new Set();
+    this.isFlushing = false;
+    this.scheduler = options.scheduler;
+    if (this.scheduler) {
+      this.flushBound = () => this.flush();
+      this.scheduler.on(
+        0 /* FLUSH */,
+        this.flushBound
+      );
+    }
+  }
+  /**
+   * Enqueue a one-shot task to be executed on the next flush.
+   * Returns a dequeue function that can be called to cancel the task before it runs.
+   */
+  enqueue(fn) {
+    let isActive = true;
+    const task = () => {
+      if (!isActive) return;
+      fn();
+    };
+    this.tasks.add(task);
+    this.ensureScheduled();
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      this.tasks.delete(task);
+    };
+  }
+  get isInFlush() {
+    return this.isFlushing;
+  }
+  /**
+   * Dequeue (cancel) a previously enqueued task by its dequeue function.
+   */
+  dequeue(dequeueFn) {
+    dequeueFn();
+  }
+  /**
+   * Execute all pending tasks.
+   *
+   * This flush drains until the queue is empty. If tasks enqueue more tasks, they will be
+   * executed within the same flush.
+   */
+  flush() {
+    this.scheduler?.cancel();
+    this.isFlushing = true;
+    this.emitter.emit(1 /* BEFORE_FLUSH */, void 0);
+    const snapshot = Array.from(this.tasks);
+    this.tasks.clear();
+    for (let i = 0; i < snapshot.length; i++) {
+      snapshot[i]();
+    }
+    this.isFlushing = false;
+    this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
+  }
+  /**
+   * Get the current number of queued functions.
+   */
+  get length() {
+    return this.tasks.size;
+  }
+  /**
+   * Check if the queue is empty.
+   */
+  get isEmpty() {
+    return this.tasks.size === 0;
+  }
+  /**
+   * Clear the queue without executing functions and cancel any scheduled flush.
+   */
+  clear() {
+    this.tasks.clear();
+    this.scheduler?.cancel();
+  }
+  ensureScheduled() {
+    if (!this.scheduler) return;
+    if (this.isFlushing) return;
+    if (this.tasks.size === 1) {
+      this.scheduler.schedule();
+    }
+  }
+  /**
+   * Clean up scheduler subscription when queue is no longer needed.
+   */
+  destroy() {
+    if (this.scheduler && this.flushBound) {
+      this.scheduler.off(
+        0 /* FLUSH */,
+        this.flushBound
+      );
+    }
+    this.clear();
+  }
+};
+
+// src/core/OIMIndexComparatorFactory.ts
+var OIMIndexComparatorFactory = class {
+  /**
+   * Create an element-wise comparator that checks arrays for strict equality.
+   * Compares array lengths and each element using strict equality (===).
+   */
+  static createElementWiseComparator() {
+    return (existingPks, newPks) => {
+      if (existingPks.length !== newPks.length) {
+        return false;
+      }
+      for (let i = 0; i < existingPks.length; i++) {
+        if (existingPks[i] !== newPks[i]) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  /**
+   * Create a set-based comparator that checks if arrays contain the same elements.
+   * Order doesn't matter, only the presence of elements.
+   */
+  static createSetBasedComparator() {
+    return (existingPks, newPks) => {
+      if (existingPks.length !== newPks.length) {
+        return false;
+      }
+      const existingSet = new Set(existingPks);
+      const newSet = new Set(newPks);
+      if (existingSet.size !== newSet.size || existingSet.size !== existingPks.length) {
+        return false;
+      }
+      for (const pk of Array.from(existingSet)) {
+        if (!newSet.has(pk)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  /**
+   * Create a shallow comparator that only checks array references.
+   * Fastest but only works if you're reusing the same array instances.
+   */
+  static createShallowComparator() {
+    return (existingPks, newPks) => {
+      return existingPks === newPks;
+    };
+  }
+  /**
+   * Create a no-comparison comparator that always returns false (always updates).
+   * Useful for disabling comparison while keeping the same interface.
+   */
+  static createAlwaysUpdateComparator() {
+    return () => false;
+  }
+};
+
+// src/core/OIMMap2Keys.ts
+var OIMMap2Keys = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  get size() {
+    return this._size;
+  }
+  set(k1, k2, v) {
+    let m = this.map.get(k1);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      this.map.set(k1, m);
+    }
+    if (!m.has(k2)) this._size++;
+    m.set(k2, v);
+  }
+  get(k1, k2) {
+    return this.map.get(k1)?.get(k2);
+  }
+  has(k1, k2) {
+    return this.map.get(k1)?.has(k2);
+  }
+  delete(k1, k2) {
+    const m = this.map.get(k1);
+    if (!m) return false;
+    const had = m.delete(k2);
+    if (had) {
+      this._size--;
+      if (m.size === 0) this.map.delete(k1);
+    }
+    return had;
+  }
+  clear() {
+    this.map.clear();
+    this._size = 0;
+  }
+};
+
+// src/modules/compute/core/OIMComputeRuntime.ts
+var OIMComputeRuntime = class {
+  constructor(queue) {
+    this.queue = queue;
+    this.isFlushScheduled = false;
+    this.isFlushing = false;
+    this.minLevel = Infinity;
+    this.maxLevel = -Infinity;
+    this.dirtyByLevel = /* @__PURE__ */ new Map();
+    this.afterFlushTasks = /* @__PURE__ */ new Set();
+    this.queue.emitter.on(0 /* AFTER_FLUSH */, () => {
+      if (!this.isFlushScheduled) return;
+      this.flush();
+    });
+  }
+  /**
+   * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
+   * ordered by `level` ascending.
+   */
+  schedule(task, level = 0) {
+    let isActive = true;
+    const wrapped = () => {
+      if (!isActive) return;
+      task();
+    };
+    let bucket = this.dirtyByLevel.get(level);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.dirtyByLevel.set(level, bucket);
+    }
+    bucket.add(wrapped);
+    if (level < this.minLevel) this.minLevel = level;
+    if (level > this.maxLevel) this.maxLevel = level;
+    if (!this.isFlushing) this.isFlushScheduled = true;
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      bucket.delete(wrapped);
+    };
+  }
+  /**
+   * Run once at the start of the next runtime flush (i.e. after queue.flush()).
+   * Useful for resubscribing dependencies exactly once per source flush.
+   */
+  scheduleAfterFlush(task) {
+    let isActive = true;
+    const wrapped = () => {
+      if (!isActive) return;
+      task();
+    };
+    this.afterFlushTasks.add(wrapped);
+    if (!this.isFlushing) this.isFlushScheduled = true;
+    return () => {
+      if (!isActive) return;
+      isActive = false;
+      this.afterFlushTasks.delete(wrapped);
+    };
+  }
+  flush() {
+    this.isFlushScheduled = false;
+    if (this.dirtyByLevel.size === 0 && this.afterFlushTasks.size === 0)
+      return;
+    this.isFlushing = true;
+    try {
+      if (this.afterFlushTasks.size > 0) {
+        const snapshot = Array.from(this.afterFlushTasks);
+        this.afterFlushTasks.clear();
+        for (let i = 0; i < snapshot.length; i++) snapshot[i]();
+      }
+      if (this.dirtyByLevel.size === 0) return;
+      let level = this.minLevel;
+      let max = this.maxLevel;
+      while (level <= max) {
+        for (; ; ) {
+          const bucket = this.dirtyByLevel.get(level);
+          if (!bucket || bucket.size === 0) break;
+          this.dirtyByLevel.delete(level);
+          const snapshot = Array.from(bucket);
+          for (let i = 0; i < snapshot.length; i++) snapshot[i]();
+        }
+        if (this.maxLevel > max) max = this.maxLevel;
+        level++;
+      }
+    } finally {
+      this.isFlushing = false;
+      if (this.dirtyByLevel.size === 0) {
+        this.minLevel = Infinity;
+        this.maxLevel = -Infinity;
+      } else {
+        let nextMin = Infinity;
+        let nextMax = -Infinity;
+        this.dirtyByLevel.forEach((_bucket, lvl) => {
+          if (lvl < nextMin) nextMin = lvl;
+          if (lvl > nextMax) nextMax = lvl;
+        });
+        this.minLevel = nextMin;
+        this.maxLevel = nextMax;
+        this.isFlushScheduled = true;
+      }
+    }
+  }
+};
+
+// src/modules/selector/core/OIMSelector.ts
+var OIMSelector = class {
+  constructor(runtime, sourceDeps, computedDeps = []) {
+    this.runtime = runtime;
+    this.sourceDeps = sourceDeps;
+    this.computedDeps = computedDeps;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.sourceUnsubscribers = [];
+    this.computedUnsubscribers = [];
+    this.isResubscribeEnqueued = false;
+    this.isTemporarilyUnsubscribedForFlush = false;
+    this.isDeliveryEnqueued = false;
+    this.hasLastValue = false;
+    this.onSourceInvalidate = () => {
+      if (this.listeners.size === 0) return;
+      if (!this.isTemporarilyUnsubscribedForFlush) {
+        this.isTemporarilyUnsubscribedForFlush = true;
+        this.unsubscribeFromSourceDeps();
+        this.ensureResubscribeAfterFlush();
+      }
+      if (this.isDeliveryEnqueued) return;
+      this.isDeliveryEnqueued = true;
+      this.dequeueDelivery = this.runtime.schedule(this.deliver);
+    };
+    this.onComputedInvalidate = () => {
+      if (this.listeners.size === 0) return;
+      if (this.isDeliveryEnqueued) return;
+      this.isDeliveryEnqueued = true;
+      this.dequeueDelivery = this.runtime.schedule(this.deliver);
+    };
+    this.deliver = () => {
+      this.isDeliveryEnqueued = false;
+      this.dequeueDelivery = void 0;
+      if (this.listeners.size === 0) return;
+      const next = this.getValue();
+      if (this.hasLastValue && this.areEqual(this.lastValue, next)) return;
+      this.setLastValue(next);
+      const snapshot = Array.from(this.listeners);
+      for (let i = 0; i < snapshot.length; i++) {
+        const listener = snapshot[i];
+        if (this.listeners.has(listener)) listener(next);
+      }
+    };
+    this.onAfterFlush = () => {
+      if (!this.isResubscribeEnqueued) return;
+      this.isResubscribeEnqueued = false;
+      this.dequeueResubscribe = void 0;
+      if (this.listeners.size === 0) return;
+      this.isTemporarilyUnsubscribedForFlush = false;
+      if (this.sourceUnsubscribers.length === 0) {
+        for (const dep of this.sourceDeps) {
+          this.sourceUnsubscribers.push(
+            dep.subscribe(this.onSourceInvalidate)
+          );
+        }
+      }
+    };
+  }
+  get queue() {
+    return this.runtime.queue;
+  }
+  /**
+   * Start watching this selector. The callback is called immediately with the current value,
+   * then coalesced and delivered on `queue.flush()` when the selector invalidates.
+   */
+  watch(onValue) {
+    this.listeners.add(onValue);
+    if (this.listeners.size === 1) {
+      this.subscribeToDeps();
+    }
+    const current = this.getValue();
+    this.setLastValue(current);
+    onValue(current);
+    return () => {
+      this.listeners.delete(onValue);
+      if (this.listeners.size > 0) return;
+      this.unsubscribeFromAllDeps();
+      if (this.dequeueResubscribe) {
+        this.dequeueResubscribe();
+        this.dequeueResubscribe = void 0;
+      }
+      this.isResubscribeEnqueued = false;
+      this.isTemporarilyUnsubscribedForFlush = false;
+      if (this.dequeueDelivery) {
+        this.dequeueDelivery();
+        this.dequeueDelivery = void 0;
+      }
+      this.isDeliveryEnqueued = false;
+      this.hasLastValue = false;
+    };
+  }
+  areEqual(prev, next) {
+    return Object.is(prev, next);
+  }
+  setLastValue(value) {
+    this.lastValue = value;
+    this.hasLastValue = true;
+  }
+  subscribeToDeps() {
+    if (this.sourceUnsubscribers.length > 0 || this.computedUnsubscribers.length > 0)
+      return;
+    for (const dep of this.sourceDeps) {
+      this.sourceUnsubscribers.push(
+        dep.subscribe(this.onSourceInvalidate)
+      );
+    }
+    for (const dep of this.computedDeps) {
+      this.computedUnsubscribers.push(
+        dep.subscribe(this.onComputedInvalidate)
+      );
+    }
+  }
+  unsubscribeFromSourceDeps() {
+    if (this.sourceUnsubscribers.length === 0) return;
+    for (const unsub of this.sourceUnsubscribers) unsub();
+    this.sourceUnsubscribers = [];
+  }
+  unsubscribeFromAllDeps() {
+    this.unsubscribeFromSourceDeps();
+    if (this.computedUnsubscribers.length === 0) return;
+    for (const unsub of this.computedUnsubscribers) unsub();
+    this.computedUnsubscribers = [];
+  }
+  ensureResubscribeAfterFlush() {
+    if (this.isResubscribeEnqueued) return;
+    this.isResubscribeEnqueued = true;
+    this.dequeueResubscribe = this.runtime.scheduleAfterFlush(
+      this.onAfterFlush
+    );
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKey.ts
+var OIMSelectorSourceDependencyUpdateEventEmitterKey = class {
+  constructor(subscription, key) {
+    this.subscription = subscription;
+    this.key = key;
+  }
+  subscribe(onUpdate) {
+    return this.subscription.subscribeOnKey(this.key, onUpdate);
+  }
+};
+
+// src/modules/selector/core/OIMCollectionByPkSelector.ts
+var OIMCollectionByPkSelector = class extends OIMSelector {
+  constructor(runtime, collection, pk) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
+        collection,
+        pk
+      )
+    ]);
+    this.collection = collection;
+    this.pk = pk;
+  }
+  getValue() {
+    return this.collection.getOneByPk(this.pk);
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKeys.ts
+var OIMSelectorSourceDependencyUpdateEventEmitterKeys = class {
+  constructor(subscription, keys) {
+    this.subscription = subscription;
+    this.keys = keys;
+  }
+  subscribe(onUpdate) {
+    return this.subscription.subscribeOnKeys(this.keys, onUpdate);
+  }
+};
+
+// src/modules/selector/core/OIMCollectionByPksSelector.ts
+var OIMCollectionByPksSelector = class extends OIMSelector {
+  constructor(runtime, collection, pks) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
+        collection,
+        pks
+      )
+    ]);
+    this.collection = collection;
+    this.pks = pks;
+  }
+  getValue() {
+    return this.pks.map((pk) => this.collection.getOneByPk(pk));
+  }
+  areEqual(prev, next) {
+    if (prev === next) return true;
+    if (prev.length !== next.length) return false;
+    for (let i = 0; i < prev.length; i++) {
+      if (prev[i] !== next[i]) return false;
+    }
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased.ts
+var OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased = class {
+  constructor(collection, reactiveIndex, key) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = this.reactiveIndex.getPksByKey(this.key);
+      if (this.sameArray(this.currentPks, nextPks)) return;
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = nextPks;
+      if (this.currentPks.length === 0) return;
+      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
+    };
+    const onIndexUpdate = () => {
+      resubscribeCollection();
+      onUpdate();
+    };
+    resubscribeCollection();
+    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
+      this.key,
+      onIndexUpdate
+    );
+    return () => {
+      unsubscribeFromIndex();
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = [];
+    };
+  }
+  sameArray(a, b) {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+};
+
+// src/modules/selector/core/OIMEntitiesByIndexKeyArrayBasedSelector.ts
+var OIMEntitiesByIndexKeyArrayBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased(collection, reactiveIndex, key)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+  }
+  getValue() {
+    const pks = this.reactiveIndex.getPksByKey(this.key);
+    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/OIMSelectorSourceDependencyEntitiesByIndexKeySetBased.ts
+var OIMSelectorSourceDependencyEntitiesByIndexKeySetBased = class {
+  constructor(collection, reactiveIndex, key) {
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
+    this.currentPks = [];
+  }
+  subscribe(onUpdate) {
+    const resubscribeCollection = () => {
+      const nextPks = Array.from(this.reactiveIndex.getPksByKey(this.key));
+      if (this.sameArray(this.currentPks, nextPks)) return;
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = nextPks;
+      if (this.currentPks.length === 0) return;
+      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
+    };
+    const onIndexUpdate = () => {
+      resubscribeCollection();
+      onUpdate();
+    };
+    resubscribeCollection();
+    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
+      this.key,
+      onIndexUpdate
+    );
+    return () => {
+      unsubscribeFromIndex();
+      this.unsubscribeFromCollectionKeys?.();
+      this.unsubscribeFromCollectionKeys = void 0;
+      this.currentPks = [];
     };
   }
-  /**
-   * Create a no-comparison comparator that always returns false (always updates).
-   * Useful for disabling comparison while keeping the same interface.
-   */
-  static createAlwaysUpdateComparator() {
-    return () => false;
+  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/core/OIMMap2Keys.ts
-var OIMMap2Keys = class {
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-    this._size = 0;
-  }
-  get size() {
-    return this._size;
+// src/modules/selector/core/OIMEntitiesByIndexKeySetBasedSelector.ts
+var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
+  constructor(runtime, collection, reactiveIndex, key) {
+    super(runtime, [
+      new OIMSelectorSourceDependencyEntitiesByIndexKeySetBased(collection, reactiveIndex, key)
+    ]);
+    this.collection = collection;
+    this.reactiveIndex = reactiveIndex;
+    this.key = key;
   }
-  set(k1, k2, v) {
-    let m = this.map.get(k1);
-    if (!m) {
-      m = /* @__PURE__ */ new Map();
-      this.map.set(k1, m);
+  getValue() {
+    const pks = this.reactiveIndex.getPksByKey(this.key);
+    const entities = [];
+    entities.length = pks.size;
+    let writeIndex = 0;
+    for (const pk of pks) {
+      entities[writeIndex++] = this.collection.getOneByPk(pk);
     }
-    if (!m.has(k2)) this._size++;
-    m.set(k2, v);
+    return entities;
   }
-  get(k1, k2) {
-    return this.map.get(k1)?.get(k2);
+  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;
   }
-  has(k1, k2) {
-    return this.map.get(k1)?.has(k2);
+};
+
+// src/dx/OIMCollectionSelectors.ts
+var OIMCollectionSelectors = class {
+  constructor(queue, collection) {
+    this.collection = collection;
+    this.runtime = new OIMComputeRuntime(queue);
   }
-  delete(k1, k2) {
-    const m = this.map.get(k1);
-    if (!m) return false;
-    const had = m.delete(k2);
-    if (had) {
-      this._size--;
-      if (m.size === 0) this.map.delete(k1);
-    }
-    return had;
+  byPk(pk) {
+    return new OIMCollectionByPkSelector(this.runtime, this.collection, pk);
   }
-  clear() {
-    this.map.clear();
-    this._size = 0;
+  byPks(pks) {
+    return new OIMCollectionByPksSelector(
+      this.runtime,
+      this.collection,
+      pks
+    );
+  }
+  entitiesBySetIndexKey(index, key) {
+    return new OIMEntitiesByIndexKeySetBasedSelector(
+      this.runtime,
+      this.collection,
+      index,
+      key
+    );
+  }
+  entitiesByArrayIndexKey(index, key) {
+    return new OIMEntitiesByIndexKeyArrayBasedSelector(
+      this.runtime,
+      this.collection,
+      index,
+      key
+    );
   }
 };
 
-// src/modules/wrapper/collection/OIMCollectionChangedFieldsWrapper.ts
-var OIMCollectionChangedFieldsWrapper = class {
+// src/dx/OIMCollectionContext.ts
+function createOIMCollectionContext(queue, opts) {
+  const collection = new OIMReactiveCollection(queue, opts);
+  const indexFactory = new OIMCollectionIndexFactory(queue, collection);
+  const select = new OIMCollectionSelectors(queue, collection);
+  return { queue, collection, indexFactory, select };
+}
+
+// src/modules/wrapper/collection/OIMCollectionChangedFields.ts
+var OIMCollectionChangedFields = class {
   constructor(queue, collection, opts) {
     this.isInWrite = false;
     this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
@@ -1780,7 +2896,7 @@ var OIMCollectionChangedFieldsWrapper = class {
     this.collection = collection;
     this.selectPk = opts?.selectPk ?? (() => {
       throw new Error(
-        `[OIMCollectionChangedFieldsWrapper]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
+        `[OIMCollectionChangedFields]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
       );
     });
     this.changedPksEventEmitter = new OIMUpdateEventEmitter(
@@ -1803,31 +2919,34 @@ var OIMCollectionChangedFieldsWrapper = class {
     );
   }
   upsertOneByPk(pk, patch) {
-    this.withWrite(() => {
+    const slot = this.withWrite(() => {
       this.trackPatch(pk, patch);
-      this.collection.upsertOneByPk(pk, patch);
+      return this.collection.upsertOneByPk(pk, patch);
     });
     this.updateEntitySnapshot(pk);
+    return slot;
   }
   upsertOne(entity) {
-    this.withWrite(() => {
+    const slot = this.withWrite(() => {
       const pk = this.selectPk(entity);
       this.trackPatch(pk, entity);
-      this.collection.upsertOne(entity);
+      return this.collection.upsertOne(entity);
     });
-    this.updateEntitySnapshot(this.selectPk(entity));
+    this.updateEntitySnapshot(slot.pk);
+    return slot;
   }
   upsertMany(entities) {
     const pks = [];
-    this.withWrite(() => {
+    const slots = this.withWrite(() => {
       for (const entity of entities) {
         const pk = this.selectPk(entity);
         pks.push(pk);
         this.trackPatch(pk, entity);
       }
-      this.collection.upsertMany(entities);
+      return this.collection.upsertMany(entities);
     });
     for (let i = 0; i < pks.length; i++) this.updateEntitySnapshot(pks[i]);
+    return slots;
   }
   getChangedFieldsByPk(pk) {
     return this.changedFieldsByPk.get(pk) ?? /* @__PURE__ */ new Set();
@@ -1858,12 +2977,11 @@ var OIMCollectionChangedFieldsWrapper = class {
   }
   withWrite(fn) {
     if (this.isInWrite) {
-      fn();
-      return;
+      return fn();
     }
     this.isInWrite = true;
     try {
-      fn();
+      return fn();
     } finally {
       this.isInWrite = false;
     }
@@ -1905,238 +3023,33 @@ var OIMCollectionChangedFieldsWrapper = class {
       ...entity
     });
   }
-  trackChangedKeys(pk, keys) {
-    let pkFields = this.changedFieldsByPk.get(pk);
-    if (!pkFields) {
-      pkFields = /* @__PURE__ */ new Set();
-      this.changedFieldsByPk.set(pk, pkFields);
-    }
-    for (const key of keys) {
-      pkFields.add(key);
-      let fieldPks = this.changedPksByField.get(key);
-      if (!fieldPks) {
-        fieldPks = /* @__PURE__ */ new Set();
-        this.changedPksByField.set(key, fieldPks);
-      }
-      fieldPks.add(pk);
-    }
-    this.changedPksEventEmitter.markUpdatedKeys([pk]);
-    this.changedFieldsEventEmitter.markUpdatedKeys(keys);
-  }
-  trackPatch(pk, patch) {
-    if (pk === void 0 || pk === null || pk === "") {
-      throw new Error(
-        `[OIMCollectionChangedFieldsWrapper]: PK is required to track changes.`
-      );
-    }
-    const keys = Object.keys(patch);
-    if (keys.length === 0) return;
-    this.trackChangedKeys(pk, keys);
-  }
-};
-
-// src/modules/wrapper/index/OIMIndexManualOrderedArrayBased.ts
-var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
-  clear(key) {
-    if (key === void 0) {
-      const keys = this.getKeys();
-      if (keys.length > 0) {
-        this.store.clear();
-        this.emitUpdate(Array.from(keys));
-      }
-      return;
-    }
-    if (this.store.getOneByKey(key) !== void 0) {
-      this.store.removeOneByKey(key);
-      this.emitUpdate([key]);
-    }
-  }
-  push(key, itemKey) {
-    const list = this.getOrCreateList(key);
-    const index = list.length;
-    list.push(itemKey);
-    this.emitUpdate([key]);
-    return index;
-  }
-  insertAt(key, index, itemKey) {
-    const list = this.getOrCreateList(key);
-    const safeIndex = Math.max(0, Math.min(index, list.length));
-    list.splice(safeIndex, 0, itemKey);
-    this.emitUpdate([key]);
-  }
-  removeAt(key, index) {
-    const list = this.store.getOneByKey(key);
-    if (!list) return void 0;
-    if (index < 0 || index >= list.length) return void 0;
-    const [removed] = list.splice(index, 1);
-    if (list.length === 0) {
-      this.store.removeOneByKey(key);
-    }
-    this.emitUpdate([key]);
-    return removed;
-  }
-  move(key, fromIndex, toIndex) {
-    const list = this.store.getOneByKey(key);
-    if (!list) return void 0;
-    if (fromIndex < 0 || fromIndex >= list.length) return void 0;
-    if (toIndex < 0 || toIndex >= list.length) return void 0;
-    if (fromIndex === toIndex) return list[fromIndex];
-    const [itemKey] = list.splice(fromIndex, 1);
-    if (itemKey === void 0) return void 0;
-    list.splice(toIndex, 0, itemKey);
-    this.emitUpdate([key]);
-    return itemKey;
-  }
-  reset(key, itemKeys) {
-    if (itemKeys.length === 0) {
-      if (this.store.getOneByKey(key) !== void 0) {
-        this.store.removeOneByKey(key);
-        this.emitUpdate([key]);
-      }
-      return;
-    }
-    this.store.setOneByKey(key, Array.from(itemKeys));
-    this.emitUpdate([key]);
-  }
-  getOrCreateList(key) {
-    let list = this.store.getOneByKey(key);
-    if (!list) {
-      list = [];
-      this.store.setOneByKey(key, list);
-    }
-    return list;
-  }
-};
-
-// src/modules/wrapper/index/OIMOrderedListIndexCommandStreamWrapper.ts
-var OIMOrderedListIndexCommandStreamWrapper = class {
-  constructor(queue, index) {
-    this.isInWrite = false;
-    this.commandsByKey = /* @__PURE__ */ new Map();
-    this.onAfterFlush = () => {
-      this.commandsByKey.clear();
-    };
-    this.onIndexUpdate = (payload) => {
-      if (this.isInWrite) return;
-      if (payload.keys.length === 0) return;
-      for (let i = 0; i < payload.keys.length; i++) {
-        const key = payload.keys[i];
-        const list = this.index.getPksByKey(key);
-        this.appendCommand(key, { type: "set", keys: Array.from(list) });
-      }
-    };
-    this.commandsEventEmitter = new OIMUpdateEventEmitter(
-      queue,
-      "after_flush"
-    );
-    this.index = index ?? new OIMIndexManualOrderedArrayBased();
-    this.unsubscribeAfterFlush = queue.emitter.on(
-      0 /* AFTER_FLUSH */,
-      this.onAfterFlush
-    );
-    this.unsubscribeFromIndexEmitter = this.index.emitter.on(
-      0 /* UPDATE */,
-      this.onIndexUpdate
-    );
-  }
-  getPksByKey(key) {
-    return this.index.getPksByKey(key);
-  }
-  hasKey(key) {
-    return this.index.hasKey(key);
-  }
-  getKeys() {
-    return this.index.getKeys();
-  }
-  push(key, itemKey) {
-    this.withWrite(() => {
-      const index = this.index.push(key, itemKey);
-      this.appendCommand(key, { type: "add", key: itemKey, index });
-    });
-  }
-  removeAt(key, index) {
-    this.withWrite(() => {
-      const itemKey = this.index.removeAt(key, index);
-      if (itemKey === void 0) return;
-      this.appendCommand(key, { type: "remove", key: itemKey, index });
-    });
-  }
-  move(key, fromIndex, toIndex) {
-    this.withWrite(() => {
-      const itemKey = this.index.move(key, fromIndex, toIndex);
-      if (itemKey === void 0) return;
-      this.appendCommand(key, {
-        type: "move",
-        key: itemKey,
-        fromIndex,
-        toIndex
-      });
-    });
-  }
-  set(key, keys) {
-    this.withWrite(() => {
-      this.index.reset(key, keys);
-      this.appendCommand(key, { type: "set", keys });
-    });
-  }
-  /**
-   * Read-only peek at buffered commands without clearing them.
-   */
-  getBufferedCommands(key) {
-    return this.commandsByKey.get(key) ?? [];
-  }
-  /**
-   * Drain buffered commands for a key, preserving order.
-   * Intended usage: call inside a `commandsEventEmitter.subscribeOnKey(key, ...)` handler.
-   */
-  consumeCommands(key) {
-    const cmds = this.commandsByKey.get(key);
-    if (!cmds || cmds.length === 0) return [];
-    return cmds.slice();
-  }
-  clear(key) {
-    if (key === void 0) {
-      this.index.destroy();
-      this.commandsByKey.clear();
-      return;
-    }
-    this.index.clear(key);
-    this.commandsByKey.delete(key);
-  }
-  destroy() {
-    this.commandsEventEmitter.destroy();
-    this.unsubscribeAfterFlush();
-    this.unsubscribeFromIndexEmitter();
-    this.clear();
-  }
-  withWrite(fn) {
-    if (this.isInWrite) {
-      fn();
-      return;
+  trackChangedKeys(pk, keys) {
+    let pkFields = this.changedFieldsByPk.get(pk);
+    if (!pkFields) {
+      pkFields = /* @__PURE__ */ new Set();
+      this.changedFieldsByPk.set(pk, pkFields);
     }
-    this.isInWrite = true;
-    try {
-      fn();
-    } finally {
-      this.isInWrite = false;
+    for (const key of keys) {
+      pkFields.add(key);
+      let fieldPks = this.changedPksByField.get(key);
+      if (!fieldPks) {
+        fieldPks = /* @__PURE__ */ new Set();
+        this.changedPksByField.set(key, fieldPks);
+      }
+      fieldPks.add(pk);
     }
+    this.changedPksEventEmitter.markUpdatedKeys([pk]);
+    this.changedFieldsEventEmitter.markUpdatedKeys(keys);
   }
-  appendCommand(key, cmd) {
-    let cmds = this.commandsByKey.get(key);
-    if (!cmds) {
-      cmds = [];
-      this.commandsByKey.set(key, cmds);
-    }
-    if (cmd.type === "set") {
-      cmds.length = 0;
-      cmds.push(cmd);
-    } else if (cmds.length > 0 && cmds[0].type === "set") {
-      const setCmd = cmds[0];
-      setCmd.keys = Array.from(this.index.getPksByKey(key));
-    } else {
-      cmds.push(cmd);
+  trackPatch(pk, patch) {
+    if (pk === void 0 || pk === null || pk === "") {
+      throw new Error(
+        `[OIMCollectionChangedFields]: PK is required to track changes.`
+      );
     }
-    this.commandsEventEmitter.markUpdatedKeys([key]);
+    const keys = Object.keys(patch);
+    if (keys.length === 0) return;
+    this.trackChangedKeys(pk, keys);
   }
 };
 
@@ -2252,7 +3165,9 @@ var OIMEventQueueSchedulerImmediate = class extends OIMEventQueueScheduler {
   cancel() {
     if (this.immediateId === void 0) return;
     if (this.useSetImmediate) {
-      clearImmediate(this.immediateId);
+      clearImmediate(
+        this.immediateId
+      );
     } else if (this.useMessageChannel) {
       this.pendingCallback = void 0;
     } else {
@@ -2309,7 +3224,7 @@ var OIMEventQueueSchedulerFactory = class {
   }
 };
 
-// src/const/OIMDBSettings.ts
+// src/constants/OIMDBSettings.ts
 var OIMDBSettings = class {
 };
 /**
@@ -2321,11 +3236,11 @@ OIMDBSettings.FLUSHING_KEYS_INDEX_KEY = "__flushingKeys__";
 
 // src/modules/effect/core/OIMEffectDependencyComputed.ts
 var OIMEffectDependencyComputed = class {
-  constructor(computed) {
-    this.computed = computed;
+  constructor(source) {
+    this.source = source;
   }
   subscribe(onUpdate) {
-    return this.computed.emitter.on("update", onUpdate);
+    return this.source.emitter.on("update", onUpdate);
   }
 };
 
@@ -2437,7 +3352,7 @@ var OIMEffect = class {
   }
 };
 
-// src/modules/computed/enum/EOIMComputedEventType.ts
+// src/modules/computed/enums/EOIMComputedEventType.ts
 var EOIMComputedEventType = /* @__PURE__ */ ((EOIMComputedEventType2) => {
   EOIMComputedEventType2["UPDATE"] = "update";
   return EOIMComputedEventType2;
@@ -2452,13 +3367,13 @@ var OIMComputed = class {
     this.runtime = runtime;
     this.compute = opts.compute;
     this.compare = opts.compare ?? Object.is;
-    this.deps = opts.deps ?? [];
+    this._deps = opts.deps ?? [];
     this.updateEventEmitter = new OIMUpdateEventEmitter(
       this.runtime.queue,
       "immediate"
     );
     this.effect = new OIMEffect(this.runtime, {
-      deps: this.deps,
+      deps: this._deps,
       onUpdate: () => {
         this.isDirty = true;
       },
@@ -2467,6 +3382,15 @@ var OIMComputed = class {
       }
     });
   }
+  get needsRecompute() {
+    return this.isDirty;
+  }
+  get isReady() {
+    return this.hasValue;
+  }
+  get deps() {
+    return this._deps;
+  }
   get() {
     this.recomputeAndEmitIfChanged();
     return this.value;
@@ -2501,8 +3425,8 @@ function isReadonlyArray(value) {
   return Array.isArray(value);
 }
 var OIMEffectDependencyKeyed = class {
-  constructor(subscription, keyOrKeys) {
-    this.subscription = subscription;
+  constructor(source, keyOrKeys) {
+    this.source = source;
     if (isReadonlyArray(keyOrKeys)) {
       this.keys = keyOrKeys;
     } else {
@@ -2511,11 +3435,11 @@ var OIMEffectDependencyKeyed = class {
   }
   subscribe(onUpdate) {
     if (this.keys !== void 0) {
-      return this.subscription.subscribeOnKeys(this.keys, onUpdate);
+      return this.source.subscribeOnKeys(this.keys, onUpdate);
     }
     if (this.key === void 0) return () => {
     };
-    return this.subscription.subscribeOnKey(this.key, onUpdate);
+    return this.source.subscribeOnKey(this.key, onUpdate);
   }
 };
 
@@ -2527,6 +3451,9 @@ var OIMEffectDependencyKeyedObject = class {
       keyOrKeys
     );
   }
+  get source() {
+    return this.dep.source;
+  }
   subscribe(onUpdate) {
     return this.dep.subscribe(onUpdate);
   }
@@ -2536,221 +3463,31 @@ var OIMEffectDependencyKeyedObject = class {
 var OIMEffectDependencyKeyedCollection = class {
   constructor(collection, pkOrPks) {
     this.dep = new OIMEffectDependencyKeyed(
-      collection,
-      pkOrPks
-    );
-  }
-  subscribe(onUpdate) {
-    return this.dep.subscribe(onUpdate);
-  }
-};
-
-// src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
-var OIMEffectDependencyKeyedIndex = class {
-  constructor(index, keyOrKeys) {
-    this.dep = new OIMEffectDependencyKeyed(
-      index,
-      keyOrKeys
-    );
-  }
-  subscribe(onUpdate) {
-    return this.dep.subscribe(onUpdate);
-  }
-};
-
-// src/modules/selector/core/OIMSelector.ts
-var OIMSelector = class {
-  constructor(runtime, sourceDeps, computedDeps = []) {
-    this.runtime = runtime;
-    this.sourceDeps = sourceDeps;
-    this.computedDeps = computedDeps;
-    this.listeners = /* @__PURE__ */ new Set();
-    this.sourceUnsubscribers = [];
-    this.computedUnsubscribers = [];
-    this.isResubscribeEnqueued = false;
-    this.isTemporarilyUnsubscribedForFlush = false;
-    this.isDeliveryEnqueued = false;
-    this.hasLastValue = false;
-    this.onSourceInvalidate = () => {
-      if (this.listeners.size === 0) return;
-      if (!this.isTemporarilyUnsubscribedForFlush) {
-        this.isTemporarilyUnsubscribedForFlush = true;
-        this.unsubscribeFromSourceDeps();
-        this.ensureResubscribeAfterFlush();
-      }
-      if (this.isDeliveryEnqueued) return;
-      this.isDeliveryEnqueued = true;
-      this.dequeueDelivery = this.runtime.schedule(this.deliver);
-    };
-    this.onComputedInvalidate = () => {
-      if (this.listeners.size === 0) return;
-      if (this.isDeliveryEnqueued) return;
-      this.isDeliveryEnqueued = true;
-      this.dequeueDelivery = this.runtime.schedule(this.deliver);
-    };
-    this.deliver = () => {
-      this.isDeliveryEnqueued = false;
-      this.dequeueDelivery = void 0;
-      if (this.listeners.size === 0) return;
-      const next = this.getValue();
-      if (this.hasLastValue && this.areEqual(this.lastValue, next)) return;
-      this.setLastValue(next);
-      const snapshot = Array.from(this.listeners);
-      for (let i = 0; i < snapshot.length; i++) {
-        const listener = snapshot[i];
-        if (this.listeners.has(listener)) listener(next);
-      }
-    };
-    this.onAfterFlush = () => {
-      if (!this.isResubscribeEnqueued) return;
-      this.isResubscribeEnqueued = false;
-      this.dequeueResubscribe = void 0;
-      if (this.listeners.size === 0) return;
-      this.isTemporarilyUnsubscribedForFlush = false;
-      if (this.sourceUnsubscribers.length === 0) {
-        for (const dep of this.sourceDeps) {
-          this.sourceUnsubscribers.push(
-            dep.subscribe(this.onSourceInvalidate)
-          );
-        }
-      }
-    };
-  }
-  get queue() {
-    return this.runtime.queue;
-  }
-  /**
-   * Start watching this selector. The callback is called immediately with the current value,
-   * then coalesced and delivered on `queue.flush()` when the selector invalidates.
-   */
-  watch(onValue) {
-    this.listeners.add(onValue);
-    if (this.listeners.size === 1) {
-      this.subscribeToDeps();
-    }
-    const current = this.getValue();
-    this.setLastValue(current);
-    onValue(current);
-    return () => {
-      this.listeners.delete(onValue);
-      if (this.listeners.size > 0) return;
-      this.unsubscribeFromAllDeps();
-      if (this.dequeueResubscribe) {
-        this.dequeueResubscribe();
-        this.dequeueResubscribe = void 0;
-      }
-      this.isResubscribeEnqueued = false;
-      this.isTemporarilyUnsubscribedForFlush = false;
-      if (this.dequeueDelivery) {
-        this.dequeueDelivery();
-        this.dequeueDelivery = void 0;
-      }
-      this.isDeliveryEnqueued = false;
-      this.hasLastValue = false;
-    };
-  }
-  areEqual(prev, next) {
-    return Object.is(prev, next);
-  }
-  setLastValue(value) {
-    this.lastValue = value;
-    this.hasLastValue = true;
-  }
-  subscribeToDeps() {
-    if (this.sourceUnsubscribers.length > 0 || this.computedUnsubscribers.length > 0)
-      return;
-    for (const dep of this.sourceDeps) {
-      this.sourceUnsubscribers.push(
-        dep.subscribe(this.onSourceInvalidate)
-      );
-    }
-    for (const dep of this.computedDeps) {
-      this.computedUnsubscribers.push(
-        dep.subscribe(this.onComputedInvalidate)
-      );
-    }
-  }
-  unsubscribeFromSourceDeps() {
-    if (this.sourceUnsubscribers.length === 0) return;
-    for (const unsub of this.sourceUnsubscribers) unsub();
-    this.sourceUnsubscribers = [];
-  }
-  unsubscribeFromAllDeps() {
-    this.unsubscribeFromSourceDeps();
-    if (this.computedUnsubscribers.length === 0) return;
-    for (const unsub of this.computedUnsubscribers) unsub();
-    this.computedUnsubscribers = [];
-  }
-  ensureResubscribeAfterFlush() {
-    if (this.isResubscribeEnqueued) return;
-    this.isResubscribeEnqueued = true;
-    this.dequeueResubscribe = this.runtime.scheduleAfterFlush(
-      this.onAfterFlush
-    );
-  }
-};
-
-// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKey.ts
-var OIMSelectorSourceDependencyUpdateEventEmitterKey = class {
-  constructor(subscription, key) {
-    this.subscription = subscription;
-    this.key = key;
-  }
-  subscribe(onUpdate) {
-    return this.subscription.subscribeOnKey(this.key, onUpdate);
-  }
-};
-
-// src/modules/selector/core/OIMCollectionByPkSelector.ts
-var OIMCollectionByPkSelector = class extends OIMSelector {
-  constructor(runtime, collection, pk) {
-    super(runtime, [
-      new OIMSelectorSourceDependencyUpdateEventEmitterKey(
-        collection,
-        pk
-      )
-    ]);
-    this.collection = collection;
-    this.pk = pk;
-  }
-  getValue() {
-    return this.collection.getOneByPk(this.pk);
-  }
-};
-
-// src/modules/selector/core/OIMSelectorSourceDependencyUpdateEventEmitterKeys.ts
-var OIMSelectorSourceDependencyUpdateEventEmitterKeys = class {
-  constructor(subscription, keys) {
-    this.subscription = subscription;
-    this.keys = keys;
-  }
-  subscribe(onUpdate) {
-    return this.subscription.subscribeOnKeys(this.keys, onUpdate);
-  }
-};
-
-// src/modules/selector/core/OIMCollectionByPksSelector.ts
-var OIMCollectionByPksSelector = class extends OIMSelector {
-  constructor(runtime, collection, pks) {
-    super(runtime, [
-      new OIMSelectorSourceDependencyUpdateEventEmitterKeys(
-        collection,
-        pks
-      )
-    ]);
-    this.collection = collection;
-    this.pks = pks;
+      collection,
+      pkOrPks
+    );
   }
-  getValue() {
-    return this.pks.map((pk) => this.collection.getOneByPk(pk));
+  get source() {
+    return this.dep.source;
   }
-  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;
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
+  }
+};
+
+// src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
+var OIMEffectDependencyKeyedIndex = class {
+  constructor(index, keyOrKeys) {
+    this.dep = new OIMEffectDependencyKeyed(
+      index,
+      keyOrKeys
+    );
+  }
+  get source() {
+    return this.dep.source;
+  }
+  subscribe(onUpdate) {
+    return this.dep.subscribe(onUpdate);
   }
 };
 
@@ -2884,241 +3621,6 @@ var OIMIndexPksByKeysArrayBasedSelector = class extends OIMSelector {
     return true;
   }
 };
-
-// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByIndexKeySetBased.ts
-var OIMSelectorSourceDependencyEntitiesByIndexKeySetBased = class {
-  constructor(collection, reactiveIndex, key) {
-    this.collection = collection;
-    this.reactiveIndex = reactiveIndex;
-    this.key = key;
-    this.currentPks = [];
-  }
-  subscribe(onUpdate) {
-    const resubscribeCollection = () => {
-      const nextPks = Array.from(
-        this.reactiveIndex.getPksByKey(this.key)
-      );
-      if (this.sameArray(this.currentPks, nextPks)) return;
-      this.unsubscribeFromCollectionKeys?.();
-      this.unsubscribeFromCollectionKeys = void 0;
-      this.currentPks = nextPks;
-      if (this.currentPks.length === 0) return;
-      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
-    };
-    const onIndexUpdate = () => {
-      resubscribeCollection();
-      onUpdate();
-    };
-    resubscribeCollection();
-    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
-      this.key,
-      onIndexUpdate
-    );
-    return () => {
-      unsubscribeFromIndex();
-      this.unsubscribeFromCollectionKeys?.();
-      this.unsubscribeFromCollectionKeys = void 0;
-      this.currentPks = [];
-    };
-  }
-  sameArray(a, b) {
-    if (a === b) return true;
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-    return true;
-  }
-};
-
-// src/modules/selector/core/OIMEntitiesByIndexKeySetBasedSelector.ts
-var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
-  constructor(runtime, collection, reactiveIndex, key) {
-    super(runtime, [
-      new OIMSelectorSourceDependencyEntitiesByIndexKeySetBased(collection, reactiveIndex, key)
-    ]);
-    this.collection = collection;
-    this.reactiveIndex = reactiveIndex;
-    this.key = key;
-  }
-  getValue() {
-    const pks = Array.from(this.reactiveIndex.getPksByKey(this.key));
-    return pks.map((pk) => this.collection.getOneByPk(pk));
-  }
-  areEqual(prev, next) {
-    if (prev === next) return true;
-    if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
-      if (prev[i] !== next[i]) return false;
-    return true;
-  }
-};
-
-// src/modules/selector/core/OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased.ts
-var OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased = class {
-  constructor(collection, reactiveIndex, key) {
-    this.collection = collection;
-    this.reactiveIndex = reactiveIndex;
-    this.key = key;
-    this.currentPks = [];
-  }
-  subscribe(onUpdate) {
-    const resubscribeCollection = () => {
-      const nextPks = this.reactiveIndex.getPksByKey(this.key);
-      if (this.sameArray(this.currentPks, nextPks)) return;
-      this.unsubscribeFromCollectionKeys?.();
-      this.unsubscribeFromCollectionKeys = void 0;
-      this.currentPks = nextPks;
-      if (this.currentPks.length === 0) return;
-      this.unsubscribeFromCollectionKeys = this.collection.subscribeOnKeys(this.currentPks, onUpdate);
-    };
-    const onIndexUpdate = () => {
-      resubscribeCollection();
-      onUpdate();
-    };
-    resubscribeCollection();
-    const unsubscribeFromIndex = this.reactiveIndex.subscribeOnKey(
-      this.key,
-      onIndexUpdate
-    );
-    return () => {
-      unsubscribeFromIndex();
-      this.unsubscribeFromCollectionKeys?.();
-      this.unsubscribeFromCollectionKeys = void 0;
-      this.currentPks = [];
-    };
-  }
-  sameArray(a, b) {
-    if (a === b) return true;
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-    return true;
-  }
-};
-
-// src/modules/selector/core/OIMEntitiesByIndexKeyArrayBasedSelector.ts
-var OIMEntitiesByIndexKeyArrayBasedSelector = class extends OIMSelector {
-  constructor(runtime, collection, reactiveIndex, key) {
-    super(runtime, [
-      new OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased(collection, reactiveIndex, key)
-    ]);
-    this.collection = collection;
-    this.reactiveIndex = reactiveIndex;
-    this.key = key;
-  }
-  getValue() {
-    const pks = this.reactiveIndex.getPksByKey(this.key);
-    return pks.map((pk) => this.collection.getOneByPk(pk));
-  }
-  areEqual(prev, next) {
-    if (prev === next) return true;
-    if (prev.length !== next.length) return false;
-    for (let i = 0; i < prev.length; i++)
-      if (prev[i] !== next[i]) return false;
-    return true;
-  }
-};
-
-// src/modules/computative/core/OIMComputativeRuntime.ts
-var OIMComputativeRuntime = class {
-  constructor(queue) {
-    this.queue = queue;
-    this.isFlushScheduled = false;
-    this.isFlushing = false;
-    this.minLevel = Infinity;
-    this.maxLevel = -Infinity;
-    this.dirtyByLevel = /* @__PURE__ */ new Map();
-    this.afterFlushTasks = /* @__PURE__ */ new Set();
-    this.queue.emitter.on(0 /* AFTER_FLUSH */, () => {
-      if (!this.isFlushScheduled) return;
-      this.flush();
-    });
-  }
-  /**
-   * Schedule a one-shot task to run on the next `queue.flush()` (AFTER_FLUSH),
-   * ordered by `level` ascending.
-   */
-  schedule(task, level = 0) {
-    let isActive = true;
-    const wrapped = () => {
-      if (!isActive) return;
-      task();
-    };
-    let bucket = this.dirtyByLevel.get(level);
-    if (!bucket) {
-      bucket = /* @__PURE__ */ new Set();
-      this.dirtyByLevel.set(level, bucket);
-    }
-    bucket.add(wrapped);
-    if (level < this.minLevel) this.minLevel = level;
-    if (level > this.maxLevel) this.maxLevel = level;
-    if (!this.isFlushing) this.isFlushScheduled = true;
-    return () => {
-      if (!isActive) return;
-      isActive = false;
-      bucket.delete(wrapped);
-    };
-  }
-  /**
-   * Run once at the start of the next runtime flush (i.e. after queue.flush()).
-   * Useful for resubscribing dependencies exactly once per source flush.
-   */
-  scheduleAfterFlush(task) {
-    let isActive = true;
-    const wrapped = () => {
-      if (!isActive) return;
-      task();
-    };
-    this.afterFlushTasks.add(wrapped);
-    if (!this.isFlushing) this.isFlushScheduled = true;
-    return () => {
-      if (!isActive) return;
-      isActive = false;
-      this.afterFlushTasks.delete(wrapped);
-    };
-  }
-  flush() {
-    this.isFlushScheduled = false;
-    if (this.dirtyByLevel.size === 0 && this.afterFlushTasks.size === 0)
-      return;
-    this.isFlushing = true;
-    try {
-      if (this.afterFlushTasks.size > 0) {
-        const snapshot = Array.from(this.afterFlushTasks);
-        this.afterFlushTasks.clear();
-        for (let i = 0; i < snapshot.length; i++) snapshot[i]();
-      }
-      if (this.dirtyByLevel.size === 0) return;
-      let level = this.minLevel;
-      let max = this.maxLevel;
-      while (level <= max) {
-        for (; ; ) {
-          const bucket = this.dirtyByLevel.get(level);
-          if (!bucket || bucket.size === 0) break;
-          this.dirtyByLevel.delete(level);
-          const snapshot = Array.from(bucket);
-          for (let i = 0; i < snapshot.length; i++) snapshot[i]();
-        }
-        if (this.maxLevel > max) max = this.maxLevel;
-        level++;
-      }
-    } finally {
-      this.isFlushing = false;
-      if (this.dirtyByLevel.size === 0) {
-        this.minLevel = Infinity;
-        this.maxLevel = -Infinity;
-      } else {
-        let nextMin = Infinity;
-        let nextMax = -Infinity;
-        this.dirtyByLevel.forEach((_bucket, lvl) => {
-          if (lvl < nextMin) nextMin = lvl;
-          if (lvl > nextMax) nextMax = lvl;
-        });
-        this.minLevel = nextMin;
-        this.maxLevel = nextMax;
-        this.isFlushScheduled = true;
-      }
-    }
-  }
-};
 export {
   EOIMCollectionEventType,
   EOIMComputedEventType,
@@ -3129,13 +3631,19 @@ export {
   OIMCollection,
   OIMCollectionByPkSelector,
   OIMCollectionByPksSelector,
-  OIMCollectionChangedFieldsWrapper,
+  OIMCollectionChangedFields,
+  OIMCollectionIndexFactory,
+  OIMCollectionIndexManualOrderedArrayBased,
+  OIMCollectionOrderedListCommandStream,
+  OIMCollectionSelectors,
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
-  OIMComputativeRuntime,
+  OIMComputeRuntime,
   OIMComputed,
   OIMDBSettings,
+  OIMDerivedCollectionIndexArrayBased,
+  OIMDerivedCollectionIndexSetBased,
   OIMEffect,
   OIMEffectDependencyComputed,
   OIMEffectDependencyKeyed,
@@ -3153,6 +3661,7 @@ export {
   OIMEventQueueSchedulerImmediate,
   OIMEventQueueSchedulerMicrotask,
   OIMEventQueueSchedulerTimeout,
+  OIMIndex,
   OIMIndexArrayBased,
   OIMIndexComparatorFactory,
   OIMIndexManualArrayBased,
@@ -3174,14 +3683,18 @@ export {
   OIMObjectStoreRecordDriven,
   OIMObjectValueByKeySelector,
   OIMObjectValuesByKeysSelector,
-  OIMOrderedListIndexCommandStreamWrapper,
+  OIMOrderedListCommandStream,
   OIMPkSelectorFactory,
-  OIMRICollection,
   OIMReactiveCollection,
+  OIMReactiveCollectionIndexManualArrayBased,
+  OIMReactiveCollectionIndexManualSetBased,
+  OIMReactiveIndex,
   OIMReactiveIndexArrayBased,
   OIMReactiveIndexManualArrayBased,
   OIMReactiveIndexManualSetBased,
   OIMReactiveIndexSetBased,
   OIMReactiveObject,
-  OIMSelector
+  OIMSelector,
+  createOIMCollectionContext,
+  createOIMCollectionIndexFactory
 };