@oimdb/core 3.8.0 → 3.10.0

package/dist/index.js

@@ -550,7 +550,7 @@ var OIMIndexArrayBased = class extends OIMIndex {
 
 // src/core/OIMCarrierKeyedEmitter.ts
 var OIMCarrierKeyedEmitter = class {
-  constructor(queue, resolver) {
+  constructor(queue, carrierProvider) {
     // Carriers with at least one subscriber — for markAllUpdated / metrics.
     this.subscribedCarriers = /* @__PURE__ */ new Set();
     // Pending flush batch. A plain array + a `carrier.dirty` flag for dedup —
@@ -575,17 +575,17 @@ var OIMCarrierKeyedEmitter = class {
       }
     };
     this.queue = queue;
-    this.resolver = resolver;
+    this.carrierProvider = carrierProvider;
   }
   subscribeOnKey(key, handler) {
-    const carrier = this.resolver.getOrReserveCarrier(key);
+    const carrier = this.carrierProvider.getOrReserveCarrier(key);
     this.addHandler(carrier, handler);
     return () => this.removeHandler(carrier, handler);
   }
   subscribeOnKeys(keys, handler) {
     const carriers = [];
     for (let i = 0; i < keys.length; i++) {
-      const carrier = this.resolver.getOrReserveCarrier(keys[i]);
+      const carrier = this.carrierProvider.getOrReserveCarrier(keys[i]);
       this.addHandler(carrier, handler);
       carriers.push(carrier);
     }
@@ -596,7 +596,7 @@ var OIMCarrierKeyedEmitter = class {
     };
   }
   unsubscribeFromKey(key, handler) {
-    const carrier = this.resolver.findCarrier(key);
+    const carrier = this.carrierProvider.findCarrier(key);
     if (carrier) this.removeHandler(carrier, handler);
   }
   unsubscribeFromKeys(keys, handler) {
@@ -619,7 +619,7 @@ var OIMCarrierKeyedEmitter = class {
     subscribers.delete(handler);
     if (subscribers.size === 0) {
       this.subscribedCarriers.delete(carrier);
-      this.resolver.onCarrierEmptied?.(carrier);
+      this.carrierProvider.onCarrierEmptied?.(carrier);
     }
   }
   /** Fast path: the writer already holds the carrier. */
@@ -637,7 +637,7 @@ var OIMCarrierKeyedEmitter = class {
       this.assertNotInFlush();
       return;
     }
-    const carrier = this.resolver.findCarrier(key);
+    const carrier = this.carrierProvider.findCarrier(key);
     if (carrier) this.markUpdatedCarrier(carrier);
     else this.assertNotInFlush();
   }
@@ -662,7 +662,7 @@ var OIMCarrierKeyedEmitter = class {
     return this.subscribedCarriers.size > 0;
   }
   getHandlerCount(key) {
-    return this.resolver.findCarrier(key)?.subscribers?.size ?? 0;
+    return this.carrierProvider.findCarrier(key)?.subscribers?.size ?? 0;
   }
   getMetrics() {
     let totalHandlers = 0;
@@ -722,8 +722,8 @@ var OIMCarrierKeyedEmitter = class {
   }
 };
 
-// src/core/OIMKeyedCarrierResolver.ts
-var OIMKeyedCarrierResolver = class {
+// src/core/OIMKeyedCarrierProvider.ts
+var OIMKeyedCarrierProvider = class {
   constructor() {
     this.carriers = /* @__PURE__ */ new Map();
   }
@@ -745,8 +745,8 @@ var OIMKeyedCarrierResolver = class {
 
 // src/abstract/OIMReactiveIndex.ts
 var OIMReactiveIndex = class {
-  constructor(queue, createIndex, createResolver = () => new OIMKeyedCarrierResolver()) {
-    this.updateEmitter = new OIMCarrierKeyedEmitter(queue, createResolver());
+  constructor(queue, createIndex, createCarrierProvider = () => new OIMKeyedCarrierProvider()) {
+    this.updateEmitter = new OIMCarrierKeyedEmitter(queue, createCarrierProvider());
     this.index = createIndex(this.updateEmitter);
   }
   getEntitiesByKey(key) {
@@ -802,8 +802,8 @@ var OIMReactiveIndex = class {
 
 // src/abstract/OIMReactiveIndexSetBased.ts
 var OIMReactiveIndexSetBased = class extends OIMReactiveIndex {
-  constructor(queue, createIndex, createResolver) {
-    super(queue, createIndex, createResolver);
+  constructor(queue, createIndex, createCarrierProvider) {
+    super(queue, createIndex, createCarrierProvider);
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -821,8 +821,8 @@ var OIMReactiveIndexSetBased = class extends OIMReactiveIndex {
 
 // src/abstract/OIMReactiveIndexArrayBased.ts
 var OIMReactiveIndexArrayBased = class extends OIMReactiveIndex {
-  constructor(queue, createIndex, createResolver) {
-    super(queue, createIndex, createResolver);
+  constructor(queue, createIndex, createCarrierProvider) {
+    super(queue, createIndex, createCarrierProvider);
   }
   getPksByKey(key) {
     return this.index.getPksByKey(key);
@@ -1097,24 +1097,10 @@ var OIMPkSelectorFactory = class {
   }
 };
 
-// src/core/OIMKeyDomainNative.ts
-var OIMKeyDomainNative = class {
-  createMap() {
-    return /* @__PURE__ */ new Map();
-  }
-  createSet() {
-    return /* @__PURE__ */ new Set();
-  }
-  canonicalize(key) {
-    return key;
-  }
-};
-
 // src/core/OIMCollectionStoreMapDriven.ts
 var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   constructor() {
     super(...arguments);
-    this.keyDomain = new OIMKeyDomainNative();
     this.slots = /* @__PURE__ */ new Map();
     // Slots reserved by indexes for PKs whose entity has not arrived yet.
     // They carry `item: undefined` and live apart from `slots` so they do not
@@ -1287,10 +1273,6 @@ var OIMCollection = class {
     this.store = opts?.store ?? new OIMCollectionStoreMapDriven();
     this.updateEntity = opts?.updateEntity ?? new OIMEntityUpdaterFactory().createMergeEntityUpdater();
   }
-  /** The collection's PK keying strategy — read by indexes and wrappers. */
-  get keyDomain() {
-    return this.store.keyDomain;
-  }
   getOneByPk(pk) {
     return this.store.getOneByPk(pk);
   }
@@ -1303,6 +1285,14 @@ var OIMCollection = class {
   getOrReserveSlotByPk(pk) {
     return this.store.getOrReserveSlotByPk(pk);
   }
+  /**
+   * The existing slot for `pk` (live or reserved) WITHOUT creating one — used
+   * by indexes to resolve a pk to its canonical slot for removal (delete by
+   * reference), with no side effect for a pk that is not present.
+   */
+  findSlotByPk(pk) {
+    return this.store.findSlotByPk(pk);
+  }
   getSlotsByPks(pks) {
     return this.store.getSlotsByPks(pks);
   }
@@ -1389,7 +1379,9 @@ var OIMReactiveCollection = class extends OIMCollection {
   constructor(queue, opts) {
     super(opts);
     this.anyUpdateHandlers = /* @__PURE__ */ new Set();
-    this.pendingAnyUpdatePks = this.store.keyDomain.createSet();
+    // Only ever holds `slot.pk` (one canonical reference per logical key), so a
+    // native `Set` dedups correctly by reference even for composite pks.
+    this.pendingAnyUpdatePks = /* @__PURE__ */ new Set();
     this.isAnyUpdateClearPending = false;
     this.isAnyUpdateScheduled = false;
     this.runAnyUpdate = () => {
@@ -1665,16 +1657,16 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
 var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrderedArrayBased {
   constructor(opts) {
     super();
-    this.resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getSlotByPk(pk) : opts.resolveSlot;
+    this.getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getSlotByPk(pk) : opts.getSlot;
   }
   push(key, pk) {
-    return this.pushSlot(key, this.resolveRequiredSlot(pk));
+    return this.pushSlot(key, this.getRequiredSlot(pk));
   }
   insertAt(key, index, pk) {
-    return this.insertSlotAt(key, index, this.resolveRequiredSlot(pk));
+    return this.insertSlotAt(key, index, this.getRequiredSlot(pk));
   }
   reset(key, pks) {
-    this.resetSlots(key, this.resolveSlots(pks));
+    this.resetSlots(key, this.getRequiredSlots(pks));
   }
   getEntitiesByKey(key) {
     return super.getEntitiesByKey(key);
@@ -1682,32 +1674,32 @@ var OIMCollectionIndexManualOrderedArrayBased = class extends OIMIndexManualOrde
   getEntitiesByKeys(keys) {
     return super.getEntitiesByKeys(keys);
   }
-  resolvePk(pk) {
-    return this.resolveRequiredSlot(pk);
+  // Gets the slot for a pk, throwing if the (custom) getter has none — this
+  // ordered index requires a real slot to place in order.
+  getRequiredSlot(pk) {
+    const slot = this.getSlot(pk);
+    if (!slot) {
+      throw new Error(
+        `[OIMCollectionIndexManualOrderedArrayBased]: no slot for PK "${String(pk)}".`
+      );
+    }
+    return slot;
   }
-  resolveSlots(pks) {
+  getRequiredSlots(pks) {
     const slots = [];
     slots.length = pks.length;
     for (let i = 0; i < pks.length; i++) {
-      slots[i] = this.resolveRequiredSlot(pks[i]);
+      slots[i] = this.getRequiredSlot(pks[i]);
     }
     return slots;
   }
-  resolveRequiredSlot(pk) {
-    const slot = this.resolveSlot(pk);
-    if (!slot) {
-      throw new Error(
-        `[OIMCollectionIndexManualOrderedArrayBased]: Unable to resolve slot for PK "${String(pk)}".`
-      );
-    }
-    return slot;
-  }
 };
 
 // src/enums/EOIMEventQueueEventType.ts
 var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
   EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["FLUSH_ERROR"] = 2] = "FLUSH_ERROR";
   return EOIMEventQueueEventType2;
 })(EOIMEventQueueEventType || {});
 
@@ -2120,18 +2112,18 @@ var OIMOrderedListCommandStream = class extends OIMOrderedListCommandBuffer {
 var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandStream {
   constructor(queue, opts) {
     const index = opts.index ?? new OIMCollectionIndexManualOrderedArrayBased(
-      opts.collection !== void 0 ? { collection: opts.collection } : { resolveSlot: opts.resolveSlot }
+      opts.collection !== void 0 ? { collection: opts.collection } : { getSlot: opts.getSlot }
     );
     super(queue, index);
     this.index = index;
   }
   push(key, pk) {
-    const slot = this.resolvePk(pk);
+    const slot = this.getRequiredSlot(pk);
     const index = this.index.pushSlot(key, slot);
     this.appendCommand(key, { type: "insert", index, item: slot });
   }
   insertAt(key, index, pk) {
-    const slot = this.resolvePk(pk);
+    const slot = this.getRequiredSlot(pk);
     const safeIndex = this.index.insertSlotAt(key, index, slot);
     this.appendCommand(key, {
       type: "insert",
@@ -2141,7 +2133,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
   }
   /** Replace the element at `index` with the slot for `pk`, in place. */
   setAt(key, index, pk) {
-    const slot = this.resolvePk(pk);
+    const slot = this.getRequiredSlot(pk);
     const safeIndex = this.index.setSlotAt(key, index, slot);
     if (safeIndex < 0) return;
     this.appendCommand(key, {
@@ -2151,7 +2143,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     });
   }
   set(key, pks) {
-    const slots = pks.map((pk) => this.resolvePk(pk));
+    const slots = pks.map((pk) => this.getRequiredSlot(pk));
     this.index.resetSlots(key, slots);
     this.appendResetCommand(key, slots);
   }
@@ -2163,8 +2155,8 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
   getEntitiesByKey(key) {
     return this.index.getEntitiesByKey(key);
   }
-  resolvePk(pk) {
-    return this.index.resolvePk(
+  getRequiredSlot(pk) {
+    return this.index.getRequiredSlot(
       pk
     );
   }
@@ -2224,8 +2216,8 @@ var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
   }
 };
 
-// src/core/OIMBucketCarrierResolver.ts
-var OIMBucketCarrierResolver = class {
+// src/core/OIMBucketCarrierProvider.ts
+var OIMBucketCarrierProvider = class {
   constructor(store) {
     this.store = store;
   }
@@ -2266,7 +2258,7 @@ var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased
         comparePks: opts?.indexOptions?.comparePks,
         store
       }),
-      () => new OIMBucketCarrierResolver(store)
+      () => new OIMBucketCarrierProvider(store)
     );
   }
   setSlots(key, slots) {
@@ -2283,52 +2275,61 @@ var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased
 // src/core/OIMReactiveCollectionIndexManualArrayBased.ts
 var OIMReactiveCollectionIndexManualArrayBased = class extends OIMReactiveIndexManualArrayBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
-    const pkDomain = opts.collection?.keyDomain ?? new OIMKeyDomainNative();
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, {
       indexOptions: opts.indexOptions
     });
-    // Persistent per-key pk membership for O(1) `addPks` dedup (avoids rebuilding
-    // a Set from the whole bucket on every call). Kept in sync by setSlots/clear.
-    this.pksByKey = /* @__PURE__ */ new Map();
-    this.resolveSlot = resolveSlot;
-    this.pkDomain = pkDomain;
+    // Persistent per-key membership for O(1) `addPks` dedup, keyed by the
+    // canonical slot reference (correct for composite pks with a native Set — no
+    // content-addressing needed, since slots are one reference per logical key).
+    this.slotsByKey = /* @__PURE__ */ new Map();
+    this.getSlot = getSlot;
+    this.findSlotForRemoval = opts.collection !== void 0 ? (pk) => opts.collection.findSlotByPk(pk) : opts.getSlot;
   }
   setPks(key, pks) {
-    const pkSet = this.pkDomain.createSet();
-    for (let i = 0; i < pks.length; i++) pkSet.add(pks[i]);
-    this.pksByKey.set(key, pkSet);
-    super.setSlots(key, this.resolveSlots(pks));
+    const slots = this.getSlotsOrTransient(pks);
+    this.slotsByKey.set(key, new Set(slots));
+    super.setSlots(key, slots);
   }
   addPks(key, pks) {
     if (pks.length === 0) return;
-    const pkSet = this.membershipOf(key);
+    const slotSet = this.membershipOf(key);
     const newSlots = [];
     for (const pk of pks) {
-      if (pkSet.has(pk)) continue;
-      pkSet.add(pk);
-      newSlots.push(this.resolveRequiredSlot(pk));
+      const slot = this.getSlotOrTransient(pk);
+      if (slotSet.has(slot)) continue;
+      slotSet.add(slot);
+      newSlots.push(slot);
     }
     if (newSlots.length > 0) this.appendSlots(key, newSlots);
   }
   removePks(key, pks) {
     if (pks.length === 0) return;
-    const pksToRemove = new Set(pks);
+    const slotsToRemove = /* @__PURE__ */ new Set();
+    const pksToRemove = /* @__PURE__ */ new Set();
+    for (let i = 0; i < pks.length; i++) {
+      const slot = this.findSlotForRemoval(pks[i]);
+      if (slot) slotsToRemove.add(slot);
+      else pksToRemove.add(pks[i]);
+    }
     const existingSlots = this.index.getSlotsByKey(key);
-    const nextSlots = existingSlots.filter(
-      (slot) => !pksToRemove.has(slot.pk)
-    );
-    if (nextSlots.length === existingSlots.length) return;
-    const pkSet = this.pksByKey.get(key);
-    if (pkSet) {
-      for (let i = 0; i < pks.length; i++) pkSet.delete(pks[i]);
+    const slotSet = this.slotsByKey.get(key);
+    const nextSlots = [];
+    for (let i = 0; i < existingSlots.length; i++) {
+      const slot = existingSlots[i];
+      if (slotsToRemove.has(slot) || pksToRemove.has(slot.pk)) {
+        slotSet?.delete(slot);
+      } else {
+        nextSlots.push(slot);
+      }
     }
+    if (nextSlots.length === existingSlots.length) return;
     if (nextSlots.length === 0) this.clear(key);
     else super.setSlots(key, nextSlots);
   }
   clear(key) {
-    if (key === void 0) this.pksByKey.clear();
-    else this.pksByKey.delete(key);
+    if (key === void 0) this.slotsByKey.clear();
+    else this.slotsByKey.delete(key);
     super.clear(key);
   }
   /**
@@ -2336,16 +2337,12 @@ var OIMReactiveCollectionIndexManualArrayBased = class extends OIMReactiveIndexM
    * stays correct even if slots were set through a lower-level path.
    */
   membershipOf(key) {
-    let pkSet = this.pksByKey.get(key);
-    if (!pkSet) {
-      pkSet = this.pkDomain.createSet();
-      const existing = this.index.getSlotsByKey(key);
-      for (let i = 0; i < existing.length; i++) {
-        pkSet.add(existing[i].pk);
-      }
-      this.pksByKey.set(key, pkSet);
+    let slotSet = this.slotsByKey.get(key);
+    if (!slotSet) {
+      slotSet = new Set(this.index.getSlotsByKey(key));
+      this.slotsByKey.set(key, slotSet);
     }
-    return pkSet;
+    return slotSet;
   }
   getEntitiesByKey(key) {
     return super.getEntitiesByKey(key);
@@ -2353,16 +2350,16 @@ var OIMReactiveCollectionIndexManualArrayBased = class extends OIMReactiveIndexM
   getEntitiesByKeys(keys) {
     return super.getEntitiesByKeys(keys);
   }
-  resolveSlots(pks) {
+  getSlotsOrTransient(pks) {
     const slots = [];
     slots.length = pks.length;
     for (let i = 0; i < pks.length; i++) {
-      slots[i] = this.resolveRequiredSlot(pks[i]);
+      slots[i] = this.getSlotOrTransient(pks[i]);
     }
     return slots;
   }
-  resolveRequiredSlot(pk) {
-    const slot = this.resolveSlot(pk);
+  getSlotOrTransient(pk) {
+    const slot = this.getSlot(pk);
     if (!slot) return { pk, item: void 0 };
     return slot;
   }
@@ -2372,7 +2369,6 @@ var OIMReactiveCollectionIndexManualArrayBased = class extends OIMReactiveIndexM
 var OIMIndexManualSetBased = class extends OIMIndexSetBased {
   constructor(options = {}) {
     super(options);
-    this.pkDomain = options.pkDomain ?? new OIMKeyDomainNative();
   }
   setSlots(key, slots) {
     const bucket = this.setStore.getOrReserveBucket(key);
@@ -2381,27 +2377,28 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
   // --- pk-oriented writes: resolve the bucket ONCE and use its own membership
   // (pk → slot) for dedup/removal, so a composite (trie) key is walked a single
   // time instead of once for the bucket and once for a separate membership map.
-  setPks(key, pks, resolveSlot) {
+  setPks(key, pks, getSlot) {
     const bucket = this.setStore.getOrReserveBucket(key);
     const slots = [];
-    for (let i = 0; i < pks.length; i++) slots.push(resolveSlot(pks[i]));
+    for (let i = 0; i < pks.length; i++) slots.push(getSlot(pks[i]));
     this.replaceBucketContents(bucket, slots);
-    const membership = bucket.membership ?? (bucket.membership = this.pkDomain.createMap());
+    const membership = bucket.membership ?? (bucket.membership = /* @__PURE__ */ new Map());
     membership.clear();
-    for (let i = 0; i < pks.length; i++) {
-      if (!membership.has(pks[i])) membership.set(pks[i], slots[i]);
+    for (let i = 0; i < slots.length; i++) {
+      if (!membership.has(slots[i].pk)) {
+        membership.set(slots[i].pk, slots[i]);
+      }
     }
   }
-  addPks(key, pks, resolveSlot) {
+  addPks(key, pks, getSlot) {
     if (pks.length === 0) return;
     const bucket = this.setStore.getOrReserveBucket(key);
     const membership = this.membershipOf(bucket);
     let changed = false;
     for (let i = 0; i < pks.length; i++) {
-      const pk = pks[i];
-      if (membership.has(pk)) continue;
-      const slot = resolveSlot(pk);
-      membership.set(pk, slot);
+      const slot = getSlot(pks[i]);
+      if (membership.has(slot.pk)) continue;
+      membership.set(slot.pk, slot);
       if (!bucket.has(slot)) {
         bucket.add(slot);
         changed = true;
@@ -2411,6 +2408,11 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
     this.setStore.retainBucket(bucket);
     this.emitBucketChanged(bucket);
   }
+  /**
+   * Removes by pk. `pks` must be canonical `slot.pk` references (membership is
+   * keyed by them): for primitive pks that is just the pk; a collection-bound
+   * composite index canonicalizes raw pks to `slot.pk` before calling this.
+   */
   removePks(key, pks) {
     if (pks.length === 0) return;
     const bucket = this.setStore.findBucket(key);
@@ -2436,7 +2438,7 @@ var OIMIndexManualSetBased = class extends OIMIndexSetBased {
   membershipOf(bucket) {
     let membership = bucket.membership;
     if (!membership) {
-      membership = this.pkDomain.createMap();
+      membership = /* @__PURE__ */ new Map();
       bucket.membership = membership;
     }
     if (membership.size === 0 && bucket.size > 0) {
@@ -2545,10 +2547,9 @@ var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
       queue,
       (updateEmitter) => new OIMIndexManualSetBasedReactive(updateEmitter, {
         comparePks: opts?.indexOptions?.comparePks,
-        store,
-        pkDomain: opts?.pkDomain
+        store
       }),
-      () => new OIMBucketCarrierResolver(store)
+      () => new OIMBucketCarrierProvider(store)
     );
   }
   setSlots(key, slots) {
@@ -2568,28 +2569,33 @@ var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
 // src/core/OIMReactiveCollectionIndexManualSetBased.ts
 var OIMReactiveCollectionIndexManualSetBased = class extends OIMReactiveIndexManualSetBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, {
-      indexOptions: opts.indexOptions,
-      pkDomain: opts.collection?.keyDomain
+      indexOptions: opts.indexOptions
     });
     // Bound once so the hot pk-write path passes a stable function (no per-call
     // closure allocation).
-    this.resolveRequiredSlot = (pk) => {
-      const slot = this.resolveSlot(pk);
+    this.getSlotOrTransient = (pk) => {
+      const slot = this.getSlot(pk);
       if (!slot) return { pk, item: void 0 };
       return slot;
     };
-    this.resolveSlot = resolveSlot;
+    this.getSlot = getSlot;
+    this.findSlotForRemoval = opts.collection !== void 0 ? (pk) => opts.collection.findSlotByPk(pk) : opts.getSlot;
   }
   setPks(key, pks) {
-    this.index.setPks(key, pks, this.resolveRequiredSlot);
+    this.index.setPks(key, pks, this.getSlotOrTransient);
   }
   addPks(key, pks) {
-    this.index.addPks(key, pks, this.resolveRequiredSlot);
+    this.index.addPks(key, pks, this.getSlotOrTransient);
   }
   removePks(key, pks) {
-    this.index.removePks(key, pks);
+    const canonical = [];
+    for (let i = 0; i < pks.length; i++) {
+      const slot = this.findSlotForRemoval(pks[i]);
+      canonical.push(slot ? slot.pk : pks[i]);
+    }
+    this.index.removePks(key, canonical);
   }
   getEntitiesByKey(key) {
     return super.getEntitiesByKey(key);
@@ -2798,29 +2804,34 @@ var OIMIndexStoreTrieDrivenSetBased = class extends OIMIndexStoreSetBased {
 // src/core/OIMReactiveCollectionIndexCompositeTrieSetBased.ts
 var OIMReactiveCollectionIndexCompositeTrieSetBased = class extends OIMReactiveIndexManualSetBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, {
       indexOptions: {
         comparePks: opts.indexOptions?.comparePks,
         store: opts.indexOptions?.store ?? new OIMIndexStoreTrieDrivenSetBased()
-      },
-      pkDomain: opts.collection?.keyDomain
+      }
     });
-    this.resolveRequiredSlot = (pk) => {
-      const slot = this.resolveSlot(pk);
+    this.getSlotOrTransient = (pk) => {
+      const slot = this.getSlot(pk);
       if (!slot) return { pk, item: void 0 };
       return slot;
     };
-    this.resolveSlot = resolveSlot;
+    this.getSlot = getSlot;
+    this.findSlotForRemoval = opts.collection !== void 0 ? (pk) => opts.collection.findSlotByPk(pk) : opts.getSlot;
   }
   setPks(key, pks) {
-    this.index.setPks(key, pks, this.resolveRequiredSlot);
+    this.index.setPks(key, pks, this.getSlotOrTransient);
   }
   addPks(key, pks) {
-    this.index.addPks(key, pks, this.resolveRequiredSlot);
+    this.index.addPks(key, pks, this.getSlotOrTransient);
   }
   removePks(key, pks) {
-    this.index.removePks(key, pks);
+    const canonical = [];
+    for (let i = 0; i < pks.length; i++) {
+      const slot = this.findSlotForRemoval(pks[i]);
+      canonical.push(slot ? slot.pk : pks[i]);
+    }
+    this.index.removePks(key, canonical);
   }
   getEntitiesByKey(key) {
     return super.getEntitiesByKey(key);
@@ -2927,7 +2938,7 @@ var OIMIndexStoreTrieDrivenArrayBased = class extends OIMIndexStoreArrayBased {
 // src/core/OIMReactiveCollectionIndexCompositeTrieArrayBased.ts
 var OIMReactiveCollectionIndexCompositeTrieArrayBased = class extends OIMReactiveIndexManualArrayBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, {
       indexOptions: {
         comparePks: opts.indexOptions?.comparePks,
@@ -2937,13 +2948,13 @@ var OIMReactiveCollectionIndexCompositeTrieArrayBased = class extends OIMReactiv
     // Persistent per-key-path pk membership for O(1) `addPks` dedup. Trie-keyed
     // so a rebuilt key path matches by content.
     this.pksByKey = new OIMTrieMap();
-    this.resolveSlot = resolveSlot;
+    this.getSlot = getSlot;
   }
   setPks(key, pks) {
     const pkSet = /* @__PURE__ */ new Set();
     for (let i = 0; i < pks.length; i++) pkSet.add(pks[i]);
     this.pksByKey.set(key, pkSet);
-    super.setSlots(key, this.resolveSlots(pks));
+    super.setSlots(key, this.getSlotsOrTransient(pks));
   }
   addPks(key, pks) {
     if (pks.length === 0) return;
@@ -2952,7 +2963,7 @@ var OIMReactiveCollectionIndexCompositeTrieArrayBased = class extends OIMReactiv
     for (const pk of pks) {
       if (pkSet.has(pk)) continue;
       pkSet.add(pk);
-      newSlots.push(this.resolveRequiredSlot(pk));
+      newSlots.push(this.getSlotOrTransient(pk));
     }
     if (newSlots.length > 0) this.appendSlots(key, newSlots);
   }
@@ -2998,16 +3009,16 @@ var OIMReactiveCollectionIndexCompositeTrieArrayBased = class extends OIMReactiv
   getEntitiesByKeys(keys) {
     return super.getEntitiesByKeys(keys);
   }
-  resolveSlots(pks) {
+  getSlotsOrTransient(pks) {
     const slots = [];
     slots.length = pks.length;
     for (let i = 0; i < pks.length; i++) {
-      slots[i] = this.resolveRequiredSlot(pks[i]);
+      slots[i] = this.getSlotOrTransient(pks[i]);
     }
     return slots;
   }
-  resolveRequiredSlot(pk) {
-    const slot = this.resolveSlot(pk);
+  getSlotOrTransient(pk) {
+    const slot = this.getSlot(pk);
     if (!slot) return { pk, item: void 0 };
     return slot;
   }
@@ -3320,20 +3331,20 @@ var OIMReactiveGlobalIndexManualArrayBased = class extends OIMReactiveGlobalInde
 // src/core/OIMReactiveCollectionGlobalIndexManualArrayBased.ts
 var OIMReactiveCollectionGlobalIndexManualArrayBased = class extends OIMReactiveGlobalIndexManualArrayBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, { indexOptions: opts.indexOptions });
     // Single pk membership set for O(1) `addPks` dedup. Lazily seeded from the
     // bucket so it stays correct even after a raw `setSlots` (e.g. derived
     // rebuild), matching the keyed index's `membershipOf`.
     this.membership = /* @__PURE__ */ new Set();
     this.membershipSeeded = false;
-    this.resolveSlot = resolveSlot;
+    this.getSlot = getSlot;
   }
   setPks(pks) {
     this.membership.clear();
     for (let i = 0; i < pks.length; i++) this.membership.add(pks[i]);
     this.membershipSeeded = true;
-    super.setSlots(this.resolveSlots(pks));
+    super.setSlots(this.getSlotsOrTransient(pks));
   }
   addPks(pks) {
     if (pks.length === 0) return;
@@ -3342,7 +3353,7 @@ var OIMReactiveCollectionGlobalIndexManualArrayBased = class extends OIMReactive
     for (const pk of pks) {
       if (membership.has(pk)) continue;
       membership.add(pk);
-      newSlots.push(this.resolveRequiredSlot(pk));
+      newSlots.push(this.getSlotOrTransient(pk));
     }
     if (newSlots.length > 0) super.appendSlots(newSlots);
   }
@@ -3379,16 +3390,16 @@ var OIMReactiveCollectionGlobalIndexManualArrayBased = class extends OIMReactive
   getEntities() {
     return super.getEntities();
   }
-  resolveSlots(pks) {
+  getSlotsOrTransient(pks) {
     const slots = [];
     slots.length = pks.length;
     for (let i = 0; i < pks.length; i++) {
-      slots[i] = this.resolveRequiredSlot(pks[i]);
+      slots[i] = this.getSlotOrTransient(pks[i]);
     }
     return slots;
   }
-  resolveRequiredSlot(pk) {
-    const slot = this.resolveSlot(pk);
+  getSlotOrTransient(pk) {
+    const slot = this.getSlot(pk);
     if (!slot) return { pk, item: void 0 };
     return slot;
   }
@@ -3468,18 +3479,18 @@ var OIMReactiveGlobalIndexManualSetBased = class extends OIMReactiveGlobalIndexS
 // src/core/OIMReactiveCollectionGlobalIndexManualSetBased.ts
 var OIMReactiveCollectionGlobalIndexManualSetBased = class extends OIMReactiveGlobalIndexManualSetBased {
   constructor(queue, opts) {
-    const resolveSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.resolveSlot;
+    const getSlot = opts.collection !== void 0 ? (pk) => opts.collection.getOrReserveSlotByPk(pk) : opts.getSlot;
     super(queue, { indexOptions: opts.indexOptions });
     this.membership = /* @__PURE__ */ new Map();
     this.membershipSeeded = false;
-    this.resolveSlot = resolveSlot;
+    this.getSlot = getSlot;
   }
   setPks(pks) {
     this.membership.clear();
     const slots = [];
     for (let i = 0; i < pks.length; i++) {
       const pk = pks[i];
-      const slot = this.resolveRequiredSlot(pk);
+      const slot = this.getSlotOrTransient(pk);
       if (!this.membership.has(pk)) this.membership.set(pk, slot);
       slots.push(slot);
     }
@@ -3492,7 +3503,7 @@ var OIMReactiveCollectionGlobalIndexManualSetBased = class extends OIMReactiveGl
     const newSlots = [];
     for (const pk of pks) {
       if (membership.has(pk)) continue;
-      const slot = this.resolveRequiredSlot(pk);
+      const slot = this.getSlotOrTransient(pk);
       membership.set(pk, slot);
       newSlots.push(slot);
     }
@@ -3531,8 +3542,8 @@ var OIMReactiveCollectionGlobalIndexManualSetBased = class extends OIMReactiveGl
   getEntities() {
     return super.getEntities();
   }
-  resolveRequiredSlot(pk) {
-    const slot = this.resolveSlot(pk);
+  getSlotOrTransient(pk) {
+    const slot = this.getSlot(pk);
     if (!slot) return { pk, item: void 0 };
     return slot;
   }
@@ -3941,7 +3952,7 @@ var OIMObject = class {
 var OIMReactiveObject = class extends OIMObject {
   constructor(queue, opts) {
     super(opts);
-    this.updateEmitter = new OIMCarrierKeyedEmitter(queue, new OIMKeyedCarrierResolver());
+    this.updateEmitter = new OIMCarrierKeyedEmitter(queue, new OIMKeyedCarrierProvider());
   }
   /**
    * Mark the written key(s) on the keyed emitter directly — no general-event
@@ -3983,57 +3994,10 @@ var OIMReactiveObject = class extends OIMObject {
   }
 };
 
-// src/core/OIMTrieSet.ts
-var OIMTrieSet = class {
-  constructor() {
-    this.map = new OIMTrieMap();
-  }
-  get size() {
-    return this.map.size;
-  }
-  add(key) {
-    this.map.set(key, true);
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  delete(key) {
-    return this.map.delete(key);
-  }
-  *values() {
-    yield* this.map.keys();
-  }
-  clear() {
-    this.map.clear();
-  }
-};
-
-// src/core/OIMKeyDomainTrie.ts
-var OIMKeyDomainTrie = class {
-  constructor() {
-    // Interning pool: logical key (by content) → the one canonical reference.
-    this.pool = new OIMTrieMap();
-  }
-  createMap() {
-    return new OIMTrieMap();
-  }
-  createSet() {
-    return new OIMTrieSet();
-  }
-  canonicalize(key) {
-    const existing = this.pool.get(key);
-    if (existing !== void 0) return existing;
-    const canonical = Object.freeze(key.slice());
-    this.pool.set(canonical, canonical);
-    return canonical;
-  }
-};
-
 // src/core/OIMCollectionStoreTrieDriven.ts
 var OIMCollectionStoreTrieDriven = class extends OIMCollectionStore {
-  constructor(keyDomain = new OIMKeyDomainTrie()) {
-    super();
-    this.keyDomain = keyDomain;
+  constructor() {
+    super(...arguments);
     this.slots = new OIMTrieMap();
     this.reservedSlots = new OIMTrieMap();
   }
@@ -4051,7 +4015,7 @@ var OIMCollectionStoreTrieDriven = class extends OIMCollectionStore {
       return reserved;
     }
     const nextSlot = {
-      pk: this.keyDomain.canonicalize(pk),
+      pk,
       item: entity
     };
     this.slots.set(pk, nextSlot);
@@ -4062,7 +4026,7 @@ var OIMCollectionStoreTrieDriven = class extends OIMCollectionStore {
     if (slot) return slot;
     let reserved = this.reservedSlots.get(pk);
     if (!reserved) {
-      reserved = { pk: this.keyDomain.canonicalize(pk), item: void 0 };
+      reserved = { pk, item: void 0 };
       this.reservedSlots.set(pk, reserved);
     }
     return reserved;
@@ -4219,8 +4183,8 @@ var OIMObjectStoreMapDriven = class extends OIMObjectStore {
   }
 };
 
-// src/core/OIMKeyPathCarrierResolver.ts
-var OIMKeyPathCarrierResolver = class {
+// src/core/OIMKeyPathCarrierProvider.ts
+var OIMKeyPathCarrierProvider = class {
   constructor() {
     this.carriers = new OIMTrieMap();
   }
@@ -4273,6 +4237,7 @@ var OIMEventQueue = class {
     this.tasksSpare = /* @__PURE__ */ new Set();
     this.isFlushing = false;
     this.scheduler = options.scheduler;
+    this.onError = options.onError;
     if (this.scheduler) {
       this.flushBound = () => this.flush();
       this.scheduler.on(
@@ -4312,12 +4277,34 @@ var OIMEventQueue = class {
     const flushing = this.tasks;
     this.tasks = this.tasksSpare;
     this.flushing = flushing;
-    for (const task of flushing) task();
-    flushing.clear();
-    this.tasksSpare = flushing;
-    this.flushing = void 0;
-    this.isFlushing = false;
+    let errors;
+    try {
+      for (const task of flushing) {
+        try {
+          task();
+        } catch (error) {
+          (errors ?? (errors = [])).push(error);
+          this.emitter.emit(2 /* FLUSH_ERROR */, {
+            error
+          });
+          this.onError?.(error);
+        }
+      }
+    } finally {
+      flushing.clear();
+      this.tasksSpare = flushing;
+      this.flushing = void 0;
+      this.isFlushing = false;
+    }
     this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
+    if (errors && this.onError === void 0) {
+      if (errors.length === 1) throw errors[0];
+      const AggregateErrorCtor = globalThis.AggregateError;
+      throw AggregateErrorCtor ? new AggregateErrorCtor(
+        errors,
+        "Errors thrown during queue flush"
+      ) : errors[0];
+    }
   }
   /**
    * Get the current number of queued functions.
@@ -4520,6 +4507,31 @@ function createOIMDisposeScope() {
   return new OIMDisposeScope();
 }
 
+// src/core/OIMTrieSet.ts
+var OIMTrieSet = class {
+  constructor() {
+    this.map = new OIMTrieMap();
+  }
+  get size() {
+    return this.map.size;
+  }
+  add(key) {
+    this.map.set(key, true);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  *values() {
+    yield* this.map.keys();
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+
 // src/core/OIMPkCodecKeyPath.ts
 var OIMPkCodecKeyPath = class {
   encode(pk) {
@@ -6167,35 +6179,20 @@ var OIMComputed = class {
 };
 
 // src/modules/effect/core/OIMEffectDependencyKeyed.ts
-function isReadonlyArray(value) {
-  return Array.isArray(value);
-}
 var OIMEffectDependencyKeyed = class {
-  constructor(source, keyOrKeys) {
+  constructor(source, key) {
     this.source = source;
-    if (isReadonlyArray(keyOrKeys)) {
-      this.keys = keyOrKeys;
-    } else {
-      this.key = keyOrKeys;
-    }
+    this.key = key;
   }
   subscribe(onUpdate) {
-    if (this.keys !== void 0) {
-      return this.source.subscribeOnKeys(this.keys, onUpdate);
-    }
-    if (this.key === void 0) return () => {
-    };
     return this.source.subscribeOnKey(this.key, onUpdate);
   }
 };
 
 // src/modules/effect/core/OIMEffectDependencyKeyedObject.ts
 var OIMEffectDependencyKeyedObject = class {
-  constructor(object, keyOrKeys) {
-    this.dep = new OIMEffectDependencyKeyed(
-      object,
-      keyOrKeys
-    );
+  constructor(object, key) {
+    this.dep = new OIMEffectDependencyKeyed(object, key);
   }
   get source() {
     return this.dep.source;
@@ -6207,11 +6204,8 @@ var OIMEffectDependencyKeyedObject = class {
 
 // src/modules/effect/core/OIMEffectDependencyKeyedCollection.ts
 var OIMEffectDependencyKeyedCollection = class {
-  constructor(collection, pkOrPks) {
-    this.dep = new OIMEffectDependencyKeyed(
-      collection,
-      pkOrPks
-    );
+  constructor(collection, pk) {
+    this.dep = new OIMEffectDependencyKeyed(collection, pk);
   }
   get source() {
     return this.dep.source;
@@ -6223,11 +6217,8 @@ var OIMEffectDependencyKeyedCollection = class {
 
 // src/modules/effect/core/OIMEffectDependencyKeyedIndex.ts
 var OIMEffectDependencyKeyedIndex = class {
-  constructor(index, keyOrKeys) {
-    this.dep = new OIMEffectDependencyKeyed(
-      index,
-      keyOrKeys
-    );
+  constructor(index, key) {
+    this.dep = new OIMEffectDependencyKeyed(index, key);
   }
   get source() {
     return this.dep.source;
@@ -6374,7 +6365,7 @@ export {
   EOIMEventQueueSchedulerEventType,
   EOIMIndexEventType,
   EOIMObjectEventType,
-  OIMBucketCarrierResolver,
+  OIMBucketCarrierProvider,
   OIMCarrierKeyedEmitter,
   OIMCarrierSingleEmitter,
   OIMCollection,
@@ -6441,9 +6432,7 @@ export {
   OIMIndexStoreSetBased,
   OIMIndexStoreTrieDrivenArrayBased,
   OIMIndexStoreTrieDrivenSetBased,
-  OIMKeyDomainNative,
-  OIMKeyDomainTrie,
-  OIMKeyPathCarrierResolver,
+  OIMKeyPathCarrierProvider,
   OIMKeyedBucketArrayBased,
   OIMKeyedBucketSetBased,
   OIMMap2Keys,