@oimdb/react 3.0.0 → 3.2.0

package/README.md

@@ -11,7 +11,7 @@ npm install @oimdb/react @oimdb/core
 
 ## Why one binding
 
-Subscribing in this engine is one call: `OIMEffectService.INSTANCE.subscribeEffect(db, sourceSlots, sourceComputeds, body)`.
+Subscribing in this engine is one call: `OIMEffectService.INSTANCE.subscribeEffect(db, body, sourceSlots?, sourceComputeds?, sourceTrackingComputeds?)`.
 It carries no value; what changed is read off the slots afterwards. So a component needs
 exactly three things: the roots a write can reach, the derivations to ask before reading,
 and the derive function. Together they make up `TOIMBinding`, and `useOIMValue` is the hook that applies it through
@@ -35,18 +35,18 @@ instance, a store slot, and every store door of the service takes that store slo
 Whatever a read mints is swept at the end of the frame unless something took a real reference to it.
 
 ```ts setup
-import { OIMDB, createOIMBucketService, createOIMEntityService, type TOIMEntitySlot } from '@oimdb/core';
+import { OIMDB, type TOIMEntitySlot, createOIMSlotCollectionService, createOIMSlotContentEntityService, OIMSlotContentPositionalArrayBucketService, OIMBucketCommands, createOIMSingleComputedService, OIMSingleSlotStoreService, createOIMSingleSlotService, createOIMComputedService, oimSameValueZeroGuard, type TOIMComputedSlot } from '@oimdb/core';
 
 type TCard = { id: string; deckId: string; title: string; rank: number };
 
 export const db = new OIMDB();
 
-export const cardService = createOIMEntityService<TCard>(db, { keyOf: (card) => card.id });
+export const cardService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<TCard>() });
 export const cards = cardService.createStoreSlot(db);
 
 // A bucket keeps the order the caller writes; a sorted list is
-// `createOIMComputedServiceSorted` over an index.
-export const byDeckService = createOIMBucketService<TOIMEntitySlot<TCard>>(db);
+// `createOIMSortedComputedService` over an index.
+export const byDeckService = createOIMSlotCollectionService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TCard>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 export const byDeck = byDeckService.createStoreSlot(db);
 
 // A BUCKET'S SLOTS ARE YOURS. A write moves the card's value and files nothing, so the
@@ -54,9 +54,9 @@ export const byDeck = byDeckService.createStoreSlot(db);
 // bucket by key: it mints one if there is none and hands back the bucket itself,
 // counted. `owner.unholdSlot` gives that count back, once the bucket's own slots keep it.
 export function setDeck(deckId: string, cardsInDeck: readonly TCard[]): void {
-    cardService.slotContentService.upsertEntities(cards, cardsInDeck);
+    cardService.writeInBatch(cards, () => (cardsInDeck).map(entity => cardService.writeSlotContentByKey(cards, entity.id, entity)));
     const bucket = byDeckService.holdSlotByKey(byDeck, deckId);
-    byDeckService.slotContentService.writeBucketMemberSlots(
+    byDeckService.slotContentService.writeSlotContent(
         bucket, cardsInDeck.map((card) => cardService.getSlotByKey(cards, card.id)),
     );
     bucket.owner.unholdSlot(bucket);
@@ -77,7 +77,7 @@ function App() {
 
 // One entity, by key.
 function Card({ pk }: { pk: string }) {
-    const card = useOIMEntity(cardService, cards, pk);
+    const card = useOIMEntity(cards, pk);
     return <span>{card?.title}</span>;
 }
 
@@ -85,7 +85,7 @@ function Card({ pk }: { pk: string }) {
 // mounted, and gives the hold back when it unmounts or when `deckId` moves —
 // there is no release to remember here.
 function DeckList({ deckId }: { deckId: string }) {
-    const deckCards = useOIMBucketSlotsByKey(byDeckService, byDeck, deckId);
+    const deckCards = useOIMBucketSlotsByKey(byDeck, deckId);
     return <ul>{deckCards.map((s) => <li key={String(s.key)}>{s.entity?.title}</li>)}</ul>;
 }
 ```
@@ -101,8 +101,9 @@ throw when it does not.
 
 ## The hooks
 
-Every hook that reads a collection takes the collection service first and the store slot second.
-The parameter is typed as a `Pick` of `OIMSlotCollectionService` with only the members the hook calls.
+Every hook that reads a collection by key takes the store slot alone and calls the service it carries,
+`storeSlot.slotService`, typed as a `Pick` of `OIMSlotCollectionService` with only the members the hook calls.
+A store aggregate passes its `storeSlot`.
 
 - **`useOIMValue(binding)`**: the binding. It subscribes one effect over the binding's roots and
   derivations (the effect holds each of them for as long as it lives), settles the derivations before
@@ -112,7 +113,7 @@ The parameter is typed as a `Pick` of `OIMSlotCollectionService` with only the m
 - **`useOIMComputedValue(computedSlot)`**: the value of ONE computed slot, re-rendering
   when it changes. It is `useOIMValue` over `sourceComputeds: [computedSlot]`, with the
   value read off `computedSlot.value` after `useOIMValue` settles it.
-- **`useOIMEntity(entityCollectionService, entityStoreSlot, key)`**: one entity, by key. The key is resolved
+- **`useOIMEntity(entityStoreSlot, key)`**: one entity, by key. The key is resolved
   to an identity ON COMMIT, not on render, through `holdSlotByKey(entityStoreSlot, key)`: a render is not a
   lifetime, and an identity a discarded render minted would have no hold to give back. The render path reads
   `getSlotByKey(entityStoreSlot, key)`, so the first paint shows current state. That read mints when the key
@@ -127,45 +128,40 @@ The parameter is typed as a `Pick` of `OIMSlotCollectionService` with only the m
   bucket's order, read through `bucketCollectionService.slotContentService.getBucketMemberSlots`. The array is
   copied only when the bucket slot's change stamp (`changedAtRevision`, `changedAtEpoch`) moved. That stamp is
   reliable here because the caller holds the bucket: a write to a slot nothing holds is not stamped.
-- **`useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key)`**: one bucket by key, as an array of
+- **`useOIMBucketSlotsByKey(bucketStoreSlot, key)`**: one bucket by key, as an array of
   entity slots. It resolves the bucket on commit, holds it for as long as the component is mounted, and gives the
   hold back on unmount or when the key changes. It copies the members on every render: the bucket it reads during a
   render may be held by nothing yet, and an unheld bucket's stamp does not move. **The key may be built inline**,
-  including the array that keys an `OIMSlotStoreServiceTreeDriven`; the hook settles it by asking the store which
+  including the array that keys an `OIMSlotTreeStoreService`; the hook settles it by asking the store which
   bucket each key names.
-- **`useOIMSlotsByKeys(slotCollectionService, storeSlot, keys)`**: several identities of one store slot,
+- **`useOIMSlotsByKeys(storeSlot, keys)`**: several identities of one store slot,
   resolved by key and held for as long as the component is mounted. It returns the slots and takes no subscription,
   so use it when a component reads **derivations**: a computed slot exists only while something holds it, and a bare
   read mints one that the next `flush()` takes straight back. See [Holds per component](#holds-per-component).
-- **`useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key)`**: the value of one key of a
-  computed store slot. Pass `computedService.computedCollectionService`. It has the same body as `useOIMEntity`:
+- **`useOIMComputedValueByKey(computedStoreSlot, key)`**: the value of one key of a
+  computed store slot. It has the same body as `useOIMEntity`:
   it resolves with `holdSlotByKey` on commit, subscribes over that computed slot, gives the resolve-hold straight
   back, and reads the value through `computedSlot.computedValueService.getValueForSlot`.
 - **`useOIMComputedCollection(computedService, derive, createSources, deps)`**: a keyed computed store slot the
   component owns. The SERVICE is yours, built once at module scope with `createOIMComputedService(options)`; the hook
   only calls `computedService.createComputedStoreSlot(db, derive, createSources)` in a `useMemo` keyed on `deps`, and
   returns that store slot. `derive` and `createSources` may be `undefined` when the service already has them.
-  Read it by key with `useOIMComputedValueByKey(computedService.computedCollectionService, computedStoreSlot, key)`.
-- **`useOIMSingleComputedValue(computedService, derive, createSources, deps)`**: a single computed the component
-  owns, read under the key `undefined`. The service is a void-keyed `createOIMComputedService` with
-  `computedSlotStoreService: OIMSlotStoreServiceSingleSlotDriven.INSTANCE`, built once at module scope. Per mount
-  the hook builds a store slot through `useOIMComputedCollection` and reads it through `useOIMComputedValueByKey`,
-  so a flush between render and subscribe, which releases the slot the render minted, is safe.
-- **`useOIMSingleEntity(singleSlotService, singleSlotStoreSlot)`** and
-  **`useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot)`**: the single entity and the single bucket.
+  Read it by key with `useOIMComputedValueByKey(computedStoreSlot, key)`.
+- **`useOIMSingleComputedValue(computedService, derive, createSources, deps)`**: a single computed the
+  component owns. The service is `createOIMSingleComputedService<V>()`, built once at module scope; `derive` and
+  `createSources` receive the computed slot. Per mount the hook builds one store slot and reads its slot through
+  `computedSingleSlotService`, so a flush between render and subscribe, which releases the slot the render minted,
+  is safe.
+- **`useOIMSingleEntity(singleSlotStoreSlot)`** and
+  **`useOIMSingleBucketSlots(singleSlotStoreSlot)`**: the single entity and the single bucket.
   See [Singles](#singles).
 - **`useOIMDB()`**: the `OIMDB` from `OIMDBContext`. It throws if used outside `<OIMDBProvider>`.
 
 ```tsx
-import { OIMSlotStoreServiceSingleSlotDriven, createOIMComputedService } from '@oimdb/core';
-import type { TOIMComputedSlot, TOIMSingleSlotStore } from '@oimdb/core';
 import { useOIMSingleComputedValue } from '@oimdb/react';
 
 // Module scope: one service per kind of computed, shared by every component.
-const totalRankService = createOIMComputedService<void, number, TOIMSingleSlotStore<TOIMComputedSlot<number, void>>>({
-    computedSlotStoreService:
-        OIMSlotStoreServiceSingleSlotDriven.INSTANCE as OIMSlotStoreServiceSingleSlotDriven<TOIMComputedSlot<number, void>>,
-});
+const totalRankService = createOIMSingleComputedService<number>();
 
 function TotalRank({ ids }: { ids: readonly string[] }) {
     // Per mount: one store slot with its own derive and sources.
@@ -181,28 +177,27 @@ function TotalRank({ ids }: { ids: readonly string[] }) {
 
 ## Singles
 
-A single is a store slot that holds ONE identity and has no key: `createOIMSingleEntityService(db)` and
-`createOIMSingleBucketService(db)` hand back an `OIMSingleSlotService`, read through `getSingleSlot(storeSlot)` and
-`holdSingleSlot(storeSlot)`. The two single hooks take that service (typed as a `Pick` of `OIMSingleSlotService`)
-and its store slot, and have the by-key hooks' mechanics without the key: the render reads `getSingleSlot`, whose
+A single is a store slot that holds ONE identity and has no key: `createOIMSingleSlotService()` and
+`createOIMSingleSlotService()` hand back an `OIMSingleSlotService`, read through `getSingleSlot(storeSlot)` and
+`holdSingleSlot(storeSlot)`. The two single hooks take the store slot and call its `slotService` (typed as a
+`Pick` of `OIMSingleSlotService`), and have the by-key hooks' mechanics without the key: the render reads `getSingleSlot`, whose
 mint the next `flush()` takes back if no commit follows; the commit resolves with `holdSingleSlot`, subscribes over
 that slot and gives the resolve-hold straight back, so a single released while nothing watched it is minted afresh.
 
 ```tsx
-import { createOIMSingleBucketService, createOIMSingleEntityService } from '@oimdb/core';
 import { useOIMSingleBucketSlots, useOIMSingleEntity } from '@oimdb/react';
 
 type TSettings = { theme: string };
 
-const settingsService = createOIMSingleEntityService<TSettings>(db);
+const settingsService = createOIMSingleSlotService({ slotContentService: createOIMSlotContentEntityService<TSettings>() });
 const settings = settingsService.createStoreSlot(db);
 
-const pickedService = createOIMSingleBucketService<TOIMEntitySlot<TCard>>(db);
+const pickedService = createOIMSingleSlotService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TCard>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const picked = pickedService.createStoreSlot(db);
 
 function Toolbar() {
-    const theme = useOIMSingleEntity(settingsService, settings)?.theme;
-    const pickedCards = useOIMSingleBucketSlots(pickedService, picked);
+    const theme = useOIMSingleEntity(settings)?.theme;
+    const pickedCards = useOIMSingleBucketSlots(picked);
     return <span>{theme}: {pickedCards.length} picked</span>;
 }
 ```
@@ -212,7 +207,7 @@ A single computed is `useOIMSingleComputedValue`.
 
 ## Binding a derivation
 
-`createOIMComputedService` and `createOIMComputedServiceBucketMemo` both hand back a service of computed slots,
+`createOIMComputedService` and `createOIMBucketMemoComputedService` both hand back a service of computed slots,
 whose store slot holds them. You can either hold the key where the lifetime is (a module, your own store) and bind
 it with `useOIMValue`, or let the component own the lifetime with `useOIMSlotsByKeys`.
 
@@ -222,7 +217,7 @@ asked and never woken. Only a computed slot's `computedValueService.getValueForS
 
 **No wake is owed for what happened before the subscription.** An effect is stamped with the channel clock at
 birth (`ranAtRevision` / `ranAtEpoch`), so a frame runs the body only when a source moved *after* the subscription.
-Every hook here subscribes with `subscribeEffect`; `OIMEffectService.INSTANCE.createEffectImmediate` is the door
+Every hook here subscribes with `subscribeEffect`; `OIMEffectService.INSTANCE.createAndRunEffect` is the door
 that delivers a value at once.
 
 ## Holds per component
@@ -232,18 +227,17 @@ resolves each key through `holdSlotByKey(storeSlot, key)` and keeps that hold, a
 moves) it gives back exactly the holds that commit took.
 
 ```tsx
-import { createOIMComputedService, oimSameValueZeroGuard } from '@oimdb/core';
 import { useOIMSlotsByKeys } from '@oimdb/react';
 
 const rankService = createOIMComputedService<string, number>({
-    createSources: (id) => ({ sourceSlots: [cardService.getSlotByKey(cards, id)] }),
+    createSources: ({ key: id }) => ({ sourceSlots: [cardService.getSlotByKey(cards, id)] }),
     derive: (computedSlot) => cardService.getSlotByKey(cards, computedSlot.key).entity?.rank ?? -1,
     sameValueGuard: oimSameValueZeroGuard,
 });
 const ranks = rankService.createComputedStoreSlot(db);
 
 function Hand({ ids }: { ids: readonly string[] }) {
-    const slots = useOIMSlotsByKeys(rankService.computedCollectionService, ranks, ids);
+    const slots = useOIMSlotsByKeys(ranks, ids);
     return <ul>{slots.map((s) => <li key={String(s.key)}>{s.computedValueService.getValueForSlot(s)}</li>)}</ul>;
 }
 ```
@@ -298,7 +292,7 @@ identity are one key.
 
 ## Things worth knowing
 
-- **The snapshot `useOIMValue` compares is a local counter, not the value.** `createOIMEntityWriterInPlace` keeps
+- **The snapshot `useOIMValue` compares is a local counter, not the value.** `createOIMInPlaceEntityWriter` keeps
   an entity's object reference stable, a bucket hands its slots back as the same live container, and a column
   subscription fires only for its own column; a value-comparing binding would fire on none of the three. The counter
   is bumped ON SUBSCRIBING too, so a write that lands between the render and the subscription is still shown. The
@@ -310,9 +304,9 @@ identity are one key.
   is one per kind of computed; a component that owns a computed gets only a store slot from
   `useOIMComputedCollection` / `useOIMSingleComputedValue`.
 - **Nothing re-files an entity when it is written into a bucket you maintain.** Write the buckets in the same code
-  that writes the entity, or use an index service (`createOIMIndexService`), which files entities by the key it
+  that writes the entity, or use an index service (`createOIMSlotCollectionIndexService`), which files entities by the key it
   derives from each one.
-- **A bucket never sorts.** A list sorted by a column is `createOIMComputedServiceSorted({ indexService, sortColumns })`
+- **A bucket never sorts.** A list sorted by a column is `createOIMSortedComputedService({ indexService, sortColumns })`
   over an index service, with `createSortedStoreSlot(indexStoreSlot)`.
 
 ## Reference

package/dist/index.cjs

@@ -71,12 +71,12 @@ var OIMSnapshotVersion = class {
     this.version = 0;
     this.getVersion = () => this.version;
   }
-  subscribeEffect(channelMap, sourceSlots, sourceComputeds, onStoreChange) {
+  subscribeEffect(channelMap, onStoreChange, sourceSlots, sourceComputeds) {
     this.version++;
-    return import_core.OIMEffectService.INSTANCE.subscribeEffect(channelMap, sourceSlots, sourceComputeds, () => {
+    return import_core.OIMEffectService.INSTANCE.subscribeEffect(channelMap, () => {
       this.version++;
       onStoreChange();
-    });
+    }, sourceSlots, sourceComputeds);
   }
 };
 
@@ -96,9 +96,9 @@ function useOIMValue(binding) {
       snapshotVersion,
       subscribe: (onStoreChange) => snapshotVersion.subscribeEffect(
         db,
+        onStoreChange,
         binding.sourceSlots ?? import_core2.OIM_FROZEN_EMPTY_SLOTS,
-        sourceComputeds,
-        onStoreChange
+        sourceComputeds
       )
     };
   }, [db, binding, sourceComputeds]);
@@ -123,17 +123,28 @@ var import_core3 = require("@oimdb/core");
 
 // src/oimAssertOneChannel.ts
 function oimAssertOneChannel(channelMap, slot, door) {
-  const storeSlot = slot.storeSlot;
-  if (storeSlot === void 0 || storeSlot.channelSlot === channelMap.defaultChannelSlot) return;
+  if (slot.storeSlot.channelSlot === channelMap.defaultChannelSlot) return;
   throw new Error(
     `${door}: the slot was filed on another OIMDB than the one <OIMDBProvider> was given, so a write would never wake this component. Build the services and their store slots on the one OIMDB the provider holds.`
   );
 }
 
+// src/oimSubscribeHeldSlot.ts
+function oimSubscribeHeldSlot(channelMap, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange) {
+  try {
+    oimAssertOneChannel(channelMap, holdingSlot, hookName);
+    const [sourceSlots, sourceComputeds] = sourcesOfSlot(holdingSlot);
+    return snapshotVersion.subscribeEffect(channelMap, onStoreChange, sourceSlots, sourceComputeds);
+  } finally {
+    holdingSlot.owner.unholdSlot(holdingSlot);
+  }
+}
+
 // src/useOIMSlotByKey.ts
 var sourcesOfRootSlot = (rootSlot) => [[rootSlot], import_core3.OIM_FROZEN_EMPTY_SLOTS];
-function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
+function useOIMSlotByKey(hookName, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
   const db = useOIMDB();
+  const slotCollectionService = storeSlot.slotService;
   const lastSeenKeyRef = (0, import_react6.useRef)(key);
   const settledKeyRef = (0, import_react6.useRef)(key);
   if (key !== lastSeenKeyRef.current) {
@@ -150,18 +161,12 @@ function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, source
       snapshotVersion,
       subscribe: (onStoreChange) => {
         const holdingSlot = slotCollectionService.holdSlotByKey(storeSlot, settledKey);
-        try {
-          oimAssertOneChannel(db, holdingSlot, hookName);
-          const [sourceSlots, sourceComputeds] = sourcesOfSlot(holdingSlot);
-          const disposeEffect = snapshotVersion.subscribeEffect(db, sourceSlots, sourceComputeds, onStoreChange);
-          subscribedSlot = holdingSlot;
-          return () => {
-            subscribedSlot = void 0;
-            disposeEffect();
-          };
-        } finally {
-          holdingSlot.owner.unholdSlot(holdingSlot);
-        }
+        const effectDisposer = oimSubscribeHeldSlot(db, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange);
+        subscribedSlot = holdingSlot;
+        return () => {
+          subscribedSlot = void 0;
+          effectDisposer();
+        };
       },
       getSlot: () => subscribedSlot ?? slotCollectionService.getSlotByKey(storeSlot, settledKey)
     };
@@ -171,14 +176,17 @@ function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, source
 }
 
 // src/useOIMEntity.ts
-function useOIMEntity(entityCollectionService, entityStoreSlot, key) {
-  return useOIMSlotByKey("useOIMEntity", entityCollectionService, entityStoreSlot, key).entity;
+function useOIMEntity(entityStoreSlot, key) {
+  return useOIMSlotByKey("useOIMEntity", entityStoreSlot, key).entity;
 }
 
 // src/useOIMSingleSlot.ts
 var import_react7 = require("react");
-function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
+var import_core4 = require("@oimdb/core");
+var sourcesOfRootSlot2 = (rootSlot) => [[rootSlot], import_core4.OIM_FROZEN_EMPTY_SLOTS];
+function useOIMSingleSlot(hookName, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
   const db = useOIMDB();
+  const singleSlotService = singleSlotStoreSlot.slotService;
   const store = (0, import_react7.useMemo)(() => {
     const snapshotVersion = new OIMSnapshotVersion();
     let subscribedSlot = void 0;
@@ -186,45 +194,40 @@ function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
       snapshotVersion,
       subscribe: (onStoreChange) => {
         const holdingSlot = singleSlotService.holdSingleSlot(singleSlotStoreSlot);
-        try {
-          oimAssertOneChannel(db, holdingSlot, hookName);
-          const disposeEffect = snapshotVersion.subscribeEffect(db, [holdingSlot], [], onStoreChange);
-          subscribedSlot = holdingSlot;
-          return () => {
-            subscribedSlot = void 0;
-            disposeEffect();
-          };
-        } finally {
-          holdingSlot.owner.unholdSlot(holdingSlot);
-        }
+        const effectDisposer = oimSubscribeHeldSlot(db, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange);
+        subscribedSlot = holdingSlot;
+        return () => {
+          subscribedSlot = void 0;
+          effectDisposer();
+        };
       },
       getSlot: () => subscribedSlot ?? singleSlotService.getSingleSlot(singleSlotStoreSlot)
     };
-  }, [hookName, db, singleSlotService, singleSlotStoreSlot]);
+  }, [hookName, db, singleSlotService, singleSlotStoreSlot, sourcesOfSlot]);
   useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
   return store.getSlot();
 }
 
 // src/useOIMSingleEntity.ts
-function useOIMSingleEntity(singleSlotService, singleSlotStoreSlot) {
-  return useOIMSingleSlot("useOIMSingleEntity", singleSlotService, singleSlotStoreSlot).entity;
+function useOIMSingleEntity(singleSlotStoreSlot) {
+  return useOIMSingleSlot("useOIMSingleEntity", singleSlotStoreSlot).entity;
 }
 
 // src/useOIMSingleBucketSlots.ts
-function useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot) {
-  const bucketSlot = useOIMSingleSlot("useOIMSingleBucketSlots", singleSlotService, singleSlotStoreSlot);
-  return Array.from(singleSlotService.slotContentService.getBucketMemberSlots(bucketSlot));
+function useOIMSingleBucketSlots(singleSlotStoreSlot) {
+  const bucketSlot = useOIMSingleSlot("useOIMSingleBucketSlots", singleSlotStoreSlot);
+  return Array.from(singleSlotStoreSlot.slotService.slotContentService.getBucketMemberSlots(bucketSlot));
 }
 
 // src/useOIMField.ts
 var import_react8 = require("react");
 
 // src/holdWhileSubscribed.ts
-var import_core4 = require("@oimdb/core");
+var import_core5 = require("@oimdb/core");
 function holdWhileSubscribed(slots, subscribe) {
-  (0, import_core4.oimHoldSlots)(slots);
+  (0, import_core5.oimHoldSlots)(slots);
   const giveEveryHoldBack = () => {
-    (0, import_core4.oimUnholdSlotsIfAlive)(slots);
+    (0, import_core5.oimUnholdSlotsIfAlive)(slots);
   };
   let disposer;
   try {
@@ -253,9 +256,8 @@ function useOIMField(entityCollectionService, slot, name) {
       snapshotVersion,
       subscribe: (onStoreChange) => holdWhileSubscribed(holds, () => snapshotVersion.subscribeEffect(
         db,
-        [entityCollectionService.getColumn(slot, name)],
-        [],
-        onStoreChange
+        onStoreChange,
+        [entityCollectionService.columnSlotService.getColumn(slot, name)]
       ))
     };
   }, [db, entityCollectionService, slot, name]);
@@ -280,32 +282,30 @@ function useOIMBucketSlots(bucketCollectionService, bucketSlot) {
 }
 
 // src/useOIMBucketSlotsByKey.ts
-function useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key) {
-  const bucketSlot = useOIMSlotByKey("useOIMBucketSlotsByKey", bucketCollectionService, bucketStoreSlot, key);
-  return Array.from(bucketCollectionService.slotContentService.getBucketMemberSlots(bucketSlot));
+function useOIMBucketSlotsByKey(bucketStoreSlot, key) {
+  const bucketSlot = useOIMSlotByKey("useOIMBucketSlotsByKey", bucketStoreSlot, key);
+  return Array.from(bucketStoreSlot.slotService.slotContentService.getBucketMemberSlots(bucketSlot));
 }
 
 // src/useOIMSlotsByKeys.ts
 var import_react10 = require("react");
-var import_core5 = require("@oimdb/core");
-function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+var import_core6 = require("@oimdb/core");
+function useOIMSlotsByKeys(storeSlot, keys) {
   const settledKeys = (0, import_react10.useRef)(keys);
   const previousKeys = settledKeys.current;
-  if (!(0, import_core5.oimSameKeySequence)(previousKeys, keys)) settledKeys.current = keys;
+  if (!(0, import_core6.oimSameKeySequence)(previousKeys, keys)) settledKeys.current = keys;
   const keysToHold = settledKeys.current;
   const [, resolveAgain] = (0, import_react10.useState)(0);
   const resolvedSlots = (0, import_react10.useRef)(void 0);
   const resolvedKeys = (0, import_react10.useRef)(keysToHold);
-  const resolvedSlotCollectionService = (0, import_react10.useRef)(slotCollectionService);
   const resolvedStoreSlot = (0, import_react10.useRef)(storeSlot);
-  if (resolvedSlots.current === void 0 || resolvedKeys.current !== keysToHold || resolvedSlotCollectionService.current !== slotCollectionService || resolvedStoreSlot.current !== storeSlot) {
+  if (resolvedSlots.current === void 0 || resolvedKeys.current !== keysToHold || resolvedStoreSlot.current !== storeSlot) {
     const slots2 = [];
     for (let i = 0; i < keysToHold.length; i++) {
-      slots2.push(slotCollectionService.getSlotByKey(storeSlot, keysToHold[i]));
+      slots2.push(storeSlot.slotService.getSlotByKey(storeSlot, keysToHold[i]));
     }
     resolvedSlots.current = slots2;
     resolvedKeys.current = keysToHold;
-    resolvedSlotCollectionService.current = slotCollectionService;
     resolvedStoreSlot.current = storeSlot;
   }
   const slots = resolvedSlots.current;
@@ -314,7 +314,7 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
     const heldSlots = [];
     let someKeyNamesAnotherIdentityNow = false;
     for (let i = 0; i < keysToHold.length; i++) {
-      const slot = slotCollectionService.holdSlotByKey(storeSlot, keysToHold[i]);
+      const slot = storeSlot.slotService.holdSlotByKey(storeSlot, keysToHold[i]);
       heldSlots.push(slot);
       if (slot !== renderedSlots?.[i]) someKeyNamesAnotherIdentityNow = true;
     }
@@ -328,26 +328,22 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
         heldSlot.owner.unholdSlot(heldSlot);
       }
     };
-  }, [slotCollectionService, storeSlot, keysToHold]);
+  }, [storeSlot, keysToHold]);
   return slots;
 }
 
 // src/useOIMComputedValueByKey.ts
-var import_core6 = require("@oimdb/core");
-var sourcesOfComputedSlot = (computedSlot) => [import_core6.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
-function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
-  const computedSlot = useOIMSlotByKey(
-    "useOIMComputedValueByKey",
-    computedCollectionService,
-    computedStoreSlot,
-    key,
-    sourcesOfComputedSlot
-  );
+var import_core7 = require("@oimdb/core");
+var sourcesOfComputedSlot = (computedSlot) => [import_core7.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
+function useOIMComputedValueByKey(computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey("useOIMComputedValueByKey", computedStoreSlot, key, sourcesOfComputedSlot);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
 // src/useOIMSingleComputedValue.ts
 var import_react11 = require("react");
+var import_core8 = require("@oimdb/core");
+var sourcesOfComputedSlot2 = (computedSlot) => [import_core8.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
 function useOIMSingleComputedValue(computedService, derive, createSources, dependencyList) {
   const db = useOIMDB();
   const computedStoreSlot = (0, import_react11.useMemo)(
@@ -355,11 +351,8 @@ function useOIMSingleComputedValue(computedService, derive, createSources, depen
     // eslint-disable-next-line react-hooks/exhaustive-deps -- the caller's list is checked at the call site
     [db, computedService, ...dependencyList]
   );
-  return useOIMComputedValueByKey(
-    computedService.computedCollectionService,
-    computedStoreSlot,
-    void 0
-  );
+  const computedSlot = useOIMSingleSlot("useOIMSingleComputedValue", computedStoreSlot, sourcesOfComputedSlot2);
+  return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
 // src/useOIMComputedCollection.ts

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { DependencyList } from 'react';
-import { OIMDB, TOIMSlot, TOIMComputedSlot, TOIMStoreKey, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMSingleSlotStore, TOIMBucketSlot, OIMSlotContentBucketService, TOIMEntityColumnName, TOIMColumnSlot, TOIMEntityColumnValue, TOIMIndexableSlot, OIMComputedService, TOIMComputedSources, TOIMComputedStoreSlot } from '@oimdb/core';
+import { OIMDB, TOIMSlot, TOIMComputedContentSlot, TOIMStoreKey, TOIMStoreSlot, TOIMEntitySlot, OIMSlotCollectionService, TOIMSingleSlotStore, TOIMEntityContentSlot, OIMSingleSlotService, TOIMBucketContentSlot, OIMSlotContentBucketService, TOIMEntityColumnName, OIMColumnSlotService, TOIMColumnSlot, OIMColumnSlotOwner, TOIMEntityColumnValue, TOIMBucketSlot, TOIMIndexableSlot, TOIMComputedSlot, OIMSingleComputedService, TOIMComputedSources, OIMComputedService, TOIMComputedStoreSlot } from '@oimdb/core';
 
 declare const OIMDBContext: React.Context<OIMDB | undefined>;
 
@@ -13,7 +13,7 @@ declare function useOIMDB(): OIMDB;
 
 type TOIMBinding<TValue> = {
     readonly sourceSlots?: readonly TOIMSlot[] | undefined;
-    readonly sourceComputeds?: readonly TOIMComputedSlot[] | undefined;
+    readonly sourceComputeds?: readonly TOIMComputedContentSlot[] | undefined;
     readonly derive: () => TValue;
 };
 
@@ -26,32 +26,36 @@ type TOIMBinding<TValue> = {
  */
 declare function useOIMValue<TValue>(binding: TOIMBinding<TValue>): TValue;
 
-declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedSlot<TValue>): TValue;
+declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedContentSlot<TValue>): TValue;
 
-declare function useOIMEntity<TEntity extends object, TKey = TOIMStoreKey, TStore = unknown>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, key: TKey): TEntity | undefined;
+declare function useOIMEntity<TEntity extends object, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, key: TKey): TEntity | undefined;
 
-declare function useOIMSingleEntity<TEntity extends object>(singleSlotService: Pick<OIMSingleSlotService<TOIMEntitySlot<TEntity, void>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntitySlot<TEntity, void>>, TOIMEntitySlot<TEntity, void>>): TEntity | undefined;
+declare function useOIMSingleEntity<TEntity extends object>(singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>, unknown, Pick<OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>>): TEntity | undefined;
 
-declare function useOIMSingleBucketSlots<TEntity extends object, TSlots = unknown>(singleSlotService: Pick<OIMSingleSlotService<TOIMBucketSlot<TSlots, void>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketSlot<TSlots, void>>, TOIMBucketSlot<TSlots, void>>): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMSingleBucketSlots<TEntity extends object, TSlots = unknown>(singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>, unknown, Pick<OIMSingleSlotService<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>>): readonly TOIMEntitySlot<TEntity>[];
 
 /**
  * One field of one identity. It cannot go through {@link useOIMValue}: a column identity is
  * minted INSIDE the subscription, so there is no root slot a binding could name. `slot` is an
  * ENTITY SLOT because an entity slot is what can be taken out from under this component — ../README.md.
  */
-declare function useOIMField<TEntity extends object, TName extends TOIMEntityColumnName<TEntity>, TKey = TOIMStoreKey>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, unknown, unknown, TName, TOIMColumnSlot>, 'getColumn'>, slot: TOIMEntitySlot<TEntity, TKey>, name: TName): TOIMEntityColumnValue<TEntity, TName> | undefined;
+declare function useOIMField<TEntity extends object, TName extends TOIMEntityColumnName<TEntity>, TKey extends NonNullable<unknown> = TOIMStoreKey>(entityCollectionService: {
+    readonly columnSlotService: Pick<OIMColumnSlotService<TOIMEntitySlot<TEntity, TKey>, TName, TOIMColumnSlot, OIMColumnSlotOwner<TOIMSlot, TOIMColumnSlot>>, 'getColumn'>;
+}, slot: TOIMEntitySlot<TEntity, TKey>, name: TName): TOIMEntityColumnValue<TEntity, TName> | undefined;
 
 /** A bucket's slots, copied out of the service's LIVE container, in the collection's order. */
-declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(bucketCollectionService: Pick<OIMSlotCollectionService<unknown, TOIMBucketSlot<TSlots>, unknown, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'slotContentService'>, bucketSlot: TOIMBucketSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(bucketCollectionService: {
+    readonly slotContentService: Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>;
+}, bucketSlot: TOIMBucketContentSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey = TOIMStoreKey, TStore = unknown>(bucketCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSlotByKey' | 'holdSlotByKey' | 'slotContentService'>, bucketStoreSlot: TOIMStoreSlot<TStore, TOIMBucketSlot<TSlots, TKey>>, key: TKey): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(bucketStoreSlot: TOIMStoreSlot<TStore, TOIMBucketSlot<TSlots, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSlotByKey' | 'holdSlotByKey' | 'slotContentService'>>, key: TKey): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMSlotsByKeys<TKey, TSlot extends TOIMIndexableSlot<TKey>, TStore = unknown>(slotCollectionService: Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, storeSlot: TOIMStoreSlot<TStore, TSlot>, keys: readonly TKey[]): readonly TSlot[];
+declare function useOIMSlotsByKeys<TKey extends NonNullable<unknown>, TSlot extends TOIMIndexableSlot<TKey>, TStore = unknown>(storeSlot: TOIMStoreSlot<TStore, TSlot, unknown, Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, keys: readonly TKey[]): readonly TSlot[];
 
-declare function useOIMComputedValueByKey<TValue, TKey = TOIMStoreKey, TStore = unknown>(computedCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>>, key: TKey): TValue;
+declare function useOIMComputedValueByKey<TValue, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, key: TKey): TValue;
 
-declare function useOIMSingleComputedValue<TValue>(computedService: OIMComputedService<void, TValue, TOIMSingleSlotStore<TOIMComputedSlot<TValue, void>>>, derive: ((computedSlot: TOIMComputedSlot<TValue, void>) => TValue) | undefined, createSources: ((key: void, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
+declare function useOIMSingleComputedValue<TValue>(computedService: OIMSingleComputedService<TValue>, derive: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
 
-declare function useOIMComputedCollection<TKey, TValue, TStore>(computedService: OIMComputedService<TKey, TValue, TStore>, derive: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TOIMComputedStoreSlot<TStore, TValue, TKey>;
+declare function useOIMComputedCollection<TKey extends NonNullable<unknown>, TValue, TStore>(computedService: OIMComputedService<TKey, TValue, TStore>, derive: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TOIMComputedStoreSlot<TStore, TValue, TOIMComputedSlot<TValue, TKey>, OIMComputedService<TKey, TValue, TStore>['computedCollectionService']>;
 
 export { OIMDBContext, OIMDBProvider, type TOIMBinding, useOIMBucketSlots, useOIMBucketSlotsByKey, useOIMComputedCollection, useOIMComputedValue, useOIMComputedValueByKey, useOIMDB, useOIMEntity, useOIMField, useOIMSingleBucketSlots, useOIMSingleComputedValue, useOIMSingleEntity, useOIMSlotsByKeys, useOIMValue };