@oimdb/core 4.0.1 → 4.1.0

package/llms.txt

@@ -6,33 +6,38 @@
 > written against the current source.
 >
 > **Services hold no data; state lives on slots.** An `OIMDB` owns the clock, the collector slot and
-> its `defaultChannelSlot`. A collection service (`OIMSlotCollectionService`) or a single slot service
+> its `defaultChannelSlot`. One channel per database; for isolation, a separate `OIMDB` — a write is
+> delivered at its own channel's flush to every effect on the slots it moved, so a second channel on
+> the same clock isolates nothing. A collection service (`OIMSlotCollectionService`) or a single slot service
 > (`OIMSingleSlotService`) is built once per collection type, and `service.createStoreSlot(db)` makes an
 > instance, a `TOIMStoreSlot`, which is NOT a slot (no owner, holds or effects) and carries its
 > `channelSlot`.
 > READS and minting are on the collection service and take the store slot first
 > (`cardService.getSlotByKey(cards, key)`, `holdSlotByKey`, `findSlotByKey`, `getSlots`, `getSlotCount`, the
-> column doors). WRITES are on `service.slotContentService` and take a slot
-> (`cardService.slotContentService.updateEntity(slot, patch)`) or, for a batch, the store slot
-> (`cardService.slotContentService.upsertEntities(cards, entities)`). There are NO by-key write doors:
-> get or find the slot, then write through it.
-> A single — one slot under no key — is an `OIMSingleSlotService`: `getSingleSlot(storeSlot)`,
-> `holdSingleSlot(storeSlot)`, `findSingleSlot(storeSlot)`.
+> column doors). One WRITE is on the collection and takes a key:
+> `cardService.writeSlotContentByKey(cards, key, entity)`, which mints the slot on a miss and writes the whole
+> value on a hit. Every other write is on `service.slotContentService` and takes a slot
+> (`cardService.slotContentService.updateEntity(slot, patch)`, `writeSlotContent(slot, entity)`,
+> `clearSlotContent(slot)`). There are NO bulk writes and no `keyOf`: the key is always the caller's. A load is a
+> loop of `writeSlotContentByKey` inside `cardService.writeInBatch(cards, () => { … })`, so an index on the
+> collection hears the whole loop in one call.
+> A single — one slot under no key — is an `OIMSingleSlotService`: `writeSingleSlotContent(storeSlot, value)`,
+> `getSingleSlot(storeSlot)`, `holdSingleSlot(storeSlot)`, `findSingleSlot(storeSlot)`,
+> `clearSingleSlotContent(storeSlot)`. No key is `void` or `undefined`: `TKey extends NonNullable<unknown>`.
 >
-> For entities the base layer is `createOIMSlotCollectionService({ slotContentService })` /
-> `createOIMSingleSlotService({ slotContentService })` over `createOIMSlotContentEntityService(db, …)`;
-> `createOIMEntityService` and `createOIMSingleEntityService` are convenience wrappers over it. A bucket
-> collection is `createOIMBucketService(db, { slotContentService })` (single:
-> `createOIMSingleBucketService`), where the content service is `new OIMSlotContentBucketServiceSetDriven()`,
-> `new OIMSlotContentBucketServiceArrayDriven()` (the default) or the sorted one; an index is
-> `createOIMIndexService(db, { entityService, keyOf | columns, slotContentService? })`, and
-> `createOIMIndexServiceByCompositeKey` is a convenience wrapper over it.
+> Every collection is `createOIMSlotCollectionService(db, { slotContentService })` and every single is
+> `createOIMSingleSlotService(db, { slotContentService })`. The content service decides what the slots hold:
+> `createOIMSlotContentEntityService<TEntity>(db, …)` for entities, `new OIMSlotContentSetBucketService()`,
+> `new OIMSlotContentPositionalArrayBucketService()` or `new OIMSlotContentSortedArrayBucketService({ … })` for
+> buckets. An index is `createOIMSlotCollectionIndexService(db, { entityService, keyOf | columns, slotContentService? })`;
+> its `keyOf` is the index's key of an entity, not the collection's. An array key needs a tree store:
+> `slotStoreService` on the collection, `bucketSlotStoreService` on the index.
 > Position reads and writes (`getBucketMemberSlotAt`, `getBucketMemberSlotPosition`, `insertBucketMemberSlotAt`,
 > `removeBucketMemberSlotAt`, `removeBucketMemberSlotRange`, `moveBucketMemberSlotToPosition`,
-> `moveBucketMemberSlotRangeToPosition`) are on `OIMSlotContentBucketServiceArrayDriven`, the default bucket
+> `moveBucketMemberSlotRangeToPosition`) are on `OIMSlotContentPositionalArrayBucketService`, the default bucket
 > content service; the set-driven one has none. A bucket sorts only on the sorted-at-write content service
-> (`createOIMIndexServiceSortedArrayDriven`); on every other bucket its order is the caller's. A sorted list
-> over any index is `createOIMComputedServiceSorted`. The render script is `OIMBucketCommands`.
+> (`createOIMSlotCollectionSortedArrayIndexService`); on every other bucket its order is the caller's. A sorted list
+> over any index is `createOIMSortedComputedService`. The render script is `OIMBucketCommands`.
 > The channel has no class: its operations are on `OIMChannelService.INSTANCE` and take a channel slot.
 > Effects are `OIMEffectService.INSTANCE.createEffect(db, sourceSlots, sourceComputeds, body)`.
 > Every stateless singleton is a static `INSTANCE` on its class. Module-level defaults are on `OIMDefaults`.
@@ -76,39 +81,7 @@ block and the one under [One derivation per key](#one-derivation-per-key). Block
 marked `ts signature` are listings of an API and are not compiled.
 
 ```ts setup
-import {
-    OIMChannelService,
-    OIMContentChangeListenerService,
-    OIMDB,
-    OIMDefaults,
-    OIMEffectService,
-    OIMSlotContentBucketServiceArrayDriven,
-    OIMSlotContentBucketServiceSetDriven,
-    OIMSlotStoreServiceMapDriven,
-    OIMSlotStoreServiceSingleSlotDriven,
-    OIMSlotStoreServiceTreeDriven,
-    OIMUnusedSlotCollectorService,
-    createOIMBucketService,
-    createOIMComputedServiceBucketMemo,
-    createOIMComputedService,
-    createOIMComputedServiceSorted,
-    createOIMEntityService,
-    createOIMEntityWriterInPlace,
-    createOIMEntityWriterReplacing,
-    createOIMIndexService,
-    createOIMIndexServiceSortedArrayDriven,
-    createOIMSingleBucketService,
-    createOIMSingleEntityService,
-    createOIMSlotCollectionService,
-    createOIMSlotContentEntityService,
-    createOIMUnusedSlotCollectorSlot,
-    oimIsSlotEmpty,
-    oimIsSlotReleased,
-    oimPatchEntityColumn,
-    oimPatchEntityColumns,
-    oimPutEntityColumns,
-    oimSameValueZeroGuard,
-} from '@oimdb/core';
+import { OIMChannelService, OIMContentChangeListenerService, OIMDB, OIMDefaults, OIMEffectService, OIMSlotContentPositionalArrayBucketService, OIMSlotContentSetBucketService, OIMSlotMapStoreService, OIMSingleSlotStoreService, OIMSlotTreeStoreService, OIMUnusedSlotCollectorService, createOIMBucketMemoComputedService, createOIMComputedService, createOIMSortedComputedService, createOIMEntityWriterInPlace, createOIMEntityWriterReplacing, createOIMSlotCollectionIndexService, createOIMSlotCollectionSortedArrayIndexService, createOIMSlotCollectionService, createOIMSlotContentEntityService, createOIMSingleSlotService, createOIMSingleComputedService, createOIMUnusedSlotCollectorSlot, oimIsSlotEmpty, oimIsSlotReleased, oimPatchEntityColumn, oimPatchEntityColumns, oimPutEntityColumns, oimSameValueZeroGuard, OIMBucketCommands, OIMSlotEarliestReleasePolicy, OIMSlotAfterWriteReleasePolicy, OIMSlotAfterIdleReleasePolicy, OIMThrowAtOnceErrorPolicy, type TOIMSlotStoreTree } from '@oimdb/core';
 import type {
     IOIMEntityWriter,
     TOIMSlotEditable,
@@ -117,6 +90,7 @@ import type {
     TOIMBucketSlotsSetStore,
     TOIMComputedSlot,
     TOIMDisposer,
+    TOIMEntityContentSlot,
     TOIMEntitySlot,
     TOIMOrderedListCommand,
     TOIMSingleSlotStore,
@@ -137,17 +111,15 @@ declare const payload: readonly Card[];
 const db = new OIMDB();
 const channelSlot = db.defaultChannelSlot;
 const effectService = OIMEffectService.INSTANCE;
-const cardService = createOIMEntityService<Card>(db, { keyOf: (card) => card.id });
+const cardService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db) });
 const cards = cardService.createStoreSlot(db);
-const slot = cardService.slotContentService.upsertEntity(cards, { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' });
+const slot = cardService.writeSlotContentByKey(cards, 'c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' });
 
-const orderedService = createOIMBucketService<TOIMEntitySlot<Card>>(db, {
-    slotContentService: new OIMSlotContentBucketServiceArrayDriven<TOIMEntitySlot<Card>>(),
-});
+const orderedService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<Card>>() });
 const ordered = orderedService.createStoreSlot(db);
 const orderedBucketSlot = orderedService.holdSlotByKey(ordered, 'top');
 
-const pageService = createOIMBucketService<TOIMEntitySlot<Card>>(db);
+const pageService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<Card>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const page = pageService.createStoreSlot(db);
 const todo = pageService.holdSlotByKey(page, 'todo');
 const done = pageService.holdSlotByKey(page, 'done');
@@ -159,26 +131,28 @@ const done = pageService.holdSlotByKey(page, 'done');
 
 | Layer | Contents |
 |---|---|
-| `src/engine/<domain>/` | the channel (`OIMChannelService`, `TOIMChannelSlot`), the flush scheduler (`OIMFlushSchedulerService`), the slot owner (`OIMSlotOwner`, and `OIMSlotOwnerService`, a type-only export), `OIMContentChangeListenerService`, the entity content service `OIMSlotContentEntityService`, `OIMComputedValueService`, `OIMEffectService`, the column owner (abstract `OIMColumnOwner` with the strategies `OIMColumnOwnerPushDriven` and `OIMColumnOwnerPullDriven`), the key stores and key tree walks, the index keys services, `TOIMStoreSlot`, `TOIMComputedSlot`, `TOIMEffect`, the collector services and slots, and the release policies |
-| `src/facade/<domain>/` | `facade/slot/`: `OIMSlotCollectionService`, `OIMSingleSlotService`; `facade/bucket/`: `OIMSlotContentBucketService` (abstract), `OIMSlotContentBucketServiceSetDriven`, `OIMSlotContentBucketServiceArrayBased` (abstract), `OIMSlotContentBucketServiceArrayDriven`, `OIMSlotContentBucketServiceSortedArrayDriven`, `OIMBucketCommands`; `facade/index/`: `OIMIndexService`, `OIMIndexServiceSortedArrayDriven`; `facade/computed/`: `OIMComputedService`, `OIMComputedServiceSorted`, `OIMComputedServiceBucketMemo` |
-| `src/factories/` | `OIMDB`, `OIMDefaults`, `OIMDefaultValue`; the base factories `createOIMSlotCollectionService`, `createOIMSingleSlotService`, `createOIMSlotContentEntityService`; the convenience wrappers `createOIMEntityService`, `createOIMSingleEntityService`, `createOIMBucketService`, `createOIMSingleBucketService`, `createOIMIndexServiceByCompositeKey`; `createOIMIndexService`, `createOIMIndexServiceSortedArrayDriven`, `createOIMComputedService`, `createOIMComputedServiceSorted`, `createOIMComputedServiceBucketMemo`, `createOIMEntityWriterInPlace`, `createOIMEntityWriterReplacing` |
+| `src/engine/<domain>/` | the channel (`OIMChannelService`, `TOIMChannelSlot`), the flush scheduler (`OIMFlushSchedulerService`), the slot owner (`OIMSlotOwner`, and `OIMSlotOwnerService`, a type-only export), `OIMContentChangeListenerService`, the entity content service `OIMSlotContentEntityService`, `OIMComputedValueService`, `OIMEffectService`, the column owner (abstract `OIMColumnSlotOwner` with the strategies `OIMPushColumnSlotOwner` and `OIMPullColumnSlotOwner`), the key stores and key tree walks, the index keys services, `TOIMStoreSlot`, `TOIMComputedSlot`, `TOIMEffect`, the collector services and slots, and the release policies |
+| `src/facade/<domain>/` | `facade/slot/`: `OIMSlotCollectionService`, `OIMWritableSlotCollectionService`, `OIMSingleSlotService`, `OIMWritableSingleSlotService`; `facade/column/`: `OIMColumnSlotService`; `facade/bucket/`: `OIMSlotContentBucketService` (abstract), `OIMSlotContentSetBucketService`, `OIMSlotContentArrayBucketService` (abstract), `OIMSlotContentPositionalArrayBucketService`, `OIMSlotContentSortedArrayBucketService`, `OIMBucketCommands`; `facade/index/`: `OIMSlotCollectionIndexService`, `OIMSlotCollectionSortedArrayIndexService`; `facade/computed/`: `OIMComputedService`, `OIMSortedComputedService`, `OIMBucketMemoComputedService` |
+| `src/factories/` | `OIMDB`, `OIMDefaults`, `OIMDefaultValue`; `createOIMSlotCollectionService`, `createOIMSingleSlotService`, `createOIMSlotContentEntityService`, `createOIMSlotCollectionIndexService`, `createOIMSlotCollectionSortedArrayIndexService`, `createOIMComputedService`, `createOIMSingleComputedService`, `createOIMSortedComputedService`, `createOIMBucketMemoComputedService`, `createOIMEntityWriterInPlace`, `createOIMEntityWriterReplacing` |
 
 **No class sits directly in `engine/` or `facade/`.** The directory is the
 domain: `engine/bucket/`, `engine/channel/`, `engine/collector/`, `engine/column/`, `engine/computed/`,
 `engine/entity/`, `engine/error/`, `engine/index/`, `engine/key/`, `engine/schedule/`, `engine/slot/`,
 `engine/store/`, each with its own `constants/`, `interfaces/`, `types/` and `utils/` beside its classes; and
-`facade/bucket/`, `facade/computed/`, `facade/index/`, `facade/slot/`.
+`facade/bucket/`, `facade/column/`, `facade/computed/`, `facade/index/`, `facade/slot/`.
 
 **A service holds no data; state lives on slots.** A collection service is built once per collection type
 and holds only configuration and other services: its slot owner, its store service and its content
 service (`service.slotContentService`). `service.createStoreSlot(db)` makes an instance, a `TOIMStoreSlot`,
 which is NOT a slot (no owner, holds or effects): its `store` is what the store service built, its
-`channelSlot` is the db's channel, and it carries the per-store state (content-change listeners, index key
-positions, bucket write queues, column readers). Every slot filed in it points back to it through
-`slot.storeSlot`, which is why a slot door needs no store slot. Reads are called on the service
-(`cardService.getSlotByKey(cards, pk)`, `cardService.getSlots(cards)`); writes on its content service
-(`cardService.slotContentService.updateEntity(slot, patch)`). A store slot's `store` is the store service's
-to read, never the caller's.
+`channelSlot` is the db's channel, its `slotService` is the service that made it, and it carries the per-store
+state (content-change listeners, index key positions, the open batch and its queued changes, column readers).
+Every slot filed in it points back to it through `slot.storeSlot`, which is why a slot door needs no store slot.
+Reads and the keyed write are called on the service (`cardService.getSlotByKey(cards, pk)`,
+`cardService.getSlots(cards)`, `cardService.writeSlotContentByKey(cards, pk, card)`, or through the store slot:
+`cards.slotService.writeSlotContentByKey(cards, pk, card)`); writes on a slot go to its content service
+(`cardService.slotContentService.updateEntity(slot, patch)`), and the column doors to
+`cardService.columnSlotService`. A store slot's `store` is the store service's to read, never the caller's.
 
 ---
 
@@ -192,20 +166,20 @@ effect, a count, or a tracked mint — so nothing can unfile the identity under
 the caller who just got it.
 
 ```ts
-cardService.slotContentService.upsertEntity(cards, { id: 'c2', title: 'Two', rank: 2, deck: 'spades' });  // write
+cardService.writeSlotContentByKey(cards, 'c2', { id: 'c2', title: 'Two', rank: 2, deck: 'spades' });  // write
 effectService.createEffect(db, [slot], [], () => { paint(slot.entity); });   // subscribe
 cardService.holdSlotByKey(cards, 'c1');                // hold, by key -> the slot, holdCount up by one
-const rankColumn = cardService.holdColumn(slot, 'rank');   // hold, on a column
-cardService.unholdColumn(rankColumn);                  // give the column back
+const rankColumn = cardService.columnSlotService.holdColumn(slot, 'rank');   // hold, on a column
+cardService.columnSlotService.unholdColumn(rankColumn);                  // give the column back
 cardService.getSlotByKey(cards, 'c1');                 // read, by key -> the slot, tracked by the collector
 ```
 
 **The non-minting lookup leaves no reference.** `findSlotByKey(storeSlot, key)` (and
 `findSingleSlot(storeSlot)` on a single) answers `undefined` on a miss and mints nothing, and the
-slot it does hand back is protected by nothing the caller took. `slotContentService.findEntityByKey`
-runs the same lookup. There are no by-key write doors: to change or remove an entity by key, find
-the slot first and write through it. Do not write a helper over any of the four doors — it would be a
-second spelling of a mint, not a fifth door.
+slot it does hand back is protected by nothing the caller took; the entity is
+`findSlotByKey(storeSlot, key)?.entity`. The one by-key write is `writeSlotContentByKey`, the write door
+above; to patch or clear an entity by key, find the slot first and write through it. Do not write a helper
+over any of the four doors — it would be a second spelling of a mint, not a fifth door.
 
 **Subscribing leaves BOTH kinds of reference.** `OIMEffectService.INSTANCE.createEffect(db, …)` files
 the effect in `slot.effects` *and* holds each root it subscribed to
@@ -237,13 +211,13 @@ owned by the object asked, and out of grace. Terms, and who gives each back:
 
 | Term | Given back by |
 |---|---|
-| `holdCount` | `slot.owner.unholdSlot(slot)`, or `service.unholdColumn(columnSlot)` for a column; the unused-slot collector's flush; a slot leaving a bucket; `effectService.disposeEffect(effect)`, for the hold the effect took |
+| `holdCount` | `slot.owner.unholdSlot(slot)`, or `service.columnSlotService.unholdColumn(columnSlot)` for a column; the unused-slot collector's flush; a slot leaving a bucket; `effectService.disposeEffect(effect)`, for the hold the effect took |
 | `effects` | `effectService.disposeEffect(effect)` |
 | a held column | its last column effect being disposed, through the service's column owner (`unsubscribeFromSlot`) |
-| the value | `entityService.slotContentService.deleteEntity(slot)`, or `bucketService.slotContentService.clearBucketMemberSlots(bucketSlot)` |
-| a composite-key edge | `OIMKeyTreeWalkComposite.deleteKey` unlinking that composite key part |
+| the value | `service.slotContentService.clearSlotContent(slot)`, on an entity slot or a bucket slot alike; `clearSingleSlotContent(storeSlot)` on a single |
+| a composite-key edge | `OIMCompositeKeyTreeWalk.deleteKey` unlinking that composite key part |
 
-`deleteEntity(slot)` takes the **value**. Subscribers stay, holds
+`clearSlotContent(slot)` takes the **value**. Subscribers stay, holds
 stay, and the identity stays with them. Slots you wrote into a bucket are held by
 that bucket until you empty it.
 
@@ -255,27 +229,36 @@ built from three stateless parts, wired once at construction, plus the injected
 | Part | Where | What it does |
 |---|---|---|
 | the slot owner, `OIMSlotOwnerService` (type-only export) | `slot.owner`, typed `IOIMSlotOwner` | holds, subscriptions, release, emptiness, `assertWritable`, the column owner; one per collection type |
-| the store service, `IOIMSlotStoreService` | given to the factory (`entitySlotStoreService`, `bucketSlotStoreService`, …) or the Map default | files and finds the slots of each store slot's `store` |
-| the content service | `service.slotContentService` | the writes and reads of one kind of content (`OIMSlotContentEntityService`, `OIMSlotContentBucketService*`) and the answers the owner asks of that kind |
+| the store service, `IOIMSlotStoreService` | given to the factory (`slotStoreService`, `bucketSlotStoreService`, …) or the Map default | files and finds the slots of each store slot's `store` |
+| the content service | `service.slotContentService` | the writes and reads of one kind of content (`OIMSlotContentEntityService`, the bucket content services, `OIMSlotContentComputedService`) and the answers the owner asks of that kind |
 
-The owner asks the content kind through one strategy object handed to it at construction, never
+The factory reads what it needs off the content service it is handed, through four small interfaces, never
 through a subclass of the service:
 
 ```ts signature
-interface IOIMSlotContentStrategy<TSlot, TKey, TSlotOwnerService> {
-    createSlot(key: TKey, storeSlot: TOIMStoreSlot | undefined, slotOwnerService: TSlotOwnerService): TSlot;
+interface IOIMKeyedSlotCreator<TKey extends NonNullable<unknown>, TSlot> {
+    createSlot(key: TKey, storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TSlot;
+}
+interface IOIMSingleSlotCreator<TSlot> {
+    createSingleSlot(storeSlot: TOIMStoreSlot, slotOwner: IOIMSlotOwner): TSlot;
+}
+interface IOIMSlotContentWriter<TSlot, TContent> {
+    insertSlotContent(slot: TSlot, content: TContent, changedSlots?: TSlot[]): void;
+    writeSlotContent(slot: TSlot, content: TContent): boolean;
+    clearSlotContent(slot: TSlot): void;
+}
+interface IOIMSlotContentService<TSlot, TSlotOwnerService extends IOIMSlotOwner = IOIMSlotOwner> {
     isSlotEmpty(slot: TSlot): boolean;
     releaseSlotContent(slot: TSlot, slotOwnerService: TSlotOwnerService): void;
     hasReference(slot: TSlot): boolean;
 }
-interface IOIMSlotContentFlushStrategy<TSlot, TSlotOwnerService> {
-    onSubframeClosed(storeSlot: TOIMStoreSlot<unknown, TSlot>, slotOwnerService: TSlotOwnerService): void;
-}
 ```
 
-`hasReference` answers whether something outside `holdCount` and `effects` keeps the slot (a
-bucket's members); the flush strategy is what a bucket content service delivers at the close of a
-subframe. Every write door asserts the identity is still filed and opens the channel's subframe.
+A content service with `createSlot` goes into `createOIMSlotCollectionService`, one with `createSingleSlot` into
+`createOIMSingleSlotService`; the entity and bucket content services have both. `hasReference` answers whether
+something outside `holdCount` and `effects` keeps the slot (a bucket's members). Every write door asserts the
+identity is still filed (`assertWritable`), and `releaseSlotContent` refuses inside a flush when the slot still
+has content.
 
 ### The injected seams
 
@@ -284,26 +267,26 @@ question that the engine asks but does not decide. There is no flag and no optio
 object.
 
 ```ts signature
-interface IOIMSlotEmptiness<TSlot> { isEmpty(slot: TSlot): boolean; }
+interface IOIMSlotEmptinessPolicy<TSlot> { isEmpty(slot: TSlot): boolean; }
 
 interface IOIMSlotStamp<TSlot> { stamp(slotEditable: TOIMSlotEditable<TSlot>): void; }
 ```
 
 **What a kind of content answers is not a seam.** Mint, write, clear and release
-belong to the content service, which the factory wires into the owner as its content strategy.
+belong to the content service, which the collection service hands its owner as `slotContentService`.
 "Does this still hold something" no part declares — the owner asks `oimIsSlotEmpty(slot)`,
 `hasReference` and the release policy's `isSlotReleasable` separately.
 
-**`IOIMSlotEmptiness`** decides what counts as empty, and the answer is written once
+**`IOIMSlotEmptinessPolicy`** decides what counts as empty, and the answer is written once
 per write into the EMPTY flag of `slot.slotFlags` — never recomputed at a read. The entity content
-service defaults to "the entity is `undefined`" (the `slotEmptiness` option of
+service defaults to "the entity is `undefined`" (the `slotEmptinessPolicy` option of
 `createOIMSlotContentEntityService` replaces it); a bucket content service answers "no members"; a
 computed answers `false`, because a derivation always has a value to produce.
 
-**Emptiness decides lifetime, never the write path.** An `upsertEntity` onto an entity slot that
-still carries an entity merges into it even when emptiness calls the slot empty (a
-soft delete, a seed planted by `IOIMSlotStamp`): a column the new entity drops is
-woken, an unchanged one is not, and an upsert that repeats the entity exactly wakes
+**Emptiness decides lifetime, never the write path.** A `writeSlotContent` (or `writeSlotContentByKey` on a
+hit) onto an entity slot that still carries an entity is put over it even when emptiness calls the slot empty
+(a soft delete, a seed planted by `IOIMSlotStamp`): a column the new entity drops is
+woken, an unchanged one is not, and a write that repeats the entity exactly wakes
 nothing. Only an entity slot with no entity at all is filled whole.
 
 **`IOIMSlotStamp`** writes onto the slot at every write, just before emptiness is
@@ -324,53 +307,67 @@ interface IOIMSlotReleasePolicy {
     cancelSlotRelease(slot: TOIMSlot): void;
 }
 
-new OIMSlotReleasePolicyAfterWrite({ keepAfterWriteMs: number })
-new OIMSlotReleasePolicyAfterIdle({ keepAfterIdleMs: number })
-new OIMSlotReleasePolicyAfterUnhold({ keepAfterUnholdMs: number })
-OIMSlotReleasePolicyAtUnhold.INSTANCE
-OIMSlotReleasePolicyAtEmpty.INSTANCE
-OIMSlotReleasePolicyNever.INSTANCE
-new OIMSlotReleasePolicyEarliest(slotReleasePolicies: readonly IOIMSlotReleasePolicy[])
+new OIMSlotAfterWriteReleasePolicy({ keepAfterWriteMs: number, slotReleaseDueFramePolicy?: IOIMSlotReleaseDueFramePolicy })
+OIMSlotReleaseAutoDueFramePolicy.INSTANCE
+new OIMSlotReleaseManualDueFramePolicy()   // openSlotReleaseDueFrame() · closeSlotReleaseDueFrame() · writeInSlotReleaseDueFrame(write)
+new OIMSlotAfterIdleReleasePolicy({ keepAfterIdleMs: number })
+new OIMSlotAfterUnholdReleasePolicy({ keepAfterUnholdMs: number })
+OIMSlotAtUnholdReleasePolicy.INSTANCE
+OIMSlotAtEmptyReleasePolicy.INSTANCE
+OIMSlotNeverReleasePolicy.INSTANCE
+new OIMSlotEarliestReleasePolicy(slotReleasePolicies: readonly IOIMSlotReleasePolicy[])
 ```
 
 `releasesWrittenSlots` is whether the policy can ever release a slot that holds
 data; a service reads it once at construction and skips the after-write
-release check when it is false (`OIMSlotReleasePolicyAtEmpty`, `OIMSlotReleasePolicyNever`: false;
-`OIMSlotReleasePolicyAtUnhold` and the timed policies: true; `OIMSlotReleasePolicyEarliest`: true
+release check when it is false (`OIMSlotAtEmptyReleasePolicy`, `OIMSlotNeverReleasePolicy`: false;
+`OIMSlotAtUnholdReleasePolicy` and the timed policies: true; `OIMSlotEarliestReleasePolicy`: true
 when any policy it combines is).
 
 `schedulesReleaseOnWrite` is whether a write can make the policy schedule a release; a service
 reads it once at construction and, when it is false and no `slotStamp` is set, skips `onSlotWritten`
-and the first-fill `onSlotIdle` on every write (`OIMSlotReleasePolicyAfterWrite`, `OIMSlotReleasePolicyAfterIdle`:
-true; `OIMSlotReleasePolicyAtEmpty`, `OIMSlotReleasePolicyNever`, `OIMSlotReleasePolicyAtUnhold`,
-`OIMSlotReleasePolicyAfterUnhold`: false; `OIMSlotReleasePolicyEarliest`: true when any policy it combines is).
+and the first-fill `onSlotIdle` on every write (`OIMSlotAfterWriteReleasePolicy`, `OIMSlotAfterIdleReleasePolicy`:
+true; `OIMSlotAtEmptyReleasePolicy`, `OIMSlotNeverReleasePolicy`, `OIMSlotAtUnholdReleasePolicy`,
+`OIMSlotAfterUnholdReleasePolicy`: false; `OIMSlotEarliestReleasePolicy`: true when any policy it combines is).
 `onSlotIdle` is still called when the last subscriber leaves.
 
 A policy decides whether and when a slot goes; it does no work itself. A
 factory, and `OIMDB` (whose `slotReleasePolicy` option every factory reads as its default), takes ONE
 through the option `slotReleasePolicy`. With none, the slot owner is built with
-`OIMSlotReleasePolicyAtEmpty`, so a slot with a value stays for good and an empty
+`OIMSlotAtEmptyReleasePolicy`, so a slot with a value stays for good and an empty
 one with nothing holding it goes; there is no "no policy" branch on any path.
-Computed services default to `OIMSlotReleasePolicyAtUnhold`.
+Computed services default to `OIMSlotAtUnholdReleasePolicy`.
 
 | Policy | A slot goes |
 |---|---|
-| `OIMSlotReleasePolicyAfterWrite` | once its last write is older than `keepAfterWriteMs` |
-| `OIMSlotReleasePolicyAfterIdle` | once nothing has watched it for `keepAfterIdleMs` |
-| `OIMSlotReleasePolicyAfterUnhold` | once `keepAfterUnholdMs` has passed since its LAST unhold; a hold taken again inside the window keeps it |
-| `OIMSlotReleasePolicyAtUnhold` | at the last unhold, even with a value |
-| `OIMSlotReleasePolicyAtEmpty` | once it has no value and nothing holds it; a computed, never empty, stays while its owner lives |
-| `OIMSlotReleasePolicyNever` | never, empty or not; a deleted key's slot stays filed |
-| `OIMSlotReleasePolicyEarliest` | when the earliest deadline of its members falls due — a `min` over deadlines |
-
-The collectors' state lives on the db's collector slot, one per `OIMDB`:
-`db.collectorSlot.afterWriteReleaseSlotCollectorSlot`, `afterIdleReleaseSlotCollectorSlot` and
-`afterUnholdReleaseSlotCollectorSlot`, swept by the stateless
-`OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE` / `OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE` /
-`OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE`. The
+| `OIMSlotAfterWriteReleasePolicy` | once its last write is older than `keepAfterWriteMs` |
+| `OIMSlotAfterIdleReleasePolicy` | once nothing has watched it for `keepAfterIdleMs` |
+| `OIMSlotAfterUnholdReleasePolicy` | once `keepAfterUnholdMs` has passed since its LAST unhold; a hold taken again inside the window keeps it |
+| `OIMSlotAtUnholdReleasePolicy` | at the last unhold, even with a value |
+| `OIMSlotAtEmptyReleasePolicy` | once it has no value and nothing holds it; a computed, never empty, stays while its owner lives |
+| `OIMSlotNeverReleasePolicy` | never, empty or not; a deleted key's slot stays filed |
+| `OIMSlotEarliestReleasePolicy` | when the earliest deadline of its members falls due — a `min` over deadlines |
+
+**WHICH WRITES MOVE THE WRITE DEADLINE is a strategy of `OIMSlotAfterWriteReleasePolicy`**,
+`slotReleaseDueFramePolicy`, chosen at construction. `OIMSlotReleaseAutoDueFramePolicy` (the default)
+makes every write its own frame, so every write moves the deadline. `OIMSlotReleaseManualDueFramePolicy`
+moves it only for writes made while one of its frames is open: `openSlotReleaseDueFrame()` and
+`closeSlotReleaseDueFrame()` (which throws by name when no frame is open), or
+`writeInSlotReleaseDueFrame(write)`, which opens, calls `write` and closes in a `finally`. One Manual object
+can be passed to several `OIMSlotAfterWriteReleasePolicy` policies with different windows: one frame then moves each slot's
+deadline by its own collection's window. This is what keeps a local edit or a client-only field from
+extending data that only a server response should refresh. `write` must be synchronous: a frame closes
+when the function returns.
+
+The release wheels live on the db's collector slot, at most one of each per `OIMDB`:
+`db.collectorSlot.afterWriteSlotReleaseWheel`, `afterIdleSlotReleaseWheel` and
+`afterUnholdSlotReleaseWheel`, each an `OIMSlotReleaseWheel` that holds its own slices, timer and clock.
+A wheel is created by the first policy that needs it, through `oimMintAfterWriteSlotReleaseWheel(collectorSlot)`
+(and its after-idle and after-unhold twins), which returns the existing wheel or creates it; until then the field is
+`undefined`, and a db with no timed policy never pulls the wheel code into a bundle. The
 clock and the timer are the db's: pass `new OIMDB({ getNowMs, releaseTimer })` to control time (tests),
-and sweep with `OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(db.collectorSlot.afterIdleReleaseSlotCollectorSlot)`.
-`OIMSlotReleasePolicyAtUnhold` is the zero window and has no collector.
+and sweep with `oimMintAfterIdleSlotReleaseWheel(db.collectorSlot).flush()`.
+`OIMSlotAtUnholdReleasePolicy` is the zero window and has no collector.
 
 A zero window never touches a release queue or a timer: when a slot goes idle with
 `onSlotIdle` answering `true`, it is released at once if nothing holds it, and
@@ -379,16 +376,11 @@ leaves at the end of the frame. A window above zero is filed in that policy's ow
 queue.
 
 ```ts
-import {
-    OIMSlotReleasePolicyAfterIdle,
-    OIMSlotReleasePolicyAfterWrite,
-    OIMSlotReleasePolicyEarliest,
-} from '@oimdb/core';
 
 const releasingDb = new OIMDB({
-    slotReleasePolicy: new OIMSlotReleasePolicyEarliest([
-        new OIMSlotReleasePolicyAfterWrite({ keepAfterWriteMs: 60_000 }),
-        new OIMSlotReleasePolicyAfterIdle({ keepAfterIdleMs: 30_000 }),
+    slotReleasePolicy: new OIMSlotEarliestReleasePolicy([
+        new OIMSlotAfterWriteReleasePolicy({ keepAfterWriteMs: 60_000 }),
+        new OIMSlotAfterIdleReleasePolicy({ keepAfterIdleMs: 30_000 }),
     ]),
 });
 ```
@@ -400,9 +392,9 @@ no other:
 
 | Marker | Moved by | Not moved by |
 |---|---|---|
-| `releaseDueAfterWriteMs` | every write, under `OIMSlotReleasePolicyAfterWrite` | a subscriber arriving or leaving |
-| `releaseDueAfterIdleMs` | the first content of a slot with no subscriber, and the departure of the last subscriber, under `OIMSlotReleasePolicyAfterIdle` | a later write, and the give-back of a hold |
-| `releaseDueAfterUnholdMs` | every last unhold, under `OIMSlotReleasePolicyAfterUnhold` | a write |
+| `releaseDueAfterWriteMs` | every write, under `OIMSlotAfterWriteReleasePolicy` | a subscriber arriving or leaving |
+| `releaseDueAfterIdleMs` | the first content of a slot with no subscriber, and the departure of the last subscriber, under `OIMSlotAfterIdleReleasePolicy` | a later write, and the give-back of a hold |
+| `releaseDueAfterUnholdMs` | every last unhold, under `OIMSlotAfterUnholdReleasePolicy` | a write |
 
 `-1` means unset. A slot goes on the SOONEST of those that are set — each
 marker is an eviction deadline, so whichever says "out" first decides — and a
@@ -423,8 +415,8 @@ now; `false` keeps it, and a policy with a finite deadline has itself filed the
 slot into its release queue (a marker of `-1` is kept with nothing scheduled).
 An **empty** slot is released without asking, and a service given no release
 policy keeps a non-empty slot. `OIMComputedService` defaults its policy to
-`OIMSlotReleasePolicyAtUnhold`, which always answers `true`, so a derivation
-nothing refers to goes at once. `OIMSlotReleasePolicyEarliest` asks every member
+`OIMSlotAtUnholdReleasePolicy`, which always answers `true`, so a derivation
+nothing refers to goes at once. `OIMSlotEarliestReleasePolicy` asks every member
 and answers `true` if any does.
 
 **AN IDLE WINDOW OPENS IN EXACTLY TWO PLACES, AND NOWHERE ELSE:**
@@ -435,7 +427,7 @@ and answers `true` if any does.
 2. **when the LAST SUBSCRIBER leaves** — `OIMSlotOwner.unsubscribeFromSlot` empties
    `slot.effects` and runs the idle step, which opens one.
 
-Both ask the policy's `onSlotIdle(slot)`; under `OIMSlotReleasePolicyAfterIdle`
+Both ask the policy's `onSlotIdle(slot)`; under `OIMSlotAfterIdleReleasePolicy`
 it stamps `releaseDueAfterIdleMs` and files the slot into the policy's queue. An
 **empty** slot gets no window, and the release guard takes it without asking a
 clock at all.
@@ -449,60 +441,65 @@ therefore taken at the give-back and not one window later.
 nothing — and the queue has taken the slot off its slice, so nothing re-files it.
 The give-back is where the guard is asked again.
 
-### The two release collectors
+### The release wheels
 
-Each of `OIMSlotReleasePolicyAfterWrite`, `OIMSlotReleasePolicyAfterIdle` and
-`OIMSlotReleasePolicyAfterUnhold` is swept by its own stateless collector service, and the difference
-between them is WHICH MARKER it reads — there is no flag, and no branch on the sweep path. Their state is
-one release collector slot each, on the db's collector slot.
+Each of `OIMSlotAfterWriteReleasePolicy`, `OIMSlotAfterIdleReleasePolicy` and
+`OIMSlotAfterUnholdReleasePolicy` files into its own release wheel, and the difference between the wheels
+is WHICH MARKER each reads and writes — injected at construction, so there is no flag and no branch on the
+sweep path. A wheel is an aggregate: its slices, its timer and its clock are fields of the object.
 
 ```ts signature
-abstract class OIMReleaseSlotCollectorService {
+abstract class OIMSlotWheel {
+    readonly getNowMs: () => number;
+    getNextSliceNumber(): number | undefined;          // the nearest filed slice, or undefined
+    sweepUpToSliceNumber(upToSliceNumber: number): void;
+    flush(): void;                                     // sweeps what is due now and re-arms the timer
+    cancelAllSlots(): void;                            // takes the timer down and drops every filing
+}
+class OIMSlotReleaseWheel extends OIMSlotWheel {
+    constructor(options: TOIMSlotReleaseWheelOptions); // { getNowMs, timer, errorPolicy, getReleaseDueMs, setReleaseDueMs, releaseScheduledSlotFlag }
     readonly getReleaseDueMs: (slot: TOIMSlot) => number;
-    getReleaseSlotCollectorSlot(collectorSlot: TOIMCollectorSlot): TOIMReleaseSlotCollectorSlot;
-    getReleaseSlotCollectorSlotOf(slot: TOIMSlot): TOIMReleaseSlotCollectorSlot;
-    markSlotReleaseDue(releaseSlotCollectorSlot, slot, keepMs): number; // stamps now + keepMs on this marker, returns now
-    isSlotReleasable(releaseSlotCollectorSlot, slot): boolean;          // due now; if not yet, files it on the queue
-    cancelSlotRelease(releaseSlotCollectorSlot, slot): void;            // no-op for a slot whose marker is -1
-    flush(releaseSlotCollectorSlot): void;
-    cancelAllSlotReleases(releaseSlotCollectorSlot): void;
+    markSlotReleaseDue(slot, keepMs): number;          // stamps now + keepMs on this marker, returns now
+    markSlotReleaseDueNow(slot): void;                 // the marker is now; an unheld, unwatched slot goes at once
+    scheduleSlotRelease(slot, nowMs): void;            // files the slot at its marker; -1 or already filed files nothing
+    isSlotReleasable(slot): boolean;                   // due now; if not yet, files it on the wheel
+    cancelSlotRelease(slot): void;                     // no-op for a slot whose marker is -1
+    isSlotReleaseScheduled(slot): boolean;
 }
-OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE
-OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE
-OIMReleaseSlotCollectorServiceAfterUnhold.INSTANCE
 
 type TOIMCollectorSlot = {
     readonly unusedSlotCollectorSlot: TOIMUnusedSlotCollectorSlot;
-    readonly afterIdleReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
-    readonly afterWriteReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
-    readonly afterUnholdReleaseSlotCollectorSlot: TOIMReleaseSlotCollectorSlot;
+    readonly slotWheelOptions: TOIMSlotWheelOptions;              // the db's clock, timer and error policy
+    afterIdleSlotReleaseWheel: OIMSlotReleaseWheel | undefined;   // created on first use
+    afterWriteSlotReleaseWheel: OIMSlotReleaseWheel | undefined;
+    afterUnholdSlotReleaseWheel: OIMSlotReleaseWheel | undefined;
 };
+oimMintAfterWriteSlotReleaseWheel(collectorSlot): OIMSlotReleaseWheel   // and …AfterIdle…, …AfterUnhold…
 ```
 
 The clock (`getNowMs`, default `Date.now`), the timer (`releaseTimer`, default an unref'd `setTimeout`)
-and the `errorPolicy` (default `OIMErrorPolicyLogAndContinue.INSTANCE`) are `OIMDB` options, shared by the
+and the `errorPolicy` (default `OIMLogAndContinueErrorPolicy.INSTANCE`) are `OIMDB` options, shared by the
 channel and every release collector of that db. A release that throws inside a hand-called `flush` throws to
 that caller; one that throws on the collector's own timer tick has no caller and goes to the db's
 `errorPolicy`. So one error policy on the db routes every error through one place:
 
 ```ts
-import { OIMErrorPolicyThrowAtOnce, OIMSlotReleasePolicyAfterIdle } from '@oimdb/core';
 
 const oneSinkDb = new OIMDB({
-    errorPolicy: new OIMErrorPolicyThrowAtOnce(),
-    slotReleasePolicy: new OIMSlotReleasePolicyAfterIdle({ keepAfterIdleMs: 30_000 }),
+    errorPolicy: new OIMThrowAtOnceErrorPolicy(),
+    slotReleasePolicy: new OIMSlotAfterIdleReleasePolicy({ keepAfterIdleMs: 30_000 }),
 });
 ```
 
-| Collector service | Reads | What renews it | What does not |
+| Wheel | Reads | What renews it | What does not |
 |---|---|---|---|
-| `OIMReleaseSlotCollectorServiceAfterIdle` | `releaseDueAfterIdleMs` | the first content of a slot, and the give-back of the last hold | a later write |
-| `OIMReleaseSlotCollectorServiceAfterWrite` | `releaseDueAfterWriteMs` | every write, under its policy | a subscriber arriving or leaving |
-| `OIMReleaseSlotCollectorServiceAfterUnhold` | `releaseDueAfterUnholdMs` | every last unhold | a hold taken again inside the window |
+| `afterIdleSlotReleaseWheel` | `releaseDueAfterIdleMs` | the first content of a slot, and the give-back of the last hold | a later write |
+| `afterWriteSlotReleaseWheel` | `releaseDueAfterWriteMs` | every write, under its policy | a subscriber arriving or leaving |
+| `afterUnholdSlotReleaseWheel` | `releaseDueAfterUnholdMs` | every last unhold | a hold taken again inside the window |
 
-**A CONSUMER MAY RUN BOTH, AND THEY SHARE NOTHING.** Each has its own release collector slot with its own
-queue and its own scheduled run. Whichever deadline falls due first takes the slot, and
-nothing has to be reconciled: `OIMSlotReleasePolicyEarliest` answers a `min`
+**A CONSUMER MAY RUN BOTH, AND THEY SHARE NOTHING.** Each wheel has its own slices and its own
+scheduled run. Whichever deadline falls due first takes the slot, and
+nothing has to be reconciled: `OIMSlotEarliestReleasePolicy` answers a `min`
 over its members' deadlines, so a sweep of either queue reaches the same verdict.
 
 **NEITHER MEANS UNREAD.** No read is seen and no door reports one: an identity a
@@ -517,7 +514,7 @@ The slot owner's `releaseSlotIfUnheld` checks `holdCount > 0`, then
 `oimIsSlotReleased(slot)`, then `slot.owner !== this`, then `hasReference(slot)`, and
 only then — on a slot that is not empty — asks the policy's `isSlotReleasable`; an empty slot
 asks `isEmptySlotReleasable` instead, which every policy but
-`OIMSlotReleasePolicyNever` answers `true`. So only `OIMSlotReleasePolicyNever`
+`OIMSlotNeverReleasePolicy` answers `true`. So only `OIMSlotNeverReleasePolicy`
 keeps an identity that holds nothing.
 
 **A release that falls inside a flush waits for it to end.** Releasing a slot
@@ -529,7 +526,7 @@ back once the flush is over; the release then runs. An empty slot needs no write
 and goes at once.
 
 *The `owner !== this` line costs no lookup. A KEYLESS slot — a single's, filed in an
-`OIMSlotStoreServiceSingleSlotDriven` store — goes through the same guard under its service's policy: an
+`OIMSingleSlotStoreService` store — goes through the same guard under its service's policy: an
 emptied single bucket nothing holds is released like a keyed one, and the single service's
 `getSingleSlot(storeSlot)` mints a fresh slot on the next read.*
 
@@ -560,28 +557,35 @@ Pinned by `engine/collector/tests/what-a-stale-index-takes-with-it.test.ts`,
 
 ### The release guard, and who fires it
 
-**THE QUEUE DECIDES AT A DEADLINE, NOT THE OWNER.**
-`OIMReleaseSlotQueueService.INSTANCE.releaseDueUpToSliceNumber`, per slot in a slice at or below the one due:
+**THE WHEEL DECIDES AT A DEADLINE, NOT THE OWNER.**
+`OIMSlotReleaseWheel.sweepUpToSliceNumber`, per slot in a slice at or below the one due:
 
-1. `oimIsSlotReleased(slot)` → skip it;
-2. its own marker, read through `getReleaseDueMs(slot)` — the ONE field this queue
+1. its bit is clear → a stale entry, skip it; `oimIsSlotReleased(slot)` → skip it;
+2. its own marker, read through `getReleaseDueMs(slot)` — the ONE field this wheel
    answers for;
-3. `-1` → the slot is dropped from the queue: this policy does not claim it;
-4. a moment still in the future → the queue **re-files the slot itself**, into
+3. `-1` → the slot is dropped from the wheel: this policy does not claim it;
+4. a moment still in the future → the wheel **re-files the slot itself**, into
    `oimSliceOfMs(getReleaseDueMs)` through its own slice arithmetic;
 5. a moment already passed → `slot.owner.releaseSlotIfUnheld(slot)`, which asks the
-   policy's `isSlotReleasable` and so declines when the other policy still keeps
-   the slot.
+   policy's `isSlotReleasable` and so declines when the other policy still keeps the
+   slot, or when the slot is held.
+
+**INVALIDATING IS MARKING THE DEADLINE NOW.** `wheel.markSlotReleaseDueNow(slot)` sets this wheel's
+marker to now and hands the slot to `slot.owner.releaseSlotIfUnheld(slot)` at once: a slot nothing
+holds or watches goes with its data; a held or watched slot stays, keeps its data, and goes the moment
+its last hold or subscriber leaves, because its deadline is already past. The next marked write moves
+the marker a window ahead again. It writes no content, so it wakes no effect.
 
 The owner files nothing from inside a sweep. It **opens** a window on its own
 events, through the policy's `onSlotIdle` — when a slot first gets content, and
 when the last subscriber leaves — and `onSlotUnheld` on the give-back of the last hold.
 
-**A SLOT ALREADY ON A QUEUE STAYS WHERE IT IS.** `scheduleSlotRelease` of a slot filed
-at a slice no later than its new deadline moves nothing: the sweep re-reads the
-deadline when that slice comes due and re-files the slot then (the timing-wheel
-lazy re-insertion). So a write to a queued entity slot costs the queue one `Map.get`, not
-an unfile and a refile.
+**A SLOT ALREADY ON A QUEUE STAYS WHERE IT IS.** `scheduleSlotRelease` of a slot that is
+already filed moves nothing: the sweep re-reads the deadline when that slice comes
+due and re-files the slot then (the timing-wheel lazy re-insertion). So a write to a
+queued entity slot costs the queue one bit test, not an unfile and a refile. A
+deadline only ever moves later — each policy adds a fixed window to a clock that
+does not go back — so the slice a slot already sits in is never later than its deadline.
 
 `releaseSlotIfUnheld(slot)` is the guard, and it releases only when all of
 `holdCount === 0`, `oimIsSlotReleased(slot)` is false, `slot.owner === this`,
@@ -591,7 +595,7 @@ happens to it. On a slot that is not empty with time still owed, `isSlotReleasab
 answers `false` and the policy files the slot into its queue at its own marker, so a
 filing can neither shorten nor extend a deadline. That is the path from `unholdSlot` and from a write, never from a
 sweep, which had already re-filed at step 4. Releasing hands the slot to the
-content strategy's `releaseSlotContent` (which gives back what the content held),
+content service's `releaseSlotContent` (which gives back what the content held),
 marks the slot empty, calls the policy's `cancelSlotRelease(slot)`, unfiles the key
 through the store service's `remove`, and sets the RELEASED flag in `slot.slotFlags`. The `owner` is NOT cleared — the slot keeps
 pointing at the object that let it go, which is what makes `slot.owner !== this`
@@ -604,48 +608,48 @@ opposite:
   `oimIsSlotReleased(slot)` and returns; it does not throw. A sweep meeting a slot
   something else already let go must not raise.
 - **Trying to WORK with a released slot throws by name.** `assertNotReleased`
-  guards the content services' write doors (`writeEntity`, `deleteEntity`, `updateEntity`, `markEntityChanged`,
-  `writeBucketMemberSlots`, `clearBucketMemberSlots`, `markContentChanged`) and the reference doors (`holdSlot`, `unholdSlot`, `subscribeToSlot`,
+  guards the content services' write doors (`writeSlotContent`, `clearSlotContent`, `updateEntity`, `markEntityChanged`,
+  `addBucketMemberSlot`, `removeBucketMemberSlot`, `markContentChanged`) and the reference doors (`holdSlot`, `unholdSlot`, `subscribeToSlot`,
   `unsubscribeFromSlot`). The refusal message starts `This identity was released:`.
 
-### The collectors
+### The wheels and the unused-slot collector
 
 ```ts signature
-OIMReleaseSlotCollectorServiceAfterWrite.INSTANCE   // and …AfterIdle, …AfterUnhold
-OIMReleaseSlotQueueService.INSTANCE
+oimMintAfterWriteSlotReleaseWheel(db.collectorSlot)   // and …AfterIdle…, …AfterUnhold…
+new OIMSlotRefetchWheel(options: TOIMSlotRefetchWheelOptions)   // { slotRefetchListener, getNowMs?, timer?, errorPolicy? }
 OIMUnusedSlotCollectorService.INSTANCE
 createOIMUnusedSlotCollectorSlot(): TOIMUnusedSlotCollectorSlot
 ```
 
-All are stateless; each works on a slot handed to it. The release collector services extend
-`OIMFlushSchedulerService`.
-
-**A release collector service** is the clock. It sweeps the queue of the release collector slot it is
-given on `flush(releaseSlotCollectorSlot)` and re-schedules itself to the next deadline.
-`cancelAllSlotReleases(releaseSlotCollectorSlot)` cancels and empties the queue; the next scheduled release
-schedules it again. The clock (`getNowMs`) and the timer come from the db, so a test drives them through
-`new OIMDB({ getNowMs, releaseTimer })`. The default timer is a `setTimeout` that calls `unref`
-where the platform has it, so an idle Node process is not held open.
-
-**`OIMReleaseSlotQueueService`** files the slots of one release collector slot into **time slices**, not
-into one entry each; the collector service's `getReleaseDueMs` is the ONE marker it answers for, which is
-what makes two queues over two markers independent. `oimSliceOfMs(ms)` is `Math.floor(ms / OIM_SLICE_LENGTH_MS)` and
-`OIM_SLICE_LENGTH_MS` is `1024`, so every slot due inside the same ~1s slice
-shares one `Set` and one timer. Its doors, each taking the release collector slot first:
-
-| Door | What it does |
-|---|---|
-| `scheduleSlotRelease(releaseSlotCollectorSlot, slot, …)` | read this queue's own marker off the slot and file it into that slice (a marker already past now files at now's slice), then schedule the collector. A marker of `-1` files nothing |
-| `cancelSlotRelease(releaseSlotCollectorSlot, slot)` | take it off |
-| `isSlotReleaseScheduled(releaseSlotCollectorSlot, slot)` | is it filed |
-| `getNextReleaseSliceNumber(releaseSlotCollectorSlot)` | the nearest filed slice number, or `undefined` |
-| `releaseDueUpToSliceNumber(releaseSlotCollectorSlot, …)` | the sweep: for every slice at or below the one due, read the marker and then drop it (`-1`), re-file it itself (still in the future), or call `slot.owner.releaseSlotIfUnheld(slot)` |
-| `cancelAllSlotReleases(releaseSlotCollectorSlot)` | drop every filing |
-
-A slot re-filed during a sweep cannot land in a slice the same sweep is still
-walking: the sweep raises a floor for its duration, so a re-file — the queue's own
-at step 4, or one `releaseSlotIfUnheld` makes — goes to the next slice and is looked
-at next time, not in a loop.
+**A wheel is the clock.** `OIMSlotWheel` extends `OIMFlushSchedulerService` and is its own scheduled slot:
+`flush()` sweeps what is due and re-arms the timer to the next deadline. `cancelAllSlots()` takes the timer
+down and drops every filing; the next filing arms it again. The release wheels take the clock (`getNowMs`)
+and the timer from the db, so a test drives them through `new OIMDB({ getNowMs, releaseTimer })`. The default
+timer is a `setTimeout` that calls `unref` where the platform has it, so an idle Node process is not held open.
+
+**A wheel files slots into time slices**, not one entry each. `oimSliceOfMs(ms)` is
+`Math.floor(ms / OIM_SLICE_LENGTH_MS)` and `OIM_SLICE_LENGTH_MS` is `1024`, so every slot due inside the
+same ~1s slice shares one array and one timer.
+
+**WHETHER A SLOT IS ON A RELEASE WHEEL IS A BIT ON THE SLOT, NOT A MAP.** Each of the three release
+wheels of a db owns one bit of `slot.slotFlags` (`releaseScheduledSlotFlag`, `4`, `8`, `16`), so a slot
+can sit on all three at once, once on each. Filing pushes the slot onto its slice's array and sets the
+bit; cancelling clears the bit and leaves the entry, which the sweep skips when its slice comes due. A
+cancelled slot therefore keeps its slice named by `getNextSliceNumber` until that sweep.
+
+A slot re-filed during a sweep cannot land in a slice the same sweep is still walking: the sweep raises a
+floor for its duration, so a re-file — the wheel's own at step 4, or one a release makes — goes to the next
+slice and is looked at next time, not in a loop.
+
+**`OIMSlotRefetchWheel` is a wheel of slots due a refetch at an explicit time.** It computes no deadline,
+keeps no bit and no field on the slot: `scheduleSlotRefetchAt(slot, atMs)` files an entry into the slice
+of `atMs`, every call files one more. Its sweep takes only slices that have fully elapsed, skips released
+slots, drops slots nobody subscribes to, and calls `slotRefetchListener.onSlotsRefetchDue(slots)` ONCE per
+sweep with every watched slot that came due; the array is reused and emptied after the call, so a listener
+does not keep it. Moving a refetch earlier is another `scheduleSlotRefetchAt`; the listener decides from
+its own data whether an entry is current, so an early or duplicate entry is skipped there. The wheel is
+created by whoever needs it, not by the db, and its clock, timer and error policy default to `Date.now`,
+an unref'd `setTimeout` and `OIMLogAndContinueErrorPolicy.INSTANCE`.
 
 **The unused-slot collector** has nothing to do with time. It is the one that makes
 `getSlotByKey(storeSlot, key)` safe: `OIMUnusedSlotCollectorService.INSTANCE.holdSlotUntilFlush(unusedSlotCollectorSlot, slot)`
@@ -709,12 +713,12 @@ path. There is no `if (inPlace)` anywhere in the engine.
 | Fork | Strategies |
 |---|---|
 | how a write lands | `createOIMEntityWriterInPlace()` / `createOIMEntityWriterReplacing()` |
-| how a bucket holds slots | `OIMSlotContentBucketServiceSetDriven` / `OIMSlotContentBucketServiceArrayDriven` (the positions are the caller's) |
-| what naming a slot records | `OIMBucketArrayMembershipNonUnique` / `OIMBucketArrayMembershipUnique`, the `bucketArrayMembership` option of `OIMSlotContentBucketServiceArrayDriven` |
-| which writes re-sort a sorted list | `sortColumns` (only a write changing one of them on a member) / `comparator` alone (any member write), the options of `createOIMComputedServiceSorted` |
+| how a bucket holds slots | `OIMSlotContentSetBucketService` / `OIMSlotContentPositionalArrayBucketService` (the positions are the caller's) |
+| what naming a slot records | `bucketMemberSlotsArrayService: OIMBucketMemberSlotsArrayService` (one per mention, the default) / `new OIMBucketUniqueMemberSlotsArrayService<TSlot>()` (one per slot), on either array bucket |
+| which writes re-sort a sorted list | `sortColumns` (only a write changing one of them on a member) / `comparator` alone (any member write), the options of `createOIMSortedComputedService` |
 | how a key is addressed | `OIMDefaults.KEY_TREE_WALK_SCALAR` / `OIMDefaults.KEY_TREE_WALK_COMPOSITE` |
-| when a slot may go | `OIMSlotReleasePolicyAfterIdle` / `OIMSlotReleasePolicyAfterWrite`, either or both |
-| who decides a bucket's slots | a bucket collection (`createOIMBucketService`, the caller) / an index (`createOIMIndexService`, filed from the entity's own key) |
+| when a slot may go | `OIMSlotAfterIdleReleasePolicy` / `OIMSlotAfterWriteReleasePolicy`, either or both |
+| who decides a bucket's slots | a bucket collection (`createOIMSlotCollectionService` over a bucket content service, the caller) / an index (`createOIMSlotCollectionIndexService`, filed from the entity's own key) |
 
 **One strategy per kind per app.** A V8 call site is shared by every service
 that runs the same engine code, so mixing strategies of one kind in one process
@@ -724,7 +728,7 @@ V8 still caches each one and can still inline
 per-site cache and no inlining through it. The kinds that count: release policies
 (the `IOIMSlotReleasePolicy` strategies), set-driven vs array-driven buckets and indexes, entity
 writers (`createOIMEntityWriterInPlace` / `createOIMEntityWriterReplacing`) and
-`TOIMEntityInsertStrategy`, `TOIMSameValueGuard`, `IOIMSlotEmptiness`, and
+`TOIMEntityInserter`, `TOIMSameValueGuard`, `IOIMSlotEmptinessPolicy`, and
 `TOIMChannelScheduler`. Two or three of one kind is fine; five release policies in
 one process is not. The pair
 `alt.slot-shape.three-shapes-against-one-at-the-write` measures three slot shapes
@@ -735,27 +739,23 @@ Generate code with one strategy per kind unless the task names a second.
 
 `createStoreSlot(db)` stamps the db's `defaultChannelSlot` on the store slot, and every write to its slots
 is reported to that channel. No service holds a channel; there is no `channel` option and no
-`unusedSlotCollector` option. The base layer and the convenience wrapper build the same thing:
+`unusedSlotCollector` option:
 
 ```ts
-const cardContentService = createOIMSlotContentEntityService<Card>(db, { keyOf: (c) => c.id });
-const handBuiltCardService = createOIMSlotCollectionService({ slotContentService: cardContentService });
+const cardContentService = createOIMSlotContentEntityService<Card>(db);
+const handBuiltCardService = createOIMSlotCollectionService(db, { slotContentService: cardContentService });
 handBuiltCardService.createStoreSlot(db);
-
-// THE CONVENIENCE WRAPPER — the same two calls in one:
-createOIMEntityService<Card>(db, { keyOf: (c) => c.id }).createStoreSlot(db);
 ```
 
-A single entity is `createOIMSingleEntityService<T>(db)` (or `createOIMSingleSlotService` over
-`createOIMSlotContentEntityService(db, { slotStoreService: OIMSlotStoreServiceSingleSlotDriven.INSTANCE })`),
+A single entity is `createOIMSingleSlotService(db, { slotContentService: createOIMSlotContentEntityService<T>(db) })`,
 and its store slot takes the db's channel too and always reports.
 
 ### A bucket's slots are the caller's
 
 A bucket's slots are a fact about the **response** being composed — a search result, a
 page, a window — and **no column can express absence**. So a bucket collection
-is manual, and `entityService.slotContentService.deleteEntity(slot)` does not take a slot out of any
-bucket. Use an index (`createOIMIndexService`) when the slots are determined by the entity's key value,
+is manual, and `entityService.slotContentService.clearSlotContent(slot)` does not take a slot out of any
+bucket. Use an index (`createOIMSlotCollectionIndexService`) when the slots are determined by the entity's key value,
 and an index should maintain buckets only for keys being held.
 
 ---
@@ -772,7 +772,7 @@ new OIMDB(options?: TOIMDBOptions)
 
 type TOIMDBOptions = {
     channelScheduler?: TOIMChannelScheduler;     // absent = you flush by hand
-    errorPolicy?: IOIMErrorPolicy;              // absent = OIMErrorPolicyLogAndContinue.INSTANCE
+    errorPolicy?: IOIMErrorPolicy;              // absent = OIMLogAndContinueErrorPolicy.INSTANCE
     onBeforeFlush?: () => void;                 // start of the flush, before the frame; READ ONLY, a write is refused
     getNowMs?: () => number;                    // the release collectors' clock; absent = Date.now
     releaseTimer?: TOIMTimer;                   // the release collectors' timer; absent = an unref'd setTimeout
@@ -788,9 +788,9 @@ db.defaultChannelSlot  // TOIMChannelSlot
 db.flush()             // OIMChannelService.INSTANCE.flush(db.defaultChannelSlot)
 
 interface IOIMErrorPolicy { onErrorCaught(error: unknown): void }
-OIMErrorPolicyLogAndContinue.INSTANCE                                       // console.error; the flush goes on
-new OIMErrorPolicyLogAndContinue({ onError?: (error: unknown) => void })   // console.error, then onError
-new OIMErrorPolicyThrowAtOnce()                                             // throws the first error out of the flush
+OIMLogAndContinueErrorPolicy.INSTANCE                                       // console.error; the flush goes on
+new OIMLogAndContinueErrorPolicy({ onError?: (error: unknown) => void })   // console.error, then onError
+new OIMThrowAtOnceErrorPolicy()                                             // throws the first error out of the flush
 ```
 
 **What the error policy covers** — every error with no synchronous caller to
@@ -801,7 +801,7 @@ hand-called collector `flush` — throws to it. `channelSlot.errorPolicy` is the
 instance the channel reports through; it is the db's `errorPolicy`, which the release collectors share,
 so one policy answers for the whole database. **The default digests and logs**: each throw goes to `console.error`
 and then to `onError` (where Sentry or the devtools registry plugs in), and the
-flush finishes every other effect and handler. `OIMErrorPolicyThrowAtOnce` throws
+flush finishes every other effect and handler. `OIMThrowAtOnceErrorPolicy` throws
 the first error out of `flush()` at once; the effects the frame had not reached yet
 stay queued and run at the next flush. **An effect whose body or cleanup threw
 has not taken the change it woke for**: its `ranAtRevision`/`ranAtEpoch` are
@@ -852,10 +852,6 @@ Every door below is on `OIMChannelService.INSTANCE` and takes the channel slot f
 | `assertNotFlushing(channelSlot)` | `void` — throws if the channel is flushing or its frame is running, i.e. for the whole of a flush |
 | `write(channelSlot, slot)` | `void` — asks `assertNotFlushing`, then marks and queues |
 | `writeWithoutFlushCheck(channelSlot, slot)` | `void` — the same marking and queueing WITHOUT the guard, for a door that already refused. Who may call it is pinned by `tests/who-may-write-without-asking-the-channel.test.ts`; a caller not on that list fails the suite |
-| `openSubframe(channelSlot)` | `void` — a subframe opens, and the frame cannot close until it closes — `flush` throws meanwhile |
-| `closeSubframe(channelSlot)` | `void` — it closes, delivering what was listed for its close and then asking for the frame it owes |
-| `isSubframeOpen(channelSlot)` | `boolean` — whether a subframe is open right now, so a caller can defer work to its close instead of per write |
-| `listChangedStoreSlot(channelSlot, storeSlot, subframeCloseListener)` | `void` — list a store slot whose changes are delivered when the OUTERMOST subframe closes, by calling `subframeCloseListener.onStoreSlotSubframeClosed(storeSlot)`; see below |
 | `dropChannelSlot(channelSlot)` | `void` — kill the channel whole; see below |
 | `isChangedInCurrentFrame(channelSlot, slot)` | `boolean` — whether the slot was written after the last frame ended, i.e. in the frame being collected now; compares `slot.changedAtRevision`/`changedAtEpoch` with the clock reading the last frame closed at. `OIMBucketCommands` keeps a bucket's render script across a flush only while this is true |
 
@@ -874,7 +870,7 @@ bucket, a computed — and a batch does not soften it: writes accumulate until
 after it.
 
 ```ts
-cardService.slotContentService.upsertEntity(cards, { id: 'a', title: 'A', rank: 1, deck: 'spades' });
+cardService.writeSlotContentByKey(cards, 'a', { id: 'a', title: 'A', rank: 1, deck: 'spades' });
 const entitySlot = cardService.getSlotByKey(cards, 'a');
 
 effectService.createEffect(db, [entitySlot], [], () => { /* NEVER runs for the upsert above */ });
@@ -920,87 +916,27 @@ effectService.createEffect(db, [slot], [], () => {
 - One list, not two: it goes into the same set at the same phase, so one-shot and
   standing handlers are called in registration order among each other.
 
-### `openSubframe(channelSlot)` / `closeSubframe(channelSlot)`
-
-A **frame** is everything delivered together: the writes collected since the
-last delivery, handed to effects and after-each-frame handlers in one go. A
-**subframe** is one logical change inside it — a write that has begun and not yet
-ended. **The frame cannot close while a subframe is open**, however many writes
-ask for one: the debt is recorded and paid by the `closeSubframe` that brings the
-count to zero. A subframe delivers nothing of its own; it only keeps the frame
-open.
-
-- **`flush()` throws while a subframe is open**, with a message containing
-  "a subframe is open": code a write runs (a `keyOf`, a content
-  listener) called `flush`, or the caller opened a subframe and has not closed it. Nothing is delivered and the write in progress stays whole; flush
-  after the write returns.
-- Counted, not a flag: a subframe is routinely inside another one, and the inner
-  close delivers nothing.
-- Not `assertNotFlushing` from the other side. That refuses a **write** made
-  while a frame closes; this refuses a **frame** asked for while a subframe is open.
-- A subframe is bigger than any single write, which is why the span is the
-  service's and not the writer's: a write moves the entity's columns and *then*
-  settles emptiness, which is what puts the entity slot into the index's
-  bucket. Under a synchronous scheduler that gap used to flush — an auto-index
-  settled over a bucket the entity slot had not joined yet, stamped itself past the
-  entity slot's revision, and the entity was invisible to that index forever with nothing
-  thrown.
-- `closeSubframe` is called from a `finally` by every opener, so a subframe that
-  threw part-way still closes and still delivers what it managed to write.
-- **The span belongs to the DOOR, and exactly one door opens it.** The entity content service's
-  `writeEntity`, `deleteEntity`, `deleteEntities`, `fillEntities`, `updateEntity` and `markEntityChanged` each
-  open one — except a write that is exactly one channel write, which opens none — one write cannot be seen
-  half-done, and there is nobody to batch for: `updateEntity`/`updateEntityColumn` and `deleteEntity` when
-  the store slot has no content listener, no column of the entity is referenced and emptiness is not
-  recomputed on a column write; the entity writer's `fillEntity`, `putEntity`, `patchEntity`, `deleteColumns`
-  and `clearEntity` open none. One `upsertEntity` therefore opens one span, and one `insertEntities` opens one
-  however many entities it carries. The one exception is the content strategy's `releaseSlotContent`, which
-  keeps its own: `releaseSlotIfUnheld` reaches it when a release deadline has passed, and that call arrives
-  from the release queue through no door at all — so a removal opens two and an eviction opens one.
-- Every write door of a content service is wrapped in the channel's `openSubframe` / `closeSubframe` on
-  `storeSlot.channelSlot`.
-- **Every bucket door wakes the bucket the same way.** Each door of a bucket content service that changed
-  the bucket — `addBucketMemberSlot(s)`, `removeBucketMemberSlot(s)`,
-  `insertBucketMemberSlotAt`, `removeBucketMemberSlotAt` / `…Range`, both moves,
-  `writeBucketMemberSlots`, `clearBucketMemberSlots` — lists the bucket's store slot on the channel
-  (`listChangedStoreSlot`) and sets the bucket's EMPTY flag there and then; the outermost `closeSubframe`
-  stamps each changed bucket once, tells its release policy `onSlotWritten` once, and only then asks
-  whether it may go. So `hasSlotContentByKey` answers right inside an open batch, a
-  batch that mixes doors stamps the bucket once, a move renews a write deadline,
-  and a door that changed nothing stamps nothing and tells the policy nothing.
-  Commands are still recorded at the door, because a position is true only when it
-  is written. A release asked for while the bucket has a pending change waits for
-  the close.
-- **A content listener that throws on one bucket does not strand the others.**
-  The close stamps every filed bucket and settles it before its listeners run,
-  goes on to the next bucket when one listener throws, and rethrows the first error
-  once every bucket is through — costing nothing when nothing throws.
-- **A released identity is refused before the bucket changes.** Every door that
-  takes a member — the add doors, the doors by key, `insertBucketMemberSlotAt`,
-  a whole-list `writeBucketMemberSlots`, and the fill of a minted bucket — checks what it was
-  handed with `oimIsSlotReleased` first and throws, so a refused door leaves the members,
-  their holds and the EMPTY flag exactly as they were. It costs one field read per
-  member handed in.
-
-### `isSubframeOpen(channelSlot)` / `listChangedStoreSlot(channelSlot, storeSlot, subframeCloseListener)`
-
-**What a batch does once instead of per entity.** A subframe is the unit a
-service can defer work to the end of: `listChangedStoreSlot` lists a store slot together with the
-`IOIMSubframeCloseListener` (`onStoreSlotSubframeClosed(storeSlot)`) that delivers its changes, and the
-outermost `closeSubframe` calls each listed listener with its store slot. `isSubframeOpen` says whether there
-is a subframe to defer into at all — with none, the caller does the work immediately.
-
-- **The drain runs before the count drops**, so a listener that writes is still inside the subframe and
-  still cannot close the frame. A store slot listed by a listener during the drain is picked up by the same
-  drain.
-- **Every listed entry runs.** A listener that throws loses its own work for that batch and nothing retries
-  it; the entries after it still run, the list is emptied, the count still drops, the frame the subframe
-  owed is still asked for, and then the FIRST throw leaves `closeSubframe`.
-- **What uses it**: the bucket content services. A join or a leave records the bucket slot on its store
-  slot's write queues and lists that store slot; the drain then writes the channel, settles emptiness and
-  asks `releaseSlotIfUnheld` **once per bucket per batch** rather than once per member. Filing 10 000 entity
-  slots into 100 buckets pays 100 of each tail instead of 10 000. Nothing is delivered before the flush either
-  way, so the two are behaviourally the same.
+### Batches: `openBatch` / `closeBatch` / `writeInBatch` on a collection
+
+There are no bulk writes. A load or a sync is a loop of single writes, and a collection
+service wraps it in a batch on its store slot:
+
+```ts
+cardService.writeInBatch(cards, () => {
+    for (const card of payload) cardService.writeSlotContentByKey(cards, card.id, card);
+});
+```
+
+- `openBatch(storeSlot)` / `closeBatch(storeSlot)` nest by a count on the store slot; `writeInBatch` is the
+  `try/finally` form and returns what its function returns.
+- **What the batch changes is who hears the writes, and when.** A content-change listener on the store slot (an
+  index on the collection) hears every write of the batch in ONE call, `onContentChangedMany`, when the
+  outermost batch closes. Code inside the batch reads the index as it was before the batch.
+- Effects are not batched by it: every write marks its slot on the channel as usual, and the frame delivers each
+  identity once whatever the batch did. A `flush()` inside a batch is allowed; the index catches up when the
+  batch closes.
+- A single write outside a batch tells the index at once, and is not rolled back: the slot is filed first and the
+  index is told after, so an index that throws leaves the write in place and the throw reaches the caller.
 
 ### `dropChannelSlot(channelSlot)`
 
@@ -1050,19 +986,11 @@ OIMChannelService.INSTANCE.dropChannelSlot(db.defaultChannelSlot);
   `finally`; `assertNotFlushing` throws on `isFlushing` or `frame.isRunning`, so
   all three phases are refused. Refusal is per channel: a flush of one db's channel does not refuse a
   write to another db's.
-- **A refused write keeps its change pending — it is never dropped.** A bucket
-  carries a change `addBucketMemberSlots`/`removeBucketMemberSlots` recorded inside an outer open batch
-  until that batch closes. If something delivers it mid-flush — a member's
-  subscriber giving the list back, so `unholdSlot` reaches `releaseSlotIfUnheld` —
-  the write is refused and the bucket's store slot stays listed, so the next
-  subframe close delivers it.
 - **Each door asks once, then writes through `writeWithoutFlushCheck`.** A content service
   door opens with `assertWritable`, which asks the channel, and every write it
-  makes after that asks nothing: the guard was three field reads and a branch
-  per write, and `upsertEntities` of 100 entities into one ordered bucket asked it 302
-  times where 201 of those were the door's own re-asking. The per-entity ask is NOT
-  removable and stays — user code runs inside a door (`keyOf`, `index.keyOf`,
-  `slotEmptiness.isEmpty`, an `IOIMEntityWriter`) and can call
+  makes after that asks nothing. The per-entity ask is NOT
+  removable and stays — user code runs inside a door (`index.keyOf`,
+  `slotEmptinessPolicy.isEmpty`, an `IOIMEntityWriter`) and can call
   `flush()`, so each entity is a new question. What went is the SECOND and THIRD ask
   of the same entity.
 - **`flush` during a frame throws:** the message says a frame is already running, and a second one
@@ -1077,7 +1005,7 @@ OIMChannelService.INSTANCE.dropChannelSlot(db.defaultChannelSlot);
   hands the work to a microtask or a later callback rather than writing itself.
 - A refusal raised from a tail handler does NOT reach the caller at the call: it
   goes to the error policy like any handler throw — logged by default, or thrown
-  out of `flush()` under `OIMErrorPolicyThrowAtOnce`.
+  out of `flush()` under `OIMThrowAtOnceErrorPolicy`.
 - Effects are isolated under the default policy: a throw is logged and handed to
   `onError`, and the frame finishes every other effect.
 - **A derivation is asked, never woken.** No frame walks to a computed slot.
@@ -1145,7 +1073,7 @@ class OIMEffectSourceTracker {              // exported as a type; the service b
 ```
 
 ```ts
-const fallback = cardService.slotContentService.upsertEntity(cards, { id: 'c2', title: 'King', rank: 13, deck: 'hearts' });
+const fallback = cardService.writeSlotContentByKey(cards, 'c2', { id: 'c2', title: 'King', rank: 13, deck: 'hearts' });
 effectService.createEffectWithSourceTracking(db, effectSourceTracker => {
     const isFirst = effectSourceTracker.readSourceSlot(slot).entity?.rank === 1;
     paint(effectSourceTracker.readSourceSlot(isFirst ? slot : fallback).entity);
@@ -1161,7 +1089,7 @@ effectService.createEffectWithSourceTracking(db, effectSourceTracker => {
   creation. A returned function is the undo, exactly as for `TOIMEffectBody`.
 
 ```ts
-const onRank = effectService.createEffect(db, [cardService.holdColumn(slot, 'rank')], [], () => { paint(slot.entity); });
+const onRank = effectService.createEffect(db, [cardService.columnSlotService.holdColumn(slot, 'rank')], [], () => { paint(slot.entity); });
 ```
 
 **A column effect takes the `TOIMColumnSlot` as a root, not a slot and a name.** Minting the
@@ -1177,7 +1105,7 @@ its carrier. An index store slot's buckets have the same doors on the index serv
 `createEffect` returns the **effect**, not the column: a column holds no value; read `slot.entity[name]`.
 
 **The name is compile-time checked only as far as the service's column-name type goes** —
-`holdColumn` takes the service's `TColumnName`, which `createOIMEntityService` sets to
+`holdColumn` takes the service's `TColumnName`, which `createOIMSlotContentEntityService` sets to
 `TOIMEntityColumnName<TEntity>`. `TOIMEntityColumnName<TEntity>` is the type that narrows a name to the
 entity's own columns, and `slotContentService.deleteEntityColumns` is typed on it.
 
@@ -1187,7 +1115,7 @@ per call; get it once per view, not per entity. `service.holdColumnGroup(slot, c
 the group's column slot on `slot`, and `service.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.** `createOIMEntityService<TCard, 'rank' | 'label'>(db, { keyOf, columnNames: ['rank', 'label'] })`
+**`columnNames` picks the column slot store.** `createOIMSlotCollectionService(db, { slotContentService, columnNames: ['rank', 'label'] })`
 — and `columnNames` on any factory's options — files the service's column slots by ordinal: every named column
 gets a number, a group gets one at its first slot, and an entity slot's column slots sit in an array by
 number instead of a `Map` per entity slot, which is cheaper to create and give back. `holdColumn` and
@@ -1220,26 +1148,21 @@ frame, with no further code. Every mutation goes through a domain neuron — a w
 from outside the orchestrator is the mistake, not a case to cover with a fallback.
 Full page: `website/docs/guides/with-cnstra.md`.
 
-The doors are free functions, one module each, so a consumer ships only the one they import. The entity,
-bucket and index factories take `db` first and ONE options object second (optional on the bucket doors); the
-base collection factories and the computed factories take only the options object. Each builds a SERVICE,
+The doors are free functions, one module each, so a consumer ships only the one they import. The collection,
+single and index factories take `db` first and ONE options object second; the computed factories take only
+the options object. Each builds a SERVICE,
 once per collection type; the store slot is made separately:
 
 | Door | Builds | Store slot |
 |---|---|---|
-| `createOIMSlotContentEntityService(db, { keyOf, entityWriter?, slotEmptiness?, slotStoreService?, slotReleasePolicy?, columnSlotStoreService? \| columnNames? })` | `OIMSlotContentEntityService<TEntity, TKey, TStore, TColumnName>`, the entity content service with its slot owner; `slotStoreService` defaults to a Map store for a key and is REQUIRED for any other store (a tree store, or `OIMSlotStoreServiceSingleSlotDriven` for a single, which takes no `keyOf`) | — |
-| `createOIMSlotCollectionService({ slotContentService })` | `OIMSlotCollectionService` over an entity content service: the read doors and the column doors | `createStoreSlot(db)` |
-| `createOIMSingleSlotService({ slotContentService })` | `OIMSingleSlotService` over a single entity content service | `createStoreSlot(db)` |
-| `createOIMEntityService(db, { keyOf, entityWriter?, slotEmptiness?, slotReleasePolicy?, columnSlotStoreService? \| columnNames? })` | convenience wrapper: the two calls above for a Map store; `TColumnName` is `TOIMEntityColumnName<TEntity>` | `createStoreSlot(db)` |
-| `createOIMSingleEntityService(db, { … }?)` | convenience wrapper for a single entity | `createStoreSlot(db)` |
-| `createOIMBucketService<TBucketMemberSlot, TKey?, TSlots?, TSlotContentService?, TStore?>(db, { slotContentService?, bucketSlotStoreService?, maxCommandsPerSlot?, slotReleasePolicy?, columnSlotStoreService? \| columnNames? }?)` | `OIMSlotCollectionService` of bucket slots; `slotContentService` defaults to an `OIMSlotContentBucketServiceArrayDriven` that records `OIMBucketCommands` (`maxCommandsPerSlot` caps it). An array `TKey` makes `bucketSlotStoreService` REQUIRED by type — pass `OIMSlotStoreServiceTreeDriven`, since a Map store compares arrays by reference | `createStoreSlot(db)` |
-| `createOIMSingleBucketService(db, { … }?)` | `OIMSingleSlotService` of one bucket slot | `createStoreSlot(db)` |
-| `createOIMIndexService(db, { entityService, columns? \| keyOf?, slotContentService?, slotReleasePolicy?, columnSlotStoreService? \| columnNames? })` | `OIMIndexService`, over the entity collection service whose store slots it will index (it takes a `Pick` of `getSlots`); `slotContentService` defaults to array-driven, pass `new OIMSlotContentBucketServiceSetDriven()` for an unordered one. Generics `<TEntity, TSourceKey, const TColumns, TKey extends TOIMStoreKey>`: a scalar key, inferred from ONE inline column or from `keyOf`'s return | `createIndexStoreSlot(entityStoreSlot)` |
-| `createOIMIndexServiceSortedArrayDriven(db, { entityService, columns? \| keyOf?, sortColumns, … })` | `OIMIndexServiceSortedArrayDriven`: the index whose buckets are kept in the order of `sortColumns` (`readonly TOIMSortColumn<TEntity>[]`, required) through an `OIMSlotContentBucketServiceSortedArrayDriven`. See [Sorted at write](#sorted-at-write) | `createIndexStoreSlot(entityStoreSlot)` |
-| `createOIMIndexServiceByCompositeKey(db, { entityService, columns? \| keyOf?, … })` | convenience wrapper: the index keyed by an array, `TKey extends readonly TOIMStoreKey[]`, inferred as a tuple from two or more inline columns or from an array-returning `keyOf`, over a tree store | `createIndexStoreSlot(entityStoreSlot)` |
-| `createOIMComputedService({ createSources?, derive?, sameValueGuard?, initialValue?, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService?, columnNames? })` | `OIMComputedService<TKey, TValue, TComputedStore>`; its reads are on `computedService.computedCollectionService`; `derive` and `createSources` may instead be given per store slot; `computedSlotStoreService` is REQUIRED for a non-Map store (a single: `OIMSlotStoreServiceSingleSlotDriven`); see [One derivation per key](#one-derivation-per-key) | `createComputedStoreSlot(db, derive?, createSources?)` |
-| `createOIMComputedServiceSorted({ indexService, sortColumns?, comparator?, slotReleasePolicy?, columnSlotStoreService?, computedSlotStoreService? })` | `OIMComputedServiceSorted` — per key, the entity slots of the index bucket under that key, sorted; see [Sorted lists](#sorted-lists) | `createSortedStoreSlot(indexStoreSlot)` |
-| `createOIMComputedServiceBucketMemo({ bucketCollectionService, slotReleasePolicy?, columnSlotStoreService?, computedSlotStoreService? })` | `OIMComputedServiceBucketMemo` — per key, the bucket's slots as one array; see [The order of a bucket](#the-order-of-a-bucket-as-one-derivation-per-key) | `createBucketMemoStoreSlot(bucketStoreSlot)` |
+| `createOIMSlotContentEntityService<TEntity, TKey?, TColumnName?>(db, { entityWriter?, slotEmptinessPolicy? }?)` | `OIMSlotContentEntityService<TEntity, TKey, TColumnName>`, the entity content service; it creates keyed and single entity slots alike | — |
+| `createOIMSlotCollectionService(db, { slotContentService, slotStoreService?, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? \| columnNames? })` | `OIMWritableSlotCollectionService` over any keyed content service (entity or bucket): the read doors, `writeSlotContentByKey`, the batch doors and `columnSlotService`. `slotStoreService` defaults to a Map store and is REQUIRED by type for an array key (`OIMSlotTreeStoreService`) | `createStoreSlot(db)` |
+| `createOIMSingleSlotService(db, { slotContentService, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? \| columnNames? })` | `OIMWritableSingleSlotService` over any content service with `createSingleSlot` (entity or bucket) | `createStoreSlot(db)` |
+| `createOIMSlotCollectionIndexService(db, { entityService, columns? \| keyOf?, slotContentService?, bucketSlotStoreService?, slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService? \| columnNames? })` | `OIMSlotCollectionIndexService`, over the entity collection service whose store slots it will index (it takes a `Pick` of `getSlots`); `slotContentService` defaults to an `OIMSlotContentPositionalArrayBucketService`, pass `new OIMSlotContentSetBucketService()` for an unordered one. A scalar key is inferred from ONE inline column or from `keyOf`'s return; an array key (two or more columns, or an array-returning `keyOf`) needs `bucketSlotStoreService: new OIMSlotTreeStoreService(…)` | `createIndexStoreSlot(entityStoreSlot)` |
+| `createOIMSlotCollectionSortedArrayIndexService(db, { entityService, columns? \| keyOf?, sortColumns, … })` | `OIMSlotCollectionSortedArrayIndexService`: the index whose buckets are kept in the order of `sortColumns` (`readonly TOIMSortColumn<TEntity>[]`, required) through an `OIMSlotContentSortedArrayBucketService`. See [Sorted at write](#sorted-at-write) | `createIndexStoreSlot(entityStoreSlot)` |
+| `createOIMComputedService({ createSources?, derive?, sameValueGuard?, initialValue?, slotReleasePolicy?, computedSlotStoreService?, columnSlotStoreService?, columnNames? })` | `OIMComputedService<TKey, TValue, TComputedStore>`; its reads are on `computedService.computedCollectionService`; `derive` and `createSources` may instead be given per store slot; `computedSlotStoreService` is REQUIRED for a non-Map store (a single: `OIMSingleSlotStoreService`); see [One derivation per key](#one-derivation-per-key) | `createComputedStoreSlot(db, derive?, createSources?)` |
+| `createOIMSortedComputedService({ indexService, sortColumns?, comparator?, slotReleasePolicy?, columnSlotStoreService?, computedSlotStoreService? })` | `OIMSortedComputedService` — per key, the entity slots of the index bucket under that key, sorted; see [Sorted lists](#sorted-lists) | `createSortedStoreSlot(indexStoreSlot)` |
+| `createOIMBucketMemoComputedService({ bucketCollectionService, slotReleasePolicy?, columnSlotStoreService?, computedSlotStoreService? })` | `OIMBucketMemoComputedService` — per key, the bucket's slots as one array; see [The order of a bucket](#the-order-of-a-bucket-as-one-derivation-per-key) | `createBucketMemoStoreSlot(bucketStoreSlot)` |
 
 `entityWriter` and `slotReleasePolicy` on these doors default to the
 db's, so naming one overrides it for that service alone.
@@ -1252,13 +1175,12 @@ which also fails when an option arrives on a service and is not forwarded,
 when the root mints anything but the channel and the collector, or when a public
 member appears on the root that is not one of the seven it owns.
 
-**`createOIMBucketService` with no content service is the door for a list whose order is yours.** It builds
-an `OIMSlotContentBucketServiceArrayDriven` — insertion order, never re-decided — that records an
+**`new OIMSlotContentPositionalArrayBucketService({ bucketCommands })` is the content service for a list whose order is yours.** It is — insertion order, never re-decided — that records an
 `OIMBucketCommands` script per bucket. The recorder holds no subscription: it lists store slots on the channel
 slot, and the script lives for one frame.
 
 ```ts
-const freshPageService = createOIMBucketService<TOIMEntitySlot<Card>>(db);
+const freshPageService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<Card>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const freshPage = freshPageService.createStoreSlot(db);
 const freshBucketSlot = freshPageService.holdSlotByKey(freshPage, 'page-1');
 // freshBucketSlot.commands and freshBucketSlot.isWholeListRecorded carry the script; read them in an effect on the bucket slot
@@ -1276,13 +1198,13 @@ construct one, never subclass it.
 |---|---|---|
 | `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.INDEX_KEYS_SERVICE` | `IOIMIndexKeysService` | `OIMIndexKeysServiceAppending`; the factories pass it when `db.indexKeysService` is not set |
-| `OIMDefaults.KEY_TREE_WALK_SCALAR` | `OIMKeyTreeWalkScalar` | the chain-of-values walk |
-| `OIMDefaults.KEY_TREE_WALK_COMPOSITE` | `OIMKeyTreeWalkComposite` | the chain-of-identities walk |
+| `OIMDefaults.INDEX_KEYS_SERVICE` | `IOIMIndexKeysService` | `OIMAppendingIndexKeysService`; the factories pass it when `db.indexKeysService` is not set |
+| `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` | `IOIMSlotEmptiness<TOIMEntitySlot>` | "empty means `slot.entity === undefined`" |
-| `OIMDefaults.STORE_SLOT_LISTENER` | `IOIMStoreSlotListener` | `OIMStoreSlotListenerNone`: hears nothing. Not a constructor option: every service reads it when it is built and calls `onStoreSlotCreated(storeSlot)` for each store slot it creates. A tool that wants to see every store slot sets its own with `setValue` before the first service is built; once one has been built, `setValue` throws |
+| `OIMDefaults.ENTITY_SLOT_EMPTINESS` | `IOIMSlotEmptinessPolicy<TOIMEntitySlot>` | "empty means `slot.entity === undefined`" |
+| `OIMDefaults.STORE_SLOT_LISTENER` | `IOIMStoreSlotListener` | `OIMNoStoreSlotListener`: hears nothing. Not a constructor option: every service reads it when it is built and calls `onStoreSlotCreated(storeSlot)` for each store slot it creates. A tool that wants to see every store slot sets its own with `setValue` before the first service is built; once one has been built, `setValue` throws |
 
 **NOTHING IS CONSTRUCTED AT MODULE LOAD.** Every entry is an `OIMDefaultValue`
 whose `getValue()` mints on its first call (`??=`) and hands the same instance back
@@ -1329,30 +1251,29 @@ with its slot owner; the collection service (`OIMSlotCollectionService`) over it
 Neither holds an entity: each `createStoreSlot(db)` is one instance of that type's store.
 
 ```ts signature
-createOIMSlotContentEntityService<TEntity, TColumnName?, TKey?, TStore?>(db, {
-    keyOf: (entity: TEntity) => TKey;                                  // REQUIRED for a key; absent for a single
+createOIMSlotContentEntityService<TEntity, TKey?, TColumnName?>(db, {
     entityWriter?: IOIMEntityWriter;                                   // db.entityWriter, then OIMDefaults.ENTITY_WRITER
-    slotEmptiness?: IOIMSlotEmptiness<TOIMEntitySlot<TEntity, TKey>>;  // OIMDefaults.ENTITY_SLOT_EMPTINESS
-    slotStoreService?: IOIMSlotStoreService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore>; // Map; REQUIRED for any other store
-                                                                       // and for a single (OIMSlotStoreServiceSingleSlotDriven)
-    slotReleasePolicy?: IOIMSlotReleasePolicy;                         // db.slotReleasePolicy, then OIMSlotReleasePolicyAtEmpty
+    slotEmptinessPolicy?: IOIMSlotEmptinessPolicy<TOIMEntityContentSlot<TEntity>>;  // OIMDefaults.ENTITY_SLOT_EMPTINESS
+}?): OIMSlotContentEntityService<TEntity, TKey, TColumnName>
+
+createOIMSlotCollectionService(db, {
+    slotContentService,
+    slotStoreService?: IOIMSlotStoreService<TKey, TSlot, TStore>;      // Map; REQUIRED for an array key
+    slotReleasePolicy?: IOIMSlotReleasePolicy;                         // db.slotReleasePolicy, then OIMSlotAtEmptyReleasePolicy
+    slotSubscriptionListener?: IOIMSlotSubscriptionListener;           // OIMNoSlotSubscriptionListener
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot>; // OIMDefaults.COLUMN_SLOT_STORE_SERVICE
     columnNames?: readonly TColumnName[];                              // the ordinal column store over those names
-}): OIMSlotContentEntityService<TEntity, TKey, TStore, TColumnName>
-
-createOIMSlotCollectionService({ slotContentService }): OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, …>
-collectionService.createStoreSlot(db): TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>, Partial<TEntity>>
-
-createOIMEntityService<TEntity, TColumnName?, TKey?>(db, { keyOf, … })   // convenience: both calls, Map store
+}): OIMWritableSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, TEntity, …>
+collectionService.createStoreSlot(db): TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>, Partial<TEntity>, typeof collectionService>
 ```
 
 **Each collection type has its own column owner.** It is stateless configuration built with the slot owner
 over `columnSlotStoreService` (or the ordinal store `columnNames` names); the column state — the column slots,
 the column groups, and which columns are referenced — lives on the store slot. The doors are on the
-collection service (`getColumn`, `holdColumn`, `unholdColumn`, `getColumnGroup`, `holdColumnGroup`,
+collection's `columnSlotService` (`getColumn`, `holdColumn`, `unholdColumn`, `getColumnGroup`, `holdColumnGroup`,
 `getAnyColumn`, `holdAnyColumn`). The column owner has two strategies, chosen by the factory: write-driven
-column slots, woken by the marks a write makes (`OIMColumnOwnerPushDriven`, entities and buckets), and
-derive-driven column slots, each a computed slot over its carrier (`OIMColumnOwnerPullDriven`, computeds).
+column slots, woken by the marks a write makes (`OIMPushColumnSlotOwner`, entities and buckets), and
+derive-driven column slots, each a computed slot over its carrier (`OIMPullColumnSlotOwner`, computeds).
 
 Example, over the `db`, `cardService`, `cards` and `slot` of the setup block:
 
@@ -1363,26 +1284,26 @@ db.flush();
 effectService.disposeEffect(effect);
 ```
 
-Assembled from the base layer, which is what `createOIMEntityService` does:
+Assembled with a store service of your own:
 
 ```ts
-const baseCardService = createOIMSlotCollectionService({
-    slotContentService: createOIMSlotContentEntityService<Card>(db, { keyOf: (card) => card.id }),
+const baseCardService = createOIMSlotCollectionService(db, {
+    slotContentService: createOIMSlotContentEntityService<Card, string>(db),
+    slotStoreService: new OIMSlotMapStoreService<TOIMEntitySlot<Card, string>>(),
 });
 const baseCards = baseCardService.createStoreSlot(db);
 ```
 
 The writer is omitted because the db and `OIMDefaults` supply it, and so is the column store. The slot stamp
-is not an option of the content service: it is `new OIMDB({ slotStamp })`, for every collection of that db.
+is not an option of any factory: it is `new OIMDB({ slotStamp })`, for every collection of that db.
 
 ### Public properties
 
 | Property | Of | Type |
 |---|---|---|
-| `slotContentService` | the collection service | the content service: the write doors |
-| `keyOf` | the entity content service | `(entity: TEntity) => TKey` |
-| `slotOwner` | the entity content service | `IOIMSlotOwner` — the owner of every slot the collection type files |
-| `slotStoreService` | the entity content service | the store service |
+| `slotContentService` | the collection service | the content service: the write doors on a slot |
+| `columnSlotService` | the collection service | `OIMColumnSlotService`: the column doors |
+| `slotService` | the store slot | the service that created it |
 
 A store slot is not a slot, so nothing holds, subscribes or wakes it: there is no
 `effectService.createEffect(db, [cards], …)` that hears the population. "Something in this population changed" is an
@@ -1406,7 +1327,7 @@ for (const filedSlot of cardService.getSlots(cards)) {
 ```
 
 To have that answer MAINTAINED and subscribable instead of walked, declare an
-index keyed on the entity's own id (`keyOf: card => card.id`) and hold the key
+index keyed on the entity's own id (`keyOf: (card: Card) => card.id`) and hold the key
 you want. An index's bucket is an injected lifetime — a
 `slotReleasePolicy` — so it is the consumer who says how long the
 answer outlives its last reader.
@@ -1415,13 +1336,12 @@ An index maintains buckets only while they are held, filing entity slots from th
 store slot on every write by the entity's key value. The bucket is created on first
 `holdSlotByKey` by walking the source store slot's slots once, and released on the last give-back.
 
-**`holdColumn(slot, columnName)`** is on the collection service and takes a hold on a column slot;
-`service.unholdColumn(columnSlot)` gives that hold back. **`service.getColumn(slot, columnName)`**
+**`holdColumn(slot, columnName)`** is on the collection's `columnSlotService` and takes a hold on a column slot;
+`service.columnSlotService.unholdColumn(columnSlot)` gives that hold back. **`service.columnSlotService.getColumn(slot, columnName)`**
 returns the same column slot without a hold: a column slot it mints is held by the
 unused-slot collector until the end of the next flush, so `getColumn` is
-the door that does not hold but tracks. `slotContentService.findEntityByKey(storeSlot, key)` reads the entity
-itself through the store lookup `findSlotByKey` runs, so it mints nothing: a miss answers `undefined`
-and leaves no slot behind.
+the door that does not hold but tracks. `findSlotByKey(storeSlot, key)?.entity` reads the entity
+itself, so it mints nothing: a miss answers `undefined` and leaves no slot behind.
 
 ### The doors every service has
 
@@ -1442,8 +1362,15 @@ class OIMSlotCollectionService<TKey, TSlot, TStore, TSlotContentService, TColumn
     getSlots(storeSlot): IterableIterator<TSlot>;
     getSlotCount(storeSlot): number;
     isSameKey(key, otherKey): boolean;
-    getColumn / holdColumn / getAnyColumn / holdAnyColumn / getColumnGroup / holdColumnGroup / unholdColumn;
+    openBatch(storeSlot): void;
+    closeBatch(storeSlot): void;
+    writeInBatch<TResult>(storeSlot, write: () => TResult): TResult;
+    readonly columnSlotService: OIMColumnSlotService;   // getColumn / holdColumn / getAnyColumn / holdAnyColumn / getColumnGroup / holdColumnGroup / unholdColumn
 }
+// createOIMSlotCollectionService returns OIMWritableSlotCollectionService, which adds:
+//     writeSlotContentByKey(storeSlot, key, content, changedSlots?): TSlot
+// createOIMSingleSlotService returns OIMWritableSingleSlotService, which adds:
+//     writeSingleSlotContent(storeSlot, content, changedSlots?): TSlot;  clearSingleSlotContent(storeSlot): void
 ```
 
 | Door | Of | Signature | Mints? |
@@ -1455,13 +1382,10 @@ class OIMSlotCollectionService<TKey, TSlot, TStore, TSlotContentService, TColumn
 | `holdSlotByKey(storeSlot, key)` | collection | `TSlot` — minted if missing, `holdCount` up by one | **yes** |
 | `hasSlotContentByKey(storeSlot, key)` | collection | `boolean` — **does this key have content right now**, not whether an identity is filed under it: a slot a read or a hold minted and nobody wrote answers `false`. It hands back no slot, which is why it can answer without minting, and it is not a read: the answer is about the past the moment it returns | no |
 | `isSameKey(key, otherKey)` | collection | `boolean` — whether two keys name one slot here, answered by the store service (SameValueZero for a Map store, part by part for a tree store) | no |
-| `insertEntity(storeSlot, key, entity, changed?)` | entity content | `TOIMEntitySlot` — **total; always the identity it resolved or minted** | **yes** |
-| `upsertEntity(storeSlot, entity, changed?)` / `upsertEntities(storeSlot, entities, changed?)` | entity content | the slot(s) — `insertEntity` under `keyOf(entity)` | **yes** |
-| `writeEntity(slot, entity)` / `writeBucketMemberSlots(bucketSlot, members)` | content | `boolean` — on a slot you already hold; the boolean is about the CONTENT | no |
-| `deleteEntity(slot)` / `deleteEntities(storeSlot, slots)` / `clearBucketMemberSlots(bucketSlot)` | content | `void` — it takes the value, not the identity | no |
-| `clearAllEntities(storeSlot)` | entity content | `void` — clears every slot filed in that store slot | no |
+| `writeSlotContentByKey(storeSlot, key, content, changed?)` | collection | `TSlot` — **total; always the identity it resolved or minted**. A hit writes the whole value through `slotContentService.writeSlotContent`, a miss mints and `insertSlotContent`s | **yes** |
+| `writeSlotContent(slot, content)` | content | `boolean` — on a slot you already hold; the boolean is about the CONTENT | no |
+| `clearSlotContent(slot)` | content | `void` — it takes the value, not the identity | no |
 | `markContentChanged(bucketSlot)` | bucket content | `void` — re-settle emptiness and re-ask the guard after a write you made another way; the entity counterpart is `markEntityChanged(slot, changedColumns?)` | no |
-| `fillEntities(storeSlot, keys, entities)` / `insertEntities(storeSlot, entities)` | entity content | `void` — a bulk load of new keys; hands out no reference. On a key that is already filed or named twice it throws and rolls back only the entities this call filed; `fillEntities` also requires an empty store slot, and throws on lists of different lengths | yes |
 | `slot.owner.holdSlot(slot)` / `slot.owner.unholdSlot(slot)` | `void` — the `IOIMSlotOwner` pair; `unholdSlot` on an unheld slot throws by name | no |
 | `slot.owner.releaseSlotIfUnheld(slot)` | `void` — run the release guard; it releases nothing unless the slot is unheld, unreferenced, still owned here and out of grace | no |
 
@@ -1470,10 +1394,10 @@ class OIMSlotCollectionService<TKey, TSlot, TStore, TSlotContentService, TColumn
 owned or in-grace slot it returns having done nothing, and on an
 already-released one it returns silently rather than throwing.
 
-**`insertEntity` does not file a key whose content is refused.** On a MISS it
+**`writeSlotContentByKey` does not file a key whose content is refused.** On a MISS it
 mints, writes inside a `try`, and on a throw runs the release guard on what it
 just minted before re-raising — so the caller's error is the only thing that
-leaves. Every path still runs `closeSubframe` from a `finally`. The HIT path looks
+leaves. The HIT path looks
 the key up first and never mints, so a refused write on an existing key leaves
 that key exactly as it was.
 
@@ -1481,21 +1405,18 @@ that key exactly as it was.
 
 | | What happened | What the caller gets |
 |---|---|---|
-| **Refused** | The write threw; **no content ever arrived** | The throw. A key minted for it is unwound — `insertEntity` files nothing |
+| **Refused** | The write threw; **no content ever arrived** | The throw. A key minted for it is unwound — `writeSlotContentByKey` files nothing |
 | **Unchanged** | The write **did** happen and the content was already there | The identity, like any other write. Nothing is unwound |
 
-`insertEntity` is **total**: whatever it decides about the content, it hands back
+`writeSlotContentByKey` is **total**: whatever it decides about the content, it hands back
 the identity it resolved or minted. A door that mints must leave a reference
 behind, which is the one test that admits a door at all.
 
-`fillEntities` is the companion and does not carry the rule: it returns `void` and hands
-out no reference at all.
-
 **`changed?` — the verdict, into an array you own.**
 
 ```ts
 const changed: TOIMEntitySlot<Card, TOIMStoreKey>[] = [];
-cardService.slotContentService.insertEntity(cards, 'c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' }, changed);   // pushed exactly when the content differed
+cardService.writeSlotContentByKey(cards, 'c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' }, changed);   // pushed exactly when the content differed
 ```
 
 - **Optional, yours, and appended to** — never read by the engine, never cleared.
@@ -1513,49 +1434,45 @@ cardService.slotContentService.insertEntity(cards, 'c1', { id: 'c1', title: 'Ace
 
 ## Writing
 
-Every write door is on the entity content service, `service.slotContentService`. A store door takes the store
-slot first; a slot door takes the slot alone. There are no by-key write doors: resolve the slot with
-`getSlotByKey` / `findSlotByKey` and write through it.
+The keyed write is on the collection; every other write is on its content service, `service.slotContentService`,
+and takes the slot alone. There is no `keyOf`: the caller names the key. There are no bulk writes: a load is a
+loop of single writes inside `service.writeInBatch(storeSlot, () => { … })`.
 
 | Call | Signature |
 |---|---|
-| `upsertEntity(storeSlot, entity, changedEntitySlots?)` | `(storeSlot, TEntity, TOIMEntitySlot<TEntity, TKey>[]?) => TOIMEntitySlot<TEntity, TKey>` — **total** |
-| `upsertEntities(storeSlot, entities, changedEntitySlots?)` | `(storeSlot, readonly TEntity[], TOIMEntitySlot<TEntity, TKey>[]?) => TOIMEntitySlot<TEntity, TKey>[]` — the slot of EVERY entity, in input order, whether or not its write changed anything |
-| `insertEntity(storeSlot, key, entity, changedEntitySlots?)` | `(storeSlot, TKey, TEntity, TOIMEntitySlot<TEntity, TKey>[]?) => TOIMEntitySlot<TEntity, TKey>` — **total**, under a key you name |
-| `insertEntities(storeSlot, entities)` | `(storeSlot, readonly TEntity[]) => void` — a bulk load of NEW keys. A key already filed, or named twice in the list, throws and rolls back only the entities this call filed; what was in the store slot before stays. No `changed` — a bulk load changes every entity |
-| `fillEntities(storeSlot, keys, entities)` | `(storeSlot, readonly TKey[], readonly TEntity[]) => void` — the same under keys you name, with the same rollback; it also **throws unless the store slot is empty** |
+| `service.writeSlotContentByKey(storeSlot, key, entity, changedEntitySlots?)` | `(storeSlot, TKey, TEntity, TOIMEntitySlot<TEntity, TKey>[]?) => TOIMEntitySlot<TEntity, TKey>` — **total**: a miss mints and fills, a hit writes the whole value |
+| `writeSlotContent(slot, entity)` | `(slot, TEntity) => boolean` — the whole value onto a slot you hold; columns it had and `entity` does not, go |
 | `updateEntity(slot, patch)` | `(slot, Partial<TEntity>) => slot` |
 | `updateEntityColumn(slot, columnName, value)` | `<C extends keyof TEntity & string>(slot, C, TEntity[C]) => slot` — one column, no patch object and no walk over it |
-| `deleteEntity(slot)` | `(slot) => void` |
-| `deleteEntities(storeSlot, slots)` | the batch form — one subframe for the whole batch, so the store slot is written to the channel ONCE for the batch, not once per entity (`upsertEntities` and `insertEntities` are the same) |
-| `clearAllEntities(storeSlot)` | `(storeSlot) => void` — clears every filed slot inside one subframe, so the whole clear is one frame, not one per slot |
-| `markEntityChanged(slot, changedColumns?)` | `(TOIMEntitySlot<TEntity, TKey>, readonly (keyof TEntity & string)[]?) => void` |
+| `clearSlotContent(slot)` | `(slot) => void` — the entity goes; the identity stays while anything refers to it |
+| `markEntityChanged(slot, changedColumns?)` | `(slot, readonly (keyof TEntity & string)[]?) => void` |
 | `deleteEntityColumns(slot, columnNames)` | `(slot, readonly TOIMEntityColumnName<TEntity>[]) => slot` — the named columns go |
-| `writeEntity(slot, entity)` | `(slot, TEntity) => boolean` — the whole value onto a slot you hold; columns it had and `entity` does not, go |
-| `findEntityByKey(storeSlot, key)` | `(storeSlot, TKey) => TEntity \| undefined` — the entity alone; mints nothing |
+| `service.writeInBatch(storeSlot, write)` | `<TResult>(storeSlot, () => TResult) => TResult` — an index on the collection hears the whole batch in one call |
+| `service.findSlotByKey(storeSlot, key)?.entity` | the entity alone; mints nothing |
 
 - **The store keeps your object by default.** Under the default `oimInsertEntityWithoutCopy` the
   slot holds the object you hand in, so with the in-place writer a later update edits that
-  same object; pass `entityInsertStrategy: oimInsertEntityWithCopy` to store `{ ...entity }`
+  same object; pass `entityInserter: oimInsertEntityWithCopy` to store `{ ...entity }`
   and leave your object untouched. After an insert, change the object only through the
   content service (`updateEntity`, or `markEntityChanged` after a hand edit): editing it and calling
-  `upsertEntity` with the same object again wakes nobody, because no column reads as changed. `oimInsertEntityWithSanitizedCopy` also removes an own
+  `writeSlotContent` with the same object again wakes nobody, because no column reads as changed. `oimInsertEntityWithSanitizedCopy` also removes an own
   `__proto__` key: pick it for untrusted JSON.
 - `updateEntity` takes a **patch** — named columns move, unnamed ones stay.
-  `insertEntity`, `upsertEntity` and `writeEntity` take a **whole value**, and a column the new value does not name
+  `writeSlotContentByKey` and `writeSlotContent` take a **whole value**, and a column the new value does not name
   is removed from the entity.
 - A write that moves no column wakes nobody.
-- **`upsertEntity` always hands back the slot**, whatever the write changed — see the
-  rule on `insertEntity`; this door is that one plus `keyOf`.
-- **`changedEntitySlots?` is the same array on both**: optional, yours, appended with the
+- **`writeSlotContentByKey` always hands back the slot**, whatever the write changed.
+- **`changedEntitySlots?`**: optional, yours, appended with the
   entity slots whose content was different from what they already held. One array reused
-  across a whole `upsertEntities` batch is the intended use, so a
+  across a whole batch is the intended use, so a
   pass over its slots costs the entities that changed rather than the entities that
   arrived. It is never cleared — you empty it.
 
 ```ts
 const changed: TOIMEntitySlot<Card, TOIMStoreKey>[] = [];
-cardService.slotContentService.upsertEntities(cards, payload, changed);
+cardService.writeInBatch(cards, () => {
+    for (const card of payload) cardService.writeSlotContentByKey(cards, card.id, card, changed);
+});
 for (const slot of changed) reindex(slot);   // the re-sent entities are not in here
 changed.length = 0;
 ```
@@ -1592,13 +1509,13 @@ cardService.slotContentService.markEntityChanged(slot, ['title']);
   what the store holds. **Pass the list.** The no-argument form is the convenient
   one and it gives back the per-column walk this door exists to skip.
 - **An empty list wakes nothing at all** — not the columns, not the entity slot, not the
-  store slot's listeners. `[]` is the caller saying nothing moved, so it returns before the
-  subframe opens: a write that changes nothing wakes nobody here too.
+  store slot's listeners. `[]` is the caller saying nothing moved, so it returns before
+  anything is marked: a write that changes nothing wakes nobody here too.
 - **With either of the other two it wakes the entity slot and the store slot's content-change listeners**, so an
   effect on the slot itself and an index over the store slot both see a hand mutation.
 - **It re-stamps emptiness** whenever emptiness can depend on the mutation — with no column list,
-  on a slot whose `entity` is `undefined`, and on a content service with a `slotEmptiness` other than
-  `OIMSlotEmptinessByEntityPresence.INSTANCE`, a release policy that releases written slots, or a db with a
+  on a slot whose `entity` is `undefined`, and on a content service with a `slotEmptinessPolicy` other than
+  `OIMSlotEntityPresenceEmptinessPolicy.INSTANCE`, a release policy that releases written slots, or a db with a
   `slotStamp` — so a hand mutation that emptied the entity leaves `oimIsSlotEmpty(slot)`
   true rather than lying, and the release guard can take the identity when it should.
 - **It refuses inside a frame**, through the same `assertWritable` →
@@ -1618,19 +1535,19 @@ Both strategies ship as factories; the fork is chosen once, as the content servi
 
 ```ts signature
 interface IOIMEntityWriter {
-    readonly fillEntity: (slot: TOIMEntitySlot, entity: object) => void;
-    readonly putEntity: (slot: TOIMEntitySlot, entity: object, changedColumnNames: string[] | undefined) => boolean;
-    readonly patchEntity: (slot: TOIMEntitySlot, patch: object, changedColumnNames: string[] | undefined) => boolean;
+    readonly fillEntity: (slot: TOIMEntityContentSlot, entity: object) => void;
+    readonly putEntity: (slot: TOIMEntityContentSlot, entity: object, changedColumnNames: string[] | undefined) => boolean;
+    readonly patchEntity: (slot: TOIMEntityContentSlot, patch: object, changedColumnNames: string[] | undefined) => boolean;
     readonly patchColumn: (
-        slot: TOIMEntitySlot, columnName: string, value: unknown, changedColumnNames: string[] | undefined,
+        slot: TOIMEntityContentSlot, columnName: string, value: unknown, changedColumnNames: string[] | undefined,
     ) => boolean;
-    readonly deleteColumns: (slot: TOIMEntitySlot, names: readonly string[]) => readonly string[];
-    readonly clearEntity: (slot: TOIMEntitySlot) => void;
+    readonly deleteColumns: (slot: TOIMEntityContentSlot, names: readonly string[]) => readonly string[];
+    readonly clearEntity: (slot: TOIMEntityContentSlot) => void;
 }
 
 type TOIMEntityWriterOptions = {
     sameValueGuard?: TOIMSameValueGuard;
-    entityInsertStrategy?: TOIMEntityInsertStrategy;
+    entityInserter?: TOIMEntityInserter;
     putEntityColumns?: typeof oimPutEntityColumns;      // oimPutEntityColumns | oimPutEntityColumnsGuarded
     patchEntityColumns?: typeof oimPatchEntityColumns;  // oimPatchEntityColumns | oimPatchEntityColumnsGuarded
     patchEntityColumn?: typeof oimPatchEntityColumn;    // oimPatchEntityColumn | oimPatchEntityColumnGuarded
@@ -1640,7 +1557,7 @@ createOIMEntityWriterInPlace(options?: TOIMEntityWriterOptions): IOIMEntityWrite
 createOIMEntityWriterReplacing(options?: TOIMEntityWriterOptions): IOIMEntityWriter  // a new object per write that changed something
 ```
 
-`entityInsertStrategy` is the first-write strategy: `oimInsertEntityWithoutCopy` (the default) stores
+`entityInserter` is the first-write strategy: `oimInsertEntityWithoutCopy` (the default) stores
 your object itself, `oimInsertEntityWithCopy` stores `{ ...entity }`, `oimInsertEntityWithSanitizedCopy`
 stores a copy with an own `__proto__` key removed (for untrusted JSON).
 
@@ -1660,8 +1577,8 @@ per-column comparison that decides "moved".
 
 `putEntity` is PUT, `patchEntity` is PATCH (HTTP semantics). PUT makes the stored entity
 the value handed in — changed columns written, columns the value lacks removed — in ONE
-call, returning both sets of names; PATCH writes only the columns named. `upsertEntity`
-of a key that already has a value and `slotContentService.writeEntity(slot, entity)` are PUT: a whole-entity
+call, returning both sets of names; PATCH writes only the columns named. `writeSlotContentByKey`
+of a key that already has a value and `slotContentService.writeSlotContent(slot, entity)` are PUT: a whole-entity
 write that drops a column is ONE channel write of the slot, and the replacing writer
 builds ONE new object.
 
@@ -1679,9 +1596,9 @@ replacing — so the entity keeps its hidden class, and the key stays in
 leaves it out does not report it, and taking the entity away does not wake its
 readers.
 
-**Neither strategy reports anything.** Reporting is `OIMSlotContentEntityService`'s,
-and it wraps each writer call in a content subframe on the store slot's channel slot so the whole write is
-one logical change.
+**Neither strategy reports anything.** Reporting is `OIMSlotContentEntityService`'s:
+after the writer returns, it marks the slot on the channel and tells the store slot's content-change listeners
+once for the whole write.
 
 **A writer of your own** reuses the column walks both shipped writers run:
 
@@ -1721,9 +1638,9 @@ stores every value frozen:
 ```ts
 const copyColumns = (entity: Record<string, unknown>): Record<string, unknown> => ({ ...entity });
 
-function storeFrozen(slot: TOIMEntitySlot, next: Record<string, unknown> | undefined): boolean {
+function storeFrozen(slot: TOIMEntityContentSlot, next: Record<string, unknown> | undefined): boolean {
     if (next === undefined) return false;
-    (slot as TOIMSlotEditable<TOIMEntitySlot>).entity = Object.freeze(next);
+    (slot as TOIMSlotEditable<TOIMEntityContentSlot>).entity = Object.freeze(next);
     return true;
 }
 
@@ -1751,30 +1668,25 @@ const freezingWriter: IOIMEntityWriter = {
 ## Single entities
 
 A single entity — one value under no key, such as settings or a session — is a store slot of an
-`OIMSingleSlotService` over an entity content service whose key type is `void` and whose store service is
-`OIMSlotStoreServiceSingleSlotDriven.INSTANCE`, which files at most one slot per store slot. It has no
-by-key doors: its read doors name the one slot.
+`OIMSingleSlotService` over an entity content service; its store service is `OIMSingleSlotStoreService.INSTANCE`,
+which files at most one slot per store slot. It has no key and no by-key doors: its doors name the one slot.
 
 ```ts signature
-createOIMSingleEntityService<TEntity, TColumnName?>(db, {
-    entityWriter?, slotEmptiness?, slotReleasePolicy?, columnSlotStoreService?, columnNames?,
-}?): OIMSingleSlotService<TOIMEntitySlot<TEntity, void>, OIMSlotContentEntityService<TEntity, void, TOIMSingleSlotStore<…>, TColumnName>, …>
-
-// the base layer it assembles
-createOIMSingleSlotService({
-    slotContentService: createOIMSlotContentEntityService<TEntity>(db, {
-        slotStoreService: OIMSlotStoreServiceSingleSlotDriven.INSTANCE,   // no keyOf
-    }),
-})
+createOIMSingleSlotService(db, {
+    slotContentService: createOIMSlotContentEntityService<TEntity>(db),
+    slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService?, columnNames?,
+}): OIMWritableSingleSlotService<TOIMEntityContentSlot<TEntity>, TEntity, …>
 
-class OIMSingleSlotService<TSlot, TSlotContentService, TColumnName, …> {
+class OIMWritableSingleSlotService<TSlot, TContent, TSlotContentService, …> {
     readonly slotContentService: TSlotContentService;
-    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch>;
+    readonly columnSlotService: OIMColumnSlotService;
+    createStoreSlot(channelMap: IOIMChannelMap): TOIMStoreSlot<TOIMSingleSlotStore<TSlot>, TSlot, TPatch, this>;
+    writeSingleSlotContent(storeSlot, content, changedSlots?): TSlot;   // minted if missing
+    clearSingleSlotContent(storeSlot): void;
     findSingleSlot(storeSlot): TSlot | undefined;     // mints nothing
     hasSingleSlotContent(storeSlot): boolean;         // mints nothing
     getSingleSlot(storeSlot): TSlot;                  // minted if missing, tracked until the next flush
     holdSingleSlot(storeSlot): TSlot;                 // minted if missing, holdCount up by one
-    getColumn / holdColumn / getAnyColumn / holdAnyColumn / getColumnGroup / holdColumnGroup / unholdColumn;
 }
 ```
 
@@ -1785,33 +1697,32 @@ with no value until something writes it. Its store slot is a `TOIMSingleSlotStor
 ```ts
 type Settings = { theme: 'light' | 'dark'; zoom: number };
 
-const settingsService = createOIMSingleEntityService<Settings>(db);
+const settingsService = createOIMSingleSlotService(db, { slotContentService: createOIMSlotContentEntityService<Settings>(db) });
 const settings = settingsService.createStoreSlot(db);
-settingsService.slotContentService.upsertEntity(settings, { theme: 'light', zoom: 1 });
+settingsService.writeSingleSlotContent(settings, { theme: 'light', zoom: 1 });
 const settingsSlot = settingsService.holdSingleSlot(settings);
-const themeColumn = settingsService.holdColumn(settingsSlot, 'theme');
+const themeColumn = settingsService.columnSlotService.holdColumn(settingsSlot, 'theme');
 const themeEffect = effectService.createEffect(db, [themeColumn], [], () => { console.log(settingsSlot.entity?.theme); });
 settingsService.slotContentService.updateEntity(settingsSlot, { theme: 'dark' });
 db.flush();
 effectService.disposeEffect(themeEffect);
-settingsService.unholdColumn(themeColumn);
+settingsService.columnSlotService.unholdColumn(themeColumn);
 settingsSlot.owner.unholdSlot(settingsSlot);
 ```
 
 **The slot is reached only through the service.** `getSingleSlot(storeSlot)` hands back the live slot, and
 mints a fresh one — tracked by the unused-slot collector until the next flush — when there is none;
-`holdSingleSlot(storeSlot)` does the same and takes a hold. Every store write door of the content service
-works on it as on a keyed store slot (`upsertEntity`, `clearAllEntities`), and every slot door
-(`updateEntity`, `updateEntityColumn`, `deleteEntityColumns`, `writeEntity`, `markEntityChanged`,
-`deleteEntity`) takes that slot.
+`holdSingleSlot(storeSlot)` does the same and takes a hold. `writeSingleSlotContent` and `clearSingleSlotContent`
+are the store doors, and every slot door of the content service (`updateEntity`, `updateEntityColumn`,
+`deleteEntityColumns`, `writeSlotContent`, `markEntityChanged`, `clearSlotContent`) takes that slot.
 
-The slot is of the keyed entity slot's literal shape, owned by the content service's slot owner —
-`settingsSlot.owner === settingsService.slotContentService.slotOwner`, and its `storeSlot` is `settings` — so
+The slot is of the keyed entity slot's literal shape (with `key: undefined` and `indexKeys: undefined`), and its
+`storeSlot` is `settings` — so
 `effectService.createEffect(db, [settingsSlot], [], …)` works and a column of it is a root like any other.
 Its key is `undefined`, and its store is `{ slot }` (`TOIMSingleSlotStore`). Its lifetime is the
-`slotReleasePolicy` (the db's, then `OIMSlotReleasePolicyAtEmpty`), so a single entity that holds a value
+`slotReleasePolicy` (the db's, then `OIMSlotAtEmptyReleasePolicy`), so a single entity that holds a value
 stays; one emptied and unheld is released, and the slot `getSingleSlot` mints next holds no entity. The value
-is stored by the writer's `entityInsertStrategy`, which by default keeps the object handed in rather than a copy.
+is stored by the writer's `entityInserter`, which by default keeps the object handed in rather than a copy.
 
 ---
 
@@ -1821,18 +1732,17 @@ A bucket collection is, like an entity collection, a content service and the col
 The content service is the strategy — how a bucket keeps its member slots — and it is chosen at the factory:
 
 ```ts signature
-createOIMBucketService<TBucketMemberSlot = TOIMEntitySlot, TKey = TOIMStoreKey, TSlots?, TSlotContentService?, TStore?>(db, {
-    slotContentService?: OIMSlotContentBucketService<TBucketMemberSlot, TSlots>;  // default: array-driven, with commands
-    maxCommandsPerSlot?: number;            // for the default content service's OIMBucketCommands
-    bucketSlotStoreService?: IOIMSlotStoreService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore>; // Map; REQUIRED for an array TKey
-    slotReleasePolicy?: IOIMSlotReleasePolicy;
-    columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot>;
-    columnNames?: readonly string[];
-}?): OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, TSlotContentService, …>
+createOIMSlotCollectionService(db, {
+    slotContentService: new OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot>(),   // or one of the others below
+    slotStoreService?: IOIMSlotStoreService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore>;      // Map; REQUIRED for an array key
+    slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService?, columnNames?,
+}): OIMWritableSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, readonly TBucketMemberSlot[], …>
 
-new OIMSlotContentBucketServiceSetDriven<TBucketMemberSlot>({ bucketCommands? })
-new OIMSlotContentBucketServiceArrayDriven<TBucketMemberSlot, TSlots?>({ bucketCommands?, bucketArrayMembership? })
-new OIMSlotContentBucketServiceSortedArrayDriven<TBucketMemberSlot>({ compareBucketMemberSlots })
+new OIMSlotContentSetBucketService<TBucketMemberSlot>({ bucketCommands? })
+new OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot>({ bucketCommands?, bucketMemberSlotsArrayService? })
+new OIMSlotContentSortedArrayBucketService<TBucketMemberSlot>({ compareBucketMemberSlots, bucketCommands?, bucketMemberSlotsArrayService? })
+// bucketMemberSlotsArrayService: OIMBucketMemberSlotsArrayService (every mention, the default)
+//                                or new OIMBucketUniqueMemberSlotsArrayService<TBucketMemberSlot>() (each slot once)
 ```
 
 A bucket holds bucket member slots of any slot type — entity slots, bucket slots, computeds — and its
@@ -1842,16 +1752,13 @@ of the collection service take that store slot first, and the bucket doors of th
 bucket slot.
 
 ```ts
-const colourService = createOIMBucketService<TOIMEntitySlot<Card>, TOIMStoreKey, TOIMBucketSlotsSetStore<TOIMEntitySlot<Card>>,
-    OIMSlotContentBucketServiceSetDriven<TOIMEntitySlot<Card>>>(db, {
-    slotContentService: new OIMSlotContentBucketServiceSetDriven<TOIMEntitySlot<Card>>(),
-});
+const colourService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentSetBucketService<TOIMEntitySlot<Card>>() });
 const colours = colourService.createStoreSlot(db);
 const red = colourService.holdSlotByKey(colours, 'red');
-colourService.slotContentService.writeBucketMemberSlots(red, [slot, cardService.getSlotByKey(cards, 'c2')]);
+colourService.slotContentService.writeSlotContent(red, [slot, cardService.getSlotByKey(cards, 'c2')]);
 db.flush();
 for (const deckSlot of colourService.slotContentService.getBucketMemberSlots(red)) { paint(deckSlot.entity); }
-colourService.slotContentService.clearBucketMemberSlots(red);
+colourService.slotContentService.clearSlotContent(red);
 red.owner.unholdSlot(red);
 ```
 
@@ -1859,23 +1766,24 @@ Every door below is the bucket content service's and takes the bucket slot:
 
 | Door | Signature |
 |---|---|
-| `writeBucketMemberSlots(bucketSlot, bucketMemberSlots)` | `boolean` — states the whole bucket; idempotent; true when anything arrived or departed |
+| `writeSlotContent(bucketSlot, bucketMemberSlots)` | `boolean` — states the whole bucket; idempotent; true when anything arrived or departed |
+| `getBucketMemberSlotsMissingFrom(bucketSlot, bucketMemberSlots)` | `TBucketMemberSlot[]` — the members the given list leaves out, so a sync can write into them (clear a group key, set a deleted flag) instead of dropping them |
 | `addBucketMemberSlot(bucketSlot, bucketMemberSlot)` / `addBucketMemberSlots(bucketSlot, bucketMemberSlots)` | joins the named bucket member slots and touches nothing else. REMOVES NOTHING |
 | `removeBucketMemberSlot(bucketSlot, bucketMemberSlot)` / `removeBucketMemberSlots(bucketSlot, bucketMemberSlots)` | takes the named bucket member slots out and touches nothing else |
-| `clearBucketMemberSlots(bucketSlot)` | empties it |
+| `clearSlotContent(bucketSlot)` | empties it |
 | `getBucketMemberSlots(bucketSlot)` | `Iterable<TBucketMemberSlot>` |
 | `getBucketMemberSlotCount(bucketSlot)` | `number` |
-| `hasBucketMemberSlot(bucketSlot, bucketMemberSlot)` | `boolean` — the content service's own membership test: one `Set.has` on a set-driven bucket, the membership's `hasSlot` on an array-driven one |
+| `hasBucketMemberSlot(bucketSlot, bucketMemberSlot)` | `boolean` — the content service's own membership test: one `Set.has` on a set bucket; on an array bucket its `bucketMemberSlotsArrayService.hasBucketMemberSlot` (a `Set.has` when unique, `indexOf` otherwise) |
 | `markBucketColumnsChanged(bucketSlot, patch, changedColumns)` | `void` — tell the bucket's column slots which member columns moved |
 | `markContentChanged(bucketSlot)` | `void` — re-settle emptiness and re-ask the release guard after a write made another way |
-| `fillBucketMemberSlots(bucketSlot, bucketMemberSlots)` | `void` — fills a bucket slot nobody was told about yet; it throws on one that was already announced, which `addBucketMemberSlots` / `writeBucketMemberSlots` are for |
+| `fillBucketMemberSlots(bucketSlot, bucketMemberSlots)` | `void` — fills a bucket slot nobody was told about yet; it throws on one that was already announced, which `addBucketMemberSlots` / `writeSlotContent` are for |
 
 The entities of a bucket by key are the index's door, `indexService.getEntitiesByKey(indexStoreSlot, key)`
 ([The index that fills itself](#the-index-that-fills-itself--oimindexservice)).
 
 ### Which door: you hold the answer, or you hold the delta
 
-`writeBucketMemberSlots` is for a caller who has THE LIST THAT SHOULD BE THERE and does not
+`writeSlotContent` is for a caller who has THE LIST THAT SHOULD BE THERE and does not
 know what changed — a search result, a page from a server, a filter re-run. One
 call, and the engine works out the arrivals and the departures. Its cost is
 proportional to WHAT THE BUCKET HOLDS, not to the change: the difference builds a
@@ -1894,31 +1802,31 @@ the order you name them.
 
 **`addBucketMemberSlots` removes nothing.** If the authoritative list SHRANK and you call
 `addBucketMemberSlots`, the entity slots that left stay in the bucket, held. Not knowing what left is
-exactly when `writeBucketMemberSlots` is the right door, and its cost is the price of not
+exactly when `writeSlotContent` is the right door, and its cost is the price of not
 knowing.
 
 The keyed doors are the collection service's and take the store slot first —
 `decksService.getSlotByKey(decks, key)`, `decksService.holdSlotByKey(decks, key)` — and a hold is given back
-with `bucketSlot.owner.unholdSlot(bucketSlot)`. There is no by-key write: resolve the bucket slot, then
-`decksService.slotContentService.writeBucketMemberSlots(bucketSlot, members)`.
+with `bucketSlot.owner.unholdSlot(bucketSlot)`. The by-key write is `decksService.writeSlotContentByKey(decks, key, members)`; on a bucket slot you hold it is
+`decksService.slotContentService.writeSlotContent(bucketSlot, members)`.
 
 A bucket's emptiness is the content service's `isSlotEmpty(bucketSlot)`, a member count of zero, so
 an emptied bucket that nothing holds and nothing watches is released by the
 guard on the same call that emptied it.
 
 **A bucket never sorts.** Its order is what the caller put in — `addBucketMemberSlots`
-appends, `insertBucketMemberSlotAt` inserts, a move moves, `writeBucketMemberSlots` takes the
+appends, `insertBucketMemberSlotAt` inserts, a move moves, `writeSlotContent` takes the
 sequence given. A sorted list is a computed over an index:
-[Sorted lists](#sorted-lists); or the bucket of a `createOIMIndexServiceSortedArrayDriven` index, which
+[Sorted lists](#sorted-lists); or the bucket of a `createOIMSlotCollectionSortedArrayIndexService` index, which
 orders itself: [Sorted at write](#sorted-at-write).
 
-`writeBucketMemberSlots(bucketSlot, members)` runs `assertWritable` — the frame guard
+`writeSlotContent(bucketSlot, members)` runs `assertWritable` — the frame guard
 (`assertNotFlushing`) and the released-identity check — then the reconcile (an empty `arrived` and
 `departed` is an unchanged write, which wakes nobody), the holds taken on arrivals, the holds given back by
 departures and the single channel write of the bucket slot. It is handed a slot, so it hands back a
 `boolean`: true when anything arrived or departed.
 
-`writeBucketMemberSlots` **joins before it evicts**, so a slot named by both the old and the
+`writeSlotContent` **joins before it evicts**, so a slot named by both the old and the
 new list never reaches zero references. It empties with one `drainSlots` rather
 than one removal at a time — per-slot eviction on an array-driven bucket is
 n(n-1)/2 element moves.
@@ -1939,7 +1847,7 @@ empty means nothing changed. Each content service reconciles its own way:
 `OIMBucketCommands` records onto the bucket slot (`bucket.commands`) as the writes land and
 empties it once the flush has fully ended, so a consumer reads it INSIDE the
 frame and what it reads can only describe the writes it was woken for.
-`clearBucketMemberSlots` asks whether the bucket is empty **before** it
+`clearSlotContent` asks whether the bucket is empty **before** it
 touches the store, so an already-empty bucket records nothing for a call that
 reports nothing.
 
@@ -1947,33 +1855,20 @@ reports nothing.
 
 | Class | Storage type | One add records |
 |---|---|---|
-| `OIMSlotContentBucketServiceSetDriven<TBucketMemberSlot>({ bucketCommands? })` | `TOIMBucketSlotsSetStore<TBucketMemberSlot>` = `Set<TBucketMemberSlot>` | one per slot |
-| `OIMSlotContentBucketServiceArrayDriven<TBucketMemberSlot, TSlots>({ bucketCommands?, bucketArrayMembership? })` | whatever `bucketArrayMembership` builds | whatever `bucketArrayMembership` records |
-| `OIMSlotContentBucketServiceSortedArrayDriven<TBucketMemberSlot>({ compareBucketMemberSlots })` | `TOIMBucketSlotsSortedArrayStore<TBucketMemberSlot>` | one per slot, at its sorted place |
+| `OIMSlotContentSetBucketService<TBucketMemberSlot>({ bucketCommands? })` | `TOIMBucketSlotsSetStore<TBucketMemberSlot>` = `Set<TBucketMemberSlot>` | one per slot |
+| `OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot>({ bucketCommands?, bucketMemberSlotsArrayService? })` | `TOIMBucketSlotsArrayStore<TBucketMemberSlot>` = `{ bucketMemberSlots, uniqueBucketMemberSlots, sortedCount }` | one per **mention**; one per slot, order kept, with `new OIMBucketUniqueMemberSlotsArrayService()` |
+| `OIMSlotContentSortedArrayBucketService<TBucketMemberSlot>({ compareBucketMemberSlots, bucketMemberSlotsArrayService? })` | `TOIMBucketSlotsArrayStore<TBucketMemberSlot>` | one per mention or per slot, at its sorted place |
 
-The first two are the ones a caller picks between, and neither sorts: the array-driven service keeps the
-caller's order. The third is the one the sorted-at-write index builds for itself
+The first two are the ones a caller picks between, and neither sorts: the array-driven services keep the
+caller's order. The last is the one the sorted-at-write index builds for itself
 ([Sorted at write](#sorted-at-write)); its `repositionBucketMemberSlot(bucketSlot, bucketMemberSlot)` moves one
 member to its place after its sort columns changed.
 
-`bucketArrayMembership` defaults to `OIMBucketArrayMembershipNonUnique.INSTANCE` and is the fork between one
-entry per mention and one per slot. There is no "ordered unique" class; you build one like this:
-
-    new OIMSlotContentBucketServiceArrayDriven<
-        TOIMEntitySlot<Card>, TOIMBucketSlotsArrayUniqueStore<TOIMEntitySlot<Card>>
-    >({
-        bucketArrayMembership: new OIMBucketArrayMembershipUnique<TOIMEntitySlot<Card>>(),
-    })
-
-| Membership | Storage it builds | One add records |
-|---|---|---|
-| `OIMBucketArrayMembershipNonUnique.INSTANCE` (default) | `TOIMBucketSlotsArrayStore<TBucketMemberSlot>` | one per **mention** |
-| `new OIMBucketArrayMembershipUnique<TBucketMemberSlot>()` | `TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot>` | one per slot |
-
-`IOIMBucketArrayMembership<TBucketMemberSlot, TSlots>`: `createStore`, `addSlot`, `removeSlot`,
-`hasSlot`, `clearSlots`, `containsTheSameSequence`. `hasBucketMemberSlot` asks the membership's `hasSlot`: the
-unique membership answers from its `Set` (no array walk), the non-unique one walks the
-array. Only the array-driven service takes one — a set-driven service keeps its slots IN a `Set`.
+Which slots an array bucket keeps is its `bucketMemberSlotsArrayService`, the only writer of the list and the
+`Set` beside it: `OIMBucketMemberSlotsArrayService` keeps every mention and no `Set`;
+`OIMBucketUniqueMemberSlotsArrayService` keeps each slot once and the list and its `Set` together, so the two never
+disagree. With the unique one `hasBucketMemberSlot` answers from the `Set` (no array walk); with the default it
+walks the array.
 
 Nothing positional is on the abstract `OIMSlotContentBucketService`: the reads `getBucketMemberSlotAt` and
 `getBucketMemberSlotPosition` are on the array-based services (array-driven and sorted), and the five
@@ -1993,8 +1888,8 @@ named constants:
 A removal answering the third is recorded as `recordWholeList(bucketSlot)`: a set has no index to patch,
 so the consumer is told to re-read the bucket rather than handed a fabricated one.
 
-`OIM_NOTHING_WAS_INSERTED` (`-1`) is the insert's answer when nothing was inserted, which is a repeat on an
-`OIMBucketArrayMembershipUnique`. The recorded insert names the index the slot LANDED on — `at` clamped to the
+`OIM_NOTHING_WAS_INSERTED` (`-1`) is the insert's answer when nothing was inserted, which is a repeat on an array bucket
+with `OIMBucketUniqueMemberSlotsArrayService`. The recorded insert names the index the slot LANDED on — `at` clamped to the
 ends of the list — and not `getBucketMemberSlotPosition`, because the default ordered list keeps one place per
 **mention**: inserting a slot the bucket already holds gives it a second position, and the position read
 names the FIRST. A command script built from it would tell the consumer to patch at an index the slot is not
@@ -2006,9 +1901,8 @@ error. **One content service instance may serve two bucket collections** — it
 
 ### Positions the caller decides
 
-A bucket whose positions are the caller's is one over `OIMSlotContentBucketServiceArrayDriven`, which is
-what `createOIMBucketService(db)` builds when it is given no content service — the `pageService` of the setup
-block. The two position reads and the five writes are that content service's, they take the bucket
+A bucket whose positions are the caller's is one over `OIMSlotContentPositionalArrayBucketService`, which is
+the `pageService` of the setup block. The two position reads and the five writes are that content service's, they take the bucket
 slot and no store slot, and an index is valid only until the next write:
 
 | Door | What it does |
@@ -2029,7 +1923,7 @@ like any other out-of-range position.
 Each wraps a store change in the frame guard, the holds, the report and the
 release question. The default ordered list records one place per MENTION, so
 `insertBucketMemberSlotAt` of a slot the bucket already holds gives it a second position —
-build the content service with an `OIMBucketArrayMembershipUnique` when a position must name
+take `bucketMemberSlotsArrayService: new OIMBucketUniqueMemberSlotsArrayService()` when a position must name
 exactly one entity slot.
 
 Per strategy, generating code:
@@ -2052,7 +1946,7 @@ slotContentBucketService.moveBucketMemberSlotToPosition(
 );
 
 // a whole list at once, in the order the server sent
-slotContentBucketService.writeBucketMemberSlots(todo, cardService.slotContentService.upsertEntities(cards, payload));
+slotContentBucketService.writeSlotContent(todo, cardService.writeInBatch(cards, () => (payload).map(entity => cardService.writeSlotContentByKey(cards, entity.id, entity))));
 ```
 
 ### The render script: `OIMBucketCommands`
@@ -2061,14 +1955,13 @@ slotContentBucketService.writeBucketMemberSlots(todo, cardService.slotContentSer
 new OIMBucketCommands(options: { maxCommandsPerSlot?: number })   // default OIM_MAX_COMMANDS_PER_SLOT
 
 // a bucket content service takes it at construction, once:
-new OIMSlotContentBucketServiceArrayDriven({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: Infinity }) });
-// createOIMBucketService(db, { maxCommandsPerSlot }) builds the default content service with one
+new OIMSlotContentPositionalArrayBucketService({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: Infinity }) });
 ```
 
 **Recording is a strategy chosen when the bucket content service is built.** `bucketCommands` is read once
-into a readonly field; left out of a content service built with `new`, it is `OIMBucketCommandsNone`, whose
+into a readonly field; left out of a content service built with `new`, it is `OIMNoBucketCommands`, whose
 every method is empty, so a bucket nobody renders positionally pays one empty call per write and allocates no
-command. The default content service of `createOIMBucketService` records. There is no setter: a content
+command. There is no setter: a content
 service records into the one recorder it was built with. One recorder serves every bucket of every store slot
 and of every db — it is stateless.
 
@@ -2103,8 +1996,8 @@ that lands after a flush but before that reset starts a new script instead of ex
 read. The reset is subscribed with `subscribeAfterEachFlush` on the first script a channel slot ever sees, and
 walks only the buckets that recorded.
 
-A positional write is always recorded as a position. `isWholeListRecorded` is set by a write of the whole bucket — `writeBucketMemberSlots`,
-`clearBucketMemberSlots`, `moveBucketMemberSlotRangeToPosition` — by a removal from a bucket whose
+A positional write is always recorded as a position. `isWholeListRecorded` is set by a write of the whole bucket — `writeSlotContent`,
+`clearSlotContent`, `moveBucketMemberSlotRangeToPosition` — by a removal from a bucket whose
 content service keeps no positions, which has no index to patch, and by the script
 outgrowing the list
 it describes. `maxCommandsPerSlot` is that ratio; it defaults to
@@ -2123,19 +2016,20 @@ content service's own write doors do.
 ### A single bucket
 
 One bucket under no key is a store slot of an `OIMSingleSlotService` over a bucket content service, with
-`OIMSlotStoreServiceSingleSlotDriven.INSTANCE` as the store service:
+`OIMSingleSlotStoreService.INSTANCE` as the store service:
 
 ```ts signature
-createOIMSingleBucketService<TBucketMemberSlot = TOIMEntitySlot, TSlots?, TSlotContentService?>(db, {
-    slotContentService?, maxCommandsPerSlot?, slotReleasePolicy?, columnSlotStoreService?, columnNames?,
-}?): OIMSingleSlotService<TOIMBucketSlot<TSlots, void>, TSlotContentService, …>
+createOIMSingleSlotService(db, {
+    slotContentService: new OIMSlotContentPositionalArrayBucketService<TBucketMemberSlot>(),   // or the set one
+    slotReleasePolicy?, slotSubscriptionListener?, columnSlotStoreService?, columnNames?,
+}): OIMWritableSingleSlotService<TOIMBucketContentSlot<TSlots>, readonly TBucketMemberSlot[], …>
 ```
 
 ```ts
-const handService = createOIMSingleBucketService<TOIMEntitySlot<Card>>(db);
+const handService = createOIMSingleSlotService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<Card>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const hand = handService.createStoreSlot(db);
 const handSlot = handService.holdSingleSlot(hand);
-handService.slotContentService.writeBucketMemberSlots(handSlot, [slot]);
+handService.slotContentService.writeSlotContent(handSlot, [slot]);
 handService.slotContentService.insertBucketMemberSlotAt(handSlot, 0, cardService.getSlotByKey(cards, 'c2'));
 effectService.disposeEffect(effectService.createEffect(db, [handSlot], [], () => {
     render(Array.from(handService.slotContentService.getBucketMemberSlots(handSlot)));
@@ -2143,23 +2037,22 @@ effectService.disposeEffect(effectService.createEffect(db, [handSlot], [], () =>
 handSlot.owner.unholdSlot(handSlot);
 ```
 
-One bucket, no key: the single-slot store files its one bucket slot under `undefined`. The bucket slot is a
-plain `TOIMBucketSlot<TSlots, void>`, what an effect subscribes to and what a reader is handed,
+One bucket, no key: the single-slot store files its one bucket slot as the store's `slot`. The bucket slot is a
+`TOIMBucketContentSlot<TSlots>` of the keyed bucket slot's shape (`key: undefined`), what an effect subscribes to and what a reader is handed,
 so the channel's write door still sees three slot shapes. Every door of the bucket content service takes it as
 it takes a keyed bucket slot, and `markBucketColumnsChanged(bucketSlot, patch, changedColumns)` is how the
 caller that changed members says which of their columns moved, as the index does for a keyed bucket. Each
-door opens its own subframe on the channel slot and coalesces the bucket's change to one channel write per
-subframe.
+door writes the bucket slot to the channel once.
 
 **Its lifetime is the `slotReleasePolicy`.** With none named (here or on the db) it is
-`OIMSlotReleasePolicyAtEmpty.INSTANCE`, so an emptied single bucket that nothing holds or watches is
+`OIMSlotAtEmptyReleasePolicy.INSTANCE`, so an emptied single bucket that nothing holds or watches is
 released, and `getSingleSlot(storeSlot)` mints a fresh, empty one on the next read. Hold the
-slot (`holdSingleSlot(storeSlot)`) for as long as you write into it, or name `OIMSlotReleasePolicyNever.INSTANCE`.
+slot (`holdSingleSlot(storeSlot)`) for as long as you write into it, or name `OIMSlotNeverReleasePolicy.INSTANCE`.
 
-### The index that fills itself — `OIMIndexService`
+### The index that fills itself — `OIMSlotCollectionIndexService`
 
 ```ts signature
-createOIMIndexService<TEntity, TSourceKey, TColumns?, TKey?, TSourceStore?, TSlots?, TSlotContentService?>(db, {
+createOIMSlotCollectionIndexService<TEntity, TSourceKey, TColumns?, TKey?, TSourceStore?, TSlots?, TSlotContentService?>(db, {
     entityService: Pick<OIMSlotCollectionService<TSourceKey, TOIMEntitySlot<TEntity, TSourceKey>, TSourceStore, unknown>, 'getSlots'>;
     ...TOIMIndexKeyOptions<TKey, TEntity, TColumns>;          // { columns } | { keyOf } | { keyOf, columns }
     slotContentService?: OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>;  // default: array-driven, no commands
@@ -2167,9 +2060,9 @@ createOIMIndexService<TEntity, TSourceKey, TColumns?, TKey?, TSourceStore?, TSlo
     slotReleasePolicy?: IOIMSlotReleasePolicy;
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMColumnSlot>;
     columnNames?: readonly string[];
-}): OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, …>
+}): OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TSlotContentService, …>
 
-class OIMIndexService<…> extends OIMSlotCollectionService<…> {
+class OIMSlotCollectionIndexService<…> extends OIMSlotCollectionService<…> {
     createIndexStoreSlot(sourceStoreSlot: TOIMStoreSlot<TSourceStore, TOIMEntitySlot<TEntity, TSourceKey>, Partial<TEntity>>): TOIMIndexStoreSlot<…>;
     disposeIndexStoreSlot(indexStoreSlot: TOIMIndexStoreSlot<…>): void;
     getEntitiesByKey(indexStoreSlot, key): (TEntity | undefined)[];
@@ -2180,12 +2073,12 @@ class OIMIndexService<…> extends OIMSlotCollectionService<…> {
 }
 ```
 
-`OIMIndexService` is a collection service of buckets, so it has every read door of one, and its
+`OIMSlotCollectionIndexService` is a collection service of buckets, so it has every read door of one, and its
 `slotContentService` is the bucket content service narrowed by type to its reads (`getBucketMemberSlots`,
 `getBucketMemberSlotCount`, `hasBucketMemberSlot`, and the positional reads where the strategy has them) — the
 index is the only writer of its buckets. The strategy is chosen at the factory:
-`OIMSlotContentBucketServiceArrayDriven` by default, `OIMSlotContentBucketServiceSetDriven` passed as
-`slotContentService`, and the sorted one built by `createOIMIndexServiceSortedArrayDriven`. Only the array-based
+`OIMSlotContentPositionalArrayBucketService` by default, `OIMSlotContentSetBucketService` passed as
+`slotContentService`, and the sorted one built by `createOIMSlotCollectionSortedArrayIndexService`. Only the array-based
 content services answer by position: `getBucketMemberSlotAt(bucketSlot, index)` (O(1), `undefined` past the
 end) and `getBucketMemberSlotPosition(bucketSlot, entitySlot)` (walks the array, O(n), `-1` for a non-member).
 The index's default content service records no commands; pass one built with `bucketCommands` for a render
@@ -2201,11 +2094,11 @@ read through the index service, passing that store slot; the index is what write
 written before it, without a flush, so minting inside an effect body does not throw.
 `getSlotsByKeys` / `holdSlotsByKeys` fill every new bucket in ONE pass over the source. How long it lives after that is **the
 `slotReleasePolicy`'s ordinary business**, exactly as for a hand-held bucket; the index injects no lifetime of its
-own. With none named it is `OIMSlotReleasePolicyAtEmpty.INSTANCE`: the bucket stands while it has members and is
+own. With none named it is `OIMSlotAtEmptyReleasePolicy.INSTANCE`: the bucket stands while it has members and is
 maintained on every write.
 
 ```ts
-const byDeckService = createOIMIndexService(db, {
+const byDeckService = createOIMSlotCollectionIndexService(db, {
     entityService: cardService,
     keyOf: (card: Card) => card.deck,
 });
@@ -2215,14 +2108,14 @@ const spades = byDeckService.holdSlotByKey(byDeck, 'spades');
 effectService.createEffect(db, [spades], [], () => render(Array.from(byDeckService.slotContentService.getBucketMemberSlots(spades))));
 ```
 
-A set-driven index names its content service, whose bucket member slot type is spelled out —
-`new OIMSlotContentBucketServiceSetDriven()` infers `<TOIMSlot>` and fails to type-check:
+A set-driven index names its content service with the bucket member slot type and the index key type spelled
+out — `new OIMSlotContentSetBucketService()` infers `<TOIMSlot, TOIMStoreKey>` and fails to type-check:
 
 ```ts
-const bySuitService = createOIMIndexService(db, {
+const bySuitService = createOIMSlotCollectionIndexService(db, {
     entityService: cardService,
     columns: ['deck'],
-    slotContentService: new OIMSlotContentBucketServiceSetDriven<TOIMEntitySlot<Card>>(),
+    slotContentService: new OIMSlotContentSetBucketService<TOIMEntitySlot<Card>, string>(),
 });
 const bySuit = bySuitService.createIndexStoreSlot(cards);
 ```
@@ -2240,17 +2133,15 @@ const bySuit = bySuitService.createIndexStoreSlot(cards);
   ones `keyOf` reads. With `columns`, a patch or put whose changed columns include none of
   them keeps the entity's key and calls nothing; a write of the whole value (a fill, a
   clear, `markEntityChanged(slot)` with no names) always reads the key again.
-- **A key of several columns** takes its own door: `createOIMIndexServiceByCompositeKey(db,
-  { entityService, columns: ['deck', 'suit'] })` makes the key the array of those values in order, typed as a
-  tuple. It builds the bucket store on `OIMSlotStoreServiceTreeDriven` over
-  `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()`, and only that store knows the key is an array (its
-  `isSameKey`), so a fresh array with the same parts moves nothing. `createOIMIndexService` takes a scalar key
+- **A key of several columns**: `createOIMSlotCollectionIndexService(db, { entityService, columns: ['deck', 'suit'],
+  bucketSlotStoreService: new OIMSlotTreeStoreService(OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()) })` makes the key
+  the array of those values in order, typed as a tuple. Only that store knows the key is an array (its
+  `isSameKey`), so a fresh array with the same parts moves nothing. `createOIMSlotCollectionIndexService` takes a scalar key
   unless it is handed a `bucketSlotStoreService`: two columns or an array `keyOf` without one do not compile.
   `getSlotsByKeys` / `holdSlotsByKeys` fill array-keyed buckets one pass over the
   source per key (the cost of `getSlotByKey` each); only a scalar key gets one pass for all.
-- **Entity slots are filed on write**, using the index's key. Batch doors (`upsertEntities`,
-  `insertEntities`/`fillEntities`, `deleteEntities`, `clearAllEntities`) notify once per
-  batch; the index groups the entity slots by key and moves each group with one bucket write.
+- **Entity slots are filed on write**, using the index's key. Writes inside `writeInBatch` on the collection
+  notify once per batch; the index groups the entity slots by key and moves each group with one bucket write.
 - **Reading**, each taking the index store slot first: `getSlotByKey`, `holdSlotByKey`, `findSlotByKey`,
   `hasSlotContentByKey`, `getSlotsByKeys`, `holdSlotsByKeys`, `getSlots`, `getSlotCount`, `getEntitiesByKey`, and the bucket column
   slot doors `getAnyBucketColumnByKey`, `holdAnyBucketColumnByKey`,
@@ -2274,9 +2165,9 @@ const bySuit = bySuitService.createIndexStoreSlot(cards);
   is maintained whether anyone holds it or not.
 - **Order is not the bucket's business, unless you pick the strategy that makes it so.**
   A bucket keeps its arrival order; a sorted list is
-  `createOIMComputedServiceSorted(db, { indexService, sortColumns?, comparator? })`
+  `createOIMSortedComputedService(db, { indexService, sortColumns?, comparator? })`
   — see [Sorted lists](#sorted-lists) — or the index is built with
-  `createOIMIndexServiceSortedArrayDriven`, whose buckets are already in order — see
+  `createOIMSlotCollectionSortedArrayIndexService`, whose buckets are already in order — see
   [Sorted at write](#sorted-at-write). A second computed over the bucket handles
   projection or filtering.
 - **Members are read through the bucket content service**: `Array.from(indexService.slotContentService.getBucketMemberSlots(bucketSlot))`.
@@ -2286,9 +2177,9 @@ const bySuit = bySuitService.createIndexStoreSlot(cards);
   membership only**: an entity slot joining or leaving. A write to an entity that stays in the
   bucket does not wake it — subscribe to that entity's own slot for that.
 - **Bucket lifetime is the `slotReleasePolicy` option, not the index's.** Name nothing (here or on the db)
-  and it is `OIMSlotReleasePolicyAtEmpty.INSTANCE`: an unheld bucket stays while it has members and goes
-  once empty; `OIMSlotReleasePolicyNever.INSTANCE` keeps it for good; pass an `OIMSlotReleasePolicyAfterIdle`
-  and it cools on its queue; pass `OIMSlotReleasePolicyAtUnhold.INSTANCE` and it dies at the last give-back,
+  and it is `OIMSlotAtEmptyReleasePolicy.INSTANCE`: an unheld bucket stays while it has members and goes
+  once empty; `OIMSlotNeverReleasePolicy.INSTANCE` keeps it for good; pass an `OIMSlotAfterIdleReleasePolicy`
+  and it cools on its queue; pass `OIMSlotAtUnholdReleasePolicy.INSTANCE` and it dies at the last give-back,
   and the next hold builds a fresh one by walking the source again.
 
 **The bucket's any-column slot exists, but it is not the recommended path.**
@@ -2299,7 +2190,7 @@ the bucket slot (`getSlotByKey` / `holdSlotByKey`). A reader that wants both sub
 to both, and the subscriber picks by which slots it puts in `createEffect`.
 
 ```ts
-const deckIndexService = createOIMIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
+const deckIndexService = createOIMSlotCollectionIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
 const deckIndex = deckIndexService.createIndexStoreSlot(cards);
 const spadesBucket = deckIndexService.holdSlotByKey(deckIndex, 'spades');
 const spadesAnyColumn = deckIndexService.holdAnyBucketColumnByKey(deckIndex, 'spades');
@@ -2307,7 +2198,7 @@ const entitiesEffect = effectService.createEffect(db, [spadesBucket, spadesAnyCo
     console.log(deckIndexService.getEntitiesByKey(deckIndex, 'spades'));
 });
 effectService.disposeEffect(entitiesEffect);
-deckIndexService.unholdColumn(spadesAnyColumn);
+deckIndexService.columnSlotService.unholdColumn(spadesAnyColumn);
 spadesBucket.owner.unholdSlot(spadesBucket);
 ```
 
@@ -2339,19 +2230,17 @@ no listener is called, nothing is buffered, and the names array is reused across
 every column write is added with `readColumnNames` `undefined`. **The filter is the union, per store
 slot, not per listener**: once a write touches a column ANY listener of that store reads, every
 listener of that store is called, so a listener that declared a narrower set still checks
-`changedColumns` itself, as `OIMIndexService` does against its key columns.
+`changedColumns` itself, as `OIMSlotCollectionIndexService` does against its key columns.
 `IOIMContentChangeListener<TSlot, TPatch>` has two methods:
 `onContentChanged(slot, patch, changedColumns)` and
 `onContentChangedMany(slotChannelQueue, patchChannelQueue, changedColumnsChannelQueue)` — three
 parallel `OIMChannelQueue`s read with `getEntryCount()` / `getEntryAt(i)`, valid only during the
 call, so a listener copies what it keeps — `patch` is what an update
 wrote, `changedColumns` the names `markEntityChanged(slot, columns)` was given, either
-`undefined` when the write carries none. A content service holds a store slot's notifications until ITS
-outermost content subframe closes: a single write delivers one `onContentChanged` when its own
-subframe closes, and a many-entity door (`upsertEntities`, `insertEntities`, `fillEntities`,
-`deleteEntities`, `clearAllEntities`) delivers ONE
-`onContentChangedMany` when the door returns. A subframe the caller opens on the channel slot
-does not hold them — an index is up to date as soon as the content service's own door returns.
+`undefined` when the write carries none. A single write outside a batch delivers one `onContentChanged` as soon as it is filed; inside
+`writeInBatch` (or `openBatch` / `closeBatch`) on the collection the writes are queued on the store slot and
+delivered as ONE `onContentChangedMany` when the outermost batch closes. Code inside the batch reads the index
+as it was before the batch.
 This hook is the only seam an index uses; an index of your own is a listener.
 
 **Bucket column slots.** An index hands out one column slot per bucket and column:
@@ -2365,24 +2254,24 @@ return the same kind of slot, written when any column of any member changes. A g
 `slot.owner.unholdSlot(slot)`.
 
 ```ts
-const decksService = createOIMIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
+const decksService = createOIMSlotCollectionIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
 const decks = decksService.createIndexStoreSlot(cards);
 const rankOfSpades = decksService.holdBucketColumnByKey(decks, 'spades', 'rank');
 effectService.disposeEffect(effectService.createEffect(db, [rankOfSpades], [], () => {}));
-decksService.unholdColumn(rankOfSpades);
+decksService.columnSlotService.unholdColumn(rankOfSpades);
 ```
 
 ### Sorted lists
 
 ```ts signature
-createOIMComputedServiceSorted<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore, TComputedStore?>({
-    indexService: OIMIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
+createOIMSortedComputedService<TKey, TEntity extends object, TSlots, TSourceKey, TSourceStore, TComputedStore?>({
+    indexService: OIMSlotCollectionIndexService<TKey, TEntity, TSlots, TSourceKey, TSourceStore>;
     sortColumns?: readonly TOIMSortColumn<TEntity>[];   // { column: TOIMSortableColumnName<TEntity>; direction: 'asc' | 'desc' }
     comparator?: (left: TEntity, right: TEntity) => number;
-    slotReleasePolicy?: IOIMSlotReleasePolicy;          // default OIMSlotReleasePolicyAtUnhold.INSTANCE
+    slotReleasePolicy?: IOIMSlotReleasePolicy;          // default OIMSlotAtUnholdReleasePolicy.INSTANCE
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot>;
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<…>, TComputedStore>;  // Map; REQUIRED for any other store
-}): OIMComputedServiceSorted<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>
+}): OIMSortedComputedService<TKey, TEntity, TSlots, TSourceKey, TSourceStore, TComputedStore>
 
 createSortedStoreSlot(indexStoreSlot: TOIMIndexStoreSlot<…>): TOIMStoreSlot<TComputedStore, TOIMSortedComputedSlot<TEntity, TKey>>
 readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMSortedComputedSlot<TEntity, TKey>, TComputedStore, …>
@@ -2390,11 +2279,11 @@ readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMSortedCom
 
 `slotReleasePolicy` decides whether a key's sorted list outlives its last hold. The
 default lets it go at the unhold, so holding the key again sorts from scratch;
-`OIMSlotReleasePolicyNever.INSTANCE` keeps every key that was ever read and re-sorts it
+`OIMSlotNeverReleasePolicy.INSTANCE` keeps every key that was ever read and re-sorts it
 only when a read finds it changed — the arm for a view that switches between groups.
 Pass the same policy to the index the list reads, or its bucket is rebuilt instead.
 
-An `OIMComputedServiceSorted` takes no db: its store slots run on the channel slot of the index store slot
+An `OIMSortedComputedService` takes no db: its store slots run on the channel slot of the index store slot
 they sort. One per index service. `createSortedStoreSlot(indexStoreSlot)` makes one sorted store slot over
 one index store slot, and the read doors of `computedCollectionService` take that store slot first:
 `getSlotByKey`, `holdSlotByKey`, `findSlotByKey`, `getSlots`, `getSlotCount`, and the column doors; per key a
@@ -2420,11 +2309,11 @@ slots sorted. A hold is given back with `slot.owner.unholdSlot(slot)`.
   to a member as with `comparator` alone.
 
   ```ts
-  const cardsInDeckService = createOIMIndexService(db, {
+  const cardsInDeckService = createOIMSlotCollectionIndexService(db, {
       entityService: cardService,
       keyOf: (card: Card) => card.deck,
   });
-  createOIMComputedServiceSorted({
+  createOIMSortedComputedService({
       indexService: cardsInDeckService,
       sortColumns: [{ column: 'title', direction: 'asc' }, { column: 'rank', direction: 'asc' }],
       comparator: (l, r) => l.title.localeCompare(r.title, 'de') || l.rank - r.rank,
@@ -2439,9 +2328,9 @@ SECOND array of `createEffect`. A re-sort that yields the same sequence
 (`oimSameSlotSequence`) keeps the previous array, so its identity is stable.
 
 ```ts
-const decksService = createOIMIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
+const decksService = createOIMSlotCollectionIndexService(db, { entityService: cardService, keyOf: (card: Card) => card.deck });
 const decks = decksService.createIndexStoreSlot(cards);
-const byRankInDeckService = createOIMComputedServiceSorted({
+const byRankInDeckService = createOIMSortedComputedService({
     indexService: decksService,
     sortColumns: [{ column: 'rank', direction: 'asc' }],
 });
@@ -2456,21 +2345,21 @@ spadesByRank.owner.unholdSlot(spadesByRank);
 
 ### Sorted at write
 
-A second way to get a sorted list. `createOIMComputedServiceSorted` sorts at read, over any
-index. `createOIMIndexServiceSortedArrayDriven` keeps the index's own buckets sorted at write, and
+A second way to get a sorted list. `createOIMSortedComputedService` sorts at read, over any
+index. `createOIMSlotCollectionSortedArrayIndexService` keeps the index's own buckets sorted at write, and
 the user picks one at construction.
 
 ```ts signature
-createOIMIndexServiceSortedArrayDriven<TEntity extends object, TSourceKey, TColumns?, TKey extends TOIMStoreKey?, TSourceStore?, TStore?>(db, {
-    entityService, ...TOIMIndexKeyOptions<TKey, TEntity, TColumns>,     // as createOIMIndexService, scalar key
+createOIMSlotCollectionSortedArrayIndexService<TEntity extends object, TSourceKey, TColumns?, TKey extends TOIMStoreKey?, TSourceStore?, TStore?>(db, {
+    entityService, ...TOIMIndexKeyOptions<TKey, TEntity, TColumns>,     // as createOIMSlotCollectionIndexService, scalar key
     sortColumns: readonly TOIMSortColumn<TEntity>[];                   // REQUIRED
     bucketSlotStoreService?, slotReleasePolicy?, columnSlotStoreService?, columnNames?,
-}): OIMIndexServiceSortedArrayDriven<…>   // its slotContentService is an OIMSlotContentBucketServiceSortedArrayDriven
+}): OIMSlotCollectionSortedArrayIndexService<…>   // its slotContentService is an OIMSlotContentSortedArrayBucketService
 ```
 
 ```ts
 declare const someCardSlot: TOIMEntitySlot<Card, TOIMStoreKey>;
-const cardsByDeckService = createOIMIndexServiceSortedArrayDriven(db, {
+const cardsByDeckService = createOIMSlotCollectionSortedArrayIndexService(db, {
     entityService: cardService,
     columns: ['deck'],
     sortColumns: [{ column: 'rank', direction: 'asc' }, { column: 'id', direction: 'desc' }],
@@ -2483,26 +2372,26 @@ cardsByDeckService.slotContentService.getBucketMemberSlotPosition(spades, someCa
 ```
 
 - **Reads come back in order**: `getBucketMemberSlots`, `getBucketMemberSlotAt` and
-  `getBucketMemberSlotPosition` on `OIMSlotContentBucketServiceSortedArrayDriven` answer in `sortColumns` order,
+  `getBucketMemberSlotPosition` on `OIMSlotContentSortedArrayBucketService` answer in `sortColumns` order,
   so no sorted computed is needed.
 - **A lazy insertion buffer.** A write appends the arrival to an unsorted tail of the bucket's
-  array (`TOIMBucketSlotsSortedArrayStore`: the array store plus `sortedCount`). The first read
+  array (`TOIMBucketSlotsArrayStore`: the array store plus `sortedCount`). The first read
   settles the tail: binary insertion when the tail is short, one sort of the array when it is
   long. A bucket nobody reads is never sorted.
 - **The index re-files a member when one of its sort columns changes, and only then.** A write
   to a column that is neither the key nor a sort column neither reorders the bucket nor wakes it.
   A re-file wakes the bucket once per frame.
 - **There are no positional writes** on this bucket (`insertBucketMemberSlotAt` and the other
-  position writes belong to `OIMSlotContentBucketServiceArrayDriven`): the order is the comparator's,
+  position writes belong to `OIMSlotContentPositionalArrayBucketService`): the order is the comparator's,
   not the caller's.
-- **Bucket commands are always `OIMBucketCommandsNone`**: this strategy records no per-flush
+- **Bucket commands are always `OIMNoBucketCommands`**: this strategy records no per-flush
   script.
-- **Parts**: `OIMSlotContentBucketServiceSortedArrayDriven` (options
-  `TOIMSlotContentBucketServiceSortedArrayDrivenOptions`: `compareBucketMemberSlots`; adds
-  `repositionBucketMemberSlot(bucketSlot, bucketMemberSlot)`), `OIMIndexServiceSortedArrayDriven`.
+- **Parts**: `OIMSlotContentSortedArrayBucketService` (options
+  `TOIMSlotContentSortedArrayBucketServiceOptions`: `compareBucketMemberSlots`; adds
+  `repositionBucketMemberSlot(bucketSlot, bucketMemberSlot)`), `OIMSlotCollectionSortedArrayIndexService`.
 
 **Choosing between the two arms.** Sort-at-write suits point updates: a change to a sort
-column re-files one member. Sort-at-read (`createOIMComputedServiceSorted` over any index)
+column re-files one member. Sort-at-read (`createOIMSortedComputedService` over any index)
 suits bulk loads. Both are shipped; neither is a default.
 
 **`indexKeys` on each entity slot.** Each indexable slot carries, per index store slot, the key the entity is
@@ -2515,10 +2404,10 @@ writer. Only the index writes it, through the `IOIMIndexKeysService` (`get(slot,
 
 | strategy | on `disposeIndexStoreSlot` | cost |
 |---|---|---|
-| `OIMIndexKeysServiceAppending` (default) | the index's position is never reused; its stale entry stays on each entity slot | an entity slot's `indexKeys` grows to the highest position any index wrote on it (K indexes made and disposed → an array of K on an entity slot the last one filed), and a stale entry keeps its key reachable. Writes pay nothing for a disposed index: only live listeners are kept |
-| `OIMIndexKeysServiceReclaiming` | wipes that position on every entity slot of the source store slot and reuses it | O(N) per dispose |
+| `OIMAppendingIndexKeysService` (default) | the index's position is never reused; its stale entry stays on each entity slot | an entity slot's `indexKeys` grows to the highest position any index wrote on it (K indexes made and disposed → an array of K on an entity slot the last one filed), and a stale entry keeps its key reachable. Writes pay nothing for a disposed index: only live listeners are kept |
+| `OIMReclaimingIndexKeysService` | wipes that position on every entity slot of the source store slot and reuses it | O(N) per dispose |
 
-Switch to `OIMIndexKeysServiceReclaiming` only if you create indexes dynamically and often. Creating
+Switch to `OIMReclaimingIndexKeysService` only if you create indexes dynamically and often. Creating
 indexes dynamically and often is expensive, so avoid it.
 
 ### The channel of a bucket store slot
@@ -2581,7 +2470,7 @@ the next read or hold.
 class OIMComputedService<TKey, TValue, TComputedStore> {
     constructor(options: TOIMComputedServiceOptions<TKey, TValue, TComputedStore>);
     readonly computedCollectionService: OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore,
-        OIMComputedValueService<TKey, TValue>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMColumnOwnerPullDriven>;
+        OIMComputedValueService<TKey, TValue>, Extract<keyof TValue, string>, TOIMComputedColumnSlot, OIMPullColumnSlotOwner>;
     createComputedStoreSlot(channelMap: IOIMChannelMap, derive?, createSources?): TOIMComputedStoreSlot<TComputedStore, TValue, TKey>;
 }
 
@@ -2590,7 +2479,7 @@ createOIMComputedService<TKey, TValue, TComputedStore = Map<TKey, TOIMComputedSl
     derive?: (computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue;
     sameValueGuard?: TOIMSameValueGuard<TValue>;   // default Object.is
     initialValue?: TValue;
-    slotReleasePolicy?: IOIMSlotReleasePolicy;     // default OIMSlotReleasePolicyAtUnhold.INSTANCE
+    slotReleasePolicy?: IOIMSlotReleasePolicy;     // default OIMSlotAtUnholdReleasePolicy.INSTANCE
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot>;  // OIMDefaults.COMPUTED_COLUMN_SLOT_STORE_SERVICE
     columnNames?: readonly Extract<keyof TValue, string>[];
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<TValue, TKey>, TComputedStore>;  // Map; REQUIRED for any other store
@@ -2610,15 +2499,13 @@ Doors of a keyed computed store slot are the read doors of `computedCollectionSe
 `getSlots(storeSlot)`, `getSlotCount(storeSlot)`, and the column doors; the value is
 `slot.computedValueService.getValueForSlot(slot)`, and a give-back is `slot.owner.unholdSlot(slot)`.
 
-**One service, both computed shapes.** A keyed store slot and a single one — a store slot of a
-`void`-keyed service over `OIMSlotStoreServiceSingleSlotDriven.INSTANCE` — outlive every computed slot they
-mint, and mint a fresh one on the next read or hold once the previous one is gone. There is no
-single-computed class and no single-computed door: the single one is read by key `undefined`.
+**A single computed is its own service.** `createOIMSingleComputedService<TValue>({ … })` builds an
+`OIMSingleComputedService`, whose store slots each hold at most one computed slot, read through
+`computedSingleSlotService` (`getSingleSlot`, `holdSingleSlot`, `findSingleSlot`). Like a keyed one, a store slot
+outlives every computed slot it mints and mints a fresh one on the next read or hold once the previous one is gone.
 
 ```ts
-const topRankService = createOIMComputedService<void, number, TOIMSingleSlotStore<TOIMComputedSlot<number, void>>>({
-    computedSlotStoreService:
-        OIMSlotStoreServiceSingleSlotDriven.INSTANCE as unknown as OIMSlotStoreServiceSingleSlotDriven<TOIMComputedSlot<number, void>>,
+const topRankService = createOIMSingleComputedService<number>({
     sameValueGuard: oimSameValueZeroGuard,
     initialValue: -1,
 });
@@ -2627,16 +2514,15 @@ const topRank = topRankService.createComputedStoreSlot(
     () => cardService.getSlotByKey(cards, 'c1').entity?.rank ?? -1,
     () => ({ sourceSlots: [cardService.getSlotByKey(cards, 'c1')] }),
 );
-const heldTopRank = topRankService.computedCollectionService.holdSlotByKey(topRank, undefined);   // the same slot while anything holds it
+const heldTopRank = topRankService.computedSingleSlotService.holdSingleSlot(topRank);   // the same slot while anything holds it
 heldTopRank.computedValueService.getValueForSlot(heldTopRank);
-heldTopRank.owner.unholdSlot(heldTopRank);        // gone; the next holdSlotByKey(topRank, undefined) mints a new one
+heldTopRank.owner.unholdSlot(heldTopRank);        // gone; the next holdSingleSlot(topRank) mints a new one
 ```
 
-A single computed store slot has one key, `undefined`, and a store of one slot. `getSlotByKey(storeSlot,
-undefined)` hands a slot without a hold — a fresh one goes to the unused-slot collector and is let go at the
+A single computed store slot has no key and a store of one slot. `getSingleSlot(storeSlot)` hands a slot without a hold — a fresh one goes to the unused-slot collector and is let go at the
 next flush unless something holds it — and `holdSlotByKey(storeSlot, undefined)` holds the live slot, minting
 one if the previous is gone. A computed slot goes at its last unhold once no effect reads it
-(`OIMSlotReleasePolicyAtUnhold`, the default), and gives back the holds it took on its
+(`OIMSlotAtUnholdReleasePolicy`, the default), and gives back the holds it took on its
 sources. A last unhold during a flush releases at the end of that flush, through the
 db's unused-slot collector, as for every non-empty slot. The holds a computed takes on its sources and
 gives back are one stateless service, shared by both shapes.
@@ -2650,11 +2536,11 @@ list, and a source a build closes over without naming is a source nothing holds.
 **A derivation is never empty.** `OIMComputedService` answers
 "empty" with `false`, so a filed derivation is released only when nothing holds
 it, nothing watches it, and the grace is `0` — which is what
-`OIMSlotReleasePolicyAtUnhold` answers, and the default when no `slotReleasePolicy` is given.
+`OIMSlotAtUnholdReleasePolicy` answers, and the default when no `slotReleasePolicy` is given.
 
 ```ts setup
 const rankService = createOIMComputedService<TOIMStoreKey, number>({
-    createSources: (id: TOIMStoreKey) => ({ sourceSlots: [cardService.getSlotByKey(cards, id)] }),
+    createSources: ({ key }) => ({ sourceSlots: [cardService.getSlotByKey(cards, key)] }),
     derive: (computedSlot) => cardService.getSlotByKey(cards, computedSlot.key).entity?.rank ?? -1,
     sameValueGuard: oimSameValueZeroGuard,
     initialValue: -1,
@@ -2685,37 +2571,34 @@ Pinned by `facade/computed/tests/what-a-computed-column-wakes-on.test.ts`.
 
 ```ts
 type Summary = { top: number; count: number };
-const summaryService = createOIMComputedService<void, Summary, TOIMSingleSlotStore<TOIMComputedSlot<Summary, void>>>({
-    computedSlotStoreService:
-        OIMSlotStoreServiceSingleSlotDriven.INSTANCE as unknown as OIMSlotStoreServiceSingleSlotDriven<TOIMComputedSlot<Summary, void>>,
-});
+const summaryService = createOIMSingleComputedService<Summary>();
 const summary = summaryService.createComputedStoreSlot(
     db,
     () => ({ top: slot.entity?.rank ?? -1, count: cardService.getSlotCount(cards) }),
     () => ({ sourceSlots: [slot] }),
 );
-const summaryCollectionService = summaryService.computedCollectionService;
-const summaryTop = summaryCollectionService.holdColumn(summaryCollectionService.getSlotByKey(summary, undefined), 'top');
+const summarySingleSlotService = summaryService.computedSingleSlotService;
+const summaryTop = summarySingleSlotService.columnSlotService.holdColumn(summarySingleSlotService.getSingleSlot(summary), 'top');
 const topEffect = effectService.createEffect(db, [], [summaryTop], () => { paint(slot.entity); });
 effectService.disposeEffect(topEffect);
-summaryCollectionService.unholdColumn(summaryTop);
+summarySingleSlotService.columnSlotService.unholdColumn(summaryTop);
 ```
 
 ### The order of a bucket, as one derivation per key
 
 ```ts signature
-createOIMComputedServiceBucketMemo<TKey, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore?>({
+createOIMBucketMemoComputedService<TKey, TBucketMemberSlot extends TOIMSlot, TSlots, TBucketStore, TComputedStore?>({
     bucketCollectionService: OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TBucketStore, OIMSlotContentBucketService<TBucketMemberSlot, TSlots>, …>;
-    slotReleasePolicy?: IOIMSlotReleasePolicy;      // default OIMSlotReleasePolicyAtUnhold.INSTANCE
+    slotReleasePolicy?: IOIMSlotReleasePolicy;      // default OIMSlotAtUnholdReleasePolicy.INSTANCE
     columnSlotStoreService?: IOIMSlotStoreService<string, TOIMComputedColumnSlot>;
     computedSlotStoreService?: IOIMSlotStoreService<TKey, TOIMComputedSlot<readonly TBucketMemberSlot[], TKey>, TComputedStore>;
-}): OIMComputedServiceBucketMemo<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>
+}): OIMBucketMemoComputedService<TKey, TBucketMemberSlot, TSlots, TBucketStore, TComputedStore>
 
 createBucketMemoStoreSlot(bucketStoreSlot: TOIMStoreSlot<TBucketStore, TOIMBucketSlot<TSlots, TKey>, readonly TBucketMemberSlot[]>): TOIMStoreSlot<TComputedStore, TOIMBucketMemoComputedSlot<TBucketMemberSlot, TKey>>
 ```
 
 It takes no db: a memo store slot runs on the channel slot of the bucket store slot it reads. The class is
-`new OIMComputedServiceBucketMemo(options)` (options type `TOIMComputedServiceBucketMemoOptions`), whose
+`new OIMBucketMemoComputedService(options)` (options type `TOIMBucketMemoComputedServiceOptions`), whose
 `computedCollectionService` reads the per-key derivations; `createBucketMemoStoreSlot(bucketStoreSlot)` makes
 one memo store slot over one bucket store slot.
 
@@ -2725,13 +2608,13 @@ it is produced on the read that asks for it and never while nothing reads it, an
 its `changedAtRevision` and `changedAtEpoch` move only when the list a reader would
 see actually changed. The list is handed back by IDENTITY: it is the same array for
 as long as the list holds, so a consumer memoising on identity needs no comparison
-of its own. For a SORTED list use [`createOIMComputedServiceSorted`](#sorted-lists).
+of its own. For a SORTED list use [`createOIMSortedComputedService`](#sorted-lists).
 
 The source list is ONE slot — the bucket — and it never grows: a bucket
 change is a move of the bucket's value, not of the derivation's sources.
 
 ```ts
-const orderService = createOIMComputedServiceBucketMemo({
+const orderService = createOIMBucketMemoComputedService({
     bucketCollectionService: orderedService,
 });
 const order = orderService.createBucketMemoStoreSlot(ordered);
@@ -2786,7 +2669,7 @@ type TOIMCompositeKeyNode<TAtKey = unknown, TCompositeKeyPart = TOIMEntitySlot>
 };
 ```
 
-`TOIMSlotStoreTree` is what `OIMSlotStoreServiceTreeDriven.createStore()` builds:
+`TOIMSlotStoreTree` is what `OIMSlotTreeStoreService.createStore()` builds:
 the tree's root plus a flat `Set` of every filed slot, which makes `getSlots()` and
 `getSlotCount()` O(1) rather than a walk, and keeps `getSlots()` in filing order like every other store.
 `TOIMCompositeKeyNode` is one level of that tree — a `Map` from composite key part to the
@@ -2796,10 +2679,10 @@ are holding; neither is something you build by hand.
 
 | Store | Key type |
 |---|---|
-| `OIMSlotStoreServiceMapDriven<TSlot>` | `TOIMStoreKey` = `string \| number` |
-| `OIMSlotStoreServiceTreeDriven<TOIMStoreKey, TSlot>` built with `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` | `readonly TOIMStoreKey[]` — **a chain of VALUES** |
-| `OIMSlotStoreServiceTreeDriven<TOIMEntitySlot, TSlot>` built with `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` | `readonly TOIMEntitySlot[]` — **a chain of entity SLOTS** |
-| `OIMSlotStoreServiceSingleSlotDriven.INSTANCE` | `void` — one slot per store slot, its store a `TOIMSingleSlotStore` (`{ slot }`); what every single is built on |
+| `OIMSlotMapStoreService<TSlot>` | `TOIMStoreKey` = `string \| number` |
+| `OIMSlotTreeStoreService<TOIMStoreKey, TSlot>` built with `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` | `readonly TOIMStoreKey[]` — **a chain of VALUES** |
+| `OIMSlotTreeStoreService<TOIMEntitySlot, TSlot>` built with `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` | `readonly TOIMEntitySlot[]` — **a chain of entity SLOTS** |
+| `OIMSingleSlotStoreService.INSTANCE` | `void` — one slot per store slot, its store a `TOIMSingleSlotStore` (`{ slot }`); what every single is built on |
 
 Two stores for keys, one per shape of address, and the single-slot store for no key. The chain store descends one `Map`
 lookup per composite key part, keeps `[a]` and `[a, b]` apart, and has **no encoding step**:
@@ -2839,10 +2722,10 @@ deletes nothing and returns `undefined`.
 
 | Walk | Class | Shared instance | What a composite key part is | Holds? |
 |---|---|---|---|---|
-| scalar | `OIMKeyTreeWalkScalar` | `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` | `TOIMStoreKey` | no |
-| composite | `OIMKeyTreeWalkComposite` | `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` | `TOIMEntitySlot` | **yes — one hold per edge** |
+| scalar | `OIMScalarKeyTreeWalk` | `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` | `TOIMStoreKey` | no |
+| composite | `OIMCompositeKeyTreeWalk` | `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` | `TOIMEntitySlot` | **yes — one hold per edge** |
 
-**The hold is the whole difference.** `OIMKeyTreeWalkComposite.mintNodeAt` calls
+**The hold is the whole difference.** `OIMCompositeKeyTreeWalk.mintNodeAt` calls
 `holdCompositeKeyPart` the first time it creates an edge, which runs
 `entitySlot.owner.holdSlot(entitySlot)`; `deleteKey` calls `unholdCompositeKeyPart` on
 exactly the edges it unlinked, deepest first and only after every unlink is done, which runs `entitySlot.owner.unholdSlot(entitySlot)` unless
@@ -2860,16 +2743,16 @@ type TScalarChain = readonly TOIMStoreKey[];
 type Tally = { deck: string; day: string; count: number };
 type TTallyStore = import('@oimdb/core').TOIMSlotStoreTree<TOIMEntitySlot<Tally, TScalarChain>, TOIMStoreKey>;
 
-const tallyService = createOIMSlotCollectionService({
-    slotContentService: createOIMSlotContentEntityService<Tally, keyof Tally, TScalarChain, TTallyStore>(db, {
-        slotStoreService: new OIMSlotStoreServiceTreeDriven<TOIMStoreKey, TOIMEntitySlot<Tally, TScalarChain>>(
-            OIMDefaults.KEY_TREE_WALK_SCALAR.getValue(),
-        ),
-        keyOf: (t) => [t.deck, t.day],
-    }),
+const tallyService = createOIMSlotCollectionService<
+    ReturnType<typeof createOIMSlotContentEntityService<Tally, TScalarChain>>, TTallyStore
+>(db, {
+    slotContentService: createOIMSlotContentEntityService<Tally, TScalarChain>(db),
+    slotStoreService: new OIMSlotTreeStoreService<TOIMStoreKey, TOIMEntitySlot<Tally, TScalarChain>>(
+        OIMDefaults.KEY_TREE_WALK_SCALAR.getValue(),
+    ),
 });
 const tallies = tallyService.createStoreSlot(db);
-tallyService.slotContentService.upsertEntity(tallies, { deck: 'spades', day: 'mon', count: 1 });
+tallyService.writeSlotContentByKey(tallies, ['spades', 'mon'], { deck: 'spades', day: 'mon', count: 1 });
 tallyService.getSlotByKey(tallies, ['spades', 'mon']);
 ```
 
@@ -2890,16 +2773,16 @@ type Enrolment = {
 type TChain = readonly TOIMEntitySlot[];
 type TEnrolmentStore = import('@oimdb/core').TOIMSlotStoreTree<TOIMEntitySlot<Enrolment, TChain>, TOIMEntitySlot>;
 
-const enrolmentService = createOIMSlotCollectionService({
-    slotContentService: createOIMSlotContentEntityService<Enrolment, keyof Enrolment, TChain, TEnrolmentStore>(db, {
-        slotStoreService: new OIMSlotStoreServiceTreeDriven<TOIMEntitySlot, TOIMEntitySlot<Enrolment, TChain>>(
-            OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue(),
-        ),
-        keyOf: (m) => [m.user, m.group],
-    }),
+const enrolmentService = createOIMSlotCollectionService<
+    ReturnType<typeof createOIMSlotContentEntityService<Enrolment, TChain>>, TEnrolmentStore
+>(db, {
+    slotContentService: createOIMSlotContentEntityService<Enrolment, TChain>(db),
+    slotStoreService: new OIMSlotTreeStoreService<TOIMEntitySlot, TOIMEntitySlot<Enrolment, TChain>>(
+        OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue(),
+    ),
 });
 const enrolments = enrolmentService.createStoreSlot(db);
-enrolmentService.slotContentService.upsertEntity(enrolments, { user: alice, group: admins, since: 2026 });
+enrolmentService.writeSlotContentByKey(enrolments, [alice, admins], { user: alice, group: admins, since: 2026 });
 enrolmentService.getSlotByKey(enrolments, [alice, admins]);
 ```
 
@@ -2944,10 +2827,14 @@ At a deadline the release queue reads its MARKER off the slot, decides, and call
 | `unsubscribeFromSlot(slot, at, effect)` | swap the tail of both arrays into `at`, tell the moved effect its new position at its edge (one write, no search), and **if that emptied the list, `onSlotIdle(slot)` opens a fresh idle window**, then give the subscription's hold back through `unholdSlot`; hand back whether it unfiled. Unfiling by remembered position is why taking N subscribers off one identity is O(N) and not quadratic. **Throws by name** on a released slot |
 
 **`OIMSlotOwner`** is the base class and it is concrete: it implements all five.
-Its `releaseSlotIfUnheld` does nothing, and a `protected
+Its `releaseSlotIfUnheld` does nothing, its
+`unsafeMutateSlot(slot, mutateSlot)` hands `mutateSlot` the slot as `TOIMSlotEditable` with no
+guard at all (it exists so a library that adds its own release wheel can keep its own bit in
+`slot.slotFlags`; the engine owns bits `1`, `2`, `4`, `8` and `16`, so a library starts at `32`;
+it is on the owner so a subclass can hook every such mutation), and a `protected
 onSlotIdle` does nothing; a `protected assertNotReleased` is what every refusing
 door above calls. `OIMSlotOwnerService` overrides `onSlotIdle` and
-`releaseSlotIfUnheld`, asking its release policy and its content strategy; the clock is the slot's channel slot's.
+`releaseSlotIfUnheld`, asking its release policy and its content service; the clock is the slot's channel slot's.
 Extend `OIMSlotOwner` when you own slots that no collection files.
 **`OIMDefaults.STANDALONE_SLOT_OWNER`** is one shared instance of it — the owner of a
 computed slot nobody has filed. It never releases anything, which is exactly what
@@ -2958,12 +2845,12 @@ owner is its collection type's slot owner, and that release policy applies to it
 
 **Columns are a module of every collection.** The column slots of a carrier slot live
 in `carrierSlot.columnSlotStore`, a field of the base `TOIMSlot`, so any slot can carry
-them — an entity slot, a bucket slot, a computed slot. `OIMColumnOwner` is abstract, an
+them — an entity slot, a bucket slot, a computed slot. `OIMColumnSlotOwner` is abstract, an
 `OIMSlotOwner` subclass, with two strategies:
-`OIMColumnOwnerPushDriven` (plain column slots woken by marks on a write; entity and bucket collections,
-keyed and single) and `OIMColumnOwnerPullDriven` (each column slot a computed slot over its carrier;
+`OIMPushColumnSlotOwner` (plain column slots woken by marks on a write; entity and bucket collections,
+keyed and single) and `OIMPullColumnSlotOwner` (each column slot a computed slot over its carrier;
 computed collections, keyed and single). The factory hands the strategy's factory to the slot owner as
-`createColumnOwner`. Each collection type has its own column owner, and every column slot it mints names that
+`createColumnSlotOwner`. Each collection type has its own column owner, and every column slot it mints names that
 owner as its `owner`. The owner holds only the column slot store service; the column state — the column
 groups and which columns are referenced — lives on the store slot. The collection exposes it only
 through its column doors: `getColumn(slot, columnName)`, `holdColumn(slot, columnName)`,
@@ -3026,12 +2913,11 @@ content service hands back the LIVE list — declared `Iterable`, not an array,
 `Array.from(bucketService.slotContentService.getBucketMemberSlots(bucketSlot))` is required and is the copy. A `prev` kept
 live is the same array as `next` on the following frame: the diff is empty,
 no reorder is ever drawn, and nothing throws. The other safe `prev` is
-`createOIMComputedServiceBucketMemo`'s value — a fresh array on every write that
+`createOIMBucketMemoComputedService`'s value — a fresh array on every write that
 changed the list, the same array while it did not.
 
 A LIST MAY NAME ONE SLOT TWICE, and then it holds that slot twice.
-`OIMBucketArrayMembershipNonUnique` — the default strategy of `OIMSlotContentBucketServiceArrayDriven` —
-records every mention, so an ordered bucket's list is exactly such a list. The
+`OIMSlotContentPositionalArrayBucketService` records every mention, so an ordered bucket's list is exactly such a list. The
 mentions of one identity are matched in the order they appear, and the script
 reproduces `next` mention for mention. The minimal move count (`common − LIS`)
 is claimed for lists whose identities are distinct: where the two lists name one
@@ -3083,7 +2969,9 @@ type TOIMStoreSlot<TStore = unknown, TSlot extends TOIMSlot = TOIMSlot, TPatch =
     readonly indexKeysPositions: TOIMIndexKeysPositions | undefined;
     readonly sourceStoreSlot: TOIMStoreSlot | undefined;   // an index store slot's source
     readonly isDisposed: boolean;                          // an index store slot after disposeIndexStoreSlot
-    // … column-reader counts, column groups, subframe queues, bucket write queues: the services' own
+    readonly slotService: TSlotService;                    // the service that created the store slot
+    readonly batchDepth: number;                           // openBatch / closeBatch nesting
+    // … column-reader counts, column groups, batch queues, bucket write queues: the services' own
 };
 
 type TOIMSingleSlotStore<TSlot> = { slot: TSlot | undefined };
@@ -3117,7 +3005,7 @@ type TOIMEntitySlot<TEntity extends object = object, TKey = unknown> = TOIMIndex
 };
 
 // `data` belongs to the consumer: the core never reads or writes it, and clearing or
-// removing the slot (`slotContentService.deleteEntity(slot)`) does not reset it. Each index keeps its
+// removing the slot (`slotContentService.clearSlotContent(slot)`) does not reset it. Each index keeps its
 // last key for the entity slot in `indexKeys`, through the db's `IOIMIndexKeysService`.
 
 type TOIMColumnSlot = TOIMSlot & {
@@ -3127,26 +3015,26 @@ type TOIMColumnSlot = TOIMSlot & {
 
 type TOIMComputedColumnSlot = TOIMComputedSlot<unknown, string>;   // a computed's getColumn / holdColumn return it; it goes in createEffect's second list
 
-type TOIMBucketSlot<TSlots = unknown, TKey = unknown> = TOIMIndexableSlot<TKey> & {
+type TOIMBucketContentSlot<TSlots = unknown> = TOIMSlot & {
     readonly owner: IOIMSlotOwner;
-    readonly storeSlot: TOIMStoreSlot<unknown, TOIMBucketSlot<TSlots>>;
+    readonly storeSlot: TOIMStoreSlot<unknown, TOIMBucketContentSlot<TSlots>>;
     readonly bucketSlotsStore: TSlots;
     readonly commands: readonly TOIMOrderedListCommand[] | undefined;   // emptied when the flush has ended
     readonly isWholeListRecorded: boolean;                               // reset to false with it
     readonly commandsStartedAtRevision: number;                          // the clock the script started at
     readonly commandsStartedAtEpoch: number;
-    readonly wasEmptyBeforeChange: boolean | undefined;
-    readonly isChangedAgainInSubframe: boolean;
 };
+type TOIMBucketSlot<TSlots = unknown, TKey extends NonNullable<unknown> = NonNullable<unknown>> =
+    TOIMBucketContentSlot<TSlots> & TOIMIndexableSlot<TKey>;   // a keyed bucket slot; a single bucket is the content slot alone
 
 // `holdSlotByKey(storeSlot, key)` hands back the slot itself; give the hold back with `slot.owner.unholdSlot(slot)`.
 
 type TOIMBucketSlotsSetStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = Set<TBucketMemberSlot>;
 type TOIMBucketSlotsArrayStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> = {
     bucketMemberSlots: TBucketMemberSlot[];
+    uniqueBucketMemberSlots: Set<TBucketMemberSlot> | undefined;   // kept by OIMBucketUniqueMemberSlotsArrayService
+    sortedCount: number;
 };
-type TOIMBucketSlotsArrayUniqueStore<TBucketMemberSlot extends TOIMSlot = TOIMSlot> =
-    TOIMBucketSlotsArrayStore<TBucketMemberSlot> & { uniqueBucketMemberSlots: Set<TBucketMemberSlot> };
 
 type TOIMEntityColumnName<TEntity extends object> =
     [TEntity] extends [never] ? never
@@ -3181,38 +3069,39 @@ that matches what you are comparing; they are not interchangeable.
 
 ## Full export list
 
-**200 names, every export of `packages/core/src/index.ts`, grouped by topic.**
+**218 names, every export of `packages/core/src/index.ts`, grouped by topic.**
 
 *Channel and database slots* — `OIMChannelService` · `TOIMChannelSlot` · `TOIMChannelSlotOptions` · `createOIMChannelSlot` ·
-`IOIMChannelMap` · `TOIMDBOptions` · `OIMFlushSchedulerService` · `TOIMFlushSchedulerSlot`
+`IOIMChannelMap` · `TOIMDBOptions` · `OIMFlushSchedulerService` · `TOIMFlushSchedulerSlot` · `IOIMFlushSchedulerListener`
 
 *Collector services and slots* — `OIMUnusedSlotCollectorService` · `TOIMUnusedSlotCollectorSlot` ·
 `createOIMUnusedSlotCollectorSlot` · `TOIMCollectorSlot` · `TOIMCollectorSlotOptions` · `createOIMCollectorSlot` ·
-`OIMReleaseSlotCollectorService` · `OIMReleaseSlotCollectorServiceAfterIdle` · `OIMReleaseSlotCollectorServiceAfterUnhold` ·
-`OIMReleaseSlotCollectorServiceAfterWrite` · `OIMReleaseSlotQueueService` · `TOIMReleaseSlotCollectorSlot` ·
-`createOIMReleaseSlotCollectorSlot`
-
-*Slot services* — `OIMSlotColumnService` (abstract; the column doors both slot services inherit) ·
-`OIMSlotCollectionService` · `TOIMSlotCollectionServiceOptions` · `createOIMSlotCollectionService` ·
-`OIMSingleSlotService` · `TOIMSingleSlotServiceOptions` · `createOIMSingleSlotService` · `OIMSlotOwnerService` (**type only**) ·
-`TOIMSlotOwnerServiceOptions` · `IOIMSlotContentStrategy` · `IOIMSlotContentFlushStrategy` · `IOIMSubframeCloseListener` ·
-`OIMContentChangeListenerService`
+`OIMSlotWheel` · `TOIMSlotWheelOptions` · `OIMSlotReleaseWheel` · `TOIMSlotReleaseWheelOptions` ·
+`oimMintAfterWriteSlotReleaseWheel` · `oimMintAfterIdleSlotReleaseWheel` · `oimMintAfterUnholdSlotReleaseWheel` ·
+`OIMSlotRefetchWheel` · `TOIMSlotRefetchWheelOptions` · `IOIMSlotRefetchListener`
+
+*Slot services* — `OIMSlotCollectionService` · `OIMWritableSlotCollectionService` · `TOIMSlotCollectionServiceOptions` ·
+`createOIMSlotCollectionService` · `OIMSingleSlotService` · `OIMWritableSingleSlotService` · `TOIMSingleSlotServiceOptions` ·
+`createOIMSingleSlotService` · `OIMColumnSlotService` (the column doors, `service.columnSlotService`) ·
+`OIMSlotOwnerService` (**type only**) · `TOIMSlotOwnerServiceOptions` · `IOIMSlotContentService` · `IOIMSlotContentWriter` ·
+`IOIMKeyedSlotCreator` · `IOIMSingleSlotCreator` · `IOIMSlotFilingService` · `TOIMSlotContentServiceKey` ·
+`TOIMSlotContentServiceSlot` · `TOIMSlotContentServiceSingleSlot` · `TOIMSlotContentServiceContent` ·
+`TOIMSlotContentServicePatch` · `OIMContentChangeListenerService`
 
 *Content services* — `OIMSlotContentEntityService` · `TOIMSlotContentEntityServiceOptions` ·
-`createOIMSlotContentEntityService` · `TOIMSlotContentEntityServiceFactoryOptions` · `TOIMEntitySlotOwnerService` · `createOIMEntityService` and
-`createOIMSingleEntityService` (convenience wrappers) · `OIMSlotContentBucketService` ·
-`OIMSlotContentBucketServiceArrayBased` · `OIMSlotContentBucketServiceArrayDriven` · `OIMSlotContentBucketServiceSetDriven` ·
-`OIMSlotContentBucketServiceSortedArrayDriven` · `TOIMSlotContentBucketServiceOptions` ·
-`TOIMSlotContentBucketServiceSortedArrayDrivenOptions` · `TOIMBucketSlotOwnerService` · `createOIMBucketService` and
-`createOIMSingleBucketService` (convenience wrappers)
+`createOIMSlotContentEntityService` · `TOIMEntitySlotOwnerService` · `TOIMEntityContentSlot` · `OIMSlotContentBucketService` ·
+`OIMSlotContentArrayBucketService` · `OIMSlotContentPositionalArrayBucketService` · `OIMSlotContentSetBucketService` ·
+`OIMSlotContentSortedArrayBucketService` · `TOIMSlotContentBucketServiceOptions` ·
+`TOIMSlotContentArrayBucketServiceOptions` · `TOIMSlotContentSortedArrayBucketServiceOptions` · `TOIMBucketSlotOwnerService` ·
+`TOIMBucketContentSlot` · `OIMSlotContentComputedService` (**type only**) · `TOIMSlotContentComputedServiceOptions` ·
+`TOIMComputedContentSlot`
 
-*Index and computed store slots* — `createOIMIndexService` · `TOIMIndexServiceFactoryOptions` ·
-`createOIMIndexServiceByCompositeKey` (convenience wrapper) ·
-`TOIMIndexServiceStoreSlot` · `TOIMSortedComputedSlot` · `TOIMBucketMemoComputedSlot`
+*Index and computed store slots* — `createOIMSlotCollectionIndexService` · `TOIMSlotCollectionIndexServiceFactoryOptions` ·
+`TOIMSlotCollectionIndexServiceStoreSlot` · `TOIMSortedComputedSlot` · `TOIMBucketMemoComputedSlot`
 
 *Runtime* — `TOIMChannelFrame` · `TOIMChannelClock` ·
-`TOIMChannelScheduler` · `TOIMDisposer` · `IOIMErrorPolicy` · `OIMErrorPolicyLogAndContinue` ·
-`TOIMErrorPolicyLogAndContinueOptions` · `OIMErrorPolicyThrowAtOnce` · `OIMChannelQueue` (**type only**) ·
+`TOIMChannelScheduler` · `TOIMDisposer` · `IOIMErrorPolicy` · `OIMLogAndContinueErrorPolicy` ·
+`TOIMLogAndContinueErrorPolicyOptions` · `OIMThrowAtOnceErrorPolicy` · `OIMChannelQueue` (**type only**) ·
 `oimIsAnySlotChangedAfter`
 
 `oimIsAnySlotChangedAfter(slots, revision, epoch): boolean` answers whether any of the slots was
@@ -3227,49 +3116,49 @@ written after that clock reading — `channelSlot.clock` read earlier.
 read outside an effect (`useOIMValue` in `@oimdb/react`, `exoBinding` in `@oimdb/exodra`) calls it
 on its `sourceComputeds` before `derive`, so the derive never reads a stale computed.
 
-*Slots and their owners* — `TOIMSlot` · `TOIMStoreSlot` · `TOIMSingleSlotStoreSlot` ·`IOIMStoreSlotListener` · `OIMStoreSlotListenerNone` ·`oimIsSlotEmpty` · `oimIsSlotReleased` · `TOIMSlotEditable` · `TOIMKeyedSlot` · `TOIMIndexableSlot` ·
-`TOIMEntitySlot` · `TOIMColumnSlot` · `TOIMComputedColumnSlot` · `TOIMColumnGroup` · `TOIMColumnReaders` · `OIMColumnOwner` ·
-`OIMColumnOwnerPushDriven` · `OIMColumnOwnerPullDriven` · `TOIMColumnOwnerOptions` · `TOIMBucketSlot` ·
+*Slots and their owners* — `TOIMSlot` · `TOIMStoreSlot` · `TOIMSingleSlotStoreSlot` ·`IOIMStoreSlotListener` · `OIMNoStoreSlotListener` · `IOIMSlotSubscriptionListener` · `OIMNoSlotSubscriptionListener` ·`oimIsSlotEmpty` · `oimIsSlotReleased` · `TOIMSlotEditable` · `TOIMKeyedSlot` · `TOIMIndexableSlot` ·
+`TOIMEntitySlot` · `TOIMColumnSlot` · `TOIMComputedColumnSlot` · `TOIMColumnGroup` · `TOIMColumnReaders` · `OIMColumnSlotOwner` ·
+`OIMPushColumnSlotOwner` · `OIMPullColumnSlotOwner` · `TOIMColumnSlotOwnerOptions` · `TOIMBucketSlot` ·
 `TOIMSameValueGuard` · `OIMSlotOwner` ·
-`IOIMSlotOwner` · `IOIMSlotEmptiness` ·
+`IOIMSlotOwner` · `IOIMSlotEmptinessPolicy` ·
 `IOIMSlotStamp` · `oimHoldSlots` · `oimUnholdSlotsIfAlive` · `IOIMContentChangeListener`
 
 `oimIsSlotEmpty(slot): boolean` reads the EMPTY bit of `slot.slotFlags`.
 `oimIsSlotReleased(slot): boolean` reads its RELEASED bit.
 
 *Release policies* — `IOIMSlotReleasePolicy` ·
-`OIMSlotReleasePolicyAfterWrite` · `TOIMSlotReleasePolicyAfterWriteOptions` ·
-`OIMSlotReleasePolicyAfterIdle` · `TOIMSlotReleasePolicyAfterIdleOptions` ·
-`OIMSlotReleasePolicyAfterUnhold` · `TOIMSlotReleasePolicyAfterUnholdOptions` ·
-`OIMSlotReleasePolicyAtUnhold` · `OIMSlotReleasePolicyAtEmpty` · `OIMSlotReleasePolicyNever` · `OIMSlotReleasePolicyEarliest` ·
+`OIMSlotAfterWriteReleasePolicy` · `TOIMSlotAfterWriteReleasePolicyOptions` ·
+`IOIMSlotReleaseDueFramePolicy` · `OIMSlotReleaseAutoDueFramePolicy` · `OIMSlotReleaseManualDueFramePolicy` ·
+`OIMSlotAfterIdleReleasePolicy` · `TOIMSlotAfterIdleReleasePolicyOptions` ·
+`OIMSlotAfterUnholdReleasePolicy` · `TOIMSlotAfterUnholdReleasePolicyOptions` ·
+`OIMSlotAtUnholdReleasePolicy` · `OIMSlotAtEmptyReleasePolicy` · `OIMSlotNeverReleasePolicy` · `OIMSlotEarliestReleasePolicy` ·
 `TOIMTimer` · `oimSliceOfMs` · `OIM_SLICE_LENGTH_MS`
 
 *Entity writers* — `IOIMEntityWriter` · `createOIMEntityWriterInPlace` ·
-`createOIMEntityWriterReplacing` · `TOIMEntityWriterOptions` · `TOIMEntityInsertStrategy` ·
+`createOIMEntityWriterReplacing` · `TOIMEntityWriterOptions` · `TOIMEntityInserter` ·
 `oimInsertEntityWithCopy` · `oimInsertEntityWithoutCopy` · `oimInsertEntityWithSanitizedCopy` · `oimPatchEntityColumns` · `oimPatchEntityColumn` · `oimPatchEntityColumnsGuarded` · `oimPatchEntityColumnGuarded` · `oimPutEntityColumns` · `oimPutEntityColumnsGuarded` · `TOIMEntityColumnName` · `TOIMEntityColumnValue`
 
-*Buckets* — `TOIMBucketCollectionFactoryArguments` ·
-`OIMBucketCommands` · `TOIMBucketCommandsOptions` · `IOIMBucketCommands` ·
-`IOIMBucketArrayMembership` · `OIMBucketArrayMembershipNonUnique` ·
-`OIMBucketArrayMembershipUnique` · `TOIMBucketSlotsSetStore` · `TOIMBucketSlotsArrayStore` ·
-`TOIMBucketSlotsSortedArrayStore` · `TOIMBucketSlotsArrayUniqueStore` · `OIM_NOTHING_WAS_INSERTED` ·
+*Buckets* — `OIMBucketCommands` · `TOIMBucketCommandsOptions` · `IOIMBucketCommands` ·
+`IOIMBucketMemberSlotsArrayService` · `OIMBucketMemberSlotsArrayService` · `OIMBucketUniqueMemberSlotsArrayService` ·
+`TOIMBucketSlotsSetStore` · `TOIMBucketSlotsArrayStore` · `OIM_NOTHING_WAS_INSERTED` ·
 `OIM_NOTHING_WAS_REMOVED` · `OIM_FROZEN_EMPTY_SLOTS` · `OIM_REMOVED_WITHOUT_A_POSITION`
 
-*Index services* — `OIMIndexService` · `OIMIndexServiceSortedArrayDriven` · `TOIMIndexServiceOptions` · `TOIMIndexStoreSlot` ·
-`createOIMIndexServiceSortedArrayDriven` · `TOIMIndexKeyOptions` · `TOIMIndexKey` ·
+*Index services* — `OIMSlotCollectionIndexService` · `OIMSlotCollectionSortedArrayIndexService` · `TOIMSlotCollectionIndexServiceOptions` · `TOIMIndexStoreSlot` ·
+`createOIMSlotCollectionSortedArrayIndexService` · `TOIMIndexKeyOptions` · `TOIMIndexKey` ·
 `IOIMIndexKeysService` · `TOIMIndexKeysPositions` · `OIMIndexKeysService` ·
-`OIMIndexKeysServiceAppending` · `OIMIndexKeysServiceReclaiming`
+`OIMAppendingIndexKeysService` · `OIMReclaimingIndexKeysService`
 
 *Computed services* — `OIMComputedService` · `TOIMComputedServiceOptions` ·
-`createOIMComputedService` · `TOIMComputedStoreSlot` · `OIMComputedServiceSorted` · `TOIMComputedServiceSortedOptions` ·
-`createOIMComputedServiceSorted` · `OIMComputedServiceBucketMemo` · `TOIMComputedServiceBucketMemoOptions` ·
-`createOIMComputedServiceBucketMemo` · `TOIMSortColumn` · `TOIMSortableColumnName` · `oimColumnsComparator`
+`createOIMComputedService` · `TOIMComputedStoreSlot` · `OIMSortedComputedService` · `TOIMSortedComputedServiceOptions` ·
+`createOIMSortedComputedService` · `OIMBucketMemoComputedService` · `TOIMBucketMemoComputedServiceOptions` ·
+`createOIMBucketMemoComputedService` · `OIMSingleComputedService` · `createOIMSingleComputedService` ·
+`TOIMComputedDerivationOptions` · `TOIMSortColumn` · `TOIMSortableColumnName` · `oimColumnsComparator`
 
 *Stores and keys* — `TOIMStoreKey` · `IOIMSlotStoreService` ·
-`OIMSlotStoreServiceMapDriven` · `OIMSlotStoreServiceTreeDriven` ·
-`OIMSlotStoreServiceSingleSlotDriven` · `TOIMSingleSlotStore` · `TOIMDefaultSlotStore` ·
+`OIMSlotMapStoreService` · `OIMSlotTreeStoreService` ·
+`OIMSingleSlotStoreService` · `TOIMSingleSlotStore` · `TOIMDefaultSlotStore` ·
 `TOIMSlotStoreTree` · `IOIMKeyTreeWalk` · `TOIMCompositeKeyNode` ·
-`OIMKeyTreeWalk` · `OIMKeyTreeWalkComposite` · `OIMKeyTreeWalkScalar`
+`OIMKeyTreeWalk` · `OIMCompositeKeyTreeWalk` · `OIMScalarKeyTreeWalk`
 
 *Assemblies* — `OIMDB` · `OIMDefaults` · `OIMDefaultValue` · `TOIMFactoryOptions`
 
@@ -3287,10 +3176,10 @@ on its `sourceComputeds` before `derive`, so the derive never reads a stale comp
 
 ### A scalar in a `KEY_TREE_WALK_COMPOSITE` key throws
 
-`OIMSlotStoreServiceTreeDriven` built with `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` keys on
+`OIMSlotTreeStoreService` built with `OIMDefaults.KEY_TREE_WALK_COMPOSITE.getValue()` keys on
 `readonly TOIMEntitySlot[]`, so a string or a number in the key throws
 a TypeError past a cast, setting `holdCount` on a string. The store for a tuple
-of scalars is `OIMSlotStoreServiceTreeDriven` built with
+of scalars is `OIMSlotTreeStoreService` built with
 `OIMDefaults.KEY_TREE_WALK_SCALAR.getValue()` —
 see **Key stores** above. The fix is the other walk, never a cast.
 
@@ -3357,14 +3246,14 @@ The computed SERVICE is the caller's, built once at module scope with `createOIM
 slot per mount — `computedService.createComputedStoreSlot(db, derive, createSources)` in a `useMemo` on `deps`;
 `derive` / `createSources` may be `undefined` when the service has them.
 `useOIMSingleComputedValue(computedService, derive, createSources, deps): TValue` is the same for a void-keyed
-service whose `computedSlotStoreService` is `OIMSlotStoreServiceSingleSlotDriven.INSTANCE`, read through
+service whose `computedSlotStoreService` is `OIMSingleSlotStoreService.INSTANCE`, read through
 `useOIMComputedValueByKey(computedService.computedCollectionService, computedStoreSlot, undefined)`, so a flush
 between render and subscribe is safe.
 `useOIMSlotsByKeys(slotCollectionService, storeSlot, keys)` holds the identities its keys name for as long as the
 component is mounted (a `holdSlotByKey` per key on commit, the same holds given back on unmount or when the list
 moves) and subscribes to nothing; it needs no provider.
-Singles are not keyed collections: `createOIMSingleEntityService(db)` / `createOIMSingleBucketService(db)` return an
-`OIMSingleSlotService` (`getSingleSlot(storeSlot)`, `holdSingleSlot(storeSlot)`), read by
+Singles are not keyed collections: `createOIMSingleSlotService(db, { slotContentService })` returns an
+`OIMWritableSingleSlotService` (`getSingleSlot(storeSlot)`, `holdSingleSlot(storeSlot)`), read by
 `useOIMSingleEntity(singleSlotService, singleSlotStoreSlot): TEntity | undefined` and
 `useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot): readonly TOIMEntitySlot<TEntity>[]` — the by-key
 mechanics without a key (getSingleSlot on render, holdSingleSlot on commit, resolve-hold given back once the
@@ -3375,8 +3264,8 @@ re-read the imports rather than trusting this table.
 
 | Package | Imports from the core | Imports a name the core does not export? |
 |---|---|---|
-| `@oimdb/persist` | `IOIMChannelMap`, `IOIMContentChangeListener`, `IOIMEntityWriter`, `OIMChannelService`, `OIMColumnOwnerPushDriven`, `OIMContentChangeListenerService`, `OIMEffectService`, `OIMSingleSlotService`, `OIMSlotCollectionService`, `OIMSlotContentBucketService`, `OIMSlotContentEntityService`, `TOIMBucketSlot`, `TOIMChannelClock`, `TOIMChannelSlot`, `TOIMColumnSlot`, `TOIMDefaultSlotStore`, `TOIMDisposer`, `TOIMEffect`, `TOIMEntitySlot`, `TOIMSingleSlotStore`, `TOIMSingleSlotStoreSlot`, `TOIMSlot`, `TOIMStoreKey`, `TOIMStoreSlot`, `oimHoldSlots`, `oimIsAnySlotChangedAfter`, `oimIsSlotReleased`, `oimSameValueZeroGuard`, `oimUnholdSlotsIfAlive` | no |
-| `@oimdb/redux-adapter` | `IOIMChannelMap`, `IOIMContentChangeListener`, `OIMChannelService`, `OIMColumnOwnerPushDriven`, `OIMContentChangeListenerService`, `OIMEffectService`, `OIMSlotCollectionService`, `OIMSlotContentBucketService`, `OIMSlotContentEntityService`, `TOIMBucketSlot`, `TOIMColumnSlot`, `TOIMDefaultSlotStore`, `TOIMDisposer`, `TOIMEffect`, `TOIMEntityColumnName`, `TOIMEntitySlot`, `TOIMStoreKey`, `TOIMStoreSlot` | no |
+| `@oimdb/persist` | `IOIMChannelMap`, `IOIMContentChangeListener`, `IOIMEntityWriter`, `OIMChannelService`, `OIMPushColumnSlotOwner`, `OIMContentChangeListenerService`, `OIMEffectService`, `OIMSingleSlotService`, `OIMSlotCollectionService`, `OIMSlotContentBucketService`, `OIMSlotContentEntityService`, `TOIMBucketSlot`, `TOIMChannelClock`, `TOIMChannelSlot`, `TOIMColumnSlot`, `TOIMDefaultSlotStore`, `TOIMDisposer`, `TOIMEffect`, `TOIMEntitySlot`, `TOIMSingleSlotStore`, `TOIMSingleSlotStoreSlot`, `TOIMSlot`, `TOIMStoreKey`, `TOIMStoreSlot`, `oimHoldSlots`, `oimIsAnySlotChangedAfter`, `oimIsSlotReleased`, `oimSameValueZeroGuard`, `oimUnholdSlotsIfAlive` | no |
+| `@oimdb/redux-adapter` | `IOIMChannelMap`, `IOIMContentChangeListener`, `OIMChannelService`, `OIMPushColumnSlotOwner`, `OIMContentChangeListenerService`, `OIMEffectService`, `OIMSlotCollectionService`, `OIMSlotContentBucketService`, `OIMSlotContentEntityService`, `TOIMBucketSlot`, `TOIMColumnSlot`, `TOIMDefaultSlotStore`, `TOIMDisposer`, `TOIMEffect`, `TOIMEntityColumnName`, `TOIMEntitySlot`, `TOIMStoreKey`, `TOIMStoreSlot` | no |
 | `@oimdb/exodra` | `IOIMChannelMap`, `OIMChannelService`, `OIMEffectService`, `OIMSlotContentBucketService`, `OIM_FROZEN_EMPTY_SLOTS`, `TOIMBucketSlot`, `TOIMComputedSlot`, `TOIMDisposer`, `TOIMEffect`, `TOIMEntitySlot`, `TOIMOrderedListCommand`, `TOIMSlot`, `TOIMStoreKey`, `oimOrderedListCommandsOfTransition`, `oimRefreshSourceComputeds`, `oimSameKeySequence` | no |
 | `@oimdb/react` | `IOIMChannelMap`, `OIMComputedService`, `OIMDB`, `OIMEffectService`, `OIMSingleSlotService`, `OIMSlotCollectionService`, `OIMSlotContentBucketService`, `OIM_FROZEN_EMPTY_SLOTS`, `TOIMBucketSlot`, `TOIMColumnSlot`, `TOIMComputedSlot`, `TOIMComputedSources`, `TOIMComputedStoreSlot`, `TOIMDisposer`, `TOIMEntityColumnName`, `TOIMEntityColumnValue`, `TOIMEntitySlot`, `TOIMIndexableSlot`, `TOIMKeyedSlot`, `TOIMSingleSlotStore`, `TOIMSlot`, `TOIMStoreKey`, `TOIMStoreSlot`, `oimHoldSlots`, `oimRefreshSourceComputeds`, `oimSameKeySequence`, `oimUnholdSlotsIfAlive` | no |
 | `@oimdb/devtools` | `IOIMChannelMap`, `IOIMStoreSlotListener`, `OIMChannelService`, `OIMComputedService`, `OIMDefaults`, `OIMSlotCollectionService`, `TOIMBucketSlot`, `TOIMComputedStoreSlot`, `TOIMDefaultSlotStore`, `TOIMDisposer`, `TOIMEntitySlot`, `TOIMKeyedSlot`, `TOIMStoreKey`, `TOIMStoreSlot` | no |
@@ -3397,10 +3286,10 @@ Every constructor in the family takes ONE options object.
 | package | exports |
 |---|---|
 | `@oimdb/persist` | the engine, plus the key-value backend `OIMPersistKeyValueBackend` and its strategies; error types `TOIMPersistErrorHandler`, `TOIMPersistErrorContext`, `TOIMPersistOperation` and `TOIMPersistErrorReport` (`{ error, persistErrorContext }`, one failure as `onPersistError` receives it or as it lands in the `AggregateError`) |
-| `@oimdb/persist-memory` | `OIMPersistMemoryBackend`, `OIMPersistMemoryWriteBatch`, `OIMPersistMemoryRecordsStrategy`, `OIMPersistMemorySnapshotStrategy`, `TOIMPersistMemoryStrategyOptions` |
-| `@oimdb/persist-json` | `OIMPersistJsonBackend`, `TOIMPersistJsonBackendOptions`, `TOIMPersistJsonDump`; depends on `@oimdb/persist-memory` |
-| `@oimdb/persist-idb` | `OIMPersistIndexedDbBackend`, `OIMPersistIndexedDbWriteBatch`, `OIMPersistIndexedDbRecordsStrategy`, `OIMPersistIndexedDbSnapshotStrategy`, `TOIMPersistIndexedDbBackendOptions`, `TOIMPersistIndexedDbRecordsStrategyOptions`, `TOIMPersistIndexedDbSnapshotStrategyOptions`, `TOIMPersistIndexedDbPrimaryKey`, `TOIMPersistIndexedDbTableRecord` |
-| `@oimdb/persist-localstorage` | `OIMPersistLocalStorageBackend`, `TOIMPersistLocalStorageBackendOptions` |
+| `@oimdb/persist-memory` | `OIMPersistMemoryBackend`, `OIMPersistMemoryWriteBatch`, `OIMPersistMemoryRecordsService`, `OIMPersistMemorySnapshotService`, `TOIMPersistMemoryServiceOptions` |
+| `@oimdb/persist-json` | `OIMPersistJsonMemoryBackend`, `TOIMPersistJsonMemoryBackendOptions`, `TOIMPersistJsonDump`; depends on `@oimdb/persist-memory` |
+| `@oimdb/persist-idb` | `OIMPersistIndexedDbBackend`, `OIMPersistIndexedDbWriteBatch`, `OIMPersistIndexedDbRecordsService`, `OIMPersistIndexedDbSnapshotService`, `TOIMPersistIndexedDbBackendOptions`, `TOIMPersistIndexedDbRecordsServiceOptions`, `TOIMPersistIndexedDbSnapshotServiceOptions`, `TOIMPersistIndexedDbPrimaryKey`, `TOIMPersistIndexedDbTableRecord` |
+| `@oimdb/persist-localstorage` | `OIMPersistLocalStorageKeyValueBackend`, `TOIMPersistLocalStorageKeyValueBackendOptions` |
 | `@oimdb/persist-async-kv` | `OIMPersistAsyncKVStorage`, `TOIMPersistAsyncKVStorageOptions`, `TOIMPersistAsyncKVMultiStorage` |
 
 ### The wiring
@@ -3411,42 +3300,37 @@ lives in the backend) and what to do on hydrate.
 
 ```ts
 import {
-    OIMPersistEntityWriter, OIMPersistRecordSourceCollectionWriteDriven, OIMPersistResourceRecords,
-    OIMPersistSchedulerMicrotaskDriven, OIMPersistor,
+    OIMPersistEntityWriter, OIMPersistCollectionWriteRecordSource, OIMPersistRecordsResource,
+    OIMPersistMicrotaskScheduler, OIMPersistor,
 } from '@oimdb/persist';
-import { OIMPersistMemoryBackend, OIMPersistMemoryRecordsStrategy, OIMPersistMemoryWriteBatch } from '@oimdb/persist-memory';
+import { OIMPersistMemoryBackend, OIMPersistMemoryRecordsService, OIMPersistMemoryWriteBatch } from '@oimdb/persist-memory';
 
 const persistEntityWriter = new OIMPersistEntityWriter<Card, TOIMStoreKey>({
     entityWriter: createOIMEntityWriterInPlace(),
 });
-const persistedCardCollectionService = createOIMEntityService<Card>(db, {
-    keyOf: card => card.id,
-    entityWriter: persistEntityWriter,
-});
+const persistedCardCollectionService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db, { entityWriter: persistEntityWriter }) });
 const persistedCardEntityStoreSlot = persistedCardCollectionService.createStoreSlot(db);
 
 const persistMemoryBackend = new OIMPersistMemoryBackend();
 const persistor = new OIMPersistor<OIMPersistMemoryBackend, OIMPersistMemoryWriteBatch>({
     persistBackend: persistMemoryBackend,
-    persistScheduler: new OIMPersistSchedulerMicrotaskDriven(),
+    persistScheduler: new OIMPersistMicrotaskScheduler(),
     onPersistError: (error, persistErrorContext) => {
         console.error(persistErrorContext.persistOperation, error);
     },
 });
-const cardPersistResourceRecords = persistor.addPersistResource(new OIMPersistResourceRecords({
-    persistRecordSource: new OIMPersistRecordSourceCollectionWriteDriven({
+const cardPersistResourceRecords = persistor.addPersistResource(new OIMPersistRecordsResource({
+    persistRecordSource: new OIMPersistCollectionWriteRecordSource({
         entityCollectionService: persistedCardCollectionService,
         entityStoreSlot: persistedCardEntityStoreSlot,
         persistEntityWriter,
     }),
-    persistRecordsStrategy: new OIMPersistMemoryRecordsStrategy<TOIMStoreKey, Card>({ storageKey: 'cards' }),
+    persistRecordsService: new OIMPersistMemoryRecordsService<TOIMStoreKey, Card>({ storageKey: 'cards' }),
 }));
 
 await persistor.hydrate();
 persistor.start();
-persistedCardCollectionService.slotContentService.upsertEntity(
-    persistedCardEntityStoreSlot, { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' },
-);
+persistedCardCollectionService.writeSlotContentByKey(persistedCardEntityStoreSlot, 'c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' });
 await persistor.persist();
 await persistor.unload(cardPersistResourceRecords, ['c1']);
 await persistor.load(cardPersistResourceRecords, ['c1']);
@@ -3456,8 +3340,8 @@ Rules a generator must keep:
 
 - Pass both generics of `OIMPersistor<TPersistBackend, TWriteBatch>`: the backend
   class and its write batch class (`OIMPersistMemoryWriteBatch`, `OIMPersistIndexedDbWriteBatch`,
-  `OIMPersistKeyValueWriteBatch`; `OIMPersistJsonBackend` uses `OIMPersistMemoryWriteBatch`,
-  `OIMPersistLocalStorageBackend` uses `OIMPersistKeyValueWriteBatch`).
+  `OIMPersistKeyValueWriteBatch`; `OIMPersistJsonMemoryBackend` uses `OIMPersistMemoryWriteBatch`,
+  `OIMPersistLocalStorageKeyValueBackend` uses `OIMPersistKeyValueWriteBatch`).
 - Pass the generics of strategies, codecs and `OIMPersistEntityWriter<TEntity, TKey>`
   explicitly; their options carry no type to infer them from.
 - An entity collection persisted through a collection source is built with the
@@ -3469,9 +3353,9 @@ Rules a generator must keep:
   `new OIMPersistEntityWriter({ entityWriter })` wraps the `IOIMEntityWriter` that
   really writes, and reports the entity slot of every fill, put, patch, column patch,
   column delete and clear that changed something (`subscribeEntitySlotWritten`).
-- The entity collection service a source takes is any collection service with `getSlots`, `findSlotByKey` and a
-  `slotContentService` with `upsertEntities`, `deleteEntity` and `deleteEntities`
-  (`TOIMPersistEntityCollectionService`), so `createOIMEntityService(db, …)` and the base-layer assembly both fit.
+- The entity collection service a source takes is any collection service with `getSlots`, `findSlotByKey`,
+  `writeSlotContentByKey`, `writeInBatch` and a `slotContentService` with `clearSlotContent`
+  (`TOIMPersistEntityCollectionService`): what `createOIMSlotCollectionService` over an entity content service builds.
 - A source refuses, by name, a store slot on another channel slot than the one it was given (the bucket source
   checks both the entity and the bucket store slot).
 - Order: `addPersistResource` every resource, `await persistor.hydrate()`, then
@@ -3482,29 +3366,29 @@ Rules a generator must keep:
 | constructor | options |
 |---|---|
 | `OIMPersistor` | `{ persistBackend, persistScheduler, onPersistError? }` |
-| `OIMPersistResourceRecords` | `{ persistRecordSource, persistRecordsStrategy, persistHydrateReconcile? }` |
-| `OIMPersistResourceSnapshot` | `{ persistSnapshotSource, persistSnapshotStrategy, persistCodec, persistHydrateReconcile? }` |
-| `OIMPersistRecordSourceCollectionWriteDriven`, `OIMPersistRecordSourceCollectionChangeDriven` | `{ entityCollectionService, entityStoreSlot, persistEntityWriter }` (`TOIMPersistRecordSourceCollectionOptions`) |
-| `OIMPersistRecordSourceBucketDriven` | `{ channelMap, entityCollectionService, entityStoreSlot, slotContentBucketService, bucketSlot }` — `channelMap` is the db, `slotContentBucketService` the bucket collection's `slotContentService` |
-| `OIMPersistSnapshotSourceSingleEntityDriven` | `{ channelMap, singleSlotService, entityStoreSlot }` — a single entity service (`createOIMSingleEntityService`) and one of its store slots (`TOIMSingleSlotStoreSlot`) |
+| `OIMPersistRecordsResource` | `{ persistRecordSource, persistRecordsService, persistHydrateReconcile? }` |
+| `OIMPersistSnapshotResource` | `{ persistSnapshotSource, persistSnapshotService, persistCodec, persistHydrateReconcile? }` |
+| `OIMPersistCollectionWriteRecordSource`, `OIMPersistCollectionChangeWriteRecordSource` | `{ entityCollectionService, entityStoreSlot, persistEntityWriter }` (`TOIMPersistRecordSourceCollectionOptions`) |
+| `OIMPersistBucketRecordSource` | `{ channelMap, entityCollectionService, entityStoreSlot, slotContentBucketService, bucketSlot }` — `channelMap` is the db, `slotContentBucketService` the bucket collection's `slotContentService` |
+| `OIMPersistSingleEntitySnapshotSource` | `{ channelMap, singleSlotService, entityStoreSlot }` — a single entity service (`createOIMSingleSlotService` over an entity content service) and one of its store slots (`TOIMSingleSlotStoreSlot`) |
 | `OIMPersistEntityWriter` | `{ entityWriter }` |
-| `OIMPersistSchedulerMicrotaskDriven` | none |
-| `OIMPersistSchedulerFrameDriven` | `{ channelSlot }` — `db.defaultChannelSlot` |
-| `OIMPersistCodecIdentity` | none |
-| `OIMPersistCodecVersioned` | `{ version, migrations, persistCodec }` |
+| `OIMPersistMicrotaskScheduler` | none |
+| `OIMPersistFrameScheduler` | `{ channelSlot }` — `db.defaultChannelSlot` |
+| `OIMPersistIdentityCodec` | none |
+| `OIMPersistVersionedCodec` | `{ version, migrations, persistCodec }` |
 | `OIMPersistMemoryBackend` | none |
-| `OIMPersistMemoryRecordsStrategy`, `OIMPersistMemorySnapshotStrategy` | `{ storageKey }` |
-| `OIMPersistJsonBackend` | `{ initialPersistJsonDump? }`, the object itself optional |
+| `OIMPersistMemoryRecordsService`, `OIMPersistMemorySnapshotService` | `{ storageKey }` |
+| `OIMPersistJsonMemoryBackend` | `{ initialPersistJsonDump? }`, the object itself optional |
 | `OIMPersistIndexedDbBackend` | `{ databaseName, databaseVersion?, indexedDb? }` |
-| `OIMPersistIndexedDbRecordsStrategy` | `{ tableName }` |
-| `OIMPersistIndexedDbSnapshotStrategy` | `{ tableName, primaryKey }` |
+| `OIMPersistIndexedDbRecordsService` | `{ tableName }` |
+| `OIMPersistIndexedDbSnapshotService` | `{ tableName, primaryKey }` |
 | `OIMPersistKeyValueBackend` | `{ persistKeyValueStorage, persistKeyValueSerializer? }` |
-| `OIMPersistKeyValueStorageItemDriven` | `{ persistKeyValueItemStorage }` |
-| `OIMPersistKeyValueEntryStrategy` | `{ storageKey }` |
-| `OIMPersistKeyValuePathStrategy` | `{ storageKey, path }` |
-| `OIMPersistLocalStorageBackend` | `{ persistKeyValueItemStorage?, persistKeyValueSerializer? }`, the object itself optional |
-| `OIMPersistSourceChangeMarkSlotDriven` | `{ channelClock, slots }` |
-| `OIMPersistSourceChangeMarkSubscriptionDriven` | `{ subscribeSourceChanged }` |
+| `OIMPersistItemKeyValueStorage` | `{ persistKeyValueItemStorage }` |
+| `OIMPersistKeyValueEntrySnapshotService` | `{ storageKey }` |
+| `OIMPersistKeyValuePathSnapshotService` | `{ storageKey, path }` |
+| `OIMPersistLocalStorageKeyValueBackend` | `{ persistKeyValueItemStorage?, persistKeyValueSerializer? }`, the object itself optional |
+| `OIMPersistSlotSourceChangeMark` | `{ channelClock, slots }` |
+| `OIMPersistSubscriptionSourceChangeMark` | `{ subscribeSourceChanged }` |
 | `OIMPersistAsyncKVStorage` | `{ persistAsyncKVMultiStorage }` |
 
 `onPersistError(error, persistErrorContext)` receives a `TOIMPersistErrorContext`,
@@ -3515,10 +3399,10 @@ or collected into the `AggregateError`.
 
 ### Two resource kinds, and when to pick each
 
-| | `OIMPersistResourceRecords` | `OIMPersistResourceSnapshot` |
+| | `OIMPersistRecordsResource` | `OIMPersistSnapshotResource` |
 |---|---|---|
 | source | a record source: entity store slot or bucket | any snapshot source: entity store slot, bucket or single entity |
-| strategy | `OIMPersistMemoryRecordsStrategy`, `OIMPersistIndexedDbRecordsStrategy` | `OIMPersistMemorySnapshotStrategy`, `OIMPersistIndexedDbSnapshotStrategy`, `OIMPersistKeyValueEntryStrategy`, `OIMPersistKeyValuePathStrategy` |
+| strategy | `OIMPersistMemoryRecordsService`, `OIMPersistIndexedDbRecordsService` | `OIMPersistMemorySnapshotService`, `OIMPersistIndexedDbSnapshotService`, `OIMPersistKeyValueEntrySnapshotService`, `OIMPersistKeyValuePathSnapshotService` |
 | autosave writes | the delta: one upsert or one deletion per entity slot written since the last drain | the whole snapshot, read from the source and encoded |
 | `persist()` writes | every record, replacing what is stored; while any key is unloaded, every in-memory record as an upsert over what is stored, plus the deletions the resource already heard | the whole snapshot |
 | codec | none | `persistCodec`, required |
@@ -3544,10 +3428,10 @@ slot wins: an upsert, not a deletion.
 
 | source | reports | scheduler |
 |---|---|---|
-| `OIMPersistRecordSourceCollectionWriteDriven` | synchronously, at the write, from `OIMPersistEntityWriter` only | `OIMPersistSchedulerMicrotaskDriven` |
-| `OIMPersistRecordSourceCollectionChangeDriven` | synchronously, at the write, from `OIMPersistEntityWriter` and from a content-change listener on the entity store slot | `OIMPersistSchedulerMicrotaskDriven` |
-| `OIMPersistRecordSourceBucketDriven` | from effects (`OIMEffectService`), when the channel runs its frame | `OIMPersistSchedulerFrameDriven({ channelSlot })` |
-| `OIMPersistSnapshotSourceSingleEntityDriven` | from an effect, when the channel runs its frame | `OIMPersistSchedulerFrameDriven({ channelSlot })` |
+| `OIMPersistCollectionWriteRecordSource` | synchronously, at the write, from `OIMPersistEntityWriter` only | `OIMPersistMicrotaskScheduler` |
+| `OIMPersistCollectionChangeWriteRecordSource` | synchronously, at the write, from `OIMPersistEntityWriter` and from a content-change listener on the entity store slot | `OIMPersistMicrotaskScheduler` |
+| `OIMPersistBucketRecordSource` | from effects (`OIMEffectService`), when the channel runs its frame | `OIMPersistFrameScheduler({ channelSlot })` |
+| `OIMPersistSingleEntitySnapshotSource` | from an effect, when the channel runs its frame | `OIMPersistFrameScheduler({ channelSlot })` |
 
 - **Collection** (an entity collection service and one of its store slots): every entity slot of that store slot that holds an entity. Starting
   reports nothing; content present before `start()` is written by `persist()` or by
@@ -3558,8 +3442,8 @@ slot wins: an upsert, not a deletion.
 
   | collection source | in-place edit announced with `slotContentService.markEntityChanged(entitySlot, changedColumns?)` | cost while a resource listens | pick it when |
   |---|---|---|---|
-  | `OIMPersistRecordSourceCollectionWriteDriven` | NOT persisted: it hears only the writer | none: every write stays on the core fast path | every change goes through the upsert / update / delete doors |
-  | `OIMPersistRecordSourceCollectionChangeDriven` | persisted: while subscribed it adds a content-change listener of every column to the store slot | EVERY write to that store slot leaves the core fast path, not only `markEntityChanged`: one subframe open/close, changed-column bookkeeping and the listener loop per write | the app edits entities in place |
+  | `OIMPersistCollectionWriteRecordSource` | NOT persisted: it hears only the writer | none: every write stays on the core fast path | every change goes through `writeSlotContentByKey`, `writeSlotContent`, `updateEntity` and `clearSlotContent` |
+  | `OIMPersistCollectionChangeWriteRecordSource` | persisted: while subscribed it adds a content-change listener of every column to the store slot | EVERY write to that store slot leaves the core fast path, not only `markEntityChanged`: changed-column bookkeeping and the listener loop per write | the app edits entities in place |
 - **Bucket**: the entities one bucket slot holds. Get the slot with
   `bucketCollectionService.holdSlotByKey(bucketStoreSlot, key)`. The source watches the
   bucket slot with one effect and each member entity slot with one effect. An entity
@@ -3569,7 +3453,7 @@ slot wins: an upsert, not a deletion.
   hydrate restored.
 - **Single entity**: the snapshot is the entity itself (a store slot of a single entity service, read through
   `findSingleSlot(entityStoreSlot)`), so it
-  goes only into `OIMPersistResourceSnapshot`. Its first subscription reports the
+  goes only into `OIMPersistSnapshotResource`. Its first subscription reports the
   current value unless it is the value a hydrate restored. `readSnapshot` throws when
   the entity slot holds no value.
 
@@ -3582,38 +3466,36 @@ frame, are both written.
 
 ```ts
 import {
-    OIMPersistRecordSourceBucketDriven, OIMPersistResourceRecords, OIMPersistSchedulerFrameDriven, OIMPersistor,
+    OIMPersistBucketRecordSource, OIMPersistRecordsResource, OIMPersistFrameScheduler, OIMPersistor,
 } from '@oimdb/persist';
-import { OIMPersistMemoryBackend, OIMPersistMemoryRecordsStrategy, OIMPersistMemoryWriteBatch } from '@oimdb/persist-memory';
+import { OIMPersistMemoryBackend, OIMPersistMemoryRecordsService, OIMPersistMemoryWriteBatch } from '@oimdb/persist-memory';
 
 type TDeckCardSlot = TOIMEntitySlot<Card, TOIMStoreKey>;
-const deckCardCollectionService = createOIMEntityService<Card>(db, { keyOf: card => card.id });
+const deckCardCollectionService = createOIMSlotCollectionService(db, { slotContentService: createOIMSlotContentEntityService<Card>(db) });
 const deckCardEntityStoreSlot = deckCardCollectionService.createStoreSlot(db);
-const deckBucketService = createOIMBucketService<TDeckCardSlot>(db);
+const deckBucketService = createOIMSlotCollectionService(db, { slotContentService: new OIMSlotContentPositionalArrayBucketService<TDeckCardSlot>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const deckBucketStoreSlot = deckBucketService.createStoreSlot(db);
 const spadesBucketSlot = deckBucketService.holdSlotByKey(deckBucketStoreSlot, 'spades');
 
 const deckPersistor = new OIMPersistor<OIMPersistMemoryBackend, OIMPersistMemoryWriteBatch>({
     persistBackend: new OIMPersistMemoryBackend(),
-    persistScheduler: new OIMPersistSchedulerFrameDriven({ channelSlot: db.defaultChannelSlot }),
+    persistScheduler: new OIMPersistFrameScheduler({ channelSlot: db.defaultChannelSlot }),
 });
-deckPersistor.addPersistResource(new OIMPersistResourceRecords({
-    persistRecordSource: new OIMPersistRecordSourceBucketDriven({
+deckPersistor.addPersistResource(new OIMPersistRecordsResource({
+    persistRecordSource: new OIMPersistBucketRecordSource({
         channelMap: db,
         entityCollectionService: deckCardCollectionService,
         entityStoreSlot: deckCardEntityStoreSlot,
         slotContentBucketService: deckBucketService.slotContentService,
         bucketSlot: spadesBucketSlot,
     }),
-    persistRecordsStrategy: new OIMPersistMemoryRecordsStrategy<TOIMStoreKey, Card>({ storageKey: 'spades' }),
+    persistRecordsService: new OIMPersistMemoryRecordsService<TOIMStoreKey, Card>({ storageKey: 'spades' }),
 }));
 await deckPersistor.hydrate();
 deckPersistor.start();
 
-const aceSlot = deckCardCollectionService.slotContentService.upsertEntity(
-    deckCardEntityStoreSlot, { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' },
-);
-deckBucketService.slotContentService.writeBucketMemberSlots(spadesBucketSlot, [aceSlot]);
+const aceSlot = deckCardCollectionService.writeSlotContentByKey(deckCardEntityStoreSlot, 'c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' });
+deckBucketService.slotContentService.writeSlotContent(spadesBucketSlot, [aceSlot]);
 db.flush();
 await deckPersistor.whenIdle();
 ```
@@ -3624,10 +3506,10 @@ await deckPersistor.whenIdle();
 The persistor calls `attachDrain` from its constructor; both shipped schedulers throw
 when a second persistor attaches, so construct one scheduler per persistor.
 
-- `OIMPersistSchedulerMicrotaskDriven`: `requestDrain()` queues one microtask; the
+- `OIMPersistMicrotaskScheduler`: `requestDrain()` queues one microtask; the
   requests that follow before it runs are absorbed by it. `stop()` makes a queued
   microtask do nothing.
-- `OIMPersistSchedulerFrameDriven({ channelSlot })`: while started it subscribes with
+- `OIMPersistFrameScheduler({ channelSlot })`: while started it subscribes with
   `OIMChannelService.INSTANCE.subscribeAfterEachFrame(channelSlot, …)` and drains after a frame only when a drain was
   requested since the last one; `stop()` unsubscribes and forgets the request. It
   holds no slot and never asks the channel for a frame: it drains only after a frame
@@ -3636,11 +3518,11 @@ when a second persistor attaches, so construct one scheduler per persistor.
 **The pairing is a rule.** A write to an entity slot that nobody holds causes no frame
 (`OIMChannelService.INSTANCE.writeWithoutFlushCheck` returns at once when `holdCount` is `0`), so a
 collection source on the frame scheduler can report changes that no frame ever
-drains. Pair `OIMPersistRecordSourceCollectionWriteDriven` and
-`OIMPersistRecordSourceCollectionChangeDriven` with
-`OIMPersistSchedulerMicrotaskDriven`. The bucket and single-entity sources report from
+drains. Pair `OIMPersistCollectionWriteRecordSource` and
+`OIMPersistCollectionChangeWriteRecordSource` with
+`OIMPersistMicrotaskScheduler`. The bucket and single-entity sources report from
 effects, which cause the frames they run in, so pair them with
-`OIMPersistSchedulerFrameDriven`. Resources of both groups in one persistor share its
+`OIMPersistFrameScheduler`. Resources of both groups in one persistor share its
 one scheduler; give them two persistors when they need different schedulers.
 
 `whenIdle()` resolves when the work queued at the moment of the call has settled. On
@@ -3660,8 +3542,8 @@ is queued on the microtask after the write: let one microtask pass before callin
 | `hydrate()` | reads every resource and writes it into its source; ends the upsert-only mode of an unloaded resource |
 | `persist()` | writes every resource in full, started or not, in one write batch; a records resource with unloaded keys writes its in-memory records as upserts over the stored table instead of replacing it, plus the deletions it already heard |
 | `clearPersisted()` | deletes every resource's stored data in one write batch; memory is untouched; ends the upsert-only mode of an unloaded resource |
-| `unload(persistResourceRecords, keys)` | writes the keys' current values plus the resource's pending change in one write batch, repeated until the keys have no unwritten change (unload holds the keys' entity slots while it writes and compares their revision stamps, a slot's stamp moving only on a real write; it also checks the resource's pending set and whether a key's slot was replaced), then removes the keys from memory only |
-| `load(persistResourceRecords, keys)` | the pair of `unload`: queued after the pending writes, reads only those keys from the backend (`readRecordsOfKeys`) and puts the stored entities back without writing them back; skips a key that holds a value in memory or has a change the resource has not written yet; the keys stop counting as unloaded |
+| `unload(persistRecordsResource, keys)` | writes the keys' current values plus the resource's pending change in one write batch, repeated until the keys have no unwritten change (unload holds the keys' entity slots while it writes and compares their revision stamps, a slot's stamp moving only on a real write; it also checks the resource's pending set and whether a key's slot was replaced), then removes the keys from memory only |
+| `load(persistRecordsResource, keys)` | the pair of `unload`: queued after the pending writes, reads only those keys from the backend (`readRecordsOfKeys`) and puts the stored entities back without writing them back; skips a key that holds a value in memory or has a change the resource has not written yet; the keys stop counting as unloaded |
 | `whenIdle()` | resolves when the queued work settles; never rejects |
 
 Every promise-returning call and every autosave runs on one ordered chain, one at a
@@ -3712,7 +3594,7 @@ What the source does with it:
   name; the store slot becomes exactly the stored content;
 - bucket: upserts every record into the entity store slot and sets the bucket's
   members to exactly the restored entities;
-- single entity: `singleSlotService.slotContentService.upsertEntity(entityStoreSlot, entity)`.
+- single entity: `singleSlotService.writeSingleSlotContent(entityStoreSlot, entity)`.
 
 **Refusal.** If the source changes while the backend read is in flight and the
 resource has no `persistHydrateReconcile`, hydrate throws instead of applying, because
@@ -3720,10 +3602,10 @@ applying would revert that change. The source keeps its newer state; the error g
 to `onPersistError` with `'hydrate'`, or into the `AggregateError`. Before the read
 the resource calls `persistSnapshotSource.markSourceChanges()`, which returns an
 `IOIMPersistSourceChangeMark` (`isSourceChangedSinceMark()`, `dispose()`): the
-single-entity and bucket sources return an `OIMPersistSourceChangeMarkSlotDriven`
+single-entity and bucket sources return an `OIMPersistSlotSourceChangeMark`
 that holds the slots and compares their revision stamps (`changedAtRevision`, `changedAtEpoch`) with the
 channel clock reading taken at the mark (`oimIsAnySlotChangedAfter`), the
-collection sources an `OIMPersistSourceChangeMarkSubscriptionDriven` whose flag their
+collection sources an `OIMPersistSubscriptionSourceChangeMark` whose flag their
 own report sets. A change made during the read is seen even when no frame runs, and
 the guard runs whether or not the persistor is started.
 
@@ -3747,7 +3629,7 @@ const answerReconcile = oimReconcileByKey<TOIMStoreKey, Card>(
 
 ### unload, load and clearPersisted
 
-`persistor.unload(persistResourceRecords, keys)` takes an `OIMPersistResourceRecords`
+`persistor.unload(persistRecordsResource, keys)` takes an `OIMPersistRecordsResource`
 only. It first drains the persistor's dirty resources onto the chain, then, in its
 own turn, writes in one write batch that resource's pending change and the current
 value of every unloaded key (`persistRecordSource.readRecordsDelta(persistRecordSource.findEntitySlotsByKeys(keys))`), so
@@ -3775,11 +3657,11 @@ stay on the backend. A deletion it never heard is not written in that mode.
 `hydrate()` and `clearPersisted()` end that mode, and so does a `load` of every
 unloaded key.
 
-`persistor.load(persistResourceRecords, keys)` is the pair of `unload` and takes an
-`OIMPersistResourceRecords` only (a key-value backend has no records strategy, so a
+`persistor.load(persistRecordsResource, keys)` is the pair of `unload` and takes an
+`OIMPersistRecordsResource` only (a key-value backend has no records strategy, so a
 snapshot resource has no `load`). It drains the dirty resources onto the chain and
 runs after those writes. In its turn it reads only those keys through
-`persistRecordsStrategy.readRecordsOfKeys(persistBackend, keys)`: on IndexedDB one
+`persistRecordsService.readRecordsOfKeys(persistBackend, keys)`: on IndexedDB one
 `readonly` transaction with one `get` per key, on memory a lookup of each key in the
 stored map; a key the backend does not hold is left out. It skips every key that holds
 a value in memory or has a change the resource has not written yet (pending or in a
@@ -3819,10 +3701,10 @@ required `persistCodec`, an `IOIMPersistCodec<TSourceSnapshot, TPersistedSnapsho
 (`encode`, `decode`). A records resource has no codec: it stores entities as the
 source holds them.
 
-- `new OIMPersistCodecIdentity<TSnapshot>()`: passes the snapshot through.
-- `new OIMPersistCodecVersioned<TSourceSnapshot, TPersistedSnapshot>({ version, migrations, persistCodec })`:
+- `new OIMPersistIdentityCodec<TSnapshot>()`: passes the snapshot through.
+- `new OIMPersistVersionedCodec<TSourceSnapshot, TPersistedSnapshot>({ version, migrations, persistCodec })`:
   stores a `TOIMPersistVersionedShape`, `{ version, data }`, where `data` is the
-  inner `persistCodec`'s encoding (required; use `OIMPersistCodecIdentity` when
+  inner `persistCodec`'s encoding (required; use `OIMPersistIdentityCodec` when
   nothing transforms). `migrations` is a `Record<number, (data: unknown) => unknown>`
   keyed by the version each migration produces. On decode it runs, ascending, every
   migration whose key is above the stored `version` and at most the current one,
@@ -3832,21 +3714,21 @@ source holds them.
 
 ```ts
 import {
-    OIMPersistCodecIdentity, OIMPersistCodecVersioned, OIMPersistKeyValueBackend, OIMPersistKeyValueEntryStrategy,
-    OIMPersistKeyValueStorageItemDriven, OIMPersistKeyValueWriteBatch, OIMPersistResourceSnapshot,
-    OIMPersistSchedulerFrameDriven, OIMPersistSnapshotSourceSingleEntityDriven, OIMPersistor,
+    OIMPersistIdentityCodec, OIMPersistVersionedCodec, OIMPersistKeyValueBackend, OIMPersistKeyValueEntrySnapshotService,
+    OIMPersistItemKeyValueStorage, OIMPersistKeyValueWriteBatch, OIMPersistSnapshotResource,
+    OIMPersistFrameScheduler, OIMPersistSingleEntitySnapshotSource, OIMPersistor,
 } from '@oimdb/persist';
 import type { TOIMPersistVersionedShape } from '@oimdb/persist';
 
 type TSettings = { theme: 'light' | 'dark'; density: 'compact' | 'comfortable' };
 
-const settingsSingleEntityService = createOIMSingleEntityService<TSettings>(db);
+const settingsSingleEntityService = createOIMSingleSlotService(db, { slotContentService: createOIMSlotContentEntityService<TSettings>(db) });
 const settingsEntityStoreSlot = settingsSingleEntityService.createStoreSlot(db);
-settingsSingleEntityService.slotContentService.upsertEntity(settingsEntityStoreSlot, { theme: 'light', density: 'compact' });
+settingsSingleEntityService.writeSingleSlotContent(settingsEntityStoreSlot, { theme: 'light', density: 'compact' });
 const itemByStorageKey = new Map<string, string>();
 const settingsPersistor = new OIMPersistor<OIMPersistKeyValueBackend, OIMPersistKeyValueWriteBatch>({
     persistBackend: new OIMPersistKeyValueBackend({
-        persistKeyValueStorage: new OIMPersistKeyValueStorageItemDriven({
+        persistKeyValueStorage: new OIMPersistItemKeyValueStorage({
             persistKeyValueItemStorage: {
                 getItem: storageKey => itemByStorageKey.get(storageKey) ?? null,
                 setItem: (storageKey, item) => { itemByStorageKey.set(storageKey, item); },
@@ -3854,17 +3736,17 @@ const settingsPersistor = new OIMPersistor<OIMPersistKeyValueBackend, OIMPersist
             },
         }),
     }),
-    persistScheduler: new OIMPersistSchedulerFrameDriven({ channelSlot: db.defaultChannelSlot }),
+    persistScheduler: new OIMPersistFrameScheduler({ channelSlot: db.defaultChannelSlot }),
 });
-settingsPersistor.addPersistResource(new OIMPersistResourceSnapshot({
-    persistSnapshotSource: new OIMPersistSnapshotSourceSingleEntityDriven({
+settingsPersistor.addPersistResource(new OIMPersistSnapshotResource({
+    persistSnapshotSource: new OIMPersistSingleEntitySnapshotSource({
         channelMap: db, singleSlotService: settingsSingleEntityService, entityStoreSlot: settingsEntityStoreSlot,
     }),
-    persistSnapshotStrategy: new OIMPersistKeyValueEntryStrategy<TOIMPersistVersionedShape>({ storageKey: 'settings' }),
-    persistCodec: new OIMPersistCodecVersioned<TSettings, TSettings>({
+    persistSnapshotService: new OIMPersistKeyValueEntrySnapshotService<TOIMPersistVersionedShape>({ storageKey: 'settings' }),
+    persistCodec: new OIMPersistVersionedCodec<TSettings, TSettings>({
         version: 2,
         migrations: { 2: data => ({ density: 'comfortable', ...(data as object) }) },
-        persistCodec: new OIMPersistCodecIdentity<TSettings>(),
+        persistCodec: new OIMPersistIdentityCodec<TSettings>(),
     }),
 }));
 await settingsPersistor.hydrate();
@@ -3881,34 +3763,34 @@ await settingsPersistor.whenIdle();
 
 **Memory** (`@oimdb/persist-memory`). `new OIMPersistMemoryBackend()`. Snapshot values
 and records live in two separate maps, so a snapshot and a records resource may share
-a `storageKey`. `OIMPersistMemoryRecordsStrategy<TKey, TEntity>({ storageKey })` keeps one
+a `storageKey`. `OIMPersistMemoryRecordsService<TKey, TEntity>({ storageKey })` keeps one
 `Map` of key to entity per `storageKey`: autosave sets and deletes keys, `persist()`
-replaces the map (while the resource has unloaded keys, sets keys and deletes only the deletions the resource already heard), `clearPersisted()` deletes it, and a `load` looks each of its keys up in the map through `readRecordsOfKeys`. `OIMPersistMemorySnapshotStrategy<TSnapshot>({ storageKey })`
+replaces the map (while the resource has unloaded keys, sets keys and deletes only the deletions the resource already heard), `clearPersisted()` deletes it, and a `load` looks each of its keys up in the map through `readRecordsOfKeys`. `OIMPersistMemorySnapshotService<TSnapshot>({ storageKey })`
 keeps one value. `readRecords(storageKey)` and `readSnapshotValue(storageKey)` read
 what was committed. `OIMPersistMemoryWriteBatch` queues every change and applies them in
 order on `commit()`.
 
 **JSON** (`@oimdb/persist-json`, depends on `@oimdb/persist-memory`).
-`OIMPersistJsonBackend` extends `OIMPersistMemoryBackend` and takes the memory
+`OIMPersistJsonMemoryBackend` extends `OIMPersistMemoryBackend` and takes the memory
 strategies. `dehydrate()` returns a `TOIMPersistJsonDump`,
 `{ snapshotValues: Record<storageKey, value>, recordsByStorageKey: Record<storageKey, { key, entity }[]> }`;
-`new OIMPersistJsonBackend({ initialPersistJsonDump })` writes such a dump straight into
+`new OIMPersistJsonMemoryBackend({ initialPersistJsonDump })` writes such a dump straight into
 its maps. The SSR flow: on the server, `await persistor.persist()` and then
-`JSON.stringify(persistJsonBackend.dehydrate())`; on the client,
-`new OIMPersistJsonBackend({ initialPersistJsonDump: JSON.parse(jsonText) })`, register
+`JSON.stringify(persistJsonMemoryBackend.dehydrate())`; on the client,
+`new OIMPersistJsonMemoryBackend({ initialPersistJsonDump: JSON.parse(jsonText) })`, register
 the same resources under the same `storageKey`s, `await persistor.hydrate()`. To merge
 a durable cache over the server's content, hydrate the JSON persistor first, then the
 durable persistor with `persistHydrateReconcile`, then `start()` the durable one.
 
 **IndexedDB** (`@oimdb/persist-idb`). `new OIMPersistIndexedDbBackend({ databaseName, databaseVersion?, indexedDb? })`;
 `indexedDb` defaults to `globalThis.indexedDB` and the constructor throws without
-either. `OIMPersistIndexedDbRecordsStrategy<TKey, TEntity>({ tableName })` stores one value
+either. `OIMPersistIndexedDbRecordsService<TKey, TEntity>({ tableName })` stores one value
 per entity key in an object store: autosave puts and deletes per key, `persist()`
 clears the table and puts every entity (while the resource has unloaded keys, only
 puts plus a delete per deletion the resource already heard), `clearPersisted()` clears it,
 and a `load` reads its keys through `readRecordsOfKeys` in one `readonly` transaction,
 one `get` per key.
-`OIMPersistIndexedDbSnapshotStrategy<TSnapshot>({ tableName, primaryKey })` stores one value
+`OIMPersistIndexedDbSnapshotService<TSnapshot>({ tableName, primaryKey })` stores one value
 at `primaryKey`. One commit is one `readwrite` transaction over every table the batch
 touches. A commit opens the database and creates missing tables by a version upgrade
 (retried when another connection upgrades first, up to five attempts; an upgrade
@@ -3920,7 +3802,7 @@ sorted property names, and is read back as that string.
 **Key-value** (`@oimdb/persist`). `new OIMPersistKeyValueBackend({ persistKeyValueStorage, persistKeyValueSerializer? })`
 stores serialized strings under string keys. `persistKeyValueStorage` is an
 `IOIMPersistKeyValueStorage` (`readItems(storageKeys)`, `writeItems(itemByStorageKey)`,
-`removeItems(storageKeys)`); `OIMPersistKeyValueStorageItemDriven({ persistKeyValueItemStorage })`
+`removeItems(storageKeys)`); `OIMPersistItemKeyValueStorage({ persistKeyValueItemStorage })`
 adapts any `TOIMPersistKeyValueItemStorage` (`getItem`, `setItem`, `removeItem`,
 synchronous or returning promises) with one call per key. The serializer is a
 `TOIMPersistKeyValueSerializer` (`serialize`, `deserialize`) and defaults to
@@ -3928,15 +3810,15 @@ synchronous or returning promises) with one call per key. The serializer is a
 
 | strategy | stored as |
 |---|---|
-| `OIMPersistKeyValueEntryStrategy<TSnapshot>({ storageKey })` | the whole snapshot under `storageKey` |
-| `OIMPersistKeyValuePathStrategy<TSnapshot>({ storageKey, path })` | the snapshot at `path` (a `string[]`) inside an object under `storageKey`; several resources may share the key; the constructor throws on an empty `path` |
+| `OIMPersistKeyValueEntrySnapshotService<TSnapshot>({ storageKey })` | the whole snapshot under `storageKey` |
+| `OIMPersistKeyValuePathSnapshotService<TSnapshot>({ storageKey, path })` | the snapshot at `path` (a `string[]`) inside an object under `storageKey`; several resources may share the key; the constructor throws on an empty `path` |
 
 `OIMPersistKeyValueWriteBatch` commits with at most one `readItems` (keys with path
 writes or path deletions and no whole-value write in the batch), one `writeItems` and
 one `removeItems`; it serializes every value before writing any. Path segments are
 own properties, so a stored `__proto__` is data.
 
-- **localStorage** (`@oimdb/persist-localstorage`): `OIMPersistLocalStorageBackend`
+- **localStorage** (`@oimdb/persist-localstorage`): `OIMPersistLocalStorageKeyValueBackend`
   extends `OIMPersistKeyValueBackend` over a `TOIMPersistKeyValueItemStorage`
   (`getItem`, `setItem`, `removeItem`) given as `persistKeyValueItemStorage`, which
   defaults to `globalThis.localStorage`; the constructor throws without either. One `setItem` per written key.
@@ -3955,10 +3837,10 @@ own properties, so a stored `__proto__` is data.
   batch keeps them in: `addWriteBatchChange(change)`, `hasWriteBatchChanges`,
   `applyWriteBatchChanges(target)`. `oimWritePersistRecordsDelta(delta, putRecord, deleteRecord)`
   walks a `TOIMPersistRecordsDelta` in the one order every backend uses: upserts, then deletions.
-- Snapshot strategy: `IOIMPersistSnapshotStrategy<TPersistBackend, TWriteBatch, TSnapshot>`
+- Snapshot strategy: `IOIMPersistSnapshotService<TPersistBackend, TWriteBatch, TSnapshot>`
   with `readSnapshot(persistBackend)`, `writeSnapshot(writeBatch, snapshot)`,
   `deleteSnapshot(writeBatch)`. Records strategy:
-  `IOIMPersistRecordsStrategy<TPersistBackend, TWriteBatch, TKey, TEntity>` with
+  `IOIMPersistRecordsService<TPersistBackend, TWriteBatch, TKey, TEntity>` with
   `readRecords(persistBackend)`, `readRecordsOfKeys(persistBackend, keys)`,
   `writeRecords(writeBatch, persistRecords)`,
   `writeRecordsDelta(writeBatch, persistRecordsDelta)` (a `TOIMPersistRecordsDelta`,
@@ -3972,15 +3854,15 @@ own properties, so a stored `__proto__` is data.
   `loadRecords(persistRecords)`, `unloadKeys(keys)`.
   `markSourceChanges()` is required and returns an `IOIMPersistSourceChangeMark`
   (`isSourceChangedSinceMark()`, `dispose()`); build it with
-  `new OIMPersistSourceChangeMarkSlotDriven({ channelClock, slots })` or
-  `new OIMPersistSourceChangeMarkSubscriptionDriven({ subscribeSourceChanged })`.
+  `new OIMPersistSlotSourceChangeMark({ channelClock, slots })` or
+  `new OIMPersistSubscriptionSourceChangeMark({ subscribeSourceChanged })`.
   It must accept more than one subscription, each with its own `TOIMDisposer`.
 - Scheduler: `IOIMPersistScheduler`, above.
 
 ### Limits
 
 - **No key-value records strategy.** Over `OIMPersistKeyValueBackend` (localStorage,
-  async KV) an entity store slot or a bucket goes through `OIMPersistResourceSnapshot`: every
+  async KV) an entity store slot or a bucket goes through `OIMPersistSnapshotResource`: every
   autosave walks every entity slot of the source and serializes the whole snapshot
   under one key.
 - **A bucket membership change walks the bucket.** Each change of the bucket slot
@@ -3990,7 +3872,7 @@ own properties, so a stored `__proto__` is data.
   `createOIMEntityWriterInPlace()` the stored entity is the live entity object, so an
   in-place write moves the stored value before any commit, and `dehydrate()` returns
   the live objects. Use `createOIMEntityWriterReplacing()` with
-  `entityInsertStrategy: oimInsertEntityWithCopy` where the stored value must stay
+  `entityInserter: oimInsertEntityWithCopy` where the stored value must stay
   what was committed, and serialize a dump at once.
 - **Hydrate without a reconcile replaces.** The collection source deletes every
   entity the stored records do not name, and an existing but empty records table
@@ -4079,7 +3961,7 @@ Who decided the order is the difference, and the core already forks on it.
 
 | | `exoDerivedList(channelMap, computedSlot, render, maxCommandsPerSlot?)` | `exoPositionalList(channelMap, slotContentBucketService, bucketSlot, render)` |
 |---|---|---|
-| takes | a `TOIMComputedSlot<readonly TOIMEntitySlot[]>` | a bucket content service built with an `OIMBucketCommands` (the default of `createOIMBucketService`) and one of its bucket slots, from any of its store slots |
+| takes | a `TOIMComputedSlot<readonly TOIMEntitySlot[]>` | a bucket content service built with an `OIMBucketCommands` and one of its bucket slots, from any of its store slots |
 | the script | **derived**, by `oimOrderedListCommandsOfTransition` | **recorded**, by `OIMBucketCommands`, read inside the frame |
 | per changed frame | one diff: two passes plus an LIS pass, `common − LIS` moves | one pass over the frame's own script |
 
@@ -4130,8 +4012,8 @@ them.
 
 The one quantity that needs no measurement, because it is arithmetic rather than
 a reading: emptying a bucket one slot at a time on an array-driven bucket costs
-n(n-1)/2 element moves — **499 500** for a thousand — which is why a bucket content service's `writeBucketMemberSlots`
-and `clearBucketMemberSlots` go through one `drainSlots`. Counted, not timed, in
+n(n-1)/2 element moves — **499 500** for a thousand — which is why a bucket content service's `writeSlotContent`
+and `clearSlotContent` go through one `drainSlots`. Counted, not timed, in
 `packages/core/src/engine/bucket/array/tests/everyone-out-at-once-and-not-one-at-a-time.test.ts`, which
 also pins `drainSlots` at zero element writes.