@oimdb/core 1.4.1 → 1.5.0

package/dist/index.cjs

@@ -239,58 +239,75 @@ var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
 var OIMIndexStoreMapDrivenSetBased = class extends OIMIndexStoreSetBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexSetBased.ts
 var OIMIndexSetBased = class {
   constructor(options = {}) {
+    this.fallbackSlots = /* @__PURE__ */ new Map();
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
     this.store = options.store ?? new OIMIndexStoreMapDrivenSetBased();
+    this.resolveSlot = options.resolveSlot;
   }
   /**
    * Get primary keys for multiple index keys
    */
   getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
+  }
+  setSlotResolver(resolveSlot) {
+    this.resolveSlot = resolveSlot;
+    const allSlots = this.store.getAll();
+    for (const [key, slots] of allSlots) {
+      this.store.setOneByKey(
+        key,
+        this.resolveSlots(this.slotsToPks(slots))
+      );
+    }
   }
   /**
    * @deprecated Use getPksByKey instead
@@ -303,8 +320,15 @@ var OIMIndexSetBased = class {
    * Get primary keys for a specific index key
    */
   getPksByKey(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet : /* @__PURE__ */ new Set();
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? this.slotsToPks(slotsSet) : /* @__PURE__ */ new Set();
+  }
+  getSlotsByKey(key) {
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? slotsSet : /* @__PURE__ */ new Set();
+  }
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
   /**
    * Check if an index key exists
@@ -322,8 +346,8 @@ var OIMIndexSetBased = class {
    * Get the number of primary keys for a specific index key
    */
   getKeySize(key) {
-    const pksSet = this.store.getOneByKey(key);
-    return pksSet ? pksSet.size : 0;
+    const slotsSet = this.store.getOneByKey(key);
+    return slotsSet ? slotsSet.size : 0;
   }
   /**
    * Get total number of index keys
@@ -345,10 +369,10 @@ var OIMIndexSetBased = class {
     let maxBucketSize = 0;
     let minBucketSize = Infinity;
     const allPks = this.store.getAll();
-    for (const pksSet of allPks.values()) {
-      totalPks += pksSet.size;
-      maxBucketSize = Math.max(maxBucketSize, pksSet.size);
-      minBucketSize = Math.min(minBucketSize, pksSet.size);
+    for (const slotsSet of allPks.values()) {
+      totalPks += slotsSet.size;
+      maxBucketSize = Math.max(maxBucketSize, slotsSet.size);
+      minBucketSize = Math.min(minBucketSize, slotsSet.size);
     }
     return {
       totalKeys: allPks.size,
@@ -370,21 +394,46 @@ var OIMIndexSetBased = class {
    * If comparator is provided and returns true (no changes), skip the update.
    */
   setPksWithComparison(key, newPks) {
+    return this.setSlotsWithComparison(key, this.resolveSlots(newPks));
+  }
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksSet = this.store.getOneByKey(key);
-      if (existingPksSet && existingPksSet.size === newPks.size) {
-        const existingPksArray = existingPksSet.size > 0 ? [...existingPksSet] : [];
-        const newPksArray = newPks.size > 0 ? [...newPks] : [];
+      const existingSlotsSet = this.store.getOneByKey(key);
+      if (existingSlotsSet && existingSlotsSet.size === newSlots.size) {
+        const existingPksArray = Array.from(
+          this.slotsToPks(existingSlotsSet)
+        );
+        const newPksArray = Array.from(this.slotsToPks(newSlots));
         if (this.comparePks(existingPksArray, newPksArray)) {
           return false;
         }
-      } else if (!existingPksSet && newPks.size === 0) {
+      } else if (!existingSlotsSet && newSlots.size === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
+  resolveSlots(pks) {
+    const slots = /* @__PURE__ */ new Set();
+    for (const pk of pks) slots.add(this.getOrCreateSlot(pk));
+    return slots;
+  }
+  getOrCreateSlot(pk) {
+    const resolved = this.resolveSlot?.(pk);
+    if (resolved) return resolved;
+    let fallback = this.fallbackSlots.get(pk);
+    if (!fallback) {
+      fallback = { pk, item: void 0 };
+      this.fallbackSlots.set(pk, fallback);
+    }
+    return fallback;
+  }
+  slotsToPks(slots) {
+    const pks = /* @__PURE__ */ new Set();
+    for (const slot of slots) pks.add(slot.pk);
+    return pks;
+  }
   /**
    * Emit update event with changed keys
    */
@@ -403,65 +452,89 @@ var OIMIndexSetBased = class {
 var OIMIndexStoreMapDrivenArrayBased = class extends OIMIndexStoreArrayBased {
   constructor() {
     super(...arguments);
-    this.pks = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
-  setOneByKey(key, pks) {
-    this.pks.set(key, pks);
+  setOneByKey(key, slots) {
+    this.slots.set(key, slots);
   }
   removeOneByKey(key) {
-    this.pks.delete(key);
+    this.slots.delete(key);
   }
   removeManyByKeys(keys) {
     for (const key of keys) {
-      this.pks.delete(key);
+      this.slots.delete(key);
     }
   }
   getOneByKey(key) {
-    return this.pks.get(key);
+    return this.slots.get(key);
   }
   getManyByKeys(keys) {
     const result = /* @__PURE__ */ new Map();
     for (const key of keys) {
-      const pks = this.getOneByKey(key);
-      if (pks !== void 0) {
-        result.set(key, pks);
+      const slots = this.getOneByKey(key);
+      if (slots !== void 0) {
+        result.set(key, slots);
       }
     }
     return result;
   }
   getAllKeys() {
-    return Array.from(this.pks.keys());
+    return Array.from(this.slots.keys());
   }
   getAll() {
-    return new Map(this.pks);
+    return new Map(this.slots);
   }
   countAll() {
-    return this.pks.size;
+    return this.slots.size;
   }
   clear() {
-    this.pks.clear();
+    this.slots.clear();
   }
 };
 
 // src/abstract/OIMIndexArrayBased.ts
 var OIMIndexArrayBased = class {
   constructor(options = {}) {
+    this.fallbackSlots = /* @__PURE__ */ new Map();
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
     this.store = options.store ?? new OIMIndexStoreMapDrivenArrayBased();
+    this.resolveSlot = options.resolveSlot;
   }
   /**
    * Get primary keys for multiple index keys
    */
   getPksByKeys(keys) {
-    return this.store.getManyByKeys(keys);
+    const result = /* @__PURE__ */ new Map();
+    const slotsByKey = this.store.getManyByKeys(keys);
+    for (const [key, slots] of slotsByKey) {
+      result.set(key, this.slotsToPks(slots));
+    }
+    return result;
+  }
+  setSlotResolver(resolveSlot) {
+    this.resolveSlot = resolveSlot;
+    const allSlots = this.store.getAll();
+    for (const [key, slots] of allSlots) {
+      this.store.setOneByKey(
+        key,
+        slots.map((slot) => this.getOrCreateSlot(slot.pk))
+      );
+    }
   }
   /**
    * Get primary keys for a specific index key
    */
   getPksByKey(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray : [];
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? this.slotsToPks(slotsArray) : [];
+  }
+  getSlotsByKey(key) {
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? slotsArray : [];
+  }
+  getSlotsByKeys(keys) {
+    return this.store.getManyByKeys(keys);
   }
   /**
    * Check if an index key exists
@@ -479,8 +552,8 @@ var OIMIndexArrayBased = class {
    * Get the number of primary keys for a specific index key
    */
   getKeySize(key) {
-    const pksArray = this.store.getOneByKey(key);
-    return pksArray ? pksArray.length : 0;
+    const slotsArray = this.store.getOneByKey(key);
+    return slotsArray ? slotsArray.length : 0;
   }
   /**
    * Get total number of index keys
@@ -502,10 +575,10 @@ var OIMIndexArrayBased = class {
     let maxBucketSize = 0;
     let minBucketSize = Infinity;
     const allPks = this.store.getAll();
-    for (const pksArray of allPks.values()) {
-      totalPks += pksArray.length;
-      maxBucketSize = Math.max(maxBucketSize, pksArray.length);
-      minBucketSize = Math.min(minBucketSize, pksArray.length);
+    for (const slotsArray of allPks.values()) {
+      totalPks += slotsArray.length;
+      maxBucketSize = Math.max(maxBucketSize, slotsArray.length);
+      minBucketSize = Math.min(minBucketSize, slotsArray.length);
     }
     return {
       totalKeys: allPks.size,
@@ -527,19 +600,49 @@ var OIMIndexArrayBased = class {
    * If comparator is provided and returns true (no changes), skip the update.
    */
   setPksWithComparison(key, newPks) {
+    return this.setSlotsWithComparison(key, this.resolveSlots(newPks));
+  }
+  setSlotsWithComparison(key, newSlots) {
     if (this.comparePks) {
-      const existingPksArray = this.store.getOneByKey(key);
-      if (existingPksArray && existingPksArray.length === newPks.length) {
-        if (this.comparePks(existingPksArray, newPks)) {
+      const existingSlotsArray = this.store.getOneByKey(key);
+      if (existingSlotsArray && existingSlotsArray.length === newSlots.length) {
+        if (this.comparePks(
+          this.slotsToPks(existingSlotsArray),
+          this.slotsToPks(newSlots)
+        )) {
           return false;
         }
-      } else if (!existingPksArray && newPks.length === 0) {
+      } else if (!existingSlotsArray && newSlots.length === 0) {
         return false;
       }
     }
-    this.store.setOneByKey(key, newPks);
+    this.store.setOneByKey(key, newSlots);
     return true;
   }
+  resolveSlots(pks) {
+    const slots = [];
+    slots.length = pks.length;
+    for (let i = 0; i < pks.length; i++) {
+      slots[i] = this.getOrCreateSlot(pks[i]);
+    }
+    return slots;
+  }
+  getOrCreateSlot(pk) {
+    const resolved = this.resolveSlot?.(pk);
+    if (resolved) return resolved;
+    let fallback = this.fallbackSlots.get(pk);
+    if (!fallback) {
+      fallback = { pk, item: void 0 };
+      this.fallbackSlots.set(pk, fallback);
+    }
+    return fallback;
+  }
+  slotsToPks(slots) {
+    const pks = [];
+    pks.length = slots.length;
+    for (let i = 0; i < slots.length; i++) pks[i] = slots[i].pk;
+    return pks;
+  }
   /**
    * Emit update event with changed keys
    */
@@ -820,6 +923,12 @@ var OIMReactiveIndexSetBased = class {
   getPksByKeys(keys) {
     return this.index.getPksByKeys(keys);
   }
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
+  }
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
+  }
   hasKey(key) {
     return this.index.hasKey(key);
   }
@@ -877,6 +986,12 @@ var OIMReactiveIndexArrayBased = class {
   getPksByKeys(keys) {
     return this.index.getPksByKeys(keys);
   }
+  getSlotsByKey(key) {
+    return this.index.getSlotsByKey(key);
+  }
+  getSlotsByKeys(keys) {
+    return this.index.getSlotsByKeys(keys);
+  }
   hasKey(key) {
     return this.index.hasKey(key);
   }
@@ -937,26 +1052,52 @@ var OIMPkSelectorFactory = class {
 var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   constructor() {
     super(...arguments);
-    this.entities = /* @__PURE__ */ new Map();
+    this.slots = /* @__PURE__ */ new Map();
   }
   setOneByPk(pk, entity) {
-    this.entities.set(pk, entity);
+    const slot = this.slots.get(pk);
+    if (slot) {
+      slot.item = entity;
+    } else {
+      this.slots.set(pk, { pk, item: entity });
+    }
   }
   setManyByPks(pks, entities) {
     for (let i = 0; i < pks.length; i++) {
-      this.entities.set(pks[i], entities[i]);
+      this.setOneByPk(pks[i], entities[i]);
+    }
+  }
+  getSlotByPk(pk) {
+    return this.slots.get(pk);
+  }
+  getSlotsByPks(pks) {
+    const result = [];
+    result.length = pks.length;
+    let writeIndex = 0;
+    for (let i = 0; i < pks.length; i++) {
+      const slot = this.slots.get(pks[i]);
+      if (slot !== void 0) {
+        result[writeIndex++] = slot;
+      }
     }
+    result.length = writeIndex;
+    return result;
+  }
+  getAllSlots() {
+    return Array.from(this.slots.values());
   }
   removeOneByPk(pk) {
-    this.entities.delete(pk);
+    const slot = this.slots.get(pk);
+    if (slot) slot.item = void 0;
+    this.slots.delete(pk);
   }
   removeManyByPks(pks) {
     for (const pk of pks) {
-      this.entities.delete(pk);
+      this.removeOneByPk(pk);
     }
   }
   getOneByPk(pk) {
-    return this.entities.get(pk);
+    return this.slots.get(pk)?.item;
   }
   getManyByPks(pks) {
     const result = [];
@@ -972,16 +1113,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();
@@ -1017,6 +1165,15 @@ var OIMCollection = class {
   getManyByPks(pks) {
     return this.store.getManyByPks(pks);
   }
+  getSlotByPk(pk) {
+    return this.store.getSlotByPk(pk);
+  }
+  getSlotsByPks(pks) {
+    return this.store.getSlotsByPks(pks);
+  }
+  getAllSlots() {
+    return this.store.getAllSlots();
+  }
   upsertOneByPk(pk, entity) {
     this.upsertOneWithoutNotificationsByPk(pk, entity);
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
@@ -1142,11 +1299,13 @@ var OIMReactiveCollection = class extends OIMCollection {
   }
   upsertOneByPk(pk, entity) {
     this.upsertOneWithoutNotificationsByPk(pk, entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   upsertOne(entity) {
     const pk = this.upsertOneWithoutNotifications(entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
@@ -1154,33 +1313,39 @@ var OIMReactiveCollection = class extends OIMCollection {
     const pks = entities.map(
       (entity) => this.upsertOneWithoutNotifications(entity)
     );
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   removeOne(entity) {
     const pk = this.selectPk(entity);
     this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   removeMany(entities) {
     const pks = entities.map(this.selectPk);
     this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   removeOneByPk(pk) {
     this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
     this.updateEmitter.markUpdatedKey(pk);
     this.trackAnyUpdatePk(pk);
   }
   removeManyByPks(pks) {
     this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
     this.updateEmitter.markUpdatedKeys(pks);
     this.trackAnyUpdatePks(pks);
   }
   clear() {
     this.store.clear();
+    this.emitter.emit(0 /* UPDATE */, { pks: [] });
     this.updateEmitter.markAllUpdated();
     this.trackAnyUpdateClear();
   }
@@ -1364,25 +1529,33 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
       this.emitUpdateOne(key);
     }
   }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, new Set(slots));
+    if (hasChanges) {
+      this.emitUpdateOne(key);
+    }
+  }
   /**
    * Add primary keys to a specific index key
    */
   addPks(key, pks) {
     if (pks.length === 0) return;
-    let pksSet = this.store.getOneByKey(key);
-    if (!pksSet) {
-      pksSet = /* @__PURE__ */ new Set();
-      this.store.setOneByKey(key, pksSet);
+    let slotsSet = this.store.getOneByKey(key);
+    if (!slotsSet) {
+      slotsSet = /* @__PURE__ */ new Set();
+      this.store.setOneByKey(key, slotsSet);
     }
+    const pksSet = this.slotsToPks(slotsSet);
     let hasChanges = false;
     for (const pk of pks) {
       if (!pksSet.has(pk)) {
         pksSet.add(pk);
+        slotsSet.add(this.getOrCreateSlot(pk));
         hasChanges = true;
       }
     }
     if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
+      this.store.setOneByKey(key, slotsSet);
       this.emitUpdateOne(key);
     }
   }
@@ -1391,19 +1564,20 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
    */
   removePks(key, pks) {
     if (pks.length === 0) return;
-    const pksSet = this.store.getOneByKey(key);
-    if (!pksSet) return;
+    const slotsSet = this.store.getOneByKey(key);
+    if (!slotsSet) return;
     let hasChanges = false;
-    for (const pk of pks) {
-      if (pksSet.delete(pk)) {
+    const pksToRemove = new Set(pks);
+    for (const slot of Array.from(slotsSet)) {
+      if (pksToRemove.has(slot.pk) && slotsSet.delete(slot)) {
         hasChanges = true;
       }
     }
-    if (pksSet.size === 0) {
+    if (slotsSet.size === 0) {
       this.store.removeOneByKey(key);
       hasChanges = true;
     } else if (hasChanges) {
-      this.store.setOneByKey(key, pksSet);
+      this.store.setOneByKey(key, slotsSet);
     }
     if (hasChanges) {
       this.emitUpdateOne(key);
@@ -1453,6 +1627,9 @@ var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
   setPks(key, pks) {
     this.index.setPks(key, pks);
   }
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
+  }
   addPks(key, pks) {
     this.index.addPks(key, pks);
   }
@@ -1479,26 +1656,34 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
       this.emitUpdateOne(key);
     }
   }
+  setSlots(key, slots) {
+    const hasChanges = this.setSlotsWithComparison(key, slots);
+    if (hasChanges) {
+      this.emitUpdateOne(key);
+    }
+  }
   /**
    * 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);
+    let slotsArray = this.store.getOneByKey(key);
+    if (!slotsArray) {
+      slotsArray = [];
+      this.store.setOneByKey(key, slotsArray);
     }
-    const pksSet = new Set(pksArray);
+    const pksSet = new Set(slotsArray.map((slot) => slot.pk));
     let hasChanges = false;
+    const nextSlots = slotsArray.slice();
     for (const pk of pks) {
       if (!pksSet.has(pk)) {
         pksSet.add(pk);
+        nextSlots.push(this.getOrCreateSlot(pk));
         hasChanges = true;
       }
     }
     if (hasChanges) {
-      this.store.setOneByKey(key, Array.from(pksSet));
+      this.store.setOneByKey(key, nextSlots);
       this.emitUpdateOne(key);
     }
   }
@@ -1507,11 +1692,11 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
    */
   removePks(key, pks) {
     if (pks.length === 0) return;
-    const pksArray = this.store.getOneByKey(key);
-    if (!pksArray) return;
+    const slotsArray = this.store.getOneByKey(key);
+    if (!slotsArray) return;
     const pksSet = new Set(pks);
-    const filtered = pksArray.filter((pk) => !pksSet.has(pk));
-    const hasChanges = filtered.length !== pksArray.length;
+    const filtered = slotsArray.filter((slot) => !pksSet.has(slot.pk));
+    const hasChanges = filtered.length !== slotsArray.length;
     if (hasChanges) {
       if (filtered.length === 0) {
         this.store.removeOneByKey(key);
@@ -1565,6 +1750,9 @@ var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased
   setPks(key, pks) {
     this.index.setPks(key, pks);
   }
+  setSlots(key, slots) {
+    this.index.setSlots(key, slots);
+  }
   addPks(key, pks) {
     this.index.addPks(key, pks);
   }
@@ -1581,6 +1769,10 @@ var OIMRICollection = class extends OIMReactiveCollection {
   constructor(queue, opts) {
     super(queue, opts.collectionOpts);
     this.indexes = opts.indexes || {};
+    const indexes = Object.values(this.indexes);
+    for (const index of indexes) {
+      index.index.setSlotResolver((pk) => this.getSlotByPk(pk));
+    }
   }
 };
 
@@ -2043,14 +2235,14 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
   push(key, itemKey) {
     const list = this.getOrCreateList(key);
     const index = list.length;
-    list.push(itemKey);
+    list.push(this.getOrCreateSlot(itemKey));
     this.emitUpdate([key]);
     return index;
   }
   insertAt(key, index, itemKey) {
     const list = this.getOrCreateList(key);
     const safeIndex = Math.max(0, Math.min(index, list.length));
-    list.splice(safeIndex, 0, itemKey);
+    list.splice(safeIndex, 0, this.getOrCreateSlot(itemKey));
     this.emitUpdate([key]);
   }
   removeAt(key, index) {
@@ -2062,19 +2254,19 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
       this.store.removeOneByKey(key);
     }
     this.emitUpdate([key]);
-    return removed;
+    return removed?.pk;
   }
   move(key, fromIndex, toIndex) {
     const list = this.store.getOneByKey(key);
     if (!list) return void 0;
     if (fromIndex < 0 || fromIndex >= list.length) return void 0;
     if (toIndex < 0 || toIndex >= list.length) return void 0;
-    if (fromIndex === toIndex) return list[fromIndex];
+    if (fromIndex === toIndex) return list[fromIndex]?.pk;
     const [itemKey] = list.splice(fromIndex, 1);
     if (itemKey === void 0) return void 0;
     list.splice(toIndex, 0, itemKey);
     this.emitUpdate([key]);
-    return itemKey;
+    return itemKey.pk;
   }
   reset(key, itemKeys) {
     if (itemKeys.length === 0) {
@@ -2084,7 +2276,7 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
       }
       return;
     }
-    this.store.setOneByKey(key, Array.from(itemKeys));
+    this.store.setOneByKey(key, this.resolveSlots(itemKeys));
     this.emitUpdate([key]);
   }
   getOrCreateList(key) {
@@ -2985,7 +3177,8 @@ var OIMSelectorSourceDependencyEntitiesByIndexKeySetBased = class {
   subscribe(onUpdate) {
     const resubscribeCollection = () => {
       const nextPks = Array.from(
-        this.reactiveIndex.getPksByKey(this.key)
+        this.reactiveIndex.getSlotsByKey(this.key),
+        (slot) => slot.pk
       );
       if (this.sameArray(this.currentPks, nextPks)) return;
       this.unsubscribeFromCollectionKeys?.();
@@ -3027,10 +3220,19 @@ var OIMEntitiesByIndexKeySetBasedSelector = class extends OIMSelector {
     this.collection = collection;
     this.reactiveIndex = reactiveIndex;
     this.key = key;
+    this.reactiveIndex.index.setSlotResolver(
+      (pk) => this.collection.getSlotByPk(pk)
+    );
   }
   getValue() {
-    const pks = Array.from(this.reactiveIndex.getPksByKey(this.key));
-    return pks.map((pk) => this.collection.getOneByPk(pk));
+    const slots = this.reactiveIndex.getSlotsByKey(this.key);
+    const entities = [];
+    entities.length = slots.size;
+    let writeIndex = 0;
+    for (const slot of slots) {
+      entities[writeIndex++] = slot.item;
+    }
+    return entities;
   }
   areEqual(prev, next) {
     if (prev === next) return true;
@@ -3051,7 +3253,7 @@ var OIMSelectorSourceDependencyEntitiesByIndexKeyArrayBased = class {
   }
   subscribe(onUpdate) {
     const resubscribeCollection = () => {
-      const nextPks = this.reactiveIndex.getPksByKey(this.key);
+      const nextPks = this.reactiveIndex.getSlotsByKey(this.key).map((slot) => slot.pk);
       if (this.sameArray(this.currentPks, nextPks)) return;
       this.unsubscribeFromCollectionKeys?.();
       this.unsubscribeFromCollectionKeys = void 0;
@@ -3092,10 +3294,18 @@ var OIMEntitiesByIndexKeyArrayBasedSelector = class extends OIMSelector {
     this.collection = collection;
     this.reactiveIndex = reactiveIndex;
     this.key = key;
+    this.reactiveIndex.index.setSlotResolver(
+      (pk) => this.collection.getSlotByPk(pk)
+    );
   }
   getValue() {
-    const pks = this.reactiveIndex.getPksByKey(this.key);
-    return pks.map((pk) => this.collection.getOneByPk(pk));
+    const slots = this.reactiveIndex.getSlotsByKey(this.key);
+    const entities = [];
+    entities.length = slots.length;
+    for (let i = 0; i < slots.length; i++) {
+      entities[i] = slots[i].item;
+    }
+    return entities;
   }
   areEqual(prev, next) {
     if (prev === next) return true;