@oimdb/core 4.1.0 → 4.3.0

package/dist/index.d.cts

@@ -10,7 +10,7 @@ interface IOIMEffectService {
     setPositionInSubscribedSlot(effect: TOIMEffect, edge: number, positionInSlot: number): void;
 }
 
-type TOIMSlotEditable<TSlot> = {
+type TOIMEditable<TSlot> = {
     -readonly [K in keyof TSlot]: TSlot[K];
 };
 
@@ -18,18 +18,39 @@ interface IOIMSlotOwner {
     holdSlot(slot: TOIMSlot): void;
     unholdSlot(slot: TOIMSlot): void;
     releaseSlotIfUnheld(slot: TOIMSlot): void;
-    unsafeMutateSlot(slot: TOIMSlot, mutateSlot: (slotEditable: TOIMSlotEditable<TOIMSlot>) => void): 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: TOIMComputedContentSlot<TValue>): TValue;
+    getValueForSlot(computedSlot: TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined>): TValue;
 }
 
-type TOIMComputedContentSlot<TValue = unknown> = TOIMSlot & Readonly<TOIMDerivation> & {
+type TOIMComputedContentSlot<TValue = unknown, TSourceTracker extends OIMSourceTracker | undefined = undefined> = TOIMSlot & Readonly<TOIMComputedDerivation> & {
     readonly owner: IOIMSlotOwner;
     readonly computedValueService: IOIMComputedValueService<TValue>;
     readonly value: TValue;
@@ -37,14 +58,12 @@ type TOIMComputedContentSlot<TValue = unknown> = TOIMSlot & Readonly<TOIMDerivat
     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 TOIMComputedContentSlot[];
-};
-
-type TOIMDerivation = TOIMComputedSources & {
+    readonly sourceComputeds: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker | undefined>[];
     ranAtRevision: number;
     ranAtEpoch: number;
 };
@@ -63,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 = {
@@ -87,7 +106,7 @@ type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch =
     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;
@@ -233,7 +252,7 @@ type TOIMChannelSlot = TOIMFlushSchedulerSlot & {
     dropped: boolean;
 };
 
-type TOIMEffect = TOIMDerivation & {
+type TOIMEffect = TOIMComputedDerivation & {
     readonly effectService: IOIMEffectService;
     readonly channelSlot: TOIMChannelSlot;
     readonly allRootSlots: readonly TOIMSlot[];
@@ -242,6 +261,7 @@ type TOIMEffect = TOIMDerivation & {
     effectFlags: number;
     readonly body: TOIMEffectBody;
     cleanup: (() => void) | undefined;
+    readonly sourceTracker: OIMSourceTracker | undefined;
 };
 
 type TOIMSlot = {
@@ -255,7 +275,7 @@ type TOIMSlot = {
     readonly releaseDueAfterUnholdMs: number;
     readonly slotFlags: number;
     readonly columnSlotStore: unknown;
-    readonly storeSlot: TOIMStoreSlot | undefined;
+    readonly storeSlot: TOIMStoreSlot;
     readonly owner: IOIMSlotOwner;
 };
 
@@ -309,7 +329,7 @@ type TOIMColumnSlot = TOIMSlot & {
     readonly key: string;
 };
 
-type TOIMComputedSlot<TValue = unknown, TKey extends NonNullable<unknown> = NonNullable<unknown>> = TOIMComputedContentSlot<TValue> & TOIMIndexableSlot<TKey>;
+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>;
 
@@ -335,7 +355,7 @@ 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: (slotEditable: TOIMSlotEditable<TOIMSlot>) => void): void;
+    unsafeMutateSlot(slot: TOIMSlot, mutateSlot: (editableSlot: TOIMEditable<TOIMSlot>) => void): void;
     onSlotFirstSubscribed(_slot: TOIMSlot): void;
     onSlotLastUnsubscribed(_slot: TOIMSlot): void;
     protected onSlotIdle(_slot: TOIMSlot): void;
@@ -395,7 +415,7 @@ declare class OIMPullColumnSlotOwner extends OIMColumnSlotOwner<TOIMComputedCont
 }
 
 interface IOIMSlotStamp<TSlot> {
-    stamp(slotEditable: TOIMSlotEditable<TSlot>): void;
+    stamp(editableSlot: TOIMEditable<TSlot>): void;
 }
 
 type TOIMOrderedListCommand = {
@@ -506,59 +526,55 @@ 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: TOIMComputedContentSlot<TValue>): TValue;
-    openSourceTracking(): void;
-    closeSourceTracking(): boolean;
-    getTrackedSourceSlots(): readonly TOIMSlot[];
-    getTrackedSourceComputeds(): readonly TOIMComputedContentSlot[];
-    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 TOIMComputedContentSlot[], body: TOIMEffectBody): TOIMEffect;
-    subscribeEffect(channelMap: IOIMChannelMap, sourceSlots: readonly TOIMSlot[], sourceComputeds: readonly TOIMComputedContentSlot[], body: TOIMEffectBody): TOIMDisposer;
-    createEffectImmediate(channelMap: IOIMChannelMap, sourceSlots: readonly TOIMSlot[], sourceComputeds: readonly TOIMComputedContentSlot[], 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<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue>> = {
+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<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue> = TOIMComputedContentSlot<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;
+    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, TSlotOwnerService extends IOIMSlotOwner = IOIMSlotOwner> {
+interface IOIMSlotContentService<TSlot extends TOIMSlot> {
     isSlotEmpty(slot: TSlot): boolean;
-    releaseSlotContent(slot: TSlot, slotOwnerService: TSlotOwnerService): void;
+    releaseSlotContent(slot: TSlot): void;
     hasReference(slot: TSlot): boolean;
 }
 
@@ -570,26 +586,27 @@ interface IOIMSingleSlotCreator<TSlot extends TOIMSlot> {
     createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TSlot;
 }
 
-type TOIMSlotContentComputedServiceOptions<TValue, TComputedSlot extends TOIMComputedContentSlot<TValue>> = {
+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> = TOIMComputedContentSlot<TValue>> implements IOIMSlotContentService<TComputedSlot>, IOIMKeyedSlotCreator<NonNullable<unknown>, TOIMComputedSlot<TValue>>, IOIMSingleSlotCreator<TOIMComputedContentSlot<TValue>> {
+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 & TOIMComputedSlot<TValue, TKey>;
-    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMComputedContentSlot<TValue>;
+    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;
-    private attachSources;
+    protected createSourceTracker(): OIMSourceTracker | undefined;
+    protected attachSources(computedSlot: TComputedSlot, storeSlot: TOIMStoreSlot): void;
 }
 
-declare function oimRefreshSourceComputeds(sourceComputeds: readonly TOIMComputedContentSlot[]): void;
+declare function oimRefreshSourceComputeds(sourceComputeds: readonly TOIMComputedContentSlot<unknown, OIMSourceTracker | undefined>[]): void;
 
 interface IOIMSlotReleasePolicy {
     readonly releasesWrittenSlots: boolean;
@@ -602,12 +619,12 @@ interface IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-type TOIMSlotOwnerServiceOptions<TSlot extends TOIMSlot, TStore, TColumnName extends string, TColumnSlot extends TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<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;
     slotSubscriptionListener?: IOIMSlotSubscriptionListener | undefined;
     slotFilingService: IOIMSlotFilingService<TSlot, TStore>;
-    slotContentService: IOIMSlotContentService<TSlot, OIMSlotOwnerService<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>>;
+    slotContentService: IOIMSlotContentService<TSlot>;
     columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TColumnSlot, TColumnName>;
     createColumnSlotOwner: (columnSlotOwnerOptions: TOIMColumnSlotOwnerOptions<TColumnSlot, TColumnName>) => TColumnSlotOwner;
 };
@@ -622,7 +639,7 @@ declare class OIMSlotOwnerService<TSlot extends TOIMSlot, TStore, TColumnName ex
     readonly settlesWrittenSlots: boolean;
     private readonly slotSubscriptionListener;
     readonly columnSlotOwner: TColumnSlotOwner;
-    constructor(options: TOIMSlotOwnerServiceOptions<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>);
+    constructor(options: TOIMSlotOwnerServiceOptions<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner>);
     isSlotEmpty(slot: TSlot): boolean;
     hasColumnSlots(slot: TOIMSlot): boolean;
     hasContentChangeListeners(slot: TOIMSlot): boolean;
@@ -654,10 +671,10 @@ interface IOIMSlotContentWriter<TSlot extends TOIMSlot, TContent> {
     clearSlotContent(slot: TSlot): void;
 }
 
-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;
+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;
@@ -706,12 +723,28 @@ declare class OIMColumnSlotService<TSlot extends TOIMSlot, TColumnName extends s
     unholdColumn(columnSlot: TColumnSlot): void;
 }
 
-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>, TPatch = unknown> = Omit<TOIMSlotOwnerServiceOptions<TSlot, TStore, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>, 'slotFilingService' | 'slotContentService'> & {
+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 & IOIMSlotContentService<TSlot> & IOIMKeyedSlotCreator<TKey, TSlot>;
     storeSlotListener?: IOIMStoreSlotListener | undefined;
 };
 
+declare class OIMSlotCollectionStoreAggregate<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey>, TStore, TPatch, TSlotService extends OIMSlotCollectionService<TKey, TSlot, TStore, unknown>> {
+    readonly slotService: TSlotService;
+    readonly storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch, TSlotService>;
+    constructor(slotService: TSlotService, storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch, TSlotService>);
+    get slotContentService(): TSlotService['slotContentService'];
+    findSlotByKey(key: TKey): TSlot | undefined;
+    hasSlotContentByKey(key: TKey): boolean;
+    getSlotByKey(key: TKey): TSlot;
+    holdSlotByKey(key: TKey): TSlot;
+    getSlots(): IterableIterator<TSlot>;
+    getSlotCount(): number;
+    openBatch(): void;
+    closeBatch(): void;
+    writeInBatch<TResult>(write: () => TResult): TResult;
+}
+
 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;
     readonly columnSlotService: OIMColumnSlotService<TSlot, TColumnName, TColumnSlot, TColumnSlotOwner>;
@@ -719,11 +752,12 @@ declare class OIMSlotCollectionService<TKey extends NonNullable<unknown>, TSlot
     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, TColumnSlotOwner, TPatch>);
+    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 createStoreSlotWith<TStoreSlot extends TOIMStoreSlot<TStore, TSlot, TPatch>>(createStoreSlotLiteral: (store: TStore) => TStoreSlot): TStoreSlot;
+    createStoreAggregate(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch, this>): OIMSlotCollectionStoreAggregate<TKey, TSlot, TStore, 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;
@@ -738,7 +772,12 @@ declare class OIMSlotCollectionService<TKey extends NonNullable<unknown>, TSlot
     private mintSlotByKey;
 }
 
+declare class OIMWritableSlotCollectionStoreAggregate<TKey extends NonNullable<unknown>, TSlot extends TOIMKeyedSlot<TKey>, TStore, TContent, TPatch, TSlotService extends OIMWritableSlotCollectionService<TKey, TSlot, TStore, TContent, IOIMSlotContentWriter<TSlot, TContent> & IOIMSlotContentService<TSlot> & IOIMKeyedSlotCreator<TKey, TSlot>>> extends OIMSlotCollectionStoreAggregate<TKey, TSlot, TStore, TPatch, TSlotService> {
+    writeSlotContentByKey(key: TKey, content: TContent, changedSlots?: TSlot[]): TSlot;
+}
+
 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> {
+    createStoreAggregate(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch, this>): OIMWritableSlotCollectionStoreAggregate<TKey, TSlot, TStore, TContent, TPatch, this>;
     writeSlotContentByKey(storeSlot: TOIMStoreSlot<TStore, TSlot, TPatch>, key: TKey, content: TContent, changedSlots?: TSlot[]): TSlot;
 }
 
@@ -752,12 +791,23 @@ declare class OIMSingleSlotStoreService<TSlot extends TOIMSlot> implements IOIMS
     getSlotCount(store: TOIMSingleSlotStore<TSlot>): number;
 }
 
-type TOIMSingleSlotServiceOptions<TSlot extends TOIMSlot, TSlotContentService, TColumnName extends string = string, TColumnSlot extends TOIMKeyedSlot<string> = TOIMKeyedSlot<string>, TColumnSlotOwner extends OIMColumnSlotOwner<TOIMSlot, TColumnSlot> = OIMColumnSlotOwner<TOIMSlot, TColumnSlot>, TPatch = unknown> = Omit<TOIMSlotOwnerServiceOptions<TSlot, TOIMSingleSlotStore<TSlot>, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>, 'slotFilingService' | 'slotContentService'> & {
+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 OIMSingleSlotStoreAggregate<TSlot extends TOIMSlot, TPatch, TSlotService extends OIMSingleSlotService<TSlot, unknown>> {
+    readonly slotService: TSlotService;
+    readonly storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, TSlotService>;
+    constructor(slotService: TSlotService, storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, TSlotService>);
+    get slotContentService(): TSlotService['slotContentService'];
+    findSingleSlot(): TSlot | undefined;
+    hasSingleSlotContent(): boolean;
+    getSingleSlot(): TSlot;
+    holdSingleSlot(): TSlot;
+}
+
 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;
     readonly columnSlotService: OIMColumnSlotService<TSlot, TColumnName, TColumnSlot, TColumnSlotOwner>;
@@ -765,9 +815,10 @@ declare class OIMSingleSlotService<TSlot extends TOIMSlot, TSlotContentService,
     protected readonly slotStoreService: OIMSingleSlotStoreService<TSlot>;
     protected readonly singleSlotCreator: IOIMSingleSlotCreator<TSlot>;
     private readonly storeSlotListener;
-    constructor(options: TOIMSingleSlotServiceOptions<TSlot, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner, TPatch>);
+    constructor(options: TOIMSingleSlotServiceOptions<TSlot, TSlotContentService, TColumnName, TColumnSlot, TColumnSlotOwner>);
     get slotOwner(): IOIMSlotOwner;
     createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, this>;
+    createStoreAggregate(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, this>): OIMSingleSlotStoreAggregate<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;
@@ -775,7 +826,13 @@ declare class OIMSingleSlotService<TSlot extends TOIMSlot, TSlotContentService,
     private mintSingleSlot;
 }
 
+declare class OIMWritableSingleSlotStoreAggregate<TSlot extends TOIMSlot, TContent, TPatch, TSlotService extends OIMWritableSingleSlotService<TSlot, TContent, IOIMSlotContentWriter<TSlot, TContent> & IOIMSlotContentService<TSlot> & IOIMSingleSlotCreator<TSlot>>> extends OIMSingleSlotStoreAggregate<TSlot, TPatch, TSlotService> {
+    writeSingleSlotContent(content: TContent, changedSlots?: TSlot[]): TSlot;
+    clearSingleSlotContent(): void;
+}
+
 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> {
+    createStoreAggregate(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, this>): OIMWritableSingleSlotStoreAggregate<TSlot, TContent, TPatch, this>;
     writeSingleSlotContent(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>, content: TContent, changedSlots?: TSlot[]): TSlot;
     clearSingleSlotContent(storeSlot: TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>): void;
 }
@@ -807,6 +864,7 @@ declare class OIMSlotContentEntityService<TEntity extends object, TKey extends N
     private writeSlotToChannelAndReleaseIfUnheld;
     private dispatchContentChangeAndReleaseIfUnheld;
     releaseSlotContent(entitySlot: TOIMEntityContentSlot<TEntity>): void;
+    private clearEntityAndMarkColumns;
     private isOnFastPath;
     private hasChangedColumnReaders;
     private updateEntitySlotEmptiness;
@@ -814,6 +872,20 @@ declare class OIMSlotContentEntityService<TEntity extends object, TKey extends N
     private dispatchColumnsChanged;
 }
 
+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;
+
+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;
     allocatePosition(positions: TOIMIndexKeysPositions): number;
@@ -822,45 +894,32 @@ 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 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;
-
-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>>;
-
-declare function createOIMSlotCollectionService<TSlotContentService extends object, TStore = Map<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>>, TColumnName extends string = string>(db: OIMDB, options: {
+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;
@@ -876,7 +935,8 @@ type TOIMSlotContentServiceSingleSlot<TSlotContentService> = TSlotContentService
     createSingleSlot(...args: never[]): infer TSlot;
 } ? Extract<TSlot, TOIMSlot> : never;
 
-declare function createOIMSingleSlotService<TSlotContentService extends object, TColumnName extends string = string>(db: OIMDB, options: {
+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;
@@ -884,7 +944,12 @@ declare function createOIMSingleSlotService<TSlotContentService extends object,
     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 createOIMSlotContentEntityService<TEntity extends object, TKey extends NonNullable<unknown> = TOIMStoreKey, TColumnName extends TOIMEntityColumnName<TEntity> = TOIMEntityColumnName<TEntity>>(db: OIMDB, options?: {
+declare function createOIMSlotCollectionStoreAggregate<TSlotContentService extends object, TStore = Map<TOIMSlotContentServiceKey<TSlotContentService>, TOIMSlotContentServiceSlot<TSlotContentService>>, TColumnName extends string = string>(channelMap: IOIMChannelMap, options: Parameters<typeof createOIMSlotCollectionService<TSlotContentService, TStore, TColumnName>>[0]): ReturnType<ReturnType<typeof createOIMSlotCollectionService<TSlotContentService, TStore, TColumnName>>['createStoreAggregate']>;
+
+declare function createOIMSingleSlotStoreAggregate<TSlotContentService extends object, TColumnName extends string = string>(channelMap: IOIMChannelMap, options: Parameters<typeof createOIMSingleSlotService<TSlotContentService, TColumnName>>[0]): ReturnType<ReturnType<typeof createOIMSingleSlotService<TSlotContentService, TColumnName>>['createStoreAggregate']>;
+
+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>;
@@ -896,13 +961,11 @@ interface IOIMBucketCommands {
     recordWholeList(bucketSlot: TOIMBucketContentSlot<unknown>): void;
 }
 
-type TOIMBucketSlotOwnerService<TSlots, TBucketMemberSlot extends TOIMSlot = TOIMSlot, TBucketSlot extends TOIMBucketContentSlot<TSlots> = TOIMBucketContentSlot<TSlots>, TStore = unknown> = OIMSlotOwnerService<TBucketSlot, TStore, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TBucketMemberSlot[]>;
-
 type TOIMSlotContentBucketServiceOptions = {
     bucketCommands?: IOIMBucketCommands | undefined;
 };
 
-declare abstract class OIMSlotContentBucketService<TBucketMemberSlot extends TOIMSlot, TSlots, TKey extends NonNullable<unknown> = TOIMStoreKey> implements IOIMSlotContentService<TOIMBucketContentSlot<TSlots>, TOIMBucketSlotOwnerService<TSlots>>, IOIMKeyedSlotCreator<TKey, TOIMBucketSlot<TSlots, TKey>>, IOIMSingleSlotCreator<TOIMBucketContentSlot<TSlots>>, IOIMSlotContentWriter<TOIMBucketContentSlot<TSlots>, readonly TBucketMemberSlot[]> {
+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;
     protected constructor(options: TOIMSlotContentBucketServiceOptions);
     protected abstract createBucketMemberSlotsStore(): TSlots;
@@ -919,7 +982,7 @@ declare abstract class OIMSlotContentBucketService<TBucketMemberSlot extends TOI
     createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TOIMBucketContentSlot<TSlots>;
     isSlotEmpty(bucketSlot: TOIMBucketContentSlot<TSlots>): boolean;
     hasReference(): boolean;
-    releaseSlotContent(bucketSlot: TOIMBucketContentSlot<TSlots>, slotOwnerService: TOIMBucketSlotOwnerService<TSlots>): void;
+    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;
@@ -1049,27 +1112,29 @@ declare class OIMSlotContentSortedArrayBucketService<TBucketMemberSlot extends T
     repositionBucketMemberSlot(bucketSlot: TOIMBucketContentSlot<TOIMBucketSlotsArrayStore<TBucketMemberSlot>>, bucketMemberSlot: TBucketMemberSlot): void;
 }
 
-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<OIMScalarKeyTreeWalk>;
-    static readonly KEY_TREE_WALK_COMPOSITE: OIMDefaultValue<OIMCompositeKeyTreeWalk>;
-    static readonly STANDALONE_SLOT_OWNER: OIMDefaultValue<OIMSlotOwner>;
-    static readonly ENTITY_WRITER: OIMDefaultValue<IOIMEntityWriter>;
-    static readonly ENTITY_SLOT_EMPTINESS: OIMDefaultValue<IOIMSlotEmptinessPolicy<TOIMEntityContentSlot>>;
-    static readonly INDEX_KEYS_SERVICE: OIMDefaultValue<IOIMIndexKeysService>;
-    static readonly STORE_SLOT_LISTENER: OIMDefaultValue<IOIMStoreSlotListener>;
+type TOIMBucketSlotOwnerService<TSlots, TBucketMemberSlot extends TOIMSlot = TOIMSlot, TBucketSlot extends TOIMBucketContentSlot<TSlots> = TOIMBucketContentSlot<TSlots>, TStore = unknown> = OIMSlotOwnerService<TBucketSlot, TStore, string, TOIMColumnSlot, OIMPushColumnSlotOwner, readonly TBucketMemberSlot[]>;
+
+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;
 }
 
 declare class OIMFlushSchedulerService {
@@ -1079,7 +1144,7 @@ declare class OIMFlushSchedulerService {
     cancelSchedule(flushSchedulerSlot: TOIMFlushSchedulerSlot): void;
 }
 
-type TOIMComputedStoreSlot<TStore = unknown, TValue = unknown, TComputedSlot extends TOIMComputedContentSlot<TValue> = TOIMComputedContentSlot<TValue>> = TOIMStoreSlot<TStore, TComputedSlot> & {
+type TOIMComputedStoreSlot<TStore = unknown, TValue = unknown, TComputedSlot extends TOIMComputedContentSlot<TValue, OIMSourceTracker | undefined> = TOIMComputedContentSlot<TValue>, TSlotService = unknown> = TOIMStoreSlot<TStore, TComputedSlot, unknown, TSlotService> & {
     readonly derive: ((computedSlot: TComputedSlot) => TValue) | undefined;
     readonly createSources: ((computedSlot: TComputedSlot) => Partial<TOIMComputedSources>) | undefined;
 };
@@ -1091,6 +1156,7 @@ type TOIMComputedDerivationOptions<TValue, TComputedSlot extends TOIMComputedCon
     createSources?: ((computedSlot: TComputedSlot) => Partial<TOIMComputedSources>) | undefined;
     derive?: ((computedSlot: TComputedSlot) => TValue) | undefined;
     sameValueGuard?: TOIMSameValueGuard<TValue> | undefined;
+    releaseValue?: TOIMComputedValueReleaser<TValue> | undefined;
     initialValue?: TValue | undefined;
 };
 
@@ -1103,17 +1169,22 @@ declare class OIMComputedService<TKey extends NonNullable<unknown>, TValue, TCom
     private readonly hasDerive;
     private readonly hasCreateSources;
     constructor(options: TOIMComputedServiceOptions<TKey, TValue, TComputedStore>);
-    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TComputedStore, TValue, TOIMComputedSlot<TValue, TKey>>;
+    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TComputedStore, TValue, TOIMComputedSlot<TValue, TKey>, this['computedCollectionService']>;
 }
 
-declare function createOIMComputedService<TKey extends NonNullable<unknown>, TValue, TComputedStore = Map<TKey, TOIMComputedSlot<TValue, TKey>>>(options: {
-    createSources?: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => 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;
+};
+
+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;
 }): OIMComputedService<TKey, TValue, TComputedStore>;
 
@@ -1122,38 +1193,89 @@ declare class OIMSingleComputedService<TValue> {
     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>;
+    createComputedStoreSlot(channelMap: IOIMChannelMap, derive?: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources?: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined): TOIMComputedStoreSlot<TOIMSingleSlotStore<TOIMComputedContentSlot<TValue>>, TValue, TOIMComputedContentSlot<TValue>, this['computedSingleSlotService']>;
 }
 
-declare function createOIMSingleComputedService<TValue>(options?: {
+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 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;
-    slotReleasePolicy?: IOIMSlotReleasePolicy | undefined;
-    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot> | undefined;
-    columnNames?: readonly Extract<keyof TValue, string>[] | undefined;
-}): OIMSingleComputedService<TValue>;
+};
+
+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>, unknown, this['computedCollectionService']>;
+}
+
+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>, unknown, this['computedSingleSlotService']>;
+}
+
+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 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, 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 OIMSlotCollectionIndexStoreAggregate<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore, TBucketSlot extends TOIMBucketSlot<TSlots, TKey>, TStore, TSlotService extends OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots, TKey>, TBucketSlot, TStore>> extends OIMSlotCollectionStoreAggregate<TKey, TBucketSlot, TStore, readonly TOIMEntitySlot<TEntity>[], TSlotService> {
+    readonly storeSlot: TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore, TSlotService>;
+    getEntitiesByKey(key: TKey): (TEntity | undefined)[];
+    getSlotsByKeys(keys: readonly TKey[]): TBucketSlot[];
+    holdSlotsByKeys(keys: readonly TKey[]): TBucketSlot[];
+    getAnyBucketColumnByKey(key: TKey): TOIMColumnSlot;
+    holdAnyBucketColumnByKey(key: TKey): TOIMColumnSlot;
+    getBucketColumnByKey(key: TKey, columnName: string): TOIMColumnSlot;
+    holdBucketColumnByKey(key: TKey, columnName: string): TOIMColumnSlot;
+    disposeIndexStoreSlot(): void;
+}
+
 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;
@@ -1162,6 +1284,7 @@ declare class OIMSlotCollectionIndexService<TKey extends NonNullable<unknown>, T
     private readonly indexKeysService;
     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>;
+    createStoreAggregate(indexStoreSlot: TOIMIndexStoreSlot<TStore, TBucketSlot, readonly TOIMEntitySlot<TEntity>[], TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>, TKey, TSourceStore, this>): OIMSlotCollectionIndexStoreAggregate<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TBucketSlot, TStore, 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;
@@ -1187,7 +1310,7 @@ declare class OIMSlotCollectionIndexService<TKey extends NonNullable<unknown>, T
     private groupUnderMintedBucketKey;
     private decideIndexKeyForSlot;
     private collectSourceSlotsForKey;
-    private setIndexKeyForSlots;
+    private fillBucketSlotWithSourceSlots;
 }
 
 type TOIMSlotCollectionIndexServiceStoreSlot<TKey extends NonNullable<unknown>, TEntity extends object, TSlots, TSourceKey extends NonNullable<unknown>, TSourceStore> = Parameters<OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>['getBucketColumnByKey']>[0];
@@ -1197,7 +1320,7 @@ type TOIMSortableColumnName<TEntity extends object> = {
 }[keyof TEntity] & string;
 
 type TOIMSortColumn<TEntity extends object> = {
-    column: TOIMSortableColumnName<TEntity>;
+    columnName: TOIMSortableColumnName<TEntity>;
     direction: 'asc' | 'desc';
 };
 
@@ -1214,12 +1337,13 @@ type TOIMSortedComputedServiceOptions<TKey extends NonNullable<unknown>, TEntity
 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>>;
+    createSortedStoreSlot(indexStoreSlot: TOIMSlotCollectionIndexServiceStoreSlot<TKey, TEntity, TSlots, TSourceKey, TSourceStore>): TOIMStoreSlot<TComputedStore, TOIMSortedComputedSlot<TEntity, TKey>, unknown, this['computedCollectionService']>;
 }
 
 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;
@@ -1241,10 +1365,11 @@ type TOIMBucketMemoComputedSlot<TBucketMemberSlot extends TOIMSlot, TKey extends
 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>>;
+    createBucketMemoStoreSlot(bucketStoreSlot: TOIMStoreSlot<TBucketStore, TOIMBucketSlot<TSlots, TKey>, readonly TBucketMemberSlot[]>): TOIMStoreSlot<TComputedStore, TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>, unknown, this['computedCollectionService']>;
 }
 
 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;
@@ -1277,6 +1402,7 @@ declare class OIMSlotCollectionSortedArrayIndexService<TKey extends NonNullable<
 
 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;
@@ -1295,16 +1421,16 @@ type TOIMIndexKeyOptions<TKey, TEntity extends object, TColumns extends readonly
     columns: [TKey] extends [never] ? never : [TKey] extends [TOIMIndexKey<TEntity, TColumns>] ? TColumns : never;
 };
 
-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>>(db: OIMDB, options: TOIMSlotCollectionIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
+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>): 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>>>(db: OIMDB, options: TOIMSlotCollectionIndexServiceFactoryOptions<TEntity, TSourceKey, TSourceStore> & {
+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>): OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, TOIMBucketSlot<TSlots, TKey>, TStore>;
 
-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>>>(db: OIMDB, options: TOIMSlotCollectionIndexServiceFactoryOptions<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<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore> | undefined;
 } & TOIMIndexKeyOptions<TKey, TEntity, TColumns>): OIMSlotCollectionSortedArrayIndexService<TKey, TEntity, TSourceKey, TSourceStore, TOIMBucketSlot<TOIMBucketSlotsArrayStore<TOIMEntitySlot<TEntity>>, TKey>, TStore>;
@@ -1350,9 +1476,9 @@ type TOIMEntityWriterOptions = {
     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: TOIMEntityContentSlot<TEntity>, entity: TEntity): void;
 
@@ -1360,11 +1486,11 @@ declare function oimInsertEntityWithCopy<TEntity extends object>(slot: TOIMEntit
 
 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 function oimMintAfterWriteSlotReleaseWheel(collectorSlot: TOIMCollectorSlot): OIMSlotReleaseWheel;
 
@@ -1540,7 +1666,7 @@ interface IOIMKeyTreeWalk<TCompositeKeyPart> {
 }
 
 type TOIMSlotStoreTree<TSlot, TCompositeKeyPart> = {
-    readonly root: TOIMCompositeKeyNode<TSlot, TCompositeKeyPart>;
+    readonly rootCompositeKeyNode: TOIMCompositeKeyNode<TSlot, TCompositeKeyPart>;
     readonly slots: Set<TSlot>;
 };
 
@@ -1589,4 +1715,4 @@ declare const OIM_REMOVED_WITHOUT_A_POSITION = -2;
 
 declare function oimOrderedListCommandsOfTransition(prev: readonly TOIMSlot[], next: readonly TOIMSlot[], maxCommandsPerSlot?: number): TOIMOrderedListCommand[];
 
-export { type IOIMBucketCommands, type IOIMBucketMemberSlotsArrayService, type IOIMChannelMap, type IOIMComputedValueService, type IOIMContentChangeListener, type IOIMEffectService, type IOIMEntityWriter, type IOIMErrorPolicy, type IOIMFlushSchedulerListener, type IOIMIndexKeysService, type IOIMKeyTreeWalk, type IOIMKeyedSlotCreator, type IOIMSingleSlotCreator, 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, OIMContentChangeListenerService, OIMDB, OIMDefaultValue, OIMDefaults, OIMEffectService, type OIMEffectSourceTracker, OIMFlushSchedulerService, OIMIndexKeysService, OIMKeyTreeWalk, OIMLogAndContinueErrorPolicy, OIMNoSlotSubscriptionListener, OIMNoStoreSlotListener, OIMPullColumnSlotOwner, type OIMPushColumnSlotOwner, OIMReclaimingIndexKeysService, OIMScalarKeyTreeWalk, OIMSingleComputedService, OIMSingleSlotService, OIMSingleSlotStoreService, OIMSlotAfterIdleReleasePolicy, OIMSlotAfterUnholdReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotAtEmptyReleasePolicy, OIMSlotAtUnholdReleasePolicy, OIMSlotCollectionIndexService, OIMSlotCollectionService, OIMSlotCollectionSortedArrayIndexService, OIMSlotContentArrayBucketService, OIMSlotContentBucketService, type OIMSlotContentComputedService, OIMSlotContentEntityService, OIMSlotContentPositionalArrayBucketService, OIMSlotContentSetBucketService, OIMSlotContentSortedArrayBucketService, OIMSlotEarliestReleasePolicy, OIMSlotMapStoreService, OIMSlotNeverReleasePolicy, OIMSlotOwner, type OIMSlotOwnerService, OIMSlotRefetchWheel, OIMSlotReleaseAutoDueFramePolicy, OIMSlotReleaseManualDueFramePolicy, OIMSlotReleaseWheel, OIMSlotTreeStoreService, OIMSlotWheel, OIMSortedComputedService, OIMThrowAtOnceErrorPolicy, OIMUnusedSlotCollectorService, OIMWritableSingleSlotService, OIMWritableSlotCollectionService, OIM_FROZEN_EMPTY_SLOTS, OIM_NOTHING_WAS_INSERTED, OIM_NOTHING_WAS_REMOVED, OIM_REMOVED_WITHOUT_A_POSITION, OIM_SLICE_LENGTH_MS, 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 TOIMComputedDerivationOptions, type TOIMComputedServiceOptions, 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 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 TOIMSlotEditable, type TOIMSlotOwnerServiceOptions, type TOIMSlotRefetchWheelOptions, type TOIMSlotReleaseWheelOptions, type TOIMSlotStoreTree, type TOIMSlotWheelOptions, type TOIMSortColumn, type TOIMSortableColumnName, type TOIMSortedComputedServiceOptions, type TOIMSortedComputedSlot, type TOIMStoreKey, type TOIMStoreSlot, type TOIMTimer, type TOIMUnusedSlotCollectorSlot, createOIMBucketMemoComputedService, createOIMChannelSlot, createOIMCollectorSlot, createOIMComputedService, createOIMEntityWriterInPlace, createOIMEntityWriterReplacing, createOIMSingleComputedService, createOIMSingleSlotService, createOIMSlotCollectionIndexService, createOIMSlotCollectionService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotContentEntityService, createOIMSortedComputedService, createOIMUnusedSlotCollectorSlot, oimColumnsComparator, oimHoldSlots, oimInsertEntityWithCopy, oimInsertEntityWithSanitizedCopy, oimInsertEntityWithoutCopy, oimIsAnySlotChangedAfter, oimIsSlotEmpty, oimIsSlotReleased, oimMintAfterIdleSlotReleaseWheel, oimMintAfterUnholdSlotReleaseWheel, oimMintAfterWriteSlotReleaseWheel, 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, OIMSingleSlotStoreAggregate, OIMSingleSlotStoreService, OIMSingleSourceTrackingComputedService, OIMSlotAfterIdleReleasePolicy, OIMSlotAfterUnholdReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotAtEmptyReleasePolicy, OIMSlotAtUnholdReleasePolicy, OIMSlotCollectionIndexService, OIMSlotCollectionIndexStoreAggregate, OIMSlotCollectionService, OIMSlotCollectionSortedArrayIndexService, OIMSlotCollectionStoreAggregate, 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, OIMWritableSingleSlotStoreAggregate, OIMWritableSlotCollectionService, OIMWritableSlotCollectionStoreAggregate, 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, createOIMSingleSlotStoreAggregate, createOIMSingleSourceTrackingComputedService, createOIMSlotCollectionIndexService, createOIMSlotCollectionService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotCollectionStoreAggregate, 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 };