@oimdb/core 4.1.0 → 4.3.0

package/README.md

@@ -60,9 +60,9 @@ still on CommonJS, which is why both are here.
 throws.** `src/index.ts` registers its copy under `Symbol.for('@oimdb/core')` on
 `globalThis`, and a second copy that finds another one there throws
 `@oimdb/core is loaded twice in this process`. Without this check the split would be silent:
-each copy keeps its own `OIMDefaults`, so a default set through one
-(`OIMDefaults.ENTITY_WRITER.setValue(createOIMEntityWriterReplacing())`) never reaches a
-service built by the other, which keeps writing in place. Objects built by
+each copy keeps its own built-in defaults and its own `OIMDefaults` class, so an `OIMDefaults` built
+with one copy's class is a stranger to the other copy's factories, and two services built by the two copies
+share no default instance. Objects built by
 either copy carry their own methods, so a channel, a service and an effect
 from different copies still deliver to each other; only the defaults diverge.
 
@@ -75,7 +75,7 @@ first sentence on its own points at the one thing that is not wrong.
 
 The mechanism is one line: a runtime loads a package once per format, so
 `import` in one file and `require` in another holds two complete copies of every
-class and every module-level value, such as the `OIMDefaults` statics or a React context.
+class and every module-level value, such as `OIMDefaults.INSTANCE` or a React context.
 
 The rule is one line too: pick `import` or `require` for `@oimdb/core`, and use the
 same one everywhere in the process, including inside every `@oimdb` package
@@ -90,24 +90,36 @@ What each consumer ships, bundled with esbuild (minified, tree-shaken, ESM).
 <!-- bundle-size:begin -->
 | Consumer | Minified | Minified + gzip |
 |---|---:|---:|
-| Everything `@oimdb/core` exports | 98686 B | 24049 B |
-| One entity store slot: `OIMDB`, `createOIMSlotCollectionService`, `createOIMSlotContentEntityService`, `writeSlotContentByKey`, `getSlotByKey` | 35379 B | 9243 B |
-| The same, plus one effect and `db.flush()` | 44020 B | 11357 B |
-| The same, plus one index: `createOIMSlotCollectionIndexService` | 64398 B | 16048 B |
-| An ordered bucket with commands: `OIMSlotContentPositionalArrayBucketService`, `OIMBucketCommands` | 48515 B | 12218 B |
+| Everything `@oimdb/core` exports | 105563 B | 25051 B |
+| One entity store slot: `OIMDB`, `createOIMSlotCollectionService`, `createOIMSlotContentEntityService`, `writeSlotContentByKey`, `getSlotByKey` | 36382 B | 9314 B |
+| The same, plus one effect and `db.flush()` | 46546 B | 11711 B |
+| The same, plus one index: `createOIMSlotCollectionIndexService` | 67554 B | 16458 B |
+| An ordered bucket with commands: `OIMSlotContentPositionalArrayBucketService`, `OIMBucketCommands` | 49435 B | 12310 B |
 <!-- bundle-size:end -->
 
 ---
 
-## The three layers
+## The domains
 
-`src/index.ts` is the entire public surface, and it is divided in three:
+`src/` holds one folder per domain and `index.ts`, the entire public surface; a factory lives in
+the domain of what it builds. Where a file goes is in `packages/core/src/README.md`.
 
-| Layer | What is in it |
+| Domain | Contents |
 |---|---|
-| `src/engine/` | The primitives, each a stateless service over a plain struct: `OIMChannelService.INSTANCE` over a `TOIMChannelSlot` (frames, the revision), `OIMEffectService.INSTANCE` (effects, handed the `db` on every call), `OIMSlotOwnerService` (the owner of every slot a collection filed: holds, release, emptiness, columns), the column owners (abstract `OIMColumnSlotOwner`, `OIMPushColumnSlotOwner` written by the collection, `OIMPullColumnSlotOwner` derived by a computed), the content services (`OIMSlotContentEntityService` for entities, `OIMComputedValueService` for computeds), the key stores and key tree walks, the release policies, the unused-slot collector (`OIMUnusedSlotCollectorService`) over the collector slot, the wheels (`OIMSlotReleaseWheel`, `OIMSlotRefetchWheel`), `TOIMStoreSlot`, `TOIMComputedSlot`, `TOIMEffect`. |
-| `src/facade/` | What a caller holds. The collection services `OIMSlotCollectionService` (keyed) and `OIMSingleSlotService` (one slot, no key), each with its `slotContentService`; the bucket content services `OIMSlotContentSetBucketService`, `OIMSlotContentPositionalArrayBucketService`, `OIMSlotContentSortedArrayBucketService` and `OIMBucketCommands`; the auto-index `OIMSlotCollectionIndexService` and `OIMSlotCollectionSortedArrayIndexService`; `OIMComputedService`, `OIMSortedComputedService`, `OIMBucketMemoComputedService`. |
-| `src/factories/` | `OIMDB`, `OIMDefaults`, `OIMDefaultValue`, and the doors that build a service: the base ones, `createOIMSlotCollectionService`, `createOIMSingleSlotService` and `createOIMSlotContentEntityService`, and the convenience ones over them, `createOIMSlotCollectionService`, `createOIMSingleSlotService`, `createOIMSlotCollectionService`, `createOIMSingleSlotService`, `createOIMSlotCollectionIndexService`, `createOIMSlotCollectionSortedArrayIndexService`, `createOIMComputedService`, `createOIMSortedComputedService`, `createOIMBucketMemoComputedService`, `createOIMEntityWriterInPlace`, `createOIMEntityWriterReplacing`. |
+| `slot/` | `OIMSlotOwner`, `OIMSlotOwnerService` (type-only export), `OIMSlotCollectionService`, `OIMWritableSlotCollectionService`, `OIMSingleSlotService`, `OIMWritableSingleSlotService`, `OIMSlotContentChangeListenerService`, `createOIMSlotCollectionService`, `createOIMSingleSlotService`, the store aggregates and their factories, `TOIMSlot`, `TOIMEditable` |
+| `store/` | `TOIMStoreSlot`, the slot store services |
+| `channel/` | `OIMChannelService`, `TOIMChannelSlot` |
+| `effect/` | `OIMEffectService`, `TOIMEffect` |
+| `computed/` | `OIMComputedValueService`, `OIMComputedService`, `OIMSingleComputedService`, `OIMSortedComputedService`, `OIMBucketMemoComputedService`, the source-tracking computed services, their factories, `TOIMComputedSlot` |
+| `entity/` | `OIMSlotContentEntityService`, `createOIMSlotContentEntityService`, `createOIMInPlaceEntityWriter`, `createOIMReplacingEntityWriter` |
+| `column/` | abstract `OIMColumnSlotOwner` with `OIMPushColumnSlotOwner` and `OIMPullColumnSlotOwner`, `OIMColumnSlotService` |
+| `bucket/` | `OIMSlotContentBucketService` (abstract), `OIMSlotContentSetBucketService`, `OIMSlotContentArrayBucketService` (abstract), `OIMSlotContentPositionalArrayBucketService`, `OIMSlotContentSortedArrayBucketService`, `OIMBucketCommands` |
+| `index/` | `OIMSlotCollectionIndexService`, `OIMSlotCollectionSortedArrayIndexService`, their factories, `OIMSlotCollectionIndexStoreAggregate`, the index keys services |
+| `key/` | the key tree walks |
+| `collector/` | the release policies, `OIMSlotReleaseWheel`, `OIMSlotRefetchWheel`, `OIMUnusedSlotCollectorService` |
+| `schedule/` | `OIMFlushSchedulerService` |
+| `error/` | the error policies |
+| `db/` | `OIMDB`, `OIMDefaults`, `OIMDefaultValue`, the default constants |
 
 **A service holds no data; a store slot is one instance.** A service is built once per
 type, and `cardService.createStoreSlot(db)` returns a `TOIMStoreSlot`, a plain object whose
@@ -127,14 +139,14 @@ release, subscribe), never through the service.
 ## The shortest thing that delivers
 
 ```typescript setup
-import { OIMBucketCommands, OIMChannelService, OIMDB, OIMDefaults, OIMEffectService, OIMLogAndContinueErrorPolicy, OIMSlotContentPositionalArrayBucketService, OIMBucketUniqueMemberSlotsArrayService, OIMSlotContentSetBucketService, OIMSlotAfterIdleReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotEarliestReleasePolicy, createOIMSingleSlotService, createOIMSingleComputedService, OIMSlotMapStoreService, OIMSingleSlotStoreService, OIMSlotTreeStoreService, OIMUnusedSlotCollectorService, createOIMUnusedSlotCollectorSlot, oimInsertEntityWithCopy, oimIsSlotReleased, createOIMBucketMemoComputedService, createOIMComputedService, createOIMSortedComputedService, createOIMEntityWriterInPlace, createOIMSlotCollectionIndexService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotCollectionService, createOIMSlotContentEntityService, oimOrderedListCommandsOfTransition, oimSameSlotSequence, oimSameValueZeroGuard, type TOIMComputedSlot, type TOIMBucketSlotsArrayStore, type TOIMBucketSlot, type TOIMBucketSlotsSetStore, type TOIMDisposer, type TOIMEntityColumnName, type TOIMEntitySlot, type TOIMOrderedListCommand, type TOIMSingleSlotStore, type TOIMSlotStoreTree, type TOIMStoreKey } from '@oimdb/core';
+import { OIMBucketCommands, OIMChannelService, OIMDB, OIMDefaults, OIMEffectService, OIMLogAndContinueErrorPolicy, OIMSlotContentPositionalArrayBucketService, OIMBucketUniqueMemberSlotsArrayService, OIMSlotContentSetBucketService, OIMSlotAfterIdleReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotEarliestReleasePolicy, createOIMSingleSlotService, createOIMSingleComputedService, OIMSlotMapStoreService, OIMSingleSlotStoreService, OIMSlotTreeStoreService, OIMUnusedSlotCollectorService, createOIMUnusedSlotCollectorSlot, oimInsertEntityWithCopy, oimIsSlotReleased, createOIMBucketMemoComputedService, createOIMComputedService, createOIMSortedComputedService, createOIMInPlaceEntityWriter, createOIMSlotCollectionIndexService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotCollectionService, createOIMSlotContentEntityService, oimOrderedListCommandsOfTransition, oimSameSlotSequence, oimSameValueZeroGuard, type TOIMComputedSlot, type TOIMBucketSlotsArrayStore, type TOIMBucketSlot, type TOIMBucketSlotsSetStore, type TOIMDisposer, type TOIMEntityColumnName, type TOIMEntitySlot, type TOIMOrderedListCommand, type TOIMSingleSlotStore, type TOIMSlotStoreTree, type TOIMStoreKey, createOIMReplacingEntityWriter, OIMScalarKeyTreeWalk, OIMCompositeKeyTreeWalk } from '@oimdb/core';
 
 type Card = { id: string; deck: string; title: string; rank: number };
 type CardSlot = TOIMEntitySlot<Card>;
 
 const db = new OIMDB();
 const effectService = OIMEffectService.INSTANCE;
-const cardService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db) });
+const cardService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Card>() });
 const cards = cardService.createStoreSlot(db);
 const slot = cardService.getSlotByKey(cards, 'c1');
 const byRank = (leftBucketMemberSlot: TOIMEntitySlot<Card>, rightBucketMemberSlot: TOIMEntitySlot<Card>): number =>
@@ -145,9 +157,9 @@ const byRank = (leftBucketMemberSlot: TOIMEntitySlot<Card>, rightBucketMemberSlo
 cardService.writeSlotContentByKey(cards, 'c1', { id: 'c1', deck: 'spades', title: 'Ace', rank: 1 });
 
 let seen = '';
-const effect = effectService.createEffect(db, [slot], [], () => {
+const effect = effectService.createEffect(db, () => {
     seen = slot.entity?.title ?? '';
-});
+}, [slot]);
 
 cardService.slotContentService.updateEntity(slot, { title: 'Ace of Spades' });
 db.flush();         // seen === 'Ace of Spades'
@@ -157,9 +169,8 @@ effectService.disposeEffect(effect);
 
 `OIMDB` is the shared state and nothing else: one `clock` (`{ revision, epoch }`), one
 `defaultChannelSlot` (a `TOIMChannelSlot`, the struct a channel's state lives in), one
-`collectorSlot` (the unused-slot collector's slot and the release wheels, made on first use), and the
-`entityWriter`, `slotStamp`, `slotReleasePolicy` and `indexKeysService` its constructor is handed,
-which it keeps as the default that every door below reads. It is an `IOIMChannelMap`, so
+`collectorSlot` (the unused-slot collector's slot and the release wheels, made on first use). It holds
+no defaults: those are an `OIMDefaults` passed to each door as `defaults`. It is an `IOIMChannelMap`, so
 anything that takes a `channelMap` takes the `db`. `flush()` is
 `OIMChannelService.INSTANCE.flush(db.defaultChannelSlot)`: it runs the pending frame, then the
 unused-slot collector, then the after-each-flush handlers, in that order. It builds nothing.
@@ -183,8 +194,8 @@ Every mutation goes through a domain neuron. See
 [With cnstra](https://oimdb.org/docs/guides/with-cnstra).
 
 The doors are free functions, one module each, and each builds a **service**, once per
-type; an instance is the store slot that service creates. A collection, a single and an index take
-`db` first and ONE options object second. Every collection is `createOIMSlotCollectionService` over a content
+type; an instance is the store slot that service creates. Every door takes ONE options object and no
+`db`; the `db` goes to `createStoreSlot(db)`. Every collection is `createOIMSlotCollectionService` over a content
 service, and every single is `createOIMSingleSlotService`; an array key needs a tree store
 (`slotStoreService: new OIMSlotTreeStoreService(…)`, or `bucketSlotStoreService` on an index), because a
 map-driven store compares arrays by reference. See [The six shapes](#the-six-shapes). The computed doors
@@ -192,15 +203,15 @@ take no `db`: a computed reaches its channel through the store slot it derives f
 the `db` handed to `createComputedStoreSlot`.
 
 ```typescript signature
-createOIMSlotContentEntityService<Card, TKey?, TColumnName?>(db, { entityWriter?, slotEmptinessPolicy? }?)
+createOIMSlotContentEntityService<Card, TKey?, TColumnName?>({ entityWriter?, slotEmptinessPolicy? }?)
 new OIMSlotContentSetBucketService<TBucketMemberSlot, TKey?>({ bucketCommands? })
 new OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot, TKey?>({ bucketCommands?, bucketMemberSlotsArrayService? })
-createOIMSlotCollectionService(db, { slotContentService, slotStoreService?, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? | columnNames? })
-createOIMSingleSlotService(db, { slotContentService, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? | columnNames? })
-createOIMSlotCollectionIndexService(db, { entityService, columns | keyOf, slotContentService?, bucketSlotStoreService?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
-createOIMSlotCollectionSortedArrayIndexService(db, { entityService, sortColumns, columns | keyOf, bucketSlotStoreService?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
-createOIMComputedService<TKey, TValue, TComputedStore?>({ createSources?, derive?, sameValueGuard?, initialValue?, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService? | columnNames? })   // a non-Map store: computedSlotStoreService required
-createOIMSingleComputedService<TValue>({ createSources?, derive?, sameValueGuard?, initialValue?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
+createOIMSlotCollectionService({ slotContentService, slotStoreService?, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? | columnNames? })
+createOIMSingleSlotService({ slotContentService, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? | columnNames? })
+createOIMSlotCollectionIndexService({ entityService, columns | keyOf, slotContentService?, bucketSlotStoreService?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
+createOIMSlotCollectionSortedArrayIndexService({ entityService, sortColumns, columns | keyOf, bucketSlotStoreService?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
+createOIMComputedService<TKey, TValue, TComputedStore?>({ createSources?, derive?, sameValueGuard?, releaseValue?, initialValue?, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService? | columnNames? })   // a non-Map store: computedSlotStoreService required
+createOIMSingleComputedService<TValue>({ createSources?, derive?, sameValueGuard?, releaseValue?, initialValue?, slotReleasePolicy?, columnSlotStoreService? | columnNames? })
 createOIMSortedComputedService({ indexService, sortColumns?, comparator?, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService? })
 createOIMBucketMemoComputedService({ bucketCollectionService, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService? })
 
@@ -213,27 +224,68 @@ computedService.createComputedStoreSlot(db, derive?, createSources?)
 
 **The content service is where everything per type is fixed, once:** the entity writer and the emptiness rule.
 The collection service adds the store service, the release policy and the column options, and builds the slot
-owner from them and `db.slotStamp`. Build the content service first when it is shared:
+owner from them and `defaults.slotStamp`. Build the content service first when it is shared:
 
 ```typescript
-const cardContentService = createOIMSlotContentEntityService<Card>(db);
-const sameShapeCardService = createOIMSlotCollectionService(db, { slotContentService: cardContentService });
+const cardContentService = createOIMSlotContentEntityService<Card>();
+const sameShapeCardService = createOIMSlotCollectionService({ slotContentService: cardContentService });
 const sameShapeCards = sameShapeCardService.createStoreSlot(db);
 ```
 
+### A store aggregate: the store slot with its store methods
+
+A **store aggregate** is a store slot together with the methods of its service that take that
+store slot first, so a call no longer passes it. `service.createStoreAggregate(storeSlot)` wraps a
+store slot you already have; `createOIMSlotCollectionStoreAggregate(db, options)` and
+`createOIMSingleSlotStoreAggregate(db, options)` build the service, the store slot and the aggregate
+in one call, with the options of `createOIMSlotCollectionService` / `createOIMSingleSlotService`.
+
+```typescript
+import { createOIMSlotCollectionStoreAggregate, createOIMSingleSlotStoreAggregate } from '@oimdb/core';
+
+const deckStoreAggregate = createOIMSlotCollectionStoreAggregate(db, {
+    slotContentService: createOIMSlotContentEntityService<Card>(),
+});
+const aceSlot = deckStoreAggregate.writeSlotContentByKey('c9', { id: 'c9', deck: 'hearts', title: 'Ace', rank: 1 });
+deckStoreAggregate.slotContentService.updateEntity(aceSlot, { rank: 14 });
+deckStoreAggregate.getSlotByKey('c9') === aceSlot;   // true
+
+const cardStoreAggregate = cardService.createStoreAggregate(cards);
+cardStoreAggregate.storeSlot === cards;              // true: hooks, indexes and computeds still take the store slot
+
+const focusStoreAggregate = createOIMSingleSlotStoreAggregate(db, {
+    slotContentService: createOIMSlotContentEntityService<{ isFocused: boolean }>(),
+});
+focusStoreAggregate.writeSingleSlotContent({ isFocused: true });
+```
+
+| Aggregate | Over | Methods |
+|---|---|---|
+| `OIMSlotCollectionStoreAggregate` | `OIMSlotCollectionService` | `findSlotByKey`, `hasSlotContentByKey`, `getSlotByKey`, `holdSlotByKey`, `getSlots`, `getSlotCount`, `openBatch`, `closeBatch`, `writeInBatch` |
+| `OIMWritableSlotCollectionStoreAggregate` | `OIMWritableSlotCollectionService` | the above and `writeSlotContentByKey` |
+| `OIMSingleSlotStoreAggregate` | `OIMSingleSlotService` | `findSingleSlot`, `hasSingleSlotContent`, `getSingleSlot`, `holdSingleSlot` |
+| `OIMWritableSingleSlotStoreAggregate` | `OIMWritableSingleSlotService` | the above, `writeSingleSlotContent` and `clearSingleSlotContent` |
+| `OIMSlotCollectionIndexStoreAggregate` | `OIMSlotCollectionIndexService` | the collection methods, `getEntitiesByKey`, `getSlotsByKeys`, `holdSlotsByKeys`, `getBucketColumnByKey`, `holdBucketColumnByKey`, `getAnyBucketColumnByKey`, `holdAnyBucketColumnByKey`, `disposeIndexStoreSlot` |
+
+Every aggregate also carries `storeSlot`, `slotService` (typed as the service it came from) and
+`slotContentService`. A method that takes a slot rather than the store slot stays on its service.
+Each aggregate method calls the service with the store slot; the service and the store slot stay
+usable directly. `createOIMSlotCollectionStoreAggregate` builds a new service per call, so for
+many store slots of one type build the service once and call `createStoreAggregate` on it.
+
 The bucket doors take the type of the bucket member slots, `TBucketMemberSlot extends TOIMSlot`
 (default `TOIMEntitySlot`). A bucket holds bucket member slots of any slot type (entity slots,
 bucket slots, computeds), and an index's `getEntitiesByKey` is there because its members are
 entity slots.
 
-Each door reads the globals that the class it builds would otherwise fall back to and
-**always passes them**, so there is one answer to each question and no class
-reaches for a default of its own.
+Each door resolves every optional dependency as its own option, then `defaults` (or
+`OIMDefaults.INSTANCE`), then the built-in `OIMDefaultValue`, and **always passes the result**, so
+there is one answer to each question and no class reaches for a default of its own.
 
 The doors are free functions, not methods on `OIMDB`, so a consumer who wires
 nothing does not import the bucket machinery. This is pinned by
 `tests/what-an-import-retains.test.ts` (the root retains no door) and by
-`src/factories/tests/which-answer-a-collection-the-root-mints-gets.test.ts`.
+`src/db/tests/which-answer-a-collection-the-root-mints-gets.test.ts`.
 
 **A bucket's content service decides how it holds its slots.** `createOIMSlotCollectionService` takes it
 as `slotContentService`. With none, it builds an `OIMSlotContentPositionalArrayBucketService`
@@ -255,8 +307,8 @@ live** (`slotStoreService`, the strategy every store slot of the service files i
 with), **how a key comes out of an entity** (`keyOf`), **how a write lands** (`entityWriter`),
 **what counts as empty** (`slotEmptinessPolicy`), **when a slot goes** (`slotReleasePolicy`), and
 **where column slots live** (`columnSlotStoreService`, or `columnNames` for the ordinal store; the
-slot owner makes its own column owner over it). Everything but `keyOf` falls back to the `db` or
-to a lazy `OIMDefaultValue` on [`OIMDefaults`](#every-optional-dependency-has-a-default).
+slot owner makes its own column owner over it). Everything but `keyOf` falls back to `defaults`, then
+to a lazy `OIMDefaultValue` (see [`OIMDefaults`](#every-optional-dependency-has-a-default)).
 
 ---
 
@@ -267,7 +319,7 @@ There is no argument that turns delivery off. A store slot is created on a `db`
 unused-slot collector a read hands its mint to is that channel slot's `collectorSlot`.
 
 ```typescript
-const deliveringCardService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db), slotStoreService: new OIMSlotMapStoreService<TOIMEntitySlot<Card, TOIMStoreKey>>(), columnSlotStoreService: OIMDefaults.COLUMN_SLOT_STORE_SERVICE.getValue() });
+const deliveringCardService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Card>(), slotStoreService: new OIMSlotMapStoreService<TOIMEntitySlot<Card, TOIMStoreKey>>() });
 const deliveringCards = deliveringCardService.createStoreSlot(db);
 ```
 
@@ -277,11 +329,11 @@ and that constructor builds the type's `OIMSlotOwnerService`. The owner asks the
 through `IOIMSlotContentService` (`isSlotEmpty`, `releaseSlotContent`, `hasReference`); the collection
 service mints through the content service's `createSlot`.
 
-`keyOf` is the one required option. `entityWriter` falls back to `db.entityWriter`, then to
-`OIMDefaults.ENTITY_WRITER`; `slotEmptinessPolicy` to `OIMDefaults.ENTITY_SLOT_EMPTINESS`;
-`slotReleasePolicy` to `db.slotReleasePolicy`, then to nothing, which is the default of "a slot
-with a value stays for good" described under **The injected seams**; the column store to
-`OIMDefaults.COLUMN_SLOT_STORE_SERVICE`.
+`keyOf` is the one required option. `entityWriter` falls back to `defaults.entityWriter`, then to
+the in-place writer; `slotEmptinessPolicy` to `defaults.entitySlotEmptinessPolicy`, then to "the entity
+is `undefined`"; `slotReleasePolicy` to `defaults.slotReleasePolicy`, then to nothing, which is the
+default of "a slot with a value stays for good" described under **The injected seams**; the column store
+to `defaults.columnSlotStoreService`, then to a shared map-driven store.
 
 A single entity is the same content service under a `void` key, built by
 `createOIMSingleSlotService`, and it reports the same way.
@@ -290,38 +342,34 @@ A single entity is the same content service under a `void` key, built by
 
 ## Every optional dependency has a default
 
-`OIMDefaults` is where a default that would otherwise be an object lives. It is a
-class of static `OIMDefaultValue` fields and nothing else; you never construct one.
+`OIMDefaults` holds the strategies a factory falls back on when its own options leave them out. Build
+one with the strategies you want shared and pass it as the `defaults` option of every factory that
+should use them; a factory given none uses `OIMDefaults.INSTANCE`, which is empty. A field left
+undefined falls back to the built-in default.
 
-| Accessor | Type | What it hands back |
+| Field | Type | Built-in default |
 |---|---|---|
-| `OIMDefaults.COLUMN_SLOT_STORE_SERVICE` | `IOIMSlotStoreService<string, TOIMColumnSlot>` | a map-driven store service for column slots; the factories pass it to every service they build without `columnNames` |
-| `OIMDefaults.COMPUTED_COLUMN_SLOT_STORE_SERVICE` | `IOIMSlotStoreService<string, TOIMComputedColumnSlot>` | a map-driven store service for the column slots of computed services, keyed or single; the computed factories pass it to every one they build without `columnNames` |
-| `OIMDefaults.KEY_TREE_WALK_SCALAR` | `OIMScalarKeyTreeWalk` | the chain-of-values walk |
-| `OIMDefaults.KEY_TREE_WALK_COMPOSITE` | `OIMCompositeKeyTreeWalk` | the chain-of-identities walk |
-| `OIMDefaults.STANDALONE_SLOT_OWNER` | `OIMSlotOwner` | the owner of a slot nobody filed |
-| `OIMDefaults.ENTITY_WRITER` | `IOIMEntityWriter` | `createOIMEntityWriterInPlace()` |
-| `OIMDefaults.ENTITY_SLOT_EMPTINESS` | `IOIMSlotEmptinessPolicy<TOIMEntitySlot>` | "empty means `slot.entity === undefined`" |
-| `OIMDefaults.INDEX_KEYS_SERVICE` | `IOIMIndexKeysService` | an `OIMAppendingIndexKeysService`; see [Index keys strategy](#index-keys-strategy) |
-| `OIMDefaults.STORE_SLOT_LISTENER` | `IOIMStoreSlotListener` | `OIMNoStoreSlotListener`, which hears nothing. It is not a constructor option: every service reads it when built and calls `onStoreSlotCreated(storeSlot)` for each store slot it creates. Set your own with `setValue` before the first service is built; afterwards `setValue` throws |
-
-**Nothing is constructed at module load.** Every entry is an `OIMDefaultValue`
-whose `getValue()` mints on its first call (`??=`) and hands back the same instance
-for the rest of the process, so a consumer that never reaches for a key tree walk
-never builds one.
-
-Each has a matching `setValue(value)`, which is how a process replaces a default
-everywhere at once. **`setValue` throws once `getValue` has handed the first one
-out**, naming the property: `OIMDefaults.ENTITY_WRITER has already been handed
-out`. Whoever took the default keeps it, so a late replacement would leave two
-implementations live in one process, with the older one inside every object built
-before the call.
-
-Setting a default before the first read works, and so does setting it twice before then. Each
-property is tracked on its own, so calling `OIMDefaults.COLUMN_SLOT_STORE_SERVICE.getValue()` does not close
-`OIMDefaults.KEY_TREE_WALK_SCALAR`. Set every default you mean to replace at startup, before
-any `OIMDB` or service exists.
-`src/factories/tests/what-a-default-replaced-too-late-does.test.ts` pins this.
+| `slotStamp` | `IOIMSlotStamp<TOIMSlot>` | none: no stamp |
+| `slotReleasePolicy` | `IOIMSlotReleasePolicy` | none: a slot with a value stays for good |
+| `entityWriter` | `IOIMEntityWriter` | `createOIMInPlaceEntityWriter()` |
+| `entitySlotEmptinessPolicy` | `IOIMSlotEmptinessPolicy<TOIMEntityContentSlot>` | "empty means `slot.entity === undefined`" |
+| `indexKeysService` | `IOIMIndexKeysService` | an `OIMAppendingIndexKeysService`; see [Index keys strategy](#index-keys-strategy) |
+| `columnSlotStoreService` | `IOIMSlotStoreService<string, TOIMColumnSlot>` | a shared map-driven store service for column slots |
+| `computedColumnSlotStoreService` | `IOIMSlotStoreService<string, TOIMComputedColumnSlot>` | a shared map-driven store service for the column slots of computed services |
+| `storeSlotListener` | `IOIMStoreSlotListener` | `OIMNoStoreSlotListener`, which hears nothing; a service calls `onStoreSlotCreated(storeSlot)` for each store slot it creates |
+
+```ts
+const replacingDefaults = new OIMDefaults({ entityWriter: createOIMReplacingEntityWriter() });
+const replacingCardService = createOIMSlotCollectionService({
+    defaults: replacingDefaults,
+    slotContentService: createOIMSlotContentEntityService<Card>({ defaults: replacingDefaults }),
+});
+```
+
+**The built-in defaults cost nothing until used.** Each is an `OIMDefaultValue` whose `getValue()`
+builds it on its first call and hands back the same instance for the rest of the process, and
+`OIMDefaults` itself imports none of them, so a bundle carries only the defaults its factories read.
+`src/db/tests/which-answer-a-collection-the-root-mints-gets.test.ts` pins which door reads which.
 
 **One module names every default, so calling one `getValue()` retains all of them.** A
 service drags the map-driven store service and both key tree walks into a
@@ -346,7 +394,7 @@ const body = (): void => {};
 cardService.writeSlotContentByKey(cards, card.id, card);          // write:     the value is the reference
 cardService.writeSlotContentByKey(cards, key, card);     // write:     the same door, by key
 const entitySlot = cardService.holdSlotByKey(cards, key);          // hold:      a counted reference; give it back with entitySlot.owner.unholdSlot(entitySlot)
-effectService.createEffect(db, [entitySlot], [], body);            // subscribe: the effect is the reference
+effectService.createEffect(db, body, [entitySlot]);            // subscribe: the effect is the reference
 const rankColumn = cardService.columnSlotService.holdColumn(entitySlot, 'rank');     // hold, on a column
 cardService.columnSlotService.unholdColumn(rankColumn);                              // give the column back
 cardService.getSlotByKey(cards, key);                              // read:      the collector's hold is the reference
@@ -446,7 +494,7 @@ about a slot through `IOIMSlotContentService`, never through an override:
 |---|---|
 | `createSlot(key, storeSlot, slotOwner)` / `createSingleSlot(storeSlot, slotOwner)` | a key (or a single) is minted, by the collection service |
 | `isSlotEmpty(slot)` | emptiness is settled after a write |
-| `releaseSlotContent(slot, slotOwnerService)` | the identity is going. Give back what its content held |
+| `releaseSlotContent(slot)` | the identity is going. Give back what its content held. Throws on a held slot |
 | `hasReference(slot)` | something outside `holdCount` and `effects` may keep it |
 
 The content service's write doors reach the owner through `slot.owner`; the owner files and unfiles
@@ -457,12 +505,12 @@ through the store service.
 ```typescript signature
 interface IOIMSlotEmptinessPolicy<TSlot> { isEmpty(slot: TSlot): boolean; }
 
-interface IOIMSlotStamp<TSlot> { stamp(slotEditable: TOIMSlotEditable<TSlot>): void; }
+interface IOIMSlotStamp<TSlot> { stamp(editableSlot: TOIMEditable<TSlot>): void; }
 ```
 
 **`IOIMSlotEmptinessPolicy`** decides what counts as empty. The answer is written once
 per write into the EMPTY flag of `slot.slotFlags` and never recomputed at a read. An entity content
-service defaults to "the entity is `undefined`" (`OIMDefaults.ENTITY_SLOT_EMPTINESS`); a bucket
+service defaults to "the entity is `undefined`" (or `defaults.entitySlotEmptinessPolicy`); a bucket
 content service answers "`getBucketMemberSlotCount(bucketSlot) === 0`"; a computed answers
 `false`.
 
@@ -476,8 +524,8 @@ settled, and it chains: each stamp takes the `next` one and calls it first. Use
 for stamps that have nothing to do with release; release has its own policy.
 
 **`IOIMSlotReleasePolicy`** decides whether and when a slot goes, and does no
-work itself. A door and `OIMDB` take ONE through `slotReleasePolicy`; a door given none takes
-`db.slotReleasePolicy`. With neither, the slot owner is built with `OIMSlotAtEmptyReleasePolicy`:
+work itself. A door and an `OIMDefaults` take ONE through `slotReleasePolicy`; a door given none takes
+`defaults.slotReleasePolicy`. With neither, the slot owner is built with `OIMSlotAtEmptyReleasePolicy`:
 a slot with a value stays for good. A computed service defaults to
 `OIMSlotAtUnholdReleasePolicy`. Two readonly flags on the policy, `releasesWrittenSlots` and
 `schedulesReleaseOnWrite`, are read once by the owner at construction, so a policy that never
@@ -496,7 +544,7 @@ A slot goes on the SOONEST of those that are set, and a hold outranks them all.
 **One number cannot carry both.** A write arriving after the subscriber left
 would overwrite the idle policy's verdict, and the last subscriber leaving after a
 write would overwrite the write policy's. Both directions are pinned by
-`src/engine/collector/tests/which-release-marker-each-collector-may-move.test.ts`.
+`src/collector/tests/which-release-marker-each-collector-may-move.test.ts`.
 
 **The POLICY answers `isSlotReleasable(slot)`**, and only for a slot that is not
 empty and has nothing left keeping it (no holds, no references). `true` releases
@@ -554,7 +602,7 @@ leaves at the end of the frame. A window above zero is filed in that policy's ow
 queue.
 
 ```typescript
-const releasingDb = new OIMDB({
+const releasingDefaults = new OIMDefaults({
     slotReleasePolicy: new OIMSlotEarliestReleasePolicy([
         new OIMSlotAfterWriteReleasePolicy({ keepAfterWriteMs: 60_000 }),
         new OIMSlotAfterIdleReleasePolicy({ keepAfterIdleMs: 30_000 }),
@@ -612,7 +660,7 @@ does not re-file it. Two consequences follow:
   that those entities' own expired windows already answer for, so the entities go in the
   same sweep.
 
-Pinned by `src/engine/collector/tests/what-a-stale-index-takes-with-it.test.ts`,
+Pinned by `src/collector/tests/what-a-stale-index-takes-with-it.test.ts`,
 `…/what-an-identity-nobody-subscribed-to-costs-after-a-while.test.ts` and
 `…/what-a-subscribed-row-costs-the-release-clock.test.ts`.
 
@@ -703,7 +751,7 @@ gives them back when released, so the arena holds the top and the chain holds
 itself. Use one arena per screen, per component or per job: a scope's cache pins what
 that scope read and nothing else.
 
-Pinned by `src/engine/collector/tests/what-a-named-arena-keeps-cached.test.ts`.
+Pinned by `src/collector/tests/what-a-named-arena-keeps-cached.test.ts`.
 
 Neither policy means *unread*: no read is reported to the clock. A subscriber
 never loses data mid-read, because an effect holds every root it reaches, so the
@@ -729,8 +777,8 @@ a store slot that holds one slot under no key, or many, a store slot that files
 
 | kind | single | collection |
 |---|---|---|
-| entity | `createOIMSingleSlotService<TEntity>(db, …)`, then `createStoreSlot(db)` | `createOIMSlotCollectionService<TEntity>(db, { keyOf, … })`, then `createStoreSlot(db)` |
-| bucket | `createOIMSingleSlotService<TMember>(db, { slotContentService?, … })`, then `createStoreSlot(db)` | `createOIMSlotCollectionService<TMember>(db, { slotContentService?, … })`, then `createStoreSlot(db)` |
+| entity | `createOIMSingleSlotService<TEntity>(…)`, then `createStoreSlot(db)` | `createOIMSlotCollectionService<TEntity>({ keyOf, … })`, then `createStoreSlot(db)` |
+| bucket | `createOIMSingleSlotService<TMember>({ slotContentService?, … })`, then `createStoreSlot(db)` | `createOIMSlotCollectionService<TMember>({ slotContentService?, … })`, then `createStoreSlot(db)` |
 | computed | `createOIMComputedService<void, TValue, TOIMSingleSlotStore<TOIMComputedSlot<TValue, void>>>({ computedSlotStoreService: new OIMSingleSlotStoreService<…>(), … })`, then `createComputedStoreSlot(db, derive?, createSources?)` | `createOIMComputedService<TKey, TValue>({ … })`, then `createComputedStoreSlot(db, derive?, createSources?)` |
 
 A single is not a second content API. Its content service is the same class with `TKey = void`,
@@ -794,10 +842,10 @@ argument, not a subclass.
 new OIMSlotMapStoreService<TOIMEntitySlot<Card, TOIMStoreKey>>()
 
 // A composite key of VALUES, descended one composite key part at a time.
-new OIMSlotTreeStoreService<TOIMStoreKey, TOIMKeyedSlot<readonly TOIMStoreKey[]>>(OIMDefaults.KEY_TREE_WALK_SCALAR.getValue())
+new OIMSlotTreeStoreService<TOIMStoreKey, TOIMKeyedSlot<readonly TOIMStoreKey[]>>(OIMScalarKeyTreeWalk.INSTANCE)
 
 // A composite key of IDENTITIES, descended the same way — and holding each.
-new OIMSlotTreeStoreService<TOIMEntitySlot, TOIMKeyedSlot<readonly TOIMEntitySlot[]>>(OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue())
+new OIMSlotTreeStoreService<TOIMEntitySlot, TOIMKeyedSlot<readonly TOIMEntitySlot[]>>(OIMCompositeKeyTreeWalk.INSTANCE)
 ```
 
 There are two stores, one per shape of address, and no store is ever asked at run time
@@ -819,8 +867,8 @@ type TScalarChain = readonly TOIMStoreKey[];
 type Tally = { deck: string; day: string; count: number };
 type TTallyStore = TOIMSlotStoreTree<TOIMEntitySlot<Tally, TScalarChain>, TOIMStoreKey>;
 
-const tallyService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Tally, TScalarChain>(db), slotStoreService: new OIMSlotTreeStoreService<TOIMStoreKey, TOIMEntitySlot<Tally, TScalarChain>>(
-            OIMDefaults.KEY_TREE_WALK_SCALAR.getValue(),
+const tallyService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Tally, TScalarChain>(), slotStoreService: new OIMSlotTreeStoreService<TOIMStoreKey, TOIMEntitySlot<Tally, TScalarChain>>(
+            OIMScalarKeyTreeWalk.INSTANCE,
         ) });
 const tallies = tallyService.createStoreSlot(db);
 tallyService.writeSlotContentByKey(tallies, ((t) => [t.deck, t.day])({ deck: 'spades', day: 'mon', count: 1 }), { deck: 'spades', day: 'mon', count: 1 });
@@ -842,17 +890,17 @@ type Enrolment = {
 };
 type TChain = readonly TOIMEntitySlot[];
 
-const userService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<User>(db) });
+const userService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<User>() });
 const users = userService.createStoreSlot(db);
-const groupService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Group>(db) });
+const groupService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Group>() });
 const groups = groupService.createStoreSlot(db);
 const alice = userService.writeSlotContentByKey(users, 'alice', { id: 'alice', name: 'Alice' });
 const admins = groupService.writeSlotContentByKey(groups, 'admins', { id: 'admins', name: 'Admins' });
 
 type TEnrolmentStore = TOIMSlotStoreTree<TOIMEntitySlot<Enrolment, TChain>, TOIMEntitySlot>;
 
-const enrolmentService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Enrolment, TChain>(db), slotStoreService: new OIMSlotTreeStoreService<TOIMEntitySlot, TOIMEntitySlot<Enrolment, TChain>>(
-            OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue(),
+const enrolmentService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Enrolment, TChain>(), slotStoreService: new OIMSlotTreeStoreService<TOIMEntitySlot, TOIMEntitySlot<Enrolment, TChain>>(
+            OIMCompositeKeyTreeWalk.INSTANCE,
         ) });
 const enrolments = enrolmentService.createStoreSlot(db);
 enrolmentService.writeSlotContentByKey(enrolments, ((m) => [m.user, m.group])({ user: alice, group: admins, since: 2026 }), { user: alice, group: admins, since: 2026 });
@@ -871,7 +919,7 @@ Both walks throw `an empty key is not a key` on `[]`.
 **A scalar is not a composite key part of a composite-walk key.** It is a compile
 error, and past a cast it throws inside the mint (`Cannot create property
 'holdCount' on string`) with the edge already in the tree. Hand the store
-`OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` instead of using a cast.
+`OIMScalarKeyTreeWalk.INSTANCE` instead of using a cast.
 
 **Compare a chain with the strategy that matches it.** `oimSameSlotSequence` walks identities by
 reference. Using it on a chain of values is the `NaN` defect: it answers
@@ -913,7 +961,7 @@ made once at construction and costs nothing per write:
 | `oimInsertEntityWithSanitizedCopy` | a one-level copy with an own `__proto__` key removed | the same; pick it when you insert untrusted JSON (`JSON.parse` of other users' data) |
 
 ```typescript
-const copiedCardService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db, { entityWriter: createOIMEntityWriterInPlace({ entityInserter: oimInsertEntityWithCopy }) }) });
+const copiedCardService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<Card>({ entityWriter: createOIMInPlaceEntityWriter({ entityInserter: oimInsertEntityWithCopy }) }) });
 ```
 
 **A copy is one level deep, and no deeper.** A nested object or
@@ -948,7 +996,7 @@ cardService.slotContentService.markEntityChanged(slot, ['title']);
 **The hand mutation needs no cast.** `TOIMEntitySlot` declares
 `readonly entity: TEntity | undefined`, and `readonly` forbids replacing the
 object, not writing its columns. You still have to narrow the `| undefined`.
-`TOIMSlotEditable<TSlot>` is the type that strips `readonly` from the field
+`TOIMEditable<TSlot>` is the type that strips `readonly` from the field
 itself, which is what assigning `slot.entity` needs.
 
 **The list is the whole point, and leaving it out gives it back.** Named columns
@@ -1024,8 +1072,8 @@ interface IOIMEntityWriter {
     readonly clearEntity: (slot: TOIMEntityContentSlot) => void;
 }
 
-createOIMEntityWriterInPlace(options?)       // the stored object keeps its identity
-createOIMEntityWriterReplacing(options?)     // every write that changed something produces a new object
+createOIMInPlaceEntityWriter(options?)       // the stored object keeps its identity
+createOIMReplacingEntityWriter(options?)     // every write that changed something produces a new object
 // TOIMEntityWriterOptions = { sameValueGuard?: TOIMSameValueGuard; entityInserter?: TOIMEntityInserter; putEntityColumns?: typeof oimPutEntityColumns }
 ```
 
@@ -1044,9 +1092,9 @@ A writer of your own can reuse the column walks that both shipped writers run,
 `oimPatchEntityColumns`, `oimPatchEntityColumn` (one column, behind `patchColumn`) and
 `oimPutEntityColumns`. The whole-entity put is itself the writers' `putEntityColumns` option:
 `oimPutEntityColumns` is the default and skips neither `__proto__` keys nor inherited stored
-columns; `oimPutEntityColumnsGuarded` keeps both guards, at a measured cost on every put, for
+columns; `oimGuardedPutEntityColumns` keeps both guards, at a measured cost on every put, for
 values that can carry a `__proto__` key or are class instances
-(`createOIMEntityWriterInPlace({ putEntityColumns: oimPutEntityColumnsGuarded })`). Each returns the object
+(`createOIMInPlaceEntityWriter({ putEntityColumns: oimGuardedPutEntityColumns })`). Each returns the object
 `targetOf` handed back with the moved columns written into it, or `undefined`
 when nothing moved, so the writer decides only where the result goes. The
 [docs](https://oimdb.org/docs/core/writing#writing-your-own-writer) build one that
@@ -1058,7 +1106,7 @@ does not have are cleared to `undefined`, in one call, and the names it returns
 only the columns the patch names. `writeSlotContentByKey` of a key that has a value and
 `writeSlotContent(slot, entity)` are PUT, so a whole-entity write that drops a column writes
 the slot to the channel once, and the replacing writer builds one new object, not
-two. This is counted in `src/facade/entity/tests/what-a-put-that-drops-a-column-costs.test.ts`.
+two. This is counted in `src/entity/tests/what-a-put-that-drops-a-column-costs.test.ts`.
 
 Neither writer `delete`s. A column that a PUT drops or `deleteColumns` takes away is
 written `undefined`, into the stored object in place or into a spread copy when
@@ -1068,8 +1116,8 @@ replacing, so the entity keeps its hidden class: the key stays in
 does not report it, and taking the entity away does not wake its readers.
 
 The choice is made once, when the entity content service is built (`entityWriter`, else
-`db.entityWriter`), so there is no `if (inPlace)` anywhere on any write path; the object already
-is the answer. The default is `createOIMEntityWriterInPlace()`. Pass `createOIMEntityWriterReplacing()` when
+`defaults.entityWriter`), so there is no `if (inPlace)` anywhere on any write path; the object already
+is the answer. The default is `createOIMInPlaceEntityWriter()`. Pass `createOIMReplacingEntityWriter()` when
 something downstream compares by reference.
 
 ---
@@ -1107,8 +1155,7 @@ the next read; a computed with no sources derives on its first read. A throw nev
 for frames: the next write after an aborted frame asks for one. A throw in one
 release of a sweep leaves the rest of that slice on the release clock for the next
 sweep. A release that falls inside a flush (an effect body disposing another
-effect) waits: the slot goes to the unused-slot collector and is released once the
-flush is over. Code that keeps
+effect) happens at once: nothing holds the slot, so nothing hears it go. Code that keeps
 derived state (an index's `keyOf`, an emptiness check) is outside the
 policy: a throw there leaves state consistent and is thrown in either mode. An
 index whose `keyOf` throws on an entity files that entity under no key, finishes the rest
@@ -1117,7 +1164,7 @@ of the write or batch, then rethrows; the next write it accepts files the entity
 **Subscribing is building an effect.** There is no `subscribe` helper over this,
 and there must not be one. An effect is stamped with the channel clock at birth,
 so `effectService.createEffect` hears only what moves after it and never delivers a first
-value. `effectService.createEffectImmediate(db, roots, computeds, body)` is the door that runs
+value. `effectService.createAndRunEffect(db, roots, computeds, body)` is the door that runs
 the body once at creation. An effect is a plain `TOIMEffect` object with no methods (its
 channel is `effect.channelSlot`); `OIMEffectService.INSTANCE` does everything to it. There is
 one effect service for the whole process, and every door is handed the `db` (any
@@ -1125,14 +1172,14 @@ one effect service for the whole process, and every door is handed the `db` (any
 
 ```typescript
 // Sources are named in two lists: root slots, and derivations.
-const effect = effectService.createEffect(db, [slot], [totalService.computedSingleSlotService.getSingleSlot(total)], () => {});
+const effect = effectService.createEffect(db, () => {}, [slot], [totalService.computedSingleSlotService.getSingleSlot(total)]);
 effectService.disposeEffect(effect);
 // The second list is typed `readonly TOIMComputedSlot[]` — pass slots taken from
 // a computed service's `computedCollectionService` straight in.
 
 // One column of one slot, woken when that named column moves and by nothing else.
 // It takes the COLUMN SLOT, which the column owner mints and holds.
-const onRank = effectService.createEffect(db, [cardService.columnSlotService.holdColumn(slot, 'rank')], [], () => {});
+const onRank = effectService.createEffect(db, () => {}, [cardService.columnSlotService.holdColumn(slot, 'rank')]);
 ```
 
 The body's type is `TOIMEffectBody`, which is `() => (() => void) | void`. **A returned
@@ -1142,10 +1189,10 @@ so a body that opened something on each run has somewhere to close it.
 ```typescript
 const poll = (): void => {};
 
-effectService.createEffect(db, [slot], [], () => {
+effectService.createEffect(db, () => {
     const timer = setInterval(poll, 1000);
     return () => clearInterval(timer);
-});
+}, [slot]);
 ```
 
 The return is checked with `typeof` rather than for truthiness, because an
@@ -1153,16 +1200,16 @@ expression-bodied arrow hands back whatever the expression evaluated to
 (`() => set.add(key)` returns the `Set`), and anything that is not a function is
 discarded.
 
-**An effect can also find its sources as it reads.** `createEffectWithSourceTracking(db, body)`
-takes no source lists: the body gets an `OIMEffectSourceTracker`, and what it reads through
+**An effect can also find its sources as it reads.** `createSourceTrackingEffect(db, body)`
+takes no source lists: the body gets an `OIMSourceTracker`, and what it reads through
 `readSourceSlot(slot)` (which files the slot and returns it) and
 `readSourceComputedValue(computedSlot)` (which files the derivation and returns its value)
-is what that run depends on. The body's type is `TOIMEffectBodyWithSourceTracking`.
+is what that run depends on. The body's type is `TOIMSourceTrackingEffectBody`.
 
 ```typescript
-effectService.createEffectWithSourceTracking(db, effectSourceTracker => {
-    const isFirst = effectSourceTracker.readSourceSlot(slot).entity?.rank === 1;
-    console.log(isFirst ? effectSourceTracker.readSourceSlot(slot).entity?.title : 'not first');
+effectService.createSourceTrackingEffect(db, sourceTracker => {
+    const isFirst = sourceTracker.readSourceSlot(slot).entity?.rank === 1;
+    console.log(isFirst ? sourceTracker.readSourceSlot(slot).entity?.title : 'not first');
 });
 ```
 
@@ -1226,13 +1273,13 @@ frozen object per set of names on that service; get it once per view, not per en
 and `unholdColumn(columnSlot)` gives it back. A write wakes it once if it changes any of the
 group's columns and not at all if it changes only others.
 
-**`columnNames` picks the column slot store.** `createOIMSlotCollectionService<Card, 'rank' | 'title'>(db, { keyOf, columnNames: ['rank', 'title'] })`
+**`columnNames` picks the column slot store.** `createOIMSlotCollectionService<Card, 'rank' | 'title'>({ keyOf, columnNames: ['rank', 'title'] })`
 keeps each entity's column slots in an array by column number instead of a `Map` per entity,
 which makes an entity's column store cheaper to create and give back; that is what a scrolling view pays.
 `holdColumn` and `getColumnGroup` are typed on the named columns, and a slot for any other
 column throws. `columnNames` is on the options of every door — entity, bucket, index, computed —
 keyed or single. Without `columnNames` the store is the `columnSlotStoreService` option, and the
-doors default it to the shared map-driven `OIMDefaults.COLUMN_SLOT_STORE_SERVICE.getValue()`.
+doors default it to the shared map-driven a shared map-driven store.
 
 ### Frame rules
 
@@ -1287,10 +1334,10 @@ doors default it to the shared map-driven `OIMDefaults.COLUMN_SLOT_STORE_SERVICE
 const paint = (card: Card | undefined): void => {};
 const measureAndScroll = (): void => {};
 
-effectService.createEffect(db, [slot], [], () => {
+effectService.createEffect(db, () => {
     paint(slot.entity);
     OIMChannelService.INSTANCE.subscribeOnceAfterFrame(db.defaultChannelSlot, () => { measureAndScroll(); });
-});
+}, [slot]);
 ```
 
 The handler is told after **one** frame, the first that ends after the call, and is then gone.
@@ -1303,7 +1350,7 @@ inside its effect and is answered at the end of that same frame.
 
 It is **not** `subscribeAfterEachFrame` plus a disposal. The effect runs again
 next frame and registers again, so a standing handler accumulates one more per run:
-`src/engine/channel/tests/a-handler-that-wants-one-frame-and-not-every-frame.test.ts` measures the
+`src/channel/tests/a-handler-that-wants-one-frame-and-not-every-frame.test.ts` measures the
 one-shot at 1, 2, 3 calls over three frames against the standing handler's 1, 3,
 6. The one-shot handler also comes off *before* its body runs, so a handler that throws is not left
 standing for the next frame.
@@ -1374,7 +1421,7 @@ computeds), and the bucket's type parameter is that slot type,
 `getEntitiesByKey` is there because its members are entity slots.
 
 ```typescript
-const byDeckService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentSetBucketService<CardSlot>() });
+const byDeckService = createOIMSlotCollectionService({ slotContentService: new OIMSlotContentSetBucketService<CardSlot>() });
 const byDeck = byDeckService.createStoreSlot(db);
 
 const aceSlot = cardService.writeSlotContentByKey(cards, 'c1', { id: 'c1', deck: 'red', title: 'Ace', rank: 1 });
@@ -1483,7 +1530,7 @@ disagree. With the unique one `hasBucketMemberSlot` answers from the `Set`; with
 
 ### Positions the caller decides, and the commands that record them
 
-`createOIMSlotCollectionService<CardSlot>(db)` with no `slotContentService` is the bucket collection to
+`createOIMSlotCollectionService<CardSlot>()` with no `slotContentService` is the bucket collection to
 take when the positions are yours: its default content service is
 `OIMSlotContentPositionalArrayBucketService` with an `OIMBucketCommands` recording over it.
 
@@ -1529,17 +1576,17 @@ from the bucket's for good.
 consumer patches instead of rebuilding:
 
 ```typescript
-const pageService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<CardSlot>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
+const pageService = createOIMSlotCollectionService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<CardSlot>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const page = pageService.createStoreSlot(db);
 const bucket = pageService.holdSlotByKey(page, 'p1');
 
 const rebuildFrom = (slots: Iterable<CardSlot>): void => {};
 const applyToTheRenderedList = (commands: readonly TOIMOrderedListCommand[]): void => {};
 
-effectService.createEffect(db, [bucket], [], () => {
+effectService.createEffect(db, () => {
     if (bucket.isWholeListRecorded) rebuildFrom(pageService.slotContentService.getBucketMemberSlots(bucket));
     else applyToTheRenderedList(bucket.commands ?? []);
-});
+}, [bucket]);
 ```
 
 The content service already writes the bucket slot on every mutation, so the consumer
@@ -1584,7 +1631,7 @@ per-bucket state, so **one instance may serve two bucket collections**.
 ### The other strategy: an index that fills itself
 
 ```typescript
-const indexService = createOIMSlotCollectionIndexService(db, {
+const indexService = createOIMSlotCollectionIndexService({
     entityService: cardService,
     keyOf: (card: Card) => card.deck,        // which key an entity belongs to
 });
@@ -1593,7 +1640,7 @@ const index = indexService.createIndexStoreSlot(cards);
 const render = (slots: unknown[]): void => {};
 
 const spades = indexService.holdSlotByKey(index, 'spades');   // the hold mints the bucket and fills it
-effectService.createEffect(db, [spades], [], () => render(Array.from(indexService.slotContentService.getBucketMemberSlots(spades))));
+effectService.createEffect(db, () => render(Array.from(indexService.slotContentService.getBucketMemberSlots(spades))), [spades]);
 ```
 
 It **is** a bucket collection (`OIMSlotCollectionIndexService` extends `OIMSlotCollectionService`), and
@@ -1609,7 +1656,7 @@ index's buckets cannot be written from outside. The default content service is
 new OIMSlotContentSetBucketService()` for buckets that keep no positions. Passing
 `entityService` and then the entity store slot is the whole wiring: `createIndexStoreSlot(cards)`
 registers a content-change listener on that store slot
-(`OIMContentChangeListenerService.INSTANCE.addContentChangeListener(cards, …)`), and the entity
+(`OIMSlotContentChangeListenerService.INSTANCE.addContentChangeListener(cards, …)`), and the entity
 service knows nothing about indexes.
 `disposeIndexStoreSlot(index)` takes that listener off, empties the buckets and gives back every
 entity held. After that, `getSlotByKey` and `holdSlotByKey` throw, but the two give-backs
@@ -1635,14 +1682,14 @@ Know these four things before choosing it:
   door (`getSlotByKey`, `holdSlotByKey`, `getSlotsByKeys`, `holdSlotsByKeys`) is filled from the source
   entities written before it, without a flush, so minting inside an effect body does not
   throw. `getSlotsByKeys` / `holdSlotsByKeys` fill all new buckets in ONE pass over the source. How long the bucket lives then is the
-  collection's ordinary business: the `slotReleasePolicy` option, or `db.slotReleasePolicy`
+  collection's ordinary business: the `slotReleasePolicy` option, or `defaults.slotReleasePolicy`
   when you name none; with neither, the bucket is kept for good. `OIMSlotAfterIdleReleasePolicy`
   cools it on the queue, and `OIMSlotAtUnholdReleasePolicy.INSTANCE` ends it at
   the last give-back. The index injects no lifetime of its own.
 - **The key comes from `columns`, `keyOf`, or both**, the same pair as the sorter's
   `sortColumns` / `comparator`. The key type is inferred from the columns (`TOIMIndexKey`):
   `{ columns: ['deck'] }` is keyed by that one column's value and refuses an array;
-  `createOIMSlotCollectionIndexService(db, { entityService, columns: ['deck', 'suit'] })` is keyed by the
+  `createOIMSlotCollectionIndexService({ entityService, columns: ['deck', 'suit'] })` is keyed by the
   tuple of their values and builds the bucket collection on a tree-driven store
   (`OIMSlotTreeStoreService`) by itself, while `createOIMSlotCollectionIndexService` without a
   `bucketSlotStoreService` refuses two columns. When the index asks
@@ -1662,7 +1709,7 @@ Know these four things before choosing it:
 ### A sorted list is a computed over an index
 
 ```typescript
-const indexService = createOIMSlotCollectionIndexService(db, {
+const indexService = createOIMSlotCollectionIndexService({
     entityService: cardService,
     keyOf: (card: Card) => card.deck,
 });
@@ -1670,12 +1717,12 @@ const index = indexService.createIndexStoreSlot(cards);
 
 const byRankInDeckService = createOIMSortedComputedService({
     indexService,
-    sortColumns: [{ column: 'rank', direction: 'asc' }],
+    sortColumns: [{ columnName: 'rank', direction: 'asc' }],
 });
 const byRankInDeck = byRankInDeckService.createSortedStoreSlot(index);
 
 const spades = byRankInDeckService.computedCollectionService.holdSlotByKey(byRankInDeck, 'spades');
-effectService.createEffect(db, [], [spades], () => { console.log(spades.computedValueService.getValueForSlot(spades).map((entitySlot) => entitySlot.entity?.title)); });
+effectService.createEffect(db, () => { console.log(spades.computedValueService.getValueForSlot(spades).map((entitySlot) => entitySlot.entity?.title)); }, [], [spades]);
 spades.owner.unholdSlot(spades);
 ```
 
@@ -1688,7 +1735,7 @@ with that store slot first. A key's value, read with
 `computedSlot.computedValueService.getValueForSlot(computedSlot)`, is that key's entity slots,
 sorted. `indexService` is the `OIMSlotCollectionIndexService` whose buckets it sorts.
 
-- `sortColumns` is `readonly TOIMSortColumn<TEntity>[]`, each `{ column, direction: 'asc' | 'desc' }`.
+- `sortColumns` is `readonly TOIMSortColumn<TEntity>[]`, each `{ columnName, direction: 'asc' | 'desc' }`.
   `column` is a `TOIMSortableColumnName<TEntity>`, meaning a column whose values are strings,
   numbers or bigints. **Columns decide which writes re-sort.**
 - `comparator` is `(left: TEntity, right: TEntity) => number`. **It decides the order.**
@@ -1721,17 +1768,17 @@ The other strategy keeps the index's own buckets in order, so a read needs no co
 The consumer picks one at construction.
 
 ```typescript
-const cardsByDeckService = createOIMSlotCollectionSortedArrayIndexService(db, {
+const cardsByDeckService = createOIMSlotCollectionSortedArrayIndexService({
     entityService: cardService,
     columns: ['deck'],
-    sortColumns: [{ column: 'rank', direction: 'asc' }, { column: 'id', direction: 'desc' }],
+    sortColumns: [{ columnName: 'rank', direction: 'asc' }, { columnName: 'id', direction: 'desc' }],
 });
 const cardsByDeck = cardsByDeckService.createIndexStoreSlot(cards);
 const spades = cardsByDeckService.holdSlotByKey(cardsByDeck, 'spades');
 Array.from(cardsByDeckService.slotContentService.getBucketMemberSlots(spades));
 ```
 
-`createOIMSlotCollectionSortedArrayIndexService(db, { entityService, columns? | keyOf?, sortColumns, slotReleasePolicy?, bucketSlotStoreService? })`
+`createOIMSlotCollectionSortedArrayIndexService({ entityService, columns? | keyOf?, sortColumns, slotReleasePolicy?, bucketSlotStoreService? })`
 returns an `OIMSlotCollectionSortedArrayIndexService`, whose content service is an
 `OIMSlotContentSortedArrayBucketService`. `sortColumns` is the same `readonly TOIMSortColumn<TEntity>[]`
 that `createOIMSortedComputedService` takes.
@@ -1760,14 +1807,14 @@ bucket any-column slot doors (`getAnyBucketColumnByKey(indexStoreSlot, key)`,
 the positional ones of the array-based kinds included.
 
 ```typescript
-const decksService = createOIMSlotCollectionIndexService(db, {
+const decksService = createOIMSlotCollectionIndexService({
     entityService: cardService,
     keyOf: (card: Card) => card.deck,
 });
 const decks = decksService.createIndexStoreSlot(cards);
 
 const rankOfSpades = decksService.holdBucketColumnByKey(decks, 'spades', 'rank');
-const onRankInSpades = effectService.createEffect(db, [rankOfSpades], [], () => {});
+const onRankInSpades = effectService.createEffect(db, () => {}, [rankOfSpades]);
 effectService.disposeEffect(onRankInSpades);
 decksService.columnSlotService.unholdColumn(rankOfSpades);
 ```
@@ -1779,7 +1826,7 @@ leaves its old bucket in O(1). Only an index writes it, through its `IOIMIndexKe
 (`get(slot, position)`, `set(slot, position, indexKey)`), at the position its index store
 slot was given (`TOIMIndexStoreSlot.indexKeysPosition`, allocated from the source store slot's
 `indexKeysPositions`). Choose the service with the `indexKeysService` option of `OIMDB`; every
-index the factories build on that `db` takes it (default `OIMDefaults.INDEX_KEYS_SERVICE.getValue()`).
+index the factories build on that `db` takes it (default `OIMAppendingIndexKeysService.INSTANCE`).
 
 - `OIMAppendingIndexKeysService` (default): a disposed index's position is never
   reused, and its stale entry stays on each entity slot. A slot's `indexKeys` grows to the highest
@@ -1796,7 +1843,7 @@ Creating indexes that way is expensive; better not to.
 ### Rendering an ordered bucket
 
 ```typescript setup
-const orderedBucketsService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<CardSlot>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
+const orderedBucketsService = createOIMSlotCollectionService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<CardSlot>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const orderedBuckets = orderedBucketsService.createStoreSlot(db);
 ```
 
@@ -1875,7 +1922,7 @@ this engine (`createEffect`'s second argument, and `sourceComputeds` in
 it is. Inside `derive`, `computedSlot.value` is the previous value:
 
 ```typescript
-effectService.createEffect(db, [], [totalSlot], () => { console.log(totalSlot.computedValueService.getValueForSlot(totalSlot)); });
+effectService.createEffect(db, () => { console.log(totalSlot.computedValueService.getValueForSlot(totalSlot)); }, [], [totalSlot]);
 ```
 
 ### One derivation per key
@@ -1908,9 +1955,7 @@ A derivation is never empty: `OIMSlotContentComputedService.isSlotEmpty` answers
 so a filed derivation goes only when nothing holds it,
 nothing watches it, and the grace is `0`. That is what
 `OIMSlotAtUnholdReleasePolicy.INSTANCE` answers, and it is the default when no `slotReleasePolicy` is given.
-A derivation let go of while the channel is flushing is not released on the spot. It is
-handed to the channel's unused-slot collector and released when the flush ends, the same
-deferral that every other non-empty slot gets.
+A derivation let go of while the channel is flushing is released on the spot, like every other slot.
 `createOIMComputedService` takes a `slotReleasePolicy` as an optional key of its options object.
 
 `createOIMComputedService` is `OIMComputedService` with its generics
@@ -1941,7 +1986,7 @@ const cardSummary = cardSummaryService.createComputedStoreSlot(
 );
 const summarySingleSlotService = cardSummaryService.computedSingleSlotService;
 const topColumn = summarySingleSlotService.columnSlotService.holdColumn(summarySingleSlotService.getSingleSlot(cardSummary), 'top');
-const onTop = effectService.createEffect(db, [], [topColumn], () => { console.log(topColumn.value); });
+const onTop = effectService.createEffect(db, () => { console.log(topColumn.value); }, [], [topColumn]);
 effectService.disposeEffect(onTop);
 summarySingleSlotService.columnSlotService.unholdColumn(topColumn);
 ```
@@ -1959,7 +2004,7 @@ const order = orderService.createBucketMemoStoreSlot(orderedBuckets);
 const render = (slots: readonly CardSlot[]): void => {};
 
 const deck = orderService.computedCollectionService.holdSlotByKey(order, 'spades');   // mints and holds the bucket too
-effectService.createEffect(db, [], [deck], () => render(deck.computedValueService.getValueForSlot(deck)));
+effectService.createEffect(db, () => render(deck.computedValueService.getValueForSlot(deck)), [], [deck]);
 ```
 
 Its value is the bucket's slots in the bucket's order, produced on the read that
@@ -1981,14 +2026,14 @@ A sorted list is the other derivation of this kind:
 ```typescript
 type Settings = { theme: string; fontSize: number };
 
-const settingsService = createOIMSingleSlotService(db, { slotContentService: createOIMSlotContentEntityService<Settings>(db), columnNames: ['theme', 'fontSize'] });
+const settingsService = createOIMSingleSlotService({ slotContentService: createOIMSlotContentEntityService<Settings>(), columnNames: ['theme', 'fontSize'] });
 const settings = settingsService.createStoreSlot(db);
 const settingsContentService = settingsService.slotContentService;
 settingsService.writeSingleSlotContent(settings, { theme: 'dark', fontSize: 14 });
 const settingsSlot = settingsService.holdSingleSlot(settings);
 
-effectService.createEffect(db, [settingsSlot], [], () => { console.log(settingsSlot.entity?.theme); });
-effectService.createEffect(db, [settingsService.columnSlotService.holdColumn(settingsSlot, 'theme')], [], () => {});
+effectService.createEffect(db, () => { console.log(settingsSlot.entity?.theme); }, [settingsSlot]);
+effectService.createEffect(db, () => {}, [settingsService.columnSlotService.holdColumn(settingsSlot, 'theme')]);
 
 settingsContentService.updateEntity(settingsSlot, { theme: 'light' });
 settingsContentService.deleteEntityColumns(settingsSlot, ['fontSize']);      // the thing a patch cannot say
@@ -1999,7 +2044,7 @@ db.flush();
 A standalone record is a single service: `createOIMSingleSlotService` is
 `createOIMSingleSlotService` over `createOIMSlotContentEntityService`, with the store fixed to
 `OIMSingleSlotStoreService` and no `keyOf`. Every option is optional:
-`entityWriter` and `slotEmptinessPolicy` fall back to `OIMDefaults`, and `columnNames` names the
+`entityWriter` and `slotEmptinessPolicy` fall back to `defaults`, then to the built-in defaults, and `columnNames` names the
 columns and files their slots in the ordinal store. The entity is
 written through `slotContentService.writeSlotContentByKey(settings, entity)`, an ordinary write announced
 to whoever subscribed, not handed to the options or to `createStoreSlot(db)`, which mints
@@ -2036,7 +2081,7 @@ const body = (): void => {};
 const entitySlot = cardService.holdSlotByKey(cards, 'c1');
 
 const disposers: TOIMDisposer[] = [];
-disposers.push(effectService.subscribeEffect(db, [entitySlot], [], body));
+disposers.push(effectService.subscribeEffect(db, body, [entitySlot]));
 disposers.push(() => { entitySlot.owner.unholdSlot(entitySlot); });
 for (let i = disposers.length - 1; i >= 0; i--) disposers[i]();
 ```
@@ -2048,7 +2093,7 @@ a throwing disposer does not stop the rest. The engine ships no scope to do that
 
 ## Export reference
 
-**218 names. This list is `src/index.ts`; nothing else is exported.**
+**237 names. This list is `src/index.ts`; nothing else is exported.**
 
 **The channel slot** — `OIMChannelService`, `TOIMChannelSlot`, `TOIMChannelSlotOptions`, `createOIMChannelSlot`,
 `IOIMChannelMap`, `TOIMChannelFrame`, `TOIMChannelClock`, `TOIMChannelScheduler`, `OIMChannelQueue` (**type only**),
@@ -2076,10 +2121,14 @@ a throwing disposer does not stop the rest. The engine ships no scope to do that
 `TOIMSlotOwnerServiceOptions`, `IOIMSlotContentService`, `IOIMSlotContentWriter`, `IOIMKeyedSlotCreator`, `IOIMSingleSlotCreator`,
 `IOIMSlotFilingService`, `TOIMSlotContentServiceKey`, `TOIMSlotContentServiceSlot`, `TOIMSlotContentServiceSingleSlot`,
 `TOIMSlotContentServiceContent`, `TOIMSlotContentServicePatch`,
-`OIMContentChangeListenerService`, `IOIMContentChangeListener`, `IOIMStoreSlotListener`, `OIMNoStoreSlotListener`,
+`OIMSlotContentChangeListenerService`, `IOIMSlotContentChangeListener`, `IOIMStoreSlotListener`, `OIMNoStoreSlotListener`,
 `IOIMSlotSubscriptionListener`, `OIMNoSlotSubscriptionListener`.
 
-**Slots and their owners** — `TOIMSlot`, `TOIMStoreSlot`, `TOIMSingleSlotStoreSlot`, `TOIMSlotEditable`, `TOIMKeyedSlot`,
+**Store aggregates** — `OIMSlotCollectionStoreAggregate`, `OIMWritableSlotCollectionStoreAggregate`,
+`OIMSingleSlotStoreAggregate`, `OIMWritableSingleSlotStoreAggregate`, `createOIMSlotCollectionStoreAggregate`,
+`createOIMSingleSlotStoreAggregate`, `OIMSlotCollectionIndexStoreAggregate`.
+
+**Slots and their owners** — `TOIMSlot`, `TOIMStoreSlot`, `TOIMSingleSlotStoreSlot`, `TOIMEditable`, `TOIMKeyedSlot`,
 `TOIMIndexableSlot`, `OIMSlotOwner`, `IOIMSlotOwner`, `IOIMSlotEmptinessPolicy`, `IOIMSlotStamp`, `TOIMSameValueGuard`,
 `oimSameValueZeroGuard`, `oimIsSlotEmpty`, `oimIsSlotReleased`, `oimHoldSlots`, `oimUnholdSlotsIfAlive`,
 `OIM_FROZEN_EMPTY_SLOTS`.
@@ -2088,11 +2137,11 @@ a throwing disposer does not stop the rest. The engine ships no scope to do that
 `OIMColumnSlotOwner`, `OIMPushColumnSlotOwner` (**type only**), `OIMPullColumnSlotOwner`, `TOIMColumnSlotOwnerOptions`.
 
 **Entities** — `OIMSlotContentEntityService`, `TOIMSlotContentEntityServiceOptions`, `TOIMEntitySlotOwnerService`,
-`TOIMEntitySlot`, `TOIMEntityContentSlot`, `createOIMSlotContentEntityService`; `IOIMEntityWriter`, `createOIMEntityWriterInPlace`,
-`createOIMEntityWriterReplacing`, `TOIMEntityWriterOptions`, `TOIMEntityInserter`,
+`TOIMEntitySlot`, `TOIMEntityContentSlot`, `createOIMSlotContentEntityService`; `IOIMEntityWriter`, `createOIMInPlaceEntityWriter`,
+`createOIMReplacingEntityWriter`, `TOIMEntityWriterOptions`, `TOIMEntityInserter`,
 `oimInsertEntityWithCopy`, `oimInsertEntityWithoutCopy`, `oimInsertEntityWithSanitizedCopy`, `oimPatchEntityColumns`,
-`oimPatchEntityColumn`, `oimPatchEntityColumnsGuarded`, `oimPatchEntityColumnGuarded`, `oimPutEntityColumns`,
-`oimPutEntityColumnsGuarded`, `TOIMEntityColumnName`, `TOIMEntityColumnValue`.
+`oimPatchEntityColumn`, `oimGuardedPatchEntityColumns`, `oimGuardedPatchEntityColumn`, `oimPutEntityColumns`,
+`oimGuardedPutEntityColumns`, `TOIMEntityColumnName`, `TOIMEntityColumnValue`.
 
 **Buckets** — `OIMSlotContentBucketService`, `OIMSlotContentArrayBucketService`,
 `OIMSlotContentPositionalArrayBucketService`, `OIMSlotContentSetBucketService`,
@@ -2109,8 +2158,8 @@ a throwing disposer does not stop the rest. The engine ships no scope to do that
 `IOIMIndexKeysService`, `TOIMIndexKeysPositions`, `OIMIndexKeysService`, `OIMAppendingIndexKeysService`,
 `OIMReclaimingIndexKeysService`.
 
-**The graph** — `OIMEffectService`, `IOIMEffectService`, `TOIMEffect`, `TOIMEffectBody`, `TOIMEffectBodyWithSourceTracking`,
-`OIMEffectSourceTracker` (**type only**), `TOIMComputedSlot`, `TOIMComputedSources`, `TOIMDerivation`, `TOIMComputedStoreSlot`,
+**The graph** — `OIMEffectService`, `IOIMEffectService`, `TOIMEffect`, `TOIMEffectBody`, `TOIMSourceTrackingEffectBody`,
+`OIMSourceTracker` (**type only**), `TOIMComputedSlot`, `TOIMComputedSources`, `TOIMComputedValueReleaser`, `OIMSourceTrackingComputedService`, `OIMSingleSourceTrackingComputedService`, `createOIMSourceTrackingComputedService`, `createOIMSingleSourceTrackingComputedService`, `TOIMSourceTrackingComputedSlot`, `TOIMSourceTrackingComputedContentSlot`, `TOIMSourceTrackingComputedDerive`, `OIMSlotContentSourceTrackingComputedService` (**type only**), `TOIMSourceTrackingComputedDerivationOptions`, `TOIMComputedServiceFactoryOptions`, `TOIMComputedDerivation`, `TOIMComputedStoreSlot`,
 `OIMComputedValueService`, `IOIMComputedValueService`, `TOIMComputedValueServiceOptions`, `TOIMComputedContentSlot`,
 `OIMSlotContentComputedService` (**type only**), `TOIMSlotContentComputedServiceOptions`, `oimRefreshSourceComputeds` (brings every computed in a `sourceComputeds` list current; call it before a `derive` that runs outside an effect, as `useOIMValue` does).
 
@@ -2125,16 +2174,14 @@ a throwing disposer does not stop the rest. The engine ships no scope to do that
 `OIMSingleSlotStoreService`, `TOIMSingleSlotStore`, `TOIMDefaultSlotStore`, `TOIMSlotStoreTree`, `IOIMKeyTreeWalk`, `TOIMCompositeKeyNode`,
 `OIMKeyTreeWalk`, `OIMCompositeKeyTreeWalk`, `OIMScalarKeyTreeWalk`.
 
-**The root and its defaults** — `OIMDB`, `TOIMDBOptions`, `OIMDefaults`, `OIMDefaultValue`, `TOIMFactoryOptions`.
+**The root and its defaults** — `OIMDB`, `TOIMDBOptions`, `OIMDefaults`, `TOIMDefaultsOptions`, `OIMDefaultValue`, `TOIMFactoryOptions`.
 
 **Comparison and diffing** — `oimSameSlotSequence`, `oimSameKeySequence`, `oimOrderedListCommandsOfTransition`,
 `TOIMOrderedListCommand`.
 
-**Shared stateless defaults** — the statics of `OIMDefaults`: `COLUMN_SLOT_STORE_SERVICE`,
-`COMPUTED_COLUMN_SLOT_STORE_SERVICE`, `KEY_TREE_WALK_SCALAR`, `KEY_TREE_WALK_COMPOSITE`,
-`STANDALONE_SLOT_OWNER`, `ENTITY_WRITER`, `ENTITY_SLOT_EMPTINESS`, `INDEX_KEYS_SERVICE`,
-`STORE_SLOT_LISTENER`. Each is minted on its first `getValue()` instead of at module load, so a
-consumer that names none of them constructs none of them. The cost of the single door is described under **Every optional
+**Shared stateless defaults** — `OIMDefaults` (an instance passed as `defaults`, `OIMDefaults.INSTANCE`
+the empty one) and `OIMDefaultValue`, the lazy holder of each built-in default, which is built on its
+first `getValue()` instead of at module load, so a consumer that reaches none of them constructs none of them. The cost of the single door is described under **Every optional
 dependency has a default** above.
 
 That is the whole of `src/index.ts`. If a name is not on this list, it is not