@oimdb/core 4.0.1 → 4.2.0

package/dist/index.d.ts

@@ -10,27 +10,47 @@ interface IOIMEffectService {
     setPositionInSubscribedSlot(effect: TOIMEffect, edge: number, positionInSlot: number): void;
 }
 
-type TOIMKeyedSlot<TKey = unknown> = TOIMSlot & {
-    readonly key: TKey;
-};
-
-type TOIMIndexableSlot<TKey = unknown> = TOIMKeyedSlot<TKey> & {
-    readonly indexKeys: unknown[] | undefined;
+type TOIMEditable<TSlot> = {
+    -readonly [K in keyof TSlot]: TSlot[K];
 };
 
 interface IOIMSlotOwner {
     holdSlot(slot: TOIMSlot): void;
     unholdSlot(slot: TOIMSlot): void;
     releaseSlotIfUnheld(slot: TOIMSlot): void;
+    unsafeMutateSlot(slot: TOIMSlot, mutateSlot: (editableSlot: TOIMEditable<TOIMSlot>) => void): void;
     subscribeToSlot(slot: TOIMSlot, effect: TOIMEffect, edge: number): number;
     unsubscribeFromSlot(slot: TOIMSlot, positionInSlot: number, effect: TOIMEffect): boolean;
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
+}
+
+declare class OIMSourceTracker {
+    private readonly slotSourceList;
+    private computedSourceList;
+    private committedAllRootSlots;
+    private trackedAllRootSlots;
+    private isTrackedAllRootSlotsChanged;
+    private committedComputedRootSlots;
+    private trackedComputedRootSlots;
+    readSourceSlot<TSlot extends TOIMSlot>(slot: TSlot): TSlot;
+    readSourceComputedValue<TValue>(computedSlot: TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined>): TValue;
+    openSourceTracking(): void;
+    closeSourceTracking(): boolean;
+    isAnyComputedRootSlotsReplaced(): boolean;
+    trackReplacedRootSlots(): boolean;
+    getTrackedSourceSlots(): readonly TOIMSlot[];
+    getTrackedSourceComputeds(): readonly TOIMComputedContentSlot<unknown, OIMSourceTracker | undefined>[];
+    getTrackedAllRootSlots(): readonly TOIMSlot[];
+    commitTrackedSources(): void;
+    private trackAllRootSlots;
 }
 
 interface IOIMComputedValueService<TValue = unknown> {
-    getValueForSlot(computedSlot: TOIMComputedSlot<TValue>): TValue;
+    getValueForSlot(computedSlot: TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined>): TValue;
 }
 
-type TOIMComputedSlot<TValue = unknown, TKey = unknown> = TOIMIndexableSlot<TKey> & Readonly<TOIMDerivation> & {
+type TOIMComputedContentSlot<TValue = unknown, TSourceTracker extends OIMSourceTracker | undefined = undefined> = TOIMSlot & Readonly<TOIMComputedDerivation> & {
     readonly owner: IOIMSlotOwner;
     readonly computedValueService: IOIMComputedValueService<TValue>;
     readonly value: TValue;
@@ -38,14 +58,12 @@ type TOIMComputedSlot<TValue = unknown, TKey = unknown> = TOIMIndexableSlot<TKey
     readonly checkedAtEpoch: number;
     readonly isDeriving: boolean;
     readonly allRootSlots: readonly TOIMSlot[] | undefined;
+    readonly sourceTracker: TSourceTracker;
 };
 
-type TOIMComputedSources = {
+type TOIMComputedDerivation = {
     readonly sourceSlots: readonly TOIMSlot[];
-    readonly sourceComputeds: readonly TOIMComputedSlot[];
-};
-
-type TOIMDerivation = TOIMComputedSources & {
+    readonly sourceComputeds: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker | undefined>[];
     ranAtRevision: number;
     ranAtEpoch: number;
 };
@@ -64,9 +82,9 @@ declare class OIMChannelQueue<TEntry> {
     keepFirstEntries(keptCount: number): void;
 }
 
-interface IOIMContentChangeListener<TSlot, TPatch = unknown> {
+interface IOIMSlotContentChangeListener<TSlot, TPatch = unknown> {
     onContentChanged(slot: TSlot, patch: TPatch | undefined, changedColumns: readonly string[] | undefined): void;
-    onContentChangedMany(slotChannelQueue: OIMChannelQueue<TSlot>, patchChannelQueue: OIMChannelQueue<TPatch | undefined>, changedColumnsChannelQueue: OIMChannelQueue<readonly string[] | undefined>): void;
+    onManyContentsChanged(slotChannelQueue: OIMChannelQueue<TSlot>, patchChannelQueue: OIMChannelQueue<TPatch | undefined>, changedColumnsChannelQueue: OIMChannelQueue<readonly string[] | undefined>): void;
 }
 
 type TOIMIndexKeysPositions = {
@@ -84,10 +102,11 @@ type TOIMColumnReaders = {
     readonly columnGroups: TOIMColumnGroup[];
 };
 
-type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch = unknown> = {
+type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch = unknown, TSlotService = unknown> = {
     readonly store: TStore;
+    readonly slotService: TSlotService;
     readonly channelSlot: TOIMChannelSlot;
-    readonly contentChangeListeners: IOIMContentChangeListener<TSlot, TPatch>[] | undefined;
+    readonly contentChangeListeners: IOIMSlotContentChangeListener<TSlot, TPatch>[] | undefined;
     readonly contentChangeListenerReadColumnNames: (readonly string[] | undefined)[] | undefined;
     readonly indexKeysPositions: TOIMIndexKeysPositions | undefined;
     readonly columnListenerCountsByColumnName: Map<string, number> | undefined;
@@ -96,10 +115,10 @@ type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch =
     readonly columnGroupSlotCountsByKey: Map<string, number> | undefined;
     readonly columnReadersByColumnName: Map<string, TOIMColumnReaders> | undefined;
     readonly anyColumnSlotCount: number;
-    readonly subframeSlotChannelQueues: OIMChannelQueue<TSlot>[] | undefined;
-    readonly subframePatchChannelQueues: OIMChannelQueue<TPatch | undefined>[] | undefined;
-    readonly subframeChangedColumnsChannelQueues: OIMChannelQueue<readonly string[] | undefined>[] | undefined;
-    readonly changedBucketSlotChannelQueue: OIMChannelQueue<TSlot> | undefined;
+    readonly batchDepth: number;
+    readonly batchSlotChannelQueue: OIMChannelQueue<TSlot> | undefined;
+    readonly batchPatchChannelQueue: OIMChannelQueue<TPatch | undefined> | undefined;
+    readonly batchChangedColumnsChannelQueue: OIMChannelQueue<readonly string[] | undefined> | undefined;
     readonly arrivedBucketMemberSlotChannelQueues: OIMChannelQueue<TOIMSlot>[] | undefined;
     readonly departedBucketMemberSlotChannelQueues: OIMChannelQueue<TOIMSlot>[] | undefined;
     readonly removedAtChannelQueues: OIMChannelQueue<number>[] | undefined;
@@ -117,10 +136,6 @@ type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch =
     readonly isDisposed: boolean;
 };
 
-interface IOIMSubframeCloseListener {
-    onStoreSlotSubframeClosed(storeSlot: TOIMStoreSlot): void;
-}
-
 type TOIMUnusedSlotCollectorSlot = {
     readonly unusedSlotChannelQueue: OIMChannelQueue<TOIMSlot>;
     openDepth: number;
@@ -129,32 +144,84 @@ type TOIMUnusedSlotCollectorSlot = {
 
 type TOIMTimer = (run: () => void, inMs: number) => TOIMDisposer;
 
+interface IOIMErrorPolicy {
+    onErrorCaught(error: unknown): void;
+}
+
+type TOIMSlotWheelOptions = {
+    getNowMs: () => number;
+    timer: TOIMTimer;
+    errorPolicy: IOIMErrorPolicy;
+};
+
+type TOIMSlotReleaseWheelOptions = TOIMSlotWheelOptions & {
+    getReleaseDueMs: (slot: TOIMSlot) => number;
+    setReleaseDueMs: (slot: TOIMSlot, releaseDueMs: number) => void;
+    releaseScheduledSlotFlag: number;
+};
+
 type TOIMFlushSchedulerSlot = {
     readonly timer: TOIMTimer | undefined;
     scheduledCallback: (() => void) | undefined;
     timerDisposer: TOIMDisposer | undefined;
 };
 
-interface IOIMErrorPolicy {
-    onErrorCaught(error: unknown): void;
+interface IOIMFlushSchedulerListener<TFlushSchedulerSlot extends TOIMFlushSchedulerSlot> {
+    onSchedulerTimerFired(flushSchedulerSlot: TFlushSchedulerSlot): void;
 }
 
-type TOIMReleaseSlotCollectorSlot = TOIMFlushSchedulerSlot & {
+declare abstract class OIMSlotWheel implements TOIMFlushSchedulerSlot, IOIMFlushSchedulerListener<OIMSlotWheel> {
+    readonly timer: TOIMTimer;
+    scheduledCallback: (() => void) | undefined;
+    timerDisposer: TOIMDisposer | undefined;
     readonly getNowMs: () => number;
-    readonly errorPolicy: IOIMErrorPolicy;
-    scheduledUntilMs: number;
-    readonly slotsBySliceNumber: Map<number, Set<TOIMSlot>>;
-    readonly sliceNumberBySlot: Map<TOIMSlot, number>;
-    floorSliceNumber: number;
-    nextSliceNumber: number | undefined;
-    nextSliceNumberNeedsRescan: boolean;
-};
+    private readonly errorPolicy;
+    private scheduledUntilMs;
+    private readonly slotsBySliceNumber;
+    private lastFiledSliceNumber;
+    private lastFiledSliceSlots;
+    private floorSliceNumber;
+    private nextSliceNumber;
+    private nextSliceNumberNeedsRescan;
+    constructor(options: TOIMSlotWheelOptions);
+    getNextSliceNumber(): number | undefined;
+    sweepUpToSliceNumber(upToSliceNumber: number): void;
+    flush(): void;
+    cancelAllSlots(): void;
+    protected fileSlot(sliceNumber: number, slot: TOIMSlot): void;
+    protected scheduleNextSweep(): void;
+    private cancelSlotWheelSchedule;
+    onSchedulerTimerFired(): void;
+    protected getSweptSliceNumberAt(nowMs: number): number;
+    protected abstract onSlotDue(slot: TOIMSlot, nowMs: number): void;
+    protected onSlotDropped(_slot: TOIMSlot): void;
+    protected onSweepFinished(): void;
+    private lowerNextSliceNumber;
+    private sweepSlice;
+}
+
+declare class OIMSlotReleaseWheel extends OIMSlotWheel {
+    readonly getReleaseDueMs: (slot: TOIMSlot) => number;
+    private readonly setReleaseDueMs;
+    private readonly releaseScheduledSlotFlag;
+    constructor(options: TOIMSlotReleaseWheelOptions);
+    markSlotReleaseDue(slot: TOIMSlot, keepMs: number): number;
+    markSlotReleaseDueNow(slot: TOIMSlot): void;
+    scheduleSlotRelease(slot: TOIMSlot, nowMs: number): void;
+    isSlotReleasable(slot: TOIMSlot): boolean;
+    cancelSlotRelease(slot: TOIMSlot): void;
+    isSlotReleaseScheduled(slot: TOIMSlot): boolean;
+    protected onSlotDue(slot: TOIMSlot, nowMs: number): void;
+    protected onSlotDropped(slot: TOIMSlot): void;
+    private fileReleaseSlot;
+}
 
 type TOIMCollectorSlot = {
     readonly unusedSlotCollectorSlot: TOIMUnusedSlotCollectorSlot;
-    readonly afterIdleReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
-    readonly afterWriteReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
-    readonly afterUnholdReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
+    readonly slotWheelOptions: TOIMSlotWheelOptions;
+    afterIdleSlotReleaseWheel: OIMSlotReleaseWheel | undefined;
+    afterWriteSlotReleaseWheel: OIMSlotReleaseWheel | undefined;
+    afterUnholdSlotReleaseWheel: OIMSlotReleaseWheel | undefined;
 };
 
 type TOIMChannelClock = {
@@ -178,21 +245,14 @@ type TOIMChannelSlot = TOIMFlushSchedulerSlot & {
     readonly effectChannelQueue: OIMChannelQueue<TOIMEffect>;
     readonly afterEachFlush: Set<() => void>;
     readonly afterEachFrameHandlerChannelQueue: OIMChannelQueue<() => void>;
-    readonly subframeStoreSlotChannelQueues: OIMChannelQueue<TOIMStoreSlot>[];
-    readonly changedStoreSlotChannelQueue: OIMChannelQueue<TOIMStoreSlot>;
-    readonly changedStoreSlotOwnerChannelQueue: OIMChannelQueue<IOIMSubframeCloseListener>;
     commandsStoreSlotChannelQueue: OIMChannelQueue<TOIMStoreSlot> | undefined;
     changedColumnNames: string[] | undefined;
-    subframesOpen: number;
-    contentSubframeDepth: number;
-    subframeDeliveryDepth: number;
-    flushRequestedInSubframe: boolean;
     flushRequested: boolean;
     isFlushing: boolean;
     dropped: boolean;
 };
 
-type TOIMEffect = TOIMDerivation & {
+type TOIMEffect = TOIMComputedDerivation & {
     readonly effectService: IOIMEffectService;
     readonly channelSlot: TOIMChannelSlot;
     readonly allRootSlots: readonly TOIMSlot[];
@@ -201,6 +261,7 @@ type TOIMEffect = TOIMDerivation & {
     effectFlags: number;
     readonly body: TOIMEffectBody;
     cleanup: (() => void) | undefined;
+    readonly sourceTracker: OIMSourceTracker | undefined;
 };
 
 type TOIMSlot = {
@@ -214,7 +275,7 @@ type TOIMSlot = {
     readonly releaseDueAfterUnholdMs: number;
     readonly slotFlags: number;
     readonly columnSlotStore: unknown;
-    readonly storeSlot: TOIMStoreSlot | undefined;
+    readonly storeSlot: TOIMStoreSlot;
     readonly owner: IOIMSlotOwner;
 };
 
@@ -228,36 +289,64 @@ interface IOIMStoreSlotListener {
     onStoreSlotCreated<TStore, TSlot extends TOIMSlot, TPatch>(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>): void;
 }
 
-declare class OIMStoreSlotListenerNone implements IOIMStoreSlotListener {
-    static readonly INSTANCE: OIMStoreSlotListenerNone;
+declare class OIMNoStoreSlotListener implements IOIMStoreSlotListener {
+    static readonly INSTANCE: OIMNoStoreSlotListener;
     onStoreSlotCreated(): void;
 }
 
+interface IOIMSlotSubscriptionListener {
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
+}
+
+declare class OIMNoSlotSubscriptionListener implements IOIMSlotSubscriptionListener {
+    static readonly INSTANCE: OIMNoSlotSubscriptionListener;
+    onSlotFirstSubscribed(): void;
+    onSlotLastUnsubscribed(): void;
+}
+
 declare function oimIsSlotEmpty(slot: TOIMSlot): boolean;
 
 declare function oimIsSlotReleased(slot: TOIMSlot): boolean;
 
-type TOIMEntitySlot<TEntity extends object = object, TKey = unknown> = TOIMIndexableSlot<TKey> & {
+type TOIMKeyedSlot<TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMSlot & {
+    readonly key: TKey;
+};
+
+type TOIMIndexableSlot<TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMKeyedSlot<TKey> & {
+    readonly indexKeys: unknown[] | undefined;
+};
+
+type TOIMEntityContentSlot<TEntity extends object = object> = TOIMSlot & {
     readonly entity: TEntity | undefined;
     readonly data: unknown[] | undefined;
 };
 
+type TOIMEntitySlot<TEntity extends object = object, TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMEntityContentSlot<TEntity> & TOIMIndexableSlot<TKey>;
+
 type TOIMColumnSlot = TOIMSlot & {
     readonly carrierSlot: TOIMSlot;
     readonly key: string;
 };
 
+type TOIMComputedSlot<TValue = unknown, TKey extends NonNullable<unknown> = NonNullable<unknown>, TSourceTracker extends OIMSourceTracker | undefined = undefined> = TOIMComputedContentSlot<TValue, TSourceTracker> & TOIMIndexableSlot<TKey>;
+
 type TOIMComputedColumnSlot = TOIMComputedSlot<unknown, string>;
 
-interface IOIMSlotStoreService<TKey, TSlot extends TOIMKeyedSlot = TOIMKeyedSlot, TStore = unknown> {
+interface IOIMSlotFilingService<TSlot extends TOIMSlot = TOIMSlot, TStore = unknown> {
     createStore(): TStore;
+    fileSlot(store: TStore, slot: TSlot): void;
+    unfileSlot(store: TStore, slot: TSlot): void;
+    getSlots(store: TStore): IterableIterator<TSlot>;
+    getSlotCount(store: TStore): number;
+}
+
+interface IOIMSlotStoreService<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey> = TOIMKeyedSlot<TKey>, TStore = unknown> extends IOIMSlotFilingService<TSlot, TStore> {
     ownKey<TOwnedKey extends TKey>(key: TOwnedKey): TOwnedKey;
     isSameKey(key: TKey, otherKey: TKey): boolean;
     get(store: TStore, key: TKey): TSlot | undefined;
     set(store: TStore, key: TKey, slot: TSlot): void;
     remove(store: TStore, key: TKey): void;
-    getSlots(store: TStore): IterableIterator<TSlot>;
-    getSlotCount(store: TStore): number;
 }
 
 declare class OIMSlotOwner implements IOIMSlotOwner {
@@ -266,12 +355,15 @@ declare class OIMSlotOwner implements IOIMSlotOwner {
     subscribeToSlot(slot: TOIMSlot, effect: TOIMEffect, edge: number): number;
     unsubscribeFromSlot(slot: TOIMSlot, positionInSlot: number, effect: TOIMEffect): boolean;
     releaseSlotIfUnheld(_slot: TOIMSlot): void;
+    unsafeMutateSlot(slot: TOIMSlot, mutateSlot: (editableSlot: TOIMEditable<TOIMSlot>) => void): void;
+    onSlotFirstSubscribed(_slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(_slot: TOIMSlot): void;
     protected onSlotIdle(_slot: TOIMSlot): void;
     protected onSlotUnheld(_slot: TOIMSlot): void;
     protected assertNotReleased(slot: TOIMSlot): void;
 }
 
-declare abstract class OIMColumnOwner<TCarrierSlot extends TOIMSlot, TColumnSlot extends TOIMKeyedSlot<string>> extends OIMSlotOwner {
+declare abstract class OIMColumnSlotOwner<TCarrierSlot extends TOIMSlot, TColumnSlot extends TOIMKeyedSlot<string>> extends OIMSlotOwner {
     protected readonly columnSlotStoreService: IOIMSlotStoreService<string, TColumnSlot>;
     protected constructor(columnSlotStoreService: IOIMSlotStoreService<string, TColumnSlot>);
     protected abstract createColumnSlot(carrierSlot: TCarrierSlot, key: string): TColumnSlot;
@@ -284,6 +376,8 @@ declare abstract class OIMColumnOwner<TCarrierSlot extends TOIMSlot, TColumnSlot
     holdColumn(carrierSlot: TCarrierSlot, key: string): TColumnSlot;
     isAnyColumnReferenced(storeSlot: TOIMStoreSlot, changedColumns: readonly string[]): boolean;
     releaseSlotIfUnheld(slot: TOIMSlot): void;
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
     protected getColumnGroupsByKeyOf(carrierSlot: TCarrierSlot): Map<string, TOIMColumnGroup> | undefined;
     protected getColumnReadersOf(carrierSlot: TCarrierSlot): Map<string, TOIMColumnReaders> | undefined;
     private getColumnIfFiled;
@@ -292,7 +386,7 @@ declare abstract class OIMColumnOwner<TCarrierSlot extends TOIMSlot, TColumnSlot
     private fileColumnSlot;
 }
 
-type TOIMColumnOwnerOptions<TColumnSlot extends TOIMKeyedSlot<string>, TColumnName extends string = string> = {
+type TOIMColumnSlotOwnerOptions<TColumnSlot extends TOIMKeyedSlot<string>, TColumnName extends string = string> = {
     columnSlotStoreService: IOIMSlotStoreService<string, TColumnSlot>;
     columnNames?: undefined;
 } | {
@@ -300,8 +394,8 @@ type TOIMColumnOwnerOptions<TColumnSlot extends TOIMKeyedSlot<string>, TColumnNa
     columnSlotStoreService?: undefined;
 };
 
-declare class OIMColumnOwnerPushDriven extends OIMColumnOwner<TOIMSlot, TOIMColumnSlot> {
-    constructor(options: TOIMColumnOwnerOptions<TOIMColumnSlot>);
+declare class OIMPushColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TOIMColumnSlot> {
+    constructor(options: TOIMColumnSlotOwnerOptions<TOIMColumnSlot>);
     protected createColumnSlot(carrierSlot: TOIMSlot, key: string): TOIMColumnSlot;
     protected carrierSlotOf(columnSlot: TOIMColumnSlot): TOIMSlot;
     markColumnsChanged(carrierSlot: TOIMSlot, patch: object | undefined, changedColumns: readonly string[] | undefined, channelSlot: TOIMChannelSlot): void;
@@ -310,22 +404,18 @@ declare class OIMColumnOwnerPushDriven extends OIMColumnOwner<TOIMSlot, TOIMColu
     private markValueColumnsChanged;
 }
 
-declare class OIMColumnOwnerPullDriven extends OIMColumnOwner<TOIMComputedSlot, TOIMComputedColumnSlot> implements IOIMComputedValueService {
-    constructor(options: TOIMColumnOwnerOptions<TOIMComputedColumnSlot>);
+declare class OIMPullColumnSlotOwner extends OIMColumnSlotOwner<TOIMComputedContentSlot, TOIMComputedColumnSlot> implements IOIMComputedValueService {
+    constructor(options: TOIMColumnSlotOwnerOptions<TOIMComputedColumnSlot>);
     private readonly deriveColumnSlotValue;
-    getValueForSlot(computedSlot: TOIMComputedSlot): unknown;
-    protected createColumnSlot(carrierSlot: TOIMComputedSlot, key: string): TOIMComputedColumnSlot;
-    protected carrierSlotOf(columnSlot: TOIMComputedColumnSlot): TOIMComputedSlot;
+    getValueForSlot(computedSlot: TOIMComputedContentSlot): unknown;
+    protected createColumnSlot(carrierSlot: TOIMComputedContentSlot, key: string): TOIMComputedColumnSlot;
+    protected carrierSlotOf(columnSlot: TOIMComputedColumnSlot): TOIMComputedContentSlot;
     private deriveColumnValue;
     private deriveColumnValues;
 }
 
-type TOIMSlotEditable<TSlot> = {
-    -readonly [K in keyof TSlot]: TSlot[K];
-};
-
 interface IOIMSlotStamp<TSlot> {
-    stamp(slotEditable: TOIMSlotEditable<TSlot>): void;
+    stamp(editableSlot: TOIMEditable<TSlot>): void;
 }
 
 type TOIMOrderedListCommand = {
@@ -344,18 +434,18 @@ type TOIMOrderedListCommand = {
     slots: readonly TOIMSlot[];
 };
 
-type TOIMBucketSlot<TSlots = unknown, TKey = unknown> = TOIMIndexableSlot<TKey> & {
+type TOIMBucketContentSlot<TSlots = unknown> = TOIMSlot & {
     readonly owner: IOIMSlotOwner;
-    readonly storeSlot: TOIMStoreSlot<unknown, TOIMBucketSlot<TSlots>>;
+    readonly storeSlot: TOIMStoreSlot<unknown, TOIMBucketContentSlot<TSlots>>;
     readonly bucketSlotsStore: TSlots;
     readonly commands: readonly TOIMOrderedListCommand[] | undefined;
     readonly isWholeListRecorded: boolean;
     readonly commandsStartedAtRevision: number;
     readonly commandsStartedAtEpoch: number;
-    readonly wasEmptyBeforeChange: boolean | undefined;
-    readonly isChangedAgainInSubframe: boolean;
 };
 
+type TOIMBucketSlot<TSlots = unknown, TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMBucketContentSlot<TSlots> & TOIMIndexableSlot<TKey>;
+
 type TOIMSameValueGuard<TValue = unknown> = (prevValue: TValue, nextValue: TValue) => boolean;
 
 declare function oimSameValueZeroGuard(prevValue: unknown, nextValue: unknown): boolean;
@@ -373,12 +463,12 @@ declare function oimUnholdSlotsIfAlive(slots: readonly TOIMSlot[]): void;
 type TOIMChannelScheduler = (flush: () => void) => void;
 
 interface IOIMEntityWriter {
-    readonly fillEntity: (slot: TOIMEntitySlot, entity: object) => void;
-    readonly putEntity: (slot: TOIMEntitySlot, entity: object, changedColumnNames: string[] | undefined) => boolean;
-    readonly patchEntity: (slot: TOIMEntitySlot, patch: object, changedColumnNames: string[] | undefined) => boolean;
-    readonly patchColumn: (slot: TOIMEntitySlot, columnName: string, value: unknown, changedColumnNames: string[] | undefined) => boolean;
-    readonly deleteColumns: (slot: TOIMEntitySlot, names: readonly string[]) => readonly string[];
-    readonly clearEntity: (slot: TOIMEntitySlot) => void;
+    readonly fillEntity: (slot: TOIMEntityContentSlot, entity: object) => void;
+    readonly putEntity: (slot: TOIMEntityContentSlot, entity: object, changedColumnNames: string[] | undefined) => boolean;
+    readonly patchEntity: (slot: TOIMEntityContentSlot, patch: object, changedColumnNames: string[] | undefined) => boolean;
+    readonly patchColumn: (slot: TOIMEntityContentSlot, columnName: string, value: unknown, changedColumnNames: string[] | undefined) => boolean;
+    readonly deleteColumns: (slot: TOIMEntityContentSlot, names: readonly string[]) => readonly string[];
+    readonly clearEntity: (slot: TOIMEntityContentSlot) => void;
 }
 
 type TOIMEntityColumnName<TEntity extends object> = [
@@ -387,23 +477,11 @@ type TOIMEntityColumnName<TEntity extends object> = [
 
 type TOIMEntityColumnValue<TEntity extends object, TColumnName> = object extends TEntity ? unknown : TColumnName extends keyof TEntity ? TEntity[TColumnName] : never;
 
-declare abstract class OIMFlushSchedulerService<TFlushSchedulerSlot extends TOIMFlushSchedulerSlot> {
-    abstract flush(flushSchedulerSlot: TFlushSchedulerSlot): void;
-    protected onSchedulerTimerFired(flushSchedulerSlot: TFlushSchedulerSlot): void;
-    protected isScheduled(flushSchedulerSlot: TFlushSchedulerSlot): boolean;
-    protected schedule(flushSchedulerSlot: TFlushSchedulerSlot, delayMs: number): void;
-    protected cancelSchedule(flushSchedulerSlot: TFlushSchedulerSlot): void;
-}
-
-declare class OIMChannelService extends OIMFlushSchedulerService<TOIMChannelSlot> {
+declare class OIMChannelService implements IOIMFlushSchedulerListener<TOIMChannelSlot> {
     static readonly INSTANCE: OIMChannelService;
     scheduleEffectRun(channelSlot: TOIMChannelSlot, effect: TOIMEffect): void;
     isRefusingWrites(channelSlot: TOIMChannelSlot): boolean;
     assertNotFlushing(channelSlot: TOIMChannelSlot): void;
-    isSubframeOpen(channelSlot: TOIMChannelSlot): boolean;
-    listChangedStoreSlot(channelSlot: TOIMChannelSlot, storeSlot: TOIMStoreSlot, subframeCloseListener: IOIMSubframeCloseListener): void;
-    openSubframe(channelSlot: TOIMChannelSlot): void;
-    closeSubframe(channelSlot: TOIMChannelSlot): void;
     subscribeAfterEachFrame(channelSlot: TOIMChannelSlot, handler: () => void): TOIMDisposer;
     subscribeAfterEachFlush(channelSlot: TOIMChannelSlot, handler: () => void): TOIMDisposer;
     subscribeOnceAfterFrame(channelSlot: TOIMChannelSlot, handler: () => void): TOIMDisposer;
@@ -412,6 +490,7 @@ declare class OIMChannelService extends OIMFlushSchedulerService<TOIMChannelSlot
     writeWithoutFlushCheck(channelSlot: TOIMChannelSlot, slot: TOIMSlot): void;
     private requestFlush;
     dropChannelSlot(channelSlot: TOIMChannelSlot): void;
+    onSchedulerTimerFired(channelSlot: TOIMChannelSlot): void;
     flush(channelSlot: TOIMChannelSlot): void;
     private runFrame;
     private dispatchAfterEachFrame;
@@ -432,72 +511,102 @@ interface IOIMChannelMap {
     readonly defaultChannelSlot: TOIMChannelSlot;
 }
 
-type TOIMErrorPolicyLogAndContinueOptions = {
+type TOIMLogAndContinueErrorPolicyOptions = {
     onError?: ((error: unknown) => void) | undefined;
 };
 
-declare class OIMErrorPolicyLogAndContinue implements IOIMErrorPolicy {
-    static readonly INSTANCE: OIMErrorPolicyLogAndContinue;
+declare class OIMLogAndContinueErrorPolicy implements IOIMErrorPolicy {
+    static readonly INSTANCE: OIMLogAndContinueErrorPolicy;
     private readonly onError;
-    constructor(options?: TOIMErrorPolicyLogAndContinueOptions);
+    constructor(options?: TOIMLogAndContinueErrorPolicyOptions);
     onErrorCaught(error: unknown): void;
 }
 
-declare class OIMErrorPolicyThrowAtOnce implements IOIMErrorPolicy {
+declare class OIMThrowAtOnceErrorPolicy implements IOIMErrorPolicy {
     onErrorCaught(error: unknown): void;
 }
 
-declare class OIMEffectSourceTracker {
-    private readonly slotEffectSourceList;
-    private computedEffectSourceList;
-    private committedAllRootSlots;
-    private trackedAllRootSlots;
-    private isTrackedAllRootSlotsChanged;
-    readSourceSlot<TSlot extends TOIMSlot>(slot: TSlot): TSlot;
-    readSourceComputedValue<TValue>(computedSlot: TOIMComputedSlot<TValue, unknown>): TValue;
-    openSourceTracking(): void;
-    closeSourceTracking(): boolean;
-    getTrackedSourceSlots(): readonly TOIMSlot[];
-    getTrackedSourceComputeds(): readonly TOIMComputedSlot[];
-    getTrackedAllRootSlots(): readonly TOIMSlot[];
-    commitTrackedSources(): void;
-    private trackAllRootSlots;
-}
-
-type TOIMEffectBodyWithSourceTracking = (effectSourceTracker: OIMEffectSourceTracker) => (() => void) | void;
+type TOIMSourceTrackingEffectBody = (sourceTracker: OIMSourceTracker) => (() => void) | void;
 
 declare class OIMEffectService implements IOIMEffectService {
     static readonly INSTANCE: OIMEffectService;
-    createEffect(channelMap: IOIMChannelMap, sourceSlots: readonly TOIMSlot[], sourceComputeds: readonly TOIMComputedSlot[], body: TOIMEffectBody): TOIMEffect;
-    subscribeEffect(channelMap: IOIMChannelMap, sourceSlots: readonly TOIMSlot[], sourceComputeds: readonly TOIMComputedSlot[], body: TOIMEffectBody): TOIMDisposer;
-    createEffectImmediate(channelMap: IOIMChannelMap, sourceSlots: readonly TOIMSlot[], sourceComputeds: readonly TOIMComputedSlot[], body: TOIMEffectBody): TOIMEffect;
-    createEffectWithSourceTracking(channelMap: IOIMChannelMap, effectBodyWithSourceTracking: TOIMEffectBodyWithSourceTracking): TOIMEffect;
+    createEffect(channelMap: IOIMChannelMap, body: TOIMEffectBody, sourceSlots?: readonly TOIMSlot[], sourceComputeds?: readonly TOIMComputedContentSlot[], sourceTrackingComputeds?: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker>[]): TOIMEffect;
+    subscribeEffect(channelMap: IOIMChannelMap, body: TOIMEffectBody, sourceSlots?: readonly TOIMSlot[], sourceComputeds?: readonly TOIMComputedContentSlot[], sourceTrackingComputeds?: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker>[]): TOIMDisposer;
+    createAndRunEffect(channelMap: IOIMChannelMap, body: TOIMEffectBody, sourceSlots?: readonly TOIMSlot[], sourceComputeds?: readonly TOIMComputedContentSlot[], sourceTrackingComputeds?: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker>[]): TOIMEffect;
+    createSourceTrackingEffect(channelMap: IOIMChannelMap, sourceTrackingEffectBody: TOIMSourceTrackingEffectBody): TOIMEffect;
+    private createEffectOverSourceTrackingComputeds;
+    private createEffectOverSourceTracker;
+    private scheduleEffectRunIfWrittenSinceFrameOpened;
     markEffectRunScheduled(effect: TOIMEffect, isSourceCheckOwed: boolean): boolean;
     runScheduledEffect(effect: TOIMEffect): void;
     runEffectIfSourcesChanged(effect: TOIMEffect): void;
     runEffect(effect: TOIMEffect): void;
     disposeEffect(effect: TOIMEffect): void;
     setPositionInSubscribedSlot(effect: TOIMEffect, edge: number, positionInSlot: number): void;
-    private runEffectBodyWithSourceTracking;
+    private runSourceTrackingEffectBody;
     private resubscribeToTrackedSources;
     private getSubscribedSlotAtEdge;
     private runCleanup;
     private unsubscribeFrom;
 }
 
-type TOIMComputedValueServiceOptions<TKey, TValue> = {
-    derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined;
+type TOIMComputedSources = {
+    readonly sourceSlots: readonly TOIMSlot[];
+    readonly sourceComputeds: readonly TOIMComputedContentSlot[];
+};
+
+type TOIMComputedValueReleaser<TValue> = (value: TValue) => void;
+
+type TOIMComputedValueServiceOptions<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined>> = {
+    derive?: ((computedSlot: TComputedSlot) => TValue) | undefined;
     sameValueGuard?: TOIMSameValueGuard<TValue> | undefined;
+    releaseValue?: TOIMComputedValueReleaser<TValue> | undefined;
 };
 
-declare class OIMComputedValueService<TKey, TValue> implements IOIMComputedValueService<TValue> {
+declare class OIMComputedValueService<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined> = TOIMComputedContentSlot<TValue>> implements IOIMComputedValueService<TValue> {
     private readonly derive;
-    private readonly sameValueGuard;
-    constructor(options: TOIMComputedValueServiceOptions<TKey, TValue>);
-    getValueForSlot(computedSlot: TOIMComputedSlot<TValue, TKey>): TValue;
+    protected readonly sameValueGuard: TOIMSameValueGuard<TValue>;
+    protected readonly releaseValue: TOIMComputedValueReleaser<TValue>;
+    constructor(options: TOIMComputedValueServiceOptions<TValue, TComputedSlot>);
+    getValueForSlot(computedSlot: TComputedSlot): TValue;
+    releaseSlotValue(computedSlot: TComputedSlot): void;
+}
+
+interface IOIMSlotContentService<TSlot extends TOIMSlot> {
+    isSlotEmpty(slot: TSlot): boolean;
+    releaseSlotContent(slot: TSlot): void;
+    hasReference(slot: TSlot): boolean;
+}
+
+interface IOIMKeyedSlotCreator<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot> {
+    createSlot(key: TKey, storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TSlot;
+}
+
+interface IOIMSingleSlotCreator<TSlot extends TOIMSlot> {
+    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TSlot;
+}
+
+type TOIMSlotContentComputedServiceOptions<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined>> = {
+    computedValueService: OIMComputedValueService<TValue, TComputedSlot>;
+    createSources?: ((computedSlot: TComputedSlot) => Partial<TOIMComputedSources>) | undefined;
+    initialValue?: TValue | undefined;
+};
+
+declare class OIMSlotContentComputedService<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined> = TOIMComputedContentSlot<TValue>> implements IOIMSlotContentService<TComputedSlot>, IOIMKeyedSlotCreator<NonNullable<unknown>, TComputedSlot & TOIMIndexableSlot>, IOIMSingleSlotCreator<TComputedSlot> {
+    private readonly computedValueService;
+    private readonly createSources;
+    private readonly initialValue;
+    constructor(options: TOIMSlotContentComputedServiceOptions<TValue, TComputedSlot>);
+    createSlot<TKey extends NonNullable<unknown>>(key: TKey, storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TComputedSlot & TOIMIndexableSlot<TKey>;
+    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TComputedSlot;
+    isSlotEmpty(): boolean;
+    releaseSlotContent(computedSlot: TComputedSlot): void;
+    hasReference(): boolean;
+    protected createSourceTracker(): OIMSourceTracker | undefined;
+    protected attachSources(computedSlot: TComputedSlot, storeSlot: TOIMStoreSlot): void;
 }
 
-declare function oimRefreshSourceComputeds(sourceComputeds: readonly TOIMComputedSlot[]): void;
+declare function oimRefreshSourceComputeds(sourceComputeds: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker | undefined>[]): void;
 
 interface IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots: boolean;
@@ -510,40 +619,27 @@ interface IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-interface IOIMSlotContentStrategy<TSlot extends TOIMSlot, TKey, TSlotOwnerService extends IOIMSlotOwner = IOIMSlotOwner> {
-    createSlot(key: TKey, storeSlot: TOIMStoreSlot | undefined, slotOwnerService: TSlotOwnerService): TSlot;
-    isSlotEmpty(slot: TSlot): boolean;
-    releaseSlotContent(slot: TSlot, slotOwnerService: TSlotOwnerService): void;
-    hasReference(slot: TSlot): boolean;
-}
-
-interface IOIMSlotContentFlushStrategy<TSlot extends TOIMSlot, TSlotOwnerService extends IOIMSlotOwner = IOIMSlotOwner> {
-    onSubframeClosed(storeSlot: TOIMStoreSlot<unknown, TSlot>, slotOwnerService: TSlotOwnerService): void;
-}
-
-type TOIMSlotOwnerServiceOptions<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStore, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch> = {
+type TOIMSlotOwnerServiceOptions<TSlot extends TOIMSlot, TStore, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot>> = {
     slotStamp?: IOIMSlotStamp<TSlot> | undefined;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
-    slotStoreService: IOIMSlotStoreService<TKey, TSlot, TStore>;
-    slotContentStrategy: IOIMSlotContentStrategy<TSlot, TKey, OIMSlotOwnerService<TKey, TSlot, TStore, TColumnName, TColumnSlot, TColumnOwner, TPatch>>;
-    slotContentFlushStrategy?: IOIMSlotContentFlushStrategy<TSlot, OIMSlotOwnerService<TKey, TSlot, TStore, TColumnName, TColumnSlot, TColumnOwner, TPatch>> | undefined;
-    columnOwnerOptions: TOIMColumnOwnerOptions<TColumnSlot, TColumnName>;
-    createColumnOwner: (columnOwnerOptions: TOIMColumnOwnerOptions<TColumnSlot, TColumnName>) => TColumnOwner;
+    slotSubscriptionListener?: IOIMSlotSubscriptionListener | undefined;
+    slotFilingService: IOIMSlotFilingService<TSlot, TStore>;
+    slotContentService: IOIMSlotContentService<TSlot>;
+    columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TColumnSlot, TColumnName>;
+    createColumnSlotOwner: (columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TColumnSlot, TColumnName>) => TColumnSlotOwner;
 };
 
-declare class OIMSlotOwnerService<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStore, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSlotOwner implements IOIMSubframeCloseListener {
-    private readonly slotContentStrategy;
-    private readonly slotStoreService;
+declare class OIMSlotOwnerService<TSlot extends TOIMSlot, TStore, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSlotOwner {
+    private readonly slotContentService;
+    private readonly slotFilingService;
     private readonly slotStamp;
     private readonly slotReleasePolicy;
     private readonly releasesWrittenSlots;
     private readonly schedulesReleaseOnWrite;
-    readonly columnOwner: TColumnOwner;
-    private readonly slotContentFlushStrategy;
-    constructor(options: TOIMSlotOwnerServiceOptions<TKey, TSlot, TStore, TColumnName, TColumnSlot, TColumnOwner, TPatch>);
-    listChangedStoreSlot(storeSlot: TOIMStoreSlot<unknown, TSlot>): void;
-    onStoreSlotSubframeClosed(storeSlot: TOIMStoreSlot): void;
-    createSlot(key: TKey, storeSlot: TOIMStoreSlot | undefined): TSlot;
+    readonly settlesWrittenSlots: boolean;
+    private readonly slotSubscriptionListener;
+    readonly columnSlotOwner: TColumnSlotOwner;
+    constructor(options: TOIMSlotOwnerServiceOptions<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner>);
     isSlotEmpty(slot: TSlot): boolean;
     hasColumnSlots(slot: TOIMSlot): boolean;
     hasContentChangeListeners(slot: TOIMSlot): boolean;
@@ -554,40 +650,47 @@ declare class OIMSlotOwnerService<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStor
     releaseSlotIfUnheldAfterListeners(slot: TSlot): void;
     releaseWrittenSlotIfUnheld(slot: TSlot): void;
     assertWritable(slot: TOIMSlot): void;
-    fileSlot(storeSlot: TOIMStoreSlot<TStore, TSlot>, slot: TSlot): void;
+    fileSlot(slot: TSlot): void;
     writeSlotToChannelAndSettle(slot: TSlot, wasEmpty: boolean): void;
     settleEmptiness(slot: TSlot, isEmpty: boolean): void;
     markEmptiness(slot: TSlot, isEmpty: boolean): void;
     private settleWrite;
     private scheduleSlotRelease;
     protected onSlotIdle(slot: TSlot): void;
+    onSlotFirstSubscribed(slot: TOIMSlot): void;
+    onSlotLastUnsubscribed(slot: TOIMSlot): void;
     protected onSlotUnheld(slot: TSlot): void;
     releaseSlotIfUnheld(slot: TOIMSlot): void;
     private isReleasable;
     private releaseSlot;
 }
 
-declare class OIMContentChangeListenerService {
-    static readonly INSTANCE: OIMContentChangeListenerService;
-    addContentChangeListener<TSlot extends TOIMSlot, TPatch>(storeSlot: TOIMStoreSlot<unknown, TSlot, TPatch>, listener: IOIMContentChangeListener<TSlot, TPatch>, readColumnNames: readonly string[] | undefined): void;
-    removeContentChangeListener<TSlot extends TOIMSlot, TPatch>(storeSlot: TOIMStoreSlot<unknown, TSlot, TPatch>, listener: IOIMContentChangeListener<TSlot, TPatch>): boolean;
+interface IOIMSlotContentWriter<TSlot extends TOIMSlot, TContent> {
+    insertSlotContent(slot: TSlot, content: TContent, changedSlots?: TSlot[]): void;
+    writeSlotContent(slot: TSlot, content: TContent): boolean;
+    clearSlotContent(slot: TSlot): void;
+}
+
+declare class OIMSlotContentChangeListenerService {
+    static readonly INSTANCE: OIMSlotContentChangeListenerService;
+    addContentChangeListener<TSlot extends TOIMSlot, TPatch>(storeSlot: TOIMStoreSlot<unknown, TSlot, TPatch>, listener: IOIMSlotContentChangeListener<TSlot, TPatch>, readColumnNames: readonly string[] | undefined): void;
+    removeContentChangeListener<TSlot extends TOIMSlot, TPatch>(storeSlot: TOIMStoreSlot<unknown, TSlot, TPatch>, listener: IOIMSlotContentChangeListener<TSlot, TPatch>): boolean;
     addReadColumn(storeSlot: TOIMStoreSlot, columnName: string): void;
     removeReadColumn(storeSlot: TOIMStoreSlot, columnName: string): void;
     addReadAnyColumn(storeSlot: TOIMStoreSlot): void;
     removeReadAnyColumn(storeSlot: TOIMStoreSlot): void;
 }
 
-interface IOIMSlotEmptiness<TSlot> {
+interface IOIMSlotEmptinessPolicy<TSlot> {
     isEmpty(slot: TSlot): boolean;
 }
 
-type TOIMSlotContentEntityServiceOptions<TEntity extends object, TKey, TStore, TColumnName extends string> = Pick<TOIMSlotOwnerServiceOptions<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, Partial<TEntity>>, 'slotStamp' | 'slotReleasePolicy' | 'slotStoreService' | 'columnOwnerOptions' | 'createColumnOwner'> & {
-    keyOf: (entity: TEntity) => TKey;
+type TOIMSlotContentEntityServiceOptions<TEntity extends object> = {
     entityWriter: IOIMEntityWriter;
-    slotEmptiness: IOIMSlotEmptiness<TOIMEntitySlot<TEntity, TKey>>;
+    slotEmptinessPolicy: IOIMSlotEmptinessPolicy<TOIMEntityContentSlot<TEntity>>;
 };
 
-type TOIMEntitySlotOwnerService<TEntity extends object, TKey, TStore = unknown, TColumnName extends string = string> = OIMSlotOwnerService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, Partial<TEntity>>;
+type TOIMEntitySlotOwnerService<TEntity extends object, TEntitySlot extends TOIMEntityContentSlot<TEntity> = TOIMEntitySlot<TEntity>, TStore = unknown, TColumnName extends string = string> = OIMSlotOwnerService<TEntitySlot, TStore, TColumnName, TOIMColumnSlot, OIMPushColumnSlotOwner, Partial<TEntity>>;
 
 declare class OIMUnusedSlotCollectorService {
     static readonly INSTANCE: OIMUnusedSlotCollectorService;
@@ -608,9 +711,9 @@ type TOIMCollectorSlotOptions = {
 
 declare function createOIMCollectorSlot(options: TOIMCollectorSlotOptions): TOIMCollectorSlot;
 
-declare abstract class OIMSlotColumnService<TSlot extends TOIMSlot, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot>> {
-    protected readonly columnOwner: TColumnOwner;
-    protected constructor(columnOwner: TColumnOwner);
+declare class OIMColumnSlotService<TSlot extends TOIMSlot, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot>> {
+    private readonly columnSlotOwner;
+    constructor(columnSlotOwner: TColumnSlotOwner);
     getColumn(slot: TSlot, columnName: TColumnName): TColumnSlot;
     holdColumn(slot: TSlot, columnName: TColumnName): TColumnSlot;
     getAnyColumn(slot: TSlot): TColumnSlot;
@@ -620,22 +723,24 @@ declare abstract class OIMSlotColumnService<TSlot extends TOIMSlot, TColumnName
     unholdColumn(columnSlot: TColumnSlot): void;
 }
 
-type TOIMSlotCollectionServiceOptions<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot> = OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> = {
-    slotOwnerService: OIMSlotOwnerService<TKey, TSlot, TStore, TColumnName, TColumnSlot, TColumnOwner, TPatch>;
+type TOIMSlotCollectionServiceOptions<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>> = Omit<TOIMSlotOwnerServiceOptions<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner>, 'slotFilingService' | 'slotContentService'> & {
     slotStoreService: IOIMSlotStoreService<TKey, TSlot, TStore>;
-    slotContentService: TSlotContentService;
+    slotContentService: TSlotContentService & IOIMSlotContentService<TSlot> & IOIMKeyedSlotCreator<TKey, TSlot>;
     storeSlotListener?: IOIMStoreSlotListener | undefined;
 };
 
-declare class OIMSlotCollectionService<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot> = OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSlotColumnService<TSlot, TColumnName, TColumnSlot, TColumnOwner> {
+declare class OIMSlotCollectionService<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> {
     readonly slotContentService: TSlotContentService;
-    protected readonly slotOwnerService: OIMSlotOwnerService<TKey, TSlot, TStore, TColumnName, TColumnSlot, TColumnOwner, TPatch>;
-    private readonly slotStoreService;
+    readonly columnSlotService: OIMColumnSlotService<TSlot, TColumnName, TColumnSlot, TColumnSlotOwner>;
+    protected readonly slotOwnerService: OIMSlotOwnerService<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>;
+    protected readonly slotStoreService: IOIMSlotStoreService<TKey, TSlot, TStore>;
+    protected readonly keyedSlotCreator: IOIMKeyedSlotCreator<TKey, TSlot>;
     private readonly storeSlotListener;
-    constructor(options: TOIMSlotCollectionServiceOptions<TKey, TSlot, TStore, TSlotContentService, TColumnName, TColumnSlot, TColumnOwner, TPatch>);
-    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TStore, TSlot, TPatch>;
-    createStoreSlotFrom(sourceStoreSlot: TOIMStoreSlot): TOIMStoreSlot<TStore, TSlot, TPatch>;
-    protected createStoreSlotWith<TStoreSlot extends TOIMStoreSlot<TStore, TSlot, TPatch>>(createStoreSlotLiteral: (store: TStore) => TStoreSlot): TStoreSlot;
+    constructor(options: TOIMSlotCollectionServiceOptions<TKey, TSlot, TStore, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner>);
+    get slotOwner(): IOIMSlotOwner;
+    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TStore, TSlot, TPatch, this>;
+    createStoreSlotFrom(sourceStoreSlot: TOIMStoreSlot): TOIMStoreSlot<TStore, TSlot, TPatch, this>;
+    protected createStoreSlotOverNewStore<TStoreSlot extends TOIMStoreSlot<TStore, TSlot, TPatch>>(createStoreSlotLiteral: (store: TStore) => TStoreSlot): TStoreSlot;
     findSlotByKey(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, key: TKey): TSlot | undefined;
     hasSlotContentByKey(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, key: TKey): boolean;
     getSlotByKey(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, key: TKey): TSlot;
@@ -643,36 +748,43 @@ declare class OIMSlotCollectionService<TKey, TSlot extends TOIMKeyedSlot<TKey>,
     getSlots(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>): IterableIterator<TSlot>;
     getSlotCount(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>): number;
     isSameKey(key: TKey, otherKey: TKey): boolean;
+    openBatch(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>): void;
+    closeBatch(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>): void;
+    writeInBatch<TResult>(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, write: () => TResult): TResult;
     protected onSlotMinted(_storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, _slot: TSlot): void;
     private mintSlotByKey;
 }
 
-declare class OIMSlotStoreServiceSingleSlotDriven<TSlot extends TOIMKeyedSlot<void>> implements IOIMSlotStoreService<void, TSlot, TOIMSingleSlotStore<TSlot>> {
-    static readonly INSTANCE: OIMSlotStoreServiceSingleSlotDriven<TOIMKeyedSlot<void>>;
+declare class OIMWritableSlotCollectionService<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey>, TStore, TContent, TSlotContentService extends IOIMSlotContentWriter<TSlot, TContent> & IOIMSlotContentService<TSlot> & IOIMKeyedSlotCreator<TKey, TSlot>, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSlotCollectionService<TKey, TSlot, TStore, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch> {
+    writeSlotContentByKey(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, key: TKey, content: TContent, changedSlots?: TSlot[]): TSlot;
+}
+
+declare class OIMSingleSlotStoreService<TSlot extends TOIMSlot> implements IOIMSlotFilingService<TSlot, TOIMSingleSlotStore<TSlot>> {
+    static readonly INSTANCE: OIMSingleSlotStoreService<TOIMSlot>;
     createStore(): TOIMSingleSlotStore<TSlot>;
-    ownKey<TOwnedKey extends void>(key: TOwnedKey): TOwnedKey;
-    isSameKey(): boolean;
-    get(store: TOIMSingleSlotStore<TSlot>): TSlot | undefined;
-    set(store: TOIMSingleSlotStore<TSlot>, _key: void, slot: TSlot): void;
-    remove(store: TOIMSingleSlotStore<TSlot>): void;
+    getSingleSlot(store: TOIMSingleSlotStore<TSlot>): TSlot | undefined;
+    fileSlot(store: TOIMSingleSlotStore<TSlot>, slot: TSlot): void;
+    unfileSlot(store: TOIMSingleSlotStore<TSlot>): void;
     getSlots(store: TOIMSingleSlotStore<TSlot>): IterableIterator<TSlot>;
     getSlotCount(store: TOIMSingleSlotStore<TSlot>): number;
 }
 
-type TOIMSingleSlotServiceOptions<TSlot extends TOIMKeyedSlot<void>, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot> = OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> = {
-    slotOwnerService: OIMSlotOwnerService<void, TSlot, TOIMSingleSlotStore<TSlot>, TColumnName, TColumnSlot, TColumnOwner, TPatch>;
-    slotStoreService: OIMSlotStoreServiceSingleSlotDriven<TSlot>;
-    slotContentService: TSlotContentService;
+type TOIMSingleSlotServiceOptions<TSlot extends TOIMSlot, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>> = Omit<TOIMSlotOwnerServiceOptions<TSlot, TOIMSingleSlotStore<TSlot>, TColumnName, TColumnSlot, TColumnSlotOwner>, 'slotFilingService' | 'slotContentService'> & {
+    slotStoreService: OIMSingleSlotStoreService<TSlot>;
+    slotContentService: TSlotContentService & IOIMSlotContentService<TSlot> & IOIMSingleSlotCreator<TSlot>;
     storeSlotListener?: IOIMStoreSlotListener | undefined;
 };
 
-declare class OIMSingleSlotService<TSlot extends TOIMKeyedSlot<void>, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnOwner extends OIMColumnOwner<TOIMSlot, TColumnSlot> = OIMColumnOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSlotColumnService<TSlot, TColumnName, TColumnSlot, TColumnOwner> {
+declare class OIMSingleSlotService<TSlot extends TOIMSlot, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> {
     readonly slotContentService: TSlotContentService;
-    protected readonly slotOwnerService: OIMSlotOwnerService<void, TSlot, TOIMSingleSlotStore<TSlot>, TColumnName, TColumnSlot, TColumnOwner, TPatch>;
-    private readonly slotStoreService;
+    readonly columnSlotService: OIMColumnSlotService<TSlot, TColumnName, TColumnSlot, TColumnSlotOwner>;
+    protected readonly slotOwnerService: OIMSlotOwnerService<TSlot, TOIMSingleSlotStore<TSlot>, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>;
+    protected readonly slotStoreService: OIMSingleSlotStoreService<TSlot>;
+    protected readonly singleSlotCreator: IOIMSingleSlotCreator<TSlot>;
     private readonly storeSlotListener;
-    constructor(options: TOIMSingleSlotServiceOptions<TSlot, TSlotContentService, TColumnName, TColumnSlot, TColumnOwner, TPatch>);
-    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>;
+    constructor(options: TOIMSingleSlotServiceOptions<TSlot, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner>);
+    get slotOwner(): IOIMSlotOwner;
+    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, this>;
     findSingleSlot(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>): TSlot | undefined;
     hasSingleSlotContent(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>): boolean;
     getSingleSlot(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>): TSlot;
@@ -680,64 +792,59 @@ declare class OIMSingleSlotService<TSlot extends TOIMKeyedSlot<void>, TSlotConte
     private mintSingleSlot;
 }
 
-declare class OIMSlotContentEntityService<TEntity extends object, TKey, TStore = unknown, TColumnName extends string = string> {
-    readonly keyOf: (entity: TEntity) => TKey;
-    readonly slotStoreService: IOIMSlotStoreService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore>;
-    private readonly slotOwnerService;
+declare class OIMWritableSingleSlotService<TSlot extends TOIMSlot, TContent, TSlotContentService extends IOIMSlotContentWriter<TSlot, TContent> & IOIMSlotContentService<TSlot> & IOIMSingleSlotCreator<TSlot>, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> extends OIMSingleSlotService<TSlot, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch> {
+    writeSingleSlotContent(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>, content: TContent, changedSlots?: TSlot[]): TSlot;
+    clearSingleSlotContent(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>): void;
+}
+
+declare class OIMSlotContentEntityService<TEntity extends object, TKey extends NonNullable<unknown> = TOIMStoreKey, TColumnName extends string = string> implements IOIMSlotContentWriter<TOIMEntityContentSlot<TEntity>, TEntity>, IOIMSlotContentService<TOIMEntityContentSlot<TEntity>>, IOIMKeyedSlotCreator<TKey, TOIMEntitySlot<TEntity, TKey>>, IOIMSingleSlotCreator<TOIMEntityContentSlot<TEntity>> {
     private readonly entityWriter;
-    private readonly slotEmptiness;
-    private readonly updatesEmptinessOnColumnWrite;
-    constructor(options: TOIMSlotContentEntityServiceOptions<TEntity, TKey, TStore, TColumnName>);
-    get slotOwner(): IOIMSlotOwner;
-    findEntityByKey(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, key: TKey): TEntity | undefined;
-    upsertEntity(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, entity: TEntity, changedEntitySlots?: TOIMEntitySlot<TEntity, TKey>[]): TOIMEntitySlot<TEntity, TKey>;
-    upsertEntities(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, entities: readonly TEntity[], changedEntitySlots?: TOIMEntitySlot<TEntity, TKey>[]): TOIMEntitySlot<TEntity, TKey>[];
-    insertEntity(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, key: TKey, entity: TEntity, changedEntitySlots?: TOIMEntitySlot<TEntity, TKey>[]): TOIMEntitySlot<TEntity, TKey>;
-    insertEntities(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, entities: readonly TEntity[]): void;
-    fillEntities(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, keys: readonly TKey[], entities: readonly TEntity[]): void;
-    private fillEntitiesUnderKeys;
-    clearAllEntities(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>): void;
-    private fillEachEntity;
-    private refileRepeatedKey;
+    private readonly slotEmptinessPolicy;
+    private readonly isSlotEmptinessCustom;
+    constructor(options: TOIMSlotContentEntityServiceOptions<TEntity>);
+    createSlot(key: TKey, storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMEntitySlot<TEntity, TKey>;
+    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMEntityContentSlot<TEntity>;
+    isSlotEmpty(entitySlot: TOIMEntityContentSlot<TEntity>): boolean;
+    hasReference(): boolean;
+    private updatesEmptinessOnColumnWriteOf;
+    private slotOwnerServiceOf;
+    insertSlotContent(entitySlot: TOIMEntityContentSlot<TEntity>, entity: TEntity, changedEntitySlots?: TOIMEntityContentSlot<TEntity>[]): void;
     private insertEntityOnFastPath;
-    private insertEntityInSubframe;
-    writeEntity(entitySlot: TOIMEntitySlot<TEntity, TKey>, entity: TEntity): boolean;
-    updateEntity(entitySlot: TOIMEntitySlot<TEntity, TKey>, patch: Partial<TEntity>): TOIMEntitySlot<TEntity, TKey>;
-    updateEntityColumn<TColumn extends keyof TEntity & string>(entitySlot: TOIMEntitySlot<TEntity, TKey>, columnName: TColumn, value: TEntity[TColumn]): TOIMEntitySlot<TEntity, TKey>;
-    deleteEntityColumns(entitySlot: TOIMEntitySlot<TEntity, TKey>, columnNames: readonly TOIMEntityColumnName<TEntity>[]): TOIMEntitySlot<TEntity, TKey>;
-    markEntityChanged(entitySlot: TOIMEntitySlot<TEntity, TKey>, changedColumns?: readonly (keyof TEntity & string)[]): void;
-    deleteEntity(entitySlot: TOIMEntitySlot<TEntity, TKey>): void;
-    deleteEntities(storeSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, entitySlots: readonly TOIMEntitySlot<TEntity, TKey>[]): void;
-    private updateEntityInSubframe;
+    private insertEntityOffFastPath;
+    writeSlotContent(entitySlot: TOIMEntityContentSlot<TEntity>, entity: TEntity): boolean;
+    updateEntity<TEntitySlot extends TOIMEntityContentSlot<TEntity>>(entitySlot: TEntitySlot, patch: Partial<TEntity>): TEntitySlot;
+    updateEntityColumn<TColumn extends keyof TEntity & string, TEntitySlot extends TOIMEntityContentSlot<TEntity>>(entitySlot: TEntitySlot, columnName: TColumn, value: TEntity[TColumn]): TEntitySlot;
+    deleteEntityColumns<TEntitySlot extends TOIMEntityContentSlot<TEntity>>(entitySlot: TEntitySlot, columnNames: readonly TOIMEntityColumnName<TEntity>[]): TEntitySlot;
+    markEntityChanged(entitySlot: TOIMEntityContentSlot<TEntity>, changedColumns?: readonly (keyof TEntity & string)[]): void;
+    clearSlotContent(entitySlot: TOIMEntityContentSlot<TEntity>): void;
+    private updateEntityOffFastPath;
     private updateEntityColumnOffFastPath;
-    private updateEntityColumnInSubframe;
+    private updateEntityColumnAndDispatch;
     private dispatchPatchWritten;
     private writeSlotToChannelAndReleaseIfUnheld;
     private dispatchContentChangeAndReleaseIfUnheld;
-    private releaseSlotContent;
-    private fillSlotContent;
-    private withdrawSlotContent;
-    private clearSlotContent;
+    releaseSlotContent(entitySlot: TOIMEntityContentSlot<TEntity>): void;
+    private clearEntityAndMarkColumns;
     private isOnFastPath;
     private hasChangedColumnReaders;
     private updateEntitySlotEmptiness;
-    private writeEntityWithoutSubframe;
+    private writeEntityToSlot;
     private dispatchColumnsChanged;
 }
 
-declare function createOIMSlotCollectionService<TKey, TSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService extends object, TColumnName extends string = string, TPatch = unknown>(options: {
-    slotContentService: TSlotContentService & {
-        readonly slotOwner: IOIMSlotOwner;
-        readonly slotStoreService: IOIMSlotStoreService<TKey, TSlot, TStore>;
-    };
-}): OIMSlotCollectionService<TKey, TSlot, TStore, TSlotContentService, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, TPatch>;
+type TOIMSlotContentServiceKey<TSlotContentService> = TSlotContentService extends {
+    createSlot(key: infer TKey, ...rest: never[]): unknown;
+} ? Extract<TKey, NonNullable<unknown>> : never;
+
+type TOIMSlotContentServiceSlot<TSlotContentService> = TSlotContentService extends {
+    createSlot(...args: never[]): infer TSlot;
+} ? Extract<TSlot, TOIMKeyedSlot<TOIMSlotContentServiceKey<TSlotContentService>>> : never;
 
-declare function createOIMSingleSlotService<TSlot extends TOIMKeyedSlot<void>, TSlotContentService extends {
-    readonly slotOwner: IOIMSlotOwner;
-    readonly slotStoreService: IOIMSlotStoreService<void, TSlot, TOIMSingleSlotStore<TSlot>>;
-}, TColumnName extends string = string, TPatch = unknown>(options: {
-    slotContentService: TSlotContentService;
-}): OIMSingleSlotService<TSlot, TSlotContentService, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, TPatch>;
+type TOIMSlotContentServiceContent<TSlotContentService> = TSlotContentService extends {
+    writeSlotContent(slot: never, content: infer TContent): boolean;
+} ? TContent : never;
+
+type TOIMSlotContentServicePatch<TSlotContentService> = TOIMSlotContentServiceContent<TSlotContentService> extends readonly unknown[] ? TOIMSlotContentServiceContent<TSlotContentService> : Partial<TOIMSlotContentServiceContent<TSlotContentService>>;
 
 interface IOIMIndexKeysService {
     createPositions(): TOIMIndexKeysPositions;
@@ -747,309 +854,380 @@ interface IOIMIndexKeysService {
     set<TIndexKey>(slot: TOIMIndexableSlot, position: number, indexKey: TIndexKey | undefined): void;
 }
 
-type TOIMDBOptions = {
-    channelScheduler?: TOIMChannelScheduler | undefined;
-    errorPolicy?: IOIMErrorPolicy | undefined;
-    onBeforeFlush?: (() => void) | undefined;
-    getNowMs?: (() => number) | undefined;
-    releaseTimer?: TOIMTimer | undefined;
-    entityWriter?: IOIMEntityWriter | undefined;
-    indexKeysService?: IOIMIndexKeysService | undefined;
+type TOIMDefaultsOptions = {
     slotStamp?: IOIMSlotStamp<TOIMSlot> | undefined;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
+    entityWriter?: IOIMEntityWriter | undefined;
+    entitySlotEmptinessPolicy?: IOIMSlotEmptinessPolicy<TOIMEntityContentSlot> | undefined;
+    indexKeysService?: IOIMIndexKeysService | undefined;
+    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
+    computedColumnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
+    storeSlotListener?: IOIMStoreSlotListener | undefined;
 };
 
-declare class OIMDB implements IOIMChannelMap {
-    readonly clock: TOIMChannelClock;
-    readonly collectorSlot: TOIMCollectorSlot;
-    readonly defaultChannelSlot: TOIMChannelSlot;
-    readonly entityWriter: IOIMEntityWriter | undefined;
+declare class OIMDefaults {
+    static readonly INSTANCE: OIMDefaults;
     readonly slotStamp: IOIMSlotStamp<TOIMSlot> | undefined;
     readonly slotReleasePolicy: IOIMSlotReleasePolicy | undefined;
+    readonly entityWriter: IOIMEntityWriter | undefined;
+    readonly entitySlotEmptinessPolicy: IOIMSlotEmptinessPolicy<TOIMEntityContentSlot> | undefined;
     readonly indexKeysService: IOIMIndexKeysService | undefined;
-    constructor(options?: TOIMDBOptions);
-    flush(): void;
+    readonly columnSlotStoreService: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
+    readonly computedColumnSlotStoreService: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
+    readonly storeSlotListener: IOIMStoreSlotListener | undefined;
+    constructor(options?: TOIMDefaultsOptions);
 }
 
-type TOIMSlotContentEntityServiceFactoryOptions<TEntity extends object, TKey, TColumnName extends string> = {
-    entityWriter?: IOIMEntityWriter | undefined;
-    slotEmptiness?: IOIMSlotEmptiness<TOIMEntitySlot<TEntity, TKey>> | undefined;
+declare function createOIMSlotCollectionService<TSlotContentService extends object, TStore = Map<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>>, TColumnName extends string = string>(options: {
+    defaults?: OIMDefaults | undefined;
+    slotContentService: TSlotContentService & IOIMKeyedSlotCreator<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>> & IOIMSlotContentWriter<TOIMSlotContentServiceSlot<TSlotContentService>, TOIMSlotContentServiceContent<TSlotContentService>> & IOIMSlotContentService<TOIMSlotContentServiceSlot<TSlotContentService>>;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
+    slotSubscriptionListener?: IOIMSlotSubscriptionListener | undefined;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
     columnNames?: readonly TColumnName[] | undefined;
-};
+} & (TOIMSlotContentServiceKey<TSlotContentService> extends readonly unknown[] ? {
+    slotStoreService: IOIMSlotStoreService<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>, TStore>;
+} : {
+    slotStoreService?: IOIMSlotStoreService<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>, TStore> | undefined;
+})): OIMWritableSlotCollectionService<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>, TStore, TOIMSlotContentServiceContent<TSlotContentService>, TSlotContentService & IOIMKeyedSlotCreator<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>> & IOIMSlotContentWriter<TOIMSlotContentServiceSlot<TSlotContentService>, TOIMSlotContentServiceContent<TSlotContentService>> & IOIMSlotContentService<TOIMSlotContentServiceSlot<TSlotContentService>>, TColumnName, TOIMColumnSlot, OIMPushColumnSlotOwner, TOIMSlotContentServicePatch<TSlotContentService>>;
 
-declare function createOIMSlotContentEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>>(db: OIMDB, options: TOIMSlotContentEntityServiceFactoryOptions<TEntity, void, TColumnName> & {
-    keyOf?: undefined;
-    slotStoreService: OIMSlotStoreServiceSingleSlotDriven<TOIMEntitySlot<TEntity, void>>;
-}): OIMSlotContentEntityService<TEntity, void, TOIMSingleSlotStore<TOIMEntitySlot<TEntity, void>>, TColumnName>;
-declare function createOIMSlotContentEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>, TKey extends TOIMStoreKey = TOIMStoreKey>(db: OIMDB, options: TOIMSlotContentEntityServiceFactoryOptions<TEntity, TKey, TColumnName> & {
-    keyOf: (entity: TEntity) => TKey;
-    slotStoreService?: undefined;
-}): OIMSlotContentEntityService<TEntity, TKey, Map<TKey, TOIMEntitySlot<TEntity, TKey>>, TColumnName>;
-declare function createOIMSlotContentEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>, TKey extends TOIMStoreKey | readonly unknown[] = TOIMStoreKey, TStore = Map<TKey, TOIMEntitySlot<TEntity, TKey>>>(db: OIMDB, options: TOIMSlotContentEntityServiceFactoryOptions<TEntity, TKey, TColumnName> & {
-    keyOf: (entity: TEntity) => TKey;
-    slotStoreService: IOIMSlotStoreService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore>;
-}): OIMSlotContentEntityService<TEntity, TKey, TStore, TColumnName>;
+type TOIMSlotContentServiceSingleSlot<TSlotContentService> = TSlotContentService extends {
+    createSingleSlot(...args: never[]): infer TSlot;
+} ? Extract<TSlot, TOIMSlot> : never;
 
-declare function createOIMEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>, TKey extends TOIMStoreKey = TOIMStoreKey>(db: OIMDB, options: TOIMSlotContentEntityServiceFactoryOptions<TEntity, TKey, TColumnName> & {
-    keyOf: (entity: TEntity) => TKey;
-    entitySlotStoreService?: undefined;
-}): OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, Map<TKey, TOIMEntitySlot<TEntity, TKey>>, OIMSlotContentEntityService<TEntity, TKey, Map<TKey, TOIMEntitySlot<TEntity, TKey>>, TColumnName>, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, Partial<TEntity>>;
-declare function createOIMEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>, TKey extends TOIMStoreKey | readonly unknown[] = TOIMStoreKey, TStore = Map<TKey, TOIMEntitySlot<TEntity, TKey>>>(db: OIMDB, options: TOIMSlotContentEntityServiceFactoryOptions<TEntity, TKey, TColumnName> & {
-    keyOf: (entity: TEntity) => TKey;
-    entitySlotStoreService: IOIMSlotStoreService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore>;
-}): OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, OIMSlotContentEntityService<TEntity, TKey, TStore, TColumnName>, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, Partial<TEntity>>;
+declare function createOIMSingleSlotService<TSlotContentService extends object, TColumnName extends string = string>(options: {
+    defaults?: OIMDefaults | undefined;
+    slotContentService: TSlotContentService & IOIMSingleSlotCreator<TOIMSlotContentServiceSingleSlot<TSlotContentService>> & IOIMSlotContentWriter<TOIMSlotContentServiceSingleSlot<TSlotContentService>, TOIMSlotContentServiceContent<TSlotContentService>> & IOIMSlotContentService<TOIMSlotContentServiceSingleSlot<TSlotContentService>>;
+    slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
+    slotSubscriptionListener?: IOIMSlotSubscriptionListener | undefined;
+    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
+    columnNames?: readonly TColumnName[] | undefined;
+}): OIMWritableSingleSlotService<TOIMSlotContentServiceSingleSlot<TSlotContentService>, TOIMSlotContentServiceContent<TSlotContentService>, TSlotContentService & IOIMSingleSlotCreator<TOIMSlotContentServiceSingleSlot<TSlotContentService>> & IOIMSlotContentWriter<TOIMSlotContentServiceSingleSlot<TSlotContentService>, TOIMSlotContentServiceContent<TSlotContentService>> & IOIMSlotContentService<TOIMSlotContentServiceSingleSlot<TSlotContentService>>, TColumnName, TOIMColumnSlot, OIMPushColumnSlotOwner>;
 
-declare function createOIMSingleEntityService<TEntity extends object, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>>(db: OIMDB, options?: TOIMSlotContentEntityServiceFactoryOptions<TEntity, void, TColumnName>): OIMSingleSlotService<TOIMEntitySlot<TEntity, void>, OIMSlotContentEntityService<TEntity, void, TOIMSingleSlotStore<TOIMEntitySlot<TEntity, void>>, TColumnName>, TColumnName, TOIMColumnSlot, OIMColumnOwnerPushDriven, Partial<TEntity>>;
+declare function createOIMSlotContentEntityService<TEntity extends object, TKey extends NonNullable<unknown> = TOIMStoreKey, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>>(options?: {
+    defaults?: OIMDefaults | undefined;
+    entityWriter?: IOIMEntityWriter | undefined;
+    slotEmptinessPolicy?: IOIMSlotEmptinessPolicy<TOIMEntityContentSlot<TEntity>> | undefined;
+}): OIMSlotContentEntityService<TEntity, TKey, TColumnName>;
 
 interface IOIMBucketCommands {
-    recordInsert(bucketSlot: TOIMBucketSlot<unknown>, index: number, bucketMemberSlot: TOIMSlot, bucketMemberSlotCount: number): void;
-    recordRemove(bucketSlot: TOIMBucketSlot<unknown>, index: number, count: number, bucketMemberSlotCount: number): void;
-    recordMove(bucketSlot: TOIMBucketSlot<unknown>, from: number, to: number, bucketMemberSlotCount: number): void;
-    recordWholeList(bucketSlot: TOIMBucketSlot<unknown>): void;
+    recordInsert(bucketSlot: TOIMBucketContentSlot<unknown>, index: number, bucketMemberSlot: TOIMSlot, bucketMemberSlotCount: number): void;
+    recordRemove(bucketSlot: TOIMBucketContentSlot<unknown>, index: number, count: number, bucketMemberSlotCount: number): void;
+    recordMove(bucketSlot: TOIMBucketContentSlot<unknown>, from: number, to: number, bucketMemberSlotCount: number): void;
+    recordWholeList(bucketSlot: TOIMBucketContentSlot<unknown>): void;
 }
 
-type TOIMBucketSlotOwnerService<TSlots, TBucketMemberSlot extends TOIMSlot = TOIMSlot, TKey = unknown, TStore = unknown> = OIMSlotOwnerService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>;
-
 type TOIMSlotContentBucketServiceOptions = {
     bucketCommands?: IOIMBucketCommands | undefined;
 };
 
-declare abstract class OIMSlotContentBucketService<TBucketMemberSlot extends TOIMSlot, TSlots> {
+declare abstract class OIMSlotContentBucketService<TBucketMemberSlot extends TOIMSlot, TSlots, TKey extends NonNullable<unknown> = TOIMStoreKey> implements IOIMSlotContentService<TOIMBucketContentSlot<TSlots>>, IOIMKeyedSlotCreator<TKey, TOIMBucketSlot<TSlots, TKey>>, IOIMSingleSlotCreator<TOIMBucketContentSlot<TSlots>>, IOIMSlotContentWriter<TOIMBucketContentSlot<TSlots>, readonly TBucketMemberSlot[]> {
     protected readonly bucketCommands: IOIMBucketCommands;
-    private readonly slotContentStrategy;
     protected constructor(options: TOIMSlotContentBucketServiceOptions);
-    createSlotOwnerService<TKey, TStore>(slotOwnerServiceOptions: Omit<TOIMSlotOwnerServiceOptions<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>, 'slotContentStrategy' | 'slotContentFlushStrategy'>): TOIMBucketSlotOwnerService<TSlots, TBucketMemberSlot, TKey, TStore>;
     protected abstract createBucketMemberSlotsStore(): TSlots;
-    protected abstract addSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    protected abstract removeSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): number;
-    protected abstract removeSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
-    protected abstract reconcileSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    protected abstract drainSlots(bucketSlot: TOIMBucketSlot<TSlots>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    abstract hasBucketMemberSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    abstract getBucketMemberSlotCount(bucketSlot: TOIMBucketSlot<TSlots>): number;
-    abstract getBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>): Iterable<TBucketMemberSlot>;
-    protected createSlot<TKey>(key: TKey, storeSlot: TOIMStoreSlot | undefined, slotOwnerService: TOIMBucketSlotOwnerService<TSlots>): TOIMBucketSlot<TSlots, TKey>;
-    isSlotEmpty(bucketSlot: TOIMBucketSlot<TSlots>): boolean;
-    protected hasReference(bucketSlot: TOIMBucketSlot<TSlots>): boolean;
-    protected releaseSlotContent(bucketSlot: TOIMBucketSlot<TSlots>, slotOwnerService: TOIMBucketSlotOwnerService<TSlots>): void;
-    protected onSubframeClosed(storeSlot: TOIMStoreSlot<unknown, TOIMBucketSlot<TSlots>>, slotOwnerService: TOIMBucketSlotOwnerService<TSlots>): void;
-    markContentChanged(bucketSlot: TOIMBucketSlot<TSlots>): void;
-    markBucketColumnsChanged(bucketSlot: TOIMBucketSlot<TSlots>, patch: object | undefined, changedColumns: readonly string[] | undefined): void;
-    addBucketMemberSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): void;
-    removeBucketMemberSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): void;
-    addBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
-    removeBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
-    writeBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
-    clearBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>): void;
-    fillBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
-    protected markBucketSlotChanged(bucketSlot: TOIMBucketSlot<TSlots>): void;
-    protected letGoOfRemovedBucketMemberSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TOIMSlot, at: number): void;
+    protected abstract addSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    protected abstract removeSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): number;
+    protected abstract removeSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    protected abstract reconcileSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    protected abstract drainSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    abstract hasBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    abstract getBucketMemberSlotCount(bucketSlot: TOIMBucketContentSlot<TSlots>): number;
+    abstract getBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TSlots>): Iterable<TBucketMemberSlot>;
+    getBucketMemberSlotsMissingFrom(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): TBucketMemberSlot[];
+    createSlot(key: TKey, storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMBucketSlot<TSlots, TKey>;
+    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMBucketContentSlot<TSlots>;
+    isSlotEmpty(bucketSlot: TOIMBucketContentSlot<TSlots>): boolean;
+    hasReference(): boolean;
+    releaseSlotContent(bucketSlot: TOIMBucketContentSlot<TSlots>): void;
+    markContentChanged(bucketSlot: TOIMBucketContentSlot<TSlots>): void;
+    markBucketColumnsChanged(bucketSlot: TOIMBucketContentSlot<TSlots>, patch: object | undefined, changedColumns: readonly string[] | undefined): void;
+    addBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): void;
+    removeBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): void;
+    addBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
+    removeBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
+    insertSlotContent(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], changedBucketSlots?: TOIMBucketContentSlot<TSlots>[]): void;
+    writeSlotContent(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
+    clearSlotContent(bucketSlot: TOIMBucketContentSlot<TSlots>): void;
+    fillBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[]): void;
+    protected markBucketSlotChanged(bucketSlot: TOIMBucketContentSlot<TSlots>): void;
+    protected letGoOfRemovedBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TSlots>, bucketMemberSlot: TOIMSlot, at: number): void;
     protected assertBucketMemberSlotNotReleased(bucketMemberSlot: TOIMSlot): void;
     private assertBucketMemberSlotsNotReleased;
-    private addBucketMemberSlotWithoutSubframe;
+    private addBucketMemberSlotUnannounced;
     private reconcileBucketMemberSlots;
     private drainBucketMemberSlots;
     private unholdAllBucketMemberSlots;
-    private writeChangedBucketSlot;
-    private flushChangedBucketSlot;
 }
 
 type TOIMBucketSlotsSetStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = Set<TBucketMemberSlot>;
 
-declare class OIMSlotContentBucketServiceSetDriven<TBucketMemberSlot extends TOIMSlot = TOIMSlot> extends OIMSlotContentBucketService<TBucketMemberSlot, TOIMBucketSlotsSetStore<TBucketMemberSlot>> {
+declare class OIMSlotContentSetBucketService<TBucketMemberSlot extends TOIMSlot = TOIMSlot, TKey extends NonNullable<unknown> = TOIMStoreKey> extends OIMSlotContentBucketService<TBucketMemberSlot, TOIMBucketSlotsSetStore<TBucketMemberSlot>, TKey> {
     constructor(options?: TOIMSlotContentBucketServiceOptions);
     protected createBucketMemberSlotsStore(): TOIMBucketSlotsSetStore<TBucketMemberSlot>;
-    protected addSlot(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    protected removeSlot(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
-    protected removeSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
-    protected reconcileSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    protected drainSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    hasBucketMemberSlot(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    getBucketMemberSlotCount(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>): number;
-    getBucketMemberSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>): Iterable<TBucketMemberSlot>;
+    protected addSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    protected removeSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
+    protected removeSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    protected reconcileSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    protected drainSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    hasBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    getBucketMemberSlotCount(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>): number;
+    getBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsSetStore<TBucketMemberSlot>>): Iterable<TBucketMemberSlot>;
 }
 
 type TOIMBucketSlotsArrayStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = {
     bucketMemberSlots: TBucketMemberSlot[];
+    uniqueBucketMemberSlots: Set<TBucketMemberSlot> | undefined;
+    sortedCount: number;
 };
 
-interface IOIMBucketArrayMembership<TBucketMemberSlot extends TOIMSlot = TOIMSlot, TSlots extends TOIMBucketSlotsArrayStore<TBucketMemberSlot> = TOIMBucketSlotsArrayStore<TBucketMemberSlot>> {
-    createStore(): TSlots;
-    addSlot(bucketSlotsArrayStore: TSlots, bucketMemberSlot: TBucketMemberSlot): boolean;
-    removeSlot(bucketSlotsArrayStore: TSlots, bucketMemberSlot: TBucketMemberSlot): boolean;
-    hasSlot(bucketSlotsArrayStore: TSlots, bucketMemberSlot: TBucketMemberSlot): boolean;
-    clearSlots(bucketSlotsArrayStore: TSlots): void;
-    containsTheSameSequence(bucketSlotsArrayStore: TSlots, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
-}
-
-declare abstract class OIMSlotContentBucketServiceArrayBased<TBucketMemberSlot extends TOIMSlot, TSlots extends TOIMBucketSlotsArrayStore<TBucketMemberSlot>> extends OIMSlotContentBucketService<TBucketMemberSlot, TSlots> {
-    protected readonly bucketArrayMembership: Omit<IOIMBucketArrayMembership<TBucketMemberSlot, TSlots>, 'createStore'>;
-    protected constructor(options: TOIMSlotContentBucketServiceOptions, bucketArrayMembership: Omit<IOIMBucketArrayMembership<TBucketMemberSlot, TSlots>, 'createStore'>);
-    protected addSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    protected removeSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): number;
-    protected removeSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
-    protected reconcileSlots(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    protected drainSlots(bucketSlot: TOIMBucketSlot<TSlots>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    hasBucketMemberSlot(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    getBucketMemberSlotCount(bucketSlot: TOIMBucketSlot<TSlots>): number;
-    getBucketMemberSlots(bucketSlot: TOIMBucketSlot<TSlots>): Iterable<TBucketMemberSlot>;
-    getBucketMemberSlotAt(bucketSlot: TOIMBucketSlot<TSlots>, at: number): TBucketMemberSlot | undefined;
-    getBucketMemberSlotPosition(bucketSlot: TOIMBucketSlot<TSlots>, bucketMemberSlot: TBucketMemberSlot): number;
-    private emptyBucketMemberSlotsStore;
-}
-
-declare class OIMSlotContentBucketServiceArrayDriven<TBucketMemberSlot extends TOIMSlot = TOIMSlot, TSlots extends TOIMBucketSlotsArrayStore<TBucketMemberSlot> = TOIMBucketSlotsArrayStore<TBucketMemberSlot>> extends OIMSlotContentBucketServiceArrayBased<TBucketMemberSlot, TSlots> {
-    protected readonly bucketArrayMembership: IOIMBucketArrayMembership<TBucketMemberSlot, TSlots>;
-    constructor(options?: TOIMSlotContentBucketServiceOptions & {
-        bucketArrayMembership?: IOIMBucketArrayMembership<TBucketMemberSlot, TSlots> | undefined;
-    });
-    protected createBucketMemberSlotsStore(): TSlots;
-    insertBucketMemberSlotAt(bucketSlot: TOIMBucketSlot<TSlots>, at: number, bucketMemberSlot: TBucketMemberSlot): void;
-    removeBucketMemberSlotAt(bucketSlot: TOIMBucketSlot<TSlots>, at: number): TBucketMemberSlot | undefined;
-    removeBucketMemberSlotRange(bucketSlot: TOIMBucketSlot<TSlots>, at: number, count: number): readonly TBucketMemberSlot[];
-    moveBucketMemberSlotToPosition(bucketSlot: TOIMBucketSlot<TSlots>, from: number, to: number): TBucketMemberSlot | undefined;
-    moveBucketMemberSlotRangeToPosition(bucketSlot: TOIMBucketSlot<TSlots>, from: number, count: number, to: number): void;
-}
-
-type TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = TOIMBucketSlotsArrayStore<TBucketMemberSlot> & {
-    sortedCount: number;
+interface IOIMBucketMemberSlotsArrayService<TBucketMemberSlot extends TOIMSlot = TOIMSlot> {
+    createBucketSlotsArrayStore(): TOIMBucketSlotsArrayStore<TBucketMemberSlot>;
+    hasBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    appendBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    insertBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number): TBucketMemberSlot;
+    removeBucketMemberSlotRange(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, count: number): TBucketMemberSlot[];
+    removeBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    moveBucketMemberSlotRange(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, from: number, count: number, landing: number): boolean;
+    sortBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, compareBucketMemberSlots: (left: TBucketMemberSlot, right: TBucketMemberSlot) => number): void;
+    isSameBucketMemberSlotSequence(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
+    clearBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>): void;
+}
+
+type TOIMSlotContentArrayBucketServiceOptions<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = TOIMSlotContentBucketServiceOptions & {
+    bucketMemberSlotsArrayService?: IOIMBucketMemberSlotsArrayService<TBucketMemberSlot> | undefined;
 };
 
-type TOIMSlotContentBucketServiceSortedArrayDrivenOptions<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = {
+declare abstract class OIMSlotContentArrayBucketService<TBucketMemberSlot extends TOIMSlot, TKey extends NonNullable<unknown> = TOIMStoreKey> extends OIMSlotContentBucketService<TBucketMemberSlot, TOIMBucketSlotsArrayStore<TBucketMemberSlot>, TKey> {
+    protected readonly bucketMemberSlotsArrayService: IOIMBucketMemberSlotsArrayService<TBucketMemberSlot>;
+    protected constructor(options: TOIMSlotContentArrayBucketServiceOptions<TBucketMemberSlot>);
+    protected createBucketMemberSlotsStore(): TOIMBucketSlotsArrayStore<TBucketMemberSlot>;
+    protected addSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    protected removeSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
+    protected removeSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    protected reconcileSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    protected drainSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    hasBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    getBucketMemberSlotCount(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>): number;
+    getBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>): Iterable<TBucketMemberSlot>;
+    getBucketMemberSlotAt(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, at: number): TBucketMemberSlot | undefined;
+    getBucketMemberSlotPosition(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
+}
+
+declare class OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot extends TOIMSlot = TOIMSlot, TKey extends NonNullable<unknown> = TOIMStoreKey> extends OIMSlotContentArrayBucketService<TBucketMemberSlot, TKey> {
+    constructor(options?: TOIMSlotContentArrayBucketServiceOptions<TBucketMemberSlot>);
+    insertBucketMemberSlotAt(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, at: number, bucketMemberSlot: TBucketMemberSlot): void;
+    removeBucketMemberSlotAt(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, at: number): TBucketMemberSlot | undefined;
+    removeBucketMemberSlotRange(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, at: number, count: number): readonly TBucketMemberSlot[];
+    moveBucketMemberSlotToPosition(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, from: number, to: number): TBucketMemberSlot | undefined;
+    moveBucketMemberSlotRangeToPosition(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, from: number, count: number, to: number): void;
+}
+
+declare class OIMBucketMemberSlotsArrayService<TBucketMemberSlot extends TOIMSlot = TOIMSlot> implements IOIMBucketMemberSlotsArrayService<TBucketMemberSlot> {
+    static readonly INSTANCE: OIMBucketMemberSlotsArrayService<TOIMSlot>;
+    createBucketSlotsArrayStore(): TOIMBucketSlotsArrayStore<TBucketMemberSlot>;
+    hasBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    appendBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    insertBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number): TBucketMemberSlot;
+    removeBucketMemberSlotRange(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, count: number): TBucketMemberSlot[];
+    removeBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    moveBucketMemberSlotRange(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, from: number, count: number, landing: number): boolean;
+    sortBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, compareBucketMemberSlots: (left: TBucketMemberSlot, right: TBucketMemberSlot) => number): void;
+    isSameBucketMemberSlotSequence(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
+    clearBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>): void;
+}
+
+declare class OIMBucketUniqueMemberSlotsArrayService<TBucketMemberSlot extends TOIMSlot = TOIMSlot> extends OIMBucketMemberSlotsArrayService<TBucketMemberSlot> {
+    static readonly INSTANCE: OIMBucketUniqueMemberSlotsArrayService<TOIMSlot>;
+    createBucketSlotsArrayStore(): TOIMBucketSlotsArrayStore<TBucketMemberSlot>;
+    hasBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    appendBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
+    insertBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): number;
+    removeBucketMemberSlotAt(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number): TBucketMemberSlot;
+    removeBucketMemberSlotRange(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, at: number, count: number): TBucketMemberSlot[];
+    removeBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
+    isSameBucketMemberSlotSequence(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
+    clearBucketMemberSlots(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>): void;
+}
+
+type TOIMSlotContentSortedArrayBucketServiceOptions<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = TOIMSlotContentArrayBucketServiceOptions<TBucketMemberSlot> & {
     compareBucketMemberSlots: (left: TBucketMemberSlot, right: TBucketMemberSlot) => number;
 };
 
-declare class OIMSlotContentBucketServiceSortedArrayDriven<TBucketMemberSlot extends TOIMSlot = TOIMSlot> extends OIMSlotContentBucketServiceArrayBased<TBucketMemberSlot, TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>> {
+declare class OIMSlotContentSortedArrayBucketService<TBucketMemberSlot extends TOIMSlot = TOIMSlot, TKey extends NonNullable<unknown> = TOIMStoreKey> extends OIMSlotContentArrayBucketService<TBucketMemberSlot, TKey> {
     private readonly compareBucketMemberSlots;
-    constructor(options: TOIMSlotContentBucketServiceSortedArrayDrivenOptions<TBucketMemberSlot>);
-    protected createBucketMemberSlotsStore(): TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>;
-    protected removeSlot(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
-    protected removeSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], removedChannelQueue: OIMChannelQueue<TOIMSlot>, removedAtChannelQueue: OIMChannelQueue<number>): void;
-    protected reconcileSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, bucketMemberSlots: readonly TBucketMemberSlot[], arrivedChannelQueue: OIMChannelQueue<TOIMSlot>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    protected drainSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
-    getBucketMemberSlots(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>): Iterable<TBucketMemberSlot>;
-    getBucketMemberSlotAt(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, at: number): TBucketMemberSlot | undefined;
-    getBucketMemberSlotPosition(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
-    repositionBucketMemberSlot(bucketSlot: TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): void;
-    private settle;
-}
-
-type TOIMBucketCollectionFactoryArguments<TKey, TBucketSlot, TStore, TOptions extends {
-    bucketSlotStoreService?: unknown;
-}> = [
-    TKey
-] extends [readonly unknown[]] ? [bucketCollectionFactoryOptions: TOptions & Required<Pick<TOptions, 'bucketSlotStoreService'>>] : [TStore] extends [Map<TKey, TBucketSlot>] ? [bucketCollectionFactoryOptions?: TOptions] : [bucketCollectionFactoryOptions: TOptions & Required<Pick<TOptions, 'bucketSlotStoreService'>>];
-
-declare function createOIMBucketService<TBucketMemberSlot extends TOIMSlot = TOIMEntitySlot, TKey extends TOIMStoreKey | readonly unknown[] = TOIMStoreKey, TSlots = TOIMBucketSlotsArrayStore<TBucketMemberSlot>, TSlotContentService extends OIMSlotContentBucketService<TBucketMemberSlot, TSlots> = OIMSlotContentBucketServiceArrayDriven<TBucketMemberSlot> & OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, TStore = Map<TKey, TOIMBucketSlot<TSlots, TKey>>>(db: OIMDB, ...[options]: TOIMBucketCollectionFactoryArguments<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, {
-    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TBucketMemberSlot, TSlots>) | undefined;
-    bucketSlotStoreService?: IOIMSlotStoreService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore> | undefined;
-    maxCommandsPerSlot?: number | undefined;
-    slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
-    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
-    columnNames?: readonly string[] | undefined;
-}>): OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, TSlotContentService, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>;
+    constructor(options: TOIMSlotContentSortedArrayBucketServiceOptions<TBucketMemberSlot>);
+    protected drainSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, departedChannelQueue: OIMChannelQueue<TOIMSlot>): void;
+    getBucketMemberSlots(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>): Iterable<TBucketMemberSlot>;
+    getBucketMemberSlotAt(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, at: number): TBucketMemberSlot | undefined;
+    getBucketMemberSlotPosition(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): number;
+    repositionBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): void;
+}
 
-declare function createOIMSingleBucketService<TBucketMemberSlot extends TOIMSlot = TOIMEntitySlot, TSlots = TOIMBucketSlotsArrayStore<TBucketMemberSlot>, TSlotContentService extends OIMSlotContentBucketService<TBucketMemberSlot, TSlots> = OIMSlotContentBucketServiceArrayDriven<TBucketMemberSlot> & OIMSlotContentBucketService<TBucketMemberSlot, TSlots>>(db: OIMDB, options?: {
-    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TBucketMemberSlot, TSlots>) | undefined;
-    maxCommandsPerSlot?: number | undefined;
-    slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
-    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
-    columnNames?: readonly string[] | undefined;
-}): OIMSingleSlotService<TOIMBucketSlot<TSlots, void>, TSlotContentService, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>;
+type TOIMBucketSlotOwnerService<TSlots, TBucketMemberSlot extends TOIMSlot = TOIMSlot, TBucketSlot extends TOIMBucketContentSlot<TSlots> = TOIMBucketContentSlot<TSlots>, TStore = unknown> = OIMSlotOwnerService<TBucketSlot, TStore, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TBucketMemberSlot[]>;
 
-declare class OIMDefaults {
-    static readonly COLUMN_SLOT_STORE_SERVICE: OIMDefaultValue<IOIMSlotStoreService<string, TOIMColumnSlot, unknown>>;
-    static readonly COMPUTED_COLUMN_SLOT_STORE_SERVICE: OIMDefaultValue<IOIMSlotStoreService<string, TOIMComputedColumnSlot, unknown>>;
-    static readonly KEY_TREE_WALK_SCALAR: OIMDefaultValue<OIMKeyTreeWalkScalar>;
-    static readonly KEY_TREE_WALK_COMPOSITE: OIMDefaultValue<OIMKeyTreeWalkComposite>;
-    static readonly STANDALONE_SLOT_OWNER: OIMDefaultValue<OIMSlotOwner>;
-    static readonly ENTITY_WRITER: OIMDefaultValue<IOIMEntityWriter>;
-    static readonly ENTITY_SLOT_EMPTINESS: OIMDefaultValue<IOIMSlotEmptiness<TOIMEntitySlot>>;
-    static readonly INDEX_KEYS_SERVICE: OIMDefaultValue<IOIMIndexKeysService>;
-    static readonly STORE_SLOT_LISTENER: OIMDefaultValue<IOIMStoreSlotListener>;
+type TOIMDBOptions = {
+    channelScheduler?: TOIMChannelScheduler | undefined;
+    errorPolicy?: IOIMErrorPolicy | undefined;
+    onBeforeFlush?: (() => void) | undefined;
+    getNowMs?: (() => number) | undefined;
+    releaseTimer?: TOIMTimer | undefined;
+};
+
+declare class OIMDB implements IOIMChannelMap {
+    readonly clock: TOIMChannelClock;
+    readonly collectorSlot: TOIMCollectorSlot;
+    readonly defaultChannelSlot: TOIMChannelSlot;
+    constructor(options?: TOIMDBOptions);
+    flush(): void;
 }
 
 declare class OIMDefaultValue<TValue> {
-    private readonly name;
     private readonly createValue;
     private defaultValue;
-    private isHandedOut;
-    constructor(name: string, createValue: () => TValue);
+    constructor(createValue: () => TValue);
     getValue(): TValue;
-    setValue(value: TValue): void;
-    private assertNoLateOverride;
 }
 
-type TOIMComputedStoreSlot<TStore = unknown, TValue = unknown, TKey = unknown> = TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>> & {
-    readonly derive: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined;
-    readonly createSources: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined;
+declare class OIMFlushSchedulerService {
+    static readonly INSTANCE: OIMFlushSchedulerService;
+    isScheduled(flushSchedulerSlot: TOIMFlushSchedulerSlot): boolean;
+    schedule<TFlushSchedulerSlot extends TOIMFlushSchedulerSlot>(flushSchedulerSlot: TFlushSchedulerSlot, delayMs: number, flushSchedulerListener: IOIMFlushSchedulerListener<TFlushSchedulerSlot>): void;
+    cancelSchedule(flushSchedulerSlot: TOIMFlushSchedulerSlot): void;
+}
+
+type TOIMComputedStoreSlot<TStore = unknown, TValue = unknown, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined> = TOIMComputedContentSlot<TValue>> = TOIMStoreSlot<TStore, TComputedSlot> & {
+    readonly derive: ((computedSlot: TComputedSlot) => TValue) | undefined;
+    readonly createSources: ((computedSlot: TComputedSlot) => Partial<TOIMComputedSources>) | undefined;
 };
 
-type TOIMComputedServiceOptions<TKey, TValue, TComputedStore> = {
-    computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore>;
-    columnOwnerOptions: TOIMColumnOwnerOptions<TOIMComputedColumnSlot, Extract<keyof TValue, string>>;
+type TOIMComputedDerivationOptions<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue>> = {
+    columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TOIMComputedColumnSlot, Extract<keyof TValue, string>>;
     slotReleasePolicy: IOIMSlotReleasePolicy;
     storeSlotListener: IOIMStoreSlotListener;
-    createSources?: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined;
-    derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined;
+    createSources?: ((computedSlot: TComputedSlot) => Partial<TOIMComputedSources>) | undefined;
+    derive?: ((computedSlot: TComputedSlot) => TValue) | undefined;
     sameValueGuard?: TOIMSameValueGuard<TValue> | undefined;
+    releaseValue?: TOIMComputedValueReleaser<TValue> | undefined;
     initialValue?: TValue | undefined;
 };
 
-declare class OIMComputedService<TKey, TValue, TComputedStore> {
-    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore, OIMComputedValueService<TKey, TValue>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMColumnOwnerPullDriven>;
+type TOIMComputedServiceOptions<TKey extends NonNullable<unknown>, TValue, TComputedStore> = TOIMComputedDerivationOptions<TValue, TOIMComputedSlot<TValue, TKey>> & {
+    computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore>;
+};
+
+declare class OIMComputedService<TKey extends NonNullable<unknown>, TValue, TComputedStore> {
+    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore, OIMSlotContentComputedService<TValue, TOIMComputedSlot<TValue, TKey>>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
     private readonly hasDerive;
     private readonly hasCreateSources;
     constructor(options: TOIMComputedServiceOptions<TKey, TValue, TComputedStore>);
-    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources?: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TComputedStore, TValue, TKey>;
-    private assertDeriveAndCreateSources;
+    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TComputedStore, TValue, TOIMComputedSlot<TValue, TKey>>;
 }
 
-type TOIMDefaultSlotStore<TKey, TSlot> = [TKey] extends [void] ? TOIMSingleSlotStore<TSlot> : Map<TKey, TSlot>;
-
-declare function createOIMComputedService<TKey, TValue, TComputedStore = TOIMDefaultSlotStore<TKey, TOIMComputedSlot<TValue, TKey>>>(options: {
-    createSources?: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined;
-    derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined;
+type TOIMComputedServiceFactoryOptions<TValue> = {
+    defaults?: OIMDefaults | undefined;
     sameValueGuard?: TOIMSameValueGuard<TValue> | undefined;
+    releaseValue?: TOIMComputedValueReleaser<TValue> | undefined;
     initialValue?: TValue | undefined;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
     columnNames?: readonly Extract<keyof TValue, string>[] | undefined;
-} & ([TComputedStore] extends [Map<TKey, TOIMComputedSlot<TValue, TKey>>] ? {
+};
+
+declare function createOIMComputedService<TKey extends NonNullable<unknown>, TValue, TComputedStore = Map<TKey, TOIMComputedSlot<TValue, TKey>>>(options: TOIMComputedServiceFactoryOptions<TValue> & {
+    createSources?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined;
+    derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined;
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore> | undefined;
-} : {
-    computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore>;
-})): OIMComputedService<TKey, TValue, TComputedStore>;
+}): OIMComputedService<TKey, TValue, TComputedStore>;
+
+declare class OIMSingleComputedService<TValue> {
+    readonly computedSingleSlotService: OIMSingleSlotService<TOIMComputedContentSlot<TValue>, OIMSlotContentComputedService<TValue>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
+    private readonly hasDerive;
+    private readonly hasCreateSources;
+    constructor(options: TOIMComputedDerivationOptions<TValue, TOIMComputedContentSlot<TValue>>);
+    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources?: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TOIMSingleSlotStore<TOIMComputedContentSlot<TValue>>, TValue>;
+}
+
+declare function createOIMSingleComputedService<TValue>(options?: TOIMComputedServiceFactoryOptions<TValue> & {
+    createSources?: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined;
+    derive?: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined;
+}): OIMSingleComputedService<TValue>;
+
+type TOIMSourceTrackingComputedSlot<TValue = unknown, TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMComputedSlot<TValue, TKey, OIMSourceTracker>;
 
-type TOIMSortedComputedSlot<TEntity extends object, TKey> = TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>;
+type TOIMSourceTrackingComputedDerive<TValue, TComputedSlot> = (computedSlot: TComputedSlot, sourceTracker: OIMSourceTracker) => TValue;
+
+type TOIMSourceTrackingComputedDerivationOptions<TValue, TComputedSlot> = {
+    columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TOIMComputedColumnSlot, Extract<keyof TValue, string>>;
+    slotReleasePolicy: IOIMSlotReleasePolicy;
+    storeSlotListener: IOIMStoreSlotListener;
+    derive: TOIMSourceTrackingComputedDerive<TValue, TComputedSlot>;
+    sameValueGuard?: TOIMSameValueGuard<TValue> | undefined;
+    releaseValue?: TOIMComputedValueReleaser<TValue> | undefined;
+    initialValue?: TValue | undefined;
+};
+
+type TOIMSourceTrackingComputedContentSlot<TValue = unknown> = TOIMComputedContentSlot<TValue, OIMSourceTracker>;
+
+declare class OIMSlotContentSourceTrackingComputedService<TValue, TComputedSlot extends TOIMSourceTrackingComputedContentSlot<TValue> = TOIMSourceTrackingComputedContentSlot<TValue>> extends OIMSlotContentComputedService<TValue, TComputedSlot> {
+    protected createSourceTracker(): OIMSourceTracker;
+    protected attachSources(): void;
+}
+
+declare class OIMSourceTrackingComputedService<TKey extends NonNullable<unknown>, TValue, TComputedStore> {
+    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMSourceTrackingComputedSlot<TValue, TKey>, TComputedStore, OIMSlotContentSourceTrackingComputedService<TValue, TOIMSourceTrackingComputedSlot<TValue, TKey>>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
+    constructor(options: TOIMSourceTrackingComputedDerivationOptions<TValue, TOIMSourceTrackingComputedSlot<TValue, TKey>> & {
+        computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMSourceTrackingComputedSlot<TValue, TKey>, TComputedStore>;
+    });
+    createComputedStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TComputedStore, TOIMSourceTrackingComputedSlot<TValue, TKey>>;
+}
 
-type TOIMIndexStoreSlot<TStore = unknown, TBucketSlot extends TOIMSlot = TOIMSlot, TBucketPatch = unknown, TSourceSlot extends TOIMSlot = TOIMSlot, TSourcePatch = unknown, TKey = unknown, TSourceStore = unknown> = TOIMStoreSlot<TStore, TBucketSlot, TBucketPatch> & {
+declare class OIMSingleSourceTrackingComputedService<TValue> {
+    readonly computedSingleSlotService: OIMSingleSlotService<TOIMSourceTrackingComputedContentSlot<TValue>, OIMSlotContentSourceTrackingComputedService<TValue>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
+    constructor(options: TOIMSourceTrackingComputedDerivationOptions<TValue, TOIMSourceTrackingComputedContentSlot<TValue>>);
+    createComputedStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TOIMSourceTrackingComputedContentSlot<TValue>>, TOIMSourceTrackingComputedContentSlot<TValue>>;
+}
+
+declare function createOIMSourceTrackingComputedService<TKey extends NonNullable<unknown>, TValue, TComputedStore = Map<TKey, TOIMSourceTrackingComputedSlot<TValue, TKey>>>(options: TOIMComputedServiceFactoryOptions<TValue> & {
+    derive: TOIMSourceTrackingComputedDerive<TValue, TOIMSourceTrackingComputedSlot<TValue, TKey>>;
+    computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMSourceTrackingComputedSlot<TValue, TKey>, TComputedStore> | undefined;
+}): OIMSourceTrackingComputedService<TKey, TValue, TComputedStore>;
+
+declare function createOIMSingleSourceTrackingComputedService<TValue>(options: TOIMComputedServiceFactoryOptions<TValue> & {
+    derive: TOIMSourceTrackingComputedDerive<TValue, TOIMSourceTrackingComputedContentSlot<TValue>>;
+}): OIMSingleSourceTrackingComputedService<TValue>;
+
+type TOIMSortedComputedSlot<TEntity extends object, TKey extends NonNullable<unknown>> = TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>;
+
+type TOIMIndexStoreSlot<TStore = unknown, TBucketSlot extends TOIMSlot = TOIMSlot, TBucketPatch = unknown, TSourceSlot extends TOIMSlot = TOIMSlot, TSourcePatch = unknown, TKey = unknown, TSourceStore = unknown, TSlotService = unknown> = TOIMStoreSlot<TStore, TBucketSlot, TBucketPatch, TSlotService> & {
     readonly sourceStoreSlot: TOIMStoreSlot<TSourceStore, TSourceSlot, TSourcePatch>;
     readonly indexKeysPosition: number;
-    readonly contentChangeListener: IOIMContentChangeListener<TSourceSlot, TSourcePatch>;
+    readonly contentChangeListener: IOIMSlotContentChangeListener<TSourceSlot, TSourcePatch>;
     readonly requestedKeys: readonly TKey[] | undefined;
     readonly bucketColumnNames: Set<string>;
     readonly isAnyBucketColumnRead: boolean;
     readonly isDisposed: boolean;
 };
 
-type TOIMIndexServiceOptions<TKey, TEntity extends object, TBucketSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TSourceKey, TSourceStore> = TOIMSlotCollectionServiceOptions<TKey, TBucketSlot, TStore, TSlotContentService, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TOIMEntitySlot<TEntity>[]> & {
+type TOIMSlotCollectionIndexServiceOptions<TKey extends NonNullable<unknown>, TEntity extends object, TBucketSlot extends TOIMKeyedSlot<TKey>, TStore, TSlotContentService, TSourceKey extends NonNullable<unknown>, TSourceStore> = TOIMSlotCollectionServiceOptions<TKey, TBucketSlot, TStore, TSlotContentService, string, TOIMColumnSlot, OIMPushColumnSlotOwner> & {
     keyOf: (entity: TEntity) => TKey;
     columns?: readonly string[] | undefined;
     sourceSlotCollectionService: Pick<OIMSlotCollectionService<TSourceKey, TOIMEntitySlot<TEntity, TSourceKey>, TSourceStore, unknown>, 'getSlots'>;
     indexKeysService: IOIMIndexKeysService;
 };
 
-declare class OIMIndexService<TKey, TEntity extends object, TSlots, TSourceKey = unknown, TSourceStore = unknown, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots> = OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, TBucketSlot extends TOIMBucketSlot<TSlots, TKey> = TOIMBucketSlot<TSlots, TKey>, TStore = Map<TKey, TBucketSlot>> extends OIMSlotCollectionService<TKey, TBucketSlot, TStore, Pick<TSlotContentService, Extract<keyof TSlotContentService, 'getBucketMemberSlots' | 'getBucketMemberSlotCount' | 'hasBucketMemberSlot' | 'getBucketMemberSlotAt' | 'getBucketMemberSlotPosition'>>, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TOIMEntitySlot<TEntity>[]> {
+declare class OIMSlotCollectionIndexService<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown> = NonNullable<unknown>, TSourceStore = unknown, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey> = OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>, TBucketSlot extends TOIMBucketSlot<TSlots, TKey> = TOIMBucketSlot<TSlots, TKey>, TStore = Map<TKey, TBucketSlot>> extends OIMSlotCollectionService<TKey, TBucketSlot, TStore, Pick<TSlotContentService, Extract<keyof TSlotContentService, 'getBucketMemberSlots' | 'getBucketMemberSlotCount' | 'hasBucketMemberSlot' | 'getBucketMemberSlotAt' | 'getBucketMemberSlotPosition'>>, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TOIMEntitySlot<TEntity>[]> {
     protected readonly slotContentBucketService: TSlotContentService;
     private readonly keyOf;
     private readonly keyColumns;
     private readonly sourceSlotCollectionService;
     private readonly indexKeysService;
-    constructor(options: TOIMIndexServiceOptions<TKey, TEntity, TBucketSlot, TStore, TSlotContentService, TSourceKey, TSourceStore>);
-    createIndexStoreSlot(sourceStoreSlot: TOIMStoreSlot<TSourceStore, TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>>): TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore>;
+    constructor(options: TOIMSlotCollectionIndexServiceOptions<TKey, TEntity, TBucketSlot, TStore, TSlotContentService, TSourceKey, TSourceStore>);
+    createIndexStoreSlot(sourceStoreSlot: TOIMStoreSlot<TSourceStore, TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>>): TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore, this>;
     disposeIndexStoreSlot(indexStoreSlot: TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore>): void;
     getSlotByKey(storeSlot: TOIMStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[]>, key: TKey): TBucketSlot;
     holdSlotByKey(storeSlot: TOIMStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[]>, key: TKey): TBucketSlot;
@@ -1075,22 +1253,22 @@ declare class OIMIndexService<TKey, TEntity extends object, TSlots, TSourceKey =
     private groupUnderMintedBucketKey;
     private decideIndexKeyForSlot;
     private collectSourceSlotsForKey;
-    private setIndexKeyForSlots;
+    private fillBucketSlotWithSourceSlots;
 }
 
-type TOIMIndexServiceStoreSlot<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore> = Parameters<OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>['getBucketColumnByKey']>[0];
+type TOIMSlotCollectionIndexServiceStoreSlot<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore> = Parameters<OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>['getBucketColumnByKey']>[0];
 
 type TOIMSortableColumnName<TEntity extends object> = {
     [TColumn in keyof TEntity]-?: NonNullable<TEntity[TColumn]> extends string | number | bigint ? TColumn : never;
 }[keyof TEntity] & string;
 
 type TOIMSortColumn<TEntity extends object> = {
-    column: TOIMSortableColumnName<TEntity>;
+    columnName: TOIMSortableColumnName<TEntity>;
     direction: 'asc' | 'desc';
 };
 
-type TOIMComputedServiceSortedOptions<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore, TComputedStore> = {
-    indexService: OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
+type TOIMSortedComputedServiceOptions<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore, TComputedStore> = {
+    indexService: OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
     computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>, TComputedStore>;
     columnSlotStoreService: IOIMSlotStoreService<string, TOIMComputedColumnSlot>;
     sortColumns?: readonly TOIMSortColumn<TEntity>[] | undefined;
@@ -1099,49 +1277,47 @@ type TOIMComputedServiceSortedOptions<TKey, TEntity extends object, TSlots, TSou
     storeSlotListener: IOIMStoreSlotListener;
 };
 
-declare class OIMComputedServiceSorted<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore, TComputedStore> {
-    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMSortedComputedSlot<TEntity, TKey>, TComputedStore, OIMComputedValueService<TKey, readonly TOIMEntitySlot<TEntity>[]>, string, TOIMComputedColumnSlot, OIMColumnOwnerPullDriven>;
-    constructor(options: TOIMComputedServiceSortedOptions<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>);
-    createSortedStoreSlot(indexStoreSlot: TOIMIndexServiceStoreSlot<TKey, TEntity, TSlots, TSourceKey, TSourceStore>): TOIMStoreSlot<TComputedStore, TOIMSortedComputedSlot<TEntity, TKey>>;
+declare class OIMSortedComputedService<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore, TComputedStore> {
+    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMSortedComputedSlot<TEntity, TKey>, TComputedStore, OIMSlotContentComputedService<readonly TOIMEntitySlot<TEntity>[], TOIMSortedComputedSlot<TEntity, TKey>>, string, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
+    constructor(options: TOIMSortedComputedServiceOptions<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>);
+    createSortedStoreSlot(indexStoreSlot: TOIMSlotCollectionIndexServiceStoreSlot<TKey, TEntity, TSlots, TSourceKey, TSourceStore>): TOIMStoreSlot<TComputedStore, TOIMSortedComputedSlot<TEntity, TKey>>;
 }
 
-declare function createOIMComputedServiceSorted<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore, TComputedStore = TOIMDefaultSlotStore<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>>>(options: {
-    indexService: OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
+type TOIMDefaultSlotStore<TKey, TSlot> = Map<TKey, TSlot>;
+
+declare function createOIMSortedComputedService<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore, TComputedStore = TOIMDefaultSlotStore<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>>>(options: {
+    defaults?: OIMDefaults | undefined;
+    indexService: OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
     sortColumns?: readonly TOIMSortColumn<TEntity>[] | undefined;
     comparator?: ((left: TEntity, right: TEntity) => number) | undefined;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
-} & ([TComputedStore] extends [Map<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>>] ? {
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>, TComputedStore> | undefined;
-} : {
-    computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TOIMEntitySlot<TEntity>[], TKey>, TComputedStore>;
-})): OIMComputedServiceSorted<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>;
+}): OIMSortedComputedService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>;
 
-type TOIMComputedServiceBucketMemoOptions<TKey, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore> = {
-    bucketCollectionService: OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TBucketStore, OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>;
+type TOIMBucketMemoComputedServiceOptions<TKey extends NonNullable<unknown>, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore> = {
+    bucketCollectionService: OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TBucketStore, OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TBucketMemberSlot[]>;
     computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>, TComputedStore>;
     columnSlotStoreService: IOIMSlotStoreService<string, TOIMComputedColumnSlot>;
     slotReleasePolicy: IOIMSlotReleasePolicy;
     storeSlotListener: IOIMStoreSlotListener;
 };
 
-type TOIMBucketMemoComputedSlot<TBucketMemberSlot extends TOIMSlot, TKey> = TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>;
+type TOIMBucketMemoComputedSlot<TBucketMemberSlot extends TOIMSlot, TKey extends NonNullable<unknown>> = TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>;
 
-declare class OIMComputedServiceBucketMemo<TKey, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore> {
-    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>, TComputedStore, OIMComputedValueService<TKey, readonly TBucketMemberSlot[]>, string, TOIMComputedColumnSlot, OIMColumnOwnerPullDriven>;
-    constructor(options: TOIMComputedServiceBucketMemoOptions<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>);
+declare class OIMBucketMemoComputedService<TKey extends NonNullable<unknown>, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore> {
+    readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>, TComputedStore, OIMSlotContentComputedService<readonly TBucketMemberSlot[], TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>>, string, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
+    constructor(options: TOIMBucketMemoComputedServiceOptions<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>);
     createBucketMemoStoreSlot(bucketStoreSlot: TOIMStoreSlot<TBucketStore, TOIMBucketSlot<TSlots, TKey>, readonly TBucketMemberSlot[]>): TOIMStoreSlot<TComputedStore, TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>>;
 }
 
-declare function createOIMComputedServiceBucketMemo<TKey, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore = TOIMDefaultSlotStore<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>>>(options: {
-    bucketCollectionService: OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TBucketStore, OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, string, TOIMColumnSlot, OIMColumnOwnerPushDriven, readonly TBucketMemberSlot[]>;
+declare function createOIMBucketMemoComputedService<TKey extends NonNullable<unknown>, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore = TOIMDefaultSlotStore<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>>>(options: {
+    defaults?: OIMDefaults | undefined;
+    bucketCollectionService: OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TBucketStore, OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TBucketMemberSlot[]>;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
-} & ([TComputedStore] extends [Map<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>>] ? {
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>, TComputedStore> | undefined;
-} : {
-    computedSlotStoreService: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>, TComputedStore>;
-})): OIMComputedServiceBucketMemo<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>;
+}): OIMBucketMemoComputedService<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>;
 
 type TOIMBucketCommandsOptions = {
     maxCommandsPerSlot?: number | undefined;
@@ -1150,26 +1326,28 @@ type TOIMBucketCommandsOptions = {
 declare class OIMBucketCommands implements IOIMBucketCommands {
     private readonly maxCommandsPerSlot;
     constructor(options: TOIMBucketCommandsOptions);
-    recordInsert(bucketSlot: TOIMBucketSlot<unknown>, index: number, bucketMemberSlot: TOIMSlot, bucketMemberSlotCount: number): void;
-    recordRemove(bucketSlot: TOIMBucketSlot<unknown>, index: number, count: number, bucketMemberSlotCount: number): void;
-    recordMove(bucketSlot: TOIMBucketSlot<unknown>, from: number, to: number, bucketMemberSlotCount: number): void;
-    recordWholeList(bucketSlot: TOIMBucketSlot<unknown>): void;
+    recordInsert(bucketSlot: TOIMBucketContentSlot<unknown>, index: number, bucketMemberSlot: TOIMSlot, bucketMemberSlotCount: number): void;
+    recordRemove(bucketSlot: TOIMBucketContentSlot<unknown>, index: number, count: number, bucketMemberSlotCount: number): void;
+    recordMove(bucketSlot: TOIMBucketContentSlot<unknown>, from: number, to: number, bucketMemberSlotCount: number): void;
+    recordWholeList(bucketSlot: TOIMBucketContentSlot<unknown>): void;
     private recordCommand;
 }
 
-declare class OIMIndexServiceSortedArrayDriven<TKey, TEntity extends object, TSourceKey = unknown, TSourceStore = unknown, TBucketSlot extends TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TKey> = TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore = Map<TKey, TBucketSlot>> extends OIMIndexService<TKey, TEntity, TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TSourceKey, TSourceStore, OIMSlotContentBucketServiceSortedArrayDriven<TOIMEntitySlot<TEntity>>, TBucketSlot, TStore> {
+declare class OIMSlotCollectionSortedArrayIndexService<TKey extends NonNullable<unknown>, TEntity extends object, TSourceKey extends NonNullable<unknown> = NonNullable<unknown>, TSourceStore = unknown, TBucketSlot extends TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey> = TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore = Map<TKey, TBucketSlot>> extends OIMSlotCollectionIndexService<TKey, TEntity, TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSourceKey, TSourceStore, OIMSlotContentSortedArrayBucketService<TOIMEntitySlot<TEntity>, TKey>, TBucketSlot, TStore> {
     private readonly sortColumnNames;
-    constructor(options: TOIMIndexServiceOptions<TKey, TEntity, TBucketSlot, TStore, OIMSlotContentBucketServiceSortedArrayDriven<TOIMEntitySlot<TEntity>>, TSourceKey, TSourceStore> & {
+    constructor(options: TOIMSlotCollectionIndexServiceOptions<TKey, TEntity, TBucketSlot, TStore, OIMSlotContentSortedArrayBucketService<TOIMEntitySlot<TEntity>, TKey>, TSourceKey, TSourceStore> & {
         sortColumns: readonly TOIMSortColumn<TEntity>[];
     });
-    createIndexStoreSlot(sourceStoreSlot: TOIMStoreSlot<TSourceStore, TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>>): TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore>;
+    createIndexStoreSlot(sourceStoreSlot: TOIMStoreSlot<TSourceStore, TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>>): TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore, this>;
     protected onBucketColumnsChanged(_indexStoreSlot: TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore>, bucketSlot: TBucketSlot, entitySlot: TOIMEntitySlot<TEntity, TSourceKey>, changedColumns: readonly string[] | undefined): void;
     private isSortColumnChanged;
 }
 
-type TOIMIndexServiceFactoryOptions<TEntity extends object, TSourceKey, TSourceStore> = {
+type TOIMSlotCollectionIndexServiceFactoryOptions<TEntity extends object, TSourceKey extends NonNullable<unknown>, TSourceStore> = {
     entityService: Pick<OIMSlotCollectionService<TSourceKey, TOIMEntitySlot<TEntity, TSourceKey>, TSourceStore, unknown>, 'getSlots'>;
+    defaults?: OIMDefaults | undefined;
     slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
+    slotSubscriptionListener?: IOIMSlotSubscriptionListener | undefined;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot> | undefined;
     columnNames?: readonly string[] | undefined;
 };
@@ -1186,34 +1364,19 @@ type TOIMIndexKeyOptions<TKey, TEntity extends object, TColumns extends readonly
     columns: [TKey] extends [never] ? never : [TKey] extends [TOIMIndexKey<TEntity, TColumns>] ? TColumns : never;
 };
 
-declare function createOIMIndexService<TEntity extends object, TSourceKey, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey = [TOIMIndexKey<TEntity, TColumns>] extends [TOIMStoreKey] ? Extract<TOIMIndexKey<TEntity, TColumns>, TOIMStoreKey> : never, TSourceStore = unknown, TSlots = TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots> = OIMSlotContentBucketServiceArrayDriven<TOIMEntitySlot<TEntity>> & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>>(db: OIMDB, options: TOIMIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
-    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>) | undefined;
+declare function createOIMSlotCollectionIndexService<TEntity extends object, TSourceKey extends NonNullable<unknown>, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey = [TOIMIndexKey<TEntity, TColumns>] extends [TOIMStoreKey] ? Extract<TOIMIndexKey<TEntity, TColumns>, TOIMStoreKey> : never, TSourceStore = unknown, TSlots = TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey> = OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TEntity>, TKey> & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>>(options: TOIMSlotCollectionIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
+    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>) | undefined;
     bucketSlotStoreService?: undefined;
-} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, Map<TKey, TOIMBucketSlot<TSlots, TKey>>>;
-declare function createOIMIndexService<TEntity extends object, TSourceKey, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey | readonly TOIMStoreKey[] = TOIMStoreKey, TSourceStore = unknown, TSlots = TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots> = OIMSlotContentBucketServiceArrayDriven<TOIMEntitySlot<TEntity>> & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, TStore = Map<TKey, TOIMBucketSlot<TSlots, TKey>>>(db: OIMDB, options: TOIMIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
-    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>) | undefined;
+} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, Map<TKey, TOIMBucketSlot<TSlots, TKey>>>;
+declare function createOIMSlotCollectionIndexService<TEntity extends object, TSourceKey extends NonNullable<unknown>, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey | readonly TOIMStoreKey[] = TOIMStoreKey, TSourceStore = unknown, TSlots = TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey> = OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TEntity>, TKey> & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>, TStore = Map<TKey, TOIMBucketSlot<TSlots, TKey>>>(options: TOIMSlotCollectionIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
+    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>) | undefined;
     bucketSlotStoreService: IOIMSlotStoreService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore>;
-} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, TStore>;
-
-type TOIMCompositeKeyNode<TAtKey = unknown, TCompositeKeyPart = TOIMEntitySlot> = {
-    childNodes: Map<TCompositeKeyPart, TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>> | undefined;
-    atThisKey: TAtKey | undefined;
-};
+} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, TStore>;
 
-type TOIMSlotStoreTree<TSlot, TCompositeKeyPart> = {
-    readonly root: TOIMCompositeKeyNode<TSlot, TCompositeKeyPart>;
-    readonly slots: Set<TSlot>;
-};
-
-declare function createOIMIndexServiceByCompositeKey<TEntity extends object, TSourceKey, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends readonly TOIMStoreKey[] = Extract<TOIMIndexKey<TEntity, TColumns>, readonly TOIMStoreKey[]>, TSourceStore = unknown, TSlots = TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TSlotContentService extends OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots> = OIMSlotContentBucketServiceArrayDriven<TOIMEntitySlot<TEntity>> & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>>(db: OIMDB, options: TOIMIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
-    columns: [TKey] extends [never] ? never : TColumns;
-    slotContentService?: (TSlotContentService & OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>) | undefined;
-}): OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, TOIMSlotStoreTree<TOIMBucketSlot<TSlots, TKey>, TOIMStoreKey>>;
-
-declare function createOIMIndexServiceSortedArrayDriven<TEntity extends object, TSourceKey, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey = [TOIMIndexKey<TEntity, TColumns>] extends [TOIMStoreKey] ? Extract<TOIMIndexKey<TEntity, TColumns>, TOIMStoreKey> : never, TSourceStore = unknown, TStore = Map<TKey, TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TKey>>>(db: OIMDB, options: TOIMIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
+declare function createOIMSlotCollectionSortedArrayIndexService<TEntity extends object, TSourceKey extends NonNullable<unknown>, const TColumns extends readonly TOIMEntityColumnName<TEntity>[] = readonly TOIMEntityColumnName<TEntity>[], TKey extends TOIMStoreKey = [TOIMIndexKey<TEntity, TColumns>] extends [TOIMStoreKey] ? Extract<TOIMIndexKey<TEntity, TColumns>, TOIMStoreKey> : never, TSourceStore = unknown, TStore = Map<TKey, TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>>>(options: TOIMSlotCollectionIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
     sortColumns: readonly TOIMSortColumn<TEntity>[];
-    bucketSlotStoreService?: IOIMSlotStoreService<TKey, TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore> | undefined;
-} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMIndexServiceSortedArrayDriven<TKey, TEntity, TSourceKey, TSourceStore, TOIMBucketSlot<TOIMBucketSlotsSortedArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore>;
+    bucketSlotStoreService?: IOIMSlotStoreService<TKey, TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore> | undefined;
+} & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMSlotCollectionSortedArrayIndexService<TKey, TEntity, TSourceKey, TSourceStore, TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore>;
 
 type TOIMFactoryOptions<TClassOptions, TFilledByDb extends PropertyKey, TDefaulted extends PropertyKey> = Omit<TClassOptions, TFilledByDb | TDefaulted> & {
     [TName in TDefaulted & keyof TClassOptions]?: TClassOptions[TName] | undefined;
@@ -1229,105 +1392,88 @@ declare abstract class OIMIndexKeysService implements IOIMIndexKeysService {
     set<TIndexKey>(slot: TOIMIndexableSlot, position: number, indexKey: TIndexKey | undefined): void;
 }
 
-declare class OIMIndexKeysServiceAppending extends OIMIndexKeysService {
-    static readonly INSTANCE: OIMIndexKeysServiceAppending;
+declare class OIMAppendingIndexKeysService extends OIMIndexKeysService {
+    static readonly INSTANCE: OIMAppendingIndexKeysService;
     allocatePosition(positions: TOIMIndexKeysPositions): number;
     releasePosition(): void;
 }
 
-declare class OIMIndexKeysServiceReclaiming extends OIMIndexKeysService {
+declare class OIMReclaimingIndexKeysService extends OIMIndexKeysService {
     allocatePosition(positions: TOIMIndexKeysPositions): number;
     releasePosition(positions: TOIMIndexKeysPositions, position: number, slots: Iterable<TOIMIndexableSlot>): void;
 }
 
-type TOIMEntityInsertStrategy = <TEntity extends object>(slot: TOIMEntitySlot<TEntity>, entity: TEntity) => void;
+type TOIMEntityInserter = <TEntity extends object>(slot: TOIMEntityContentSlot<TEntity>, entity: TEntity) => void;
 
-declare function oimPutEntityColumns(slot: TOIMEntitySlot, entity: object, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
+declare function oimPutEntityColumns(slot: TOIMEntityContentSlot, entity: object, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
 
-declare function oimPatchEntityColumns(slot: TOIMEntitySlot, patch: object, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
+declare function oimPatchEntityColumns(slot: TOIMEntityContentSlot, patch: object, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
 
-declare function oimPatchEntityColumn(slot: TOIMEntitySlot, columnName: string, value: unknown, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
+declare function oimPatchEntityColumn(slot: TOIMEntityContentSlot, columnName: string, value: unknown, sameValueGuard: TOIMSameValueGuard, changedColumnNames: string[] | undefined, targetOf: (entity: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown> | undefined;
 
 type TOIMEntityWriterOptions = {
     sameValueGuard?: TOIMSameValueGuard | undefined;
-    entityInsertStrategy?: TOIMEntityInsertStrategy | undefined;
+    entityInserter?: TOIMEntityInserter | undefined;
     putEntityColumns?: typeof oimPutEntityColumns | undefined;
     patchEntityColumns?: typeof oimPatchEntityColumns | undefined;
     patchEntityColumn?: typeof oimPatchEntityColumn | undefined;
 };
 
-declare function createOIMEntityWriterInPlace(options?: TOIMEntityWriterOptions): IOIMEntityWriter;
+declare function createOIMInPlaceEntityWriter(options?: TOIMEntityWriterOptions): IOIMEntityWriter;
 
-declare function createOIMEntityWriterReplacing(options?: TOIMEntityWriterOptions): IOIMEntityWriter;
+declare function createOIMReplacingEntityWriter(options?: TOIMEntityWriterOptions): IOIMEntityWriter;
 
-declare function oimInsertEntityWithoutCopy<TEntity extends object>(slot: TOIMEntitySlot<TEntity>, entity: TEntity): void;
+declare function oimInsertEntityWithoutCopy<TEntity extends object>(slot: TOIMEntityContentSlot<TEntity>, entity: TEntity): void;
 
-declare function oimInsertEntityWithCopy<TEntity extends object>(slot: TOIMEntitySlot<TEntity>, entity: TEntity): void;
+declare function oimInsertEntityWithCopy<TEntity extends object>(slot: TOIMEntityContentSlot<TEntity>, entity: TEntity): void;
 
-declare function oimInsertEntityWithSanitizedCopy<TEntity extends object>(slot: TOIMEntitySlot<TEntity>, entity: TEntity): void;
+declare function oimInsertEntityWithSanitizedCopy<TEntity extends object>(slot: TOIMEntityContentSlot<TEntity>, entity: TEntity): void;
 
-declare const oimPatchEntityColumnsGuarded: typeof oimPatchEntityColumns;
+declare const oimGuardedPatchEntityColumns: typeof oimPatchEntityColumns;
 
-declare const oimPatchEntityColumnGuarded: typeof oimPatchEntityColumn;
+declare const oimGuardedPatchEntityColumn: typeof oimPatchEntityColumn;
 
-declare const oimPutEntityColumnsGuarded: typeof oimPutEntityColumns;
+declare const oimGuardedPutEntityColumns: typeof oimPutEntityColumns;
 
-declare abstract class OIMReleaseSlotCollectorService extends OIMFlushSchedulerService<TOIMReleaseSlotCollectorSlot> {
-    abstract readonly getReleaseDueMs: (slot: TOIMSlot) => number;
-    protected abstract readonly setReleaseDueMs: (slot: TOIMSlot, releaseDueMs: number) => void;
-    abstract getReleaseSlotCollectorSlot(collectorSlot: TOIMCollectorSlot): TOIMReleaseSlotCollectorSlot;
-    getReleaseSlotCollectorSlotOf(slot: TOIMSlot): TOIMReleaseSlotCollectorSlot;
-    markSlotReleaseDue(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot, keepMs: number): number;
-    scheduleSlotRelease(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot, nowMs: number): void;
-    isSlotReleasable(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot): boolean;
-    cancelSlotRelease(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot): void;
-    scheduleNextRelease(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-    protected cancelSchedule(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-    flush(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-    protected onSchedulerTimerFired(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-    cancelAllSlotReleases(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-}
+declare function oimMintAfterWriteSlotReleaseWheel(collectorSlot: TOIMCollectorSlot): OIMSlotReleaseWheel;
+
+declare function oimMintAfterIdleSlotReleaseWheel(collectorSlot: TOIMCollectorSlot): OIMSlotReleaseWheel;
 
-declare function createOIMReleaseSlotCollectorSlot(options: TOIMCollectorSlotOptions): TOIMReleaseSlotCollectorSlot;
+declare function oimMintAfterUnholdSlotReleaseWheel(collectorSlot: TOIMCollectorSlot): OIMSlotReleaseWheel;
 
-declare class OIMReleaseSlotQueueService {
-    static readonly INSTANCE: OIMReleaseSlotQueueService;
-    scheduleSlotRelease(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, releaseSlotCollectorService: OIMReleaseSlotCollectorService, slot: TOIMSlot, nowMs: number): void;
-    cancelSlotRelease(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot): void;
-    getNextReleaseSliceNumber(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): number | undefined;
-    cancelAllSlotReleases(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot): void;
-    isSlotReleaseScheduled(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, slot: TOIMSlot): boolean;
-    releaseDueUpToSliceNumber(releaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot, releaseSlotCollectorService: OIMReleaseSlotCollectorService, upToSliceNumber: number): void;
-    private releaseSlice;
-    private removeFromSliceNumber;
-    private updateNextSliceNumber;
-    private invalidateNextSliceNumber;
-    private addToSliceNumber;
+interface IOIMSlotRefetchListener {
+    onSlotsRefetchDue(slots: readonly TOIMSlot[]): void;
 }
 
-declare class OIMReleaseSlotCollectorServiceAfterIdle extends OIMReleaseSlotCollectorService {
-    static readonly INSTANCE: OIMReleaseSlotCollectorServiceAfterIdle;
-    readonly getReleaseDueMs: (slot: TOIMSlot) => number;
-    protected readonly setReleaseDueMs: (slot: TOIMSlot, releaseDueMs: number) => void;
-    getReleaseSlotCollectorSlot(collectorSlot: TOIMCollectorSlot): TOIMReleaseSlotCollectorSlot;
+type TOIMSlotRefetchWheelOptions = Partial<TOIMSlotWheelOptions> & {
+    slotRefetchListener: IOIMSlotRefetchListener;
+};
+
+declare class OIMSlotRefetchWheel extends OIMSlotWheel {
+    private readonly slotRefetchListener;
+    private readonly refetchDueSlots;
+    constructor(options: TOIMSlotRefetchWheelOptions);
+    scheduleSlotRefetchAt(slot: TOIMSlot, atMs: number): void;
+    protected getSweptSliceNumberAt(nowMs: number): number;
+    protected onSlotDue(slot: TOIMSlot): void;
+    protected onSweepFinished(): void;
 }
 
-declare class OIMReleaseSlotCollectorServiceAfterWrite extends OIMReleaseSlotCollectorService {
-    static readonly INSTANCE: OIMReleaseSlotCollectorServiceAfterWrite;
-    readonly getReleaseDueMs: (slot: TOIMSlot) => number;
-    protected readonly setReleaseDueMs: (slot: TOIMSlot, releaseDueMs: number) => void;
-    getReleaseSlotCollectorSlot(collectorSlot: TOIMCollectorSlot): TOIMReleaseSlotCollectorSlot;
+interface IOIMSlotReleaseDueFramePolicy {
+    isSlotReleaseDueFrameOpen(): boolean;
 }
 
-type TOIMSlotReleasePolicyAfterWriteOptions = {
+type TOIMSlotAfterWriteReleasePolicyOptions = {
     keepAfterWriteMs: number;
+    slotReleaseDueFramePolicy?: IOIMSlotReleaseDueFramePolicy;
 };
 
-declare class OIMSlotReleasePolicyAfterWrite implements IOIMSlotReleasePolicy {
+declare class OIMSlotAfterWriteReleasePolicy implements IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots = true;
     readonly schedulesReleaseOnWrite = true;
     private readonly keepAfterWriteMs;
-    constructor(options: TOIMSlotReleasePolicyAfterWriteOptions);
+    private readonly slotReleaseDueFramePolicy;
+    constructor(options: TOIMSlotAfterWriteReleasePolicyOptions);
     onSlotWritten(slot: TOIMSlot): void;
     onSlotIdle(slot: TOIMSlot): boolean;
     onSlotUnheld(): void;
@@ -1336,15 +1482,28 @@ declare class OIMSlotReleasePolicyAfterWrite implements IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-type TOIMSlotReleasePolicyAfterIdleOptions = {
+declare class OIMSlotReleaseAutoDueFramePolicy implements IOIMSlotReleaseDueFramePolicy {
+    static readonly INSTANCE: OIMSlotReleaseAutoDueFramePolicy;
+    isSlotReleaseDueFrameOpen(): boolean;
+}
+
+declare class OIMSlotReleaseManualDueFramePolicy implements IOIMSlotReleaseDueFramePolicy {
+    private slotReleaseDueFrameDepth;
+    isSlotReleaseDueFrameOpen(): boolean;
+    openSlotReleaseDueFrame(): void;
+    closeSlotReleaseDueFrame(): void;
+    writeInSlotReleaseDueFrame(write: () => void): void;
+}
+
+type TOIMSlotAfterIdleReleasePolicyOptions = {
     keepAfterIdleMs: number;
 };
 
-declare class OIMSlotReleasePolicyAfterIdle implements IOIMSlotReleasePolicy {
+declare class OIMSlotAfterIdleReleasePolicy implements IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots = true;
     readonly schedulesReleaseOnWrite = true;
     private readonly keepAfterIdleMs;
-    constructor(options: TOIMSlotReleasePolicyAfterIdleOptions);
+    constructor(options: TOIMSlotAfterIdleReleasePolicyOptions);
     onSlotWritten(): void;
     onSlotIdle(slot: TOIMSlot): boolean;
     onSlotUnheld(): void;
@@ -1353,8 +1512,8 @@ declare class OIMSlotReleasePolicyAfterIdle implements IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-declare class OIMSlotReleasePolicyAtUnhold implements IOIMSlotReleasePolicy {
-    static readonly INSTANCE: OIMSlotReleasePolicyAtUnhold;
+declare class OIMSlotAtUnholdReleasePolicy implements IOIMSlotReleasePolicy {
+    static readonly INSTANCE: OIMSlotAtUnholdReleasePolicy;
     readonly releasesWrittenSlots = true;
     readonly schedulesReleaseOnWrite = false;
     onSlotWritten(): void;
@@ -1365,8 +1524,8 @@ declare class OIMSlotReleasePolicyAtUnhold implements IOIMSlotReleasePolicy {
     cancelSlotRelease(): void;
 }
 
-declare class OIMSlotReleasePolicyAtEmpty implements IOIMSlotReleasePolicy {
-    static readonly INSTANCE: OIMSlotReleasePolicyAtEmpty;
+declare class OIMSlotAtEmptyReleasePolicy implements IOIMSlotReleasePolicy {
+    static readonly INSTANCE: OIMSlotAtEmptyReleasePolicy;
     readonly releasesWrittenSlots = false;
     readonly schedulesReleaseOnWrite = false;
     onSlotWritten(): void;
@@ -1377,8 +1536,8 @@ declare class OIMSlotReleasePolicyAtEmpty implements IOIMSlotReleasePolicy {
     cancelSlotRelease(): void;
 }
 
-declare class OIMSlotReleasePolicyNever implements IOIMSlotReleasePolicy {
-    static readonly INSTANCE: OIMSlotReleasePolicyNever;
+declare class OIMSlotNeverReleasePolicy implements IOIMSlotReleasePolicy {
+    static readonly INSTANCE: OIMSlotNeverReleasePolicy;
     readonly releasesWrittenSlots = false;
     readonly schedulesReleaseOnWrite = false;
     onSlotWritten(): void;
@@ -1389,15 +1548,15 @@ declare class OIMSlotReleasePolicyNever implements IOIMSlotReleasePolicy {
     cancelSlotRelease(): void;
 }
 
-type TOIMSlotReleasePolicyAfterUnholdOptions = {
+type TOIMSlotAfterUnholdReleasePolicyOptions = {
     keepAfterUnholdMs: number;
 };
 
-declare class OIMSlotReleasePolicyAfterUnhold implements IOIMSlotReleasePolicy {
+declare class OIMSlotAfterUnholdReleasePolicy implements IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots = true;
     readonly schedulesReleaseOnWrite = false;
     private readonly keepAfterUnholdMs;
-    constructor(options: TOIMSlotReleasePolicyAfterUnholdOptions);
+    constructor(options: TOIMSlotAfterUnholdReleasePolicyOptions);
     onSlotWritten(): void;
     onSlotIdle(): boolean;
     onSlotUnheld(slot: TOIMSlot): void;
@@ -1406,14 +1565,7 @@ declare class OIMSlotReleasePolicyAfterUnhold implements IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-declare class OIMReleaseSlotCollectorServiceAfterUnhold extends OIMReleaseSlotCollectorService {
-    static readonly INSTANCE: OIMReleaseSlotCollectorServiceAfterUnhold;
-    readonly getReleaseDueMs: (slot: TOIMSlot) => number;
-    protected readonly setReleaseDueMs: (slot: TOIMSlot, releaseDueMs: number) => void;
-    getReleaseSlotCollectorSlot(collectorSlot: TOIMCollectorSlot): TOIMReleaseSlotCollectorSlot;
-}
-
-declare class OIMSlotReleasePolicyEarliest implements IOIMSlotReleasePolicy {
+declare class OIMSlotEarliestReleasePolicy implements IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots: boolean;
     readonly schedulesReleaseOnWrite: boolean;
     private readonly slotReleasePolicies;
@@ -1431,25 +1583,37 @@ declare const oimSliceOfMs: (ms: number) => number;
 
 declare const OIM_SLICE_LENGTH_MS = 1024;
 
-declare class OIMSlotStoreServiceMapDriven<TSlot extends TOIMKeyedSlot<TKey>, TKey = TSlot extends TOIMKeyedSlot<infer TSlotKey> ? TSlotKey : TOIMStoreKey> implements IOIMSlotStoreService<TKey, TSlot, Map<TKey, TSlot>> {
-    static readonly INSTANCE: OIMSlotStoreServiceMapDriven<TOIMKeyedSlot<unknown>, unknown>;
+declare class OIMSlotMapStoreService<TSlot extends TOIMKeyedSlot<TKey>, TKey extends NonNullable<unknown> = TSlot extends TOIMKeyedSlot<infer TSlotKey> ? TSlotKey : TOIMStoreKey> implements IOIMSlotStoreService<TKey, TSlot, Map<TKey, TSlot>> {
+    static readonly INSTANCE: OIMSlotMapStoreService<TOIMKeyedSlot, {}>;
     createStore(): Map<TKey, TSlot>;
     ownKey<TOwnedKey extends TKey>(key: TOwnedKey): TOwnedKey;
     isSameKey(key: TKey, otherKey: TKey): boolean;
     get(store: Map<TKey, TSlot>, key: TKey): TSlot | undefined;
     set(store: Map<TKey, TSlot>, key: TKey, slot: TSlot): void;
     remove(store: Map<TKey, TSlot>, key: TKey): void;
+    fileSlot(store: Map<TKey, TSlot>, slot: TSlot): void;
+    unfileSlot(store: Map<TKey, TSlot>, slot: TSlot): void;
     getSlots(store: Map<TKey, TSlot>): IterableIterator<TSlot>;
     getSlotCount(store: Map<TKey, TSlot>): number;
 }
 
+type TOIMCompositeKeyNode<TAtKey = unknown, TCompositeKeyPart = TOIMEntitySlot> = {
+    childNodes: Map<TCompositeKeyPart, TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>> | undefined;
+    atThisKey: TAtKey | undefined;
+};
+
 interface IOIMKeyTreeWalk<TCompositeKeyPart> {
     mintNodeAt<TAtKey>(rootCompositeKeyNode: TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>;
     nodeAt<TAtKey>(rootCompositeKeyNode: TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart> | undefined;
     deleteKey<TAtKey>(rootCompositeKeyNode: TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): TAtKey | undefined;
 }
 
-declare class OIMSlotStoreServiceTreeDriven<TCompositeKeyPart, TSlot extends TOIMKeyedSlot<readonly TCompositeKeyPart[]>> implements IOIMSlotStoreService<readonly TCompositeKeyPart[], TSlot, TOIMSlotStoreTree<TSlot, TCompositeKeyPart>> {
+type TOIMSlotStoreTree<TSlot, TCompositeKeyPart> = {
+    readonly rootCompositeKeyNode: TOIMCompositeKeyNode<TSlot, TCompositeKeyPart>;
+    readonly slots: Set<TSlot>;
+};
+
+declare class OIMSlotTreeStoreService<TCompositeKeyPart, TSlot extends TOIMKeyedSlot<readonly TCompositeKeyPart[]>> implements IOIMSlotStoreService<readonly TCompositeKeyPart[], TSlot, TOIMSlotStoreTree<TSlot, TCompositeKeyPart>> {
     private readonly keyTreeWalk;
     constructor(keyTreeWalk: IOIMKeyTreeWalk<TCompositeKeyPart>);
     createStore(): TOIMSlotStoreTree<TSlot, TCompositeKeyPart>;
@@ -1458,6 +1622,8 @@ declare class OIMSlotStoreServiceTreeDriven<TCompositeKeyPart, TSlot extends TOI
     get(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): TSlot | undefined;
     set(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[], slot: TSlot): void;
     remove(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): void;
+    fileSlot(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>, slot: TSlot): void;
+    unfileSlot(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>, slot: TSlot): void;
     getSlots(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>): IterableIterator<TSlot>;
     getSlotCount(slotStoreTree: TOIMSlotStoreTree<TSlot, TCompositeKeyPart>): number;
 }
@@ -1470,41 +1636,18 @@ declare abstract class OIMKeyTreeWalk<TCompositeKeyPart> implements IOIMKeyTreeW
     deleteKey<TAtKey>(rootCompositeKeyNode: TOIMCompositeKeyNode<TAtKey, TCompositeKeyPart>, compositeKey: readonly TCompositeKeyPart[]): TAtKey | undefined;
 }
 
-declare class OIMKeyTreeWalkComposite extends OIMKeyTreeWalk<TOIMEntitySlot> {
-    static readonly INSTANCE: OIMKeyTreeWalkComposite;
+declare class OIMCompositeKeyTreeWalk extends OIMKeyTreeWalk<TOIMEntitySlot> {
+    static readonly INSTANCE: OIMCompositeKeyTreeWalk;
     protected holdCompositeKeyPart(entitySlot: TOIMEntitySlot): void;
     protected unholdCompositeKeyPart(entitySlot: TOIMEntitySlot): void;
 }
 
-declare class OIMKeyTreeWalkScalar extends OIMKeyTreeWalk<TOIMStoreKey> {
-    static readonly INSTANCE: OIMKeyTreeWalkScalar;
+declare class OIMScalarKeyTreeWalk extends OIMKeyTreeWalk<TOIMStoreKey> {
+    static readonly INSTANCE: OIMScalarKeyTreeWalk;
     protected holdCompositeKeyPart(): void;
     protected unholdCompositeKeyPart(): void;
 }
 
-type TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = TOIMBucketSlotsArrayStore<TBucketMemberSlot> & {
-    uniqueBucketMemberSlots: Set<TBucketMemberSlot>;
-};
-
-declare class OIMBucketArrayMembershipNonUnique<TBucketMemberSlot extends TOIMSlot = TOIMSlot> implements IOIMBucketArrayMembership<TBucketMemberSlot, TOIMBucketSlotsArrayStore<TBucketMemberSlot>> {
-    static readonly INSTANCE: OIMBucketArrayMembershipNonUnique<TOIMSlot>;
-    createStore(): TOIMBucketSlotsArrayStore<TBucketMemberSlot>;
-    addSlot(): boolean;
-    removeSlot(): boolean;
-    hasSlot(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    clearSlots(): void;
-    containsTheSameSequence(bucketSlotsArrayStore: TOIMBucketSlotsArrayStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
-}
-
-declare class OIMBucketArrayMembershipUnique<TBucketMemberSlot extends TOIMSlot = TOIMSlot> implements IOIMBucketArrayMembership<TBucketMemberSlot, TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>> {
-    createStore(): TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>;
-    addSlot(bucketSlotsArrayUniqueStore: TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    removeSlot(bucketSlotsArrayUniqueStore: TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    hasSlot(bucketSlotsArrayUniqueStore: TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>, bucketMemberSlot: TBucketMemberSlot): boolean;
-    clearSlots(bucketSlotsArrayUniqueStore: TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>): void;
-    containsTheSameSequence(bucketSlotsArrayUniqueStore: TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>, bucketMemberSlots: readonly TBucketMemberSlot[]): boolean;
-}
-
 declare const OIM_NOTHING_WAS_INSERTED = -1;
 
 declare const OIM_NOTHING_WAS_REMOVED = -1;
@@ -1515,4 +1658,4 @@ declare const OIM_REMOVED_WITHOUT_A_POSITION = -2;
 
 declare function oimOrderedListCommandsOfTransition(prev: readonly TOIMSlot[], next: readonly TOIMSlot[], maxCommandsPerSlot?: number): TOIMOrderedListCommand[];
 
-export { type IOIMBucketArrayMembership, type IOIMBucketCommands, type IOIMChannelMap, type IOIMComputedValueService, type IOIMContentChangeListener, type IOIMEffectService, type IOIMEntityWriter, type IOIMErrorPolicy, type IOIMIndexKeysService, type IOIMKeyTreeWalk, type IOIMSlotContentFlushStrategy, type IOIMSlotContentStrategy, type IOIMSlotEmptiness, type IOIMSlotOwner, type IOIMSlotReleasePolicy, type IOIMSlotStamp, type IOIMSlotStoreService, type IOIMStoreSlotListener, type IOIMSubframeCloseListener, OIMBucketArrayMembershipNonUnique, OIMBucketArrayMembershipUnique, OIMBucketCommands, type OIMChannelQueue, OIMChannelService, OIMColumnOwner, OIMColumnOwnerPullDriven, type OIMColumnOwnerPushDriven, OIMComputedService, OIMComputedServiceBucketMemo, OIMComputedServiceSorted, OIMComputedValueService, OIMContentChangeListenerService, OIMDB, OIMDefaultValue, OIMDefaults, OIMEffectService, type OIMEffectSourceTracker, OIMErrorPolicyLogAndContinue, OIMErrorPolicyThrowAtOnce, OIMFlushSchedulerService, OIMIndexKeysService, OIMIndexKeysServiceAppending, OIMIndexKeysServiceReclaiming, OIMIndexService, OIMIndexServiceSortedArrayDriven, OIMKeyTreeWalk, OIMKeyTreeWalkComposite, OIMKeyTreeWalkScalar, OIMReleaseSlotCollectorService, OIMReleaseSlotCollectorServiceAfterIdle, OIMReleaseSlotCollectorServiceAfterUnhold, OIMReleaseSlotCollectorServiceAfterWrite, OIMReleaseSlotQueueService, OIMSingleSlotService, OIMSlotCollectionService, OIMSlotColumnService, OIMSlotContentBucketService, OIMSlotContentBucketServiceArrayBased, OIMSlotContentBucketServiceArrayDriven, OIMSlotContentBucketServiceSetDriven, OIMSlotContentBucketServiceSortedArrayDriven, OIMSlotContentEntityService, OIMSlotOwner, type OIMSlotOwnerService, OIMSlotReleasePolicyAfterIdle, OIMSlotReleasePolicyAfterUnhold, OIMSlotReleasePolicyAfterWrite, OIMSlotReleasePolicyAtEmpty, OIMSlotReleasePolicyAtUnhold, OIMSlotReleasePolicyEarliest, OIMSlotReleasePolicyNever, OIMSlotStoreServiceMapDriven, OIMSlotStoreServiceSingleSlotDriven, OIMSlotStoreServiceTreeDriven, OIMStoreSlotListenerNone, OIMUnusedSlotCollectorService, OIM_FROZEN_EMPTY_SLOTS, OIM_NOTHING_WAS_INSERTED, OIM_NOTHING_WAS_REMOVED, OIM_REMOVED_WITHOUT_A_POSITION, OIM_SLICE_LENGTH_MS, type TOIMBucketCollectionFactoryArguments, type TOIMBucketCommandsOptions, type TOIMBucketMemoComputedSlot, type TOIMBucketSlot, type TOIMBucketSlotOwnerService, type TOIMBucketSlotsArrayStore, type TOIMBucketSlotsArrayUniqueStore, type TOIMBucketSlotsSetStore, type TOIMBucketSlotsSortedArrayStore, type TOIMChannelClock, type TOIMChannelFrame, type TOIMChannelScheduler, type TOIMChannelSlot, type TOIMChannelSlotOptions, type TOIMCollectorSlot, type TOIMCollectorSlotOptions, type TOIMColumnGroup, type TOIMColumnOwnerOptions, type TOIMColumnReaders, type TOIMColumnSlot, type TOIMCompositeKeyNode, type TOIMComputedColumnSlot, type TOIMComputedServiceBucketMemoOptions, type TOIMComputedServiceOptions, type TOIMComputedServiceSortedOptions, type TOIMComputedSlot, type TOIMComputedSources, type TOIMComputedStoreSlot, type TOIMComputedValueServiceOptions, type TOIMDBOptions, type TOIMDefaultSlotStore, type TOIMDerivation, type TOIMDisposer, type TOIMEffect, type TOIMEffectBody, type TOIMEffectBodyWithSourceTracking, type TOIMEntityColumnName, type TOIMEntityColumnValue, type TOIMEntityInsertStrategy, type TOIMEntitySlot, type TOIMEntitySlotOwnerService, type TOIMEntityWriterOptions, type TOIMErrorPolicyLogAndContinueOptions, type TOIMFactoryOptions, type TOIMFlushSchedulerSlot, type TOIMIndexKey, type TOIMIndexKeyOptions, type TOIMIndexKeysPositions, type TOIMIndexServiceFactoryOptions, type TOIMIndexServiceOptions, type TOIMIndexServiceStoreSlot, type TOIMIndexStoreSlot, type TOIMIndexableSlot, type TOIMKeyedSlot, type TOIMOrderedListCommand, type TOIMReleaseSlotCollectorSlot, type TOIMSameValueGuard, type TOIMSingleSlotServiceOptions, type TOIMSingleSlotStore, type TOIMSingleSlotStoreSlot, type TOIMSlot, type TOIMSlotCollectionServiceOptions, type TOIMSlotContentBucketServiceOptions, type TOIMSlotContentBucketServiceSortedArrayDrivenOptions, type TOIMSlotContentEntityServiceFactoryOptions, type TOIMSlotContentEntityServiceOptions, type TOIMSlotEditable, type TOIMSlotOwnerServiceOptions, type TOIMSlotReleasePolicyAfterIdleOptions, type TOIMSlotReleasePolicyAfterUnholdOptions, type TOIMSlotReleasePolicyAfterWriteOptions, type TOIMSlotStoreTree, type TOIMSortColumn, type TOIMSortableColumnName, type TOIMSortedComputedSlot, type TOIMStoreKey, type TOIMStoreSlot, type TOIMTimer, type TOIMUnusedSlotCollectorSlot, createOIMBucketService, createOIMChannelSlot, createOIMCollectorSlot, createOIMComputedService, createOIMComputedServiceBucketMemo, createOIMComputedServiceSorted, createOIMEntityService, createOIMEntityWriterInPlace, createOIMEntityWriterReplacing, createOIMIndexService, createOIMIndexServiceByCompositeKey, createOIMIndexServiceSortedArrayDriven, createOIMReleaseSlotCollectorSlot, createOIMSingleBucketService, createOIMSingleEntityService, createOIMSingleSlotService, createOIMSlotCollectionService, createOIMSlotContentEntityService, createOIMUnusedSlotCollectorSlot, oimColumnsComparator, oimHoldSlots, oimInsertEntityWithCopy, oimInsertEntityWithSanitizedCopy, oimInsertEntityWithoutCopy, oimIsAnySlotChangedAfter, oimIsSlotEmpty, oimIsSlotReleased, oimOrderedListCommandsOfTransition, oimPatchEntityColumn, oimPatchEntityColumnGuarded, oimPatchEntityColumns, oimPatchEntityColumnsGuarded, oimPutEntityColumns, oimPutEntityColumnsGuarded, oimRefreshSourceComputeds, oimSameKeySequence, oimSameSlotSequence, oimSameValueZeroGuard, oimSliceOfMs, oimUnholdSlotsIfAlive };
+export { type IOIMBucketCommands, type IOIMBucketMemberSlotsArrayService, type IOIMChannelMap, type IOIMComputedValueService, type IOIMEffectService, type IOIMEntityWriter, type IOIMErrorPolicy, type IOIMFlushSchedulerListener, type IOIMIndexKeysService, type IOIMKeyTreeWalk, type IOIMKeyedSlotCreator, type IOIMSingleSlotCreator, type IOIMSlotContentChangeListener, type IOIMSlotContentService, type IOIMSlotContentWriter, type IOIMSlotEmptinessPolicy, type IOIMSlotFilingService, type IOIMSlotOwner, type IOIMSlotRefetchListener, type IOIMSlotReleaseDueFramePolicy, type IOIMSlotReleasePolicy, type IOIMSlotStamp, type IOIMSlotStoreService, type IOIMSlotSubscriptionListener, type IOIMStoreSlotListener, OIMAppendingIndexKeysService, OIMBucketCommands, OIMBucketMemberSlotsArrayService, OIMBucketMemoComputedService, OIMBucketUniqueMemberSlotsArrayService, type OIMChannelQueue, OIMChannelService, OIMColumnSlotOwner, OIMColumnSlotService, OIMCompositeKeyTreeWalk, OIMComputedService, OIMComputedValueService, OIMDB, OIMDefaultValue, OIMDefaults, OIMEffectService, OIMFlushSchedulerService, OIMIndexKeysService, OIMKeyTreeWalk, OIMLogAndContinueErrorPolicy, OIMNoSlotSubscriptionListener, OIMNoStoreSlotListener, OIMPullColumnSlotOwner, type OIMPushColumnSlotOwner, OIMReclaimingIndexKeysService, OIMScalarKeyTreeWalk, OIMSingleComputedService, OIMSingleSlotService, OIMSingleSlotStoreService, OIMSingleSourceTrackingComputedService, OIMSlotAfterIdleReleasePolicy, OIMSlotAfterUnholdReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotAtEmptyReleasePolicy, OIMSlotAtUnholdReleasePolicy, OIMSlotCollectionIndexService, OIMSlotCollectionService, OIMSlotCollectionSortedArrayIndexService, OIMSlotContentArrayBucketService, OIMSlotContentBucketService, OIMSlotContentChangeListenerService, type OIMSlotContentComputedService, OIMSlotContentEntityService, OIMSlotContentPositionalArrayBucketService, OIMSlotContentSetBucketService, OIMSlotContentSortedArrayBucketService, type OIMSlotContentSourceTrackingComputedService, OIMSlotEarliestReleasePolicy, OIMSlotMapStoreService, OIMSlotNeverReleasePolicy, OIMSlotOwner, type OIMSlotOwnerService, OIMSlotRefetchWheel, OIMSlotReleaseAutoDueFramePolicy, OIMSlotReleaseManualDueFramePolicy, OIMSlotReleaseWheel, OIMSlotTreeStoreService, OIMSlotWheel, OIMSortedComputedService, type OIMSourceTracker, OIMSourceTrackingComputedService, OIMThrowAtOnceErrorPolicy, OIMUnusedSlotCollectorService, OIMWritableSingleSlotService, OIMWritableSlotCollectionService, OIM_FROZEN_EMPTY_SLOTS, OIM_NOTHING_WAS_INSERTED, OIM_NOTHING_WAS_REMOVED, OIM_REMOVED_WITHOUT_A_POSITION, OIM_SLICE_LENGTH_MS, type TOIMBucketCommandsOptions, type TOIMBucketContentSlot, type TOIMBucketMemoComputedServiceOptions, type TOIMBucketMemoComputedSlot, type TOIMBucketSlot, type TOIMBucketSlotOwnerService, type TOIMBucketSlotsArrayStore, type TOIMBucketSlotsSetStore, type TOIMChannelClock, type TOIMChannelFrame, type TOIMChannelScheduler, type TOIMChannelSlot, type TOIMChannelSlotOptions, type TOIMCollectorSlot, type TOIMCollectorSlotOptions, type TOIMColumnGroup, type TOIMColumnReaders, type TOIMColumnSlot, type TOIMColumnSlotOwnerOptions, type TOIMCompositeKeyNode, type TOIMComputedColumnSlot, type TOIMComputedContentSlot, type TOIMComputedDerivation, type TOIMComputedDerivationOptions, type TOIMComputedServiceFactoryOptions, type TOIMComputedServiceOptions, type TOIMComputedSlot, type TOIMComputedSources, type TOIMComputedStoreSlot, type TOIMComputedValueReleaser, type TOIMComputedValueServiceOptions, type TOIMDBOptions, type TOIMDefaultSlotStore, type TOIMDefaultsOptions, type TOIMDisposer, type TOIMEditable, type TOIMEffect, type TOIMEffectBody, type TOIMEntityColumnName, type TOIMEntityColumnValue, type TOIMEntityContentSlot, type TOIMEntityInserter, type TOIMEntitySlot, type TOIMEntitySlotOwnerService, type TOIMEntityWriterOptions, type TOIMFactoryOptions, type TOIMFlushSchedulerSlot, type TOIMIndexKey, type TOIMIndexKeyOptions, type TOIMIndexKeysPositions, type TOIMIndexStoreSlot, type TOIMIndexableSlot, type TOIMKeyedSlot, type TOIMLogAndContinueErrorPolicyOptions, type TOIMOrderedListCommand, type TOIMSameValueGuard, type TOIMSingleSlotServiceOptions, type TOIMSingleSlotStore, type TOIMSingleSlotStoreSlot, type TOIMSlot, type TOIMSlotAfterIdleReleasePolicyOptions, type TOIMSlotAfterUnholdReleasePolicyOptions, type TOIMSlotAfterWriteReleasePolicyOptions, type TOIMSlotCollectionIndexServiceFactoryOptions, type TOIMSlotCollectionIndexServiceOptions, type TOIMSlotCollectionIndexServiceStoreSlot, type TOIMSlotCollectionServiceOptions, type TOIMSlotContentArrayBucketServiceOptions, type TOIMSlotContentBucketServiceOptions, type TOIMSlotContentComputedServiceOptions, type TOIMSlotContentEntityServiceOptions, type TOIMSlotContentServiceContent, type TOIMSlotContentServiceKey, type TOIMSlotContentServicePatch, type TOIMSlotContentServiceSingleSlot, type TOIMSlotContentServiceSlot, type TOIMSlotContentSortedArrayBucketServiceOptions, type TOIMSlotOwnerServiceOptions, type TOIMSlotRefetchWheelOptions, type TOIMSlotReleaseWheelOptions, type TOIMSlotStoreTree, type TOIMSlotWheelOptions, type TOIMSortColumn, type TOIMSortableColumnName, type TOIMSortedComputedServiceOptions, type TOIMSortedComputedSlot, type TOIMSourceTrackingComputedContentSlot, type TOIMSourceTrackingComputedDerivationOptions, type TOIMSourceTrackingComputedDerive, type TOIMSourceTrackingComputedSlot, type TOIMSourceTrackingEffectBody, type TOIMStoreKey, type TOIMStoreSlot, type TOIMTimer, type TOIMUnusedSlotCollectorSlot, createOIMBucketMemoComputedService, createOIMChannelSlot, createOIMCollectorSlot, createOIMComputedService, createOIMInPlaceEntityWriter, createOIMReplacingEntityWriter, createOIMSingleComputedService, createOIMSingleSlotService, createOIMSingleSourceTrackingComputedService, createOIMSlotCollectionIndexService, createOIMSlotCollectionService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotContentEntityService, createOIMSortedComputedService, createOIMSourceTrackingComputedService, createOIMUnusedSlotCollectorSlot, oimColumnsComparator, oimGuardedPatchEntityColumn, oimGuardedPatchEntityColumns, oimGuardedPutEntityColumns, oimHoldSlots, oimInsertEntityWithCopy, oimInsertEntityWithSanitizedCopy, oimInsertEntityWithoutCopy, oimIsAnySlotChangedAfter, oimIsSlotEmpty, oimIsSlotReleased, oimMintAfterIdleSlotReleaseWheel, oimMintAfterUnholdSlotReleaseWheel, oimMintAfterWriteSlotReleaseWheel, oimOrderedListCommandsOfTransition, oimPatchEntityColumn, oimPatchEntityColumns, oimPutEntityColumns, oimRefreshSourceComputeds, oimSameKeySequence, oimSameSlotSequence, oimSameValueZeroGuard, oimSliceOfMs, oimUnholdSlotsIfAlive };