@oimdb/core 4.0.1 → 4.1.0

package/dist/index.js

@@ -1,12 +1,9 @@
 // src/engine/schedule/OIMFlushSchedulerService.ts
-var OIMFlushSchedulerService = class {
-  onSchedulerTimerFired(flushSchedulerSlot) {
-    this.flush(flushSchedulerSlot);
-  }
+var _OIMFlushSchedulerService = class _OIMFlushSchedulerService {
   isScheduled(flushSchedulerSlot) {
     return flushSchedulerSlot.scheduledCallback !== void 0;
   }
-  schedule(flushSchedulerSlot, delayMs) {
+  schedule(flushSchedulerSlot, delayMs, flushSchedulerListener) {
     if (flushSchedulerSlot.scheduledCallback !== void 0) return;
     const timer = flushSchedulerSlot.timer;
     if (timer === void 0) return;
@@ -14,7 +11,7 @@ var OIMFlushSchedulerService = class {
       if (flushSchedulerSlot.scheduledCallback !== scheduledCallback) return;
       flushSchedulerSlot.scheduledCallback = void 0;
       flushSchedulerSlot.timerDisposer = void 0;
-      this.onSchedulerTimerFired(flushSchedulerSlot);
+      flushSchedulerListener.onSchedulerTimerFired(flushSchedulerSlot);
     };
     flushSchedulerSlot.scheduledCallback = scheduledCallback;
     let timerDisposer;
@@ -33,6 +30,8 @@ var OIMFlushSchedulerService = class {
     timerDisposer?.();
   }
 };
+_OIMFlushSchedulerService.INSTANCE = new _OIMFlushSchedulerService();
+var OIMFlushSchedulerService = _OIMFlushSchedulerService;
 
 // src/engine/slot/constants/OIM_SLOT_FLAG_RELEASED.ts
 var OIM_SLOT_FLAG_RELEASED = 2;
@@ -98,7 +97,7 @@ function oimIsRevisionAfter(revision, epoch, sinceRevision, sinceEpoch) {
 }
 
 // src/engine/channel/OIMChannelService.ts
-var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerService {
+var _OIMChannelService = class _OIMChannelService {
   scheduleEffectRun(channelSlot, effect) {
     channelSlot.effectChannelQueue.enqueueEntry(effect);
     this.requestFlush(channelSlot);
@@ -113,45 +112,6 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
       );
     }
   }
-  isSubframeOpen(channelSlot) {
-    return channelSlot.subframesOpen > 0;
-  }
-  listChangedStoreSlot(channelSlot, storeSlot, subframeCloseListener) {
-    channelSlot.changedStoreSlotChannelQueue.enqueueEntry(storeSlot);
-    channelSlot.changedStoreSlotOwnerChannelQueue.enqueueEntry(subframeCloseListener);
-  }
-  openSubframe(channelSlot) {
-    channelSlot.subframesOpen++;
-  }
-  closeSubframe(channelSlot) {
-    if (channelSlot.subframesOpen > 1) {
-      channelSlot.subframesOpen--;
-      return;
-    }
-    let hasFailed = false;
-    let firstFailure;
-    const changedStoreSlotChannelQueue = channelSlot.changedStoreSlotChannelQueue;
-    const changedStoreSlotOwnerChannelQueue = channelSlot.changedStoreSlotOwnerChannelQueue;
-    try {
-      for (let i = 0; i < changedStoreSlotChannelQueue.getEntryCount(); i++) {
-        try {
-          changedStoreSlotOwnerChannelQueue.getEntryAt(i).onStoreSlotSubframeClosed(changedStoreSlotChannelQueue.getEntryAt(i));
-        } catch (failure) {
-          if (!hasFailed) firstFailure = failure;
-          hasFailed = true;
-        }
-      }
-    } finally {
-      changedStoreSlotChannelQueue.keepFirstEntries(0);
-      changedStoreSlotOwnerChannelQueue.keepFirstEntries(0);
-      channelSlot.subframesOpen--;
-    }
-    if (channelSlot.flushRequestedInSubframe) {
-      channelSlot.flushRequestedInSubframe = false;
-      this.requestFlush(channelSlot);
-    }
-    if (hasFailed) throw firstFailure;
-  }
   subscribeAfterEachFrame(channelSlot, handler) {
     const afterEachFrame = channelSlot.frame.afterEachFrame;
     const subscription = () => {
@@ -220,14 +180,10 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
   }
   requestFlush(channelSlot) {
     if (channelSlot.dropped) return;
-    if (channelSlot.subframesOpen !== 0) {
-      channelSlot.flushRequestedInSubframe = true;
-      return;
-    }
     if (channelSlot.flushRequested || channelSlot.timer === void 0 || channelSlot.frame.isRunning) return;
     channelSlot.flushRequested = true;
     try {
-      this.schedule(channelSlot, 0);
+      OIMFlushSchedulerService.INSTANCE.schedule(channelSlot, 0, this);
     } catch (failure) {
       channelSlot.flushRequested = false;
       throw failure;
@@ -235,12 +191,15 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
   }
   dropChannelSlot(channelSlot) {
     channelSlot.dropped = true;
-    this.cancelSchedule(channelSlot);
+    OIMFlushSchedulerService.INSTANCE.cancelSchedule(channelSlot);
     if (!channelSlot.isFlushing) OIMUnusedSlotCollectorService.INSTANCE.flush(channelSlot.collectorSlot.unusedSlotCollectorSlot);
     channelSlot.effectChannelQueue.keepFirstEntries(0);
     channelSlot.frame.afterEachFrame.clear();
     channelSlot.afterEachFlush.clear();
   }
+  onSchedulerTimerFired(channelSlot) {
+    this.flush(channelSlot);
+  }
   flush(channelSlot) {
     if (channelSlot.dropped) return;
     if (channelSlot.frame.isRunning) {
@@ -248,11 +207,6 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
         "OIMChannelService.flush: a frame is already running, and a second one inside it would end the first. A subscriber is told during the frame; to do work after it, subscribe with subscribeAfterEachFrame."
       );
     }
-    if (channelSlot.subframesOpen > 0) {
-      throw new Error(
-        "OIMChannelService.flush: a subframe is open \u2014 a write is still landing (or openSubframe() was called and closeSubframe() was not yet), and the frame cannot close while a subframe is open. Flush after the write returns; the outermost closeSubframe asks for the frame it owes by itself."
-      );
-    }
     if (channelSlot.isFlushing) return;
     channelSlot.isFlushing = true;
     try {
@@ -262,7 +216,7 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
         this.runFrame(channelSlot);
       } else {
         channelSlot.flushRequested = false;
-        this.cancelSchedule(channelSlot);
+        OIMFlushSchedulerService.INSTANCE.cancelSchedule(channelSlot);
         frame.openedAtRevision = clock.revision;
         frame.openedAtEpoch = clock.epoch;
       }
@@ -279,7 +233,7 @@ var _OIMChannelService = class _OIMChannelService extends OIMFlushSchedulerServi
   }
   runFrame(channelSlot) {
     channelSlot.flushRequested = false;
-    this.cancelSchedule(channelSlot);
+    OIMFlushSchedulerService.INSTANCE.cancelSchedule(channelSlot);
     const onBeforeFlush = channelSlot.onBeforeFlush;
     if (onBeforeFlush !== void 0) {
       try {
@@ -392,15 +346,8 @@ function createOIMChannelSlot(options) {
     effectChannelQueue: new OIMChannelQueue(),
     afterEachFlush: /* @__PURE__ */ new Set(),
     afterEachFrameHandlerChannelQueue: new OIMChannelQueue(),
-    subframeStoreSlotChannelQueues: [],
-    changedStoreSlotChannelQueue: new OIMChannelQueue(),
-    changedStoreSlotOwnerChannelQueue: new OIMChannelQueue(),
     commandsStoreSlotChannelQueue: void 0,
     changedColumnNames: void 0,
-    subframesOpen: 0,
-    contentSubframeDepth: 0,
-    subframeDeliveryDepth: 0,
-    flushRequestedInSubframe: false,
     flushRequested: false,
     isFlushing: false,
     dropped: false
@@ -412,30 +359,14 @@ function createOIMUnusedSlotCollectorSlot() {
   return { unusedSlotChannelQueue: new OIMChannelQueue(), openDepth: 0, isFlushing: false };
 }
 
-// src/engine/collector/utils/createOIMReleaseSlotCollectorSlot.ts
-function createOIMReleaseSlotCollectorSlot(options) {
-  return {
-    timer: options.releaseTimer,
-    scheduledCallback: void 0,
-    timerDisposer: void 0,
-    getNowMs: options.getNowMs,
-    errorPolicy: options.errorPolicy,
-    scheduledUntilMs: Number.POSITIVE_INFINITY,
-    slotsBySliceNumber: /* @__PURE__ */ new Map(),
-    sliceNumberBySlot: /* @__PURE__ */ new Map(),
-    floorSliceNumber: Number.NEGATIVE_INFINITY,
-    nextSliceNumber: void 0,
-    nextSliceNumberNeedsRescan: false
-  };
-}
-
 // src/engine/collector/utils/createOIMCollectorSlot.ts
 function createOIMCollectorSlot(options) {
   return {
     unusedSlotCollectorSlot: createOIMUnusedSlotCollectorSlot(),
-    afterIdleReleaseSlotCollectorSlot: createOIMReleaseSlotCollectorSlot(options),
-    afterWriteReleaseSlotCollectorSlot: createOIMReleaseSlotCollectorSlot(options),
-    afterUnholdReleaseSlotCollectorSlot: createOIMReleaseSlotCollectorSlot(options)
+    slotWheelOptions: { getNowMs: options.getNowMs, timer: options.releaseTimer, errorPolicy: options.errorPolicy },
+    afterIdleSlotReleaseWheel: void 0,
+    afterWriteSlotReleaseWheel: void 0,
+    afterUnholdSlotReleaseWheel: void 0
   };
 }
 
@@ -459,8 +390,8 @@ var OIM_TIMER_ON_TIMEOUT = (run, inMs) => {
   };
 };
 
-// src/engine/error/OIMErrorPolicyLogAndContinue.ts
-var _OIMErrorPolicyLogAndContinue = class _OIMErrorPolicyLogAndContinue {
+// src/engine/error/OIMLogAndContinueErrorPolicy.ts
+var _OIMLogAndContinueErrorPolicy = class _OIMLogAndContinueErrorPolicy {
   constructor(options) {
     this.onError = options?.onError;
   }
@@ -469,14 +400,14 @@ var _OIMErrorPolicyLogAndContinue = class _OIMErrorPolicyLogAndContinue {
     this.onError?.(error);
   }
 };
-_OIMErrorPolicyLogAndContinue.INSTANCE = new _OIMErrorPolicyLogAndContinue();
-var OIMErrorPolicyLogAndContinue = _OIMErrorPolicyLogAndContinue;
+_OIMLogAndContinueErrorPolicy.INSTANCE = new _OIMLogAndContinueErrorPolicy();
+var OIMLogAndContinueErrorPolicy = _OIMLogAndContinueErrorPolicy;
 
 // src/factories/OIMDB.ts
 var OIMDB = class {
   constructor(options) {
     this.clock = { revision: 0, epoch: 0 };
-    const errorPolicy = options?.errorPolicy ?? OIMErrorPolicyLogAndContinue.INSTANCE;
+    const errorPolicy = options?.errorPolicy ?? OIMLogAndContinueErrorPolicy.INSTANCE;
     this.collectorSlot = createOIMCollectorSlot({
       getNowMs: options?.getNowMs ?? Date.now,
       releaseTimer: options?.releaseTimer ?? OIM_TIMER_ON_TIMEOUT,
@@ -515,14 +446,26 @@ function oimRegisterCoreInstance(coreInstance) {
   );
 }
 
-// src/engine/slot/OIMStoreSlotListenerNone.ts
-var _OIMStoreSlotListenerNone = class _OIMStoreSlotListenerNone {
+// src/engine/slot/OIMNoStoreSlotListener.ts
+var _OIMNoStoreSlotListener = class _OIMNoStoreSlotListener {
   onStoreSlotCreated() {
     return;
   }
 };
-_OIMStoreSlotListenerNone.INSTANCE = new _OIMStoreSlotListenerNone();
-var OIMStoreSlotListenerNone = _OIMStoreSlotListenerNone;
+_OIMNoStoreSlotListener.INSTANCE = new _OIMNoStoreSlotListener();
+var OIMNoStoreSlotListener = _OIMNoStoreSlotListener;
+
+// src/engine/slot/OIMNoSlotSubscriptionListener.ts
+var _OIMNoSlotSubscriptionListener = class _OIMNoSlotSubscriptionListener {
+  onSlotFirstSubscribed() {
+    return;
+  }
+  onSlotLastUnsubscribed() {
+    return;
+  }
+};
+_OIMNoSlotSubscriptionListener.INSTANCE = new _OIMNoSlotSubscriptionListener();
+var OIMNoSlotSubscriptionListener = _OIMNoSlotSubscriptionListener;
 
 // src/engine/slot/constants/OIM_SLOT_FLAG_EMPTY.ts
 var OIM_SLOT_FLAG_EMPTY = 1;
@@ -569,6 +512,7 @@ var OIMSlotOwner = class {
     const subscribers = slotEditable.effects ?? (slotEditable.effects = []);
     subscribers.push(effect);
     (slotEditable.effectEdges ?? (slotEditable.effectEdges = [])).push(edge);
+    if (subscribers.length === 1) this.onSlotFirstSubscribed(slot);
     return subscribers.length - 1;
   }
   unsubscribeFromSlot(slot, positionInSlot, effect) {
@@ -584,13 +528,25 @@ var OIMSlotOwner = class {
     subscribers.pop();
     effectEdges.pop();
     if (last !== positionInSlot) tailEffect.effectService.setPositionInSubscribedSlot(tailEffect, tailEdge, positionInSlot);
-    if (last === 0) this.onSlotIdle(slot);
+    if (last === 0) {
+      this.onSlotIdle(slot);
+      this.onSlotLastUnsubscribed(slot);
+    }
     this.unholdSlot(slot);
     return true;
   }
   releaseSlotIfUnheld(_slot) {
     return;
   }
+  unsafeMutateSlot(slot, mutateSlot) {
+    mutateSlot(slot);
+  }
+  onSlotFirstSubscribed(_slot) {
+    return;
+  }
+  onSlotLastUnsubscribed(_slot) {
+    return;
+  }
   onSlotIdle(_slot) {
     return;
   }
@@ -625,8 +581,8 @@ function oimMarkSlotReleased(slot) {
   slot.slotFlags |= OIM_SLOT_FLAG_RELEASED;
 }
 
-// src/engine/column/OIMColumnOwner.ts
-var OIMColumnOwner = class extends OIMSlotOwner {
+// src/engine/column/OIMColumnSlotOwner.ts
+var OIMColumnSlotOwner = class extends OIMSlotOwner {
   constructor(columnSlotStoreService) {
     super();
     this.columnSlotStoreService = columnSlotStoreService;
@@ -634,7 +590,7 @@ var OIMColumnOwner = class extends OIMSlotOwner {
   getColumnGroup(columnNames) {
     if (columnNames.length === 0) {
       throw new Error(
-        "OIMColumnOwner.getColumnGroup: a column group names at least one column. A slot that hears every column is the any-column slot: holdAnyColumn."
+        "OIMColumnSlotOwner.getColumnGroup: a column group names at least one column. A slot that hears every column is the any-column slot: holdAnyColumn."
       );
     }
     const sortedColumnNames = [...new Set(columnNames)].sort();
@@ -688,6 +644,12 @@ var OIMColumnOwner = class extends OIMSlotOwner {
     oimMarkSlotReleased(columnSlot);
     carrierSlot.owner.releaseSlotIfUnheld(carrierSlot);
   }
+  onSlotFirstSubscribed(slot) {
+    this.carrierSlotOf(slot).owner.onSlotFirstSubscribed(slot);
+  }
+  onSlotLastUnsubscribed(slot) {
+    this.carrierSlotOf(slot).owner.onSlotLastUnsubscribed(slot);
+  }
   getColumnGroupsByKeyOf(carrierSlot) {
     return carrierSlot.storeSlot.columnGroupsByKey;
   }
@@ -704,7 +666,7 @@ var OIMColumnOwner = class extends OIMSlotOwner {
     const registeredColumnGroup = columnGroupsByKey.get(columnGroup.key);
     if (registeredColumnGroup !== columnGroup && (columnGroup.key !== oimColumnGroupKeyOfColumnNames(columnGroup.columnNames) || columnGroup.key === OIM_ANY_COLUMN_KEY)) {
       throw new Error(
-        `OIMColumnOwner.holdColumnGroup: "${columnGroup.key}" is not the key of its columns. A column group comes from getColumnGroup, which builds the key from the names.`
+        `OIMColumnSlotOwner.holdColumnGroup: "${columnGroup.key}" is not the key of its columns. A column group comes from getColumnGroup, which builds the key from the names.`
       );
     }
     if (registeredColumnGroup === void 0) {
@@ -783,8 +745,8 @@ function forgetColumnReadersIfUnread(storeSlot, columnName, columnReaders) {
   storeSlot.columnReadersByColumnName.delete(columnName);
 }
 
-// src/engine/column/OIMColumnSlotStoreServiceOrdinalDriven.ts
-var OIMColumnSlotStoreServiceOrdinalDriven = class {
+// src/engine/column/OIMColumnSlotOrdinalStoreService.ts
+var OIMColumnSlotOrdinalStoreService = class {
   constructor(options) {
     this.ordinalsByColumnName = /* @__PURE__ */ new Map();
     this.declaredColumnNames = new Set(options.columnNames);
@@ -819,6 +781,12 @@ var OIMColumnSlotStoreServiceOrdinalDriven = class {
     columnSlots[ordinal] = void 0;
     store.slotCount--;
   }
+  fileSlot(store, slot) {
+    this.set(store, slot.key, slot);
+  }
+  unfileSlot(store, slot) {
+    this.remove(store, slot.key);
+  }
   *getSlots(store) {
     const columnSlots = store.columnSlots;
     for (let i = 0; i < columnSlots.length; i++) {
@@ -834,7 +802,7 @@ var OIMColumnSlotStoreServiceOrdinalDriven = class {
     for (let i = 0; i < columnNames.length; i++) {
       if (this.declaredColumnNames.has(columnNames[i])) continue;
       throw new Error(
-        `OIMColumnSlotStoreServiceOrdinalDriven: the column "${columnNames[i]}" is not among the columns this collection was created with, so no slot can be filed for it. Name it in \`columns\`.`
+        `OIMColumnSlotOrdinalStoreService: the column "${columnNames[i]}" is not among the columns this collection was created with, so no slot can be filed for it. Name it in \`columns\`.`
       );
     }
     const ordinal = this.ordinalsByColumnName.size;
@@ -844,15 +812,18 @@ var OIMColumnSlotStoreServiceOrdinalDriven = class {
 };
 
 // src/engine/column/utils/oimColumnSlotStoreServiceOfColumnOwnerOptions.ts
-function oimColumnSlotStoreServiceOfColumnOwnerOptions(columnOwnerOptions) {
-  if (columnOwnerOptions.columnNames !== void 0) {
-    return new OIMColumnSlotStoreServiceOrdinalDriven({ columnNames: columnOwnerOptions.columnNames });
+function oimColumnSlotStoreServiceOfColumnOwnerOptions(columnSlotOwnerOptions) {
+  if (columnSlotOwnerOptions.columnNames !== void 0) {
+    return new OIMColumnSlotOrdinalStoreService({ columnNames: columnSlotOwnerOptions.columnNames });
   }
-  return columnOwnerOptions.columnSlotStoreService;
+  return columnSlotOwnerOptions.columnSlotStoreService;
 }
 
+// src/engine/computed/constants/OIM_FROZEN_EMPTY_COMPUTED_SLOTS.ts
+var OIM_FROZEN_EMPTY_COMPUTED_SLOTS = Object.freeze([]);
+
 // src/engine/computed/utils/createOIMComputedSlot.ts
-function createOIMComputedSlot(key, owner, computedValueService, sourceSlots, sourceComputeds, initialValue, storeSlot = void 0) {
+function createOIMComputedSlot(key, owner, computedValueService, initialValue, storeSlot = void 0) {
   return {
     effects: void 0,
     changedAtRevision: 0,
@@ -869,8 +840,8 @@ function createOIMComputedSlot(key, owner, computedValueService, sourceSlots, so
     computedValueService,
     key,
     indexKeys: void 0,
-    sourceSlots,
-    sourceComputeds,
+    sourceSlots: OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
+    sourceComputeds: OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
     value: initialValue,
     ranAtRevision: -1,
     ranAtEpoch: -1,
@@ -881,9 +852,6 @@ function createOIMComputedSlot(key, owner, computedValueService, sourceSlots, so
   };
 }
 
-// src/engine/computed/constants/OIM_FROZEN_EMPTY_COMPUTED_SLOTS.ts
-var OIM_FROZEN_EMPTY_COMPUTED_SLOTS = Object.freeze([]);
-
 // src/engine/computed/utils/oimRefreshSourceComputeds.ts
 function oimRefreshSourceComputeds(sourceComputeds) {
   for (let i = 0; i < sourceComputeds.length; i++) {
@@ -946,7 +914,7 @@ function oimRefreshComputedSlot(computedSlot, derive, sameValueGuard, channelClo
   computedSlotEditable.changedAtEpoch = sourceCount === 0 ? channelClock.epoch : newestSourceEpoch;
 }
 
-// src/engine/column/OIMColumnOwnerPullDriven.ts
+// src/engine/column/OIMPullColumnSlotOwner.ts
 var columnValueOf = (value, columnName) => typeof value === "object" && value !== null ? value[columnName] : void 0;
 var isSameColumnValues = (prevColumnValues, nextColumnValues) => {
   if (!Array.isArray(prevColumnValues) || !Array.isArray(nextColumnValues)) return false;
@@ -956,7 +924,7 @@ var isSameColumnValues = (prevColumnValues, nextColumnValues) => {
   }
   return true;
 };
-var OIMColumnOwnerPullDriven = class extends OIMColumnOwner {
+var OIMPullColumnSlotOwner = class extends OIMColumnSlotOwner {
   constructor(options) {
     super(oimColumnSlotStoreServiceOfColumnOwnerOptions(options));
     this.deriveColumnSlotValue = (columnSlot) => {
@@ -977,14 +945,8 @@ var OIMColumnOwnerPullDriven = class extends OIMColumnOwner {
     return columnSlot.value;
   }
   createColumnSlot(carrierSlot, key) {
-    const columnSlot = createOIMComputedSlot(
-      key,
-      this,
-      this,
-      OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
-      [carrierSlot],
-      void 0
-    );
+    const columnSlot = createOIMComputedSlot(key, this, this, void 0);
+    columnSlot.sourceComputeds = [carrierSlot];
     this.getValueForSlot(columnSlot);
     return columnSlot;
   }
@@ -1035,8 +997,8 @@ function oimUnholdSlotsIfAlive(slots) {
   for (let i = 0; i < slots.length; i++) oimUnholdSlotIfAlive(slots[i]);
 }
 
-// src/engine/error/OIMErrorPolicyThrowAtOnce.ts
-var OIMErrorPolicyThrowAtOnce = class {
+// src/engine/error/OIMThrowAtOnceErrorPolicy.ts
+var OIMThrowAtOnceErrorPolicy = class {
   onErrorCaught(error) {
     throw error;
   }
@@ -1485,9 +1447,6 @@ var _OIMContentChangeListenerService = class _OIMContentChangeListenerService {
     if (storeSlotEditable.contentChangeListeners === void 0) {
       storeSlotEditable.contentChangeListeners = [];
       storeSlotEditable.contentChangeListenerReadColumnNames = [];
-      storeSlotEditable.subframeSlotChannelQueues = [];
-      storeSlotEditable.subframePatchChannelQueues = [];
-      storeSlotEditable.subframeChangedColumnsChannelQueues = [];
     }
     storeSlotEditable.contentChangeListeners.push(listener);
     storeSlotEditable.contentChangeListenerReadColumnNames.push(readColumnNames);
@@ -1534,290 +1493,87 @@ function oimGetChannelSlot(slot) {
   return slot.storeSlot.channelSlot;
 }
 
-// src/facade/slot/OIMSlotColumnService.ts
-var OIMSlotColumnService = class {
-  constructor(columnOwner) {
-    this.columnOwner = columnOwner;
+// src/facade/column/OIMColumnSlotService.ts
+var OIMColumnSlotService = class {
+  constructor(columnSlotOwner) {
+    this.columnSlotOwner = columnSlotOwner;
   }
   getColumn(slot, columnName) {
-    return this.columnOwner.getColumn(slot, columnName, oimGetChannelSlot(slot).collectorSlot.unusedSlotCollectorSlot);
+    return this.columnSlotOwner.getColumn(slot, columnName, oimGetChannelSlot(slot).collectorSlot.unusedSlotCollectorSlot);
   }
   holdColumn(slot, columnName) {
-    return this.columnOwner.holdColumn(slot, columnName);
+    return this.columnSlotOwner.holdColumn(slot, columnName);
   }
   getAnyColumn(slot) {
-    return this.columnOwner.getAnyColumn(slot, oimGetChannelSlot(slot).collectorSlot.unusedSlotCollectorSlot);
+    return this.columnSlotOwner.getAnyColumn(slot, oimGetChannelSlot(slot).collectorSlot.unusedSlotCollectorSlot);
   }
   holdAnyColumn(slot) {
-    return this.columnOwner.holdAnyColumn(slot);
+    return this.columnSlotOwner.holdAnyColumn(slot);
   }
   getColumnGroup(columnNames) {
-    return this.columnOwner.getColumnGroup(columnNames);
+    return this.columnSlotOwner.getColumnGroup(columnNames);
   }
   holdColumnGroup(slot, columnGroup) {
-    return this.columnOwner.holdColumnGroup(slot, columnGroup);
+    return this.columnSlotOwner.holdColumnGroup(slot, columnGroup);
   }
   unholdColumn(columnSlot) {
-    this.columnOwner.unholdSlot(columnSlot);
-  }
-};
-
-// src/engine/slot/utils/createOIMStoreSlot.ts
-function createOIMStoreSlot(store, channelSlot, sourceStoreSlot) {
-  return {
-    store,
-    channelSlot,
-    contentChangeListeners: void 0,
-    contentChangeListenerReadColumnNames: void 0,
-    indexKeysPositions: void 0,
-    columnListenerCountsByColumnName: void 0,
-    allColumnsListenerCount: 0,
-    columnGroupsByKey: void 0,
-    columnGroupSlotCountsByKey: void 0,
-    columnReadersByColumnName: void 0,
-    anyColumnSlotCount: 0,
-    subframeSlotChannelQueues: void 0,
-    subframePatchChannelQueues: void 0,
-    subframeChangedColumnsChannelQueues: void 0,
-    changedBucketSlotChannelQueue: void 0,
-    arrivedBucketMemberSlotChannelQueues: void 0,
-    departedBucketMemberSlotChannelQueues: void 0,
-    removedAtChannelQueues: void 0,
-    writeDepth: 0,
-    commandsBucketSlotChannelQueue: void 0,
-    sourceStoreSlot,
-    keptStampedEntitySlots: void 0,
-    derive: void 0,
-    createSources: void 0,
-    indexKeysPosition: -1,
-    contentChangeListener: void 0,
-    requestedKeys: void 0,
-    bucketColumnNames: void 0,
-    isAnyBucketColumnRead: false,
-    isDisposed: false
-  };
-}
-
-// src/facade/slot/OIMSlotCollectionService.ts
-var OIMSlotCollectionService = class extends OIMSlotColumnService {
-  constructor(options) {
-    super(options.slotOwnerService.columnOwner);
-    this.slotOwnerService = options.slotOwnerService;
-    this.slotStoreService = options.slotStoreService;
-    this.slotContentService = options.slotContentService;
-    this.storeSlotListener = options.storeSlotListener;
-  }
-  createStoreSlot(channelMap) {
-    const channelSlot = channelMap.defaultChannelSlot;
-    return this.createStoreSlotWith((store) => createOIMStoreSlot(store, channelSlot));
-  }
-  createStoreSlotFrom(sourceStoreSlot) {
-    return this.createStoreSlotWith((store) => createOIMStoreSlot(store, sourceStoreSlot.channelSlot, sourceStoreSlot));
-  }
-  createStoreSlotWith(createStoreSlotLiteral) {
-    const storeSlot = createStoreSlotLiteral(this.slotStoreService.createStore());
-    if (this.storeSlotListener !== void 0) this.storeSlotListener.onStoreSlotCreated(storeSlot);
-    return storeSlot;
-  }
-  findSlotByKey(storeSlot, key) {
-    return this.slotStoreService.get(storeSlot.store, key);
-  }
-  hasSlotContentByKey(storeSlot, key) {
-    const slot = this.slotStoreService.get(storeSlot.store, key);
-    return slot !== void 0 && !oimIsSlotEmpty(slot);
-  }
-  getSlotByKey(storeSlot, key) {
-    const found = this.slotStoreService.get(storeSlot.store, key);
-    if (found !== void 0) return found;
-    const slot = this.mintSlotByKey(storeSlot, key);
-    OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(storeSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot, slot);
-    return slot;
-  }
-  holdSlotByKey(storeSlot, key) {
-    const slot = this.slotStoreService.get(storeSlot.store, key) ?? this.mintSlotByKey(storeSlot, key);
-    this.slotOwnerService.holdSlot(slot);
-    return slot;
-  }
-  getSlots(storeSlot) {
-    return this.slotStoreService.getSlots(storeSlot.store);
-  }
-  getSlotCount(storeSlot) {
-    return this.slotStoreService.getSlotCount(storeSlot.store);
-  }
-  isSameKey(key, otherKey) {
-    return this.slotStoreService.isSameKey(key, otherKey);
-  }
-  onSlotMinted(_storeSlot, _slot) {
-    return;
-  }
-  mintSlotByKey(storeSlot, key) {
-    const slotOwnerService = this.slotOwnerService;
-    const slot = slotOwnerService.createSlot(this.slotStoreService.ownKey(key), storeSlot);
-    this.onSlotMinted(storeSlot, slot);
-    slotOwnerService.settleEmptiness(slot, slotOwnerService.isSlotEmpty(slot));
-    slotOwnerService.fileSlot(storeSlot, slot);
-    return slot;
-  }
-};
-
-// src/facade/slot/OIMSingleSlotService.ts
-var OIMSingleSlotService = class extends OIMSlotColumnService {
-  constructor(options) {
-    super(options.slotOwnerService.columnOwner);
-    this.slotOwnerService = options.slotOwnerService;
-    this.slotStoreService = options.slotStoreService;
-    this.slotContentService = options.slotContentService;
-    this.storeSlotListener = options.storeSlotListener;
-  }
-  createStoreSlot(channelMap) {
-    const storeSlot = createOIMStoreSlot(
-      this.slotStoreService.createStore(),
-      channelMap.defaultChannelSlot
-    );
-    if (this.storeSlotListener !== void 0) this.storeSlotListener.onStoreSlotCreated(storeSlot);
-    return storeSlot;
-  }
-  findSingleSlot(storeSlot) {
-    return this.slotStoreService.get(storeSlot.store);
-  }
-  hasSingleSlotContent(storeSlot) {
-    const slot = this.slotStoreService.get(storeSlot.store);
-    return slot !== void 0 && !oimIsSlotEmpty(slot);
-  }
-  getSingleSlot(storeSlot) {
-    const found = this.slotStoreService.get(storeSlot.store);
-    if (found !== void 0) return found;
-    const slot = this.mintSingleSlot(storeSlot);
-    OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(storeSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot, slot);
-    return slot;
-  }
-  holdSingleSlot(storeSlot) {
-    const slot = this.slotStoreService.get(storeSlot.store) ?? this.mintSingleSlot(storeSlot);
-    this.slotOwnerService.holdSlot(slot);
-    return slot;
-  }
-  mintSingleSlot(storeSlot) {
-    const slotOwnerService = this.slotOwnerService;
-    const slot = slotOwnerService.createSlot(void 0, storeSlot);
-    slotOwnerService.settleEmptiness(slot, slotOwnerService.isSlotEmpty(slot));
-    slotOwnerService.fileSlot(storeSlot, slot);
-    return slot;
+    this.columnSlotOwner.unholdSlot(columnSlot);
   }
 };
 
-// src/engine/channel/utils/oimGetChannelQueueAtDepth.ts
-function oimGetChannelQueueAtDepth(channelQueues, depth) {
-  const found = channelQueues[depth];
-  if (found !== void 0) return found;
-  const made = new OIMChannelQueue();
-  channelQueues[depth] = made;
-  return made;
-}
-
 // src/engine/slot/OIMContentChangeDeliveryService.ts
 var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
-  isDeliveryDeferred(channelSlot) {
-    return channelSlot.contentSubframeDepth > 0 || channelSlot.subframeDeliveryDepth > 0;
+  isBatchOpen(storeSlot) {
+    return storeSlot.batchDepth > 0;
   }
-  openContentSubframe(channelSlot) {
-    OIMChannelService.INSTANCE.openSubframe(channelSlot);
-    channelSlot.contentSubframeDepth++;
+  openBatch(storeSlot) {
+    storeSlot.batchDepth++;
   }
-  closeContentSubframe(channelSlot) {
-    try {
-      if (--channelSlot.contentSubframeDepth > 0 || channelSlot.subframeDeliveryDepth > 0) return;
-      this.deliverEnqueuedContentChanges(channelSlot);
-    } finally {
-      OIMChannelService.INSTANCE.closeSubframe(channelSlot);
-    }
-  }
-  enqueueContentChange(channelSlot, storeSlot, slot, patch, changedColumns) {
-    const subframeDeliveryDepth = channelSlot.subframeDeliveryDepth;
-    const subframeSlotChannelQueue = oimGetChannelQueueAtDepth(
-      storeSlot.subframeSlotChannelQueues,
-      subframeDeliveryDepth
-    );
-    if (subframeSlotChannelQueue.getEntryCount() === 0) {
-      oimGetChannelQueueAtDepth(channelSlot.subframeStoreSlotChannelQueues, subframeDeliveryDepth).enqueueEntry(storeSlot);
-    }
-    subframeSlotChannelQueue.enqueueEntry(slot);
-    oimGetChannelQueueAtDepth(
-      storeSlot.subframePatchChannelQueues,
-      subframeDeliveryDepth
-    ).enqueueEntry(patch);
-    oimGetChannelQueueAtDepth(
-      storeSlot.subframeChangedColumnsChannelQueues,
-      subframeDeliveryDepth
-    ).enqueueEntry(changedColumns === void 0 ? void 0 : changedColumns.slice());
-  }
-  isLastEnqueuedSlot(channelSlot, storeSlot, slot) {
-    const subframeSlotChannelQueues = storeSlot.subframeSlotChannelQueues;
-    if (subframeSlotChannelQueues === void 0) return false;
-    const subframeSlotChannelQueue = subframeSlotChannelQueues[channelSlot.subframeDeliveryDepth];
-    if (subframeSlotChannelQueue === void 0) return false;
-    const subframeSlotCount = subframeSlotChannelQueue.getEntryCount();
-    return subframeSlotCount !== 0 && subframeSlotChannelQueue.getEntryAt(subframeSlotCount - 1) === slot;
-  }
-  deliverEnqueuedContentChanges(channelSlot) {
-    const storeSlotChannelQueue = channelSlot.subframeStoreSlotChannelQueues[channelSlot.subframeDeliveryDepth];
-    if (storeSlotChannelQueue === void 0 || storeSlotChannelQueue.getEntryCount() === 0) return;
-    this.deliverSubframeContentChanges(channelSlot, storeSlotChannelQueue);
-  }
-  deliverSubframeContentChanges(channelSlot, storeSlotChannelQueue) {
-    const subframeDeliveryDepth = channelSlot.subframeDeliveryDepth;
-    channelSlot.subframeDeliveryDepth = subframeDeliveryDepth + 1;
-    let isRefused = false;
-    let refusal;
-    try {
-      for (let i = 0; i < storeSlotChannelQueue.getEntryCount(); i++) {
-        try {
-          this.deliverStoreSlotContentChanges(storeSlotChannelQueue.getEntryAt(i), subframeDeliveryDepth);
-        } catch (error) {
-          if (!isRefused) refusal = error;
-          isRefused = true;
-        }
-      }
-      const nextStoreSlotChannelQueue = channelSlot.subframeStoreSlotChannelQueues[subframeDeliveryDepth + 1];
-      if (nextStoreSlotChannelQueue !== void 0 && nextStoreSlotChannelQueue.getEntryCount() !== 0) {
-        try {
-          this.deliverSubframeContentChanges(channelSlot, nextStoreSlotChannelQueue);
-        } catch (error) {
-          if (!isRefused) refusal = error;
-          isRefused = true;
-        }
-      }
-    } finally {
-      storeSlotChannelQueue.keepFirstEntries(0);
-      channelSlot.subframeDeliveryDepth = subframeDeliveryDepth;
-    }
-    if (isRefused) throw refusal;
+  closeBatch(storeSlot) {
+    const storeSlotEditable = storeSlot;
+    if (--storeSlotEditable.batchDepth > 0) return;
+    const batchSlotChannelQueue = storeSlot.batchSlotChannelQueue;
+    if (batchSlotChannelQueue === void 0 || batchSlotChannelQueue.getEntryCount() === 0) return;
+    this.deliverBatch(storeSlot, batchSlotChannelQueue);
   }
-  deliverStoreSlotContentChanges(storeSlot, subframeDeliveryDepth) {
-    const subframeSlotChannelQueue = storeSlot.subframeSlotChannelQueues[subframeDeliveryDepth];
-    const subframePatchChannelQueue = storeSlot.subframePatchChannelQueues[subframeDeliveryDepth];
-    const subframeChangedColumnsChannelQueue = storeSlot.subframeChangedColumnsChannelQueues[subframeDeliveryDepth];
+  enqueueContentChange(storeSlot, slot, patch, changedColumns) {
+    const storeSlotEditable = storeSlot;
+    (storeSlotEditable.batchSlotChannelQueue ?? (storeSlotEditable.batchSlotChannelQueue = new OIMChannelQueue())).enqueueEntry(slot);
+    (storeSlotEditable.batchPatchChannelQueue ?? (storeSlotEditable.batchPatchChannelQueue = new OIMChannelQueue())).enqueueEntry(patch);
+    (storeSlotEditable.batchChangedColumnsChannelQueue ?? (storeSlotEditable.batchChangedColumnsChannelQueue = new OIMChannelQueue())).enqueueEntry(changedColumns === void 0 ? void 0 : changedColumns.slice());
+  }
+  isLastEnqueuedSlot(storeSlot, slot) {
+    const batchSlotChannelQueue = storeSlot.batchSlotChannelQueue;
+    if (batchSlotChannelQueue === void 0) return false;
+    const batchSlotCount = batchSlotChannelQueue.getEntryCount();
+    return batchSlotCount !== 0 && batchSlotChannelQueue.getEntryAt(batchSlotCount - 1) === slot;
+  }
+  deliverBatch(storeSlot, batchSlotChannelQueue) {
+    const batchPatchChannelQueue = storeSlot.batchPatchChannelQueue;
+    const batchChangedColumnsChannelQueue = storeSlot.batchChangedColumnsChannelQueue;
     const listeners = storeSlot.contentChangeListeners;
     try {
-      if (subframeSlotChannelQueue.getEntryCount() === 1) {
-        const slot = subframeSlotChannelQueue.getEntryAt(0);
-        const patch = subframePatchChannelQueue.getEntryAt(0);
-        const changedColumns = subframeChangedColumnsChannelQueue.getEntryAt(0);
+      if (listeners === void 0) return;
+      if (batchSlotChannelQueue.getEntryCount() === 1) {
+        const slot = batchSlotChannelQueue.getEntryAt(0);
+        const patch = batchPatchChannelQueue.getEntryAt(0);
+        const changedColumns = batchChangedColumnsChannelQueue.getEntryAt(0);
         for (let i = 0; i < listeners.length; i++) listeners[i].onContentChanged(slot, patch, changedColumns);
       } else {
         for (let i = 0; i < listeners.length; i++) {
-          listeners[i].onContentChangedMany(subframeSlotChannelQueue, subframePatchChannelQueue, subframeChangedColumnsChannelQueue);
+          listeners[i].onContentChangedMany(batchSlotChannelQueue, batchPatchChannelQueue, batchChangedColumnsChannelQueue);
         }
       }
     } finally {
       try {
-        for (let i = 0; i < subframeSlotChannelQueue.getEntryCount(); i++) {
-          const slot = subframeSlotChannelQueue.getEntryAt(i);
+        for (let i = 0; i < batchSlotChannelQueue.getEntryCount(); i++) {
+          const slot = batchSlotChannelQueue.getEntryAt(i);
           slot.owner.releaseSlotIfUnheld(slot);
         }
       } finally {
-        subframeSlotChannelQueue.keepFirstEntries(0);
-        subframePatchChannelQueue.keepFirstEntries(0);
-        subframeChangedColumnsChannelQueue.keepFirstEntries(0);
+        batchSlotChannelQueue.keepFirstEntries(0);
+        batchPatchChannelQueue.keepFirstEntries(0);
+        batchChangedColumnsChannelQueue.keepFirstEntries(0);
       }
     }
   }
@@ -1825,8 +1581,8 @@ var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
 _OIMContentChangeDeliveryService.INSTANCE = new _OIMContentChangeDeliveryService();
 var OIMContentChangeDeliveryService = _OIMContentChangeDeliveryService;
 
-// src/engine/collector/OIMSlotReleasePolicyAtEmpty.ts
-var _OIMSlotReleasePolicyAtEmpty = class _OIMSlotReleasePolicyAtEmpty {
+// src/engine/collector/OIMSlotAtEmptyReleasePolicy.ts
+var _OIMSlotAtEmptyReleasePolicy = class _OIMSlotAtEmptyReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = false;
     this.schedulesReleaseOnWrite = false;
@@ -1850,34 +1606,26 @@ var _OIMSlotReleasePolicyAtEmpty = class _OIMSlotReleasePolicyAtEmpty {
     return;
   }
 };
-_OIMSlotReleasePolicyAtEmpty.INSTANCE = new _OIMSlotReleasePolicyAtEmpty();
-var OIMSlotReleasePolicyAtEmpty = _OIMSlotReleasePolicyAtEmpty;
+_OIMSlotAtEmptyReleasePolicy.INSTANCE = new _OIMSlotAtEmptyReleasePolicy();
+var OIMSlotAtEmptyReleasePolicy = _OIMSlotAtEmptyReleasePolicy;
 
 // src/engine/slot/OIMSlotOwnerService.ts
 var OIMSlotOwnerService = class extends OIMSlotOwner {
   constructor(options) {
     super();
-    this.slotContentStrategy = options.slotContentStrategy;
-    this.slotStoreService = options.slotStoreService;
+    this.slotContentService = options.slotContentService;
+    this.slotFilingService = options.slotFilingService;
     this.slotStamp = options.slotStamp;
-    const slotReleasePolicy = options.slotReleasePolicy ?? OIMSlotReleasePolicyAtEmpty.INSTANCE;
+    const slotReleasePolicy = options.slotReleasePolicy ?? OIMSlotAtEmptyReleasePolicy.INSTANCE;
     this.slotReleasePolicy = slotReleasePolicy;
     this.releasesWrittenSlots = slotReleasePolicy.releasesWrittenSlots;
     this.schedulesReleaseOnWrite = slotReleasePolicy.schedulesReleaseOnWrite;
-    this.columnOwner = options.createColumnOwner(options.columnOwnerOptions);
-    this.slotContentFlushStrategy = options.slotContentFlushStrategy;
-  }
-  listChangedStoreSlot(storeSlot) {
-    OIMChannelService.INSTANCE.listChangedStoreSlot(storeSlot.channelSlot, storeSlot, this);
-  }
-  onStoreSlotSubframeClosed(storeSlot) {
-    this.slotContentFlushStrategy?.onSubframeClosed(storeSlot, this);
-  }
-  createSlot(key, storeSlot) {
-    return this.slotContentStrategy.createSlot(key, storeSlot, this);
+    this.settlesWrittenSlots = this.releasesWrittenSlots || this.schedulesReleaseOnWrite || options.slotStamp !== void 0;
+    this.slotSubscriptionListener = options.slotSubscriptionListener ?? OIMNoSlotSubscriptionListener.INSTANCE;
+    this.columnSlotOwner = options.createColumnSlotOwner(options.columnSlotOwnerOptions);
   }
   isSlotEmpty(slot) {
-    return this.slotContentStrategy.isSlotEmpty(slot);
+    return this.slotContentService.isSlotEmpty(slot);
   }
   hasColumnSlots(slot) {
     return slot.columnSlotStore !== void 0;
@@ -1894,10 +1642,8 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     const listeners = storeSlot.contentChangeListeners;
     if (listeners === void 0 || listeners.length === 0) return;
     if (changedColumns !== void 0 && !this.isAnyColumnRead(storeSlot, changedColumns)) return;
-    const channelSlot = storeSlot.channelSlot;
-    const contentChangeDeliveryService = OIMContentChangeDeliveryService.INSTANCE;
-    if (contentChangeDeliveryService.isDeliveryDeferred(channelSlot)) {
-      contentChangeDeliveryService.enqueueContentChange(channelSlot, storeSlot, slot, patch, changedColumns);
+    if (storeSlot.batchDepth > 0) {
+      OIMContentChangeDeliveryService.INSTANCE.enqueueContentChange(storeSlot, slot, patch, changedColumns);
       return;
     }
     for (let i = 0; i < listeners.length; i++) listeners[i].onContentChanged(slot, patch, changedColumns);
@@ -1905,7 +1651,7 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
   isAnyColumnReferenced(slot, changedColumns) {
     const storeSlot = slot.storeSlot;
     if (storeSlot === void 0) return false;
-    return slot.columnSlotStore !== void 0 && this.columnOwner.isAnyColumnReferenced(storeSlot, changedColumns) || this.isAnyColumnRead(storeSlot, changedColumns);
+    return slot.columnSlotStore !== void 0 && this.columnSlotOwner.isAnyColumnReferenced(storeSlot, changedColumns) || this.isAnyColumnRead(storeSlot, changedColumns);
   }
   isAnyColumnRead(storeSlot, changedColumns) {
     if (storeSlot.allColumnsListenerCount !== 0) return true;
@@ -1924,11 +1670,7 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
   }
   releaseSlotIfUnheldAfterListeners(slot) {
     const storeSlot = slot.storeSlot;
-    if (storeSlot !== void 0) {
-      const contentChangeDeliveryService = OIMContentChangeDeliveryService.INSTANCE;
-      const channelSlot = storeSlot.channelSlot;
-      if (contentChangeDeliveryService.isDeliveryDeferred(channelSlot) && contentChangeDeliveryService.isLastEnqueuedSlot(channelSlot, storeSlot, slot)) return;
-    }
+    if (storeSlot !== void 0 && storeSlot.batchDepth > 0 && OIMContentChangeDeliveryService.INSTANCE.isLastEnqueuedSlot(storeSlot, slot)) return;
     this.releaseSlotIfUnheld(slot);
   }
   releaseWrittenSlotIfUnheld(slot) {
@@ -1938,8 +1680,8 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     OIMChannelService.INSTANCE.assertNotFlushing(oimGetChannelSlot(slot));
     oimAssertSlotNotReleased(slot);
   }
-  fileSlot(storeSlot, slot) {
-    this.slotStoreService.set(storeSlot.store, slot.key, slot);
+  fileSlot(slot) {
+    this.slotFilingService.fileSlot(slot.storeSlot.store, slot);
   }
   writeSlotToChannelAndSettle(slot, wasEmpty) {
     OIMChannelService.INSTANCE.writeWithoutFlushCheck(oimGetChannelSlot(slot), slot);
@@ -1969,6 +1711,12 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     if (oimIsSlotEmpty(slot)) return;
     if (this.slotReleasePolicy.onSlotIdle(slot)) this.releaseSlotIfUnheld(slot);
   }
+  onSlotFirstSubscribed(slot) {
+    this.slotSubscriptionListener.onSlotFirstSubscribed(slot);
+  }
+  onSlotLastUnsubscribed(slot) {
+    this.slotSubscriptionListener.onSlotLastUnsubscribed(slot);
+  }
   onSlotUnheld(slot) {
     this.slotReleasePolicy.onSlotUnheld(slot);
   }
@@ -1993,222 +1741,320 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     if (slot.holdCount > 0) return false;
     if (slot.owner !== this) return false;
     if (slot.columnSlotStore !== void 0) return false;
-    return !this.slotContentStrategy.hasReference(slot);
+    return !this.slotContentService.hasReference(slot);
   }
   releaseSlot(slot, isEmpty) {
     if (!isEmpty) this.assertWritable(slot);
-    this.slotContentStrategy.releaseSlotContent(slot, this);
+    this.slotContentService.releaseSlotContent(slot, this);
     slot.slotFlags |= OIM_SLOT_FLAG_EMPTY;
     this.slotReleasePolicy.cancelSlotRelease(slot);
     const storeSlot = slot.storeSlot;
-    if (storeSlot !== void 0) this.slotStoreService.remove(storeSlot.store, slot.key);
+    if (storeSlot !== void 0) this.slotFilingService.unfileSlot(storeSlot.store, slot);
     oimMarkSlotReleased(slot);
   }
 };
 
-// src/engine/entity/utils/createOIMEntitySlot.ts
-function createOIMEntitySlot(key, owner, storeSlot = void 0) {
+// src/engine/slot/utils/createOIMStoreSlot.ts
+function createOIMStoreSlot(store, channelSlot, slotService, sourceStoreSlot) {
   return {
-    effects: void 0,
-    changedAtRevision: 0,
-    changedAtEpoch: 0,
-    effectEdges: void 0,
-    holdCount: 0,
-    releaseDueAfterWriteMs: -1,
-    releaseDueAfterIdleMs: -1,
-    releaseDueAfterUnholdMs: -1,
-    slotFlags: OIM_SLOT_FLAG_EMPTY,
-    owner,
-    key,
-    entity: void 0,
-    columnSlotStore: void 0,
-    storeSlot,
-    data: void 0,
-    indexKeys: void 0
-  };
-}
-
-// src/engine/slot/utils/oimFillEntitiesLengthMismatchError.ts
-function oimFillEntitiesLengthMismatchError(collectionName, keyCount, contentCount) {
-  return new Error(
-    `${collectionName}.fillEntities: ${keyCount} keys against ${contentCount} contents. The two run in step \u2014 the content at a position is filed under the key at that same position \u2014 so lists of different lengths name either a key with nothing to file or a content with nowhere to go, and which of the two it is cannot be guessed.`
-  );
-}
-
-// src/engine/slot/utils/oimFillEntitiesIntoFilledCollectionError.ts
-function oimFillEntitiesIntoFilledCollectionError(collectionName) {
-  return new Error(
-    `${collectionName}.fillEntities: this collection already holds identities, and fillEntities files every key without asking whether it is taken \u2014 which would mint a second identity under a key that has one and strand every effect on the first. Use \`upsertEntity\` per entry, which asks; it is one hash more and correct at any moment.`
-  );
-}
-
-// src/engine/slot/utils/oimFillEntitiesKeyNamedTwiceError.ts
-function oimFillEntitiesKeyNamedTwiceError(collectionName) {
-  return new Error(
-    `${collectionName}.fillEntities: the pairs name one key more than once. Filing the second would take the identity the first is under and strand every effect on it, and nothing could reach the stranded one again. The collection is left as fillEntities found it. Use \`upsertEntity\` per entry, which asks.`
-  );
-}
-
-// src/engine/entity/OIMSlotEmptinessByEntityPresence.ts
-var _OIMSlotEmptinessByEntityPresence = class _OIMSlotEmptinessByEntityPresence {
-  isEmpty(entitySlot) {
-    return entitySlot.entity === void 0;
-  }
-};
-_OIMSlotEmptinessByEntityPresence.INSTANCE = new _OIMSlotEmptinessByEntityPresence();
-var OIMSlotEmptinessByEntityPresence = _OIMSlotEmptinessByEntityPresence;
-
-// src/engine/entity/OIMSlotContentEntityService.ts
-var OIMSlotContentEntityService = class {
-  constructor(options) {
-    this.keyOf = options.keyOf;
-    this.slotStoreService = options.slotStoreService;
-    this.entityWriter = options.entityWriter;
-    this.slotEmptiness = options.slotEmptiness;
-    this.updatesEmptinessOnColumnWrite = options.slotEmptiness !== OIMSlotEmptinessByEntityPresence.INSTANCE || options.slotReleasePolicy?.schedulesReleaseOnWrite === true || options.slotReleasePolicy?.releasesWrittenSlots === true || options.slotStamp !== void 0;
-    this.slotOwnerService = new OIMSlotOwnerService({
-      slotStamp: options.slotStamp,
-      slotReleasePolicy: options.slotReleasePolicy,
-      slotStoreService: options.slotStoreService,
-      slotContentStrategy: {
-        createSlot: (key, storeSlot, slotOwnerService) => createOIMEntitySlot(key, slotOwnerService, storeSlot),
-        isSlotEmpty: (entitySlot) => this.slotEmptiness.isEmpty(entitySlot),
-        hasReference: () => false,
-        releaseSlotContent: (entitySlot) => {
-          this.releaseSlotContent(entitySlot);
-        }
-      },
-      columnOwnerOptions: options.columnOwnerOptions,
-      createColumnOwner: options.createColumnOwner
-    });
+    store,
+    slotService,
+    channelSlot,
+    contentChangeListeners: void 0,
+    contentChangeListenerReadColumnNames: void 0,
+    indexKeysPositions: void 0,
+    columnListenerCountsByColumnName: void 0,
+    allColumnsListenerCount: 0,
+    columnGroupsByKey: void 0,
+    columnGroupSlotCountsByKey: void 0,
+    columnReadersByColumnName: void 0,
+    anyColumnSlotCount: 0,
+    batchDepth: 0,
+    batchSlotChannelQueue: void 0,
+    batchPatchChannelQueue: void 0,
+    batchChangedColumnsChannelQueue: void 0,
+    arrivedBucketMemberSlotChannelQueues: void 0,
+    departedBucketMemberSlotChannelQueues: void 0,
+    removedAtChannelQueues: void 0,
+    writeDepth: 0,
+    commandsBucketSlotChannelQueue: void 0,
+    sourceStoreSlot,
+    keptStampedEntitySlots: void 0,
+    derive: void 0,
+    createSources: void 0,
+    indexKeysPosition: -1,
+    contentChangeListener: void 0,
+    requestedKeys: void 0,
+    bucketColumnNames: void 0,
+    isAnyBucketColumnRead: false,
+    isDisposed: false
+  };
+}
+
+// src/facade/slot/OIMSlotCollectionService.ts
+var OIMSlotCollectionService = class {
+  constructor(options) {
+    const slotOwnerService = new OIMSlotOwnerService({ ...options, slotFilingService: options.slotStoreService });
+    this.slotOwnerService = slotOwnerService;
+    this.columnSlotService = new OIMColumnSlotService(slotOwnerService.columnSlotOwner);
+    this.slotStoreService = options.slotStoreService;
+    this.keyedSlotCreator = options.slotContentService;
+    this.slotContentService = options.slotContentService;
+    this.storeSlotListener = options.storeSlotListener;
   }
   get slotOwner() {
     return this.slotOwnerService;
   }
-  findEntityByKey(storeSlot, key) {
-    return this.slotStoreService.get(storeSlot.store, key)?.entity;
+  createStoreSlot(channelMap) {
+    const channelSlot = channelMap.defaultChannelSlot;
+    return this.createStoreSlotWith((store) => createOIMStoreSlot(store, channelSlot, this));
+  }
+  createStoreSlotFrom(sourceStoreSlot) {
+    return this.createStoreSlotWith((store) => createOIMStoreSlot(
+      store,
+      sourceStoreSlot.channelSlot,
+      this,
+      sourceStoreSlot
+    ));
+  }
+  createStoreSlotWith(createStoreSlotLiteral) {
+    const storeSlot = createStoreSlotLiteral(this.slotStoreService.createStore());
+    if (this.storeSlotListener !== void 0) this.storeSlotListener.onStoreSlotCreated(storeSlot);
+    return storeSlot;
+  }
+  findSlotByKey(storeSlot, key) {
+    return this.slotStoreService.get(storeSlot.store, key);
+  }
+  hasSlotContentByKey(storeSlot, key) {
+    const slot = this.slotStoreService.get(storeSlot.store, key);
+    return slot !== void 0 && !oimIsSlotEmpty(slot);
+  }
+  getSlotByKey(storeSlot, key) {
+    const found = this.slotStoreService.get(storeSlot.store, key);
+    if (found !== void 0) return found;
+    const slot = this.mintSlotByKey(storeSlot, key);
+    OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(storeSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot, slot);
+    return slot;
+  }
+  holdSlotByKey(storeSlot, key) {
+    const slot = this.slotStoreService.get(storeSlot.store, key) ?? this.mintSlotByKey(storeSlot, key);
+    this.slotOwnerService.holdSlot(slot);
+    return slot;
+  }
+  getSlots(storeSlot) {
+    return this.slotStoreService.getSlots(storeSlot.store);
+  }
+  getSlotCount(storeSlot) {
+    return this.slotStoreService.getSlotCount(storeSlot.store);
+  }
+  isSameKey(key, otherKey) {
+    return this.slotStoreService.isSameKey(key, otherKey);
+  }
+  openBatch(storeSlot) {
+    OIMContentChangeDeliveryService.INSTANCE.openBatch(storeSlot);
   }
-  upsertEntity(storeSlot, entity, changedEntitySlots) {
-    return this.insertEntity(storeSlot, this.keyOf(entity), entity, changedEntitySlots);
+  closeBatch(storeSlot) {
+    OIMContentChangeDeliveryService.INSTANCE.closeBatch(storeSlot);
   }
-  upsertEntities(storeSlot, entities, changedEntitySlots) {
-    const entitySlots = [];
-    const channelSlot = storeSlot.channelSlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
+  writeInBatch(storeSlot, write) {
+    const contentChangeDeliveryService = OIMContentChangeDeliveryService.INSTANCE;
+    contentChangeDeliveryService.openBatch(storeSlot);
     try {
-      for (let i = 0; i < entities.length; i++) entitySlots.push(this.upsertEntity(storeSlot, entities[i], changedEntitySlots));
-      return entitySlots;
+      return write();
     } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+      contentChangeDeliveryService.closeBatch(storeSlot);
     }
   }
-  insertEntity(storeSlot, key, entity, changedEntitySlots) {
+  onSlotMinted(_storeSlot, _slot) {
+    return;
+  }
+  mintSlotByKey(storeSlot, key) {
+    const slotOwnerService = this.slotOwnerService;
+    const slot = this.keyedSlotCreator.createSlot(this.slotStoreService.ownKey(key), storeSlot, slotOwnerService);
+    this.onSlotMinted(storeSlot, slot);
+    slotOwnerService.settleEmptiness(slot, slotOwnerService.isSlotEmpty(slot));
+    slotOwnerService.fileSlot(slot);
+    return slot;
+  }
+};
+
+// src/facade/slot/OIMWritableSlotCollectionService.ts
+var OIMWritableSlotCollectionService = class extends OIMSlotCollectionService {
+  writeSlotContentByKey(storeSlot, key, content, changedSlots) {
     const filed = this.slotStoreService.get(storeSlot.store, key);
     if (filed !== void 0) {
-      const landedOnFiled = this.writeEntity(filed, entity);
-      if (landedOnFiled && changedEntitySlots !== void 0) changedEntitySlots.push(filed);
+      if (this.slotContentService.writeSlotContent(filed, content) && changedSlots !== void 0) changedSlots.push(filed);
       return filed;
     }
-    const entitySlot = this.slotOwnerService.createSlot(this.slotStoreService.ownKey(key), storeSlot);
-    if (this.isOnFastPath(entitySlot)) return this.insertEntityOnFastPath(storeSlot, entitySlot, entity, changedEntitySlots);
-    return this.insertEntityInSubframe(storeSlot, entitySlot, entity, changedEntitySlots);
+    const slot = this.slotContentService.createSlot(this.slotStoreService.ownKey(key), storeSlot, this.slotOwnerService);
+    this.slotContentService.insertSlotContent(slot, content, changedSlots);
+    return slot;
+  }
+};
+
+// src/facade/slot/OIMSingleSlotService.ts
+var OIMSingleSlotService = class {
+  constructor(options) {
+    const slotOwnerService = new OIMSlotOwnerService({ ...options, slotFilingService: options.slotStoreService });
+    this.slotOwnerService = slotOwnerService;
+    this.columnSlotService = new OIMColumnSlotService(slotOwnerService.columnSlotOwner);
+    this.slotStoreService = options.slotStoreService;
+    this.singleSlotCreator = options.slotContentService;
+    this.slotContentService = options.slotContentService;
+    this.storeSlotListener = options.storeSlotListener;
   }
-  insertEntities(storeSlot, entities) {
-    this.fillEntitiesUnderKeys(storeSlot, void 0, entities);
+  get slotOwner() {
+    return this.slotOwnerService;
   }
-  fillEntities(storeSlot, keys, entities) {
-    if (keys.length !== entities.length) {
-      throw oimFillEntitiesLengthMismatchError("OIMSlotContentEntityService", keys.length, entities.length);
-    }
-    if (this.slotStoreService.getSlotCount(storeSlot.store) !== 0) throw oimFillEntitiesIntoFilledCollectionError("OIMSlotContentEntityService");
-    this.fillEntitiesUnderKeys(storeSlot, keys, entities);
+  createStoreSlot(channelMap) {
+    const storeSlot = createOIMStoreSlot(
+      this.slotStoreService.createStore(),
+      channelMap.defaultChannelSlot,
+      this
+    );
+    if (this.storeSlotListener !== void 0) this.storeSlotListener.onStoreSlotCreated(storeSlot);
+    return storeSlot;
   }
-  fillEntitiesUnderKeys(storeSlot, keys, entities) {
-    const channelSlot = storeSlot.channelSlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const filedCount = this.fillEachEntity(storeSlot, keys, entities);
-      if (filedCount === entities.length) return;
-      const slotOwnerService = this.slotOwnerService;
-      for (let i = 0; i < filedCount; i++) {
-        const entitySlot = this.slotStoreService.get(storeSlot.store, keys === void 0 ? this.keyOf(entities[i]) : keys[i]);
-        if (entitySlot === void 0) continue;
-        slotOwnerService.assertWritable(entitySlot);
-        this.clearSlotContent(entitySlot);
-      }
-      throw oimFillEntitiesKeyNamedTwiceError("OIMSlotContentEntityService");
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+  findSingleSlot(storeSlot) {
+    return this.slotStoreService.getSingleSlot(storeSlot.store);
   }
-  clearAllEntities(storeSlot) {
-    const slotOwnerService = this.slotOwnerService;
-    const channelSlot = storeSlot.channelSlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      for (const entitySlot of this.slotStoreService.getSlots(storeSlot.store)) {
-        slotOwnerService.assertWritable(entitySlot);
-        this.clearSlotContent(entitySlot);
-      }
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+  hasSingleSlotContent(storeSlot) {
+    const slot = this.slotStoreService.getSingleSlot(storeSlot.store);
+    return slot !== void 0 && !oimIsSlotEmpty(slot);
+  }
+  getSingleSlot(storeSlot) {
+    const found = this.slotStoreService.getSingleSlot(storeSlot.store);
+    if (found !== void 0) return found;
+    const slot = this.mintSingleSlot(storeSlot);
+    OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(storeSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot, slot);
+    return slot;
+  }
+  holdSingleSlot(storeSlot) {
+    const slot = this.slotStoreService.getSingleSlot(storeSlot.store) ?? this.mintSingleSlot(storeSlot);
+    this.slotOwnerService.holdSlot(slot);
+    return slot;
   }
-  fillEachEntity(storeSlot, keys, entities) {
-    const slotStoreService = this.slotStoreService;
+  mintSingleSlot(storeSlot) {
     const slotOwnerService = this.slotOwnerService;
-    const store = storeSlot.store;
-    const isStoreEmptyAtStart = slotStoreService.getSlotCount(store) === 0;
-    const filedEntitySlots = isStoreEmptyAtStart ? [] : void 0;
-    let i = 0;
-    let filingEntitySlot;
-    try {
-      for (; i < entities.length; i++) {
-        filingEntitySlot = void 0;
-        const key = keys === void 0 ? this.keyOf(entities[i]) : keys[i];
-        if (filedEntitySlots === void 0 && slotStoreService.get(store, key) !== void 0) return i;
-        const entitySlot = slotOwnerService.createSlot(slotStoreService.ownKey(key), storeSlot);
-        slotOwnerService.assertWritable(entitySlot);
-        slotOwnerService.fileSlot(storeSlot, entitySlot);
-        if (filedEntitySlots !== void 0) {
-          if (slotStoreService.getSlotCount(store) === filedEntitySlots.length) {
-            this.refileRepeatedKey(storeSlot, filedEntitySlots, entitySlot);
-            return i;
-          }
-          filedEntitySlots.push(entitySlot);
-        }
-        filingEntitySlot = entitySlot;
-        this.fillSlotContent(entitySlot, entities[i]);
-        if (oimIsSlotEmpty(entitySlot)) slotOwnerService.releaseSlotIfUnheld(entitySlot);
-        else slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
-      }
-    } catch (refusal) {
-      for (let j = 0; j < i; j++) {
-        const entitySlot = slotStoreService.get(store, keys === void 0 ? this.keyOf(entities[j]) : keys[j]);
-        if (entitySlot !== void 0) slotOwnerService.releaseSlotIfUnheld(entitySlot);
-      }
-      if (filingEntitySlot !== void 0) slotOwnerService.releaseSlotIfUnheld(filingEntitySlot);
-      throw refusal;
+    const slot = this.singleSlotCreator.createSingleSlot(storeSlot, slotOwnerService);
+    slotOwnerService.settleEmptiness(slot, slotOwnerService.isSlotEmpty(slot));
+    slotOwnerService.fileSlot(slot);
+    return slot;
+  }
+};
+
+// src/facade/slot/OIMWritableSingleSlotService.ts
+var OIMWritableSingleSlotService = class extends OIMSingleSlotService {
+  writeSingleSlotContent(storeSlot, content, changedSlots) {
+    const filed = this.slotStoreService.getSingleSlot(storeSlot.store);
+    if (filed !== void 0) {
+      if (this.slotContentService.writeSlotContent(filed, content) && changedSlots !== void 0) changedSlots.push(filed);
+      return filed;
     }
-    return entities.length;
+    const slot = this.slotContentService.createSingleSlot(storeSlot, this.slotOwnerService);
+    this.slotContentService.insertSlotContent(slot, content, changedSlots);
+    return slot;
+  }
+  clearSingleSlotContent(storeSlot) {
+    const slot = this.slotStoreService.getSingleSlot(storeSlot.store);
+    if (slot !== void 0) this.slotContentService.clearSlotContent(slot);
+  }
+};
+
+// src/engine/entity/OIMSlotEntityPresenceEmptinessPolicy.ts
+var _OIMSlotEntityPresenceEmptinessPolicy = class _OIMSlotEntityPresenceEmptinessPolicy {
+  isEmpty(entitySlot) {
+    return entitySlot.entity === void 0;
+  }
+};
+_OIMSlotEntityPresenceEmptinessPolicy.INSTANCE = new _OIMSlotEntityPresenceEmptinessPolicy();
+var OIMSlotEntityPresenceEmptinessPolicy = _OIMSlotEntityPresenceEmptinessPolicy;
+
+// src/engine/entity/utils/createOIMEntitySlot.ts
+function createOIMEntitySlot(key, owner, storeSlot = void 0) {
+  return {
+    effects: void 0,
+    changedAtRevision: 0,
+    changedAtEpoch: 0,
+    effectEdges: void 0,
+    holdCount: 0,
+    releaseDueAfterWriteMs: -1,
+    releaseDueAfterIdleMs: -1,
+    releaseDueAfterUnholdMs: -1,
+    slotFlags: OIM_SLOT_FLAG_EMPTY,
+    owner,
+    key,
+    entity: void 0,
+    columnSlotStore: void 0,
+    storeSlot,
+    data: void 0,
+    indexKeys: void 0
+  };
+}
+
+// src/engine/entity/utils/createOIMSingleEntitySlot.ts
+function createOIMSingleEntitySlot(owner, storeSlot) {
+  const singleEntitySlot = {
+    effects: void 0,
+    changedAtRevision: 0,
+    changedAtEpoch: 0,
+    effectEdges: void 0,
+    holdCount: 0,
+    releaseDueAfterWriteMs: -1,
+    releaseDueAfterIdleMs: -1,
+    releaseDueAfterUnholdMs: -1,
+    slotFlags: OIM_SLOT_FLAG_EMPTY,
+    owner,
+    key: void 0,
+    entity: void 0,
+    columnSlotStore: void 0,
+    storeSlot,
+    data: void 0,
+    indexKeys: void 0
+  };
+  return singleEntitySlot;
+}
+
+// src/engine/entity/OIMSlotContentEntityService.ts
+var OIMSlotContentEntityService = class {
+  constructor(options) {
+    this.entityWriter = options.entityWriter;
+    this.slotEmptinessPolicy = options.slotEmptinessPolicy;
+    this.isSlotEmptinessCustom = options.slotEmptinessPolicy !== OIMSlotEntityPresenceEmptinessPolicy.INSTANCE;
+  }
+  createSlot(key, storeSlot, slotOwner) {
+    return createOIMEntitySlot(key, slotOwner, storeSlot);
+  }
+  createSingleSlot(storeSlot, slotOwner) {
+    return createOIMSingleEntitySlot(slotOwner, storeSlot);
   }
-  refileRepeatedKey(storeSlot, filedEntitySlots, repeatingEntitySlot) {
-    const slotStoreService = this.slotStoreService;
-    for (let j = 0; j < filedEntitySlots.length; j++) {
-      const filedEntitySlot = filedEntitySlots[j];
-      if (!slotStoreService.isSameKey(filedEntitySlot.key, repeatingEntitySlot.key)) continue;
-      this.slotOwnerService.fileSlot(storeSlot, filedEntitySlot);
+  isSlotEmpty(entitySlot) {
+    return this.slotEmptinessPolicy.isEmpty(entitySlot);
+  }
+  hasReference() {
+    return false;
+  }
+  updatesEmptinessOnColumnWriteOf(entitySlot) {
+    return this.isSlotEmptinessCustom || this.slotOwnerServiceOf(entitySlot).settlesWrittenSlots;
+  }
+  slotOwnerServiceOf(entitySlot) {
+    return entitySlot.owner;
+  }
+  insertSlotContent(entitySlot, entity, changedEntitySlots) {
+    if (this.isOnFastPath(entitySlot)) {
+      this.insertEntityOnFastPath(entitySlot, entity, changedEntitySlots);
       return;
     }
+    this.insertEntityOffFastPath(entitySlot, entity, changedEntitySlots);
   }
-  insertEntityOnFastPath(storeSlot, entitySlot, entity, changedEntitySlots) {
-    const slotOwnerService = this.slotOwnerService;
+  insertEntityOnFastPath(entitySlot, entity, changedEntitySlots) {
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
     try {
       slotOwnerService.assertWritable(entitySlot);
       this.entityWriter.fillEntity(entitySlot, entity);
       this.updateEntitySlotEmptiness(entitySlot);
-      slotOwnerService.fileSlot(storeSlot, entitySlot);
-      const channelSlot = storeSlot.channelSlot;
+      slotOwnerService.fileSlot(entitySlot);
+      const channelSlot = oimGetChannelSlot(entitySlot);
       if (oimIsSlotEmpty(entitySlot)) OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(channelSlot.collectorSlot.unusedSlotCollectorSlot, entitySlot);
       OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
     } catch (refusal) {
@@ -2216,170 +2062,137 @@ var OIMSlotContentEntityService = class {
       throw refusal;
     }
     if (changedEntitySlots !== void 0) changedEntitySlots.push(entitySlot);
-    return entitySlot;
   }
-  insertEntityInSubframe(storeSlot, entitySlot, entity, changedEntitySlots) {
-    const slotOwnerService = this.slotOwnerService;
-    let isAnnounced = false;
-    const channelSlot = storeSlot.channelSlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
+  insertEntityOffFastPath(entitySlot, entity, changedEntitySlots) {
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
+    let isLanded;
     try {
       slotOwnerService.assertWritable(entitySlot);
-      isAnnounced = this.fillSlotContent(entitySlot, entity);
-      slotOwnerService.fileSlot(storeSlot, entitySlot);
-      if (oimIsSlotEmpty(entitySlot)) OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(channelSlot.collectorSlot.unusedSlotCollectorSlot, entitySlot);
-      else slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
+      isLanded = this.writeEntityToSlot(entitySlot, entity, void 0);
+      this.updateEntitySlotEmptiness(entitySlot);
+      slotOwnerService.fileSlot(entitySlot);
     } catch (refusal) {
-      this.withdrawSlotContent(entitySlot, isAnnounced);
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+      slotOwnerService.releaseSlotIfUnheld(entitySlot);
       throw refusal;
     }
-    try {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    } catch (refusal) {
-      this.withdrawSlotContent(entitySlot, isAnnounced);
-      throw refusal;
+    if (oimIsSlotEmpty(entitySlot)) {
+      const unusedSlotCollectorSlot = oimGetChannelSlot(entitySlot).collectorSlot.unusedSlotCollectorSlot;
+      OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(unusedSlotCollectorSlot, entitySlot);
     }
-    if (isAnnounced && changedEntitySlots !== void 0) changedEntitySlots.push(entitySlot);
-    return entitySlot;
+    if (!isLanded) return;
+    slotOwnerService.dispatchContentChange(entitySlot, entity);
+    if (!oimIsSlotEmpty(entitySlot)) slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
+    if (changedEntitySlots !== void 0) changedEntitySlots.push(entitySlot);
   }
-  writeEntity(entitySlot, entity) {
-    const slotOwnerService = this.slotOwnerService;
+  writeSlotContent(entitySlot, entity) {
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
     slotOwnerService.assertWritable(entitySlot);
     if (entitySlot.entity !== void 0 && this.isOnFastPath(entitySlot)) {
       if (!this.entityWriter.putEntity(entitySlot, entity, void 0)) return false;
       this.writeSlotToChannelAndReleaseIfUnheld(entitySlot);
       return true;
     }
-    if (entitySlot.entity !== void 0 && !this.updatesEmptinessOnColumnWrite) {
+    if (entitySlot.entity !== void 0 && !this.updatesEmptinessOnColumnWriteOf(entitySlot)) {
       const channelSlot2 = oimGetChannelSlot(entitySlot);
-      const changedColumnNames = slotOwnerService.takeChangedColumnNames(channelSlot2);
-      if (!this.entityWriter.putEntity(entitySlot, entity, changedColumnNames)) return false;
-      if (!slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumnNames)) {
+      const changedColumnNames2 = slotOwnerService.takeChangedColumnNames(channelSlot2);
+      if (!this.entityWriter.putEntity(entitySlot, entity, changedColumnNames2)) return false;
+      if (!slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumnNames2)) {
         this.writeSlotToChannelAndReleaseIfUnheld(entitySlot);
         return true;
       }
+      this.dispatchColumnsChanged(entitySlot, void 0, changedColumnNames2);
       if (!slotOwnerService.hasContentChangeListeners(entitySlot)) {
-        OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot2);
-        try {
-          this.dispatchColumnsChanged(entitySlot, void 0, changedColumnNames);
-        } finally {
-          OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot2);
-        }
         slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
         return true;
       }
-      OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot2);
-      try {
-        this.dispatchColumnsChanged(entitySlot, void 0, changedColumnNames);
-        this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, entity, changedColumnNames);
-      } finally {
-        OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot2);
-      }
+      this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, entity, changedColumnNames2);
       return true;
     }
     const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const wasEmpty = oimIsSlotEmpty(entitySlot);
-      const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? slotOwnerService.takeChangedColumnNames(channelSlot) : void 0;
-      const landed = this.writeEntityWithoutSubframe(entitySlot, entity, changedColumnNames);
-      if (landed) {
-        this.updateEntitySlotEmptiness(entitySlot);
-        this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, entity, wasEmpty ? void 0 : changedColumnNames);
-      }
-      return landed;
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    const wasEmpty = oimIsSlotEmpty(entitySlot);
+    const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? slotOwnerService.takeChangedColumnNames(channelSlot) : void 0;
+    const isLanded = this.writeEntityToSlot(entitySlot, entity, changedColumnNames);
+    if (isLanded) {
+      this.updateEntitySlotEmptiness(entitySlot);
+      this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, entity, wasEmpty ? void 0 : changedColumnNames);
     }
+    return isLanded;
   }
   updateEntity(entitySlot, patch) {
-    this.slotOwnerService.assertWritable(entitySlot);
-    if (!this.isOnFastPath(entitySlot)) return this.updateEntityInSubframe(entitySlot, patch);
+    this.slotOwnerServiceOf(entitySlot).assertWritable(entitySlot);
+    if (!this.isOnFastPath(entitySlot)) return this.updateEntityOffFastPath(entitySlot, patch);
     if (!this.entityWriter.patchEntity(entitySlot, patch, void 0)) return entitySlot;
     this.writeSlotToChannelAndReleaseIfUnheld(entitySlot);
     return entitySlot;
   }
   updateEntityColumn(entitySlot, columnName, value) {
-    this.slotOwnerService.assertWritable(entitySlot);
+    this.slotOwnerServiceOf(entitySlot).assertWritable(entitySlot);
     if (!this.isOnFastPath(entitySlot)) return this.updateEntityColumnOffFastPath(entitySlot, columnName, value);
     if (!this.entityWriter.patchColumn(entitySlot, columnName, value, void 0)) return entitySlot;
     this.writeSlotToChannelAndReleaseIfUnheld(entitySlot);
     return entitySlot;
   }
   deleteEntityColumns(entitySlot, columnNames) {
-    this.slotOwnerService.assertWritable(entitySlot);
-    const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const deletedColumnNames = this.entityWriter.deleteColumns(entitySlot, columnNames);
-      if (deletedColumnNames.length !== 0) {
-        this.dispatchColumnsChanged(entitySlot, void 0, deletedColumnNames);
-        this.updateEntitySlotEmptiness(entitySlot);
-        this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, void 0, deletedColumnNames);
-      }
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    this.slotOwnerServiceOf(entitySlot).assertWritable(entitySlot);
+    const deletedColumnNames = this.entityWriter.deleteColumns(entitySlot, columnNames);
+    if (deletedColumnNames.length !== 0) {
+      this.dispatchColumnsChanged(entitySlot, void 0, deletedColumnNames);
+      this.updateEntitySlotEmptiness(entitySlot);
+      this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, void 0, deletedColumnNames);
     }
     return entitySlot;
   }
   markEntityChanged(entitySlot, changedColumns) {
-    const slotOwnerService = this.slotOwnerService;
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
     slotOwnerService.assertWritable(entitySlot);
     if (changedColumns !== void 0 && changedColumns.length === 0) return;
-    if (changedColumns !== void 0 && !this.updatesEmptinessOnColumnWrite && entitySlot.entity !== void 0 && !slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumns)) {
+    if (changedColumns !== void 0 && !this.updatesEmptinessOnColumnWriteOf(entitySlot) && entitySlot.entity !== void 0 && !slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumns)) {
       this.writeSlotToChannelAndReleaseIfUnheld(entitySlot);
       return;
     }
     const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const hasColumnSlots = slotOwnerService.hasColumnSlots(entitySlot);
-      const isObserved = changedColumns === void 0 || !hasColumnSlots || slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumns);
-      if (hasColumnSlots && isObserved) {
-        slotOwnerService.columnOwner.markColumnsChanged(entitySlot, void 0, changedColumns, channelSlot);
-      }
-      OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
-      if (this.updatesEmptinessOnColumnWrite || changedColumns === void 0 || entitySlot.entity === void 0) {
-        this.updateEntitySlotEmptiness(entitySlot);
-      }
-      if (isObserved) slotOwnerService.dispatchContentChange(entitySlot, void 0, changedColumns);
-      slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    const hasColumnSlots = slotOwnerService.hasColumnSlots(entitySlot);
+    const isObserved = changedColumns === void 0 || !hasColumnSlots || slotOwnerService.isAnyColumnReferenced(entitySlot, changedColumns);
+    if (hasColumnSlots && isObserved) {
+      slotOwnerService.columnSlotOwner.markColumnsChanged(entitySlot, void 0, changedColumns, channelSlot);
     }
-  }
-  deleteEntity(entitySlot) {
-    this.slotOwnerService.assertWritable(entitySlot);
-    this.clearSlotContent(entitySlot);
-  }
-  deleteEntities(storeSlot, entitySlots) {
-    const channelSlot = storeSlot.channelSlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      for (let i = 0; i < entitySlots.length; i++) this.deleteEntity(entitySlots[i]);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
+    if (this.updatesEmptinessOnColumnWriteOf(entitySlot) || changedColumns === void 0 || entitySlot.entity === void 0) {
+      this.updateEntitySlotEmptiness(entitySlot);
     }
+    if (isObserved) slotOwnerService.dispatchContentChange(entitySlot, void 0, changedColumns);
+    slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
   }
-  updateEntityInSubframe(entitySlot, patch) {
+  clearSlotContent(entitySlot) {
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
+    slotOwnerService.assertWritable(entitySlot);
     const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? this.slotOwnerService.takeChangedColumnNames(channelSlot) : void 0;
-      if (this.entityWriter.patchEntity(entitySlot, patch, changedColumnNames)) {
-        this.dispatchPatchWritten(entitySlot, patch, changedColumnNames);
-      }
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    if (!this.isOnFastPath(entitySlot)) {
+      this.releaseSlotContent(entitySlot);
+      slotOwnerService.settleEmptiness(entitySlot, this.slotEmptinessPolicy.isEmpty(entitySlot));
+      slotOwnerService.dispatchContentChange(entitySlot);
+      slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
+      return;
+    }
+    if (entitySlot.entity !== void 0) {
+      this.entityWriter.clearEntity(entitySlot);
+      OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
+      slotOwnerService.markEmptiness(entitySlot, this.slotEmptinessPolicy.isEmpty(entitySlot));
+    }
+    slotOwnerService.releaseSlotIfUnheld(entitySlot);
+  }
+  updateEntityOffFastPath(entitySlot, patch) {
+    const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? this.slotOwnerServiceOf(entitySlot).takeChangedColumnNames(oimGetChannelSlot(entitySlot)) : void 0;
+    if (this.entityWriter.patchEntity(entitySlot, patch, changedColumnNames)) {
+      this.dispatchPatchWritten(entitySlot, patch, changedColumnNames);
     }
     return entitySlot;
   }
   updateEntityColumnOffFastPath(entitySlot, columnName, value) {
-    if (this.updatesEmptinessOnColumnWrite || entitySlot.entity === void 0) {
-      return this.updateEntityColumnInSubframe(entitySlot, columnName, value);
+    if (this.updatesEmptinessOnColumnWriteOf(entitySlot) || entitySlot.entity === void 0) {
+      return this.updateEntityColumnAndDispatch(entitySlot, columnName, value);
     }
-    const slotOwnerService = this.slotOwnerService;
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
     const channelSlot = oimGetChannelSlot(entitySlot);
     const columnNames = slotOwnerService.takeChangedColumnNames(channelSlot);
     columnNames.push(columnName);
@@ -2389,105 +2202,51 @@ var OIMSlotContentEntityService = class {
       return entitySlot;
     }
     if (slotOwnerService.hasContentChangeListeners(entitySlot)) {
-      return this.updateEntityColumnInSubframe(entitySlot, columnName, value);
+      return this.updateEntityColumnAndDispatch(entitySlot, columnName, value);
     }
     if (!this.entityWriter.patchColumn(entitySlot, columnName, value, void 0)) return entitySlot;
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      this.dispatchColumnsChanged(entitySlot, void 0, columnNames);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+    this.dispatchColumnsChanged(entitySlot, void 0, columnNames);
     slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
     return entitySlot;
   }
-  updateEntityColumnInSubframe(entitySlot, columnName, value) {
-    const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? this.slotOwnerService.takeChangedColumnNames(channelSlot) : void 0;
-      if (this.entityWriter.patchColumn(entitySlot, columnName, value, changedColumnNames)) {
-        this.dispatchPatchWritten(entitySlot, void 0, changedColumnNames);
-      }
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+  updateEntityColumnAndDispatch(entitySlot, columnName, value) {
+    const changedColumnNames = this.hasChangedColumnReaders(entitySlot) ? this.slotOwnerServiceOf(entitySlot).takeChangedColumnNames(oimGetChannelSlot(entitySlot)) : void 0;
+    if (this.entityWriter.patchColumn(entitySlot, columnName, value, changedColumnNames)) {
+      this.dispatchPatchWritten(entitySlot, void 0, changedColumnNames);
     }
     return entitySlot;
   }
   dispatchPatchWritten(entitySlot, patch, changedColumnNames) {
     this.dispatchColumnsChanged(entitySlot, void 0, changedColumnNames);
-    if (this.updatesEmptinessOnColumnWrite) this.updateEntitySlotEmptiness(entitySlot);
+    if (this.updatesEmptinessOnColumnWriteOf(entitySlot)) this.updateEntitySlotEmptiness(entitySlot);
     this.dispatchContentChangeAndReleaseIfUnheld(entitySlot, patch, changedColumnNames);
   }
   writeSlotToChannelAndReleaseIfUnheld(entitySlot) {
     OIMChannelService.INSTANCE.writeWithoutFlushCheck(oimGetChannelSlot(entitySlot), entitySlot);
-    this.slotOwnerService.releaseWrittenSlotIfUnheld(entitySlot);
+    this.slotOwnerServiceOf(entitySlot).releaseWrittenSlotIfUnheld(entitySlot);
   }
   dispatchContentChangeAndReleaseIfUnheld(entitySlot, patch, changedColumnNames) {
-    const slotOwnerService = this.slotOwnerService;
+    const slotOwnerService = this.slotOwnerServiceOf(entitySlot);
     slotOwnerService.dispatchContentChange(entitySlot, patch, changedColumnNames);
     slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
   }
   releaseSlotContent(entitySlot) {
     const entity = entitySlot.entity;
     if (entity === void 0) return;
-    const channelSlot = oimGetChannelSlot(entitySlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      this.entityWriter.clearEntity(entitySlot);
-      this.dispatchColumnsChanged(entitySlot, entity, void 0);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-  fillSlotContent(entitySlot, entity) {
-    const slotOwnerService = this.slotOwnerService;
-    const landed = this.writeEntityWithoutSubframe(entitySlot, entity, void 0);
-    slotOwnerService.settleEmptiness(entitySlot, this.slotEmptiness.isEmpty(entitySlot));
-    if (landed) slotOwnerService.dispatchContentChange(entitySlot, entity);
-    return landed;
-  }
-  withdrawSlotContent(entitySlot, isAnnounced) {
-    const slotOwnerService = this.slotOwnerService;
-    if (isAnnounced) {
-      this.releaseSlotContent(entitySlot);
-      slotOwnerService.markEmptiness(entitySlot, this.slotEmptiness.isEmpty(entitySlot));
-      slotOwnerService.dispatchContentChange(entitySlot);
-    }
-    slotOwnerService.releaseSlotIfUnheld(entitySlot);
-  }
-  clearSlotContent(entitySlot) {
-    const slotOwnerService = this.slotOwnerService;
-    const channelSlot = oimGetChannelSlot(entitySlot);
-    if (!this.isOnFastPath(entitySlot)) {
-      OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-      try {
-        this.releaseSlotContent(entitySlot);
-        slotOwnerService.settleEmptiness(entitySlot, this.slotEmptiness.isEmpty(entitySlot));
-        slotOwnerService.dispatchContentChange(entitySlot);
-        slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
-      } finally {
-        OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-      }
-      return;
-    }
-    if (entitySlot.entity !== void 0) {
-      this.entityWriter.clearEntity(entitySlot);
-      OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
-      slotOwnerService.markEmptiness(entitySlot, this.slotEmptiness.isEmpty(entitySlot));
-    }
-    slotOwnerService.releaseSlotIfUnheld(entitySlot);
+    this.slotOwnerServiceOf(entitySlot).assertWritable(entitySlot);
+    this.entityWriter.clearEntity(entitySlot);
+    this.dispatchColumnsChanged(entitySlot, entity, void 0);
   }
   isOnFastPath(entitySlot) {
-    return !this.updatesEmptinessOnColumnWrite && !this.hasChangedColumnReaders(entitySlot);
+    return !this.updatesEmptinessOnColumnWriteOf(entitySlot) && !this.hasChangedColumnReaders(entitySlot);
   }
   hasChangedColumnReaders(entitySlot) {
-    return entitySlot.columnSlotStore !== void 0 || this.slotOwnerService.hasContentChangeListeners(entitySlot);
+    return entitySlot.columnSlotStore !== void 0 || this.slotOwnerServiceOf(entitySlot).hasContentChangeListeners(entitySlot);
   }
   updateEntitySlotEmptiness(entitySlot) {
-    this.slotOwnerService.settleEmptiness(entitySlot, this.slotEmptiness.isEmpty(entitySlot));
+    this.slotOwnerServiceOf(entitySlot).settleEmptiness(entitySlot, this.slotEmptinessPolicy.isEmpty(entitySlot));
   }
-  writeEntityWithoutSubframe(entitySlot, entity, changedColumnNames) {
+  writeEntityToSlot(entitySlot, entity, changedColumnNames) {
     if (entitySlot.entity === void 0) {
       this.entityWriter.fillEntity(entitySlot, entity);
       this.dispatchColumnsChanged(entitySlot, entitySlot.entity, void 0);
@@ -2500,7 +2259,7 @@ var OIMSlotContentEntityService = class {
   dispatchColumnsChanged(entitySlot, entity, changedColumnNames) {
     const channelSlot = oimGetChannelSlot(entitySlot);
     if (entitySlot.columnSlotStore !== void 0 && (entity !== void 0 || changedColumnNames !== void 0)) {
-      this.slotOwnerService.columnOwner.markColumnsChanged(entitySlot, entity, changedColumnNames, channelSlot);
+      this.slotOwnerServiceOf(entitySlot).columnSlotOwner.markColumnsChanged(entitySlot, entity, changedColumnNames, channelSlot);
     }
     OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, entitySlot);
   }
@@ -2531,33 +2290,52 @@ var OIMDefaultValue = class {
 };
 
 // src/factories/defaults/OIM_DEFAULT_STORE_SLOT_LISTENER.ts
-var OIM_DEFAULT_STORE_SLOT_LISTENER = /* @__PURE__ */ new OIMDefaultValue("STORE_SLOT_LISTENER", () => OIMStoreSlotListenerNone.INSTANCE);
+var OIM_DEFAULT_STORE_SLOT_LISTENER = /* @__PURE__ */ new OIMDefaultValue("STORE_SLOT_LISTENER", () => OIMNoStoreSlotListener.INSTANCE);
 
-// src/factories/createOIMSlotCollectionService.ts
-function createOIMSlotCollectionService(options) {
-  const slotContentService = options.slotContentService;
-  return new OIMSlotCollectionService({
-    slotOwnerService: slotContentService.slotOwner,
-    slotStoreService: slotContentService.slotStoreService,
-    slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
-  });
-}
+// src/engine/store/OIMSlotMapStoreService.ts
+var _OIMSlotMapStoreService = class _OIMSlotMapStoreService {
+  createStore() {
+    return /* @__PURE__ */ new Map();
+  }
+  ownKey(key) {
+    return key;
+  }
+  isSameKey(key, otherKey) {
+    return oimSameValueZeroGuard(key, otherKey);
+  }
+  get(store, key) {
+    return store.get(key);
+  }
+  set(store, key, slot) {
+    store.set(key, slot);
+  }
+  remove(store, key) {
+    store.delete(key);
+  }
+  fileSlot(store, slot) {
+    store.set(slot.key, slot);
+  }
+  unfileSlot(store, slot) {
+    store.delete(slot.key);
+  }
+  getSlots(store) {
+    return store.values();
+  }
+  getSlotCount(store) {
+    return store.size;
+  }
+};
+_OIMSlotMapStoreService.INSTANCE = new _OIMSlotMapStoreService();
+var OIMSlotMapStoreService = _OIMSlotMapStoreService;
 
-// src/factories/createOIMSingleSlotService.ts
-function createOIMSingleSlotService(options) {
-  const slotContentService = options.slotContentService;
-  return new OIMSingleSlotService({
-    slotOwnerService: slotContentService.slotOwner,
-    slotStoreService: slotContentService.slotStoreService,
-    slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
-  });
+// src/factories/utils/oimSlotStoreServiceWithDefault.ts
+function oimSlotStoreServiceWithDefault(slotStoreService) {
+  return slotStoreService ?? OIMSlotMapStoreService.INSTANCE;
 }
 
-// src/engine/column/OIMColumnOwnerPushDriven.ts
+// src/engine/column/OIMPushColumnSlotOwner.ts
 var hasValueColumn = (value, columnName) => Object.prototype.hasOwnProperty.call(value, columnName) && value[columnName] !== void 0;
-var OIMColumnOwnerPushDriven = class extends OIMColumnOwner {
+var OIMPushColumnSlotOwner = class extends OIMColumnSlotOwner {
   constructor(options) {
     super(oimColumnSlotStoreServiceOfColumnOwnerOptions(options));
   }
@@ -2642,44 +2420,87 @@ var OIMColumnOwnerPushDriven = class extends OIMColumnOwner {
   }
 };
 
-// src/engine/column/utils/createOIMColumnOwnerPushDriven.ts
-var createOIMColumnOwnerPushDriven = (columnOwnerOptions) => new OIMColumnOwnerPushDriven(columnOwnerOptions);
+// src/engine/column/utils/createOIMPushColumnSlotOwner.ts
+var createOIMPushColumnSlotOwner = (columnSlotOwnerOptions) => new OIMPushColumnSlotOwner(columnSlotOwnerOptions);
+
+// src/factories/defaults/OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.ts
+var OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue("COLUMN_SLOT_STORE_SERVICE", () => OIMSlotMapStoreService.INSTANCE);
+
+// src/engine/column/utils/oimColumnOwnerOptions.ts
+function oimColumnOwnerOptions(columnSlotOwnerOptions) {
+  return columnSlotOwnerOptions.columnNames !== void 0 ? { columnNames: columnSlotOwnerOptions.columnNames } : { columnSlotStoreService: columnSlotOwnerOptions.columnSlotStoreService };
+}
+
+// src/factories/utils/oimColumnOwnerOptionsWithDefault.ts
+function oimColumnOwnerOptionsWithDefault(columnSlotStoreService, columnNames, defaultColumnSlotStoreService) {
+  return oimColumnOwnerOptions({ columnNames, columnSlotStoreService: columnSlotStoreService ?? defaultColumnSlotStoreService });
+}
+
+// src/factories/utils/oimSlotOwnerOptionsWithDefault.ts
+function oimSlotOwnerOptionsWithDefault(db, options) {
+  return {
+    slotStamp: db.slotStamp,
+    slotReleasePolicy: options.slotReleasePolicy ?? db.slotReleasePolicy,
+    slotSubscriptionListener: options.slotSubscriptionListener,
+    columnSlotOwnerOptions: oimColumnOwnerOptionsWithDefault(
+      options.columnSlotStoreService,
+      options.columnNames,
+      OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.getValue()
+    ),
+    createColumnSlotOwner: createOIMPushColumnSlotOwner
+  };
+}
+
+// src/factories/createOIMSlotCollectionService.ts
+function createOIMSlotCollectionService(db, options) {
+  return new OIMWritableSlotCollectionService({
+    ...oimSlotOwnerOptionsWithDefault(db, options),
+    slotStoreService: oimSlotStoreServiceWithDefault(options.slotStoreService),
+    slotContentService: options.slotContentService,
+    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+  });
+}
+
+// src/engine/slot/constants/OIM_FROZEN_EMPTY_SLOTS.ts
+var OIM_FROZEN_EMPTY_SLOTS = Object.freeze([]);
 
-// src/engine/store/OIMSlotStoreServiceMapDriven.ts
-var _OIMSlotStoreServiceMapDriven = class _OIMSlotStoreServiceMapDriven {
+// src/engine/store/OIMSingleSlotStoreService.ts
+var _OIMSingleSlotStoreService = class _OIMSingleSlotStoreService {
   createStore() {
-    return /* @__PURE__ */ new Map();
-  }
-  ownKey(key) {
-    return key;
-  }
-  isSameKey(key, otherKey) {
-    return oimSameValueZeroGuard(key, otherKey);
+    return { slot: void 0 };
   }
-  get(store, key) {
-    return store.get(key);
+  getSingleSlot(store) {
+    return store.slot;
   }
-  set(store, key, slot) {
-    store.set(key, slot);
+  fileSlot(store, slot) {
+    store.slot = slot;
   }
-  remove(store, key) {
-    store.delete(key);
+  unfileSlot(store) {
+    store.slot = void 0;
   }
   getSlots(store) {
-    return store.values();
+    const slot = store.slot;
+    return slot === void 0 ? OIM_FROZEN_EMPTY_SLOTS.values() : [slot].values();
   }
   getSlotCount(store) {
-    return store.size;
+    return store.slot === void 0 ? 0 : 1;
   }
 };
-_OIMSlotStoreServiceMapDriven.INSTANCE = new _OIMSlotStoreServiceMapDriven();
-var OIMSlotStoreServiceMapDriven = _OIMSlotStoreServiceMapDriven;
+_OIMSingleSlotStoreService.INSTANCE = new _OIMSingleSlotStoreService();
+var OIMSingleSlotStoreService = _OIMSingleSlotStoreService;
 
-// src/factories/defaults/OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.ts
-var OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue("COLUMN_SLOT_STORE_SERVICE", () => OIMSlotStoreServiceMapDriven.INSTANCE);
+// src/factories/createOIMSingleSlotService.ts
+function createOIMSingleSlotService(db, options) {
+  return new OIMWritableSingleSlotService({
+    ...oimSlotOwnerOptionsWithDefault(db, options),
+    slotStoreService: OIMSingleSlotStoreService.INSTANCE,
+    slotContentService: options.slotContentService,
+    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+  });
+}
 
 // src/factories/defaults/OIM_DEFAULT_ENTITY_SLOT_EMPTINESS.ts
-var OIM_DEFAULT_ENTITY_SLOT_EMPTINESS = /* @__PURE__ */ new OIMDefaultValue("ENTITY_SLOT_EMPTINESS", () => OIMSlotEmptinessByEntityPresence.INSTANCE);
+var OIM_DEFAULT_ENTITY_SLOT_EMPTINESS = /* @__PURE__ */ new OIMDefaultValue("ENTITY_SLOT_EMPTINESS", () => OIMSlotEntityPresenceEmptinessPolicy.INSTANCE);
 
 // src/engine/entity/utils/oimClearEntity.ts
 function oimClearEntity(entitySlot) {
@@ -2765,7 +2586,7 @@ function oimPutEntityColumns(slot, entity, sameValueGuard, changedColumnNames, t
 function oimEntityWriterOptionsWithDefault(options) {
   return {
     sameValueGuard: options?.sameValueGuard ?? oimSameValueZeroGuard,
-    entityInsertStrategy: options?.entityInsertStrategy ?? oimInsertEntityWithoutCopy,
+    entityInserter: options?.entityInserter ?? oimInsertEntityWithoutCopy,
     putEntityColumns: options?.putEntityColumns ?? oimPutEntityColumns,
     patchEntityColumns: options?.patchEntityColumns ?? oimPatchEntityColumns,
     patchEntityColumn: options?.patchEntityColumn ?? oimPatchEntityColumn
@@ -2784,13 +2605,13 @@ function deleteColumnsInPlace(slot, names) {
 function createOIMEntityWriterInPlace(options) {
   const {
     sameValueGuard,
-    entityInsertStrategy,
+    entityInserter,
     putEntityColumns,
     patchEntityColumns,
     patchEntityColumn
   } = oimEntityWriterOptionsWithDefault(options);
   return {
-    fillEntity: entityInsertStrategy,
+    fillEntity: entityInserter,
     clearEntity: oimClearEntity,
     putEntity: (slot, entity, changedColumnNames) => putEntityColumns(slot, entity, sameValueGuard, changedColumnNames, theEntityItself) !== void 0,
     patchEntity: (slot, patch, changedColumnNames) => patchEntityColumns(slot, patch, sameValueGuard, changedColumnNames, theEntityItself) !== void 0,
@@ -2802,96 +2623,42 @@ function createOIMEntityWriterInPlace(options) {
 // src/factories/defaults/OIM_DEFAULT_ENTITY_WRITER.ts
 var OIM_DEFAULT_ENTITY_WRITER = /* @__PURE__ */ new OIMDefaultValue("ENTITY_WRITER", () => createOIMEntityWriterInPlace());
 
-// src/engine/column/utils/oimColumnOwnerOptions.ts
-function oimColumnOwnerOptions(columnOwnerOptions) {
-  return columnOwnerOptions.columnNames !== void 0 ? { columnNames: columnOwnerOptions.columnNames } : { columnSlotStoreService: columnOwnerOptions.columnSlotStoreService };
-}
-
-// src/factories/utils/oimColumnOwnerOptionsWithDefault.ts
-function oimColumnOwnerOptionsWithDefault(columnSlotStoreService, columnNames, defaultColumnSlotStoreService) {
-  return oimColumnOwnerOptions({ columnNames, columnSlotStoreService: columnSlotStoreService ?? defaultColumnSlotStoreService });
-}
-
-// src/factories/utils/oimSlotStoreServiceWithDefault.ts
-function oimSlotStoreServiceWithDefault(slotStoreService) {
-  return slotStoreService ?? OIMSlotStoreServiceMapDriven.INSTANCE;
-}
-
 // src/factories/createOIMSlotContentEntityService.ts
-var keyOfNothing = () => void 0;
-function createOIMSlotContentEntityService(db, options) {
+function createOIMSlotContentEntityService(db, options = {}) {
   return new OIMSlotContentEntityService({
-    keyOf: options.keyOf ?? keyOfNothing,
     entityWriter: options.entityWriter ?? db.entityWriter ?? OIM_DEFAULT_ENTITY_WRITER.getValue(),
-    slotEmptiness: options.slotEmptiness ?? OIM_DEFAULT_ENTITY_SLOT_EMPTINESS.getValue(),
-    slotStoreService: oimSlotStoreServiceWithDefault(options.slotStoreService),
-    slotStamp: db.slotStamp,
-    slotReleasePolicy: options.slotReleasePolicy ?? db.slotReleasePolicy,
-    columnOwnerOptions: oimColumnOwnerOptionsWithDefault(
-      options.columnSlotStoreService,
-      options.columnNames,
-      OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.getValue()
-    ),
-    createColumnOwner: createOIMColumnOwnerPushDriven
-  });
-}
-
-// src/factories/createOIMEntityService.ts
-function createOIMEntityService(db, options) {
-  return createOIMSlotCollectionService({
-    slotContentService: createOIMSlotContentEntityService(db, {
-      ...options,
-      slotStoreService: oimSlotStoreServiceWithDefault(options.entitySlotStoreService)
-    })
+    slotEmptinessPolicy: options.slotEmptinessPolicy ?? OIM_DEFAULT_ENTITY_SLOT_EMPTINESS.getValue()
   });
 }
 
-// src/engine/slot/constants/OIM_FROZEN_EMPTY_SLOTS.ts
-var OIM_FROZEN_EMPTY_SLOTS = Object.freeze([]);
-
-// src/engine/store/OIMSlotStoreServiceSingleSlotDriven.ts
-var _OIMSlotStoreServiceSingleSlotDriven = class _OIMSlotStoreServiceSingleSlotDriven {
-  createStore() {
-    return { slot: void 0 };
-  }
-  ownKey(key) {
-    return key;
-  }
-  isSameKey() {
-    return true;
-  }
-  get(store) {
-    return store.slot;
-  }
-  set(store, _key, slot) {
-    store.slot = slot;
-  }
-  remove(store) {
-    store.slot = void 0;
-  }
-  getSlots(store) {
-    const slot = store.slot;
-    return slot === void 0 ? OIM_FROZEN_EMPTY_SLOTS.values() : [slot].values();
-  }
-  getSlotCount(store) {
-    return store.slot === void 0 ? 0 : 1;
-  }
-};
-_OIMSlotStoreServiceSingleSlotDriven.INSTANCE = new _OIMSlotStoreServiceSingleSlotDriven();
-var OIMSlotStoreServiceSingleSlotDriven = _OIMSlotStoreServiceSingleSlotDriven;
-
-// src/factories/createOIMSingleEntityService.ts
-function createOIMSingleEntityService(db, options = {}) {
-  return createOIMSingleSlotService({
-    slotContentService: createOIMSlotContentEntityService(db, {
-      ...options,
-      slotStoreService: OIMSlotStoreServiceSingleSlotDriven.INSTANCE
-    })
-  });
+// src/engine/bucket/utils/createOIMSingleBucketSlot.ts
+function createOIMSingleBucketSlot(owner, bucketSlotsStore, storeSlot) {
+  const singleBucketSlot = {
+    effects: void 0,
+    changedAtRevision: 0,
+    changedAtEpoch: 0,
+    effectEdges: void 0,
+    holdCount: 0,
+    releaseDueAfterWriteMs: -1,
+    releaseDueAfterIdleMs: -1,
+    releaseDueAfterUnholdMs: -1,
+    slotFlags: OIM_SLOT_FLAG_EMPTY,
+    columnSlotStore: void 0,
+    storeSlot,
+    owner,
+    key: void 0,
+    indexKeys: void 0,
+    bucketSlotsStore,
+    commands: void 0,
+    isWholeListRecorded: false,
+    commandsStartedAtRevision: 0,
+    commandsStartedAtEpoch: 0
+  };
+  return singleBucketSlot;
 }
 
-// src/engine/bucket/commands/OIMBucketCommandsNone.ts
-var _OIMBucketCommandsNone = class _OIMBucketCommandsNone {
+// src/engine/bucket/commands/OIMNoBucketCommands.ts
+var _OIMNoBucketCommands = class _OIMNoBucketCommands {
   recordInsert() {
     return;
   }
@@ -2905,8 +2672,8 @@ var _OIMBucketCommandsNone = class _OIMBucketCommandsNone {
     return;
   }
 };
-_OIMBucketCommandsNone.INSTANCE = new _OIMBucketCommandsNone();
-var OIMBucketCommandsNone = _OIMBucketCommandsNone;
+_OIMNoBucketCommands.INSTANCE = new _OIMNoBucketCommands();
+var OIMNoBucketCommands = _OIMNoBucketCommands;
 
 // src/engine/bucket/constants/OIM_NOTHING_WAS_REMOVED.ts
 var OIM_NOTHING_WAS_REMOVED = -1;
@@ -2935,44 +2702,43 @@ function createOIMBucketSlot(key, owner, bucketSlotsStore, storeSlot) {
     commands: void 0,
     isWholeListRecorded: false,
     commandsStartedAtRevision: 0,
-    commandsStartedAtEpoch: 0,
-    wasEmptyBeforeChange: void 0,
-    isChangedAgainInSubframe: false
+    commandsStartedAtEpoch: 0
   };
 }
 
+// src/engine/channel/utils/oimGetChannelQueueAtDepth.ts
+function oimGetChannelQueueAtDepth(channelQueues, depth) {
+  const found = channelQueues[depth];
+  if (found !== void 0) return found;
+  const made = new OIMChannelQueue();
+  channelQueues[depth] = made;
+  return made;
+}
+
 // src/facade/bucket/OIMSlotContentBucketService.ts
 var OIMSlotContentBucketService = class {
   constructor(options) {
-    this.bucketCommands = options.bucketCommands ?? OIMBucketCommandsNone.INSTANCE;
-    this.slotContentStrategy = {
-      createSlot: (key, storeSlot, slotOwnerService) => this.createSlot(key, storeSlot, slotOwnerService),
-      isSlotEmpty: (bucketSlot) => this.isSlotEmpty(bucketSlot),
-      hasReference: (bucketSlot) => this.hasReference(bucketSlot),
-      releaseSlotContent: (bucketSlot, slotOwnerService) => {
-        this.releaseSlotContent(bucketSlot, slotOwnerService);
-      },
-      onSubframeClosed: (storeSlot, slotOwnerService) => {
-        this.onSubframeClosed(storeSlot, slotOwnerService);
-      }
-    };
-  }
-  createSlotOwnerService(slotOwnerServiceOptions) {
-    return new OIMSlotOwnerService({
-      ...slotOwnerServiceOptions,
-      slotContentStrategy: this.slotContentStrategy,
-      slotContentFlushStrategy: this.slotContentStrategy
-    });
+    this.bucketCommands = options.bucketCommands ?? OIMNoBucketCommands.INSTANCE;
   }
-  createSlot(key, storeSlot, slotOwnerService) {
-    if (storeSlot === void 0) {
-      throw new Error(
-        "OIMSlotContentBucketService: a bucket is minted into a store slot and none was given. Mint it through its collection or single service."
-      );
+  getBucketMemberSlotsMissingFrom(bucketSlot, bucketMemberSlots) {
+    const givenBucketMemberSlots = new Set(bucketMemberSlots);
+    const missingBucketMemberSlots = [];
+    for (const bucketMemberSlot of this.getBucketMemberSlots(bucketSlot)) {
+      if (!givenBucketMemberSlots.has(bucketMemberSlot)) missingBucketMemberSlots.push(bucketMemberSlot);
     }
+    return missingBucketMemberSlots;
+  }
+  createSlot(key, storeSlot, slotOwner) {
     return createOIMBucketSlot(
       key,
-      slotOwnerService,
+      slotOwner,
+      this.createBucketMemberSlotsStore(),
+      storeSlot
+    );
+  }
+  createSingleSlot(storeSlot, slotOwner) {
+    return createOIMSingleBucketSlot(
+      slotOwner,
       this.createBucketMemberSlotsStore(),
       storeSlot
     );
@@ -2980,43 +2746,15 @@ var OIMSlotContentBucketService = class {
   isSlotEmpty(bucketSlot) {
     return this.getBucketMemberSlotCount(bucketSlot) === 0;
   }
-  hasReference(bucketSlot) {
-    return bucketSlot.wasEmptyBeforeChange !== void 0;
+  hasReference() {
+    return false;
   }
   releaseSlotContent(bucketSlot, slotOwnerService) {
-    if (this.unholdAllBucketMemberSlots(bucketSlot) === 0) return;
+    if (this.getBucketMemberSlotCount(bucketSlot) === 0) return;
+    slotOwnerService.assertWritable(bucketSlot);
+    this.unholdAllBucketMemberSlots(bucketSlot);
     slotOwnerService.dispatchContentChange(bucketSlot);
   }
-  onSubframeClosed(storeSlot, slotOwnerService) {
-    const changedBucketSlotChannelQueue = storeSlot.changedBucketSlotChannelQueue;
-    if (changedBucketSlotChannelQueue === void 0) return;
-    let isRefused = false;
-    let refusal;
-    try {
-      for (let i = 0; i < changedBucketSlotChannelQueue.getEntryCount(); i++) {
-        const bucketSlot = changedBucketSlotChannelQueue.getEntryAt(i);
-        const bucketSlotEditable = bucketSlot;
-        const isChangedAgain = bucketSlot.isChangedAgainInSubframe;
-        bucketSlotEditable.isChangedAgainInSubframe = false;
-        bucketSlotEditable.wasEmptyBeforeChange = void 0;
-        try {
-          if (isChangedAgain && !oimIsSlotReleased(bucketSlot)) this.writeChangedBucketSlot(bucketSlot, false, slotOwnerService);
-        } catch (error) {
-          if (!isRefused) refusal = error;
-          isRefused = true;
-        }
-        try {
-          slotOwnerService.releaseSlotIfUnheld(bucketSlot);
-        } catch (error) {
-          if (!isRefused) refusal = error;
-          isRefused = true;
-        }
-      }
-    } finally {
-      changedBucketSlotChannelQueue.keepFirstEntries(0);
-    }
-    if (isRefused) throw refusal;
-  }
   markContentChanged(bucketSlot) {
     bucketSlot.owner.assertWritable(bucketSlot);
     this.markBucketSlotChanged(bucketSlot);
@@ -3025,105 +2763,82 @@ var OIMSlotContentBucketService = class {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
     if (!slotOwnerService.hasColumnSlots(bucketSlot)) return;
-    slotOwnerService.columnOwner.markColumnsChanged(bucketSlot, patch, changedColumns, oimGetChannelSlot(bucketSlot));
+    slotOwnerService.columnSlotOwner.markColumnsChanged(bucketSlot, patch, changedColumns, oimGetChannelSlot(bucketSlot));
   }
   addBucketMemberSlot(bucketSlot, bucketMemberSlot) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
     this.assertBucketMemberSlotNotReleased(bucketMemberSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      if (this.addBucketMemberSlotWithoutSubframe(bucketSlot, bucketMemberSlot)) this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+    if (this.addBucketMemberSlotUnannounced(bucketSlot, bucketMemberSlot)) this.markBucketSlotChanged(bucketSlot);
   }
   removeBucketMemberSlot(bucketSlot, bucketMemberSlot) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const at = this.removeSlot(bucketSlot, bucketMemberSlot);
-      if (at === OIM_NOTHING_WAS_REMOVED) return;
-      this.letGoOfRemovedBucketMemberSlot(bucketSlot, bucketMemberSlot, at);
-      this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+    const at = this.removeSlot(bucketSlot, bucketMemberSlot);
+    if (at === OIM_NOTHING_WAS_REMOVED) return;
+    this.letGoOfRemovedBucketMemberSlot(bucketSlot, bucketMemberSlot, at);
+    this.markBucketSlotChanged(bucketSlot);
   }
   addBucketMemberSlots(bucketSlot, bucketMemberSlots) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
     this.assertBucketMemberSlotsNotReleased(bucketMemberSlots);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      let isAnyAdded = false;
-      for (let i = 0; i < bucketMemberSlots.length; i++) {
-        if (this.addBucketMemberSlotWithoutSubframe(bucketSlot, bucketMemberSlots[i])) isAnyAdded = true;
-      }
-      if (isAnyAdded) this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+    let isAnyAdded = false;
+    for (let i = 0; i < bucketMemberSlots.length; i++) {
+      if (this.addBucketMemberSlotUnannounced(bucketSlot, bucketMemberSlots[i])) isAnyAdded = true;
     }
+    if (isAnyAdded) this.markBucketSlotChanged(bucketSlot);
   }
   removeBucketMemberSlots(bucketSlot, bucketMemberSlots) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
     const storeSlotEditable = bucketSlot.storeSlot;
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
+    const writeDepth = storeSlotEditable.writeDepth++;
+    const removedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.departedBucketMemberSlotChannelQueues ?? (storeSlotEditable.departedBucketMemberSlotChannelQueues = []), writeDepth);
+    const removedAtChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.removedAtChannelQueues ?? (storeSlotEditable.removedAtChannelQueues = []), writeDepth);
     try {
-      const writeDepth = storeSlotEditable.writeDepth++;
-      const removedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.departedBucketMemberSlotChannelQueues ?? (storeSlotEditable.departedBucketMemberSlotChannelQueues = []), writeDepth);
-      const removedAtChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.removedAtChannelQueues ?? (storeSlotEditable.removedAtChannelQueues = []), writeDepth);
-      try {
-        this.removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue);
-        const removedCount = removedChannelQueue.getEntryCount();
-        for (let i = 0; i < removedCount; i++) {
-          this.letGoOfRemovedBucketMemberSlot(bucketSlot, removedChannelQueue.getEntryAt(i), removedAtChannelQueue.getEntryAt(i));
-        }
-        if (removedCount !== 0) this.markBucketSlotChanged(bucketSlot);
-      } finally {
-        removedChannelQueue.keepFirstEntries(0);
-        removedAtChannelQueue.keepFirstEntries(0);
-        storeSlotEditable.writeDepth = writeDepth;
+      this.removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue);
+      const removedCount = removedChannelQueue.getEntryCount();
+      for (let i = 0; i < removedCount; i++) {
+        this.letGoOfRemovedBucketMemberSlot(bucketSlot, removedChannelQueue.getEntryAt(i), removedAtChannelQueue.getEntryAt(i));
       }
+      if (removedCount !== 0) this.markBucketSlotChanged(bucketSlot);
     } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+      removedChannelQueue.keepFirstEntries(0);
+      removedAtChannelQueue.keepFirstEntries(0);
+      storeSlotEditable.writeDepth = writeDepth;
     }
   }
-  writeBucketMemberSlots(bucketSlot, bucketMemberSlots) {
+  insertSlotContent(bucketSlot, bucketMemberSlots, changedBucketSlots) {
     const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
+    slotOwnerService.fileSlot(bucketSlot);
+    let isWritten;
     try {
-      if (!this.reconcileBucketMemberSlots(bucketSlot, bucketMemberSlots)) return false;
-      this.markBucketSlotChanged(bucketSlot);
-      return true;
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
+      isWritten = this.writeSlotContent(bucketSlot, bucketMemberSlots);
+    } catch (refusal) {
+      slotOwnerService.releaseSlotIfUnheld(bucketSlot);
+      throw refusal;
     }
+    if (!isWritten) slotOwnerService.releaseSlotIfUnheld(bucketSlot);
+    else if (changedBucketSlots !== void 0) changedBucketSlots.push(bucketSlot);
   }
-  clearBucketMemberSlots(bucketSlot) {
+  writeSlotContent(bucketSlot, bucketMemberSlots) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      if (this.drainBucketMemberSlots(bucketSlot)) this.markBucketSlotChanged(bucketSlot);
-      else slotOwnerService.releaseSlotIfUnheld(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
+    if (!this.reconcileBucketMemberSlots(bucketSlot, bucketMemberSlots)) return false;
+    this.markBucketSlotChanged(bucketSlot);
+    return true;
+  }
+  clearSlotContent(bucketSlot) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    if (this.drainBucketMemberSlots(bucketSlot)) this.markBucketSlotChanged(bucketSlot);
+    else slotOwnerService.releaseSlotIfUnheld(bucketSlot);
   }
   fillBucketMemberSlots(bucketSlot, bucketMemberSlots) {
-    if (bucketSlot.changedAtRevision !== 0 || bucketSlot.wasEmptyBeforeChange !== void 0) {
+    if (bucketSlot.changedAtRevision !== 0) {
       throw new Error(
-        "OIMSlotContentBucketService: fillBucketMemberSlots fills only a bucket nobody was told about yet, and this one was announced. Use addBucketMemberSlots or writeBucketMemberSlots, which tell its listeners."
+        "OIMSlotContentBucketService: fillBucketMemberSlots fills only a bucket nobody was told about yet, and this one was announced. Use addBucketMemberSlots or writeSlotContent, which tell its listeners."
       );
     }
     this.assertBucketMemberSlotsNotReleased(bucketMemberSlots);
@@ -3134,23 +2849,12 @@ var OIMSlotContentBucketService = class {
   }
   markBucketSlotChanged(bucketSlot) {
     const slotOwnerService = bucketSlot.owner;
-    const bucketSlotEditable = bucketSlot;
-    const isFirstChange = bucketSlot.wasEmptyBeforeChange === void 0;
-    if (isFirstChange) bucketSlotEditable.wasEmptyBeforeChange = oimIsSlotEmpty(bucketSlot);
+    const wasEmpty = oimIsSlotEmpty(bucketSlot);
     slotOwnerService.markEmptiness(bucketSlot, this.isSlotEmpty(bucketSlot));
-    if (!OIMChannelService.INSTANCE.isSubframeOpen(oimGetChannelSlot(bucketSlot)) || bucketSlot.holdCount > 0 && !slotOwnerService.hasContentChangeListeners(bucketSlot)) {
-      this.flushChangedBucketSlot(bucketSlot, slotOwnerService);
-      return;
-    }
-    if (!isFirstChange) {
-      bucketSlotEditable.isChangedAgainInSubframe = true;
-      return;
-    }
-    const storeSlot = bucketSlot.storeSlot;
-    const changedBucketSlotChannelQueue = storeSlot.changedBucketSlotChannelQueue ?? (storeSlot.changedBucketSlotChannelQueue = new OIMChannelQueue());
-    if (changedBucketSlotChannelQueue.getEntryCount() === 0) slotOwnerService.listChangedStoreSlot(storeSlot);
-    changedBucketSlotChannelQueue.enqueueEntry(bucketSlot);
-    this.writeChangedBucketSlot(bucketSlot, bucketSlot.wasEmptyBeforeChange === true, slotOwnerService);
+    if (oimIsSlotReleased(bucketSlot)) return;
+    slotOwnerService.writeSlotToChannelAndSettle(bucketSlot, wasEmpty);
+    slotOwnerService.dispatchContentChange(bucketSlot);
+    slotOwnerService.releaseSlotIfUnheldAfterListeners(bucketSlot);
   }
   letGoOfRemovedBucketMemberSlot(bucketSlot, bucketMemberSlot, at) {
     oimUnholdSlotIfAlive(bucketMemberSlot);
@@ -3166,7 +2870,7 @@ var OIMSlotContentBucketService = class {
   assertBucketMemberSlotsNotReleased(bucketMemberSlots) {
     for (let i = 0; i < bucketMemberSlots.length; i++) this.assertBucketMemberSlotNotReleased(bucketMemberSlots[i]);
   }
-  addBucketMemberSlotWithoutSubframe(bucketSlot, bucketMemberSlot) {
+  addBucketMemberSlotUnannounced(bucketSlot, bucketMemberSlot) {
     if (!this.addSlot(bucketSlot, bucketMemberSlot)) return false;
     bucketMemberSlot.owner.holdSlot(bucketMemberSlot);
     const bucketMemberSlotCount = this.getBucketMemberSlotCount(bucketSlot);
@@ -3217,21 +2921,10 @@ var OIMSlotContentBucketService = class {
       storeSlotEditable.writeDepth = writeDepth;
     }
   }
-  writeChangedBucketSlot(bucketSlot, wasEmpty, slotOwnerService) {
-    slotOwnerService.writeSlotToChannelAndSettle(bucketSlot, wasEmpty);
-    slotOwnerService.dispatchContentChange(bucketSlot);
-  }
-  flushChangedBucketSlot(bucketSlot, slotOwnerService) {
-    const wasEmpty = bucketSlot.wasEmptyBeforeChange;
-    if (wasEmpty === void 0) return;
-    bucketSlot.wasEmptyBeforeChange = void 0;
-    if (oimIsSlotReleased(bucketSlot)) return;
-    this.writeChangedBucketSlot(bucketSlot, wasEmpty, slotOwnerService);
-  }
 };
 
-// src/facade/bucket/OIMSlotContentBucketServiceSetDriven.ts
-var OIMSlotContentBucketServiceSetDriven = class extends OIMSlotContentBucketService {
+// src/facade/bucket/OIMSlotContentSetBucketService.ts
+var OIMSlotContentSetBucketService = class extends OIMSlotContentBucketService {
   constructor(options = {}) {
     super(options);
   }
@@ -3285,35 +2978,53 @@ var OIMSlotContentBucketServiceSetDriven = class extends OIMSlotContentBucketSer
   }
 };
 
-// src/facade/bucket/OIMSlotContentBucketServiceArrayBased.ts
-var OIMSlotContentBucketServiceArrayBased = class extends OIMSlotContentBucketService {
-  constructor(options, bucketArrayMembership) {
-    super(options);
-    this.bucketArrayMembership = bucketArrayMembership;
+// src/engine/bucket/array/OIMBucketMemberSlotsArrayService.ts
+var insertionTailLimit = 8;
+var _OIMBucketMemberSlotsArrayService = class _OIMBucketMemberSlotsArrayService {
+  createBucketSlotsArrayStore() {
+    return { bucketMemberSlots: [], uniqueBucketMemberSlots: void 0, sortedCount: 0 };
   }
-  addSlot(bucketSlot, bucketMemberSlot) {
-    const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-    if (!this.bucketArrayMembership.addSlot(bucketMemberSlotsArrayStore, bucketMemberSlot)) return false;
-    bucketMemberSlotsArrayStore.bucketMemberSlots.push(bucketMemberSlot);
+  hasBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    return bucketSlotsArrayStore.bucketMemberSlots.indexOf(bucketMemberSlot) >= 0;
+  }
+  appendBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    bucketSlotsArrayStore.bucketMemberSlots.push(bucketMemberSlot);
     return true;
   }
-  removeSlot(bucketSlot, bucketMemberSlot) {
-    const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-    if (!this.bucketArrayMembership.removeSlot(bucketMemberSlotsArrayStore, bucketMemberSlot)) return OIM_NOTHING_WAS_REMOVED;
-    const bucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
+  insertBucketMemberSlotAt(bucketSlotsArrayStore, at, bucketMemberSlot) {
+    const bucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    const landing = at < 0 ? 0 : at > bucketMemberSlots.length ? bucketMemberSlots.length : at;
+    bucketMemberSlots.splice(landing, 0, bucketMemberSlot);
+    return landing;
+  }
+  removeBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    const bucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
     const at = bucketMemberSlots.indexOf(bucketMemberSlot);
-    if (at >= 0) bucketMemberSlots.splice(at, 1);
+    if (at < 0) return OIM_NOTHING_WAS_REMOVED;
+    bucketMemberSlots.splice(at, 1);
+    if (at < bucketSlotsArrayStore.sortedCount) bucketSlotsArrayStore.sortedCount--;
     return at;
   }
-  removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue) {
+  removeBucketMemberSlotAt(bucketSlotsArrayStore, at) {
+    if (at < bucketSlotsArrayStore.sortedCount) bucketSlotsArrayStore.sortedCount--;
+    return bucketSlotsArrayStore.bucketMemberSlots.splice(at, 1)[0];
+  }
+  removeBucketMemberSlotRange(bucketSlotsArrayStore, at, count) {
+    const removedBucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots.splice(at, count);
+    const sortedCount = bucketSlotsArrayStore.sortedCount;
+    if (at < sortedCount) bucketSlotsArrayStore.sortedCount = sortedCount - Math.min(removedBucketMemberSlots.length, sortedCount - at);
+    return removedBucketMemberSlots;
+  }
+  removeBucketMemberSlots(bucketSlotsArrayStore, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue) {
     if (bucketMemberSlots.length === 0) return;
-    const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
     const leavingCounts = /* @__PURE__ */ new Map();
     for (let i = 0; i < bucketMemberSlots.length; i++) {
       leavingCounts.set(bucketMemberSlots[i], (leavingCounts.get(bucketMemberSlots[i]) ?? 0) + 1);
     }
-    const heldBucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
+    const heldBucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    const sortedCount = bucketSlotsArrayStore.sortedCount;
     const length = heldBucketMemberSlots.length;
+    let removedFromSortedCount = 0;
     let kept = 0;
     for (let read = 0; read < length; read++) {
       const bucketMemberSlot = heldBucketMemberSlots[read];
@@ -3324,303 +3035,42 @@ var OIMSlotContentBucketServiceArrayBased = class extends OIMSlotContentBucketSe
         continue;
       }
       leavingCounts.set(bucketMemberSlot, leavingCount - 1);
-      this.bucketArrayMembership.removeSlot(bucketMemberSlotsArrayStore, bucketMemberSlot);
+      if (read < sortedCount) removedFromSortedCount++;
       removedChannelQueue.enqueueEntry(bucketMemberSlot);
       removedAtChannelQueue.enqueueEntry(kept);
     }
     if (kept !== length) heldBucketMemberSlots.length = kept;
-  }
-  reconcileSlots(bucketSlot, bucketMemberSlots, arrivedChannelQueue, departedChannelQueue) {
-    const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-    if (this.bucketArrayMembership.containsTheSameSequence(bucketMemberSlotsArrayStore, bucketMemberSlots)) return;
-    arrivedChannelQueue.keepFirstEntries(0);
-    departedChannelQueue.keepFirstEntries(0);
-    const heldBucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-    for (let i = 0; i < heldBucketMemberSlots.length; i++) departedChannelQueue.enqueueEntry(heldBucketMemberSlots[i]);
-    this.emptyBucketMemberSlotsStore(bucketMemberSlotsArrayStore);
-    for (let i = 0; i < bucketMemberSlots.length; i++) {
-      if (this.addSlot(bucketSlot, bucketMemberSlots[i])) arrivedChannelQueue.enqueueEntry(bucketMemberSlots[i]);
-    }
-  }
-  drainSlots(bucketSlot, departedChannelQueue) {
-    const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-    const heldBucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-    for (let i = 0; i < heldBucketMemberSlots.length; i++) departedChannelQueue.enqueueEntry(heldBucketMemberSlots[i]);
-    this.emptyBucketMemberSlotsStore(bucketMemberSlotsArrayStore);
-  }
-  hasBucketMemberSlot(bucketSlot, bucketMemberSlot) {
-    return this.bucketArrayMembership.hasSlot(bucketSlot.bucketSlotsStore, bucketMemberSlot);
-  }
-  getBucketMemberSlotCount(bucketSlot) {
-    return bucketSlot.bucketSlotsStore.bucketMemberSlots.length;
-  }
-  getBucketMemberSlots(bucketSlot) {
-    return bucketSlot.bucketSlotsStore.bucketMemberSlots;
-  }
-  getBucketMemberSlotAt(bucketSlot, at) {
-    return bucketSlot.bucketSlotsStore.bucketMemberSlots[at];
-  }
-  getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot) {
-    return bucketSlot.bucketSlotsStore.bucketMemberSlots.indexOf(bucketMemberSlot);
-  }
-  emptyBucketMemberSlotsStore(bucketMemberSlotsArrayStore) {
-    const bucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-    if (bucketMemberSlots.length !== 0) bucketMemberSlots.length = 0;
-    this.bucketArrayMembership.clearSlots(bucketMemberSlotsArrayStore);
-  }
-};
-
-// src/engine/bucket/array/OIMBucketArrayMembershipNonUnique.ts
-var _OIMBucketArrayMembershipNonUnique = class _OIMBucketArrayMembershipNonUnique {
-  createStore() {
-    return { bucketMemberSlots: [] };
-  }
-  addSlot() {
-    return true;
-  }
-  removeSlot() {
-    return true;
-  }
-  hasSlot(bucketSlotsArrayStore, bucketMemberSlot) {
-    return bucketSlotsArrayStore.bucketMemberSlots.indexOf(bucketMemberSlot) >= 0;
-  }
-  clearSlots() {
-    return;
-  }
-  containsTheSameSequence(bucketSlotsArrayStore, bucketMemberSlots) {
-    return oimSameSlotSequence(bucketSlotsArrayStore.bucketMemberSlots, bucketMemberSlots);
-  }
-};
-_OIMBucketArrayMembershipNonUnique.INSTANCE = new _OIMBucketArrayMembershipNonUnique();
-var OIMBucketArrayMembershipNonUnique = _OIMBucketArrayMembershipNonUnique;
-
-// src/engine/bucket/array/utils/oimAssertWholePosition.ts
-function oimAssertWholePosition(position) {
-  if (position === Math.trunc(position)) return;
-  throw new Error(
-    `OIMSlotContentBucketServiceArrayDriven: a position must be a whole number, got ${position}. A fraction or NaN would be read one way by the list and another by splice.`
-  );
-}
-
-// src/facade/bucket/OIMSlotContentBucketServiceArrayDriven.ts
-var OIMSlotContentBucketServiceArrayDriven = class extends OIMSlotContentBucketServiceArrayBased {
-  constructor(options = {}) {
-    super(
-      options,
-      options.bucketArrayMembership ?? OIMBucketArrayMembershipNonUnique.INSTANCE
-    );
-  }
-  createBucketMemberSlotsStore() {
-    return this.bucketArrayMembership.createStore();
-  }
-  insertBucketMemberSlotAt(bucketSlot, at, bucketMemberSlot) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    oimAssertWholePosition(at);
-    this.assertBucketMemberSlotNotReleased(bucketMemberSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-      if (!this.bucketArrayMembership.addSlot(bucketMemberSlotsArrayStore, bucketMemberSlot)) return;
-      const bucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-      const landing = clampPosition(bucketMemberSlots.length, at);
-      bucketMemberSlots.splice(landing, 0, bucketMemberSlot);
-      bucketMemberSlot.owner.holdSlot(bucketMemberSlot);
-      this.bucketCommands.recordInsert(bucketSlot, landing, bucketMemberSlot, bucketMemberSlots.length);
-      this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-  removeBucketMemberSlotAt(bucketSlot, at) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    oimAssertWholePosition(at);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-      const bucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-      if (at < 0 || at >= bucketMemberSlots.length) return void 0;
-      const removedBucketMemberSlot = bucketMemberSlots[at];
-      bucketMemberSlots.splice(at, 1);
-      this.bucketArrayMembership.removeSlot(bucketMemberSlotsArrayStore, removedBucketMemberSlot);
-      oimUnholdSlotIfAlive(removedBucketMemberSlot);
-      this.bucketCommands.recordRemove(bucketSlot, at, 1, bucketMemberSlots.length);
-      this.markBucketSlotChanged(bucketSlot);
-      return removedBucketMemberSlot;
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-  removeBucketMemberSlotRange(bucketSlot, at, count) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    oimAssertWholePosition(at);
-    oimAssertWholePosition(count);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const bucketMemberSlotsArrayStore = bucketSlot.bucketSlotsStore;
-      const bucketMemberSlots = bucketMemberSlotsArrayStore.bucketMemberSlots;
-      if (at < 0 || count <= 0 || at >= bucketMemberSlots.length) return OIM_FROZEN_EMPTY_SLOTS;
-      const removedBucketMemberSlots = bucketMemberSlots.splice(at, count);
-      for (let i = 0; i < removedBucketMemberSlots.length; i++) {
-        this.bucketArrayMembership.removeSlot(bucketMemberSlotsArrayStore, removedBucketMemberSlots[i]);
-        oimUnholdSlotIfAlive(removedBucketMemberSlots[i]);
+    bucketSlotsArrayStore.sortedCount = sortedCount - removedFromSortedCount;
+  }
+  moveBucketMemberSlotRange(bucketSlotsArrayStore, from, count, landing) {
+    const bucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    const firstTouched = from < landing ? from : landing;
+    const pastTouched = (from > landing ? from : landing) + count;
+    const touched = pastTouched - firstTouched;
+    const leftShift = from < landing ? count : touched - count;
+    if (leftShift === 0 || leftShift === touched) return false;
+    let isChanged = false;
+    for (let at = firstTouched; at < pastTouched; at++) {
+      const after = firstTouched + (at - firstTouched + leftShift) % touched;
+      if (bucketMemberSlots[at] !== bucketMemberSlots[after]) {
+        isChanged = true;
+        break;
       }
-      this.bucketCommands.recordRemove(bucketSlot, at, removedBucketMemberSlots.length, bucketMemberSlots.length);
-      this.markBucketSlotChanged(bucketSlot);
-      return removedBucketMemberSlots;
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-  moveBucketMemberSlotToPosition(bucketSlot, from, to) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    oimAssertWholePosition(from);
-    oimAssertWholePosition(to);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const bucketMemberSlots = bucketSlot.bucketSlotsStore.bucketMemberSlots;
-      if (from < 0 || from >= bucketMemberSlots.length || to < 0 || to >= bucketMemberSlots.length || from === to) return void 0;
-      if (!moveRange(bucketMemberSlots, from, 1, to)) return void 0;
-      this.bucketCommands.recordMove(bucketSlot, from, to, bucketMemberSlots.length);
-      this.markBucketSlotChanged(bucketSlot);
-      return bucketMemberSlots[to];
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-  moveBucketMemberSlotRangeToPosition(bucketSlot, from, count, to) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    oimAssertWholePosition(from);
-    oimAssertWholePosition(count);
-    oimAssertWholePosition(to);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      const bucketMemberSlots = bucketSlot.bucketSlotsStore.bucketMemberSlots;
-      if (from < 0 || count <= 0 || from >= bucketMemberSlots.length) return;
-      const taking = from + count > bucketMemberSlots.length ? bucketMemberSlots.length - from : count;
-      const landing = clampPosition(bucketMemberSlots.length - taking, to);
-      if (!moveRange(bucketMemberSlots, from, taking, landing)) return;
-      this.bucketCommands.recordWholeList(bucketSlot);
-      this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
-    }
-  }
-};
-function clampPosition(length, at) {
-  return at < 0 ? 0 : at > length ? length : at;
-}
-function moveRange(bucketMemberSlots, from, count, landing) {
-  const firstTouched = from < landing ? from : landing;
-  const pastTouched = (from > landing ? from : landing) + count;
-  const touched = pastTouched - firstTouched;
-  const leftShift = from < landing ? count : touched - count;
-  if (leftShift === 0 || leftShift === touched) return false;
-  let changes = false;
-  for (let at = firstTouched; at < pastTouched; at++) {
-    const after = firstTouched + (at - firstTouched + leftShift) % touched;
-    if (bucketMemberSlots[at] !== bucketMemberSlots[after]) {
-      changes = true;
-      break;
-    }
-  }
-  if (!changes) return false;
-  reverse(bucketMemberSlots, firstTouched, firstTouched + leftShift - 1);
-  reverse(bucketMemberSlots, firstTouched + leftShift, pastTouched - 1);
-  reverse(bucketMemberSlots, firstTouched, pastTouched - 1);
-  return true;
-}
-function reverse(bucketMemberSlots, first, last) {
-  for (let low = first, high = last; low < high; low++, high--) {
-    const bucketMemberSlot = bucketMemberSlots[low];
-    bucketMemberSlots[low] = bucketMemberSlots[high];
-    bucketMemberSlots[high] = bucketMemberSlot;
-  }
-}
-
-// src/facade/bucket/OIMSlotContentBucketServiceSortedArrayDriven.ts
-var insertionTailLimit = 8;
-var OIMSlotContentBucketServiceSortedArrayDriven = class extends OIMSlotContentBucketServiceArrayBased {
-  constructor(options) {
-    super({}, OIMBucketArrayMembershipNonUnique.INSTANCE);
-    this.compareBucketMemberSlots = options.compareBucketMemberSlots;
-  }
-  createBucketMemberSlotsStore() {
-    return { bucketMemberSlots: [], sortedCount: 0 };
-  }
-  removeSlot(bucketSlot, bucketMemberSlot) {
-    const at = super.removeSlot(bucketSlot, bucketMemberSlot);
-    if (at === OIM_NOTHING_WAS_REMOVED) return OIM_NOTHING_WAS_REMOVED;
-    const bucketMemberSlotsSortedArrayStore = bucketSlot.bucketSlotsStore;
-    if (at < bucketMemberSlotsSortedArrayStore.sortedCount) bucketMemberSlotsSortedArrayStore.sortedCount--;
-    return at;
-  }
-  removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue) {
-    const bucketMemberSlotsSortedArrayStore = bucketSlot.bucketSlotsStore;
-    const sortedCount = bucketMemberSlotsSortedArrayStore.sortedCount;
-    const removedCountBefore = removedChannelQueue.getEntryCount();
-    const removedAtCountBefore = removedAtChannelQueue.getEntryCount();
-    super.removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue);
-    const removedCount = removedChannelQueue.getEntryCount() - removedCountBefore;
-    let removedFromSortedCount = 0;
-    for (let i = 0; i < removedCount; i++) {
-      if (removedAtChannelQueue.getEntryAt(removedAtCountBefore + i) + i >= sortedCount) break;
-      removedFromSortedCount++;
-    }
-    bucketMemberSlotsSortedArrayStore.sortedCount = sortedCount - removedFromSortedCount;
-  }
-  reconcileSlots(bucketSlot, bucketMemberSlots, arrivedChannelQueue, departedChannelQueue) {
-    super.reconcileSlots(bucketSlot, bucketMemberSlots, arrivedChannelQueue, departedChannelQueue);
-    bucketSlot.bucketSlotsStore.sortedCount = 0;
-  }
-  drainSlots(bucketSlot, departedChannelQueue) {
-    const bucketMemberSlotsSortedArrayStore = bucketSlot.bucketSlotsStore;
-    this.settle(bucketMemberSlotsSortedArrayStore);
-    super.drainSlots(bucketSlot, departedChannelQueue);
-    bucketMemberSlotsSortedArrayStore.sortedCount = 0;
-  }
-  getBucketMemberSlots(bucketSlot) {
-    this.settle(bucketSlot.bucketSlotsStore);
-    return super.getBucketMemberSlots(bucketSlot);
-  }
-  getBucketMemberSlotAt(bucketSlot, at) {
-    this.settle(bucketSlot.bucketSlotsStore);
-    return super.getBucketMemberSlotAt(bucketSlot, at);
-  }
-  getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot) {
-    this.settle(bucketSlot.bucketSlotsStore);
-    return super.getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot);
-  }
-  repositionBucketMemberSlot(bucketSlot, bucketMemberSlot) {
-    const slotOwnerService = bucketSlot.owner;
-    slotOwnerService.assertWritable(bucketSlot);
-    const channelSlot = oimGetChannelSlot(bucketSlot);
-    OIMContentChangeDeliveryService.INSTANCE.openContentSubframe(channelSlot);
-    try {
-      if (this.removeSlot(bucketSlot, bucketMemberSlot) === OIM_NOTHING_WAS_REMOVED) return;
-      if (this.addSlot(bucketSlot, bucketMemberSlot)) this.markBucketSlotChanged(bucketSlot);
-    } finally {
-      OIMContentChangeDeliveryService.INSTANCE.closeContentSubframe(channelSlot);
     }
+    if (!isChanged) return false;
+    reverseRange(bucketMemberSlots, firstTouched, firstTouched + leftShift - 1);
+    reverseRange(bucketMemberSlots, firstTouched + leftShift, pastTouched - 1);
+    reverseRange(bucketMemberSlots, firstTouched, pastTouched - 1);
+    return true;
   }
-  settle(bucketMemberSlotsSortedArrayStore) {
-    const bucketMemberSlots = bucketMemberSlotsSortedArrayStore.bucketMemberSlots;
+  sortBucketMemberSlots(bucketSlotsArrayStore, compareBucketMemberSlots) {
+    const bucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
     const length = bucketMemberSlots.length;
-    const sortedCount = bucketMemberSlotsSortedArrayStore.sortedCount;
+    const sortedCount = bucketSlotsArrayStore.sortedCount;
     if (length === sortedCount) return;
-    const compareBucketMemberSlots = this.compareBucketMemberSlots;
     if (length - sortedCount > insertionTailLimit) {
       bucketMemberSlots.sort(compareBucketMemberSlots);
-      bucketMemberSlotsSortedArrayStore.sortedCount = length;
+      bucketSlotsArrayStore.sortedCount = length;
       return;
     }
     for (let at = sortedCount; at < length; at++) {
@@ -3636,164 +3086,277 @@ var OIMSlotContentBucketServiceSortedArrayDriven = class extends OIMSlotContentB
       bucketMemberSlots.splice(at, 1);
       bucketMemberSlots.splice(low, 0, bucketMemberSlot);
     }
-    bucketMemberSlotsSortedArrayStore.sortedCount = length;
+    bucketSlotsArrayStore.sortedCount = length;
+  }
+  isSameBucketMemberSlotSequence(bucketSlotsArrayStore, bucketMemberSlots) {
+    return oimSameSlotSequence(bucketSlotsArrayStore.bucketMemberSlots, bucketMemberSlots);
+  }
+  clearBucketMemberSlots(bucketSlotsArrayStore) {
+    const bucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    if (bucketMemberSlots.length !== 0) bucketMemberSlots.length = 0;
+    bucketSlotsArrayStore.sortedCount = 0;
   }
 };
+_OIMBucketMemberSlotsArrayService.INSTANCE = new _OIMBucketMemberSlotsArrayService();
+var OIMBucketMemberSlotsArrayService = _OIMBucketMemberSlotsArrayService;
+function reverseRange(bucketMemberSlots, first, last) {
+  for (let low = first, high = last; low < high; low++, high--) {
+    const bucketMemberSlot = bucketMemberSlots[low];
+    bucketMemberSlots[low] = bucketMemberSlots[high];
+    bucketMemberSlots[high] = bucketMemberSlot;
+  }
+}
 
-// src/engine/bucket/commands/constants/OIM_MAX_COMMANDS_PER_SLOT.ts
-var OIM_MAX_COMMANDS_PER_SLOT = 1;
-
-// src/facade/bucket/OIMBucketCommands.ts
-var OIMBucketCommands = class {
+// src/facade/bucket/OIMSlotContentArrayBucketService.ts
+var OIMSlotContentArrayBucketService = class extends OIMSlotContentBucketService {
   constructor(options) {
-    this.maxCommandsPerSlot = options.maxCommandsPerSlot ?? OIM_MAX_COMMANDS_PER_SLOT;
+    super(options);
+    this.bucketMemberSlotsArrayService = options.bucketMemberSlotsArrayService ?? OIMBucketMemberSlotsArrayService.INSTANCE;
   }
-  recordInsert(bucketSlot, index, bucketMemberSlot, bucketMemberSlotCount) {
-    this.recordCommand(bucketSlot, { type: "insert", index, slot: bucketMemberSlot }, bucketMemberSlotCount);
+  createBucketMemberSlotsStore() {
+    return this.bucketMemberSlotsArrayService.createBucketSlotsArrayStore();
   }
-  recordRemove(bucketSlot, index, count, bucketMemberSlotCount) {
-    for (let i = 0; i < count; i++) this.recordCommand(bucketSlot, { type: "remove", index }, bucketMemberSlotCount);
+  addSlot(bucketSlot, bucketMemberSlot) {
+    return this.bucketMemberSlotsArrayService.appendBucketMemberSlot(bucketSlot.bucketSlotsStore, bucketMemberSlot);
   }
-  recordMove(bucketSlot, from, to, bucketMemberSlotCount) {
-    this.recordCommand(bucketSlot, { type: "move", from, to }, bucketMemberSlotCount);
+  removeSlot(bucketSlot, bucketMemberSlot) {
+    return this.bucketMemberSlotsArrayService.removeBucketMemberSlot(bucketSlot.bucketSlotsStore, bucketMemberSlot);
   }
-  recordWholeList(bucketSlot) {
-    const bucketSlotEditable = enlistInFlush(bucketSlot);
-    const commands = bucketSlotEditable.commands;
-    if (commands !== void 0 && commands.length !== 0) commands.length = 0;
-    bucketSlotEditable.isWholeListRecorded = true;
+  removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue) {
+    this.bucketMemberSlotsArrayService.removeBucketMemberSlots(
+      bucketSlot.bucketSlotsStore,
+      bucketMemberSlots,
+      removedChannelQueue,
+      removedAtChannelQueue
+    );
   }
-  recordCommand(bucketSlot, orderedListCommand, bucketMemberSlotCount) {
-    const bucketSlotEditable = enlistInFlush(bucketSlot);
-    if (bucketSlotEditable.isWholeListRecorded) return;
-    const commands = bucketSlotEditable.commands ?? (bucketSlotEditable.commands = []);
-    commands.push(orderedListCommand);
-    if (commands.length > this.maxCommandsPerSlot * bucketMemberSlotCount) {
-      commands.length = 0;
-      bucketSlotEditable.isWholeListRecorded = true;
+  reconcileSlots(bucketSlot, bucketMemberSlots, arrivedChannelQueue, departedChannelQueue) {
+    const bucketMemberSlotsArrayService = this.bucketMemberSlotsArrayService;
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    if (bucketMemberSlotsArrayService.isSameBucketMemberSlotSequence(bucketSlotsArrayStore, bucketMemberSlots)) return;
+    arrivedChannelQueue.keepFirstEntries(0);
+    departedChannelQueue.keepFirstEntries(0);
+    const heldBucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    for (let i = 0; i < heldBucketMemberSlots.length; i++) departedChannelQueue.enqueueEntry(heldBucketMemberSlots[i]);
+    bucketMemberSlotsArrayService.clearBucketMemberSlots(bucketSlotsArrayStore);
+    for (let i = 0; i < bucketMemberSlots.length; i++) {
+      if (bucketMemberSlotsArrayService.appendBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlots[i])) {
+        arrivedChannelQueue.enqueueEntry(bucketMemberSlots[i]);
+      }
     }
   }
-};
-function enlistInFlush(bucketSlot) {
-  const bucketSlotEditable = bucketSlot;
-  const storeSlot = bucketSlot.storeSlot;
-  const channelSlot = storeSlot.channelSlot;
-  const commands = bucketSlotEditable.commands;
-  const hasScript = commands !== void 0 && commands.length > 0 || bucketSlotEditable.isWholeListRecorded;
-  if (hasScript && !isScriptStale(channelSlot, bucketSlotEditable)) return bucketSlotEditable;
-  if (hasScript) {
-    clearScript(bucketSlotEditable);
-  } else {
-    const commandsBucketSlotChannelQueue = storeSlot.commandsBucketSlotChannelQueue ?? (storeSlot.commandsBucketSlotChannelQueue = new OIMChannelQueue());
-    if (commandsBucketSlotChannelQueue.getEntryCount() === 0) getCommandsStoreSlotChannelQueue(channelSlot).enqueueEntry(storeSlot);
-    commandsBucketSlotChannelQueue.enqueueEntry(bucketSlotEditable);
+  drainSlots(bucketSlot, departedChannelQueue) {
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    const heldBucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    for (let i = 0; i < heldBucketMemberSlots.length; i++) departedChannelQueue.enqueueEntry(heldBucketMemberSlots[i]);
+    this.bucketMemberSlotsArrayService.clearBucketMemberSlots(bucketSlotsArrayStore);
   }
-  const clock = channelSlot.clock;
-  bucketSlotEditable.commandsStartedAtRevision = clock.revision;
-  bucketSlotEditable.commandsStartedAtEpoch = clock.epoch;
-  return bucketSlotEditable;
-}
-function getCommandsStoreSlotChannelQueue(channelSlot) {
-  const commandsStoreSlotChannelQueue = channelSlot.commandsStoreSlotChannelQueue;
-  if (commandsStoreSlotChannelQueue !== void 0) return commandsStoreSlotChannelQueue;
-  const createdCommandsStoreSlotChannelQueue = new OIMChannelQueue();
-  channelSlot.commandsStoreSlotChannelQueue = createdCommandsStoreSlotChannelQueue;
-  OIMChannelService.INSTANCE.subscribeAfterEachFlush(channelSlot, () => {
-    clearStaleScripts(channelSlot, createdCommandsStoreSlotChannelQueue);
-  });
-  return createdCommandsStoreSlotChannelQueue;
-}
-function isScriptStale(channelSlot, bucketSlot) {
-  const frame = channelSlot.frame;
-  return oimIsRevisionAfter(
-    frame.openedAtRevision,
-    frame.openedAtEpoch,
-    bucketSlot.commandsStartedAtRevision,
-    bucketSlot.commandsStartedAtEpoch
-  );
-}
-function clearScript(bucketSlotEditable) {
-  const commands = bucketSlotEditable.commands;
-  if (commands !== void 0 && commands.length !== 0) commands.length = 0;
-  bucketSlotEditable.isWholeListRecorded = false;
-}
-function clearStaleScripts(channelSlot, commandsStoreSlotChannelQueue) {
-  let keptStoreSlotCount = 0;
-  for (let i = 0; i < commandsStoreSlotChannelQueue.getEntryCount(); i++) {
-    const storeSlot = commandsStoreSlotChannelQueue.getEntryAt(i);
-    const commandsBucketSlotChannelQueue = storeSlot.commandsBucketSlotChannelQueue;
-    let keptBucketSlotCount = 0;
-    for (let j = 0; j < commandsBucketSlotChannelQueue.getEntryCount(); j++) {
-      const bucketSlotEditable = commandsBucketSlotChannelQueue.getEntryAt(j);
-      if (!isScriptStale(channelSlot, bucketSlotEditable)) {
-        commandsBucketSlotChannelQueue.setEntryAt(keptBucketSlotCount++, bucketSlotEditable);
-        continue;
-      }
-      clearScript(bucketSlotEditable);
-    }
-    commandsBucketSlotChannelQueue.keepFirstEntries(keptBucketSlotCount);
-    if (keptBucketSlotCount !== 0) commandsStoreSlotChannelQueue.setEntryAt(keptStoreSlotCount++, storeSlot);
+  hasBucketMemberSlot(bucketSlot, bucketMemberSlot) {
+    return this.bucketMemberSlotsArrayService.hasBucketMemberSlot(bucketSlot.bucketSlotsStore, bucketMemberSlot);
   }
-  commandsStoreSlotChannelQueue.keepFirstEntries(keptStoreSlotCount);
-}
+  getBucketMemberSlotCount(bucketSlot) {
+    return bucketSlot.bucketSlotsStore.bucketMemberSlots.length;
+  }
+  getBucketMemberSlots(bucketSlot) {
+    return bucketSlot.bucketSlotsStore.bucketMemberSlots;
+  }
+  getBucketMemberSlotAt(bucketSlot, at) {
+    return bucketSlot.bucketSlotsStore.bucketMemberSlots[at];
+  }
+  getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot) {
+    return bucketSlot.bucketSlotsStore.bucketMemberSlots.indexOf(bucketMemberSlot);
+  }
+};
 
-// src/factories/utils/createOIMBucketSlotOwnerService.ts
-function createOIMBucketSlotOwnerService(db, options) {
-  return options.slotContentService.createSlotOwnerService({
-    slotStamp: db.slotStamp,
-    slotReleasePolicy: options.slotReleasePolicy ?? db.slotReleasePolicy,
-    slotStoreService: options.slotStoreService,
-    columnOwnerOptions: oimColumnOwnerOptionsWithDefault(
-      options.columnSlotStoreService,
-      options.columnNames,
-      OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.getValue()
-    ),
-    createColumnOwner: createOIMColumnOwnerPushDriven
-  });
+// src/engine/bucket/constants/OIM_NOTHING_WAS_INSERTED.ts
+var OIM_NOTHING_WAS_INSERTED = -1;
+
+// src/engine/bucket/array/utils/oimAssertWholePosition.ts
+function oimAssertWholePosition(position) {
+  if (position === Math.trunc(position)) return;
+  throw new Error(
+    `OIMSlotContentPositionalArrayBucketService: a position must be a whole number, got ${position}. A fraction or NaN would be read one way by the list and another by splice.`
+  );
 }
 
-// src/factories/createOIMBucketService.ts
-function createOIMBucketService(db, ...[options = {}]) {
-  const slotStoreService = oimSlotStoreServiceWithDefault(options.bucketSlotStoreService);
-  const slotContentService = options.slotContentService ?? new OIMSlotContentBucketServiceArrayDriven({
-    bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: options.maxCommandsPerSlot })
-  });
-  return new OIMSlotCollectionService({
-    slotOwnerService: createOIMBucketSlotOwnerService(db, {
-      slotStoreService,
-      slotContentService,
-      slotReleasePolicy: options.slotReleasePolicy,
-      columnSlotStoreService: options.columnSlotStoreService,
-      columnNames: options.columnNames
-    }),
-    slotStoreService,
-    slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
-  });
+// src/facade/bucket/OIMSlotContentPositionalArrayBucketService.ts
+var OIMSlotContentPositionalArrayBucketService = class extends OIMSlotContentArrayBucketService {
+  constructor(options = {}) {
+    super(options);
+  }
+  insertBucketMemberSlotAt(bucketSlot, at, bucketMemberSlot) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    oimAssertWholePosition(at);
+    this.assertBucketMemberSlotNotReleased(bucketMemberSlot);
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    const landing = this.bucketMemberSlotsArrayService.insertBucketMemberSlotAt(bucketSlotsArrayStore, at, bucketMemberSlot);
+    if (landing === OIM_NOTHING_WAS_INSERTED) return;
+    bucketMemberSlot.owner.holdSlot(bucketMemberSlot);
+    this.bucketCommands.recordInsert(bucketSlot, landing, bucketMemberSlot, bucketSlotsArrayStore.bucketMemberSlots.length);
+    this.markBucketSlotChanged(bucketSlot);
+  }
+  removeBucketMemberSlotAt(bucketSlot, at) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    oimAssertWholePosition(at);
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    if (at < 0 || at >= bucketSlotsArrayStore.bucketMemberSlots.length) return void 0;
+    const removedBucketMemberSlot = this.bucketMemberSlotsArrayService.removeBucketMemberSlotAt(bucketSlotsArrayStore, at);
+    oimUnholdSlotIfAlive(removedBucketMemberSlot);
+    this.bucketCommands.recordRemove(bucketSlot, at, 1, bucketSlotsArrayStore.bucketMemberSlots.length);
+    this.markBucketSlotChanged(bucketSlot);
+    return removedBucketMemberSlot;
+  }
+  removeBucketMemberSlotRange(bucketSlot, at, count) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    oimAssertWholePosition(at);
+    oimAssertWholePosition(count);
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    if (at < 0 || count <= 0 || at >= bucketSlotsArrayStore.bucketMemberSlots.length) return OIM_FROZEN_EMPTY_SLOTS;
+    const removedBucketMemberSlots = this.bucketMemberSlotsArrayService.removeBucketMemberSlotRange(bucketSlotsArrayStore, at, count);
+    for (let i = 0; i < removedBucketMemberSlots.length; i++) oimUnholdSlotIfAlive(removedBucketMemberSlots[i]);
+    this.bucketCommands.recordRemove(bucketSlot, at, removedBucketMemberSlots.length, bucketSlotsArrayStore.bucketMemberSlots.length);
+    this.markBucketSlotChanged(bucketSlot);
+    return removedBucketMemberSlots;
+  }
+  moveBucketMemberSlotToPosition(bucketSlot, from, to) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    oimAssertWholePosition(from);
+    oimAssertWholePosition(to);
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    const bucketMemberSlotCount = bucketSlotsArrayStore.bucketMemberSlots.length;
+    if (from < 0 || from >= bucketMemberSlotCount || to < 0 || to >= bucketMemberSlotCount || from === to) return void 0;
+    if (!this.bucketMemberSlotsArrayService.moveBucketMemberSlotRange(bucketSlotsArrayStore, from, 1, to)) return void 0;
+    this.bucketCommands.recordMove(bucketSlot, from, to, bucketMemberSlotCount);
+    this.markBucketSlotChanged(bucketSlot);
+    return bucketSlotsArrayStore.bucketMemberSlots[to];
+  }
+  moveBucketMemberSlotRangeToPosition(bucketSlot, from, count, to) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    oimAssertWholePosition(from);
+    oimAssertWholePosition(count);
+    oimAssertWholePosition(to);
+    const bucketSlotsArrayStore = bucketSlot.bucketSlotsStore;
+    const bucketMemberSlotCount = bucketSlotsArrayStore.bucketMemberSlots.length;
+    if (from < 0 || count <= 0 || from >= bucketMemberSlotCount) return;
+    const taking = from + count > bucketMemberSlotCount ? bucketMemberSlotCount - from : count;
+    const remaining = bucketMemberSlotCount - taking;
+    const landing = to < 0 ? 0 : to > remaining ? remaining : to;
+    if (!this.bucketMemberSlotsArrayService.moveBucketMemberSlotRange(bucketSlotsArrayStore, from, taking, landing)) return;
+    this.bucketCommands.recordWholeList(bucketSlot);
+    this.markBucketSlotChanged(bucketSlot);
+  }
+};
+
+// src/engine/bucket/utils/oimSameUniqueSlotSequence.ts
+function oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots) {
+  const seenBucketMemberSlots = /* @__PURE__ */ new Set();
+  let at = 0;
+  for (let i = 0; i < bucketMemberSlots.length; i++) {
+    const bucketMemberSlot = bucketMemberSlots[i];
+    if (seenBucketMemberSlots.has(bucketMemberSlot)) continue;
+    seenBucketMemberSlots.add(bucketMemberSlot);
+    if (at >= heldBucketMemberSlots.length || heldBucketMemberSlots[at] !== bucketMemberSlot) return false;
+    at++;
+  }
+  return at === heldBucketMemberSlots.length;
 }
 
-// src/factories/createOIMSingleBucketService.ts
-function createOIMSingleBucketService(db, options = {}) {
-  const slotStoreService = OIMSlotStoreServiceSingleSlotDriven.INSTANCE;
-  const slotContentService = options.slotContentService ?? new OIMSlotContentBucketServiceArrayDriven({
-    bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: options.maxCommandsPerSlot })
-  });
-  return new OIMSingleSlotService({
-    slotOwnerService: createOIMBucketSlotOwnerService(db, {
-      slotStoreService,
-      slotContentService,
-      slotReleasePolicy: options.slotReleasePolicy,
-      columnSlotStoreService: options.columnSlotStoreService,
-      columnNames: options.columnNames
-    }),
-    slotStoreService,
-    slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
-  });
+// src/engine/bucket/array/OIMBucketUniqueMemberSlotsArrayService.ts
+var _OIMBucketUniqueMemberSlotsArrayService = class _OIMBucketUniqueMemberSlotsArrayService extends OIMBucketMemberSlotsArrayService {
+  createBucketSlotsArrayStore() {
+    return { bucketMemberSlots: [], uniqueBucketMemberSlots: /* @__PURE__ */ new Set(), sortedCount: 0 };
+  }
+  hasBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    return uniqueBucketMemberSlotsOf(bucketSlotsArrayStore).has(bucketMemberSlot);
+  }
+  appendBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    const uniqueBucketMemberSlots = uniqueBucketMemberSlotsOf(bucketSlotsArrayStore);
+    if (uniqueBucketMemberSlots.has(bucketMemberSlot)) return false;
+    uniqueBucketMemberSlots.add(bucketMemberSlot);
+    return super.appendBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot);
+  }
+  insertBucketMemberSlotAt(bucketSlotsArrayStore, at, bucketMemberSlot) {
+    const uniqueBucketMemberSlots = uniqueBucketMemberSlotsOf(bucketSlotsArrayStore);
+    if (uniqueBucketMemberSlots.has(bucketMemberSlot)) return OIM_NOTHING_WAS_INSERTED;
+    uniqueBucketMemberSlots.add(bucketMemberSlot);
+    return super.insertBucketMemberSlotAt(bucketSlotsArrayStore, at, bucketMemberSlot);
+  }
+  removeBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot) {
+    if (!uniqueBucketMemberSlotsOf(bucketSlotsArrayStore).delete(bucketMemberSlot)) return OIM_NOTHING_WAS_REMOVED;
+    return super.removeBucketMemberSlot(bucketSlotsArrayStore, bucketMemberSlot);
+  }
+  removeBucketMemberSlotAt(bucketSlotsArrayStore, at) {
+    const removedBucketMemberSlot = super.removeBucketMemberSlotAt(bucketSlotsArrayStore, at);
+    uniqueBucketMemberSlotsOf(bucketSlotsArrayStore).delete(removedBucketMemberSlot);
+    return removedBucketMemberSlot;
+  }
+  removeBucketMemberSlotRange(bucketSlotsArrayStore, at, count) {
+    const removedBucketMemberSlots = super.removeBucketMemberSlotRange(bucketSlotsArrayStore, at, count);
+    const uniqueBucketMemberSlots = uniqueBucketMemberSlotsOf(bucketSlotsArrayStore);
+    for (let i = 0; i < removedBucketMemberSlots.length; i++) uniqueBucketMemberSlots.delete(removedBucketMemberSlots[i]);
+    return removedBucketMemberSlots;
+  }
+  removeBucketMemberSlots(bucketSlotsArrayStore, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue) {
+    const removedCountBefore = removedChannelQueue.getEntryCount();
+    super.removeBucketMemberSlots(bucketSlotsArrayStore, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue);
+    const uniqueBucketMemberSlots = uniqueBucketMemberSlotsOf(bucketSlotsArrayStore);
+    for (let i = removedCountBefore; i < removedChannelQueue.getEntryCount(); i++) {
+      uniqueBucketMemberSlots.delete(removedChannelQueue.getEntryAt(i));
+    }
+  }
+  isSameBucketMemberSlotSequence(bucketSlotsArrayStore, bucketMemberSlots) {
+    const heldBucketMemberSlots = bucketSlotsArrayStore.bucketMemberSlots;
+    if (bucketMemberSlots.length < heldBucketMemberSlots.length) return false;
+    return oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots);
+  }
+  clearBucketMemberSlots(bucketSlotsArrayStore) {
+    super.clearBucketMemberSlots(bucketSlotsArrayStore);
+    uniqueBucketMemberSlotsOf(bucketSlotsArrayStore).clear();
+  }
+};
+_OIMBucketUniqueMemberSlotsArrayService.INSTANCE = new _OIMBucketUniqueMemberSlotsArrayService();
+var OIMBucketUniqueMemberSlotsArrayService = _OIMBucketUniqueMemberSlotsArrayService;
+function uniqueBucketMemberSlotsOf(bucketSlotsArrayStore) {
+  return bucketSlotsArrayStore.uniqueBucketMemberSlots;
 }
 
+// src/facade/bucket/OIMSlotContentSortedArrayBucketService.ts
+var OIMSlotContentSortedArrayBucketService = class extends OIMSlotContentArrayBucketService {
+  constructor(options) {
+    super(options);
+    this.compareBucketMemberSlots = options.compareBucketMemberSlots;
+  }
+  drainSlots(bucketSlot, departedChannelQueue) {
+    this.bucketMemberSlotsArrayService.sortBucketMemberSlots(bucketSlot.bucketSlotsStore, this.compareBucketMemberSlots);
+    super.drainSlots(bucketSlot, departedChannelQueue);
+  }
+  getBucketMemberSlots(bucketSlot) {
+    this.bucketMemberSlotsArrayService.sortBucketMemberSlots(bucketSlot.bucketSlotsStore, this.compareBucketMemberSlots);
+    return super.getBucketMemberSlots(bucketSlot);
+  }
+  getBucketMemberSlotAt(bucketSlot, at) {
+    this.bucketMemberSlotsArrayService.sortBucketMemberSlots(bucketSlot.bucketSlotsStore, this.compareBucketMemberSlots);
+    return super.getBucketMemberSlotAt(bucketSlot, at);
+  }
+  getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot) {
+    this.bucketMemberSlotsArrayService.sortBucketMemberSlots(bucketSlot.bucketSlotsStore, this.compareBucketMemberSlots);
+    return super.getBucketMemberSlotPosition(bucketSlot, bucketMemberSlot);
+  }
+  repositionBucketMemberSlot(bucketSlot, bucketMemberSlot) {
+    const slotOwnerService = bucketSlot.owner;
+    slotOwnerService.assertWritable(bucketSlot);
+    if (this.removeSlot(bucketSlot, bucketMemberSlot) === OIM_NOTHING_WAS_REMOVED) return;
+    if (this.addSlot(bucketSlot, bucketMemberSlot)) this.markBucketSlotChanged(bucketSlot);
+  }
+};
+
 // src/factories/defaults/OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.ts
-var OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue("COMPUTED_COLUMN_SLOT_STORE_SERVICE", () => OIMSlotStoreServiceMapDriven.INSTANCE);
+var OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue("COMPUTED_COLUMN_SLOT_STORE_SERVICE", () => OIMSlotMapStoreService.INSTANCE);
 
 // src/engine/index/OIMIndexKeysService.ts
 var OIMIndexKeysService = class {
@@ -3824,8 +3387,8 @@ var OIMIndexKeysService = class {
   }
 };
 
-// src/engine/index/OIMIndexKeysServiceAppending.ts
-var _OIMIndexKeysServiceAppending = class _OIMIndexKeysServiceAppending extends OIMIndexKeysService {
+// src/engine/index/OIMAppendingIndexKeysService.ts
+var _OIMAppendingIndexKeysService = class _OIMAppendingIndexKeysService extends OIMIndexKeysService {
   allocatePosition(positions) {
     return positions.nextPosition++;
   }
@@ -3833,11 +3396,11 @@ var _OIMIndexKeysServiceAppending = class _OIMIndexKeysServiceAppending extends
     return;
   }
 };
-_OIMIndexKeysServiceAppending.INSTANCE = new _OIMIndexKeysServiceAppending();
-var OIMIndexKeysServiceAppending = _OIMIndexKeysServiceAppending;
+_OIMAppendingIndexKeysService.INSTANCE = new _OIMAppendingIndexKeysService();
+var OIMAppendingIndexKeysService = _OIMAppendingIndexKeysService;
 
 // src/factories/defaults/OIM_DEFAULT_INDEX_KEYS_SERVICE.ts
-var OIM_DEFAULT_INDEX_KEYS_SERVICE = /* @__PURE__ */ new OIMDefaultValue("INDEX_KEYS_SERVICE", () => OIMIndexKeysServiceAppending.INSTANCE);
+var OIM_DEFAULT_INDEX_KEYS_SERVICE = /* @__PURE__ */ new OIMDefaultValue("INDEX_KEYS_SERVICE", () => OIMAppendingIndexKeysService.INSTANCE);
 
 // src/engine/key/OIMKeyTreeWalk.ts
 var OIMKeyTreeWalk = class {
@@ -3905,8 +3468,8 @@ var OIMKeyTreeWalk = class {
   }
 };
 
-// src/engine/key/OIMKeyTreeWalkComposite.ts
-var _OIMKeyTreeWalkComposite = class _OIMKeyTreeWalkComposite extends OIMKeyTreeWalk {
+// src/engine/key/OIMCompositeKeyTreeWalk.ts
+var _OIMCompositeKeyTreeWalk = class _OIMCompositeKeyTreeWalk extends OIMKeyTreeWalk {
   holdCompositeKeyPart(entitySlot) {
     entitySlot.owner.holdSlot(entitySlot);
   }
@@ -3914,14 +3477,14 @@ var _OIMKeyTreeWalkComposite = class _OIMKeyTreeWalkComposite extends OIMKeyTree
     oimUnholdSlotIfAlive(entitySlot);
   }
 };
-_OIMKeyTreeWalkComposite.INSTANCE = new _OIMKeyTreeWalkComposite();
-var OIMKeyTreeWalkComposite = _OIMKeyTreeWalkComposite;
+_OIMCompositeKeyTreeWalk.INSTANCE = new _OIMCompositeKeyTreeWalk();
+var OIMCompositeKeyTreeWalk = _OIMCompositeKeyTreeWalk;
 
 // src/factories/defaults/OIM_DEFAULT_KEY_TREE_WALK_COMPOSITE.ts
-var OIM_DEFAULT_KEY_TREE_WALK_COMPOSITE = /* @__PURE__ */ new OIMDefaultValue("KEY_TREE_WALK_COMPOSITE", () => OIMKeyTreeWalkComposite.INSTANCE);
+var OIM_DEFAULT_KEY_TREE_WALK_COMPOSITE = /* @__PURE__ */ new OIMDefaultValue("KEY_TREE_WALK_COMPOSITE", () => OIMCompositeKeyTreeWalk.INSTANCE);
 
-// src/engine/key/OIMKeyTreeWalkScalar.ts
-var _OIMKeyTreeWalkScalar = class _OIMKeyTreeWalkScalar extends OIMKeyTreeWalk {
+// src/engine/key/OIMScalarKeyTreeWalk.ts
+var _OIMScalarKeyTreeWalk = class _OIMScalarKeyTreeWalk extends OIMKeyTreeWalk {
   holdCompositeKeyPart() {
     return;
   }
@@ -3929,11 +3492,11 @@ var _OIMKeyTreeWalkScalar = class _OIMKeyTreeWalkScalar extends OIMKeyTreeWalk {
     return;
   }
 };
-_OIMKeyTreeWalkScalar.INSTANCE = new _OIMKeyTreeWalkScalar();
-var OIMKeyTreeWalkScalar = _OIMKeyTreeWalkScalar;
+_OIMScalarKeyTreeWalk.INSTANCE = new _OIMScalarKeyTreeWalk();
+var OIMScalarKeyTreeWalk = _OIMScalarKeyTreeWalk;
 
 // src/factories/defaults/OIM_DEFAULT_KEY_TREE_WALK_SCALAR.ts
-var OIM_DEFAULT_KEY_TREE_WALK_SCALAR = /* @__PURE__ */ new OIMDefaultValue("KEY_TREE_WALK_SCALAR", () => OIMKeyTreeWalkScalar.INSTANCE);
+var OIM_DEFAULT_KEY_TREE_WALK_SCALAR = /* @__PURE__ */ new OIMDefaultValue("KEY_TREE_WALK_SCALAR", () => OIMScalarKeyTreeWalk.INSTANCE);
 
 // src/factories/defaults/OIM_DEFAULT_STANDALONE_SLOT_OWNER.ts
 var OIM_DEFAULT_STANDALONE_SLOT_OWNER = /* @__PURE__ */ new OIMDefaultValue("STANDALONE_SLOT_OWNER", () => new OIMSlotOwner());
@@ -3951,8 +3514,8 @@ OIMDefaults.ENTITY_SLOT_EMPTINESS = OIM_DEFAULT_ENTITY_SLOT_EMPTINESS;
 OIMDefaults.INDEX_KEYS_SERVICE = OIM_DEFAULT_INDEX_KEYS_SERVICE;
 OIMDefaults.STORE_SLOT_LISTENER = OIM_DEFAULT_STORE_SLOT_LISTENER;
 
-// src/engine/column/utils/createOIMColumnOwnerPullDriven.ts
-var createOIMColumnOwnerPullDriven = (columnOwnerOptions) => new OIMColumnOwnerPullDriven(columnOwnerOptions);
+// src/engine/column/utils/createOIMPullColumnSlotOwner.ts
+var createOIMPullColumnSlotOwner = (columnSlotOwnerOptions) => new OIMPullColumnSlotOwner(columnSlotOwnerOptions);
 
 // src/engine/computed/OIMComputedSourcesService.ts
 var _OIMComputedSourcesService = class _OIMComputedSourcesService {
@@ -3970,29 +3533,58 @@ var _OIMComputedSourcesService = class _OIMComputedSourcesService {
 _OIMComputedSourcesService.INSTANCE = new _OIMComputedSourcesService();
 var OIMComputedSourcesService = _OIMComputedSourcesService;
 
-// src/engine/computed/OIMSlotContentComputedStrategy.ts
-var OIMSlotContentComputedStrategy = class {
+// src/engine/computed/utils/createOIMSingleComputedSlot.ts
+function createOIMSingleComputedSlot(owner, computedValueService, initialValue, storeSlot) {
+  const singleComputedSlot = {
+    effects: void 0,
+    changedAtRevision: 0,
+    changedAtEpoch: 0,
+    effectEdges: void 0,
+    holdCount: 0,
+    releaseDueAfterWriteMs: -1,
+    releaseDueAfterIdleMs: -1,
+    releaseDueAfterUnholdMs: -1,
+    slotFlags: OIM_SLOT_FLAG_EMPTY,
+    columnSlotStore: void 0,
+    storeSlot,
+    owner,
+    computedValueService,
+    key: void 0,
+    indexKeys: void 0,
+    sourceSlots: OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
+    sourceComputeds: OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
+    value: initialValue,
+    ranAtRevision: -1,
+    ranAtEpoch: -1,
+    checkedAtRevision: -1,
+    checkedAtEpoch: -1,
+    isDeriving: false,
+    allRootSlots: void 0
+  };
+  return singleComputedSlot;
+}
+
+// src/engine/computed/OIMSlotContentComputedService.ts
+var OIMSlotContentComputedService = class {
   constructor(options) {
     this.computedValueService = options.computedValueService;
     this.createSources = options.createSources;
     this.initialValue = options.initialValue;
   }
-  createSlot(key, storeSlot, slotOwnerService) {
-    const createSources = storeSlot?.createSources ?? this.createSources;
-    const computedSources = createSources(
-      key,
-      storeSlot
-    );
+  createSlot(key, storeSlot, slotOwner) {
     const computedSlot = createOIMComputedSlot(
       key,
-      slotOwnerService,
+      slotOwner,
       this.computedValueService,
-      computedSources.sourceSlots ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
-      computedSources.sourceComputeds ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS,
       this.initialValue,
       storeSlot
     );
-    OIMComputedSourcesService.INSTANCE.holdSources(computedSlot);
+    this.attachSources(computedSlot, storeSlot);
+    return computedSlot;
+  }
+  createSingleSlot(storeSlot, slotOwner) {
+    const computedSlot = createOIMSingleComputedSlot(slotOwner, this.computedValueService, this.initialValue, storeSlot);
+    this.attachSources(computedSlot, storeSlot);
     return computedSlot;
   }
   isSlotEmpty() {
@@ -4004,61 +3596,72 @@ var OIMSlotContentComputedStrategy = class {
   hasReference() {
     return false;
   }
+  attachSources(computedSlot, storeSlot) {
+    const createSources = storeSlot.createSources ?? this.createSources;
+    const computedSources = createSources(computedSlot);
+    const computedSlotEditable = computedSlot;
+    computedSlotEditable.sourceSlots = computedSources.sourceSlots ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
+    computedSlotEditable.sourceComputeds = computedSources.sourceComputeds ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
+    OIMComputedSourcesService.INSTANCE.holdSources(computedSlot);
+  }
 };
 
 // src/facade/computed/utils/createOIMComputedCollectionService.ts
 function createOIMComputedCollectionService(options) {
-  const slotOwnerService = new OIMSlotOwnerService({
-    slotReleasePolicy: options.slotReleasePolicy,
-    slotStoreService: options.computedSlotStoreService,
-    slotContentStrategy: new OIMSlotContentComputedStrategy(options),
-    columnOwnerOptions: options.columnOwnerOptions,
-    createColumnOwner: createOIMColumnOwnerPullDriven
-  });
   return new OIMSlotCollectionService({
-    slotOwnerService,
+    slotReleasePolicy: options.slotReleasePolicy,
     slotStoreService: options.computedSlotStoreService,
-    slotContentService: options.computedValueService,
+    slotContentService: new OIMSlotContentComputedService(options),
+    columnSlotOwnerOptions: options.columnSlotOwnerOptions,
+    createColumnSlotOwner: createOIMPullColumnSlotOwner,
     storeSlotListener: options.storeSlotListener
   });
 }
 
+// src/facade/computed/utils/oimAttachComputedDerivation.ts
+function oimAttachComputedDerivation(computedStoreSlot, hasServiceDerive, hasServiceCreateSources, derive, createSources) {
+  if (derive === void 0 && !hasServiceDerive || createSources === void 0 && !hasServiceCreateSources) {
+    throw new Error(
+      "A computed store slot needs a derive and a createSources, from the store slot or from the service options. Pass the missing one when creating the store slot or to the service."
+    );
+  }
+  const computedStoreSlotEditable = computedStoreSlot;
+  computedStoreSlotEditable.derive = derive;
+  computedStoreSlotEditable.createSources = createSources;
+  return computedStoreSlot;
+}
+
 // src/facade/computed/OIMComputedService.ts
 var OIMComputedService = class {
   constructor(options) {
-    const computedValueService = new OIMComputedValueService({
-      derive: options.derive,
-      sameValueGuard: options.sameValueGuard
-    });
     this.computedCollectionService = createOIMComputedCollectionService({
-      computedValueService,
+      computedValueService: new OIMComputedValueService({
+        derive: options.derive,
+        sameValueGuard: options.sameValueGuard
+      }),
       createSources: options.createSources,
       initialValue: options.initialValue,
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
-      columnOwnerOptions: options.columnOwnerOptions,
+      columnSlotOwnerOptions: options.columnSlotOwnerOptions,
       storeSlotListener: options.storeSlotListener
     });
     this.hasDerive = options.derive !== void 0;
     this.hasCreateSources = options.createSources !== void 0;
   }
   createComputedStoreSlot(channelMap, derive, createSources) {
-    this.assertDeriveAndCreateSources(derive !== void 0, createSources !== void 0);
-    const computedStoreSlot = this.computedCollectionService.createStoreSlot(channelMap);
-    computedStoreSlot.derive = derive;
-    computedStoreSlot.createSources = createSources;
-    return computedStoreSlot;
-  }
-  assertDeriveAndCreateSources(hasStoreSlotDerive, hasStoreSlotCreateSources) {
-    if ((hasStoreSlotDerive || this.hasDerive) && (hasStoreSlotCreateSources || this.hasCreateSources)) return;
-    throw new Error(
-      "OIMComputedService: a computed store slot needs a derive and a createSources, from the store slot or from the service options. Pass the missing one to createComputedStoreSlot or to the service."
+    return oimAttachComputedDerivation(
+      this.computedCollectionService.createStoreSlot(channelMap),
+      this.hasDerive,
+      this.hasCreateSources,
+      derive,
+      createSources
     );
   }
 };
 
-// src/engine/collector/OIMSlotReleasePolicyAtUnhold.ts
-var _OIMSlotReleasePolicyAtUnhold = class _OIMSlotReleasePolicyAtUnhold {
+// src/engine/collector/OIMSlotAtUnholdReleasePolicy.ts
+var _OIMSlotAtUnholdReleasePolicy = class _OIMSlotAtUnholdReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = true;
     this.schedulesReleaseOnWrite = false;
@@ -4082,19 +3685,68 @@ var _OIMSlotReleasePolicyAtUnhold = class _OIMSlotReleasePolicyAtUnhold {
     return;
   }
 };
-_OIMSlotReleasePolicyAtUnhold.INSTANCE = new _OIMSlotReleasePolicyAtUnhold();
-var OIMSlotReleasePolicyAtUnhold = _OIMSlotReleasePolicyAtUnhold;
+_OIMSlotAtUnholdReleasePolicy.INSTANCE = new _OIMSlotAtUnholdReleasePolicy();
+var OIMSlotAtUnholdReleasePolicy = _OIMSlotAtUnholdReleasePolicy;
 
 // src/factories/createOIMComputedService.ts
 function createOIMComputedService(options) {
   return new OIMComputedService({
     computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
-    columnOwnerOptions: oimColumnOwnerOptionsWithDefault(
+    columnSlotOwnerOptions: oimColumnOwnerOptionsWithDefault(
+      options.columnSlotStoreService,
+      options.columnNames,
+      OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue()
+    ),
+    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
+    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
+    createSources: options.createSources,
+    derive: options.derive,
+    sameValueGuard: options.sameValueGuard,
+    initialValue: options.initialValue
+  });
+}
+
+// src/facade/computed/OIMSingleComputedService.ts
+var OIMSingleComputedService = class {
+  constructor(options) {
+    this.computedSingleSlotService = new OIMSingleSlotService({
+      slotReleasePolicy: options.slotReleasePolicy,
+      slotStoreService: OIMSingleSlotStoreService.INSTANCE,
+      slotContentService: new OIMSlotContentComputedService({
+        computedValueService: new OIMComputedValueService({
+          derive: options.derive,
+          sameValueGuard: options.sameValueGuard
+        }),
+        createSources: options.createSources,
+        initialValue: options.initialValue
+      }),
+      columnSlotOwnerOptions: options.columnSlotOwnerOptions,
+      createColumnSlotOwner: createOIMPullColumnSlotOwner,
+      storeSlotListener: options.storeSlotListener
+    });
+    this.hasDerive = options.derive !== void 0;
+    this.hasCreateSources = options.createSources !== void 0;
+  }
+  createComputedStoreSlot(channelMap, derive, createSources) {
+    return oimAttachComputedDerivation(
+      this.computedSingleSlotService.createStoreSlot(channelMap),
+      this.hasDerive,
+      this.hasCreateSources,
+      derive,
+      createSources
+    );
+  }
+};
+
+// src/factories/createOIMSingleComputedService.ts
+function createOIMSingleComputedService(options = {}) {
+  return new OIMSingleComputedService({
+    columnSlotOwnerOptions: oimColumnOwnerOptionsWithDefault(
       options.columnSlotStoreService,
       options.columnNames,
       OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue()
     ),
-    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotReleasePolicyAtUnhold.INSTANCE,
+    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
     storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
     createSources: options.createSources,
     derive: options.derive,
@@ -4134,8 +3786,8 @@ function oimEntitySlotsComparator(compareEntities) {
   };
 }
 
-// src/facade/computed/OIMComputedServiceSorted.ts
-var OIMComputedServiceSorted = class {
+// src/facade/computed/OIMSortedComputedService.ts
+var OIMSortedComputedService = class {
   constructor(options) {
     const indexService = options.indexService;
     const bucketContentService = indexService.slotContentService;
@@ -4150,11 +3802,17 @@ var OIMComputedServiceSorted = class {
     });
     this.computedCollectionService = createOIMComputedCollectionService({
       computedValueService,
-      createSources: (key, storeSlot) => createSortedSources(key, storeSlot, indexService, sortColumns, hasComparator),
+      createSources: (computedSlot) => createSortedSources(
+        computedSlot.key,
+        computedSlot.storeSlot,
+        indexService,
+        sortColumns,
+        hasComparator
+      ),
       initialValue: OIM_FROZEN_EMPTY_SLOTS,
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
-      columnOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
+      columnSlotOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
       storeSlotListener: options.storeSlotListener
     });
   }
@@ -4235,21 +3893,21 @@ function reconcileArrayWithEveryBucketMemberSlot(entitySlots, bucketMemberSlots)
   return next;
 }
 
-// src/factories/createOIMComputedServiceSorted.ts
-function createOIMComputedServiceSorted(options) {
-  return new OIMComputedServiceSorted({
+// src/factories/createOIMSortedComputedService.ts
+function createOIMSortedComputedService(options) {
+  return new OIMSortedComputedService({
     indexService: options.indexService,
     computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
     columnSlotStoreService: options.columnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
     sortColumns: options.sortColumns,
     comparator: options.comparator,
-    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotReleasePolicyAtUnhold.INSTANCE,
+    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
     storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
   });
 }
 
-// src/facade/computed/OIMComputedServiceBucketMemo.ts
-var OIMComputedServiceBucketMemo = class {
+// src/facade/computed/OIMBucketMemoComputedService.ts
+var OIMBucketMemoComputedService = class {
   constructor(options) {
     const bucketCollectionService = options.bucketCollectionService;
     const bucketContentService = bucketCollectionService.slotContentService;
@@ -4259,11 +3917,11 @@ var OIMComputedServiceBucketMemo = class {
     });
     this.computedCollectionService = createOIMComputedCollectionService({
       computedValueService,
-      createSources: (key, storeSlot) => createBucketMemoSources(key, storeSlot, bucketCollectionService),
+      createSources: (computedSlot) => createBucketMemoSources(computedSlot.key, computedSlot.storeSlot, bucketCollectionService),
       initialValue: OIM_FROZEN_EMPTY_SLOTS,
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
-      columnOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
+      columnSlotOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
       storeSlotListener: options.storeSlotListener
     });
   }
@@ -4274,26 +3932,123 @@ var OIMComputedServiceBucketMemo = class {
 function deriveBucketMemo(computedSlot, bucketContentService) {
   return Array.from(bucketContentService.getBucketMemberSlots(computedSlot.sourceSlots[0]));
 }
-function createBucketMemoSources(key, storeSlot, bucketCollectionService) {
-  const bucketStoreSlot = storeSlot.sourceStoreSlot;
-  return { sourceSlots: [bucketCollectionService.getSlotByKey(bucketStoreSlot, key)] };
+function createBucketMemoSources(key, storeSlot, bucketCollectionService) {
+  const bucketStoreSlot = storeSlot.sourceStoreSlot;
+  return { sourceSlots: [bucketCollectionService.getSlotByKey(bucketStoreSlot, key)] };
+}
+
+// src/factories/createOIMBucketMemoComputedService.ts
+function createOIMBucketMemoComputedService(options) {
+  return new OIMBucketMemoComputedService({
+    bucketCollectionService: options.bucketCollectionService,
+    computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
+    columnSlotStoreService: options.columnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
+    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
+    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+  });
+}
+
+// src/engine/bucket/commands/constants/OIM_MAX_COMMANDS_PER_SLOT.ts
+var OIM_MAX_COMMANDS_PER_SLOT = 1;
+
+// src/facade/bucket/OIMBucketCommands.ts
+var OIMBucketCommands = class {
+  constructor(options) {
+    this.maxCommandsPerSlot = options.maxCommandsPerSlot ?? OIM_MAX_COMMANDS_PER_SLOT;
+  }
+  recordInsert(bucketSlot, index, bucketMemberSlot, bucketMemberSlotCount) {
+    this.recordCommand(bucketSlot, { type: "insert", index, slot: bucketMemberSlot }, bucketMemberSlotCount);
+  }
+  recordRemove(bucketSlot, index, count, bucketMemberSlotCount) {
+    for (let i = 0; i < count; i++) this.recordCommand(bucketSlot, { type: "remove", index }, bucketMemberSlotCount);
+  }
+  recordMove(bucketSlot, from, to, bucketMemberSlotCount) {
+    this.recordCommand(bucketSlot, { type: "move", from, to }, bucketMemberSlotCount);
+  }
+  recordWholeList(bucketSlot) {
+    const bucketSlotEditable = enlistInFlush(bucketSlot);
+    const commands = bucketSlotEditable.commands;
+    if (commands !== void 0 && commands.length !== 0) commands.length = 0;
+    bucketSlotEditable.isWholeListRecorded = true;
+  }
+  recordCommand(bucketSlot, orderedListCommand, bucketMemberSlotCount) {
+    const bucketSlotEditable = enlistInFlush(bucketSlot);
+    if (bucketSlotEditable.isWholeListRecorded) return;
+    const commands = bucketSlotEditable.commands ?? (bucketSlotEditable.commands = []);
+    commands.push(orderedListCommand);
+    if (commands.length > this.maxCommandsPerSlot * bucketMemberSlotCount) {
+      commands.length = 0;
+      bucketSlotEditable.isWholeListRecorded = true;
+    }
+  }
+};
+function enlistInFlush(bucketSlot) {
+  const bucketSlotEditable = bucketSlot;
+  const storeSlot = bucketSlot.storeSlot;
+  const channelSlot = storeSlot.channelSlot;
+  const commands = bucketSlotEditable.commands;
+  const hasScript = commands !== void 0 && commands.length > 0 || bucketSlotEditable.isWholeListRecorded;
+  if (hasScript && !isScriptStale(channelSlot, bucketSlotEditable)) return bucketSlotEditable;
+  if (hasScript) {
+    clearScript(bucketSlotEditable);
+  } else {
+    const commandsBucketSlotChannelQueue = storeSlot.commandsBucketSlotChannelQueue ?? (storeSlot.commandsBucketSlotChannelQueue = new OIMChannelQueue());
+    if (commandsBucketSlotChannelQueue.getEntryCount() === 0) getCommandsStoreSlotChannelQueue(channelSlot).enqueueEntry(storeSlot);
+    commandsBucketSlotChannelQueue.enqueueEntry(bucketSlotEditable);
+  }
+  const clock = channelSlot.clock;
+  bucketSlotEditable.commandsStartedAtRevision = clock.revision;
+  bucketSlotEditable.commandsStartedAtEpoch = clock.epoch;
+  return bucketSlotEditable;
+}
+function getCommandsStoreSlotChannelQueue(channelSlot) {
+  const commandsStoreSlotChannelQueue = channelSlot.commandsStoreSlotChannelQueue;
+  if (commandsStoreSlotChannelQueue !== void 0) return commandsStoreSlotChannelQueue;
+  const createdCommandsStoreSlotChannelQueue = new OIMChannelQueue();
+  channelSlot.commandsStoreSlotChannelQueue = createdCommandsStoreSlotChannelQueue;
+  OIMChannelService.INSTANCE.subscribeAfterEachFlush(channelSlot, () => {
+    clearStaleScripts(channelSlot, createdCommandsStoreSlotChannelQueue);
+  });
+  return createdCommandsStoreSlotChannelQueue;
+}
+function isScriptStale(channelSlot, bucketSlot) {
+  const frame = channelSlot.frame;
+  return oimIsRevisionAfter(
+    frame.openedAtRevision,
+    frame.openedAtEpoch,
+    bucketSlot.commandsStartedAtRevision,
+    bucketSlot.commandsStartedAtEpoch
+  );
 }
-
-// src/factories/createOIMComputedServiceBucketMemo.ts
-function createOIMComputedServiceBucketMemo(options) {
-  return new OIMComputedServiceBucketMemo({
-    bucketCollectionService: options.bucketCollectionService,
-    computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
-    columnSlotStoreService: options.columnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
-    slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotReleasePolicyAtUnhold.INSTANCE,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
-  });
+function clearScript(bucketSlotEditable) {
+  const commands = bucketSlotEditable.commands;
+  if (commands !== void 0 && commands.length !== 0) commands.length = 0;
+  bucketSlotEditable.isWholeListRecorded = false;
+}
+function clearStaleScripts(channelSlot, commandsStoreSlotChannelQueue) {
+  let keptStoreSlotCount = 0;
+  for (let i = 0; i < commandsStoreSlotChannelQueue.getEntryCount(); i++) {
+    const storeSlot = commandsStoreSlotChannelQueue.getEntryAt(i);
+    const commandsBucketSlotChannelQueue = storeSlot.commandsBucketSlotChannelQueue;
+    let keptBucketSlotCount = 0;
+    for (let j = 0; j < commandsBucketSlotChannelQueue.getEntryCount(); j++) {
+      const bucketSlotEditable = commandsBucketSlotChannelQueue.getEntryAt(j);
+      if (!isScriptStale(channelSlot, bucketSlotEditable)) {
+        commandsBucketSlotChannelQueue.setEntryAt(keptBucketSlotCount++, bucketSlotEditable);
+        continue;
+      }
+      clearScript(bucketSlotEditable);
+    }
+    commandsBucketSlotChannelQueue.keepFirstEntries(keptBucketSlotCount);
+    if (keptBucketSlotCount !== 0) commandsStoreSlotChannelQueue.setEntryAt(keptStoreSlotCount++, storeSlot);
+  }
+  commandsStoreSlotChannelQueue.keepFirstEntries(keptStoreSlotCount);
 }
 
 // src/engine/index/utils/createOIMIndexStoreSlot.ts
-function createOIMIndexStoreSlot(store, sourceStoreSlot, contentChangeListener) {
+function createOIMIndexStoreSlot(store, slotService, sourceStoreSlot, contentChangeListener) {
   return {
-    ...createOIMStoreSlot(store, sourceStoreSlot.channelSlot),
+    ...createOIMStoreSlot(store, sourceStoreSlot.channelSlot, slotService),
     sourceStoreSlot,
     indexKeysPosition: -1,
     contentChangeListener,
@@ -4304,8 +4059,8 @@ function createOIMIndexStoreSlot(store, sourceStoreSlot, contentChangeListener)
   };
 }
 
-// src/facade/index/OIMIndexService.ts
-var OIMIndexService = class extends OIMSlotCollectionService {
+// src/facade/index/OIMSlotCollectionIndexService.ts
+var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
   constructor(options) {
     super(options);
     this.slotContentBucketService = options.slotContentService;
@@ -4323,7 +4078,7 @@ var OIMIndexService = class extends OIMSlotCollectionService {
         this.updateIndexKeysForSlots(indexStoreSlot, entitySlotChannelQueue, patchChannelQueue, changedColumnsChannelQueue);
       }
     };
-    const indexStoreSlot = this.createStoreSlotWith((store) => createOIMIndexStoreSlot(store, sourceStoreSlot, contentChangeListener));
+    const indexStoreSlot = this.createStoreSlotWith((store) => createOIMIndexStoreSlot(store, this, sourceStoreSlot, contentChangeListener));
     const indexKeysService = this.indexKeysService;
     const indexKeysPositions = sourceStoreSlot.indexKeysPositions ?? (sourceStoreSlot.indexKeysPositions = indexKeysService.createPositions());
     indexStoreSlot.indexKeysPosition = indexKeysService.allocatePosition(indexKeysPositions);
@@ -4351,7 +4106,7 @@ var OIMIndexService = class extends OIMSlotCollectionService {
     const bucketSlots = Array.from(this.getSlots(indexStoreSlot));
     for (let i = 0; i < bucketSlots.length; i++) {
       if (oimIsSlotReleased(bucketSlots[i])) continue;
-      slotContentService.clearBucketMemberSlots(bucketSlots[i]);
+      slotContentService.clearSlotContent(bucketSlots[i]);
     }
     indexStoreSlot.isDisposed = true;
   }
@@ -4409,18 +4164,18 @@ var OIMIndexService = class extends OIMSlotCollectionService {
   }
   getAnyBucketColumnByKey(indexStoreSlot, key) {
     this.addAnyBucketColumnRead(indexStoreSlot);
-    return this.slotOwnerService.columnOwner.getAnyColumn(
+    return this.slotOwnerService.columnSlotOwner.getAnyColumn(
       this.getSlotByKey(indexStoreSlot, key),
       indexStoreSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot
     );
   }
   holdAnyBucketColumnByKey(indexStoreSlot, key) {
     this.addAnyBucketColumnRead(indexStoreSlot);
-    return this.slotOwnerService.columnOwner.holdAnyColumn(this.getSlotByKey(indexStoreSlot, key));
+    return this.slotOwnerService.columnSlotOwner.holdAnyColumn(this.getSlotByKey(indexStoreSlot, key));
   }
   getBucketColumnByKey(indexStoreSlot, key, columnName) {
     this.addBucketColumnName(indexStoreSlot, columnName);
-    return this.slotOwnerService.columnOwner.getColumn(
+    return this.slotOwnerService.columnSlotOwner.getColumn(
       this.getSlotByKey(indexStoreSlot, key),
       columnName,
       indexStoreSlot.channelSlot.collectorSlot.unusedSlotCollectorSlot
@@ -4428,7 +4183,7 @@ var OIMIndexService = class extends OIMSlotCollectionService {
   }
   holdBucketColumnByKey(indexStoreSlot, key, columnName) {
     this.addBucketColumnName(indexStoreSlot, columnName);
-    return this.slotOwnerService.columnOwner.holdColumn(this.getSlotByKey(indexStoreSlot, key), columnName);
+    return this.slotOwnerService.columnSlotOwner.holdColumn(this.getSlotByKey(indexStoreSlot, key), columnName);
   }
   addBucketColumnName(indexStoreSlot, columnName) {
     const bucketColumnNames = indexStoreSlot.bucketColumnNames;
@@ -4450,7 +4205,7 @@ var OIMIndexService = class extends OIMSlotCollectionService {
   assertNotDisposed(storeSlot) {
     if (!storeSlot.isDisposed) return;
     throw new Error(
-      "OIMIndexService: this index store slot was disposed. It no longer hears its source store slot and its buckets were emptied, so anything it answered now would be stale. Create a new store slot."
+      "OIMSlotCollectionIndexService: this index store slot was disposed. It no longer hears its source store slot and its buckets were emptied, so anything it answered now would be stale. Create a new store slot."
     );
   }
   addAnyBucketColumnRead(indexStoreSlot) {
@@ -4636,8 +4391,8 @@ function takeNothing() {
   return;
 }
 
-// src/facade/index/OIMIndexServiceSortedArrayDriven.ts
-var OIMIndexServiceSortedArrayDriven = class extends OIMIndexService {
+// src/facade/index/OIMSlotCollectionSortedArrayIndexService.ts
+var OIMSlotCollectionSortedArrayIndexService = class extends OIMSlotCollectionIndexService {
   constructor(options) {
     super(options);
     const sortColumnNames = /* @__PURE__ */ new Set();
@@ -4676,16 +4431,10 @@ function oimKeyOfColumns(columns) {
   };
 }
 
-// src/factories/utils/oimIndexServiceOptionsWithDefault.ts
-function oimIndexServiceOptionsWithDefault(db, options, slotStoreService, slotContentService) {
+// src/factories/utils/oimSlotCollectionIndexServiceOptionsWithDefault.ts
+function oimSlotCollectionIndexServiceOptionsWithDefault(db, options, slotStoreService, slotContentService) {
   return {
-    slotOwnerService: createOIMBucketSlotOwnerService(db, {
-      slotStoreService,
-      slotContentService,
-      slotReleasePolicy: options.slotReleasePolicy,
-      columnSlotStoreService: options.columnSlotStoreService,
-      columnNames: options.columnNames
-    }),
+    ...oimSlotOwnerOptionsWithDefault(db, options),
     slotStoreService,
     slotContentService,
     storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
@@ -4696,70 +4445,23 @@ function oimIndexServiceOptionsWithDefault(db, options, slotStoreService, slotCo
   };
 }
 
-// src/factories/createOIMIndexService.ts
-function createOIMIndexService(db, options) {
-  return new OIMIndexService(oimIndexServiceOptionsWithDefault(
+// src/factories/createOIMSlotCollectionIndexService.ts
+function createOIMSlotCollectionIndexService(db, options) {
+  return new OIMSlotCollectionIndexService(oimSlotCollectionIndexServiceOptionsWithDefault(
     db,
     options,
     oimSlotStoreServiceWithDefault(options.bucketSlotStoreService),
-    options.slotContentService ?? new OIMSlotContentBucketServiceArrayDriven()
+    options.slotContentService ?? new OIMSlotContentPositionalArrayBucketService()
   ));
 }
 
-// src/engine/store/OIMSlotStoreServiceTreeDriven.ts
-var OIMSlotStoreServiceTreeDriven = class {
-  constructor(keyTreeWalk) {
-    this.keyTreeWalk = keyTreeWalk;
-  }
-  createStore() {
-    return { root: { childNodes: void 0, atThisKey: void 0 }, slots: /* @__PURE__ */ new Set() };
-  }
-  ownKey(compositeKey) {
-    return compositeKey.slice();
-  }
-  isSameKey(compositeKey, otherCompositeKey) {
-    return oimSameKeySequence(compositeKey, otherCompositeKey);
-  }
-  get(slotStoreTree, compositeKey) {
-    return this.keyTreeWalk.nodeAt(slotStoreTree.root, compositeKey)?.atThisKey;
-  }
-  set(slotStoreTree, compositeKey, slot) {
-    const compositeKeyNode = this.keyTreeWalk.mintNodeAt(slotStoreTree.root, compositeKey);
-    const filedSlot = compositeKeyNode.atThisKey;
-    if (filedSlot !== void 0 && filedSlot !== slot) slotStoreTree.slots.delete(filedSlot);
-    compositeKeyNode.atThisKey = slot;
-    slotStoreTree.slots.add(slot);
-  }
-  remove(slotStoreTree, compositeKey) {
-    const slot = this.keyTreeWalk.deleteKey(slotStoreTree.root, compositeKey);
-    if (slot !== void 0) slotStoreTree.slots.delete(slot);
-  }
-  getSlots(slotStoreTree) {
-    return slotStoreTree.slots.values();
-  }
-  getSlotCount(slotStoreTree) {
-    return slotStoreTree.slots.size;
-  }
-};
-
-// src/factories/createOIMIndexServiceByCompositeKey.ts
-function createOIMIndexServiceByCompositeKey(db, options) {
-  return createOIMIndexService(db, {
-    ...options,
-    keyOf: oimKeyOfColumns(options.columns),
-    bucketSlotStoreService: new OIMSlotStoreServiceTreeDriven(
-      OIM_DEFAULT_KEY_TREE_WALK_SCALAR.getValue()
-    )
-  });
-}
-
-// src/factories/createOIMIndexServiceSortedArrayDriven.ts
-function createOIMIndexServiceSortedArrayDriven(db, options) {
-  const slotContentService = new OIMSlotContentBucketServiceSortedArrayDriven({
+// src/factories/createOIMSlotCollectionSortedArrayIndexService.ts
+function createOIMSlotCollectionSortedArrayIndexService(db, options) {
+  const slotContentService = new OIMSlotContentSortedArrayBucketService({
     compareBucketMemberSlots: oimEntitySlotsComparator(oimColumnsComparator(options.sortColumns))
   });
-  return new OIMIndexServiceSortedArrayDriven({
-    ...oimIndexServiceOptionsWithDefault(
+  return new OIMSlotCollectionSortedArrayIndexService({
+    ...oimSlotCollectionIndexServiceOptionsWithDefault(
       db,
       options,
       oimSlotStoreServiceWithDefault(options.bucketSlotStoreService),
@@ -4769,8 +4471,8 @@ function createOIMIndexServiceSortedArrayDriven(db, options) {
   });
 }
 
-// src/engine/index/OIMIndexKeysServiceReclaiming.ts
-var OIMIndexKeysServiceReclaiming = class extends OIMIndexKeysService {
+// src/engine/index/OIMReclaimingIndexKeysService.ts
+var OIMReclaimingIndexKeysService = class extends OIMIndexKeysService {
   allocatePosition(positions) {
     const freePosition = positions.freePositions.pop();
     return freePosition === void 0 ? positions.nextPosition++ : freePosition;
@@ -4806,13 +4508,13 @@ function deleteColumnsReplacing(slot, names) {
 function createOIMEntityWriterReplacing(options) {
   const {
     sameValueGuard,
-    entityInsertStrategy,
+    entityInserter,
     putEntityColumns,
     patchEntityColumns,
     patchEntityColumn
   } = oimEntityWriterOptionsWithDefault(options);
   return {
-    fillEntity: entityInsertStrategy,
+    fillEntity: entityInserter,
     clearEntity: oimClearEntity,
     putEntity: (slot, entity, changedColumnNames) => storeReplacement(slot, putEntityColumns(slot, entity, sameValueGuard, changedColumnNames, oimCopyEntity)),
     patchEntity: (slot, patch, changedColumnNames) => storeReplacement(slot, patchEntityColumns(slot, patch, sameValueGuard, changedColumnNames, oimCopyEntity)),
@@ -4878,191 +4580,231 @@ var OIM_SLICE_LENGTH_MS = 1024;
 // src/engine/collector/utils/oimSliceOfMs.ts
 var oimSliceOfMs = (ms) => Math.floor(ms / OIM_SLICE_LENGTH_MS);
 
-// src/engine/collector/OIMReleaseSlotQueueService.ts
-var _OIMReleaseSlotQueueService = class _OIMReleaseSlotQueueService {
-  scheduleSlotRelease(releaseSlotCollectorSlot, releaseSlotCollectorService, slot, nowMs) {
-    const releaseDueMs = releaseSlotCollectorService.getReleaseDueMs(slot);
-    if (releaseDueMs < 0) return;
-    const queuedSliceNumber = releaseSlotCollectorSlot.sliceNumberBySlot.get(slot);
-    if (queuedSliceNumber !== void 0 && queuedSliceNumber <= oimSliceOfMs(releaseDueMs)) return;
-    this.addToSliceNumber(releaseSlotCollectorSlot, oimSliceOfMs(Math.max(releaseDueMs, nowMs)), slot);
-    releaseSlotCollectorService.scheduleNextRelease(releaseSlotCollectorSlot);
-  }
-  cancelSlotRelease(releaseSlotCollectorSlot, slot) {
-    const sliceNumber = releaseSlotCollectorSlot.sliceNumberBySlot.get(slot);
-    if (sliceNumber === void 0) return;
-    releaseSlotCollectorSlot.sliceNumberBySlot.delete(slot);
-    this.removeFromSliceNumber(releaseSlotCollectorSlot, sliceNumber, slot);
-  }
-  getNextReleaseSliceNumber(releaseSlotCollectorSlot) {
-    if (releaseSlotCollectorSlot.nextSliceNumberNeedsRescan) {
+// src/engine/collector/OIMSlotWheel.ts
+var OIMSlotWheel = class {
+  constructor(options) {
+    this.scheduledCallback = void 0;
+    this.timerDisposer = void 0;
+    this.scheduledUntilMs = Number.POSITIVE_INFINITY;
+    this.slotsBySliceNumber = /* @__PURE__ */ new Map();
+    this.lastFiledSliceNumber = Number.NaN;
+    this.lastFiledSliceSlots = void 0;
+    this.floorSliceNumber = Number.NEGATIVE_INFINITY;
+    this.nextSliceNumber = void 0;
+    this.nextSliceNumberNeedsRescan = false;
+    this.timer = options.timer;
+    this.getNowMs = options.getNowMs;
+    this.errorPolicy = options.errorPolicy;
+  }
+  getNextSliceNumber() {
+    if (this.nextSliceNumberNeedsRescan) {
       let nextSliceNumber;
-      for (const sliceNumber of releaseSlotCollectorSlot.slotsBySliceNumber.keys()) {
+      for (const sliceNumber of this.slotsBySliceNumber.keys()) {
         if (nextSliceNumber === void 0 || sliceNumber < nextSliceNumber) nextSliceNumber = sliceNumber;
       }
-      releaseSlotCollectorSlot.nextSliceNumber = nextSliceNumber;
-      releaseSlotCollectorSlot.nextSliceNumberNeedsRescan = false;
+      this.nextSliceNumber = nextSliceNumber;
+      this.nextSliceNumberNeedsRescan = false;
     }
-    return releaseSlotCollectorSlot.nextSliceNumber;
-  }
-  cancelAllSlotReleases(releaseSlotCollectorSlot) {
-    releaseSlotCollectorSlot.slotsBySliceNumber.clear();
-    releaseSlotCollectorSlot.sliceNumberBySlot.clear();
-    releaseSlotCollectorSlot.nextSliceNumber = void 0;
-    releaseSlotCollectorSlot.nextSliceNumberNeedsRescan = false;
+    return this.nextSliceNumber;
   }
-  isSlotReleaseScheduled(releaseSlotCollectorSlot, slot) {
-    return releaseSlotCollectorSlot.sliceNumberBySlot.has(slot);
-  }
-  releaseDueUpToSliceNumber(releaseSlotCollectorSlot, releaseSlotCollectorService, upToSliceNumber) {
-    const nextSliceNumber = this.getNextReleaseSliceNumber(releaseSlotCollectorSlot);
+  sweepUpToSliceNumber(upToSliceNumber) {
+    const nextSliceNumber = this.getNextSliceNumber();
     if (nextSliceNumber === void 0 || nextSliceNumber > upToSliceNumber) return;
-    const outerFloor = releaseSlotCollectorSlot.floorSliceNumber;
-    releaseSlotCollectorSlot.floorSliceNumber = upToSliceNumber + 1;
-    const slotsBySliceNumber = releaseSlotCollectorSlot.slotsBySliceNumber;
+    const outerFloor = this.floorSliceNumber;
+    this.floorSliceNumber = upToSliceNumber + 1;
+    const slotsBySliceNumber = this.slotsBySliceNumber;
     try {
       if (upToSliceNumber - nextSliceNumber < slotsBySliceNumber.size) {
         for (let sliceNumber = nextSliceNumber; sliceNumber <= upToSliceNumber; sliceNumber++) {
           const sliceSlots = slotsBySliceNumber.get(sliceNumber);
-          if (sliceSlots !== void 0) this.releaseSlice(releaseSlotCollectorSlot, releaseSlotCollectorService, sliceNumber, sliceSlots);
+          if (sliceSlots !== void 0) this.sweepSlice(sliceNumber, sliceSlots);
         }
       } else {
         for (const [sliceNumber, sliceSlots] of slotsBySliceNumber) {
-          if (sliceNumber <= upToSliceNumber) this.releaseSlice(releaseSlotCollectorSlot, releaseSlotCollectorService, sliceNumber, sliceSlots);
+          if (sliceNumber <= upToSliceNumber) this.sweepSlice(sliceNumber, sliceSlots);
         }
       }
     } finally {
-      releaseSlotCollectorSlot.floorSliceNumber = outerFloor;
+      this.floorSliceNumber = outerFloor;
     }
+    this.onSweepFinished();
   }
-  releaseSlice(releaseSlotCollectorSlot, releaseSlotCollectorService, sliceNumber, sliceSlots) {
-    releaseSlotCollectorSlot.slotsBySliceNumber.delete(sliceNumber);
-    this.invalidateNextSliceNumber(releaseSlotCollectorSlot, sliceNumber);
-    const nowMs = releaseSlotCollectorSlot.getNowMs();
-    const sliceNumberBySlot = releaseSlotCollectorSlot.sliceNumberBySlot;
+  flush() {
+    this.cancelSlotWheelSchedule();
     try {
-      for (const slot of sliceSlots) {
-        sliceSlots.delete(slot);
-        if (sliceNumberBySlot.get(slot) === sliceNumber) sliceNumberBySlot.delete(slot);
-        if (oimIsSlotReleased(slot)) continue;
-        const releaseDueMs = releaseSlotCollectorService.getReleaseDueMs(slot);
-        if (releaseDueMs < 0) continue;
-        if (releaseDueMs > nowMs) {
-          this.addToSliceNumber(releaseSlotCollectorSlot, oimSliceOfMs(releaseDueMs), slot);
-          continue;
-        }
-        slot.owner.releaseSlotIfUnheld(slot);
-      }
+      this.sweepUpToSliceNumber(this.getSweptSliceNumberAt(this.getNowMs()));
     } finally {
-      if (sliceSlots.size !== 0) {
-        releaseSlotCollectorSlot.slotsBySliceNumber.set(sliceNumber, sliceSlots);
-        this.updateNextSliceNumber(releaseSlotCollectorSlot, sliceNumber);
+      this.scheduleNextSweep();
+    }
+  }
+  cancelAllSlots() {
+    this.cancelSlotWheelSchedule();
+    for (const sliceSlots of this.slotsBySliceNumber.values()) {
+      for (let index = 0; index < sliceSlots.length; index++) this.onSlotDropped(sliceSlots[index]);
+    }
+    this.slotsBySliceNumber.clear();
+    this.lastFiledSliceSlots = void 0;
+    this.nextSliceNumber = void 0;
+    this.nextSliceNumberNeedsRescan = false;
+  }
+  fileSlot(sliceNumber, slot) {
+    const flooredSliceNumber = Math.max(sliceNumber, this.floorSliceNumber);
+    let sliceSlots = flooredSliceNumber === this.lastFiledSliceNumber ? this.lastFiledSliceSlots : void 0;
+    if (sliceSlots === void 0) {
+      sliceSlots = this.slotsBySliceNumber.get(flooredSliceNumber);
+      if (sliceSlots === void 0) {
+        sliceSlots = [];
+        this.slotsBySliceNumber.set(flooredSliceNumber, sliceSlots);
       }
+      this.lastFiledSliceNumber = flooredSliceNumber;
+      this.lastFiledSliceSlots = sliceSlots;
+    }
+    sliceSlots.push(slot);
+    this.lowerNextSliceNumber(flooredSliceNumber);
+  }
+  scheduleNextSweep() {
+    const nextSliceNumber = this.getNextSliceNumber();
+    if (nextSliceNumber === void 0) return;
+    const nowMs = this.getNowMs();
+    const untilMs = Math.max(nowMs, (nextSliceNumber + 1) * OIM_SLICE_LENGTH_MS);
+    if (OIMFlushSchedulerService.INSTANCE.isScheduled(this)) {
+      if (untilMs >= this.scheduledUntilMs) return;
+      this.cancelSlotWheelSchedule();
     }
+    this.scheduledUntilMs = untilMs;
+    OIMFlushSchedulerService.INSTANCE.schedule(this, untilMs - nowMs, this);
   }
-  removeFromSliceNumber(releaseSlotCollectorSlot, sliceNumber, slot) {
-    const sliceSlots = releaseSlotCollectorSlot.slotsBySliceNumber.get(sliceNumber);
-    if (sliceSlots === void 0) return;
-    sliceSlots.delete(slot);
-    if (sliceSlots.size !== 0) return;
-    releaseSlotCollectorSlot.slotsBySliceNumber.delete(sliceNumber);
-    this.invalidateNextSliceNumber(releaseSlotCollectorSlot, sliceNumber);
+  cancelSlotWheelSchedule() {
+    this.scheduledUntilMs = Number.POSITIVE_INFINITY;
+    OIMFlushSchedulerService.INSTANCE.cancelSchedule(this);
   }
-  updateNextSliceNumber(releaseSlotCollectorSlot, sliceNumber) {
-    const nextSliceNumber = releaseSlotCollectorSlot.nextSliceNumber;
-    if (nextSliceNumber === void 0 || sliceNumber <= nextSliceNumber) {
-      releaseSlotCollectorSlot.nextSliceNumber = sliceNumber;
-      releaseSlotCollectorSlot.nextSliceNumberNeedsRescan = false;
+  onSchedulerTimerFired() {
+    try {
+      this.flush();
+    } catch (error) {
+      this.errorPolicy.onErrorCaught(error);
     }
   }
-  invalidateNextSliceNumber(releaseSlotCollectorSlot, sliceNumber) {
-    if (sliceNumber === releaseSlotCollectorSlot.nextSliceNumber) releaseSlotCollectorSlot.nextSliceNumberNeedsRescan = true;
+  getSweptSliceNumberAt(nowMs) {
+    return oimSliceOfMs(nowMs);
   }
-  addToSliceNumber(releaseSlotCollectorSlot, sliceNumber, slot) {
-    const flooredSliceNumber = Math.max(sliceNumber, releaseSlotCollectorSlot.floorSliceNumber);
-    const sliceNumberBySlot = releaseSlotCollectorSlot.sliceNumberBySlot;
-    const prevSliceNumber = sliceNumberBySlot.get(slot);
-    if (prevSliceNumber !== void 0) this.removeFromSliceNumber(releaseSlotCollectorSlot, prevSliceNumber, slot);
-    const slotsBySliceNumber = releaseSlotCollectorSlot.slotsBySliceNumber;
-    let sliceSlots = slotsBySliceNumber.get(flooredSliceNumber);
-    if (sliceSlots === void 0) {
-      sliceSlots = /* @__PURE__ */ new Set();
-      slotsBySliceNumber.set(flooredSliceNumber, sliceSlots);
+  onSlotDropped(_slot) {
+    return;
+  }
+  onSweepFinished() {
+    return;
+  }
+  lowerNextSliceNumber(sliceNumber) {
+    const nextSliceNumber = this.nextSliceNumber;
+    if (nextSliceNumber === void 0 || sliceNumber <= nextSliceNumber) {
+      this.nextSliceNumber = sliceNumber;
+      this.nextSliceNumberNeedsRescan = false;
+    }
+  }
+  sweepSlice(sliceNumber, sliceSlots) {
+    this.slotsBySliceNumber.delete(sliceNumber);
+    if (this.lastFiledSliceSlots === sliceSlots) this.lastFiledSliceSlots = void 0;
+    if (sliceNumber === this.nextSliceNumber) this.nextSliceNumberNeedsRescan = true;
+    const nowMs = this.getNowMs();
+    let index = 0;
+    try {
+      for (; index < sliceSlots.length; index++) this.onSlotDue(sliceSlots[index], nowMs);
+    } finally {
+      if (index < sliceSlots.length - 1) {
+        this.slotsBySliceNumber.set(sliceNumber, sliceSlots.slice(index + 1));
+        this.lowerNextSliceNumber(sliceNumber);
+      }
     }
-    sliceSlots.add(slot);
-    sliceNumberBySlot.set(slot, flooredSliceNumber);
-    this.updateNextSliceNumber(releaseSlotCollectorSlot, flooredSliceNumber);
   }
 };
-_OIMReleaseSlotQueueService.INSTANCE = new _OIMReleaseSlotQueueService();
-var OIMReleaseSlotQueueService = _OIMReleaseSlotQueueService;
 
-// src/engine/collector/OIMReleaseSlotCollectorService.ts
-var OIMReleaseSlotCollectorService = class extends OIMFlushSchedulerService {
-  getReleaseSlotCollectorSlotOf(slot) {
-    return this.getReleaseSlotCollectorSlot(oimGetChannelSlot(slot).collectorSlot);
+// src/engine/collector/OIMSlotReleaseWheel.ts
+var OIMSlotReleaseWheel = class extends OIMSlotWheel {
+  constructor(options) {
+    super(options);
+    this.getReleaseDueMs = options.getReleaseDueMs;
+    this.setReleaseDueMs = options.setReleaseDueMs;
+    this.releaseScheduledSlotFlag = options.releaseScheduledSlotFlag;
   }
-  markSlotReleaseDue(releaseSlotCollectorSlot, slot, keepMs) {
-    const nowMs = releaseSlotCollectorSlot.getNowMs();
+  markSlotReleaseDue(slot, keepMs) {
+    const nowMs = this.getNowMs();
     this.setReleaseDueMs(slot, nowMs + keepMs);
     return nowMs;
   }
-  scheduleSlotRelease(releaseSlotCollectorSlot, slot, nowMs) {
-    OIMReleaseSlotQueueService.INSTANCE.scheduleSlotRelease(releaseSlotCollectorSlot, this, slot, nowMs);
+  markSlotReleaseDueNow(slot) {
+    this.setReleaseDueMs(slot, this.getNowMs());
+    slot.owner.releaseSlotIfUnheld(slot);
+  }
+  scheduleSlotRelease(slot, nowMs) {
+    const releaseDueMs = this.getReleaseDueMs(slot);
+    if (releaseDueMs < 0) return;
+    if ((slot.slotFlags & this.releaseScheduledSlotFlag) !== 0) return;
+    this.fileReleaseSlot(oimSliceOfMs(Math.max(releaseDueMs, nowMs)), slot);
+    this.scheduleNextSweep();
   }
-  isSlotReleasable(releaseSlotCollectorSlot, slot) {
+  isSlotReleasable(slot) {
     const releaseDueMs = this.getReleaseDueMs(slot);
     if (releaseDueMs < 0) return false;
-    const nowMs = releaseSlotCollectorSlot.getNowMs();
+    const nowMs = this.getNowMs();
     if (releaseDueMs <= nowMs) return true;
-    OIMReleaseSlotQueueService.INSTANCE.scheduleSlotRelease(releaseSlotCollectorSlot, this, slot, nowMs);
+    this.scheduleSlotRelease(slot, nowMs);
     return false;
   }
-  cancelSlotRelease(releaseSlotCollectorSlot, slot) {
+  cancelSlotRelease(slot) {
     if (this.getReleaseDueMs(slot) < 0) return;
-    OIMReleaseSlotQueueService.INSTANCE.cancelSlotRelease(releaseSlotCollectorSlot, slot);
-  }
-  scheduleNextRelease(releaseSlotCollectorSlot) {
-    const nextSliceNumber = OIMReleaseSlotQueueService.INSTANCE.getNextReleaseSliceNumber(releaseSlotCollectorSlot);
-    if (nextSliceNumber === void 0) return;
-    const nowMs = releaseSlotCollectorSlot.getNowMs();
-    const untilMs = Math.max(nowMs, (nextSliceNumber + 1) * OIM_SLICE_LENGTH_MS);
-    if (this.isScheduled(releaseSlotCollectorSlot)) {
-      if (untilMs >= releaseSlotCollectorSlot.scheduledUntilMs) return;
-      this.cancelSchedule(releaseSlotCollectorSlot);
-    }
-    releaseSlotCollectorSlot.scheduledUntilMs = untilMs;
-    this.schedule(releaseSlotCollectorSlot, untilMs - nowMs);
+    slot.slotFlags &= ~this.releaseScheduledSlotFlag;
   }
-  cancelSchedule(releaseSlotCollectorSlot) {
-    releaseSlotCollectorSlot.scheduledUntilMs = Number.POSITIVE_INFINITY;
-    super.cancelSchedule(releaseSlotCollectorSlot);
+  isSlotReleaseScheduled(slot) {
+    return (slot.slotFlags & this.releaseScheduledSlotFlag) !== 0;
   }
-  flush(releaseSlotCollectorSlot) {
-    this.cancelSchedule(releaseSlotCollectorSlot);
-    try {
-      OIMReleaseSlotQueueService.INSTANCE.releaseDueUpToSliceNumber(
-        releaseSlotCollectorSlot,
-        this,
-        oimSliceOfMs(releaseSlotCollectorSlot.getNowMs())
-      );
-    } finally {
-      this.scheduleNextRelease(releaseSlotCollectorSlot);
+  onSlotDue(slot, nowMs) {
+    const slotFlags = slot.slotFlags;
+    if ((slotFlags & this.releaseScheduledSlotFlag) === 0) return;
+    slot.slotFlags = slotFlags & ~this.releaseScheduledSlotFlag;
+    if (oimIsSlotReleased(slot)) return;
+    const releaseDueMs = this.getReleaseDueMs(slot);
+    if (releaseDueMs < 0) return;
+    if (releaseDueMs > nowMs) {
+      this.fileReleaseSlot(oimSliceOfMs(releaseDueMs), slot);
+      return;
     }
+    slot.owner.releaseSlotIfUnheld(slot);
   }
-  onSchedulerTimerFired(releaseSlotCollectorSlot) {
-    try {
-      this.flush(releaseSlotCollectorSlot);
-    } catch (error) {
-      releaseSlotCollectorSlot.errorPolicy.onErrorCaught(error);
-    }
+  onSlotDropped(slot) {
+    slot.slotFlags &= ~this.releaseScheduledSlotFlag;
   }
-  cancelAllSlotReleases(releaseSlotCollectorSlot) {
-    this.cancelSchedule(releaseSlotCollectorSlot);
-    OIMReleaseSlotQueueService.INSTANCE.cancelAllSlotReleases(releaseSlotCollectorSlot);
+  fileReleaseSlot(sliceNumber, slot) {
+    this.fileSlot(sliceNumber, slot);
+    slot.slotFlags |= this.releaseScheduledSlotFlag;
   }
 };
 
+// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_WRITE.ts
+var OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_WRITE = 8;
+
+// src/engine/slot/utils/oimGetReleaseDueAfterWriteMs.ts
+function oimGetReleaseDueAfterWriteMs(slot) {
+  return slot.releaseDueAfterWriteMs;
+}
+
+// src/engine/slot/utils/oimSetReleaseDueAfterWriteMs.ts
+function oimSetReleaseDueAfterWriteMs(slot, releaseDueMs) {
+  slot.releaseDueAfterWriteMs = releaseDueMs;
+}
+
+// src/engine/collector/utils/oimMintAfterWriteSlotReleaseWheel.ts
+function oimMintAfterWriteSlotReleaseWheel(collectorSlot) {
+  return collectorSlot.afterWriteSlotReleaseWheel ?? (collectorSlot.afterWriteSlotReleaseWheel = new OIMSlotReleaseWheel({
+    ...collectorSlot.slotWheelOptions,
+    getReleaseDueMs: oimGetReleaseDueAfterWriteMs,
+    setReleaseDueMs: oimSetReleaseDueAfterWriteMs,
+    releaseScheduledSlotFlag: OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_WRITE
+  }));
+}
+
+// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_IDLE.ts
+var OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_IDLE = 4;
+
 // src/engine/slot/utils/oimGetReleaseDueAfterIdleMs.ts
 function oimGetReleaseDueAfterIdleMs(slot) {
   return slot.releaseDueAfterIdleMs;
@@ -5073,73 +4815,142 @@ function oimSetReleaseDueAfterIdleMs(slot, releaseDueMs) {
   slot.releaseDueAfterIdleMs = releaseDueMs;
 }
 
-// src/engine/collector/OIMReleaseSlotCollectorServiceAfterIdle.ts
-var _OIMReleaseSlotCollectorServiceAfterIdle = class _OIMReleaseSlotCollectorServiceAfterIdle extends OIMReleaseSlotCollectorService {
-  constructor() {
-    super(...arguments);
-    this.getReleaseDueMs = oimGetReleaseDueAfterIdleMs;
-    this.setReleaseDueMs = oimSetReleaseDueAfterIdleMs;
-  }
-  getReleaseSlotCollectorSlot(collectorSlot) {
-    return collectorSlot.afterIdleReleaseSlotCollectorSlot;
-  }
-};
-_OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE = new _OIMReleaseSlotCollectorServiceAfterIdle();
-var OIMReleaseSlotCollectorServiceAfterIdle = _OIMReleaseSlotCollectorServiceAfterIdle;
+// src/engine/collector/utils/oimMintAfterIdleSlotReleaseWheel.ts
+function oimMintAfterIdleSlotReleaseWheel(collectorSlot) {
+  return collectorSlot.afterIdleSlotReleaseWheel ?? (collectorSlot.afterIdleSlotReleaseWheel = new OIMSlotReleaseWheel({
+    ...collectorSlot.slotWheelOptions,
+    getReleaseDueMs: oimGetReleaseDueAfterIdleMs,
+    setReleaseDueMs: oimSetReleaseDueAfterIdleMs,
+    releaseScheduledSlotFlag: OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_IDLE
+  }));
+}
 
-// src/engine/slot/utils/oimGetReleaseDueAfterWriteMs.ts
-function oimGetReleaseDueAfterWriteMs(slot) {
-  return slot.releaseDueAfterWriteMs;
+// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_UNHOLD.ts
+var OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_UNHOLD = 16;
+
+// src/engine/slot/utils/oimGetReleaseDueAfterUnholdMs.ts
+function oimGetReleaseDueAfterUnholdMs(slot) {
+  return slot.releaseDueAfterUnholdMs;
 }
 
-// src/engine/slot/utils/oimSetReleaseDueAfterWriteMs.ts
-function oimSetReleaseDueAfterWriteMs(slot, releaseDueMs) {
-  slot.releaseDueAfterWriteMs = releaseDueMs;
+// src/engine/slot/utils/oimSetReleaseDueAfterUnholdMs.ts
+function oimSetReleaseDueAfterUnholdMs(slot, releaseDueMs) {
+  slot.releaseDueAfterUnholdMs = releaseDueMs;
 }
 
-// src/engine/collector/OIMReleaseSlotCollectorServiceAfterWrite.ts
-var _OIMReleaseSlotCollectorServiceAfterWrite = class _OIMReleaseSlotCollectorServiceAfterWrite extends OIMReleaseSlotCollectorService {
-  constructor() {
-    super(...arguments);
-    this.getReleaseDueMs = oimGetReleaseDueAfterWriteMs;
-    this.setReleaseDueMs = oimSetReleaseDueAfterWriteMs;
+// src/engine/collector/utils/oimMintAfterUnholdSlotReleaseWheel.ts
+function oimMintAfterUnholdSlotReleaseWheel(collectorSlot) {
+  return collectorSlot.afterUnholdSlotReleaseWheel ?? (collectorSlot.afterUnholdSlotReleaseWheel = new OIMSlotReleaseWheel({
+    ...collectorSlot.slotWheelOptions,
+    getReleaseDueMs: oimGetReleaseDueAfterUnholdMs,
+    setReleaseDueMs: oimSetReleaseDueAfterUnholdMs,
+    releaseScheduledSlotFlag: OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_UNHOLD
+  }));
+}
+
+// src/engine/collector/OIMSlotRefetchWheel.ts
+var OIMSlotRefetchWheel = class extends OIMSlotWheel {
+  constructor(options) {
+    super({
+      getNowMs: options.getNowMs ?? Date.now,
+      timer: options.timer ?? OIM_TIMER_ON_TIMEOUT,
+      errorPolicy: options.errorPolicy ?? OIMLogAndContinueErrorPolicy.INSTANCE
+    });
+    this.refetchDueSlots = [];
+    this.slotRefetchListener = options.slotRefetchListener;
+  }
+  scheduleSlotRefetchAt(slot, atMs) {
+    this.fileSlot(oimSliceOfMs(atMs), slot);
+    this.scheduleNextSweep();
+  }
+  getSweptSliceNumberAt(nowMs) {
+    return oimSliceOfMs(nowMs) - 1;
+  }
+  onSlotDue(slot) {
+    if (oimIsSlotReleased(slot)) return;
+    if (slot.effects === void 0 || slot.effects.length === 0) return;
+    this.refetchDueSlots.push(slot);
+  }
+  onSweepFinished() {
+    const refetchDueSlots = this.refetchDueSlots;
+    if (refetchDueSlots.length === 0) return;
+    try {
+      this.slotRefetchListener.onSlotsRefetchDue(refetchDueSlots);
+    } finally {
+      refetchDueSlots.length = 0;
+    }
   }
-  getReleaseSlotCollectorSlot(collectorSlot) {
-    return collectorSlot.afterWriteReleaseSlotCollectorSlot;
+};
+
+// src/engine/collector/OIMSlotReleaseAutoDueFramePolicy.ts
+var _OIMSlotReleaseAutoDueFramePolicy = class _OIMSlotReleaseAutoDueFramePolicy {
+  isSlotReleaseDueFrameOpen() {
+    return true;
   }
 };
-_OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE = new _OIMReleaseSlotCollectorServiceAfterWrite();
-var OIMReleaseSlotCollectorServiceAfterWrite = _OIMReleaseSlotCollectorServiceAfterWrite;
+_OIMSlotReleaseAutoDueFramePolicy.INSTANCE = new _OIMSlotReleaseAutoDueFramePolicy();
+var OIMSlotReleaseAutoDueFramePolicy = _OIMSlotReleaseAutoDueFramePolicy;
 
-// src/engine/collector/OIMSlotReleasePolicyAfterWrite.ts
-var OIMSlotReleasePolicyAfterWrite = class {
+// src/engine/collector/OIMSlotAfterWriteReleasePolicy.ts
+var OIMSlotAfterWriteReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
     this.schedulesReleaseOnWrite = true;
     this.keepAfterWriteMs = options.keepAfterWriteMs;
+    this.slotReleaseDueFramePolicy = options.slotReleaseDueFramePolicy ?? OIMSlotReleaseAutoDueFramePolicy.INSTANCE;
   }
   onSlotWritten(slot) {
-    OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.markSlotReleaseDue(OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot, this.keepAfterWriteMs);
+    if (!this.slotReleaseDueFramePolicy.isSlotReleaseDueFrameOpen()) return;
+    oimMintAfterWriteSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).markSlotReleaseDue(slot, this.keepAfterWriteMs);
   }
   onSlotIdle(slot) {
-    return OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.isSlotReleasable(OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    return oimMintAfterWriteSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).isSlotReleasable(slot);
   }
   onSlotUnheld() {
     return;
   }
   isSlotReleasable(slot) {
-    return OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.isSlotReleasable(OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    return oimMintAfterWriteSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).isSlotReleasable(slot);
   }
   isEmptySlotReleasable() {
     return true;
   }
   cancelSlotRelease(slot) {
-    OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.cancelSlotRelease(OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    oimMintAfterWriteSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).cancelSlotRelease(slot);
+  }
+};
+
+// src/engine/collector/OIMSlotReleaseManualDueFramePolicy.ts
+var OIMSlotReleaseManualDueFramePolicy = class {
+  constructor() {
+    this.slotReleaseDueFrameDepth = 0;
+  }
+  isSlotReleaseDueFrameOpen() {
+    return this.slotReleaseDueFrameDepth !== 0;
+  }
+  openSlotReleaseDueFrame() {
+    this.slotReleaseDueFrameDepth++;
+  }
+  closeSlotReleaseDueFrame() {
+    if (this.slotReleaseDueFrameDepth === 0) {
+      throw new Error(
+        "OIMSlotReleaseManualDueFramePolicy.closeSlotReleaseDueFrame: no frame is open. Every closeSlotReleaseDueFrame answers one openSlotReleaseDueFrame."
+      );
+    }
+    this.slotReleaseDueFrameDepth--;
+  }
+  writeInSlotReleaseDueFrame(write) {
+    this.openSlotReleaseDueFrame();
+    try {
+      write();
+    } finally {
+      this.closeSlotReleaseDueFrame();
+    }
   }
 };
 
-// src/engine/collector/OIMSlotReleasePolicyAfterIdle.ts
-var OIMSlotReleasePolicyAfterIdle = class {
+// src/engine/collector/OIMSlotAfterIdleReleasePolicy.ts
+var OIMSlotAfterIdleReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
     this.schedulesReleaseOnWrite = true;
@@ -5149,29 +4960,28 @@ var OIMSlotReleasePolicyAfterIdle = class {
     return;
   }
   onSlotIdle(slot) {
-    const releaseSlotCollectorService = OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE;
-    const releaseSlotCollectorSlot = OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.getReleaseSlotCollectorSlotOf(slot);
-    const nowMs = releaseSlotCollectorService.markSlotReleaseDue(releaseSlotCollectorSlot, slot, this.keepAfterIdleMs);
+    const afterIdleSlotReleaseWheel = oimMintAfterIdleSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot);
+    const nowMs = afterIdleSlotReleaseWheel.markSlotReleaseDue(slot, this.keepAfterIdleMs);
     if (this.keepAfterIdleMs <= 0) return true;
-    releaseSlotCollectorService.scheduleSlotRelease(releaseSlotCollectorSlot, slot, nowMs);
+    afterIdleSlotReleaseWheel.scheduleSlotRelease(slot, nowMs);
     return false;
   }
   onSlotUnheld() {
     return;
   }
   isSlotReleasable(slot) {
-    return OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.isSlotReleasable(OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    return oimMintAfterIdleSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).isSlotReleasable(slot);
   }
   isEmptySlotReleasable() {
     return true;
   }
   cancelSlotRelease(slot) {
-    OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.cancelSlotRelease(OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    oimMintAfterIdleSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).cancelSlotRelease(slot);
   }
 };
 
-// src/engine/collector/OIMSlotReleasePolicyNever.ts
-var _OIMSlotReleasePolicyNever = class _OIMSlotReleasePolicyNever {
+// src/engine/collector/OIMSlotNeverReleasePolicy.ts
+var _OIMSlotNeverReleasePolicy = class _OIMSlotNeverReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = false;
     this.schedulesReleaseOnWrite = false;
@@ -5195,35 +5005,11 @@ var _OIMSlotReleasePolicyNever = class _OIMSlotReleasePolicyNever {
     return;
   }
 };
-_OIMSlotReleasePolicyNever.INSTANCE = new _OIMSlotReleasePolicyNever();
-var OIMSlotReleasePolicyNever = _OIMSlotReleasePolicyNever;
-
-// src/engine/slot/utils/oimGetReleaseDueAfterUnholdMs.ts
-function oimGetReleaseDueAfterUnholdMs(slot) {
-  return slot.releaseDueAfterUnholdMs;
-}
-
-// src/engine/slot/utils/oimSetReleaseDueAfterUnholdMs.ts
-function oimSetReleaseDueAfterUnholdMs(slot, releaseDueMs) {
-  slot.releaseDueAfterUnholdMs = releaseDueMs;
-}
-
-// src/engine/collector/OIMReleaseSlotCollectorServiceAfterUnhold.ts
-var _OIMReleaseSlotCollectorServiceAfterUnhold = class _OIMReleaseSlotCollectorServiceAfterUnhold extends OIMReleaseSlotCollectorService {
-  constructor() {
-    super(...arguments);
-    this.getReleaseDueMs = oimGetReleaseDueAfterUnholdMs;
-    this.setReleaseDueMs = oimSetReleaseDueAfterUnholdMs;
-  }
-  getReleaseSlotCollectorSlot(collectorSlot) {
-    return collectorSlot.afterUnholdReleaseSlotCollectorSlot;
-  }
-};
-_OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE = new _OIMReleaseSlotCollectorServiceAfterUnhold();
-var OIMReleaseSlotCollectorServiceAfterUnhold = _OIMReleaseSlotCollectorServiceAfterUnhold;
+_OIMSlotNeverReleasePolicy.INSTANCE = new _OIMSlotNeverReleasePolicy();
+var OIMSlotNeverReleasePolicy = _OIMSlotNeverReleasePolicy;
 
-// src/engine/collector/OIMSlotReleasePolicyAfterUnhold.ts
-var OIMSlotReleasePolicyAfterUnhold = class {
+// src/engine/collector/OIMSlotAfterUnholdReleasePolicy.ts
+var OIMSlotAfterUnholdReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
     this.schedulesReleaseOnWrite = false;
@@ -5236,24 +5022,24 @@ var OIMSlotReleasePolicyAfterUnhold = class {
     return false;
   }
   onSlotUnheld(slot) {
-    OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.markSlotReleaseDue(OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot, this.keepAfterUnholdMs);
+    oimMintAfterUnholdSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).markSlotReleaseDue(slot, this.keepAfterUnholdMs);
   }
   isSlotReleasable(slot) {
-    return OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.isSlotReleasable(OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    return oimMintAfterUnholdSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).isSlotReleasable(slot);
   }
   isEmptySlotReleasable() {
     return true;
   }
   cancelSlotRelease(slot) {
-    OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.cancelSlotRelease(OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE.getReleaseSlotCollectorSlotOf(slot), slot);
+    oimMintAfterUnholdSlotReleaseWheel(oimGetChannelSlot(slot).collectorSlot).cancelSlotRelease(slot);
   }
 };
 
-// src/engine/collector/OIMSlotReleasePolicyEarliest.ts
+// src/engine/collector/OIMSlotEarliestReleasePolicy.ts
 var askOnSlotIdle = (slotReleasePolicy, slot) => slotReleasePolicy.onSlotIdle(slot);
 var askIsSlotReleasable = (slotReleasePolicy, slot) => slotReleasePolicy.isSlotReleasable(slot);
 var askIsEmptySlotReleasable = (slotReleasePolicy, slot) => slotReleasePolicy.isEmptySlotReleasable(slot);
-var OIMSlotReleasePolicyEarliest = class {
+var OIMSlotEarliestReleasePolicy = class {
   constructor(slotReleasePolicies) {
     this.slotReleasePolicies = slotReleasePolicies;
     let releasesWrittenSlots = false;
@@ -5296,52 +5082,48 @@ var OIMSlotReleasePolicyEarliest = class {
   }
 };
 
-// src/engine/bucket/utils/oimSameUniqueSlotSequence.ts
-function oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots) {
-  const seenBucketMemberSlots = /* @__PURE__ */ new Set();
-  let at = 0;
-  for (let i = 0; i < bucketMemberSlots.length; i++) {
-    const bucketMemberSlot = bucketMemberSlots[i];
-    if (seenBucketMemberSlots.has(bucketMemberSlot)) continue;
-    seenBucketMemberSlots.add(bucketMemberSlot);
-    if (at >= heldBucketMemberSlots.length || heldBucketMemberSlots[at] !== bucketMemberSlot) return false;
-    at++;
+// src/engine/store/OIMSlotTreeStoreService.ts
+var OIMSlotTreeStoreService = class {
+  constructor(keyTreeWalk) {
+    this.keyTreeWalk = keyTreeWalk;
   }
-  return at === heldBucketMemberSlots.length;
-}
-
-// src/engine/bucket/array/OIMBucketArrayMembershipUnique.ts
-var OIMBucketArrayMembershipUnique = class {
   createStore() {
-    return {
-      bucketMemberSlots: [],
-      uniqueBucketMemberSlots: /* @__PURE__ */ new Set()
-    };
+    return { root: { childNodes: void 0, atThisKey: void 0 }, slots: /* @__PURE__ */ new Set() };
   }
-  addSlot(bucketSlotsArrayUniqueStore, bucketMemberSlot) {
-    if (bucketSlotsArrayUniqueStore.uniqueBucketMemberSlots.has(bucketMemberSlot)) return false;
-    bucketSlotsArrayUniqueStore.uniqueBucketMemberSlots.add(bucketMemberSlot);
-    return true;
+  ownKey(compositeKey) {
+    return compositeKey.slice();
+  }
+  isSameKey(compositeKey, otherCompositeKey) {
+    return oimSameKeySequence(compositeKey, otherCompositeKey);
+  }
+  get(slotStoreTree, compositeKey) {
+    return this.keyTreeWalk.nodeAt(slotStoreTree.root, compositeKey)?.atThisKey;
+  }
+  set(slotStoreTree, compositeKey, slot) {
+    const compositeKeyNode = this.keyTreeWalk.mintNodeAt(slotStoreTree.root, compositeKey);
+    const filedSlot = compositeKeyNode.atThisKey;
+    if (filedSlot !== void 0 && filedSlot !== slot) slotStoreTree.slots.delete(filedSlot);
+    compositeKeyNode.atThisKey = slot;
+    slotStoreTree.slots.add(slot);
   }
-  removeSlot(bucketSlotsArrayUniqueStore, bucketMemberSlot) {
-    return bucketSlotsArrayUniqueStore.uniqueBucketMemberSlots.delete(bucketMemberSlot);
+  remove(slotStoreTree, compositeKey) {
+    const slot = this.keyTreeWalk.deleteKey(slotStoreTree.root, compositeKey);
+    if (slot !== void 0) slotStoreTree.slots.delete(slot);
   }
-  hasSlot(bucketSlotsArrayUniqueStore, bucketMemberSlot) {
-    return bucketSlotsArrayUniqueStore.uniqueBucketMemberSlots.has(bucketMemberSlot);
+  fileSlot(slotStoreTree, slot) {
+    this.set(slotStoreTree, slot.key, slot);
   }
-  clearSlots(bucketSlotsArrayUniqueStore) {
-    bucketSlotsArrayUniqueStore.uniqueBucketMemberSlots.clear();
+  unfileSlot(slotStoreTree, slot) {
+    this.remove(slotStoreTree, slot.key);
   }
-  containsTheSameSequence(bucketSlotsArrayUniqueStore, bucketMemberSlots) {
-    const heldBucketMemberSlots = bucketSlotsArrayUniqueStore.bucketMemberSlots;
-    if (bucketMemberSlots.length < heldBucketMemberSlots.length) return false;
-    return oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots);
+  getSlots(slotStoreTree) {
+    return slotStoreTree.slots.values();
+  }
+  getSlotCount(slotStoreTree) {
+    return slotStoreTree.slots.size;
   }
 };
 
-// src/engine/bucket/constants/OIM_NOTHING_WAS_INSERTED.ts
-var OIM_NOTHING_WAS_INSERTED = -1;
-
 // src/engine/bucket/commands/constants/OIM_MAX_DIFF_SCRATCH_SLOTS.ts
 var OIM_MAX_DIFF_SCRATCH_SLOTS = 4096;
 
@@ -5446,82 +5228,81 @@ function collectAnchors(sequence, count, anchorBuffer) {
 // src/index.ts
 oimRegisterCoreInstance(OIMDB);
 export {
-  OIMBucketArrayMembershipNonUnique,
-  OIMBucketArrayMembershipUnique,
+  OIMAppendingIndexKeysService,
   OIMBucketCommands,
+  OIMBucketMemberSlotsArrayService,
+  OIMBucketMemoComputedService,
+  OIMBucketUniqueMemberSlotsArrayService,
   OIMChannelService,
-  OIMColumnOwner,
-  OIMColumnOwnerPullDriven,
+  OIMColumnSlotOwner,
+  OIMColumnSlotService,
+  OIMCompositeKeyTreeWalk,
   OIMComputedService,
-  OIMComputedServiceBucketMemo,
-  OIMComputedServiceSorted,
   OIMComputedValueService,
   OIMContentChangeListenerService,
   OIMDB,
   OIMDefaultValue,
   OIMDefaults,
   OIMEffectService,
-  OIMErrorPolicyLogAndContinue,
-  OIMErrorPolicyThrowAtOnce,
   OIMFlushSchedulerService,
   OIMIndexKeysService,
-  OIMIndexKeysServiceAppending,
-  OIMIndexKeysServiceReclaiming,
-  OIMIndexService,
-  OIMIndexServiceSortedArrayDriven,
   OIMKeyTreeWalk,
-  OIMKeyTreeWalkComposite,
-  OIMKeyTreeWalkScalar,
-  OIMReleaseSlotCollectorService,
-  OIMReleaseSlotCollectorServiceAfterIdle,
-  OIMReleaseSlotCollectorServiceAfterUnhold,
-  OIMReleaseSlotCollectorServiceAfterWrite,
-  OIMReleaseSlotQueueService,
+  OIMLogAndContinueErrorPolicy,
+  OIMNoSlotSubscriptionListener,
+  OIMNoStoreSlotListener,
+  OIMPullColumnSlotOwner,
+  OIMReclaimingIndexKeysService,
+  OIMScalarKeyTreeWalk,
+  OIMSingleComputedService,
   OIMSingleSlotService,
+  OIMSingleSlotStoreService,
+  OIMSlotAfterIdleReleasePolicy,
+  OIMSlotAfterUnholdReleasePolicy,
+  OIMSlotAfterWriteReleasePolicy,
+  OIMSlotAtEmptyReleasePolicy,
+  OIMSlotAtUnholdReleasePolicy,
+  OIMSlotCollectionIndexService,
   OIMSlotCollectionService,
-  OIMSlotColumnService,
+  OIMSlotCollectionSortedArrayIndexService,
+  OIMSlotContentArrayBucketService,
   OIMSlotContentBucketService,
-  OIMSlotContentBucketServiceArrayBased,
-  OIMSlotContentBucketServiceArrayDriven,
-  OIMSlotContentBucketServiceSetDriven,
-  OIMSlotContentBucketServiceSortedArrayDriven,
   OIMSlotContentEntityService,
+  OIMSlotContentPositionalArrayBucketService,
+  OIMSlotContentSetBucketService,
+  OIMSlotContentSortedArrayBucketService,
+  OIMSlotEarliestReleasePolicy,
+  OIMSlotMapStoreService,
+  OIMSlotNeverReleasePolicy,
   OIMSlotOwner,
-  OIMSlotReleasePolicyAfterIdle,
-  OIMSlotReleasePolicyAfterUnhold,
-  OIMSlotReleasePolicyAfterWrite,
-  OIMSlotReleasePolicyAtEmpty,
-  OIMSlotReleasePolicyAtUnhold,
-  OIMSlotReleasePolicyEarliest,
-  OIMSlotReleasePolicyNever,
-  OIMSlotStoreServiceMapDriven,
-  OIMSlotStoreServiceSingleSlotDriven,
-  OIMSlotStoreServiceTreeDriven,
-  OIMStoreSlotListenerNone,
+  OIMSlotRefetchWheel,
+  OIMSlotReleaseAutoDueFramePolicy,
+  OIMSlotReleaseManualDueFramePolicy,
+  OIMSlotReleaseWheel,
+  OIMSlotTreeStoreService,
+  OIMSlotWheel,
+  OIMSortedComputedService,
+  OIMThrowAtOnceErrorPolicy,
   OIMUnusedSlotCollectorService,
+  OIMWritableSingleSlotService,
+  OIMWritableSlotCollectionService,
   OIM_FROZEN_EMPTY_SLOTS,
   OIM_NOTHING_WAS_INSERTED,
   OIM_NOTHING_WAS_REMOVED,
   OIM_REMOVED_WITHOUT_A_POSITION,
   OIM_SLICE_LENGTH_MS,
-  createOIMBucketService,
+  createOIMBucketMemoComputedService,
   createOIMChannelSlot,
   createOIMCollectorSlot,
   createOIMComputedService,
-  createOIMComputedServiceBucketMemo,
-  createOIMComputedServiceSorted,
-  createOIMEntityService,
   createOIMEntityWriterInPlace,
   createOIMEntityWriterReplacing,
-  createOIMIndexService,
-  createOIMIndexServiceByCompositeKey,
-  createOIMIndexServiceSortedArrayDriven,
-  createOIMReleaseSlotCollectorSlot,
-  createOIMSingleBucketService,
-  createOIMSingleEntityService,
+  createOIMSingleComputedService,
   createOIMSingleSlotService,
+  createOIMSlotCollectionIndexService,
   createOIMSlotCollectionService,
+  createOIMSlotCollectionSortedArrayIndexService,
   createOIMSlotContentEntityService,
+  createOIMSortedComputedService,
   createOIMUnusedSlotCollectorSlot,
   oimColumnsComparator,
   oimHoldSlots,
@@ -5531,6 +5312,9 @@ export {
   oimIsAnySlotChangedAfter,
   oimIsSlotEmpty,
   oimIsSlotReleased,
+  oimMintAfterIdleSlotReleaseWheel,
+  oimMintAfterUnholdSlotReleaseWheel,
+  oimMintAfterWriteSlotReleaseWheel,
   oimOrderedListCommandsOfTransition,
   oimPatchEntityColumn,
   oimPatchEntityColumnGuarded,