@oimdb/core 4.1.0 → 4.2.0

package/dist/index.cjs

@@ -31,7 +31,6 @@ __export(index_exports, {
   OIMCompositeKeyTreeWalk: () => OIMCompositeKeyTreeWalk,
   OIMComputedService: () => OIMComputedService,
   OIMComputedValueService: () => OIMComputedValueService,
-  OIMContentChangeListenerService: () => OIMContentChangeListenerService,
   OIMDB: () => OIMDB,
   OIMDefaultValue: () => OIMDefaultValue,
   OIMDefaults: () => OIMDefaults,
@@ -48,6 +47,7 @@ __export(index_exports, {
   OIMSingleComputedService: () => OIMSingleComputedService,
   OIMSingleSlotService: () => OIMSingleSlotService,
   OIMSingleSlotStoreService: () => OIMSingleSlotStoreService,
+  OIMSingleSourceTrackingComputedService: () => OIMSingleSourceTrackingComputedService,
   OIMSlotAfterIdleReleasePolicy: () => OIMSlotAfterIdleReleasePolicy,
   OIMSlotAfterUnholdReleasePolicy: () => OIMSlotAfterUnholdReleasePolicy,
   OIMSlotAfterWriteReleasePolicy: () => OIMSlotAfterWriteReleasePolicy,
@@ -58,6 +58,7 @@ __export(index_exports, {
   OIMSlotCollectionSortedArrayIndexService: () => OIMSlotCollectionSortedArrayIndexService,
   OIMSlotContentArrayBucketService: () => OIMSlotContentArrayBucketService,
   OIMSlotContentBucketService: () => OIMSlotContentBucketService,
+  OIMSlotContentChangeListenerService: () => OIMSlotContentChangeListenerService,
   OIMSlotContentEntityService: () => OIMSlotContentEntityService,
   OIMSlotContentPositionalArrayBucketService: () => OIMSlotContentPositionalArrayBucketService,
   OIMSlotContentSetBucketService: () => OIMSlotContentSetBucketService,
@@ -73,6 +74,7 @@ __export(index_exports, {
   OIMSlotTreeStoreService: () => OIMSlotTreeStoreService,
   OIMSlotWheel: () => OIMSlotWheel,
   OIMSortedComputedService: () => OIMSortedComputedService,
+  OIMSourceTrackingComputedService: () => OIMSourceTrackingComputedService,
   OIMThrowAtOnceErrorPolicy: () => OIMThrowAtOnceErrorPolicy,
   OIMUnusedSlotCollectorService: () => OIMUnusedSlotCollectorService,
   OIMWritableSingleSlotService: () => OIMWritableSingleSlotService,
@@ -86,17 +88,22 @@ __export(index_exports, {
   createOIMChannelSlot: () => createOIMChannelSlot,
   createOIMCollectorSlot: () => createOIMCollectorSlot,
   createOIMComputedService: () => createOIMComputedService,
-  createOIMEntityWriterInPlace: () => createOIMEntityWriterInPlace,
-  createOIMEntityWriterReplacing: () => createOIMEntityWriterReplacing,
+  createOIMInPlaceEntityWriter: () => createOIMInPlaceEntityWriter,
+  createOIMReplacingEntityWriter: () => createOIMReplacingEntityWriter,
   createOIMSingleComputedService: () => createOIMSingleComputedService,
   createOIMSingleSlotService: () => createOIMSingleSlotService,
+  createOIMSingleSourceTrackingComputedService: () => createOIMSingleSourceTrackingComputedService,
   createOIMSlotCollectionIndexService: () => createOIMSlotCollectionIndexService,
   createOIMSlotCollectionService: () => createOIMSlotCollectionService,
   createOIMSlotCollectionSortedArrayIndexService: () => createOIMSlotCollectionSortedArrayIndexService,
   createOIMSlotContentEntityService: () => createOIMSlotContentEntityService,
   createOIMSortedComputedService: () => createOIMSortedComputedService,
+  createOIMSourceTrackingComputedService: () => createOIMSourceTrackingComputedService,
   createOIMUnusedSlotCollectorSlot: () => createOIMUnusedSlotCollectorSlot,
   oimColumnsComparator: () => oimColumnsComparator,
+  oimGuardedPatchEntityColumn: () => oimGuardedPatchEntityColumn,
+  oimGuardedPatchEntityColumns: () => oimGuardedPatchEntityColumns,
+  oimGuardedPutEntityColumns: () => oimGuardedPutEntityColumns,
   oimHoldSlots: () => oimHoldSlots,
   oimInsertEntityWithCopy: () => oimInsertEntityWithCopy,
   oimInsertEntityWithSanitizedCopy: () => oimInsertEntityWithSanitizedCopy,
@@ -109,11 +116,8 @@ __export(index_exports, {
   oimMintAfterWriteSlotReleaseWheel: () => oimMintAfterWriteSlotReleaseWheel,
   oimOrderedListCommandsOfTransition: () => oimOrderedListCommandsOfTransition,
   oimPatchEntityColumn: () => oimPatchEntityColumn,
-  oimPatchEntityColumnGuarded: () => oimPatchEntityColumnGuarded,
   oimPatchEntityColumns: () => oimPatchEntityColumns,
-  oimPatchEntityColumnsGuarded: () => oimPatchEntityColumnsGuarded,
   oimPutEntityColumns: () => oimPutEntityColumns,
-  oimPutEntityColumnsGuarded: () => oimPutEntityColumnsGuarded,
   oimRefreshSourceComputeds: () => oimRefreshSourceComputeds,
   oimSameKeySequence: () => oimSameKeySequence,
   oimSameSlotSequence: () => oimSameSlotSequence,
@@ -123,7 +127,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/engine/schedule/OIMFlushSchedulerService.ts
+// src/schedule/OIMFlushSchedulerService.ts
 var _OIMFlushSchedulerService = class _OIMFlushSchedulerService {
   isScheduled(flushSchedulerSlot) {
     return flushSchedulerSlot.scheduledCallback !== void 0;
@@ -158,15 +162,15 @@ var _OIMFlushSchedulerService = class _OIMFlushSchedulerService {
 _OIMFlushSchedulerService.INSTANCE = new _OIMFlushSchedulerService();
 var OIMFlushSchedulerService = _OIMFlushSchedulerService;
 
-// src/engine/slot/constants/OIM_SLOT_FLAG_RELEASED.ts
+// src/slot/constants/OIM_SLOT_FLAG_RELEASED.ts
 var OIM_SLOT_FLAG_RELEASED = 2;
 
-// src/engine/slot/utils/oimUnholdSlotIfAlive.ts
+// src/slot/utils/oimUnholdSlotIfAlive.ts
 function oimUnholdSlotIfAlive(slot) {
   if ((slot.slotFlags & OIM_SLOT_FLAG_RELEASED) === 0) slot.owner.unholdSlot(slot);
 }
 
-// src/engine/collector/OIMUnusedSlotCollectorService.ts
+// src/collector/OIMUnusedSlotCollectorService.ts
 var _OIMUnusedSlotCollectorService = class _OIMUnusedSlotCollectorService {
   holdSlotUntilFlush(unusedSlotCollectorSlot, slot) {
     slot.owner.holdSlot(slot);
@@ -212,16 +216,16 @@ var _OIMUnusedSlotCollectorService = class _OIMUnusedSlotCollectorService {
 _OIMUnusedSlotCollectorService.INSTANCE = new _OIMUnusedSlotCollectorService();
 var OIMUnusedSlotCollectorService = _OIMUnusedSlotCollectorService;
 
-// src/engine/channel/constants/OIM_REVISIONS_PER_EPOCH.ts
+// src/channel/constants/OIM_REVISIONS_PER_EPOCH.ts
 var OIM_REVISIONS_PER_EPOCH = 2 ** 30;
 
-// src/engine/channel/utils/oimIsRevisionAfter.ts
+// src/channel/utils/oimIsRevisionAfter.ts
 function oimIsRevisionAfter(revision, epoch, sinceRevision, sinceEpoch) {
-  if (epoch !== sinceEpoch) return epoch > sinceEpoch;
+  if (epoch !== sinceEpoch) return (epoch - sinceEpoch | 0) > 0;
   return revision > sinceRevision;
 }
 
-// src/engine/channel/OIMChannelService.ts
+// src/channel/OIMChannelService.ts
 var _OIMChannelService = class _OIMChannelService {
   scheduleEffectRun(channelSlot, effect) {
     channelSlot.effectChannelQueue.enqueueEntry(effect);
@@ -281,24 +285,24 @@ var _OIMChannelService = class _OIMChannelService {
     const clock = channelSlot.clock;
     if (clock.revision >= OIM_REVISIONS_PER_EPOCH - 1) {
       clock.revision = 0;
-      clock.epoch++;
+      clock.epoch = clock.epoch + 1 | 0;
     } else {
       clock.revision++;
     }
-    const dependents = slot.effects;
-    const slotEditable = slot;
+    const effects = slot.effects;
+    const editableSlot = slot;
     const effectChannelQueue = channelSlot.effectChannelQueue;
     let owesAFrame = false;
-    if (dependents !== void 0 && dependents.length !== 0 && !this.isChangedInCurrentFrame(channelSlot, slot)) {
-      const owed = dependents.length;
+    if (effects !== void 0 && effects.length !== 0 && !this.isChangedInCurrentFrame(channelSlot, slot)) {
+      const owed = effects.length;
       for (let i = 0; i < owed; i++) {
-        const dependent = dependents[i];
-        if (dependent.effectService.markEffectRunScheduled(dependent, false)) effectChannelQueue.enqueueEntry(dependent);
+        const effect = effects[i];
+        if (effect.effectService.markEffectRunScheduled(effect, false)) effectChannelQueue.enqueueEntry(effect);
       }
       owesAFrame = true;
     }
-    slotEditable.changedAtRevision = clock.revision;
-    slotEditable.changedAtEpoch = clock.epoch;
+    editableSlot.changedAtRevision = clock.revision;
+    editableSlot.changedAtEpoch = clock.epoch;
     if (!owesAFrame && (channelSlot.flushRequested || channelSlot.frame.afterEachFrame.size === 0 && effectChannelQueue.getEntryCount() === 0)) return;
     if (channelSlot.timer === void 0) return;
     this.requestFlush(channelSlot);
@@ -423,7 +427,7 @@ var _OIMChannelService = class _OIMChannelService {
 _OIMChannelService.INSTANCE = new _OIMChannelService();
 var OIMChannelService = _OIMChannelService;
 
-// src/engine/channel/OIMChannelQueue.ts
+// src/channel/OIMChannelQueue.ts
 var OIMChannelQueue = class {
   constructor() {
     this.entries = [];
@@ -457,7 +461,7 @@ var OIMChannelQueue = class {
   }
 };
 
-// src/engine/channel/utils/createOIMChannelSlot.ts
+// src/channel/utils/createOIMChannelSlot.ts
 function createOIMChannelSlot(options) {
   return {
     timer: options.timer,
@@ -479,12 +483,12 @@ function createOIMChannelSlot(options) {
   };
 }
 
-// src/engine/collector/utils/createOIMUnusedSlotCollectorSlot.ts
+// src/collector/utils/createOIMUnusedSlotCollectorSlot.ts
 function createOIMUnusedSlotCollectorSlot() {
   return { unusedSlotChannelQueue: new OIMChannelQueue(), openDepth: 0, isFlushing: false };
 }
 
-// src/engine/collector/utils/createOIMCollectorSlot.ts
+// src/collector/utils/createOIMCollectorSlot.ts
 function createOIMCollectorSlot(options) {
   return {
     unusedSlotCollectorSlot: createOIMUnusedSlotCollectorSlot(),
@@ -495,18 +499,18 @@ function createOIMCollectorSlot(options) {
   };
 }
 
-// src/engine/schedule/constants/OIM_NOTHING_TO_DISPOSE.ts
+// src/schedule/constants/OIM_NOTHING_TO_DISPOSE.ts
 var OIM_NOTHING_TO_DISPOSE = () => {
   return;
 };
 
-// src/engine/schedule/utils/oimTimerOfChannelScheduler.ts
+// src/schedule/utils/oimTimerOfChannelScheduler.ts
 var oimTimerOfChannelScheduler = (scheduler) => (run) => {
   scheduler(run);
   return OIM_NOTHING_TO_DISPOSE;
 };
 
-// src/engine/schedule/constants/OIM_TIMER_ON_TIMEOUT.ts
+// src/schedule/constants/OIM_TIMER_ON_TIMEOUT.ts
 var OIM_TIMER_ON_TIMEOUT = (run, inMs) => {
   const handle = setTimeout(run, inMs);
   handle.unref?.();
@@ -515,7 +519,7 @@ var OIM_TIMER_ON_TIMEOUT = (run, inMs) => {
   };
 };
 
-// src/engine/error/OIMLogAndContinueErrorPolicy.ts
+// src/error/OIMLogAndContinueErrorPolicy.ts
 var _OIMLogAndContinueErrorPolicy = class _OIMLogAndContinueErrorPolicy {
   constructor(options) {
     this.onError = options?.onError;
@@ -528,7 +532,7 @@ var _OIMLogAndContinueErrorPolicy = class _OIMLogAndContinueErrorPolicy {
 _OIMLogAndContinueErrorPolicy.INSTANCE = new _OIMLogAndContinueErrorPolicy();
 var OIMLogAndContinueErrorPolicy = _OIMLogAndContinueErrorPolicy;
 
-// src/factories/OIMDB.ts
+// src/db/OIMDB.ts
 var OIMDB = class {
   constructor(options) {
     this.clock = { revision: 0, epoch: 0 };
@@ -546,17 +550,13 @@ var OIMDB = class {
       timer: channelScheduler === void 0 ? void 0 : oimTimerOfChannelScheduler(channelScheduler),
       onBeforeFlush: options?.onBeforeFlush
     });
-    this.entityWriter = options?.entityWriter;
-    this.slotStamp = options?.slotStamp;
-    this.slotReleasePolicy = options?.slotReleasePolicy;
-    this.indexKeysService = options?.indexKeysService;
   }
   flush() {
     OIMChannelService.INSTANCE.flush(this.defaultChannelSlot);
   }
 };
 
-// src/factories/defaults/oimRegisterCoreInstance.ts
+// src/db/utils/oimRegisterCoreInstance.ts
 var OIM_CORE_INSTANCE_KEY = Symbol.for("@oimdb/core");
 function oimRegisterCoreInstance(coreInstance) {
   const globalThisRecord = globalThis;
@@ -567,11 +567,11 @@ function oimRegisterCoreInstance(coreInstance) {
   }
   if (registeredCoreInstance === coreInstance) return;
   throw new Error(
-    "@oimdb/core is loaded twice in this process \u2014 usually `import` in one place and `require` in another, or two installed copies. Each copy keeps its own OIMDefaults, so a default set through one never reaches collections built by the other. Load @oimdb/core one way everywhere, including inside every @oimdb package."
+    "@oimdb/core is loaded twice in this process \u2014 usually `import` in one place and `require` in another, or two installed copies. Each copy keeps its own built-in defaults and its own classes, so services built by the two copies share nothing. Load @oimdb/core one way everywhere, including inside every @oimdb package."
   );
 }
 
-// src/engine/slot/OIMNoStoreSlotListener.ts
+// src/slot/OIMNoStoreSlotListener.ts
 var _OIMNoStoreSlotListener = class _OIMNoStoreSlotListener {
   onStoreSlotCreated() {
     return;
@@ -580,7 +580,7 @@ var _OIMNoStoreSlotListener = class _OIMNoStoreSlotListener {
 _OIMNoStoreSlotListener.INSTANCE = new _OIMNoStoreSlotListener();
 var OIMNoStoreSlotListener = _OIMNoStoreSlotListener;
 
-// src/engine/slot/OIMNoSlotSubscriptionListener.ts
+// src/slot/OIMNoSlotSubscriptionListener.ts
 var _OIMNoSlotSubscriptionListener = class _OIMNoSlotSubscriptionListener {
   onSlotFirstSubscribed() {
     return;
@@ -592,20 +592,20 @@ var _OIMNoSlotSubscriptionListener = class _OIMNoSlotSubscriptionListener {
 _OIMNoSlotSubscriptionListener.INSTANCE = new _OIMNoSlotSubscriptionListener();
 var OIMNoSlotSubscriptionListener = _OIMNoSlotSubscriptionListener;
 
-// src/engine/slot/constants/OIM_SLOT_FLAG_EMPTY.ts
+// src/slot/constants/OIM_SLOT_FLAG_EMPTY.ts
 var OIM_SLOT_FLAG_EMPTY = 1;
 
-// src/engine/slot/utils/oimIsSlotEmpty.ts
+// src/slot/utils/oimIsSlotEmpty.ts
 function oimIsSlotEmpty(slot) {
   return (slot.slotFlags & OIM_SLOT_FLAG_EMPTY) !== 0;
 }
 
-// src/engine/slot/utils/oimIsSlotReleased.ts
+// src/slot/utils/oimIsSlotReleased.ts
 function oimIsSlotReleased(slot) {
   return (slot.slotFlags & OIM_SLOT_FLAG_RELEASED) !== 0;
 }
 
-// src/engine/slot/utils/oimAssertSlotNotReleased.ts
+// src/slot/utils/oimAssertSlotNotReleased.ts
 var oimAssertSlotNotReleased = (slot) => {
   if ((slot.slotFlags & OIM_SLOT_FLAG_RELEASED) === 0) return;
   throw new Error(
@@ -613,7 +613,7 @@ var oimAssertSlotNotReleased = (slot) => {
   );
 };
 
-// src/engine/slot/OIMSlotOwner.ts
+// src/slot/OIMSlotOwner.ts
 var OIMSlotOwner = class {
   holdSlot(slot) {
     this.assertNotReleased(slot);
@@ -633,10 +633,10 @@ var OIMSlotOwner = class {
   }
   subscribeToSlot(slot, effect, edge) {
     this.holdSlot(slot);
-    const slotEditable = slot;
-    const subscribers = slotEditable.effects ?? (slotEditable.effects = []);
+    const editableSlot = slot;
+    const subscribers = editableSlot.effects ?? (editableSlot.effects = []);
     subscribers.push(effect);
-    (slotEditable.effectEdges ?? (slotEditable.effectEdges = [])).push(edge);
+    (editableSlot.effectEdges ?? (editableSlot.effectEdges = [])).push(edge);
     if (subscribers.length === 1) this.onSlotFirstSubscribed(slot);
     return subscribers.length - 1;
   }
@@ -683,30 +683,30 @@ var OIMSlotOwner = class {
   }
 };
 
-// src/engine/column/constants/OIM_COLUMN_GROUP_KEY_SEPARATOR.ts
+// src/column/constants/OIM_COLUMN_GROUP_KEY_SEPARATOR.ts
 var OIM_COLUMN_GROUP_KEY_SEPARATOR = "\0";
 
-// src/engine/column/utils/oimColumnGroupKeyOfColumnNames.ts
+// src/column/utils/oimColumnGroupKeyOfColumnNames.ts
 function oimColumnGroupKeyOfColumnNames(sortedColumnNames) {
   return `${OIM_COLUMN_GROUP_KEY_SEPARATOR}${sortedColumnNames.join(OIM_COLUMN_GROUP_KEY_SEPARATOR)}`;
 }
 
-// src/engine/column/constants/OIM_ANY_COLUMN_KEY.ts
+// src/column/constants/OIM_ANY_COLUMN_KEY.ts
 var OIM_ANY_COLUMN_KEY = OIM_COLUMN_GROUP_KEY_SEPARATOR;
 
-// src/engine/column/utils/oimColumnNamesOfKey.ts
+// src/column/utils/oimColumnNamesOfKey.ts
 function oimColumnNamesOfKey(columnKey) {
   if (!columnKey.startsWith(OIM_COLUMN_GROUP_KEY_SEPARATOR)) return [columnKey];
   const joinedColumnNames = columnKey.slice(OIM_COLUMN_GROUP_KEY_SEPARATOR.length);
   return joinedColumnNames === "" ? [] : joinedColumnNames.split(OIM_COLUMN_GROUP_KEY_SEPARATOR);
 }
 
-// src/engine/slot/utils/oimMarkSlotReleased.ts
+// src/slot/utils/oimMarkSlotReleased.ts
 function oimMarkSlotReleased(slot) {
   slot.slotFlags |= OIM_SLOT_FLAG_RELEASED;
 }
 
-// src/engine/column/OIMColumnSlotOwner.ts
+// src/column/OIMColumnSlotOwner.ts
 var OIMColumnSlotOwner = class extends OIMSlotOwner {
   constructor(columnSlotStoreService) {
     super();
@@ -811,8 +811,8 @@ var OIMColumnSlotOwner = class extends OIMSlotOwner {
   }
   fileColumnSlot(carrierSlot, key) {
     const columnSlotStoreService = this.columnSlotStoreService;
-    const carrierSlotEditable = carrierSlot;
-    const columnSlotStore = carrierSlotEditable.columnSlotStore ?? (carrierSlotEditable.columnSlotStore = columnSlotStoreService.createStore());
+    const editableCarrierSlot = carrierSlot;
+    const columnSlotStore = editableCarrierSlot.columnSlotStore ?? (editableCarrierSlot.columnSlotStore = columnSlotStoreService.createStore());
     const columnSlot = this.createColumnSlot(carrierSlot, key);
     columnSlotStoreService.set(columnSlotStore, key, columnSlot);
     return columnSlot;
@@ -870,7 +870,7 @@ function forgetColumnReadersIfUnread(storeSlot, columnName, columnReaders) {
   storeSlot.columnReadersByColumnName.delete(columnName);
 }
 
-// src/engine/column/OIMColumnSlotOrdinalStoreService.ts
+// src/column/OIMColumnSlotOrdinalStoreService.ts
 var OIMColumnSlotOrdinalStoreService = class {
   constructor(options) {
     this.ordinalsByColumnName = /* @__PURE__ */ new Map();
@@ -936,19 +936,19 @@ var OIMColumnSlotOrdinalStoreService = class {
   }
 };
 
-// src/engine/column/utils/oimColumnSlotStoreServiceOfColumnOwnerOptions.ts
-function oimColumnSlotStoreServiceOfColumnOwnerOptions(columnSlotOwnerOptions) {
+// src/column/utils/oimColumnSlotStoreServiceOfColumnSlotOwnerOptions.ts
+function oimColumnSlotStoreServiceOfColumnSlotOwnerOptions(columnSlotOwnerOptions) {
   if (columnSlotOwnerOptions.columnNames !== void 0) {
     return new OIMColumnSlotOrdinalStoreService({ columnNames: columnSlotOwnerOptions.columnNames });
   }
   return columnSlotOwnerOptions.columnSlotStoreService;
 }
 
-// src/engine/computed/constants/OIM_FROZEN_EMPTY_COMPUTED_SLOTS.ts
+// src/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, initialValue, storeSlot = void 0) {
+// src/computed/utils/createOIMComputedSlot.ts
+function createOIMComputedSlot(key, owner, computedValueService, initialValue, storeSlot, sourceTracker) {
   return {
     effects: void 0,
     changedAtRevision: 0,
@@ -973,11 +973,12 @@ function createOIMComputedSlot(key, owner, computedValueService, initialValue, s
     checkedAtRevision: -1,
     checkedAtEpoch: -1,
     isDeriving: false,
-    allRootSlots: void 0
+    allRootSlots: void 0,
+    sourceTracker
   };
 }
 
-// src/engine/computed/utils/oimRefreshSourceComputeds.ts
+// src/computed/utils/oimRefreshSourceComputeds.ts
 function oimRefreshSourceComputeds(sourceComputeds) {
   for (let i = 0; i < sourceComputeds.length; i++) {
     const sourceComputedSlot = sourceComputeds[i];
@@ -985,7 +986,7 @@ function oimRefreshSourceComputeds(sourceComputeds) {
   }
 }
 
-// src/engine/channel/utils/oimIsAnySlotChangedAfter.ts
+// src/channel/utils/oimIsAnySlotChangedAfter.ts
 function oimIsAnySlotChangedAfter(slots, revision, epoch) {
   for (let i = 0; i < slots.length; i++) {
     const slot = slots[i];
@@ -994,52 +995,67 @@ function oimIsAnySlotChangedAfter(slots, revision, epoch) {
   return false;
 }
 
-// src/engine/computed/utils/oimHasSourceChangedSinceLastRun.ts
+// src/computed/utils/oimHasSourceChangedSinceLastRun.ts
 function oimHasSourceChangedSinceLastRun(derivation) {
   return oimIsAnySlotChangedAfter(derivation.sourceComputeds, derivation.ranAtRevision, derivation.ranAtEpoch) || oimIsAnySlotChangedAfter(derivation.sourceSlots, derivation.ranAtRevision, derivation.ranAtEpoch);
 }
 
-// src/engine/computed/utils/oimRefreshComputedSlot.ts
-function oimRefreshComputedSlot(computedSlot, derive, sameValueGuard, channelClock) {
+// src/computed/utils/oimRefreshComputedSlot.ts
+function oimRefreshComputedSlot(computedSlot, derive, sameValueGuard, releaseValue, channelClock) {
   if (computedSlot.isDeriving) return;
   if (computedSlot.checkedAtRevision === channelClock.revision && computedSlot.checkedAtEpoch === channelClock.epoch) return;
-  const computedSlotEditable = computedSlot;
+  const editableComputedSlot = computedSlot;
   oimRefreshSourceComputeds(computedSlot.sourceComputeds);
   if (computedSlot.ranAtRevision !== -1 && !oimHasSourceChangedSinceLastRun(computedSlot)) {
-    computedSlotEditable.checkedAtRevision = channelClock.revision;
-    computedSlotEditable.checkedAtEpoch = channelClock.epoch;
+    editableComputedSlot.checkedAtRevision = channelClock.revision;
+    editableComputedSlot.checkedAtEpoch = channelClock.epoch;
     return;
   }
-  computedSlotEditable.isDeriving = true;
+  const hasDerived = computedSlot.ranAtRevision !== -1;
+  editableComputedSlot.isDeriving = true;
   let next;
   try {
     next = derive(computedSlot);
   } finally {
-    computedSlotEditable.isDeriving = false;
-  }
-  const isSameValue = sameValueGuard(computedSlot.value, next);
-  computedSlotEditable.ranAtRevision = channelClock.revision;
-  computedSlotEditable.ranAtEpoch = channelClock.epoch;
-  computedSlotEditable.checkedAtRevision = channelClock.revision;
-  computedSlotEditable.checkedAtEpoch = channelClock.epoch;
-  if (isSameValue) return;
-  computedSlotEditable.value = next;
+    editableComputedSlot.isDeriving = false;
+  }
+  if ((computedSlot.slotFlags & OIM_SLOT_FLAG_RELEASED) !== 0) {
+    releaseValue(next);
+    return;
+  }
+  const prevValue = computedSlot.value;
+  const isSameValue = sameValueGuard(prevValue, next);
+  editableComputedSlot.ranAtRevision = channelClock.revision;
+  editableComputedSlot.ranAtEpoch = channelClock.epoch;
+  editableComputedSlot.checkedAtRevision = channelClock.revision;
+  editableComputedSlot.checkedAtEpoch = channelClock.epoch;
+  if (isSameValue) {
+    if (next !== prevValue) releaseValue(next);
+    return;
+  }
+  editableComputedSlot.value = next;
+  if (hasDerived) releaseValue(prevValue);
   const sourceSlots = computedSlot.sourceSlots;
   const sourceComputeds = computedSlot.sourceComputeds;
   const sourceCount = sourceSlots.length + sourceComputeds.length;
   let newestSourceRevision = -1;
   let newestSourceEpoch = -1;
   for (let i = 0; i < sourceCount; i++) {
-    const source = i < sourceSlots.length ? sourceSlots[i] : sourceComputeds[i - sourceSlots.length];
-    if (!oimIsRevisionAfter(source.changedAtRevision, source.changedAtEpoch, newestSourceRevision, newestSourceEpoch)) continue;
-    newestSourceRevision = source.changedAtRevision;
-    newestSourceEpoch = source.changedAtEpoch;
+    const sourceSlot = i < sourceSlots.length ? sourceSlots[i] : sourceComputeds[i - sourceSlots.length];
+    if (!oimIsRevisionAfter(sourceSlot.changedAtRevision, sourceSlot.changedAtEpoch, newestSourceRevision, newestSourceEpoch)) continue;
+    newestSourceRevision = sourceSlot.changedAtRevision;
+    newestSourceEpoch = sourceSlot.changedAtEpoch;
   }
-  computedSlotEditable.changedAtRevision = sourceCount === 0 ? channelClock.revision : newestSourceRevision;
-  computedSlotEditable.changedAtEpoch = sourceCount === 0 ? channelClock.epoch : newestSourceEpoch;
+  editableComputedSlot.changedAtRevision = sourceCount === 0 ? channelClock.revision : newestSourceRevision;
+  editableComputedSlot.changedAtEpoch = sourceCount === 0 ? channelClock.epoch : newestSourceEpoch;
+}
+
+// src/computed/utils/oimReleaseNoValue.ts
+function oimReleaseNoValue() {
+  return;
 }
 
-// src/engine/column/OIMPullColumnSlotOwner.ts
+// src/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;
@@ -1051,7 +1067,7 @@ var isSameColumnValues = (prevColumnValues, nextColumnValues) => {
 };
 var OIMPullColumnSlotOwner = class extends OIMColumnSlotOwner {
   constructor(options) {
-    super(oimColumnSlotStoreServiceOfColumnOwnerOptions(options));
+    super(oimColumnSlotStoreServiceOfColumnSlotOwnerOptions(options));
     this.deriveColumnSlotValue = (columnSlot) => {
       const columnGroup = this.getColumnGroupsByKeyOf(this.carrierSlotOf(columnSlot))?.get(columnSlot.key);
       return columnGroup === void 0 ? this.deriveColumnValue(columnSlot) : this.deriveColumnValues(columnSlot, columnGroup.columnNames);
@@ -1060,17 +1076,18 @@ var OIMPullColumnSlotOwner = class extends OIMColumnSlotOwner {
   getValueForSlot(computedSlot) {
     this.assertNotReleased(computedSlot);
     const columnSlot = computedSlot;
-    const carrierStoreSlot = this.carrierSlotOf(columnSlot).storeSlot;
+    const carrierStoreSlot = columnSlot.storeSlot;
     oimRefreshComputedSlot(
       columnSlot,
       this.deriveColumnSlotValue,
       carrierStoreSlot.columnGroupsByKey?.has(columnSlot.key) === true ? isSameColumnValues : Object.is,
+      oimReleaseNoValue,
       carrierStoreSlot.channelSlot.clock
     );
     return columnSlot.value;
   }
   createColumnSlot(carrierSlot, key) {
-    const columnSlot = createOIMComputedSlot(key, this, this, void 0);
+    const columnSlot = createOIMComputedSlot(key, this, this, void 0, carrierSlot.storeSlot, void 0);
     columnSlot.sourceComputeds = [carrierSlot];
     this.getValueForSlot(columnSlot);
     return columnSlot;
@@ -1090,19 +1107,19 @@ var OIMPullColumnSlotOwner = class extends OIMColumnSlotOwner {
   }
 };
 
-// src/engine/slot/utils/oimSameValueZeroGuard.ts
+// src/slot/utils/oimSameValueZeroGuard.ts
 function oimSameValueZeroGuard(prevValue, nextValue) {
   return prevValue === nextValue || prevValue !== prevValue && nextValue !== nextValue;
 }
 
-// src/engine/bucket/utils/oimSameSlotSequence.ts
+// src/bucket/utils/oimSameSlotSequence.ts
 function oimSameSlotSequence(prev, next) {
   if (prev.length !== next.length) return false;
   for (let i = 0; i < prev.length; i++) if (prev[i] !== next[i]) return false;
   return true;
 }
 
-// src/engine/key/utils/oimSameKeySequence.ts
+// src/key/utils/oimSameKeySequence.ts
 function oimSameKeySequence(keys, otherKeys) {
   if (keys === otherKeys) return true;
   if (keys.length !== otherKeys.length) return false;
@@ -1112,25 +1129,25 @@ function oimSameKeySequence(keys, otherKeys) {
   return true;
 }
 
-// src/engine/slot/utils/oimHoldSlots.ts
+// src/slot/utils/oimHoldSlots.ts
 function oimHoldSlots(slots) {
   for (let i = 0; i < slots.length; i++) slots[i].owner.holdSlot(slots[i]);
 }
 
-// src/engine/slot/utils/oimUnholdSlotsIfAlive.ts
+// src/slot/utils/oimUnholdSlotsIfAlive.ts
 function oimUnholdSlotsIfAlive(slots) {
   for (let i = 0; i < slots.length; i++) oimUnholdSlotIfAlive(slots[i]);
 }
 
-// src/engine/error/OIMThrowAtOnceErrorPolicy.ts
+// src/error/OIMThrowAtOnceErrorPolicy.ts
 var OIMThrowAtOnceErrorPolicy = class {
   onErrorCaught(error) {
     throw error;
   }
 };
 
-// src/engine/computed/OIMEffectSourceList.ts
-var OIMEffectSourceList = class {
+// src/computed/OIMSourceList.ts
+var OIMSourceList = class {
   constructor() {
     this.committedSources = [];
     this.trackedSources = [];
@@ -1179,6 +1196,9 @@ var OIMEffectSourceList = class {
     this.isTrackedSourcesChanged = true;
     return true;
   }
+  getCommittedSources() {
+    return this.committedSources;
+  }
   getTrackedSources() {
     return this.isTrackedSourcesChanged ? this.trackedSources : this.committedSources;
   }
@@ -1197,7 +1217,7 @@ var OIMEffectSourceList = class {
   }
 };
 
-// src/engine/computed/utils/oimMergeRootSlots.ts
+// src/computed/utils/oimMergeRootSlots.ts
 var scannedRootSlotLimit = 16;
 function oimMergeRootSlots(sourceSlots, sourceComputeds) {
   if (sourceComputeds.length === 0) return sourceSlots;
@@ -1227,7 +1247,7 @@ function pushIfAbsent(mergedRootSlots, distinctRootSlots, rootSlot) {
   return mergedRootSlots.length > scannedRootSlotLimit ? new Set(mergedRootSlots) : void 0;
 }
 
-// src/engine/computed/utils/oimGetAllRootSlots.ts
+// src/computed/utils/oimGetAllRootSlots.ts
 function oimGetAllRootSlots(computedSlot) {
   const allRootSlots = computedSlot.allRootSlots;
   if (allRootSlots !== void 0) return allRootSlots;
@@ -1236,62 +1256,85 @@ function oimGetAllRootSlots(computedSlot) {
   return mergedRootSlots;
 }
 
-// src/engine/computed/OIMEffectSourceTracker.ts
-var OIMEffectSourceTracker = class {
+// src/computed/OIMSourceTracker.ts
+var OIMSourceTracker = class {
   constructor() {
-    this.slotEffectSourceList = new OIMEffectSourceList();
-    this.computedEffectSourceList = void 0;
+    this.slotSourceList = new OIMSourceList();
+    this.computedSourceList = void 0;
     this.committedAllRootSlots = [];
     this.trackedAllRootSlots = [];
     this.isTrackedAllRootSlotsChanged = false;
+    this.committedComputedRootSlots = [];
+    this.trackedComputedRootSlots = [];
   }
   readSourceSlot(slot) {
-    this.slotEffectSourceList.trackSource(slot);
+    this.slotSourceList.trackSource(slot);
     return slot;
   }
   readSourceComputedValue(computedSlot) {
     const value = computedSlot.computedValueService.getValueForSlot(computedSlot);
-    (this.computedEffectSourceList ?? (this.computedEffectSourceList = new OIMEffectSourceList())).trackSource(computedSlot);
+    (this.computedSourceList ?? (this.computedSourceList = new OIMSourceList())).trackSource(computedSlot);
     return value;
   }
   openSourceTracking() {
-    this.slotEffectSourceList.openSourceTracking();
-    this.computedEffectSourceList?.openSourceTracking();
+    this.slotSourceList.openSourceTracking();
+    this.computedSourceList?.openSourceTracking();
     this.isTrackedAllRootSlotsChanged = false;
   }
   closeSourceTracking() {
-    const isSourceSlotsChanged = this.slotEffectSourceList.closeSourceTracking();
-    const isSourceComputedsChanged = this.computedEffectSourceList?.closeSourceTracking() ?? false;
-    if (!isSourceSlotsChanged && !isSourceComputedsChanged) return false;
+    const isSourceSlotsChanged = this.slotSourceList.closeSourceTracking();
+    const isSourceComputedsChanged = this.computedSourceList?.closeSourceTracking() ?? false;
+    if (!isSourceSlotsChanged && !isSourceComputedsChanged && !this.isAnyComputedRootSlotsReplaced()) return false;
+    this.trackAllRootSlots();
+    return true;
+  }
+  isAnyComputedRootSlotsReplaced() {
+    const computedSourceList = this.computedSourceList;
+    if (computedSourceList === void 0) return false;
+    const committedSourceComputeds = computedSourceList.getCommittedSources();
+    const committedComputedRootSlots = this.committedComputedRootSlots;
+    for (let i = 0; i < committedSourceComputeds.length; i++) {
+      if (oimGetAllRootSlots(committedSourceComputeds[i]) !== committedComputedRootSlots[i]) return true;
+    }
+    return false;
+  }
+  trackReplacedRootSlots() {
+    if (!this.isAnyComputedRootSlotsReplaced()) return false;
     this.trackAllRootSlots();
     return true;
   }
   getTrackedSourceSlots() {
-    return this.slotEffectSourceList.getTrackedSources();
+    return this.slotSourceList.getTrackedSources();
   }
   getTrackedSourceComputeds() {
-    return this.computedEffectSourceList?.getTrackedSources() ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
+    return this.computedSourceList?.getTrackedSources() ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
   }
   getTrackedAllRootSlots() {
     return this.isTrackedAllRootSlotsChanged ? this.trackedAllRootSlots : this.committedAllRootSlots;
   }
   commitTrackedSources() {
-    this.slotEffectSourceList.commitTrackedSources();
-    this.computedEffectSourceList?.commitTrackedSources();
+    this.slotSourceList.commitTrackedSources();
+    this.computedSourceList?.commitTrackedSources();
     if (!this.isTrackedAllRootSlotsChanged) return;
     const committedAllRootSlots = this.committedAllRootSlots;
     this.committedAllRootSlots = this.trackedAllRootSlots;
     this.trackedAllRootSlots = committedAllRootSlots;
+    const committedComputedRootSlots = this.committedComputedRootSlots;
+    this.committedComputedRootSlots = this.trackedComputedRootSlots;
+    this.trackedComputedRootSlots = committedComputedRootSlots;
     this.isTrackedAllRootSlotsChanged = false;
   }
   trackAllRootSlots() {
-    const sourceSlots = this.slotEffectSourceList.getTrackedSources();
+    const sourceSlots = this.slotSourceList.getTrackedSources();
     const sourceComputeds = this.getTrackedSourceComputeds();
     const trackedAllRootSlots = this.trackedAllRootSlots;
+    const trackedComputedRootSlots = this.trackedComputedRootSlots;
+    if (trackedComputedRootSlots.length !== sourceComputeds.length) trackedComputedRootSlots.length = sourceComputeds.length;
     let rootSlotCount = 0;
     for (let i = 0; i < sourceSlots.length; i++) trackedAllRootSlots[rootSlotCount++] = sourceSlots[i];
     for (let i = 0; i < sourceComputeds.length; i++) {
       const computedRootSlots = oimGetAllRootSlots(sourceComputeds[i]);
+      trackedComputedRootSlots[i] = computedRootSlots;
       for (let j = 0; j < computedRootSlots.length; j++) trackedAllRootSlots[rootSlotCount++] = computedRootSlots[j];
     }
     if (trackedAllRootSlots.length !== rootSlotCount) trackedAllRootSlots.length = rootSlotCount;
@@ -1299,23 +1342,26 @@ var OIMEffectSourceTracker = class {
   }
 };
 
-// src/engine/computed/constants/OIM_EFFECT_FLAG_DISPOSED.ts
+// src/effect/constants/OIM_EFFECT_FLAG_DISPOSED.ts
 var OIM_EFFECT_FLAG_DISPOSED = 2;
 
-// src/engine/computed/utils/oimIsEffectDisposed.ts
+// src/effect/utils/oimIsEffectDisposed.ts
 function oimIsEffectDisposed(effect) {
   return (effect.effectFlags & OIM_EFFECT_FLAG_DISPOSED) !== 0;
 }
 
-// src/engine/computed/constants/OIM_EFFECT_FLAG_RUN_SCHEDULED.ts
+// src/effect/constants/OIM_EFFECT_FLAG_RUN_SCHEDULED.ts
 var OIM_EFFECT_FLAG_RUN_SCHEDULED = 1;
 
-// src/engine/computed/constants/OIM_EFFECT_FLAG_SOURCE_CHECK_OWED.ts
+// src/effect/constants/OIM_EFFECT_FLAG_SOURCE_CHECK_OWED.ts
 var OIM_EFFECT_FLAG_SOURCE_CHECK_OWED = 4;
 
-// src/engine/computed/OIMEffectService.ts
+// src/effect/OIMEffectService.ts
 var _OIMEffectService = class _OIMEffectService {
-  createEffect(channelMap, sourceSlots, sourceComputeds, body) {
+  createEffect(channelMap, body, sourceSlots = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceTrackingComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS) {
+    if (sourceTrackingComputeds.length !== 0) {
+      return this.createEffectOverSourceTrackingComputeds(channelMap, body, sourceSlots, sourceComputeds, sourceTrackingComputeds);
+    }
     let distinctSourceComputeds = sourceComputeds;
     if (sourceComputeds.length > 1) {
       const distinctSourceComputedSet = new Set(sourceComputeds);
@@ -1336,7 +1382,8 @@ var _OIMEffectService = class _OIMEffectService {
       ranAtEpoch: clock.epoch,
       effectFlags: 0,
       body,
-      cleanup: void 0
+      cleanup: void 0,
+      sourceTracker: void 0
     };
     try {
       for (let i = 0; i < allRootSlots.length; i++) {
@@ -1352,20 +1399,17 @@ var _OIMEffectService = class _OIMEffectService {
       this.disposeEffect(effect);
       throw failure;
     }
-    const frame = channelSlot.frame;
-    if (!frame.isRunning && oimIsRevisionAfter(clock.revision, clock.epoch, frame.openedAtRevision, frame.openedAtEpoch) && this.markEffectRunScheduled(effect, true)) {
-      OIMChannelService.INSTANCE.scheduleEffectRun(channelSlot, effect);
-    }
+    this.scheduleEffectRunIfWrittenSinceFrameOpened(effect);
     return effect;
   }
-  subscribeEffect(channelMap, sourceSlots, sourceComputeds, body) {
-    const effect = this.createEffect(channelMap, sourceSlots, sourceComputeds, body);
+  subscribeEffect(channelMap, body, sourceSlots = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceTrackingComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS) {
+    const effect = this.createEffect(channelMap, body, sourceSlots, sourceComputeds, sourceTrackingComputeds);
     return () => {
       this.disposeEffect(effect);
     };
   }
-  createEffectImmediate(channelMap, sourceSlots, sourceComputeds, body) {
-    const effect = this.createEffect(channelMap, sourceSlots, sourceComputeds, body);
+  createAndRunEffect(channelMap, body, sourceSlots = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS, sourceTrackingComputeds = OIM_FROZEN_EMPTY_COMPUTED_SLOTS) {
+    const effect = this.createEffect(channelMap, body, sourceSlots, sourceComputeds, sourceTrackingComputeds);
     try {
       this.runEffect(effect);
     } catch (refusal) {
@@ -1374,31 +1418,63 @@ var _OIMEffectService = class _OIMEffectService {
     }
     return effect;
   }
-  createEffectWithSourceTracking(channelMap, effectBodyWithSourceTracking) {
-    const effectSourceTracker = new OIMEffectSourceTracker();
+  createSourceTrackingEffect(channelMap, sourceTrackingEffectBody) {
+    const sourceTracker = new OIMSourceTracker();
+    const effect = this.createEffectOverSourceTracker(
+      channelMap,
+      sourceTracker,
+      () => this.runSourceTrackingEffectBody(effect, sourceTracker, sourceTrackingEffectBody)
+    );
+    try {
+      this.runEffect(effect);
+    } catch (failure) {
+      this.disposeEffect(effect);
+      throw failure;
+    }
+    return effect;
+  }
+  createEffectOverSourceTrackingComputeds(channelMap, body, sourceSlots, sourceComputeds, sourceTrackingComputeds) {
+    const sourceTracker = new OIMSourceTracker();
+    const effect = this.createEffectOverSourceTracker(channelMap, sourceTracker, body);
+    try {
+      sourceTracker.openSourceTracking();
+      for (let i = 0; i < sourceSlots.length; i++) sourceTracker.readSourceSlot(sourceSlots[i]);
+      for (let i = 0; i < sourceComputeds.length; i++) sourceTracker.readSourceComputedValue(sourceComputeds[i]);
+      for (let i = 0; i < sourceTrackingComputeds.length; i++) sourceTracker.readSourceComputedValue(sourceTrackingComputeds[i]);
+      if (sourceTracker.closeSourceTracking()) this.resubscribeToTrackedSources(effect, sourceTracker);
+    } catch (failure) {
+      this.disposeEffect(effect);
+      throw failure;
+    }
+    this.scheduleEffectRunIfWrittenSinceFrameOpened(effect);
+    return effect;
+  }
+  createEffectOverSourceTracker(channelMap, sourceTracker, body) {
     const channelSlot = channelMap.defaultChannelSlot;
     const clock = channelSlot.clock;
-    const effect = {
+    return {
       effectService: this,
       channelSlot,
-      sourceSlots: effectSourceTracker.getTrackedSourceSlots(),
-      sourceComputeds: effectSourceTracker.getTrackedSourceComputeds(),
-      allRootSlots: effectSourceTracker.getTrackedAllRootSlots(),
+      sourceSlots: sourceTracker.getTrackedSourceSlots(),
+      sourceComputeds: sourceTracker.getTrackedSourceComputeds(),
+      allRootSlots: sourceTracker.getTrackedAllRootSlots(),
       positionInFirstSubscribedSlot: -1,
       positionsInOtherSubscribedSlots: void 0,
       ranAtRevision: clock.revision,
       ranAtEpoch: clock.epoch,
       effectFlags: 0,
-      body: () => this.runEffectBodyWithSourceTracking(effect, effectSourceTracker, effectBodyWithSourceTracking),
-      cleanup: void 0
+      body,
+      cleanup: void 0,
+      sourceTracker
     };
-    try {
-      this.runEffect(effect);
-    } catch (failure) {
-      this.disposeEffect(effect);
-      throw failure;
+  }
+  scheduleEffectRunIfWrittenSinceFrameOpened(effect) {
+    const channelSlot = effect.channelSlot;
+    const clock = channelSlot.clock;
+    const frame = channelSlot.frame;
+    if (!frame.isRunning && oimIsRevisionAfter(clock.revision, clock.epoch, frame.openedAtRevision, frame.openedAtEpoch) && this.markEffectRunScheduled(effect, true)) {
+      OIMChannelService.INSTANCE.scheduleEffectRun(channelSlot, effect);
     }
-    return effect;
   }
   markEffectRunScheduled(effect, isSourceCheckOwed) {
     const effectFlags = effect.effectFlags;
@@ -1422,8 +1498,11 @@ var _OIMEffectService = class _OIMEffectService {
   }
   runEffectIfSourcesChanged(effect) {
     oimRefreshSourceComputeds(effect.sourceComputeds);
-    if (!oimHasSourceChangedSinceLastRun(effect)) return;
-    this.runEffect(effect);
+    if (oimHasSourceChangedSinceLastRun(effect)) this.runEffect(effect);
+    const sourceTracker = effect.sourceTracker;
+    if (sourceTracker !== void 0 && !oimIsEffectDisposed(effect) && sourceTracker.trackReplacedRootSlots()) {
+      this.resubscribeToTrackedSources(effect, sourceTracker);
+    }
   }
   runEffect(effect) {
     const channelClock = effect.channelSlot.clock;
@@ -1465,11 +1544,11 @@ var _OIMEffectService = class _OIMEffectService {
     }
     (effect.positionsInOtherSubscribedSlots ?? (effect.positionsInOtherSubscribedSlots = []))[edge - 1] = positionInSlot;
   }
-  runEffectBodyWithSourceTracking(effect, effectSourceTracker, effectBodyWithSourceTracking) {
-    effectSourceTracker.openSourceTracking();
-    const undo = effectBodyWithSourceTracking(effectSourceTracker);
+  runSourceTrackingEffectBody(effect, sourceTracker, sourceTrackingEffectBody) {
+    sourceTracker.openSourceTracking();
+    const undo = sourceTrackingEffectBody(sourceTracker);
     try {
-      if (effectSourceTracker.closeSourceTracking()) this.resubscribeToTrackedSources(effect, effectSourceTracker);
+      if (sourceTracker.closeSourceTracking()) this.resubscribeToTrackedSources(effect, sourceTracker);
     } catch (failure) {
       this.disposeEffect(effect);
       if (typeof undo === "function") undo();
@@ -1477,11 +1556,11 @@ var _OIMEffectService = class _OIMEffectService {
     }
     return undo;
   }
-  resubscribeToTrackedSources(effect, effectSourceTracker) {
+  resubscribeToTrackedSources(effect, sourceTracker) {
     const committedAllRootSlots = effect.allRootSlots;
     const committedSourceComputeds = effect.sourceComputeds;
-    const trackedAllRootSlots = effectSourceTracker.getTrackedAllRootSlots();
-    const trackedSourceComputeds = effectSourceTracker.getTrackedSourceComputeds();
+    const trackedAllRootSlots = sourceTracker.getTrackedAllRootSlots();
+    const trackedSourceComputeds = sourceTracker.getTrackedSourceComputeds();
     const committedEdgeCount = committedAllRootSlots.length + committedSourceComputeds.length;
     const trackedEdgeCount = trackedAllRootSlots.length + trackedSourceComputeds.length;
     const sharedEdgeCount = committedEdgeCount < trackedEdgeCount ? committedEdgeCount : trackedEdgeCount;
@@ -1506,11 +1585,11 @@ var _OIMEffectService = class _OIMEffectService {
       if (positionsInOtherSubscribedSlots !== void 0 && positionsInOtherSubscribedSlots.length > otherEdgeCount) {
         positionsInOtherSubscribedSlots.length = otherEdgeCount;
       }
-      const effectEditable = effect;
-      effectEditable.sourceSlots = effectSourceTracker.getTrackedSourceSlots();
-      effectEditable.sourceComputeds = trackedSourceComputeds;
-      effectEditable.allRootSlots = trackedAllRootSlots;
-      effectSourceTracker.commitTrackedSources();
+      const editableEffect = effect;
+      editableEffect.sourceSlots = sourceTracker.getTrackedSourceSlots();
+      editableEffect.sourceComputeds = trackedSourceComputeds;
+      editableEffect.allRootSlots = trackedAllRootSlots;
+      sourceTracker.commitTrackedSources();
       const channelSlot = effect.channelSlot;
       const isFrameRunning = channelSlot.frame.isRunning;
       for (let edge = firstChangedEdge; edge < trackedEdgeCount; edge++) {
@@ -1545,11 +1624,12 @@ var _OIMEffectService = class _OIMEffectService {
 _OIMEffectService.INSTANCE = new _OIMEffectService();
 var OIMEffectService = _OIMEffectService;
 
-// src/engine/computed/OIMComputedValueService.ts
+// src/computed/OIMComputedValueService.ts
 var OIMComputedValueService = class {
   constructor(options) {
     this.derive = options.derive;
     this.sameValueGuard = options.sameValueGuard ?? Object.is;
+    this.releaseValue = options.releaseValue ?? oimReleaseNoValue;
   }
   getValueForSlot(computedSlot) {
     oimAssertSlotNotReleased(computedSlot);
@@ -1559,22 +1639,26 @@ var OIMComputedValueService = class {
       computedSlot,
       derive,
       this.sameValueGuard,
+      this.releaseValue,
       computedStoreSlot.channelSlot.clock
     );
     return computedSlot.value;
   }
+  releaseSlotValue(computedSlot) {
+    if (computedSlot.ranAtRevision !== -1) this.releaseValue(computedSlot.value);
+  }
 };
 
-// src/engine/slot/OIMContentChangeListenerService.ts
-var _OIMContentChangeListenerService = class _OIMContentChangeListenerService {
+// src/slot/OIMSlotContentChangeListenerService.ts
+var _OIMSlotContentChangeListenerService = class _OIMSlotContentChangeListenerService {
   addContentChangeListener(storeSlot, listener, readColumnNames) {
-    const storeSlotEditable = storeSlot;
-    if (storeSlotEditable.contentChangeListeners === void 0) {
-      storeSlotEditable.contentChangeListeners = [];
-      storeSlotEditable.contentChangeListenerReadColumnNames = [];
+    const editableStoreSlot = storeSlot;
+    if (editableStoreSlot.contentChangeListeners === void 0) {
+      editableStoreSlot.contentChangeListeners = [];
+      editableStoreSlot.contentChangeListenerReadColumnNames = [];
     }
-    storeSlotEditable.contentChangeListeners.push(listener);
-    storeSlotEditable.contentChangeListenerReadColumnNames.push(readColumnNames);
+    editableStoreSlot.contentChangeListeners.push(listener);
+    editableStoreSlot.contentChangeListenerReadColumnNames.push(readColumnNames);
     if (readColumnNames === void 0) this.addReadAnyColumn(storeSlot);
     else for (let i = 0; i < readColumnNames.length; i++) this.addReadColumn(storeSlot, readColumnNames[i]);
   }
@@ -1610,15 +1694,15 @@ var _OIMContentChangeListenerService = class _OIMContentChangeListenerService {
     if (storeSlot.allColumnsListenerCount !== 0) storeSlot.allColumnsListenerCount--;
   }
 };
-_OIMContentChangeListenerService.INSTANCE = new _OIMContentChangeListenerService();
-var OIMContentChangeListenerService = _OIMContentChangeListenerService;
+_OIMSlotContentChangeListenerService.INSTANCE = new _OIMSlotContentChangeListenerService();
+var OIMSlotContentChangeListenerService = _OIMSlotContentChangeListenerService;
 
-// src/engine/slot/utils/oimGetChannelSlot.ts
+// src/slot/utils/oimGetChannelSlot.ts
 function oimGetChannelSlot(slot) {
   return slot.storeSlot.channelSlot;
 }
 
-// src/facade/column/OIMColumnSlotService.ts
+// src/column/OIMColumnSlotService.ts
 var OIMColumnSlotService = class {
   constructor(columnSlotOwner) {
     this.columnSlotOwner = columnSlotOwner;
@@ -1646,8 +1730,11 @@ var OIMColumnSlotService = class {
   }
 };
 
-// src/engine/slot/OIMContentChangeDeliveryService.ts
-var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
+// src/slot/constants/OIM_SLOT_FLAG_QUEUED_IN_BATCH.ts
+var OIM_SLOT_FLAG_QUEUED_IN_BATCH = 32;
+
+// src/slot/OIMSlotContentChangeDeliveryService.ts
+var _OIMSlotContentChangeDeliveryService = class _OIMSlotContentChangeDeliveryService {
   isBatchOpen(storeSlot) {
     return storeSlot.batchDepth > 0;
   }
@@ -1655,23 +1742,23 @@ var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
     storeSlot.batchDepth++;
   }
   closeBatch(storeSlot) {
-    const storeSlotEditable = storeSlot;
-    if (--storeSlotEditable.batchDepth > 0) return;
+    const editableStoreSlot = storeSlot;
+    if (editableStoreSlot.batchDepth === 0) {
+      throw new Error(
+        "OIMSlotContentChangeDeliveryService.closeBatch: no batch is open on this store slot, so there is nothing to close. A close without its open would leave the next batch delivering every write at once."
+      );
+    }
+    if (--editableStoreSlot.batchDepth > 0) return;
     const batchSlotChannelQueue = storeSlot.batchSlotChannelQueue;
     if (batchSlotChannelQueue === void 0 || batchSlotChannelQueue.getEntryCount() === 0) return;
     this.deliverBatch(storeSlot, batchSlotChannelQueue);
   }
   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;
+    const editableStoreSlot = storeSlot;
+    (editableStoreSlot.batchSlotChannelQueue ?? (editableStoreSlot.batchSlotChannelQueue = new OIMChannelQueue())).enqueueEntry(slot);
+    slot.slotFlags |= OIM_SLOT_FLAG_QUEUED_IN_BATCH;
+    (editableStoreSlot.batchPatchChannelQueue ?? (editableStoreSlot.batchPatchChannelQueue = new OIMChannelQueue())).enqueueEntry(patch);
+    (editableStoreSlot.batchChangedColumnsChannelQueue ?? (editableStoreSlot.batchChangedColumnsChannelQueue = new OIMChannelQueue())).enqueueEntry(changedColumns === void 0 ? void 0 : changedColumns.slice());
   }
   deliverBatch(storeSlot, batchSlotChannelQueue) {
     const batchPatchChannelQueue = storeSlot.batchPatchChannelQueue;
@@ -1686,10 +1773,13 @@ var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
         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(batchSlotChannelQueue, batchPatchChannelQueue, batchChangedColumnsChannelQueue);
+          listeners[i].onManyContentsChanged(batchSlotChannelQueue, batchPatchChannelQueue, batchChangedColumnsChannelQueue);
         }
       }
     } finally {
+      for (let i = 0; i < batchSlotChannelQueue.getEntryCount(); i++) {
+        batchSlotChannelQueue.getEntryAt(i).slotFlags &= ~OIM_SLOT_FLAG_QUEUED_IN_BATCH;
+      }
       try {
         for (let i = 0; i < batchSlotChannelQueue.getEntryCount(); i++) {
           const slot = batchSlotChannelQueue.getEntryAt(i);
@@ -1703,10 +1793,10 @@ var _OIMContentChangeDeliveryService = class _OIMContentChangeDeliveryService {
     }
   }
 };
-_OIMContentChangeDeliveryService.INSTANCE = new _OIMContentChangeDeliveryService();
-var OIMContentChangeDeliveryService = _OIMContentChangeDeliveryService;
+_OIMSlotContentChangeDeliveryService.INSTANCE = new _OIMSlotContentChangeDeliveryService();
+var OIMSlotContentChangeDeliveryService = _OIMSlotContentChangeDeliveryService;
 
-// src/engine/collector/OIMSlotAtEmptyReleasePolicy.ts
+// src/collector/OIMSlotAtEmptyReleasePolicy.ts
 var _OIMSlotAtEmptyReleasePolicy = class _OIMSlotAtEmptyReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = false;
@@ -1734,7 +1824,7 @@ var _OIMSlotAtEmptyReleasePolicy = class _OIMSlotAtEmptyReleasePolicy {
 _OIMSlotAtEmptyReleasePolicy.INSTANCE = new _OIMSlotAtEmptyReleasePolicy();
 var OIMSlotAtEmptyReleasePolicy = _OIMSlotAtEmptyReleasePolicy;
 
-// src/engine/slot/OIMSlotOwnerService.ts
+// src/slot/OIMSlotOwnerService.ts
 var OIMSlotOwnerService = class extends OIMSlotOwner {
   constructor(options) {
     super();
@@ -1756,26 +1846,22 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     return slot.columnSlotStore !== void 0;
   }
   hasContentChangeListeners(slot) {
-    const storeSlot = slot.storeSlot;
-    if (storeSlot === void 0) return false;
-    const listeners = storeSlot.contentChangeListeners;
+    const listeners = slot.storeSlot.contentChangeListeners;
     return listeners !== void 0 && listeners.length !== 0;
   }
   dispatchContentChange(slot, patch, changedColumns) {
     const storeSlot = slot.storeSlot;
-    if (storeSlot === void 0) return;
     const listeners = storeSlot.contentChangeListeners;
     if (listeners === void 0 || listeners.length === 0) return;
     if (changedColumns !== void 0 && !this.isAnyColumnRead(storeSlot, changedColumns)) return;
     if (storeSlot.batchDepth > 0) {
-      OIMContentChangeDeliveryService.INSTANCE.enqueueContentChange(storeSlot, slot, patch, changedColumns);
+      OIMSlotContentChangeDeliveryService.INSTANCE.enqueueContentChange(storeSlot, slot, patch, changedColumns);
       return;
     }
     for (let i = 0; i < listeners.length; i++) listeners[i].onContentChanged(slot, patch, changedColumns);
   }
   isAnyColumnReferenced(slot, changedColumns) {
     const storeSlot = slot.storeSlot;
-    if (storeSlot === void 0) return false;
     return slot.columnSlotStore !== void 0 && this.columnSlotOwner.isAnyColumnReferenced(storeSlot, changedColumns) || this.isAnyColumnRead(storeSlot, changedColumns);
   }
   isAnyColumnRead(storeSlot, changedColumns) {
@@ -1794,8 +1880,7 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     return changedColumnNames;
   }
   releaseSlotIfUnheldAfterListeners(slot) {
-    const storeSlot = slot.storeSlot;
-    if (storeSlot !== void 0 && storeSlot.batchDepth > 0 && OIMContentChangeDeliveryService.INSTANCE.isLastEnqueuedSlot(storeSlot, slot)) return;
+    if ((slot.slotFlags & OIM_SLOT_FLAG_QUEUED_IN_BATCH) !== 0) return;
     this.releaseSlotIfUnheld(slot);
   }
   releaseWrittenSlotIfUnheld(slot) {
@@ -1834,7 +1919,7 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
   }
   onSlotIdle(slot) {
     if (oimIsSlotEmpty(slot)) return;
-    if (this.slotReleasePolicy.onSlotIdle(slot)) this.releaseSlotIfUnheld(slot);
+    this.slotReleasePolicy.onSlotIdle(slot);
   }
   onSlotFirstSubscribed(slot) {
     this.slotSubscriptionListener.onSlotFirstSubscribed(slot);
@@ -1853,14 +1938,7 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     if (!isEmpty && !this.releasesWrittenSlots) return;
     if (!this.isReleasable(ownSlot)) return;
     if (isEmpty ? !this.slotReleasePolicy.isEmptySlotReleasable(ownSlot) : !this.slotReleasePolicy.isSlotReleasable(ownSlot)) return;
-    if (!isEmpty) {
-      const channelSlot = oimGetChannelSlot(ownSlot);
-      if (OIMChannelService.INSTANCE.isRefusingWrites(channelSlot)) {
-        OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(channelSlot.collectorSlot.unusedSlotCollectorSlot, ownSlot);
-        return;
-      }
-    }
-    this.releaseSlot(ownSlot, isEmpty);
+    this.releaseSlot(ownSlot);
   }
   isReleasable(slot) {
     if (slot.holdCount > 0) return false;
@@ -1868,18 +1946,16 @@ var OIMSlotOwnerService = class extends OIMSlotOwner {
     if (slot.columnSlotStore !== void 0) return false;
     return !this.slotContentService.hasReference(slot);
   }
-  releaseSlot(slot, isEmpty) {
-    if (!isEmpty) this.assertWritable(slot);
-    this.slotContentService.releaseSlotContent(slot, this);
+  releaseSlot(slot) {
+    this.slotContentService.releaseSlotContent(slot);
     slot.slotFlags |= OIM_SLOT_FLAG_EMPTY;
     this.slotReleasePolicy.cancelSlotRelease(slot);
-    const storeSlot = slot.storeSlot;
-    if (storeSlot !== void 0) this.slotFilingService.unfileSlot(storeSlot.store, slot);
+    this.slotFilingService.unfileSlot(slot.storeSlot.store, slot);
     oimMarkSlotReleased(slot);
   }
 };
 
-// src/engine/slot/utils/createOIMStoreSlot.ts
+// src/slot/utils/createOIMStoreSlot.ts
 function createOIMStoreSlot(store, channelSlot, slotService, sourceStoreSlot) {
   return {
     store,
@@ -1916,7 +1992,7 @@ function createOIMStoreSlot(store, channelSlot, slotService, sourceStoreSlot) {
   };
 }
 
-// src/facade/slot/OIMSlotCollectionService.ts
+// src/slot/OIMSlotCollectionService.ts
 var OIMSlotCollectionService = class {
   constructor(options) {
     const slotOwnerService = new OIMSlotOwnerService({ ...options, slotFilingService: options.slotStoreService });
@@ -1932,17 +2008,17 @@ var OIMSlotCollectionService = class {
   }
   createStoreSlot(channelMap) {
     const channelSlot = channelMap.defaultChannelSlot;
-    return this.createStoreSlotWith((store) => createOIMStoreSlot(store, channelSlot, this));
+    return this.createStoreSlotOverNewStore((store) => createOIMStoreSlot(store, channelSlot, this));
   }
   createStoreSlotFrom(sourceStoreSlot) {
-    return this.createStoreSlotWith((store) => createOIMStoreSlot(
+    return this.createStoreSlotOverNewStore((store) => createOIMStoreSlot(
       store,
       sourceStoreSlot.channelSlot,
       this,
       sourceStoreSlot
     ));
   }
-  createStoreSlotWith(createStoreSlotLiteral) {
+  createStoreSlotOverNewStore(createStoreSlotLiteral) {
     const storeSlot = createStoreSlotLiteral(this.slotStoreService.createStore());
     if (this.storeSlotListener !== void 0) this.storeSlotListener.onStoreSlotCreated(storeSlot);
     return storeSlot;
@@ -1976,13 +2052,13 @@ var OIMSlotCollectionService = class {
     return this.slotStoreService.isSameKey(key, otherKey);
   }
   openBatch(storeSlot) {
-    OIMContentChangeDeliveryService.INSTANCE.openBatch(storeSlot);
+    OIMSlotContentChangeDeliveryService.INSTANCE.openBatch(storeSlot);
   }
   closeBatch(storeSlot) {
-    OIMContentChangeDeliveryService.INSTANCE.closeBatch(storeSlot);
+    OIMSlotContentChangeDeliveryService.INSTANCE.closeBatch(storeSlot);
   }
   writeInBatch(storeSlot, write) {
-    const contentChangeDeliveryService = OIMContentChangeDeliveryService.INSTANCE;
+    const contentChangeDeliveryService = OIMSlotContentChangeDeliveryService.INSTANCE;
     contentChangeDeliveryService.openBatch(storeSlot);
     try {
       return write();
@@ -2003,7 +2079,7 @@ var OIMSlotCollectionService = class {
   }
 };
 
-// src/facade/slot/OIMWritableSlotCollectionService.ts
+// src/slot/OIMWritableSlotCollectionService.ts
 var OIMWritableSlotCollectionService = class extends OIMSlotCollectionService {
   writeSlotContentByKey(storeSlot, key, content, changedSlots) {
     const filed = this.slotStoreService.get(storeSlot.store, key);
@@ -2017,7 +2093,7 @@ var OIMWritableSlotCollectionService = class extends OIMSlotCollectionService {
   }
 };
 
-// src/facade/slot/OIMSingleSlotService.ts
+// src/slot/OIMSingleSlotService.ts
 var OIMSingleSlotService = class {
   constructor(options) {
     const slotOwnerService = new OIMSlotOwnerService({ ...options, slotFilingService: options.slotStoreService });
@@ -2068,7 +2144,7 @@ var OIMSingleSlotService = class {
   }
 };
 
-// src/facade/slot/OIMWritableSingleSlotService.ts
+// src/slot/OIMWritableSingleSlotService.ts
 var OIMWritableSingleSlotService = class extends OIMSingleSlotService {
   writeSingleSlotContent(storeSlot, content, changedSlots) {
     const filed = this.slotStoreService.getSingleSlot(storeSlot.store);
@@ -2086,7 +2162,7 @@ var OIMWritableSingleSlotService = class extends OIMSingleSlotService {
   }
 };
 
-// src/engine/entity/OIMSlotEntityPresenceEmptinessPolicy.ts
+// src/entity/OIMSlotEntityPresenceEmptinessPolicy.ts
 var _OIMSlotEntityPresenceEmptinessPolicy = class _OIMSlotEntityPresenceEmptinessPolicy {
   isEmpty(entitySlot) {
     return entitySlot.entity === void 0;
@@ -2095,8 +2171,8 @@ var _OIMSlotEntityPresenceEmptinessPolicy = class _OIMSlotEntityPresenceEmptines
 _OIMSlotEntityPresenceEmptinessPolicy.INSTANCE = new _OIMSlotEntityPresenceEmptinessPolicy();
 var OIMSlotEntityPresenceEmptinessPolicy = _OIMSlotEntityPresenceEmptinessPolicy;
 
-// src/engine/entity/utils/createOIMEntitySlot.ts
-function createOIMEntitySlot(key, owner, storeSlot = void 0) {
+// src/entity/utils/createOIMEntitySlot.ts
+function createOIMEntitySlot(key, owner, storeSlot) {
   return {
     effects: void 0,
     changedAtRevision: 0,
@@ -2117,8 +2193,8 @@ function createOIMEntitySlot(key, owner, storeSlot = void 0) {
   };
 }
 
-// src/engine/entity/utils/createOIMSingleEntitySlot.ts
-function createOIMSingleEntitySlot(owner, storeSlot) {
+// src/entity/utils/createOIMEntityContentSlot.ts
+function createOIMEntityContentSlot(owner, storeSlot) {
   const singleEntitySlot = {
     effects: void 0,
     changedAtRevision: 0,
@@ -2140,7 +2216,15 @@ function createOIMSingleEntitySlot(owner, storeSlot) {
   return singleEntitySlot;
 }
 
-// src/engine/entity/OIMSlotContentEntityService.ts
+// src/slot/utils/oimAssertSlotUnheld.ts
+var oimAssertSlotUnheld = (slot) => {
+  if (slot.holdCount === 0) return;
+  throw new Error(
+    "releaseSlotContent: this slot is still held, so its identity is not going. The slot owner calls releaseSlotContent when it releases a slot nothing holds; to empty a held slot, use clearSlotContent."
+  );
+};
+
+// src/entity/OIMSlotContentEntityService.ts
 var OIMSlotContentEntityService = class {
   constructor(options) {
     this.entityWriter = options.entityWriter;
@@ -2151,7 +2235,7 @@ var OIMSlotContentEntityService = class {
     return createOIMEntitySlot(key, slotOwner, storeSlot);
   }
   createSingleSlot(storeSlot, slotOwner) {
-    return createOIMSingleEntitySlot(slotOwner, storeSlot);
+    return createOIMEntityContentSlot(slotOwner, storeSlot);
   }
   isSlotEmpty(entitySlot) {
     return this.slotEmptinessPolicy.isEmpty(entitySlot);
@@ -2293,7 +2377,7 @@ var OIMSlotContentEntityService = class {
     slotOwnerService.assertWritable(entitySlot);
     const channelSlot = oimGetChannelSlot(entitySlot);
     if (!this.isOnFastPath(entitySlot)) {
-      this.releaseSlotContent(entitySlot);
+      this.clearEntityAndMarkColumns(entitySlot);
       slotOwnerService.settleEmptiness(entitySlot, this.slotEmptinessPolicy.isEmpty(entitySlot));
       slotOwnerService.dispatchContentChange(entitySlot);
       slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
@@ -2356,9 +2440,12 @@ var OIMSlotContentEntityService = class {
     slotOwnerService.releaseSlotIfUnheldAfterListeners(entitySlot);
   }
   releaseSlotContent(entitySlot) {
+    oimAssertSlotUnheld(entitySlot);
+    this.clearEntityAndMarkColumns(entitySlot);
+  }
+  clearEntityAndMarkColumns(entitySlot) {
     const entity = entitySlot.entity;
     if (entity === void 0) return;
-    this.slotOwnerServiceOf(entitySlot).assertWritable(entitySlot);
     this.entityWriter.clearEntity(entitySlot);
     this.dispatchColumnsChanged(entitySlot, entity, void 0);
   }
@@ -2390,34 +2477,21 @@ var OIMSlotContentEntityService = class {
   }
 };
 
-// src/factories/defaults/OIMDefaultValue.ts
+// src/db/OIMDefaultValue.ts
 var OIMDefaultValue = class {
-  constructor(name, createValue) {
+  constructor(createValue) {
     this.defaultValue = void 0;
-    this.isHandedOut = false;
-    this.name = name;
     this.createValue = createValue;
   }
   getValue() {
-    this.isHandedOut = true;
     return this.defaultValue ?? (this.defaultValue = this.createValue());
   }
-  setValue(value) {
-    this.assertNoLateOverride();
-    this.defaultValue = value;
-  }
-  assertNoLateOverride() {
-    if (!this.isHandedOut) return;
-    throw new Error(
-      `OIMDefaults.${this.name} has already been handed out, and whoever took it keeps it \u2014 so replacing it now leaves two implementations live in one process, the older one inside every object built before this call. Set it at startup, before anything reads it.`
-    );
-  }
 };
 
-// src/factories/defaults/OIM_DEFAULT_STORE_SLOT_LISTENER.ts
-var OIM_DEFAULT_STORE_SLOT_LISTENER = /* @__PURE__ */ new OIMDefaultValue("STORE_SLOT_LISTENER", () => OIMNoStoreSlotListener.INSTANCE);
+// src/db/constants/OIM_DEFAULT_STORE_SLOT_LISTENER.ts
+var OIM_DEFAULT_STORE_SLOT_LISTENER = /* @__PURE__ */ new OIMDefaultValue(() => OIMNoStoreSlotListener.INSTANCE);
 
-// src/engine/store/OIMSlotMapStoreService.ts
+// src/store/OIMSlotMapStoreService.ts
 var _OIMSlotMapStoreService = class _OIMSlotMapStoreService {
   createStore() {
     return /* @__PURE__ */ new Map();
@@ -2453,16 +2527,32 @@ var _OIMSlotMapStoreService = class _OIMSlotMapStoreService {
 _OIMSlotMapStoreService.INSTANCE = new _OIMSlotMapStoreService();
 var OIMSlotMapStoreService = _OIMSlotMapStoreService;
 
-// src/factories/utils/oimSlotStoreServiceWithDefault.ts
-function oimSlotStoreServiceWithDefault(slotStoreService) {
+// src/store/utils/oimResolveSlotStoreService.ts
+function oimResolveSlotStoreService(slotStoreService) {
   return slotStoreService ?? OIMSlotMapStoreService.INSTANCE;
 }
 
-// src/engine/column/OIMPushColumnSlotOwner.ts
+// src/db/OIMDefaults.ts
+var _OIMDefaults = class _OIMDefaults {
+  constructor(options = {}) {
+    this.slotStamp = options.slotStamp;
+    this.slotReleasePolicy = options.slotReleasePolicy;
+    this.entityWriter = options.entityWriter;
+    this.entitySlotEmptinessPolicy = options.entitySlotEmptinessPolicy;
+    this.indexKeysService = options.indexKeysService;
+    this.columnSlotStoreService = options.columnSlotStoreService;
+    this.computedColumnSlotStoreService = options.computedColumnSlotStoreService;
+    this.storeSlotListener = options.storeSlotListener;
+  }
+};
+_OIMDefaults.INSTANCE = new _OIMDefaults();
+var OIMDefaults = _OIMDefaults;
+
+// src/column/OIMPushColumnSlotOwner.ts
 var hasValueColumn = (value, columnName) => Object.prototype.hasOwnProperty.call(value, columnName) && value[columnName] !== void 0;
 var OIMPushColumnSlotOwner = class extends OIMColumnSlotOwner {
   constructor(options) {
-    super(oimColumnSlotStoreServiceOfColumnOwnerOptions(options));
+    super(oimColumnSlotStoreServiceOfColumnSlotOwnerOptions(options));
   }
   createColumnSlot(carrierSlot, key) {
     return {
@@ -2476,7 +2566,7 @@ var OIMPushColumnSlotOwner = class extends OIMColumnSlotOwner {
       releaseDueAfterUnholdMs: -1,
       slotFlags: OIM_SLOT_FLAG_EMPTY,
       columnSlotStore: void 0,
-      storeSlot: void 0,
+      storeSlot: carrierSlot.storeSlot,
       owner: this,
       key,
       carrierSlot
@@ -2545,51 +2635,51 @@ var OIMPushColumnSlotOwner = class extends OIMColumnSlotOwner {
   }
 };
 
-// src/engine/column/utils/createOIMPushColumnSlotOwner.ts
+// src/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/db/constants/OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.ts
+var OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue(() => OIMSlotMapStoreService.INSTANCE);
 
-// src/engine/column/utils/oimColumnOwnerOptions.ts
-function oimColumnOwnerOptions(columnSlotOwnerOptions) {
+// src/column/utils/oimColumnSlotOwnerOptions.ts
+function oimColumnSlotOwnerOptions(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/column/utils/oimResolveColumnSlotOwnerOptions.ts
+function oimResolveColumnSlotOwnerOptions(columnSlotStoreService, columnNames, defaultColumnSlotStoreService) {
+  return oimColumnSlotOwnerOptions({ columnNames, columnSlotStoreService: columnSlotStoreService ?? defaultColumnSlotStoreService });
 }
 
-// src/factories/utils/oimSlotOwnerOptionsWithDefault.ts
-function oimSlotOwnerOptionsWithDefault(db, options) {
+// src/slot/utils/oimResolveSlotOwnerServiceOptions.ts
+function oimResolveSlotOwnerServiceOptions(defaults, options) {
   return {
-    slotStamp: db.slotStamp,
-    slotReleasePolicy: options.slotReleasePolicy ?? db.slotReleasePolicy,
+    slotStamp: defaults.slotStamp,
+    slotReleasePolicy: options.slotReleasePolicy ?? defaults.slotReleasePolicy,
     slotSubscriptionListener: options.slotSubscriptionListener,
-    columnSlotOwnerOptions: oimColumnOwnerOptionsWithDefault(
+    columnSlotOwnerOptions: oimResolveColumnSlotOwnerOptions(
       options.columnSlotStoreService,
       options.columnNames,
-      OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.getValue()
+      defaults.columnSlotStoreService ?? OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE.getValue()
     ),
     createColumnSlotOwner: createOIMPushColumnSlotOwner
   };
 }
 
-// src/factories/createOIMSlotCollectionService.ts
-function createOIMSlotCollectionService(db, options) {
+// src/slot/createOIMSlotCollectionService.ts
+function createOIMSlotCollectionService(options) {
   return new OIMWritableSlotCollectionService({
-    ...oimSlotOwnerOptionsWithDefault(db, options),
-    slotStoreService: oimSlotStoreServiceWithDefault(options.slotStoreService),
+    ...oimResolveSlotOwnerServiceOptions(options.defaults ?? OIMDefaults.INSTANCE, options),
+    slotStoreService: oimResolveSlotStoreService(options.slotStoreService),
     slotContentService: options.slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+    storeSlotListener: options.defaults?.storeSlotListener ?? OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
   });
 }
 
-// src/engine/slot/constants/OIM_FROZEN_EMPTY_SLOTS.ts
+// src/slot/constants/OIM_FROZEN_EMPTY_SLOTS.ts
 var OIM_FROZEN_EMPTY_SLOTS = Object.freeze([]);
 
-// src/engine/store/OIMSingleSlotStoreService.ts
+// src/store/OIMSingleSlotStoreService.ts
 var _OIMSingleSlotStoreService = class _OIMSingleSlotStoreService {
   createStore() {
     return { slot: void 0 };
@@ -2614,36 +2704,36 @@ var _OIMSingleSlotStoreService = class _OIMSingleSlotStoreService {
 _OIMSingleSlotStoreService.INSTANCE = new _OIMSingleSlotStoreService();
 var OIMSingleSlotStoreService = _OIMSingleSlotStoreService;
 
-// src/factories/createOIMSingleSlotService.ts
-function createOIMSingleSlotService(db, options) {
+// src/slot/createOIMSingleSlotService.ts
+function createOIMSingleSlotService(options) {
   return new OIMWritableSingleSlotService({
-    ...oimSlotOwnerOptionsWithDefault(db, options),
+    ...oimResolveSlotOwnerServiceOptions(options.defaults ?? OIMDefaults.INSTANCE, options),
     slotStoreService: OIMSingleSlotStoreService.INSTANCE,
     slotContentService: options.slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+    storeSlotListener: options.defaults?.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", () => OIMSlotEntityPresenceEmptinessPolicy.INSTANCE);
+// src/db/constants/OIM_DEFAULT_ENTITY_SLOT_EMPTINESS_POLICY.ts
+var OIM_DEFAULT_ENTITY_SLOT_EMPTINESS_POLICY = /* @__PURE__ */ new OIMDefaultValue(() => OIMSlotEntityPresenceEmptinessPolicy.INSTANCE);
 
-// src/engine/entity/utils/oimClearEntity.ts
+// src/entity/utils/oimClearEntity.ts
 function oimClearEntity(entitySlot) {
   entitySlot.entity = void 0;
 }
 
-// src/engine/entity/constants/OIM_FROZEN_EMPTY_COLUMN_NAMES.ts
+// src/entity/constants/OIM_FROZEN_EMPTY_COLUMN_NAMES.ts
 var OIM_FROZEN_EMPTY_COLUMN_NAMES = Object.freeze([]);
 
-// src/engine/entity/constants/OIM_PROTO_KEY.ts
+// src/entity/constants/OIM_PROTO_KEY.ts
 var OIM_PROTO_KEY = "__proto__";
 
-// src/engine/entity/utils/oimIsProtoKey.ts
+// src/entity/utils/oimIsProtoKey.ts
 function oimIsProtoKey(name) {
   return name === OIM_PROTO_KEY;
 }
 
-// src/engine/entity/utils/oimOwnedColumnNames.ts
+// src/entity/utils/oimOwnedColumnNames.ts
 function oimOwnedColumnNames(slot, names) {
   const entity = slot.entity;
   if (entity === void 0) return void 0;
@@ -2657,12 +2747,12 @@ function oimOwnedColumnNames(slot, names) {
   return owned;
 }
 
-// src/engine/entity/utils/oimInsertEntityWithoutCopy.ts
+// src/entity/utils/oimInsertEntityWithoutCopy.ts
 function oimInsertEntityWithoutCopy(slot, entity) {
   slot.entity = entity;
 }
 
-// src/engine/entity/utils/oimPatchEntityColumns.ts
+// src/entity/utils/oimPatchEntityColumns.ts
 function oimPatchEntityColumns(slot, patch, sameValueGuard, changedColumnNames, targetOf) {
   const entity = slot.entity;
   if (entity === void 0) return void 0;
@@ -2676,7 +2766,7 @@ function oimPatchEntityColumns(slot, patch, sameValueGuard, changedColumnNames,
   return target;
 }
 
-// src/engine/entity/utils/oimPatchEntityColumn.ts
+// src/entity/utils/oimPatchEntityColumn.ts
 function oimPatchEntityColumn(slot, columnName, value, sameValueGuard, changedColumnNames, targetOf) {
   const entity = slot.entity;
   if (entity === void 0) return void 0;
@@ -2687,7 +2777,7 @@ function oimPatchEntityColumn(slot, columnName, value, sameValueGuard, changedCo
   return target;
 }
 
-// src/engine/entity/utils/oimClearDepartedEntityColumns.ts
+// src/entity/utils/oimClearDepartedEntityColumns.ts
 function oimClearDepartedEntityColumns(prevColumns, prevEntity, entity, patchedTarget, changedColumnNames, targetOf) {
   let target = patchedTarget;
   for (const name in prevColumns) {
@@ -2699,7 +2789,7 @@ function oimClearDepartedEntityColumns(prevColumns, prevEntity, entity, patchedT
   return target;
 }
 
-// src/engine/entity/utils/oimPutEntityColumns.ts
+// src/entity/utils/oimPutEntityColumns.ts
 function oimPutEntityColumns(slot, entity, sameValueGuard, changedColumnNames, targetOf) {
   const prevEntity = slot.entity;
   if (prevEntity === void 0) return void 0;
@@ -2707,8 +2797,8 @@ function oimPutEntityColumns(slot, entity, sameValueGuard, changedColumnNames, t
   return oimClearDepartedEntityColumns(prevEntity, prevEntity, entity, target, changedColumnNames, targetOf);
 }
 
-// src/factories/utils/oimEntityWriterOptionsWithDefault.ts
-function oimEntityWriterOptionsWithDefault(options) {
+// src/entity/utils/oimResolveEntityWriterOptions.ts
+function oimResolveEntityWriterOptions(options) {
   return {
     sameValueGuard: options?.sameValueGuard ?? oimSameValueZeroGuard,
     entityInserter: options?.entityInserter ?? oimInsertEntityWithoutCopy,
@@ -2718,7 +2808,7 @@ function oimEntityWriterOptionsWithDefault(options) {
   };
 }
 
-// src/factories/createOIMEntityWriterInPlace.ts
+// src/entity/createOIMInPlaceEntityWriter.ts
 var theEntityItself = (entity) => entity;
 function deleteColumnsInPlace(slot, names) {
   const deleted = oimOwnedColumnNames(slot, names);
@@ -2727,14 +2817,14 @@ function deleteColumnsInPlace(slot, names) {
   for (let i = 0; i < deleted.length; i++) entity[deleted[i]] = void 0;
   return deleted;
 }
-function createOIMEntityWriterInPlace(options) {
+function createOIMInPlaceEntityWriter(options) {
   const {
     sameValueGuard,
     entityInserter,
     putEntityColumns,
     patchEntityColumns,
     patchEntityColumn
-  } = oimEntityWriterOptionsWithDefault(options);
+  } = oimResolveEntityWriterOptions(options);
   return {
     fillEntity: entityInserter,
     clearEntity: oimClearEntity,
@@ -2745,19 +2835,20 @@ function createOIMEntityWriterInPlace(options) {
   };
 }
 
-// src/factories/defaults/OIM_DEFAULT_ENTITY_WRITER.ts
-var OIM_DEFAULT_ENTITY_WRITER = /* @__PURE__ */ new OIMDefaultValue("ENTITY_WRITER", () => createOIMEntityWriterInPlace());
+// src/db/constants/OIM_DEFAULT_ENTITY_WRITER.ts
+var OIM_DEFAULT_ENTITY_WRITER = /* @__PURE__ */ new OIMDefaultValue(() => createOIMInPlaceEntityWriter());
 
-// src/factories/createOIMSlotContentEntityService.ts
-function createOIMSlotContentEntityService(db, options = {}) {
+// src/entity/createOIMSlotContentEntityService.ts
+function createOIMSlotContentEntityService(options = {}) {
+  const defaults = options.defaults ?? OIMDefaults.INSTANCE;
   return new OIMSlotContentEntityService({
-    entityWriter: options.entityWriter ?? db.entityWriter ?? OIM_DEFAULT_ENTITY_WRITER.getValue(),
-    slotEmptinessPolicy: options.slotEmptinessPolicy ?? OIM_DEFAULT_ENTITY_SLOT_EMPTINESS.getValue()
+    entityWriter: options.entityWriter ?? defaults.entityWriter ?? OIM_DEFAULT_ENTITY_WRITER.getValue(),
+    slotEmptinessPolicy: options.slotEmptinessPolicy ?? defaults.entitySlotEmptinessPolicy ?? OIM_DEFAULT_ENTITY_SLOT_EMPTINESS_POLICY.getValue()
   });
 }
 
-// src/engine/bucket/utils/createOIMSingleBucketSlot.ts
-function createOIMSingleBucketSlot(owner, bucketSlotsStore, storeSlot) {
+// src/bucket/utils/createOIMBucketContentSlot.ts
+function createOIMBucketContentSlot(owner, bucketSlotsStore, storeSlot) {
   const singleBucketSlot = {
     effects: void 0,
     changedAtRevision: 0,
@@ -2782,7 +2873,7 @@ function createOIMSingleBucketSlot(owner, bucketSlotsStore, storeSlot) {
   return singleBucketSlot;
 }
 
-// src/engine/bucket/commands/OIMNoBucketCommands.ts
+// src/bucket/commands/OIMNoBucketCommands.ts
 var _OIMNoBucketCommands = class _OIMNoBucketCommands {
   recordInsert() {
     return;
@@ -2800,13 +2891,13 @@ var _OIMNoBucketCommands = class _OIMNoBucketCommands {
 _OIMNoBucketCommands.INSTANCE = new _OIMNoBucketCommands();
 var OIMNoBucketCommands = _OIMNoBucketCommands;
 
-// src/engine/bucket/constants/OIM_NOTHING_WAS_REMOVED.ts
+// src/bucket/constants/OIM_NOTHING_WAS_REMOVED.ts
 var OIM_NOTHING_WAS_REMOVED = -1;
 
-// src/engine/bucket/constants/OIM_REMOVED_WITHOUT_A_POSITION.ts
+// src/bucket/constants/OIM_REMOVED_WITHOUT_A_POSITION.ts
 var OIM_REMOVED_WITHOUT_A_POSITION = -2;
 
-// src/engine/bucket/utils/createOIMBucketSlot.ts
+// src/bucket/utils/createOIMBucketSlot.ts
 function createOIMBucketSlot(key, owner, bucketSlotsStore, storeSlot) {
   return {
     effects: void 0,
@@ -2831,16 +2922,16 @@ function createOIMBucketSlot(key, owner, bucketSlotsStore, storeSlot) {
   };
 }
 
-// src/engine/channel/utils/oimGetChannelQueueAtDepth.ts
+// src/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;
+  const existingChannelQueue = channelQueues[depth];
+  if (existingChannelQueue !== void 0) return existingChannelQueue;
+  const channelQueue = new OIMChannelQueue();
+  channelQueues[depth] = channelQueue;
+  return channelQueue;
 }
 
-// src/facade/bucket/OIMSlotContentBucketService.ts
+// src/bucket/OIMSlotContentBucketService.ts
 var OIMSlotContentBucketService = class {
   constructor(options) {
     this.bucketCommands = options.bucketCommands ?? OIMNoBucketCommands.INSTANCE;
@@ -2862,7 +2953,7 @@ var OIMSlotContentBucketService = class {
     );
   }
   createSingleSlot(storeSlot, slotOwner) {
-    return createOIMSingleBucketSlot(
+    return createOIMBucketContentSlot(
       slotOwner,
       this.createBucketMemberSlotsStore(),
       storeSlot
@@ -2874,11 +2965,9 @@ var OIMSlotContentBucketService = class {
   hasReference() {
     return false;
   }
-  releaseSlotContent(bucketSlot, slotOwnerService) {
-    if (this.getBucketMemberSlotCount(bucketSlot) === 0) return;
-    slotOwnerService.assertWritable(bucketSlot);
+  releaseSlotContent(bucketSlot) {
+    oimAssertSlotUnheld(bucketSlot);
     this.unholdAllBucketMemberSlots(bucketSlot);
-    slotOwnerService.dispatchContentChange(bucketSlot);
   }
   markContentChanged(bucketSlot) {
     bucketSlot.owner.assertWritable(bucketSlot);
@@ -2917,10 +3006,10 @@ var OIMSlotContentBucketService = class {
   removeBucketMemberSlots(bucketSlot, bucketMemberSlots) {
     const slotOwnerService = bucketSlot.owner;
     slotOwnerService.assertWritable(bucketSlot);
-    const storeSlotEditable = bucketSlot.storeSlot;
-    const writeDepth = storeSlotEditable.writeDepth++;
-    const removedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.departedBucketMemberSlotChannelQueues ?? (storeSlotEditable.departedBucketMemberSlotChannelQueues = []), writeDepth);
-    const removedAtChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.removedAtChannelQueues ?? (storeSlotEditable.removedAtChannelQueues = []), writeDepth);
+    const editableStoreSlot = bucketSlot.storeSlot;
+    const writeDepth = editableStoreSlot.writeDepth++;
+    const removedChannelQueue = oimGetChannelQueueAtDepth(editableStoreSlot.departedBucketMemberSlotChannelQueues ?? (editableStoreSlot.departedBucketMemberSlotChannelQueues = []), writeDepth);
+    const removedAtChannelQueue = oimGetChannelQueueAtDepth(editableStoreSlot.removedAtChannelQueues ?? (editableStoreSlot.removedAtChannelQueues = []), writeDepth);
     try {
       this.removeSlots(bucketSlot, bucketMemberSlots, removedChannelQueue, removedAtChannelQueue);
       const removedCount = removedChannelQueue.getEntryCount();
@@ -2931,7 +3020,7 @@ var OIMSlotContentBucketService = class {
     } finally {
       removedChannelQueue.keepFirstEntries(0);
       removedAtChannelQueue.keepFirstEntries(0);
-      storeSlotEditable.writeDepth = writeDepth;
+      editableStoreSlot.writeDepth = writeDepth;
     }
   }
   insertSlotContent(bucketSlot, bucketMemberSlots, changedBucketSlots) {
@@ -3004,10 +3093,10 @@ var OIMSlotContentBucketService = class {
   }
   reconcileBucketMemberSlots(bucketSlot, bucketMemberSlots) {
     this.assertBucketMemberSlotsNotReleased(bucketMemberSlots);
-    const storeSlotEditable = bucketSlot.storeSlot;
-    const writeDepth = storeSlotEditable.writeDepth++;
-    const arrivedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.arrivedBucketMemberSlotChannelQueues ?? (storeSlotEditable.arrivedBucketMemberSlotChannelQueues = []), writeDepth);
-    const departedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.departedBucketMemberSlotChannelQueues ?? (storeSlotEditable.departedBucketMemberSlotChannelQueues = []), writeDepth);
+    const editableStoreSlot = bucketSlot.storeSlot;
+    const writeDepth = editableStoreSlot.writeDepth++;
+    const arrivedChannelQueue = oimGetChannelQueueAtDepth(editableStoreSlot.arrivedBucketMemberSlotChannelQueues ?? (editableStoreSlot.arrivedBucketMemberSlotChannelQueues = []), writeDepth);
+    const departedChannelQueue = oimGetChannelQueueAtDepth(editableStoreSlot.departedBucketMemberSlotChannelQueues ?? (editableStoreSlot.departedBucketMemberSlotChannelQueues = []), writeDepth);
     try {
       this.reconcileSlots(bucketSlot, bucketMemberSlots, arrivedChannelQueue, departedChannelQueue);
       const arrivedCount = arrivedChannelQueue.getEntryCount();
@@ -3023,7 +3112,7 @@ var OIMSlotContentBucketService = class {
     } finally {
       arrivedChannelQueue.keepFirstEntries(0);
       departedChannelQueue.keepFirstEntries(0);
-      storeSlotEditable.writeDepth = writeDepth;
+      editableStoreSlot.writeDepth = writeDepth;
     }
   }
   drainBucketMemberSlots(bucketSlot) {
@@ -3033,9 +3122,9 @@ var OIMSlotContentBucketService = class {
     return true;
   }
   unholdAllBucketMemberSlots(bucketSlot) {
-    const storeSlotEditable = bucketSlot.storeSlot;
-    const writeDepth = storeSlotEditable.writeDepth++;
-    const departedChannelQueue = oimGetChannelQueueAtDepth(storeSlotEditable.departedBucketMemberSlotChannelQueues ?? (storeSlotEditable.departedBucketMemberSlotChannelQueues = []), writeDepth);
+    const editableStoreSlot = bucketSlot.storeSlot;
+    const writeDepth = editableStoreSlot.writeDepth++;
+    const departedChannelQueue = oimGetChannelQueueAtDepth(editableStoreSlot.departedBucketMemberSlotChannelQueues ?? (editableStoreSlot.departedBucketMemberSlotChannelQueues = []), writeDepth);
     try {
       this.drainSlots(bucketSlot, departedChannelQueue);
       const drainedCount = departedChannelQueue.getEntryCount();
@@ -3043,12 +3132,12 @@ var OIMSlotContentBucketService = class {
       return drainedCount;
     } finally {
       departedChannelQueue.keepFirstEntries(0);
-      storeSlotEditable.writeDepth = writeDepth;
+      editableStoreSlot.writeDepth = writeDepth;
     }
   }
 };
 
-// src/facade/bucket/OIMSlotContentSetBucketService.ts
+// src/bucket/OIMSlotContentSetBucketService.ts
 var OIMSlotContentSetBucketService = class extends OIMSlotContentBucketService {
   constructor(options = {}) {
     super(options);
@@ -3103,7 +3192,7 @@ var OIMSlotContentSetBucketService = class extends OIMSlotContentBucketService {
   }
 };
 
-// src/engine/bucket/array/OIMBucketMemberSlotsArrayService.ts
+// src/bucket/array/OIMBucketMemberSlotsArrayService.ts
 var insertionTailLimit = 8;
 var _OIMBucketMemberSlotsArrayService = class _OIMBucketMemberSlotsArrayService {
   createBucketSlotsArrayStore() {
@@ -3232,7 +3321,7 @@ function reverseRange(bucketMemberSlots, first, last) {
   }
 }
 
-// src/facade/bucket/OIMSlotContentArrayBucketService.ts
+// src/bucket/OIMSlotContentArrayBucketService.ts
 var OIMSlotContentArrayBucketService = class extends OIMSlotContentBucketService {
   constructor(options) {
     super(options);
@@ -3293,10 +3382,10 @@ var OIMSlotContentArrayBucketService = class extends OIMSlotContentBucketService
   }
 };
 
-// src/engine/bucket/constants/OIM_NOTHING_WAS_INSERTED.ts
+// src/bucket/constants/OIM_NOTHING_WAS_INSERTED.ts
 var OIM_NOTHING_WAS_INSERTED = -1;
 
-// src/engine/bucket/array/utils/oimAssertWholePosition.ts
+// src/bucket/array/utils/oimAssertWholePosition.ts
 function oimAssertWholePosition(position) {
   if (position === Math.trunc(position)) return;
   throw new Error(
@@ -3304,7 +3393,7 @@ function oimAssertWholePosition(position) {
   );
 }
 
-// src/facade/bucket/OIMSlotContentPositionalArrayBucketService.ts
+// src/bucket/OIMSlotContentPositionalArrayBucketService.ts
 var OIMSlotContentPositionalArrayBucketService = class extends OIMSlotContentArrayBucketService {
   constructor(options = {}) {
     super(options);
@@ -3377,7 +3466,7 @@ var OIMSlotContentPositionalArrayBucketService = class extends OIMSlotContentArr
   }
 };
 
-// src/engine/bucket/utils/oimSameUniqueSlotSequence.ts
+// src/bucket/utils/oimSameUniqueSlotSequence.ts
 function oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots) {
   const seenBucketMemberSlots = /* @__PURE__ */ new Set();
   let at = 0;
@@ -3391,7 +3480,7 @@ function oimSameUniqueSlotSequence(heldBucketMemberSlots, bucketMemberSlots) {
   return at === heldBucketMemberSlots.length;
 }
 
-// src/engine/bucket/array/OIMBucketUniqueMemberSlotsArrayService.ts
+// src/bucket/array/OIMBucketUniqueMemberSlotsArrayService.ts
 var _OIMBucketUniqueMemberSlotsArrayService = class _OIMBucketUniqueMemberSlotsArrayService extends OIMBucketMemberSlotsArrayService {
   createBucketSlotsArrayStore() {
     return { bucketMemberSlots: [], uniqueBucketMemberSlots: /* @__PURE__ */ new Set(), sortedCount: 0 };
@@ -3450,7 +3539,7 @@ function uniqueBucketMemberSlotsOf(bucketSlotsArrayStore) {
   return bucketSlotsArrayStore.uniqueBucketMemberSlots;
 }
 
-// src/facade/bucket/OIMSlotContentSortedArrayBucketService.ts
+// src/bucket/OIMSlotContentSortedArrayBucketService.ts
 var OIMSlotContentSortedArrayBucketService = class extends OIMSlotContentArrayBucketService {
   constructor(options) {
     super(options);
@@ -3480,169 +3569,7 @@ var OIMSlotContentSortedArrayBucketService = class extends OIMSlotContentArrayBu
   }
 };
 
-// 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", () => OIMSlotMapStoreService.INSTANCE);
-
-// src/engine/index/OIMIndexKeysService.ts
-var OIMIndexKeysService = class {
-  createPositions() {
-    return { nextPosition: 0, freePositions: [] };
-  }
-  get(slot, position) {
-    const indexKeys = slot.indexKeys;
-    return indexKeys === void 0 || position >= indexKeys.length ? void 0 : indexKeys[position];
-  }
-  set(slot, position, indexKey) {
-    const indexKeys = slot.indexKeys;
-    if (indexKeys !== void 0) {
-      if (position < indexKeys.length) {
-        indexKeys[position] = indexKey;
-        return;
-      }
-      if (indexKey === void 0) return;
-      while (indexKeys.length < position) indexKeys.push(void 0);
-      indexKeys.push(indexKey);
-      return;
-    }
-    if (indexKey === void 0) return;
-    const created = [];
-    while (created.length < position) created.push(void 0);
-    created.push(indexKey);
-    slot.indexKeys = created;
-  }
-};
-
-// src/engine/index/OIMAppendingIndexKeysService.ts
-var _OIMAppendingIndexKeysService = class _OIMAppendingIndexKeysService extends OIMIndexKeysService {
-  allocatePosition(positions) {
-    return positions.nextPosition++;
-  }
-  releasePosition() {
-    return;
-  }
-};
-_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", () => OIMAppendingIndexKeysService.INSTANCE);
-
-// src/engine/key/OIMKeyTreeWalk.ts
-var OIMKeyTreeWalk = class {
-  mintNodeAt(rootCompositeKeyNode, compositeKey) {
-    if (compositeKey.length === 0) throw new Error("OIMKeyTreeWalk: an empty key is not a key.");
-    let compositeKeyNode = rootCompositeKeyNode;
-    let firstMintedDepth = -1;
-    let parentOfFirstMintedCompositeKeyNode = rootCompositeKeyNode;
-    for (let i = 0; i < compositeKey.length; i++) {
-      const compositeKeyPart = compositeKey[i];
-      let nextCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKeyPart);
-      if (nextCompositeKeyNode === void 0) {
-        try {
-          this.holdCompositeKeyPart(compositeKeyPart);
-        } catch (failure) {
-          if (firstMintedDepth >= 0) {
-            parentOfFirstMintedCompositeKeyNode.childNodes?.delete(compositeKey[firstMintedDepth]);
-            for (let j = i - 1; j >= firstMintedDepth; j--) this.unholdCompositeKeyPart(compositeKey[j]);
-          }
-          throw failure;
-        }
-        nextCompositeKeyNode = { childNodes: void 0, atThisKey: void 0 };
-        (compositeKeyNode.childNodes ?? (compositeKeyNode.childNodes = /* @__PURE__ */ new Map())).set(compositeKeyPart, nextCompositeKeyNode);
-        if (firstMintedDepth < 0) {
-          firstMintedDepth = i;
-          parentOfFirstMintedCompositeKeyNode = compositeKeyNode;
-        }
-      }
-      compositeKeyNode = nextCompositeKeyNode;
-    }
-    return compositeKeyNode;
-  }
-  nodeAt(rootCompositeKeyNode, compositeKey) {
-    let compositeKeyNode = rootCompositeKeyNode;
-    for (let i = 0; i < compositeKey.length; i++) {
-      compositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[i]);
-      if (compositeKeyNode === void 0) return void 0;
-    }
-    return compositeKeyNode;
-  }
-  deleteKey(rootCompositeKeyNode, compositeKey) {
-    const lastDepth = compositeKey.length - 1;
-    if (lastDepth < 0) return void 0;
-    let compositeKeyNode = rootCompositeKeyNode;
-    let keptCompositeKeyNode = rootCompositeKeyNode;
-    let firstUnlinkedDepth = 0;
-    for (let i = 0; i < lastDepth; i++) {
-      const nextCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[i]);
-      if (nextCompositeKeyNode === void 0) return void 0;
-      compositeKeyNode = nextCompositeKeyNode;
-      if (compositeKeyNode.atThisKey !== void 0 || (compositeKeyNode.childNodes?.size ?? 0) > 1) {
-        keptCompositeKeyNode = compositeKeyNode;
-        firstUnlinkedDepth = i + 1;
-      }
-    }
-    const lastCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[lastDepth]);
-    if (lastCompositeKeyNode === void 0) return void 0;
-    const deletedAtKey = lastCompositeKeyNode.atThisKey;
-    if (deletedAtKey === void 0) return void 0;
-    lastCompositeKeyNode.atThisKey = void 0;
-    if ((lastCompositeKeyNode.childNodes?.size ?? 0) > 0) return deletedAtKey;
-    keptCompositeKeyNode.childNodes?.delete(compositeKey[firstUnlinkedDepth]);
-    for (let i = lastDepth; i >= firstUnlinkedDepth; i--) this.unholdCompositeKeyPart(compositeKey[i]);
-    return deletedAtKey;
-  }
-};
-
-// src/engine/key/OIMCompositeKeyTreeWalk.ts
-var _OIMCompositeKeyTreeWalk = class _OIMCompositeKeyTreeWalk extends OIMKeyTreeWalk {
-  holdCompositeKeyPart(entitySlot) {
-    entitySlot.owner.holdSlot(entitySlot);
-  }
-  unholdCompositeKeyPart(entitySlot) {
-    oimUnholdSlotIfAlive(entitySlot);
-  }
-};
-_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", () => OIMCompositeKeyTreeWalk.INSTANCE);
-
-// src/engine/key/OIMScalarKeyTreeWalk.ts
-var _OIMScalarKeyTreeWalk = class _OIMScalarKeyTreeWalk extends OIMKeyTreeWalk {
-  holdCompositeKeyPart() {
-    return;
-  }
-  unholdCompositeKeyPart() {
-    return;
-  }
-};
-_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", () => 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());
-
-// src/factories/OIMDefaults.ts
-var OIMDefaults = class {
-};
-OIMDefaults.COLUMN_SLOT_STORE_SERVICE = OIM_DEFAULT_COLUMN_SLOT_STORE_SERVICE;
-OIMDefaults.COMPUTED_COLUMN_SLOT_STORE_SERVICE = OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE;
-OIMDefaults.KEY_TREE_WALK_SCALAR = OIM_DEFAULT_KEY_TREE_WALK_SCALAR;
-OIMDefaults.KEY_TREE_WALK_COMPOSITE = OIM_DEFAULT_KEY_TREE_WALK_COMPOSITE;
-OIMDefaults.STANDALONE_SLOT_OWNER = OIM_DEFAULT_STANDALONE_SLOT_OWNER;
-OIMDefaults.ENTITY_WRITER = OIM_DEFAULT_ENTITY_WRITER;
-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/createOIMPullColumnSlotOwner.ts
-var createOIMPullColumnSlotOwner = (columnSlotOwnerOptions) => new OIMPullColumnSlotOwner(columnSlotOwnerOptions);
-
-// src/engine/computed/OIMComputedSourcesService.ts
+// src/computed/OIMComputedSourcesService.ts
 var _OIMComputedSourcesService = class _OIMComputedSourcesService {
   holdSources(derivation) {
     oimHoldSlots(derivation.sourceSlots);
@@ -3658,8 +3585,8 @@ var _OIMComputedSourcesService = class _OIMComputedSourcesService {
 _OIMComputedSourcesService.INSTANCE = new _OIMComputedSourcesService();
 var OIMComputedSourcesService = _OIMComputedSourcesService;
 
-// src/engine/computed/utils/createOIMSingleComputedSlot.ts
-function createOIMSingleComputedSlot(owner, computedValueService, initialValue, storeSlot) {
+// src/computed/utils/createOIMComputedContentSlot.ts
+function createOIMComputedContentSlot(owner, computedValueService, initialValue, storeSlot, sourceTracker) {
   const singleComputedSlot = {
     effects: void 0,
     changedAtRevision: 0,
@@ -3684,12 +3611,13 @@ function createOIMSingleComputedSlot(owner, computedValueService, initialValue,
     checkedAtRevision: -1,
     checkedAtEpoch: -1,
     isDeriving: false,
-    allRootSlots: void 0
+    allRootSlots: void 0,
+    sourceTracker
   };
   return singleComputedSlot;
 }
 
-// src/engine/computed/OIMSlotContentComputedService.ts
+// src/computed/OIMSlotContentComputedService.ts
 var OIMSlotContentComputedService = class {
   constructor(options) {
     this.computedValueService = options.computedValueService;
@@ -3702,13 +3630,20 @@ var OIMSlotContentComputedService = class {
       slotOwner,
       this.computedValueService,
       this.initialValue,
-      storeSlot
+      storeSlot,
+      this.createSourceTracker()
     );
     this.attachSources(computedSlot, storeSlot);
     return computedSlot;
   }
   createSingleSlot(storeSlot, slotOwner) {
-    const computedSlot = createOIMSingleComputedSlot(slotOwner, this.computedValueService, this.initialValue, storeSlot);
+    const computedSlot = createOIMComputedContentSlot(
+      slotOwner,
+      this.computedValueService,
+      this.initialValue,
+      storeSlot,
+      this.createSourceTracker()
+    );
     this.attachSources(computedSlot, storeSlot);
     return computedSlot;
   }
@@ -3716,56 +3651,67 @@ var OIMSlotContentComputedService = class {
     return false;
   }
   releaseSlotContent(computedSlot) {
+    oimAssertSlotUnheld(computedSlot);
     OIMComputedSourcesService.INSTANCE.unholdSources(computedSlot);
+    this.computedValueService.releaseSlotValue(computedSlot);
   }
   hasReference() {
     return false;
   }
+  createSourceTracker() {
+    return void 0;
+  }
   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;
+    const editableComputedSlot = computedSlot;
+    editableComputedSlot.sourceSlots = computedSources.sourceSlots ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
+    editableComputedSlot.sourceComputeds = computedSources.sourceComputeds ?? OIM_FROZEN_EMPTY_COMPUTED_SLOTS;
     OIMComputedSourcesService.INSTANCE.holdSources(computedSlot);
   }
 };
 
-// src/facade/computed/utils/createOIMComputedCollectionService.ts
-function createOIMComputedCollectionService(options) {
+// src/column/utils/createOIMPullColumnSlotOwner.ts
+var createOIMPullColumnSlotOwner = (columnSlotOwnerOptions) => new OIMPullColumnSlotOwner(columnSlotOwnerOptions);
+
+// src/computed/utils/createOIMComputedSlotCollectionService.ts
+function createOIMComputedSlotCollectionService(options) {
   return new OIMSlotCollectionService({
     slotReleasePolicy: options.slotReleasePolicy,
     slotStoreService: options.computedSlotStoreService,
-    slotContentService: new OIMSlotContentComputedService(options),
+    slotContentService: options.slotContentService,
     columnSlotOwnerOptions: options.columnSlotOwnerOptions,
     createColumnSlotOwner: createOIMPullColumnSlotOwner,
     storeSlotListener: options.storeSlotListener
   });
 }
 
-// src/facade/computed/utils/oimAttachComputedDerivation.ts
+// src/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;
+  const editableComputedStoreSlot = computedStoreSlot;
+  editableComputedStoreSlot.derive = derive;
+  editableComputedStoreSlot.createSources = createSources;
   return computedStoreSlot;
 }
 
-// src/facade/computed/OIMComputedService.ts
+// src/computed/OIMComputedService.ts
 var OIMComputedService = class {
   constructor(options) {
-    this.computedCollectionService = createOIMComputedCollectionService({
-      computedValueService: new OIMComputedValueService({
-        derive: options.derive,
-        sameValueGuard: options.sameValueGuard
+    this.computedCollectionService = createOIMComputedSlotCollectionService({
+      slotContentService: new OIMSlotContentComputedService({
+        computedValueService: new OIMComputedValueService({
+          derive: options.derive,
+          sameValueGuard: options.sameValueGuard,
+          releaseValue: options.releaseValue
+        }),
+        createSources: options.createSources,
+        initialValue: options.initialValue
       }),
-      createSources: options.createSources,
-      initialValue: options.initialValue,
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
       columnSlotOwnerOptions: options.columnSlotOwnerOptions,
@@ -3785,7 +3731,7 @@ var OIMComputedService = class {
   }
 };
 
-// src/engine/collector/OIMSlotAtUnholdReleasePolicy.ts
+// src/collector/OIMSlotAtUnholdReleasePolicy.ts
 var _OIMSlotAtUnholdReleasePolicy = class _OIMSlotAtUnholdReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = true;
@@ -3813,25 +3759,37 @@ var _OIMSlotAtUnholdReleasePolicy = class _OIMSlotAtUnholdReleasePolicy {
 _OIMSlotAtUnholdReleasePolicy.INSTANCE = new _OIMSlotAtUnholdReleasePolicy();
 var OIMSlotAtUnholdReleasePolicy = _OIMSlotAtUnholdReleasePolicy;
 
-// src/factories/createOIMComputedService.ts
-function createOIMComputedService(options) {
-  return new OIMComputedService({
-    computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
-    columnSlotOwnerOptions: oimColumnOwnerOptionsWithDefault(
+// src/db/constants/OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.ts
+var OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE = /* @__PURE__ */ new OIMDefaultValue(() => OIMSlotMapStoreService.INSTANCE);
+
+// src/computed/utils/oimResolveComputedDerivationOptions.ts
+function oimResolveComputedDerivationOptions(options) {
+  const defaults = options.defaults ?? OIMDefaults.INSTANCE;
+  return {
+    columnSlotOwnerOptions: oimResolveColumnSlotOwnerOptions(
       options.columnSlotStoreService,
       options.columnNames,
-      OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue()
+      defaults.computedColumnSlotStoreService ?? 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,
+    storeSlotListener: defaults.storeSlotListener ?? OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
     sameValueGuard: options.sameValueGuard,
+    releaseValue: options.releaseValue,
     initialValue: options.initialValue
+  };
+}
+
+// src/computed/createOIMComputedService.ts
+function createOIMComputedService(options) {
+  return new OIMComputedService({
+    computedSlotStoreService: oimResolveSlotStoreService(options.computedSlotStoreService),
+    ...oimResolveComputedDerivationOptions(options),
+    createSources: options.createSources,
+    derive: options.derive
   });
 }
 
-// src/facade/computed/OIMSingleComputedService.ts
+// src/computed/OIMSingleComputedService.ts
 var OIMSingleComputedService = class {
   constructor(options) {
     this.computedSingleSlotService = new OIMSingleSlotService({
@@ -3840,7 +3798,8 @@ var OIMSingleComputedService = class {
       slotContentService: new OIMSlotContentComputedService({
         computedValueService: new OIMComputedValueService({
           derive: options.derive,
-          sameValueGuard: options.sameValueGuard
+          sameValueGuard: options.sameValueGuard,
+          releaseValue: options.releaseValue
         }),
         createSources: options.createSources,
         initialValue: options.initialValue
@@ -3863,30 +3822,133 @@ var OIMSingleComputedService = class {
   }
 };
 
-// src/factories/createOIMSingleComputedService.ts
+// src/computed/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 ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
+    ...oimResolveComputedDerivationOptions(options),
     createSources: options.createSources,
-    derive: options.derive,
-    sameValueGuard: options.sameValueGuard,
-    initialValue: options.initialValue
+    derive: options.derive
   });
 }
 
-// src/facade/computed/utils/oimColumnsComparator.ts
+// src/computed/OIMSourceTrackingComputedValueService.ts
+var OIMSourceTrackingComputedValueService = class extends OIMComputedValueService {
+  constructor(options) {
+    super({ sameValueGuard: options.sameValueGuard, releaseValue: options.releaseValue });
+    this.deriveTrackingSources = (computedSlot) => {
+      const sourceTracker = computedSlot.sourceTracker;
+      sourceTracker.openSourceTracking();
+      const value = this.sourceTrackingDerive(computedSlot, sourceTracker);
+      if (sourceTracker.closeSourceTracking() && !oimIsSlotReleased(computedSlot)) this.replaceSources(computedSlot, sourceTracker);
+      return value;
+    };
+    this.sourceTrackingDerive = options.derive;
+  }
+  getValueForSlot(computedSlot) {
+    oimAssertSlotNotReleased(computedSlot);
+    const sourceTracker = computedSlot.sourceTracker;
+    oimRefreshComputedSlot(computedSlot, this.deriveTrackingSources, this.sameValueGuard, this.releaseValue, computedSlot.storeSlot.channelSlot.clock);
+    if (sourceTracker.trackReplacedRootSlots()) {
+      sourceTracker.commitTrackedSources();
+      computedSlot.allRootSlots = void 0;
+    }
+    return computedSlot.value;
+  }
+  replaceSources(computedSlot, sourceTracker) {
+    const trackedSourceSlots = sourceTracker.getTrackedSourceSlots().slice();
+    const trackedSourceComputeds = sourceTracker.getTrackedSourceComputeds().slice();
+    oimHoldSlots(trackedSourceSlots);
+    oimHoldSlots(trackedSourceComputeds);
+    OIMComputedSourcesService.INSTANCE.unholdSources(computedSlot);
+    const editableComputedSlot = computedSlot;
+    editableComputedSlot.sourceSlots = trackedSourceSlots;
+    editableComputedSlot.sourceComputeds = trackedSourceComputeds;
+    editableComputedSlot.allRootSlots = void 0;
+    sourceTracker.commitTrackedSources();
+  }
+};
+
+// src/computed/OIMSlotContentSourceTrackingComputedService.ts
+var OIMSlotContentSourceTrackingComputedService = class extends OIMSlotContentComputedService {
+  createSourceTracker() {
+    return new OIMSourceTracker();
+  }
+  attachSources() {
+    return;
+  }
+};
+
+// src/computed/OIMSourceTrackingComputedService.ts
+var OIMSourceTrackingComputedService = class {
+  constructor(options) {
+    this.computedCollectionService = createOIMComputedSlotCollectionService({
+      slotContentService: new OIMSlotContentSourceTrackingComputedService({
+        computedValueService: new OIMSourceTrackingComputedValueService({
+          derive: options.derive,
+          sameValueGuard: options.sameValueGuard,
+          releaseValue: options.releaseValue
+        }),
+        initialValue: options.initialValue
+      }),
+      slotReleasePolicy: options.slotReleasePolicy,
+      computedSlotStoreService: options.computedSlotStoreService,
+      columnSlotOwnerOptions: options.columnSlotOwnerOptions,
+      storeSlotListener: options.storeSlotListener
+    });
+  }
+  createComputedStoreSlot(channelMap) {
+    return this.computedCollectionService.createStoreSlot(channelMap);
+  }
+};
+
+// src/computed/OIMSingleSourceTrackingComputedService.ts
+var OIMSingleSourceTrackingComputedService = class {
+  constructor(options) {
+    this.computedSingleSlotService = new OIMSingleSlotService({
+      slotReleasePolicy: options.slotReleasePolicy,
+      slotStoreService: OIMSingleSlotStoreService.INSTANCE,
+      slotContentService: new OIMSlotContentSourceTrackingComputedService({
+        computedValueService: new OIMSourceTrackingComputedValueService({
+          derive: options.derive,
+          sameValueGuard: options.sameValueGuard,
+          releaseValue: options.releaseValue
+        }),
+        initialValue: options.initialValue
+      }),
+      columnSlotOwnerOptions: options.columnSlotOwnerOptions,
+      createColumnSlotOwner: createOIMPullColumnSlotOwner,
+      storeSlotListener: options.storeSlotListener
+    });
+  }
+  createComputedStoreSlot(channelMap) {
+    return this.computedSingleSlotService.createStoreSlot(channelMap);
+  }
+};
+
+// src/computed/createOIMSourceTrackingComputedService.ts
+function createOIMSourceTrackingComputedService(options) {
+  return new OIMSourceTrackingComputedService({
+    computedSlotStoreService: oimResolveSlotStoreService(options.computedSlotStoreService),
+    ...oimResolveComputedDerivationOptions(options),
+    derive: options.derive
+  });
+}
+
+// src/computed/createOIMSingleSourceTrackingComputedService.ts
+function createOIMSingleSourceTrackingComputedService(options) {
+  return new OIMSingleSourceTrackingComputedService({
+    ...oimResolveComputedDerivationOptions(options),
+    derive: options.derive
+  });
+}
+
+// src/computed/utils/oimColumnsComparator.ts
 function oimColumnsComparator(columns) {
   return (left, right) => {
     for (let i = 0; i < columns.length; i++) {
-      const column = columns[i].column;
-      const leftValue = left[column];
-      const rightValue = right[column];
+      const columnName = columns[i].columnName;
+      const leftValue = left[columnName];
+      const rightValue = right[columnName];
       if (leftValue === rightValue) continue;
       const isLeftMissing = leftValue === void 0 || leftValue === null || leftValue !== leftValue;
       const isRightMissing = rightValue === void 0 || rightValue === null || rightValue !== rightValue;
@@ -3900,7 +3962,7 @@ function oimColumnsComparator(columns) {
   };
 }
 
-// src/facade/computed/utils/oimEntitySlotsComparator.ts
+// src/computed/utils/oimEntitySlotsComparator.ts
 function oimEntitySlotsComparator(compareEntities) {
   return (leftEntitySlot, rightEntitySlot) => {
     const leftEntity = leftEntitySlot.entity;
@@ -3911,7 +3973,7 @@ function oimEntitySlotsComparator(compareEntities) {
   };
 }
 
-// src/facade/computed/OIMSortedComputedService.ts
+// src/computed/OIMSortedComputedService.ts
 var OIMSortedComputedService = class {
   constructor(options) {
     const indexService = options.indexService;
@@ -3925,16 +3987,18 @@ var OIMSortedComputedService = class {
       derive: (computedSlot) => sortBucketMemberSlots(computedSlot, bucketContentService, compareEntitySlots),
       sameValueGuard: oimSameSlotSequence
     });
-    this.computedCollectionService = createOIMComputedCollectionService({
-      computedValueService,
-      createSources: (computedSlot) => createSortedSources(
-        computedSlot.key,
-        computedSlot.storeSlot,
-        indexService,
-        sortColumns,
-        hasComparator
-      ),
-      initialValue: OIM_FROZEN_EMPTY_SLOTS,
+    this.computedCollectionService = createOIMComputedSlotCollectionService({
+      slotContentService: new OIMSlotContentComputedService({
+        computedValueService,
+        createSources: (computedSlot) => createSortedComputedSources(
+          computedSlot.key,
+          computedSlot.storeSlot,
+          indexService,
+          sortColumns,
+          hasComparator
+        ),
+        initialValue: OIM_FROZEN_EMPTY_SLOTS
+      }),
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
       columnSlotOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
@@ -3948,12 +4012,12 @@ var OIMSortedComputedService = class {
 function compareNothing() {
   return 0;
 }
-function createSortedSources(key, storeSlot, indexService, sortColumns, hasComparator) {
+function createSortedComputedSources(key, storeSlot, indexService, sortColumns, hasComparator) {
   const indexStoreSlot = storeSlot.sourceStoreSlot;
   const sourceSlots = [indexService.getSlotByKey(indexStoreSlot, key)];
   if (sortColumns !== void 0) {
     for (let i = 0; i < sortColumns.length; i++) {
-      sourceSlots.push(indexService.getBucketColumnByKey(indexStoreSlot, key, sortColumns[i].column));
+      sourceSlots.push(indexService.getBucketColumnByKey(indexStoreSlot, key, sortColumns[i].columnName));
     }
   } else if (hasComparator) {
     sourceSlots.push(indexService.getAnyBucketColumnByKey(indexStoreSlot, key));
@@ -4018,20 +4082,21 @@ function reconcileArrayWithEveryBucketMemberSlot(entitySlots, bucketMemberSlots)
   return next;
 }
 
-// src/factories/createOIMSortedComputedService.ts
+// src/computed/createOIMSortedComputedService.ts
 function createOIMSortedComputedService(options) {
+  const defaults = options.defaults ?? OIMDefaults.INSTANCE;
   return new OIMSortedComputedService({
     indexService: options.indexService,
-    computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
-    columnSlotStoreService: options.columnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
+    computedSlotStoreService: oimResolveSlotStoreService(options.computedSlotStoreService),
+    columnSlotStoreService: options.columnSlotStoreService ?? defaults.computedColumnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
     sortColumns: options.sortColumns,
     comparator: options.comparator,
     slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+    storeSlotListener: defaults.storeSlotListener ?? OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
   });
 }
 
-// src/facade/computed/OIMBucketMemoComputedService.ts
+// src/computed/OIMBucketMemoComputedService.ts
 var OIMBucketMemoComputedService = class {
   constructor(options) {
     const bucketCollectionService = options.bucketCollectionService;
@@ -4040,10 +4105,12 @@ var OIMBucketMemoComputedService = class {
       derive: (computedSlot) => deriveBucketMemo(computedSlot, bucketContentService),
       sameValueGuard: oimSameSlotSequence
     });
-    this.computedCollectionService = createOIMComputedCollectionService({
-      computedValueService,
-      createSources: (computedSlot) => createBucketMemoSources(computedSlot.key, computedSlot.storeSlot, bucketCollectionService),
-      initialValue: OIM_FROZEN_EMPTY_SLOTS,
+    this.computedCollectionService = createOIMComputedSlotCollectionService({
+      slotContentService: new OIMSlotContentComputedService({
+        computedValueService,
+        createSources: (computedSlot) => createBucketMemoComputedSources(computedSlot.key, computedSlot.storeSlot, bucketCollectionService),
+        initialValue: OIM_FROZEN_EMPTY_SLOTS
+      }),
       slotReleasePolicy: options.slotReleasePolicy,
       computedSlotStoreService: options.computedSlotStoreService,
       columnSlotOwnerOptions: { columnSlotStoreService: options.columnSlotStoreService },
@@ -4057,26 +4124,27 @@ var OIMBucketMemoComputedService = class {
 function deriveBucketMemo(computedSlot, bucketContentService) {
   return Array.from(bucketContentService.getBucketMemberSlots(computedSlot.sourceSlots[0]));
 }
-function createBucketMemoSources(key, storeSlot, bucketCollectionService) {
+function createBucketMemoComputedSources(key, storeSlot, bucketCollectionService) {
   const bucketStoreSlot = storeSlot.sourceStoreSlot;
   return { sourceSlots: [bucketCollectionService.getSlotByKey(bucketStoreSlot, key)] };
 }
 
-// src/factories/createOIMBucketMemoComputedService.ts
+// src/computed/createOIMBucketMemoComputedService.ts
 function createOIMBucketMemoComputedService(options) {
+  const defaults = options.defaults ?? OIMDefaults.INSTANCE;
   return new OIMBucketMemoComputedService({
     bucketCollectionService: options.bucketCollectionService,
-    computedSlotStoreService: oimSlotStoreServiceWithDefault(options.computedSlotStoreService),
-    columnSlotStoreService: options.columnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
+    computedSlotStoreService: oimResolveSlotStoreService(options.computedSlotStoreService),
+    columnSlotStoreService: options.columnSlotStoreService ?? defaults.computedColumnSlotStoreService ?? OIM_DEFAULT_COMPUTED_COLUMN_SLOT_STORE_SERVICE.getValue(),
     slotReleasePolicy: options.slotReleasePolicy ?? OIMSlotAtUnholdReleasePolicy.INSTANCE,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
+    storeSlotListener: defaults.storeSlotListener ?? OIM_DEFAULT_STORE_SLOT_LISTENER.getValue()
   });
 }
 
-// src/engine/bucket/commands/constants/OIM_MAX_COMMANDS_PER_SLOT.ts
+// src/bucket/commands/constants/OIM_MAX_COMMANDS_PER_SLOT.ts
 var OIM_MAX_COMMANDS_PER_SLOT = 1;
 
-// src/facade/bucket/OIMBucketCommands.ts
+// src/bucket/OIMBucketCommands.ts
 var OIMBucketCommands = class {
   constructor(options) {
     this.maxCommandsPerSlot = options.maxCommandsPerSlot ?? OIM_MAX_COMMANDS_PER_SLOT;
@@ -4091,40 +4159,40 @@ var OIMBucketCommands = class {
     this.recordCommand(bucketSlot, { type: "move", from, to }, bucketMemberSlotCount);
   }
   recordWholeList(bucketSlot) {
-    const bucketSlotEditable = enlistInFlush(bucketSlot);
-    const commands = bucketSlotEditable.commands;
+    const editableBucketSlot = enlistInFlush(bucketSlot);
+    const commands = editableBucketSlot.commands;
     if (commands !== void 0 && commands.length !== 0) commands.length = 0;
-    bucketSlotEditable.isWholeListRecorded = true;
+    editableBucketSlot.isWholeListRecorded = true;
   }
   recordCommand(bucketSlot, orderedListCommand, bucketMemberSlotCount) {
-    const bucketSlotEditable = enlistInFlush(bucketSlot);
-    if (bucketSlotEditable.isWholeListRecorded) return;
-    const commands = bucketSlotEditable.commands ?? (bucketSlotEditable.commands = []);
+    const editableBucketSlot = enlistInFlush(bucketSlot);
+    if (editableBucketSlot.isWholeListRecorded) return;
+    const commands = editableBucketSlot.commands ?? (editableBucketSlot.commands = []);
     commands.push(orderedListCommand);
     if (commands.length > this.maxCommandsPerSlot * bucketMemberSlotCount) {
       commands.length = 0;
-      bucketSlotEditable.isWholeListRecorded = true;
+      editableBucketSlot.isWholeListRecorded = true;
     }
   }
 };
 function enlistInFlush(bucketSlot) {
-  const bucketSlotEditable = bucketSlot;
+  const editableBucketSlot = 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;
+  const commands = editableBucketSlot.commands;
+  const hasScript = commands !== void 0 && commands.length > 0 || editableBucketSlot.isWholeListRecorded;
+  if (hasScript && !isScriptStale(channelSlot, editableBucketSlot)) return editableBucketSlot;
   if (hasScript) {
-    clearScript(bucketSlotEditable);
+    clearScript(editableBucketSlot);
   } else {
     const commandsBucketSlotChannelQueue = storeSlot.commandsBucketSlotChannelQueue ?? (storeSlot.commandsBucketSlotChannelQueue = new OIMChannelQueue());
     if (commandsBucketSlotChannelQueue.getEntryCount() === 0) getCommandsStoreSlotChannelQueue(channelSlot).enqueueEntry(storeSlot);
-    commandsBucketSlotChannelQueue.enqueueEntry(bucketSlotEditable);
+    commandsBucketSlotChannelQueue.enqueueEntry(editableBucketSlot);
   }
   const clock = channelSlot.clock;
-  bucketSlotEditable.commandsStartedAtRevision = clock.revision;
-  bucketSlotEditable.commandsStartedAtEpoch = clock.epoch;
-  return bucketSlotEditable;
+  editableBucketSlot.commandsStartedAtRevision = clock.revision;
+  editableBucketSlot.commandsStartedAtEpoch = clock.epoch;
+  return editableBucketSlot;
 }
 function getCommandsStoreSlotChannelQueue(channelSlot) {
   const commandsStoreSlotChannelQueue = channelSlot.commandsStoreSlotChannelQueue;
@@ -4145,10 +4213,10 @@ function isScriptStale(channelSlot, bucketSlot) {
     bucketSlot.commandsStartedAtEpoch
   );
 }
-function clearScript(bucketSlotEditable) {
-  const commands = bucketSlotEditable.commands;
+function clearScript(editableBucketSlot) {
+  const commands = editableBucketSlot.commands;
   if (commands !== void 0 && commands.length !== 0) commands.length = 0;
-  bucketSlotEditable.isWholeListRecorded = false;
+  editableBucketSlot.isWholeListRecorded = false;
 }
 function clearStaleScripts(channelSlot, commandsStoreSlotChannelQueue) {
   let keptStoreSlotCount = 0;
@@ -4157,12 +4225,12 @@ function clearStaleScripts(channelSlot, commandsStoreSlotChannelQueue) {
     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);
+      const editableBucketSlot = commandsBucketSlotChannelQueue.getEntryAt(j);
+      if (!isScriptStale(channelSlot, editableBucketSlot)) {
+        commandsBucketSlotChannelQueue.setEntryAt(keptBucketSlotCount++, editableBucketSlot);
         continue;
       }
-      clearScript(bucketSlotEditable);
+      clearScript(editableBucketSlot);
     }
     commandsBucketSlotChannelQueue.keepFirstEntries(keptBucketSlotCount);
     if (keptBucketSlotCount !== 0) commandsStoreSlotChannelQueue.setEntryAt(keptStoreSlotCount++, storeSlot);
@@ -4170,7 +4238,7 @@ function clearStaleScripts(channelSlot, commandsStoreSlotChannelQueue) {
   commandsStoreSlotChannelQueue.keepFirstEntries(keptStoreSlotCount);
 }
 
-// src/engine/index/utils/createOIMIndexStoreSlot.ts
+// src/index/utils/createOIMIndexStoreSlot.ts
 function createOIMIndexStoreSlot(store, slotService, sourceStoreSlot, contentChangeListener) {
   return {
     ...createOIMStoreSlot(store, sourceStoreSlot.channelSlot, slotService),
@@ -4184,7 +4252,7 @@ function createOIMIndexStoreSlot(store, slotService, sourceStoreSlot, contentCha
   };
 }
 
-// src/facade/index/OIMSlotCollectionIndexService.ts
+// src/index/OIMSlotCollectionIndexService.ts
 var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
   constructor(options) {
     super(options);
@@ -4199,26 +4267,26 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
       onContentChanged: (entitySlot, patch, changedColumns) => {
         this.updateIndexKeyForSlot(indexStoreSlot, entitySlot, patch, changedColumns);
       },
-      onContentChangedMany: (entitySlotChannelQueue, patchChannelQueue, changedColumnsChannelQueue) => {
+      onManyContentsChanged: (entitySlotChannelQueue, patchChannelQueue, changedColumnsChannelQueue) => {
         this.updateIndexKeysForSlots(indexStoreSlot, entitySlotChannelQueue, patchChannelQueue, changedColumnsChannelQueue);
       }
     };
-    const indexStoreSlot = this.createStoreSlotWith((store) => createOIMIndexStoreSlot(store, this, sourceStoreSlot, contentChangeListener));
+    const indexStoreSlot = this.createStoreSlotOverNewStore((store) => createOIMIndexStoreSlot(store, this, sourceStoreSlot, contentChangeListener));
     const indexKeysService = this.indexKeysService;
     const indexKeysPositions = sourceStoreSlot.indexKeysPositions ?? (sourceStoreSlot.indexKeysPositions = indexKeysService.createPositions());
     indexStoreSlot.indexKeysPosition = indexKeysService.allocatePosition(indexKeysPositions);
-    OIMContentChangeListenerService.INSTANCE.addContentChangeListener(sourceStoreSlot, contentChangeListener, this.keyColumns);
+    OIMSlotContentChangeListenerService.INSTANCE.addContentChangeListener(sourceStoreSlot, contentChangeListener, this.keyColumns);
     return indexStoreSlot;
   }
   disposeIndexStoreSlot(indexStoreSlot) {
     this.assertNotDisposed(indexStoreSlot);
     OIMChannelService.INSTANCE.assertNotFlushing(indexStoreSlot.channelSlot);
     const sourceStoreSlot = indexStoreSlot.sourceStoreSlot;
-    OIMContentChangeListenerService.INSTANCE.removeContentChangeListener(sourceStoreSlot, indexStoreSlot.contentChangeListener);
+    OIMSlotContentChangeListenerService.INSTANCE.removeContentChangeListener(sourceStoreSlot, indexStoreSlot.contentChangeListener);
     for (const bucketColumnName of indexStoreSlot.bucketColumnNames) {
-      OIMContentChangeListenerService.INSTANCE.removeReadColumn(sourceStoreSlot, bucketColumnName);
+      OIMSlotContentChangeListenerService.INSTANCE.removeReadColumn(sourceStoreSlot, bucketColumnName);
     }
-    if (indexStoreSlot.isAnyBucketColumnRead) OIMContentChangeListenerService.INSTANCE.removeReadAnyColumn(sourceStoreSlot);
+    if (indexStoreSlot.isAnyBucketColumnRead) OIMSlotContentChangeListenerService.INSTANCE.removeReadAnyColumn(sourceStoreSlot);
     const indexKeysPositions = sourceStoreSlot.indexKeysPositions;
     if (indexKeysPositions !== void 0) {
       this.indexKeysService.releasePosition(
@@ -4265,10 +4333,10 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
   }
   walkSlotsByKeys(indexStoreSlot, keys, takeFoundSlot, slotByKeyDoor) {
     this.assertNotDisposed(indexStoreSlot);
-    const indexStoreSlotEditable = indexStoreSlot;
+    const editableIndexStoreSlot = indexStoreSlot;
     const bucketSlots = [];
     let entitySlotsByMintedBucketSlot;
-    indexStoreSlotEditable.requestedKeys = keys;
+    editableIndexStoreSlot.requestedKeys = keys;
     try {
       for (let i = 0; i < keys.length; i++) {
         const foundBucketSlot = this.findSlotByKey(indexStoreSlot, keys[i]);
@@ -4282,7 +4350,7 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
         bucketSlots.push(bucketSlot);
       }
     } finally {
-      indexStoreSlotEditable.requestedKeys = void 0;
+      editableIndexStoreSlot.requestedKeys = void 0;
       if (entitySlotsByMintedBucketSlot !== void 0) this.fillMintedBucketSlots(indexStoreSlot, entitySlotsByMintedBucketSlot);
     }
     return bucketSlots;
@@ -4314,18 +4382,14 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
     const bucketColumnNames = indexStoreSlot.bucketColumnNames;
     if (bucketColumnNames.has(columnName)) return;
     bucketColumnNames.add(columnName);
-    OIMContentChangeListenerService.INSTANCE.addReadColumn(indexStoreSlot.sourceStoreSlot, columnName);
+    OIMSlotContentChangeListenerService.INSTANCE.addReadColumn(indexStoreSlot.sourceStoreSlot, columnName);
   }
   onBucketColumnsChanged(_indexStoreSlot, _bucketSlot, _entitySlot, _changedColumns) {
     return;
   }
   onSlotMinted(indexStoreSlot, bucketSlot) {
     if (indexStoreSlot.requestedKeys !== void 0) return;
-    const key = bucketSlot.key;
-    this.slotContentBucketService.fillBucketMemberSlots(
-      bucketSlot,
-      this.setIndexKeyForSlots(indexStoreSlot, this.collectSourceSlotsForKey(indexStoreSlot, key), key)
-    );
+    this.fillBucketSlotWithSourceSlots(indexStoreSlot, bucketSlot, this.collectSourceSlotsForKey(indexStoreSlot, bucketSlot.key));
   }
   assertNotDisposed(storeSlot) {
     if (!storeSlot.isDisposed) return;
@@ -4336,7 +4400,7 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
   addAnyBucketColumnRead(indexStoreSlot) {
     if (indexStoreSlot.isAnyBucketColumnRead) return;
     indexStoreSlot.isAnyBucketColumnRead = true;
-    OIMContentChangeListenerService.INSTANCE.addReadAnyColumn(indexStoreSlot.sourceStoreSlot);
+    OIMSlotContentChangeListenerService.INSTANCE.addReadAnyColumn(indexStoreSlot.sourceStoreSlot);
   }
   fillMintedBucketSlots(indexStoreSlot, entitySlotsByMintedBucketSlot) {
     for (const entitySlot of this.sourceSlotCollectionService.getSlots(indexStoreSlot.sourceStoreSlot)) {
@@ -4348,7 +4412,7 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
     const slotContentService = this.slotContentBucketService;
     const slotOwnerService = this.slotOwnerService;
     for (const [bucketSlot, entitySlots] of entitySlotsByMintedBucketSlot) {
-      slotContentService.fillBucketMemberSlots(bucketSlot, this.setIndexKeyForSlots(indexStoreSlot, entitySlots, bucketSlot.key));
+      this.fillBucketSlotWithSourceSlots(indexStoreSlot, bucketSlot, entitySlots);
       slotOwnerService.settleEmptiness(bucketSlot, slotContentService.isSlotEmpty(bucketSlot));
     }
   }
@@ -4488,40 +4552,42 @@ var OIMSlotCollectionIndexService = class extends OIMSlotCollectionService {
     }
     return matchingEntitySlots;
   }
-  setIndexKeyForSlots(indexStoreSlot, entitySlots, key) {
+  fillBucketSlotWithSourceSlots(indexStoreSlot, bucketSlot, entitySlots) {
     const indexKeysService = this.indexKeysService;
     const indexKeysPosition = indexStoreSlot.indexKeysPosition;
-    const channelSlot = indexStoreSlot.channelSlot;
-    const isRefusingWrites = OIMChannelService.INSTANCE.isRefusingWrites(channelSlot);
-    let movableEntitySlots;
+    const key = bucketSlot.key;
+    const isRefusingWrites = OIMChannelService.INSTANCE.isRefusingWrites(indexStoreSlot.channelSlot);
+    const fillingEntitySlots = [];
+    const prevKeys = [];
+    const movingEntitySlots = [];
     for (let i = 0; i < entitySlots.length; i++) {
       const entitySlot = entitySlots[i];
       const prevKey = indexKeysService.get(entitySlot, indexKeysPosition);
       const isMoving = prevKey !== void 0 && !this.isSameKey(prevKey, key);
-      if (isMoving && isRefusingWrites) {
-        movableEntitySlots ?? (movableEntitySlots = entitySlots.slice(0, i));
-        continue;
-      }
-      movableEntitySlots?.push(entitySlot);
+      if (isMoving && isRefusingWrites) continue;
+      fillingEntitySlots.push(entitySlot);
       indexKeysService.set(entitySlot, indexKeysPosition, key);
       if (!isMoving) continue;
-      OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(channelSlot.collectorSlot.unusedSlotCollectorSlot, entitySlot);
-      const prevBucketSlot = this.findSlotByKey(indexStoreSlot, prevKey);
-      if (prevBucketSlot !== void 0) this.slotContentBucketService.removeBucketMemberSlot(prevBucketSlot, entitySlot);
+      prevKeys.push(prevKey);
+      movingEntitySlots.push(entitySlot);
+    }
+    this.slotContentBucketService.fillBucketMemberSlots(bucketSlot, fillingEntitySlots);
+    for (let i = 0; i < movingEntitySlots.length; i++) {
+      const prevBucketSlot = this.findSlotByKey(indexStoreSlot, prevKeys[i]);
+      if (prevBucketSlot !== void 0) this.slotContentBucketService.removeBucketMemberSlot(prevBucketSlot, movingEntitySlots[i]);
     }
-    return movableEntitySlots ?? entitySlots;
   }
 };
 function takeNothing() {
   return;
 }
 
-// src/facade/index/OIMSlotCollectionSortedArrayIndexService.ts
+// src/index/OIMSlotCollectionSortedArrayIndexService.ts
 var OIMSlotCollectionSortedArrayIndexService = class extends OIMSlotCollectionIndexService {
   constructor(options) {
     super(options);
     const sortColumnNames = /* @__PURE__ */ new Set();
-    for (let i = 0; i < options.sortColumns.length; i++) sortColumnNames.add(options.sortColumns[i].column);
+    for (let i = 0; i < options.sortColumns.length; i++) sortColumnNames.add(options.sortColumns[i].columnName);
     this.sortColumnNames = sortColumnNames;
   }
   createIndexStoreSlot(sourceStoreSlot) {
@@ -4543,7 +4609,51 @@ var OIMSlotCollectionSortedArrayIndexService = class extends OIMSlotCollectionIn
   }
 };
 
-// src/factories/utils/oimKeyOfColumns.ts
+// src/index/OIMIndexKeysService.ts
+var OIMIndexKeysService = class {
+  createPositions() {
+    return { nextPosition: 0, freePositions: [] };
+  }
+  get(slot, position) {
+    const indexKeys = slot.indexKeys;
+    return indexKeys === void 0 || position >= indexKeys.length ? void 0 : indexKeys[position];
+  }
+  set(slot, position, indexKey) {
+    const indexKeys = slot.indexKeys;
+    if (indexKeys !== void 0) {
+      if (position < indexKeys.length) {
+        indexKeys[position] = indexKey;
+        return;
+      }
+      if (indexKey === void 0) return;
+      while (indexKeys.length < position) indexKeys.push(void 0);
+      indexKeys.push(indexKey);
+      return;
+    }
+    if (indexKey === void 0) return;
+    const created = [];
+    while (created.length < position) created.push(void 0);
+    created.push(indexKey);
+    slot.indexKeys = created;
+  }
+};
+
+// src/index/OIMAppendingIndexKeysService.ts
+var _OIMAppendingIndexKeysService = class _OIMAppendingIndexKeysService extends OIMIndexKeysService {
+  allocatePosition(positions) {
+    return positions.nextPosition++;
+  }
+  releasePosition() {
+    return;
+  }
+};
+_OIMAppendingIndexKeysService.INSTANCE = new _OIMAppendingIndexKeysService();
+var OIMAppendingIndexKeysService = _OIMAppendingIndexKeysService;
+
+// src/db/constants/OIM_DEFAULT_INDEX_KEYS_SERVICE.ts
+var OIM_DEFAULT_INDEX_KEYS_SERVICE = /* @__PURE__ */ new OIMDefaultValue(() => OIMAppendingIndexKeysService.INSTANCE);
+
+// src/index/utils/oimKeyOfColumns.ts
 function oimKeyOfColumns(columns) {
   if (columns.length === 1) {
     const column = columns[0];
@@ -4556,47 +4666,47 @@ function oimKeyOfColumns(columns) {
   };
 }
 
-// src/factories/utils/oimSlotCollectionIndexServiceOptionsWithDefault.ts
-function oimSlotCollectionIndexServiceOptionsWithDefault(db, options, slotStoreService, slotContentService) {
+// src/index/utils/oimResolveSlotCollectionIndexServiceOptions.ts
+function oimResolveSlotCollectionIndexServiceOptions(defaults, options, slotStoreService, slotContentService) {
   return {
-    ...oimSlotOwnerOptionsWithDefault(db, options),
+    ...oimResolveSlotOwnerServiceOptions(defaults, options),
     slotStoreService,
     slotContentService,
-    storeSlotListener: OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
+    storeSlotListener: defaults.storeSlotListener ?? OIM_DEFAULT_STORE_SLOT_LISTENER.getValue(),
     keyOf: options.keyOf ?? oimKeyOfColumns(options.columns),
     columns: options.columns,
     sourceSlotCollectionService: options.entityService,
-    indexKeysService: db.indexKeysService ?? OIM_DEFAULT_INDEX_KEYS_SERVICE.getValue()
+    indexKeysService: defaults.indexKeysService ?? OIM_DEFAULT_INDEX_KEYS_SERVICE.getValue()
   };
 }
 
-// src/factories/createOIMSlotCollectionIndexService.ts
-function createOIMSlotCollectionIndexService(db, options) {
-  return new OIMSlotCollectionIndexService(oimSlotCollectionIndexServiceOptionsWithDefault(
-    db,
+// src/index/createOIMSlotCollectionIndexService.ts
+function createOIMSlotCollectionIndexService(options) {
+  return new OIMSlotCollectionIndexService(oimResolveSlotCollectionIndexServiceOptions(
+    options.defaults ?? OIMDefaults.INSTANCE,
     options,
-    oimSlotStoreServiceWithDefault(options.bucketSlotStoreService),
+    oimResolveSlotStoreService(options.bucketSlotStoreService),
     options.slotContentService ?? new OIMSlotContentPositionalArrayBucketService()
   ));
 }
 
-// src/factories/createOIMSlotCollectionSortedArrayIndexService.ts
-function createOIMSlotCollectionSortedArrayIndexService(db, options) {
+// src/index/createOIMSlotCollectionSortedArrayIndexService.ts
+function createOIMSlotCollectionSortedArrayIndexService(options) {
   const slotContentService = new OIMSlotContentSortedArrayBucketService({
     compareBucketMemberSlots: oimEntitySlotsComparator(oimColumnsComparator(options.sortColumns))
   });
   return new OIMSlotCollectionSortedArrayIndexService({
-    ...oimSlotCollectionIndexServiceOptionsWithDefault(
-      db,
+    ...oimResolveSlotCollectionIndexServiceOptions(
+      options.defaults ?? OIMDefaults.INSTANCE,
       options,
-      oimSlotStoreServiceWithDefault(options.bucketSlotStoreService),
+      oimResolveSlotStoreService(options.bucketSlotStoreService),
       slotContentService
     ),
     sortColumns: options.sortColumns
   });
 }
 
-// src/engine/index/OIMReclaimingIndexKeysService.ts
+// src/index/OIMReclaimingIndexKeysService.ts
 var OIMReclaimingIndexKeysService = class extends OIMIndexKeysService {
   allocatePosition(positions) {
     const freePosition = positions.freePositions.pop();
@@ -4611,18 +4721,18 @@ var OIMReclaimingIndexKeysService = class extends OIMIndexKeysService {
   }
 };
 
-// src/engine/entity/utils/oimCopyEntity.ts
+// src/entity/utils/oimCopyEntity.ts
 function oimCopyEntity(entity) {
   return { ...entity };
 }
 
-// src/factories/createOIMEntityWriterReplacing.ts
+// src/entity/createOIMReplacingEntityWriter.ts
 function storeReplacement(slot, next) {
   if (next === void 0) return false;
   slot.entity = next;
   return true;
 }
-function deleteColumnsReplacing(slot, names) {
+function deleteColumnsInCopy(slot, names) {
   const deleted = oimOwnedColumnNames(slot, names);
   if (deleted === void 0) return OIM_FROZEN_EMPTY_COLUMN_NAMES;
   const next = oimCopyEntity(slot.entity);
@@ -4630,61 +4740,61 @@ function deleteColumnsReplacing(slot, names) {
   slot.entity = next;
   return deleted;
 }
-function createOIMEntityWriterReplacing(options) {
+function createOIMReplacingEntityWriter(options) {
   const {
     sameValueGuard,
     entityInserter,
     putEntityColumns,
     patchEntityColumns,
     patchEntityColumn
-  } = oimEntityWriterOptionsWithDefault(options);
+  } = oimResolveEntityWriterOptions(options);
   return {
     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)),
     patchColumn: (slot, columnName, value, changedColumnNames) => storeReplacement(slot, patchEntityColumn(slot, columnName, value, sameValueGuard, changedColumnNames, oimCopyEntity)),
-    deleteColumns: deleteColumnsReplacing
+    deleteColumns: deleteColumnsInCopy
   };
 }
 
-// src/engine/entity/utils/oimInsertEntityWithCopy.ts
+// src/entity/utils/oimInsertEntityWithCopy.ts
 function oimInsertEntityWithCopy(slot, entity) {
   slot.entity = oimCopyEntity(entity);
 }
 
-// src/engine/entity/utils/oimCopyEntitySanitized.ts
-function oimCopyEntitySanitized(entity) {
+// src/entity/utils/oimSanitizedCopyEntity.ts
+function oimSanitizedCopyEntity(entity) {
   const copy = { ...entity };
   if (Object.hasOwn(copy, OIM_PROTO_KEY)) delete copy[OIM_PROTO_KEY];
   return copy;
 }
 
-// src/engine/entity/utils/oimInsertEntityWithSanitizedCopy.ts
+// src/entity/utils/oimInsertEntityWithSanitizedCopy.ts
 function oimInsertEntityWithSanitizedCopy(slot, entity) {
-  slot.entity = oimCopyEntitySanitized(entity);
+  slot.entity = oimSanitizedCopyEntity(entity);
 }
 
-// src/engine/entity/utils/oimIsPlain.ts
-function oimIsPlain(source) {
+// src/entity/utils/oimIsPlainObject.ts
+function oimIsPlainObject(source) {
   const proto = Object.getPrototypeOf(source);
   return proto === Object.prototype || proto === null;
 }
 
-// src/engine/entity/utils/oimOwnEntityColumns.ts
+// src/entity/utils/oimOwnEntityColumns.ts
 function oimOwnEntityColumns(entity) {
-  if (oimIsPlain(entity) && !Object.hasOwn(entity, OIM_PROTO_KEY)) return entity;
-  return oimCopyEntitySanitized(entity);
+  if (oimIsPlainObject(entity) && !Object.hasOwn(entity, OIM_PROTO_KEY)) return entity;
+  return oimSanitizedCopyEntity(entity);
 }
 
-// src/engine/entity/utils/oimPatchEntityColumnsGuarded.ts
-var oimPatchEntityColumnsGuarded = (slot, patch, sameValueGuard, changedColumnNames, targetOf) => oimPatchEntityColumns(slot, oimOwnEntityColumns(patch), sameValueGuard, changedColumnNames, targetOf);
+// src/entity/utils/oimGuardedPatchEntityColumns.ts
+var oimGuardedPatchEntityColumns = (slot, patch, sameValueGuard, changedColumnNames, targetOf) => oimPatchEntityColumns(slot, oimOwnEntityColumns(patch), sameValueGuard, changedColumnNames, targetOf);
 
-// src/engine/entity/utils/oimPatchEntityColumnGuarded.ts
-var oimPatchEntityColumnGuarded = (slot, columnName, value, sameValueGuard, changedColumnNames, targetOf) => oimIsProtoKey(columnName) ? void 0 : oimPatchEntityColumn(slot, columnName, value, sameValueGuard, changedColumnNames, targetOf);
+// src/entity/utils/oimGuardedPatchEntityColumn.ts
+var oimGuardedPatchEntityColumn = (slot, columnName, value, sameValueGuard, changedColumnNames, targetOf) => oimIsProtoKey(columnName) ? void 0 : oimPatchEntityColumn(slot, columnName, value, sameValueGuard, changedColumnNames, targetOf);
 
-// src/engine/entity/utils/oimPutEntityColumnsGuarded.ts
-var oimPutEntityColumnsGuarded = (slot, entity, sameValueGuard, changedColumnNames, targetOf) => {
+// src/entity/utils/oimGuardedPutEntityColumns.ts
+var oimGuardedPutEntityColumns = (slot, entity, sameValueGuard, changedColumnNames, targetOf) => {
   const prevEntity = slot.entity;
   if (prevEntity === void 0) return void 0;
   const ownColumns = oimOwnEntityColumns(entity);
@@ -4699,13 +4809,13 @@ var oimPutEntityColumnsGuarded = (slot, entity, sameValueGuard, changedColumnNam
   );
 };
 
-// src/engine/collector/constants/OIM_SLICE_LENGTH_MS.ts
+// src/collector/constants/OIM_SLICE_LENGTH_MS.ts
 var OIM_SLICE_LENGTH_MS = 1024;
 
-// src/engine/collector/utils/oimSliceOfMs.ts
+// src/collector/utils/oimSliceOfMs.ts
 var oimSliceOfMs = (ms) => Math.floor(ms / OIM_SLICE_LENGTH_MS);
 
-// src/engine/collector/OIMSlotWheel.ts
+// src/collector/OIMSlotWheel.ts
 var OIMSlotWheel = class {
   constructor(options) {
     this.scheduledCallback = void 0;
@@ -4843,7 +4953,7 @@ var OIMSlotWheel = class {
   }
 };
 
-// src/engine/collector/OIMSlotReleaseWheel.ts
+// src/collector/OIMSlotReleaseWheel.ts
 var OIMSlotReleaseWheel = class extends OIMSlotWheel {
   constructor(options) {
     super(options);
@@ -4904,20 +5014,20 @@ var OIMSlotReleaseWheel = class extends OIMSlotWheel {
   }
 };
 
-// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_WRITE.ts
+// src/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
+// src/slot/utils/oimGetReleaseDueAfterWriteMs.ts
 function oimGetReleaseDueAfterWriteMs(slot) {
   return slot.releaseDueAfterWriteMs;
 }
 
-// src/engine/slot/utils/oimSetReleaseDueAfterWriteMs.ts
+// src/slot/utils/oimSetReleaseDueAfterWriteMs.ts
 function oimSetReleaseDueAfterWriteMs(slot, releaseDueMs) {
   slot.releaseDueAfterWriteMs = releaseDueMs;
 }
 
-// src/engine/collector/utils/oimMintAfterWriteSlotReleaseWheel.ts
+// src/collector/utils/oimMintAfterWriteSlotReleaseWheel.ts
 function oimMintAfterWriteSlotReleaseWheel(collectorSlot) {
   return collectorSlot.afterWriteSlotReleaseWheel ?? (collectorSlot.afterWriteSlotReleaseWheel = new OIMSlotReleaseWheel({
     ...collectorSlot.slotWheelOptions,
@@ -4927,20 +5037,20 @@ function oimMintAfterWriteSlotReleaseWheel(collectorSlot) {
   }));
 }
 
-// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_IDLE.ts
+// src/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
+// src/slot/utils/oimGetReleaseDueAfterIdleMs.ts
 function oimGetReleaseDueAfterIdleMs(slot) {
   return slot.releaseDueAfterIdleMs;
 }
 
-// src/engine/slot/utils/oimSetReleaseDueAfterIdleMs.ts
+// src/slot/utils/oimSetReleaseDueAfterIdleMs.ts
 function oimSetReleaseDueAfterIdleMs(slot, releaseDueMs) {
   slot.releaseDueAfterIdleMs = releaseDueMs;
 }
 
-// src/engine/collector/utils/oimMintAfterIdleSlotReleaseWheel.ts
+// src/collector/utils/oimMintAfterIdleSlotReleaseWheel.ts
 function oimMintAfterIdleSlotReleaseWheel(collectorSlot) {
   return collectorSlot.afterIdleSlotReleaseWheel ?? (collectorSlot.afterIdleSlotReleaseWheel = new OIMSlotReleaseWheel({
     ...collectorSlot.slotWheelOptions,
@@ -4950,20 +5060,20 @@ function oimMintAfterIdleSlotReleaseWheel(collectorSlot) {
   }));
 }
 
-// src/engine/collector/constants/OIM_SLOT_FLAG_RELEASE_SCHEDULED_AFTER_UNHOLD.ts
+// src/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
+// src/slot/utils/oimGetReleaseDueAfterUnholdMs.ts
 function oimGetReleaseDueAfterUnholdMs(slot) {
   return slot.releaseDueAfterUnholdMs;
 }
 
-// src/engine/slot/utils/oimSetReleaseDueAfterUnholdMs.ts
+// src/slot/utils/oimSetReleaseDueAfterUnholdMs.ts
 function oimSetReleaseDueAfterUnholdMs(slot, releaseDueMs) {
   slot.releaseDueAfterUnholdMs = releaseDueMs;
 }
 
-// src/engine/collector/utils/oimMintAfterUnholdSlotReleaseWheel.ts
+// src/collector/utils/oimMintAfterUnholdSlotReleaseWheel.ts
 function oimMintAfterUnholdSlotReleaseWheel(collectorSlot) {
   return collectorSlot.afterUnholdSlotReleaseWheel ?? (collectorSlot.afterUnholdSlotReleaseWheel = new OIMSlotReleaseWheel({
     ...collectorSlot.slotWheelOptions,
@@ -4973,7 +5083,7 @@ function oimMintAfterUnholdSlotReleaseWheel(collectorSlot) {
   }));
 }
 
-// src/engine/collector/OIMSlotRefetchWheel.ts
+// src/collector/OIMSlotRefetchWheel.ts
 var OIMSlotRefetchWheel = class extends OIMSlotWheel {
   constructor(options) {
     super({
@@ -5007,7 +5117,7 @@ var OIMSlotRefetchWheel = class extends OIMSlotWheel {
   }
 };
 
-// src/engine/collector/OIMSlotReleaseAutoDueFramePolicy.ts
+// src/collector/OIMSlotReleaseAutoDueFramePolicy.ts
 var _OIMSlotReleaseAutoDueFramePolicy = class _OIMSlotReleaseAutoDueFramePolicy {
   isSlotReleaseDueFrameOpen() {
     return true;
@@ -5016,7 +5126,7 @@ var _OIMSlotReleaseAutoDueFramePolicy = class _OIMSlotReleaseAutoDueFramePolicy
 _OIMSlotReleaseAutoDueFramePolicy.INSTANCE = new _OIMSlotReleaseAutoDueFramePolicy();
 var OIMSlotReleaseAutoDueFramePolicy = _OIMSlotReleaseAutoDueFramePolicy;
 
-// src/engine/collector/OIMSlotAfterWriteReleasePolicy.ts
+// src/collector/OIMSlotAfterWriteReleasePolicy.ts
 var OIMSlotAfterWriteReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
@@ -5045,7 +5155,7 @@ var OIMSlotAfterWriteReleasePolicy = class {
   }
 };
 
-// src/engine/collector/OIMSlotReleaseManualDueFramePolicy.ts
+// src/collector/OIMSlotReleaseManualDueFramePolicy.ts
 var OIMSlotReleaseManualDueFramePolicy = class {
   constructor() {
     this.slotReleaseDueFrameDepth = 0;
@@ -5074,7 +5184,7 @@ var OIMSlotReleaseManualDueFramePolicy = class {
   }
 };
 
-// src/engine/collector/OIMSlotAfterIdleReleasePolicy.ts
+// src/collector/OIMSlotAfterIdleReleasePolicy.ts
 var OIMSlotAfterIdleReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
@@ -5105,7 +5215,7 @@ var OIMSlotAfterIdleReleasePolicy = class {
   }
 };
 
-// src/engine/collector/OIMSlotNeverReleasePolicy.ts
+// src/collector/OIMSlotNeverReleasePolicy.ts
 var _OIMSlotNeverReleasePolicy = class _OIMSlotNeverReleasePolicy {
   constructor() {
     this.releasesWrittenSlots = false;
@@ -5133,7 +5243,7 @@ var _OIMSlotNeverReleasePolicy = class _OIMSlotNeverReleasePolicy {
 _OIMSlotNeverReleasePolicy.INSTANCE = new _OIMSlotNeverReleasePolicy();
 var OIMSlotNeverReleasePolicy = _OIMSlotNeverReleasePolicy;
 
-// src/engine/collector/OIMSlotAfterUnholdReleasePolicy.ts
+// src/collector/OIMSlotAfterUnholdReleasePolicy.ts
 var OIMSlotAfterUnholdReleasePolicy = class {
   constructor(options) {
     this.releasesWrittenSlots = true;
@@ -5160,7 +5270,7 @@ var OIMSlotAfterUnholdReleasePolicy = class {
   }
 };
 
-// src/engine/collector/OIMSlotEarliestReleasePolicy.ts
+// src/collector/OIMSlotEarliestReleasePolicy.ts
 var askOnSlotIdle = (slotReleasePolicy, slot) => slotReleasePolicy.onSlotIdle(slot);
 var askIsSlotReleasable = (slotReleasePolicy, slot) => slotReleasePolicy.isSlotReleasable(slot);
 var askIsEmptySlotReleasable = (slotReleasePolicy, slot) => slotReleasePolicy.isEmptySlotReleasable(slot);
@@ -5207,13 +5317,13 @@ var OIMSlotEarliestReleasePolicy = class {
   }
 };
 
-// src/engine/store/OIMSlotTreeStoreService.ts
+// src/store/OIMSlotTreeStoreService.ts
 var OIMSlotTreeStoreService = class {
   constructor(keyTreeWalk) {
     this.keyTreeWalk = keyTreeWalk;
   }
   createStore() {
-    return { root: { childNodes: void 0, atThisKey: void 0 }, slots: /* @__PURE__ */ new Set() };
+    return { rootCompositeKeyNode: { childNodes: void 0, atThisKey: void 0 }, slots: /* @__PURE__ */ new Set() };
   }
   ownKey(compositeKey) {
     return compositeKey.slice();
@@ -5222,17 +5332,17 @@ var OIMSlotTreeStoreService = class {
     return oimSameKeySequence(compositeKey, otherCompositeKey);
   }
   get(slotStoreTree, compositeKey) {
-    return this.keyTreeWalk.nodeAt(slotStoreTree.root, compositeKey)?.atThisKey;
+    return this.keyTreeWalk.nodeAt(slotStoreTree.rootCompositeKeyNode, compositeKey)?.atThisKey;
   }
   set(slotStoreTree, compositeKey, slot) {
-    const compositeKeyNode = this.keyTreeWalk.mintNodeAt(slotStoreTree.root, compositeKey);
+    const compositeKeyNode = this.keyTreeWalk.mintNodeAt(slotStoreTree.rootCompositeKeyNode, 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);
+    const slot = this.keyTreeWalk.deleteKey(slotStoreTree.rootCompositeKeyNode, compositeKey);
     if (slot !== void 0) slotStoreTree.slots.delete(slot);
   }
   fileSlot(slotStoreTree, slot) {
@@ -5249,10 +5359,100 @@ var OIMSlotTreeStoreService = class {
   }
 };
 
-// src/engine/bucket/commands/constants/OIM_MAX_DIFF_SCRATCH_SLOTS.ts
+// src/key/OIMKeyTreeWalk.ts
+var OIMKeyTreeWalk = class {
+  mintNodeAt(rootCompositeKeyNode, compositeKey) {
+    if (compositeKey.length === 0) throw new Error("OIMKeyTreeWalk: an empty key is not a key.");
+    let compositeKeyNode = rootCompositeKeyNode;
+    let firstMintedDepth = -1;
+    let parentOfFirstMintedCompositeKeyNode = rootCompositeKeyNode;
+    for (let i = 0; i < compositeKey.length; i++) {
+      const compositeKeyPart = compositeKey[i];
+      let nextCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKeyPart);
+      if (nextCompositeKeyNode === void 0) {
+        try {
+          this.holdCompositeKeyPart(compositeKeyPart);
+        } catch (failure) {
+          if (firstMintedDepth >= 0) {
+            parentOfFirstMintedCompositeKeyNode.childNodes?.delete(compositeKey[firstMintedDepth]);
+            for (let j = i - 1; j >= firstMintedDepth; j--) this.unholdCompositeKeyPart(compositeKey[j]);
+          }
+          throw failure;
+        }
+        nextCompositeKeyNode = { childNodes: void 0, atThisKey: void 0 };
+        (compositeKeyNode.childNodes ?? (compositeKeyNode.childNodes = /* @__PURE__ */ new Map())).set(compositeKeyPart, nextCompositeKeyNode);
+        if (firstMintedDepth < 0) {
+          firstMintedDepth = i;
+          parentOfFirstMintedCompositeKeyNode = compositeKeyNode;
+        }
+      }
+      compositeKeyNode = nextCompositeKeyNode;
+    }
+    return compositeKeyNode;
+  }
+  nodeAt(rootCompositeKeyNode, compositeKey) {
+    let compositeKeyNode = rootCompositeKeyNode;
+    for (let i = 0; i < compositeKey.length; i++) {
+      compositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[i]);
+      if (compositeKeyNode === void 0) return void 0;
+    }
+    return compositeKeyNode;
+  }
+  deleteKey(rootCompositeKeyNode, compositeKey) {
+    const lastDepth = compositeKey.length - 1;
+    if (lastDepth < 0) return void 0;
+    let compositeKeyNode = rootCompositeKeyNode;
+    let keptCompositeKeyNode = rootCompositeKeyNode;
+    let firstUnlinkedDepth = 0;
+    for (let i = 0; i < lastDepth; i++) {
+      const nextCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[i]);
+      if (nextCompositeKeyNode === void 0) return void 0;
+      compositeKeyNode = nextCompositeKeyNode;
+      if (compositeKeyNode.atThisKey !== void 0 || (compositeKeyNode.childNodes?.size ?? 0) > 1) {
+        keptCompositeKeyNode = compositeKeyNode;
+        firstUnlinkedDepth = i + 1;
+      }
+    }
+    const lastCompositeKeyNode = compositeKeyNode.childNodes?.get(compositeKey[lastDepth]);
+    if (lastCompositeKeyNode === void 0) return void 0;
+    const deletedAtKey = lastCompositeKeyNode.atThisKey;
+    if (deletedAtKey === void 0) return void 0;
+    lastCompositeKeyNode.atThisKey = void 0;
+    if ((lastCompositeKeyNode.childNodes?.size ?? 0) > 0) return deletedAtKey;
+    keptCompositeKeyNode.childNodes?.delete(compositeKey[firstUnlinkedDepth]);
+    for (let i = lastDepth; i >= firstUnlinkedDepth; i--) this.unholdCompositeKeyPart(compositeKey[i]);
+    return deletedAtKey;
+  }
+};
+
+// src/key/OIMCompositeKeyTreeWalk.ts
+var _OIMCompositeKeyTreeWalk = class _OIMCompositeKeyTreeWalk extends OIMKeyTreeWalk {
+  holdCompositeKeyPart(entitySlot) {
+    entitySlot.owner.holdSlot(entitySlot);
+  }
+  unholdCompositeKeyPart(entitySlot) {
+    oimUnholdSlotIfAlive(entitySlot);
+  }
+};
+_OIMCompositeKeyTreeWalk.INSTANCE = new _OIMCompositeKeyTreeWalk();
+var OIMCompositeKeyTreeWalk = _OIMCompositeKeyTreeWalk;
+
+// src/key/OIMScalarKeyTreeWalk.ts
+var _OIMScalarKeyTreeWalk = class _OIMScalarKeyTreeWalk extends OIMKeyTreeWalk {
+  holdCompositeKeyPart() {
+    return;
+  }
+  unholdCompositeKeyPart() {
+    return;
+  }
+};
+_OIMScalarKeyTreeWalk.INSTANCE = new _OIMScalarKeyTreeWalk();
+var OIMScalarKeyTreeWalk = _OIMScalarKeyTreeWalk;
+
+// src/bucket/commands/constants/OIM_MAX_DIFF_SCRATCH_SLOTS.ts
 var OIM_MAX_DIFF_SCRATCH_SLOTS = 4096;
 
-// src/engine/bucket/commands/utils/oimOrderedListCommandsOfTransition.ts
+// src/bucket/commands/utils/oimOrderedListCommandsOfTransition.ts
 var indexInNext = /* @__PURE__ */ new Map();
 var occurrenceAfter = new Int32Array(0);
 var removedPrevIndices = new Int32Array(0);
@@ -5365,7 +5565,6 @@ oimRegisterCoreInstance(OIMDB);
   OIMCompositeKeyTreeWalk,
   OIMComputedService,
   OIMComputedValueService,
-  OIMContentChangeListenerService,
   OIMDB,
   OIMDefaultValue,
   OIMDefaults,
@@ -5382,6 +5581,7 @@ oimRegisterCoreInstance(OIMDB);
   OIMSingleComputedService,
   OIMSingleSlotService,
   OIMSingleSlotStoreService,
+  OIMSingleSourceTrackingComputedService,
   OIMSlotAfterIdleReleasePolicy,
   OIMSlotAfterUnholdReleasePolicy,
   OIMSlotAfterWriteReleasePolicy,
@@ -5392,6 +5592,7 @@ oimRegisterCoreInstance(OIMDB);
   OIMSlotCollectionSortedArrayIndexService,
   OIMSlotContentArrayBucketService,
   OIMSlotContentBucketService,
+  OIMSlotContentChangeListenerService,
   OIMSlotContentEntityService,
   OIMSlotContentPositionalArrayBucketService,
   OIMSlotContentSetBucketService,
@@ -5407,6 +5608,7 @@ oimRegisterCoreInstance(OIMDB);
   OIMSlotTreeStoreService,
   OIMSlotWheel,
   OIMSortedComputedService,
+  OIMSourceTrackingComputedService,
   OIMThrowAtOnceErrorPolicy,
   OIMUnusedSlotCollectorService,
   OIMWritableSingleSlotService,
@@ -5420,17 +5622,22 @@ oimRegisterCoreInstance(OIMDB);
   createOIMChannelSlot,
   createOIMCollectorSlot,
   createOIMComputedService,
-  createOIMEntityWriterInPlace,
-  createOIMEntityWriterReplacing,
+  createOIMInPlaceEntityWriter,
+  createOIMReplacingEntityWriter,
   createOIMSingleComputedService,
   createOIMSingleSlotService,
+  createOIMSingleSourceTrackingComputedService,
   createOIMSlotCollectionIndexService,
   createOIMSlotCollectionService,
   createOIMSlotCollectionSortedArrayIndexService,
   createOIMSlotContentEntityService,
   createOIMSortedComputedService,
+  createOIMSourceTrackingComputedService,
   createOIMUnusedSlotCollectorSlot,
   oimColumnsComparator,
+  oimGuardedPatchEntityColumn,
+  oimGuardedPatchEntityColumns,
+  oimGuardedPutEntityColumns,
   oimHoldSlots,
   oimInsertEntityWithCopy,
   oimInsertEntityWithSanitizedCopy,
@@ -5443,11 +5650,8 @@ oimRegisterCoreInstance(OIMDB);
   oimMintAfterWriteSlotReleaseWheel,
   oimOrderedListCommandsOfTransition,
   oimPatchEntityColumn,
-  oimPatchEntityColumnGuarded,
   oimPatchEntityColumns,
-  oimPatchEntityColumnsGuarded,
   oimPutEntityColumns,
-  oimPutEntityColumnsGuarded,
   oimRefreshSourceComputeds,
   oimSameKeySequence,
   oimSameSlotSequence,