@oimdb/react 3.1.0 → 3.2.0

package/README.md

@@ -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,32 +128,32 @@ 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 `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)`.
+  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(singleSlotService, singleSlotStoreSlot)`** and
-  **`useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot)`**: the single entity and the single bucket.
+- **`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>`.
 
@@ -178,8 +179,8 @@ function TotalRank({ ids }: { ids: readonly string[] }) {
 
 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 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
+`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.
 
@@ -195,8 +196,8 @@ const pickedService = createOIMSingleSlotService({ slotContentService: new OIMSl
 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>;
 }
 ```
@@ -236,7 +237,7 @@ const rankService = createOIMComputedService<string, number>({
 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>;
 }
 ```

package/dist/index.cjs

@@ -142,8 +142,9 @@ function oimSubscribeHeldSlot(channelMap, hookName, snapshotVersion, 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) {
@@ -175,16 +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");
 var import_core4 = require("@oimdb/core");
 var sourcesOfRootSlot2 = (rootSlot) => [[rootSlot], import_core4.OIM_FROZEN_EMPTY_SLOTS];
-function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
+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;
@@ -207,14 +209,14 @@ function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot, sour
 }
 
 // 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
@@ -280,15 +282,15 @@ 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_core6 = require("@oimdb/core");
-function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+function useOIMSlotsByKeys(storeSlot, keys) {
   const settledKeys = (0, import_react10.useRef)(keys);
   const previousKeys = settledKeys.current;
   if (!(0, import_core6.oimSameKeySequence)(previousKeys, keys)) settledKeys.current = keys;
@@ -296,16 +298,14 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
   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,21 +328,15 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
         heldSlot.owner.unholdSlot(heldSlot);
       }
     };
-  }, [slotCollectionService, storeSlot, keysToHold]);
+  }, [storeSlot, keysToHold]);
   return slots;
 }
 
 // src/useOIMComputedValueByKey.ts
 var import_core7 = require("@oimdb/core");
 var sourcesOfComputedSlot = (computedSlot) => [import_core7.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
-function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
-  const computedSlot = useOIMSlotByKey(
-    "useOIMComputedValueByKey",
-    computedCollectionService,
-    computedStoreSlot,
-    key,
-    sourcesOfComputedSlot
-  );
+function useOIMComputedValueByKey(computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey("useOIMComputedValueByKey", computedStoreSlot, key, sourcesOfComputedSlot);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
@@ -357,12 +351,7 @@ 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]
   );
-  const computedSlot = useOIMSingleSlot(
-    "useOIMSingleComputedValue",
-    computedService.computedSingleSlotService,
-    computedStoreSlot,
-    sourcesOfComputedSlot2
-  );
+  const computedSlot = useOIMSingleSlot("useOIMSingleComputedValue", computedStoreSlot, sourcesOfComputedSlot2);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { DependencyList } from 'react';
-import { OIMDB, TOIMSlot, TOIMComputedContentSlot, TOIMStoreKey, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMEntityContentSlot, TOIMSingleSlotStore, TOIMBucketContentSlot, OIMSlotContentBucketService, TOIMEntityColumnName, OIMColumnSlotService, TOIMColumnSlot, OIMColumnSlotOwner, TOIMEntityColumnValue, TOIMBucketSlot, TOIMIndexableSlot, TOIMComputedSlot, OIMSingleComputedService, TOIMComputedSources, OIMComputedService, 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>;
 
@@ -28,11 +28,11 @@ declare function useOIMValue<TValue>(binding: TOIMBinding<TValue>): TValue;
 
 declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedContentSlot<TValue>): TValue;
 
-declare function useOIMEntity<TEntity extends object, TKey extends NonNullable<unknown> = 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<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>>): 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<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>>): 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
@@ -48,14 +48,14 @@ declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(buc
     readonly slotContentService: Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>;
 }, bucketSlot: TOIMBucketContentSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey extends NonNullable<unknown> = 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 extends NonNullable<unknown>, 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 extends NonNullable<unknown> = 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: OIMSingleComputedService<TValue>, derive: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
 
-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>>;
+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 };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { DependencyList } from 'react';
-import { OIMDB, TOIMSlot, TOIMComputedContentSlot, TOIMStoreKey, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMEntityContentSlot, TOIMSingleSlotStore, TOIMBucketContentSlot, OIMSlotContentBucketService, TOIMEntityColumnName, OIMColumnSlotService, TOIMColumnSlot, OIMColumnSlotOwner, TOIMEntityColumnValue, TOIMBucketSlot, TOIMIndexableSlot, TOIMComputedSlot, OIMSingleComputedService, TOIMComputedSources, OIMComputedService, 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>;
 
@@ -28,11 +28,11 @@ declare function useOIMValue<TValue>(binding: TOIMBinding<TValue>): TValue;
 
 declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedContentSlot<TValue>): TValue;
 
-declare function useOIMEntity<TEntity extends object, TKey extends NonNullable<unknown> = 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<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>>): 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<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>>): 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
@@ -48,14 +48,14 @@ declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(buc
     readonly slotContentService: Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>;
 }, bucketSlot: TOIMBucketContentSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey extends NonNullable<unknown> = 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 extends NonNullable<unknown>, 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 extends NonNullable<unknown> = 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: OIMSingleComputedService<TValue>, derive: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
 
-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>>;
+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 };

package/dist/index.js

@@ -102,8 +102,9 @@ function oimSubscribeHeldSlot(channelMap, hookName, snapshotVersion, holdingSlot
 
 // src/useOIMSlotByKey.ts
 var sourcesOfRootSlot = (rootSlot) => [[rootSlot], OIM_FROZEN_EMPTY_SLOTS2];
-function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
+function useOIMSlotByKey(hookName, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
   const db = useOIMDB();
+  const slotCollectionService = storeSlot.slotService;
   const lastSeenKeyRef = useRef(key);
   const settledKeyRef = useRef(key);
   if (key !== lastSeenKeyRef.current) {
@@ -135,16 +136,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
 import { useMemo as useMemo4 } from "react";
 import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS3 } from "@oimdb/core";
 var sourcesOfRootSlot2 = (rootSlot) => [[rootSlot], OIM_FROZEN_EMPTY_SLOTS3];
-function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
+function useOIMSingleSlot(hookName, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
   const db = useOIMDB();
+  const singleSlotService = singleSlotStoreSlot.slotService;
   const store = useMemo4(() => {
     const snapshotVersion = new OIMSnapshotVersion();
     let subscribedSlot = void 0;
@@ -167,14 +169,14 @@ function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot, sour
 }
 
 // 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
@@ -240,15 +242,15 @@ 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
 import { useEffect, useRef as useRef2, useState } from "react";
 import { oimSameKeySequence } from "@oimdb/core";
-function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+function useOIMSlotsByKeys(storeSlot, keys) {
   const settledKeys = useRef2(keys);
   const previousKeys = settledKeys.current;
   if (!oimSameKeySequence(previousKeys, keys)) settledKeys.current = keys;
@@ -256,16 +258,14 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
   const [, resolveAgain] = useState(0);
   const resolvedSlots = useRef2(void 0);
   const resolvedKeys = useRef2(keysToHold);
-  const resolvedSlotCollectionService = useRef2(slotCollectionService);
   const resolvedStoreSlot = useRef2(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;
@@ -274,7 +274,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;
     }
@@ -288,21 +288,15 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
         heldSlot.owner.unholdSlot(heldSlot);
       }
     };
-  }, [slotCollectionService, storeSlot, keysToHold]);
+  }, [storeSlot, keysToHold]);
   return slots;
 }
 
 // src/useOIMComputedValueByKey.ts
 import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS4 } from "@oimdb/core";
 var sourcesOfComputedSlot = (computedSlot) => [OIM_FROZEN_EMPTY_SLOTS4, [computedSlot]];
-function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
-  const computedSlot = useOIMSlotByKey(
-    "useOIMComputedValueByKey",
-    computedCollectionService,
-    computedStoreSlot,
-    key,
-    sourcesOfComputedSlot
-  );
+function useOIMComputedValueByKey(computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey("useOIMComputedValueByKey", computedStoreSlot, key, sourcesOfComputedSlot);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
@@ -317,12 +311,7 @@ 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]
   );
-  const computedSlot = useOIMSingleSlot(
-    "useOIMSingleComputedValue",
-    computedService.computedSingleSlotService,
-    computedStoreSlot,
-    sourcesOfComputedSlot2
-  );
+  const computedSlot = useOIMSingleSlot("useOIMSingleComputedValue", computedStoreSlot, sourcesOfComputedSlot2);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 

package/llms.txt

@@ -697,7 +697,7 @@ derivation survives a settle, is the SAME instance on the next read (built once)
 is rebuilt only after the arena is flushed, and `open`/`close` nest so an inner
 scope ending drops nothing an outer one stands on.
 
-`@oimdb/react`'s `useOIMSlotsByKeys(slotCollectionService, storeSlot, keys)` does not use an arena: it takes a
+`@oimdb/react`'s `useOIMSlotsByKeys(storeSlot, keys)` does not use an arena: it takes a
 plain `holdSlotByKey` per key on commit and gives the same holds back on unmount or when the key list moves.
 
 ```ts signature
@@ -790,10 +790,6 @@ type TOIMDBOptions = {
     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
-    entityWriter?: IOIMEntityWriter;            // default entity writer for every entity factory
-    indexKeysService?: IOIMIndexKeysService;
-    slotStamp?: IOIMSlotStamp<TOIMSlot>;
-    slotReleasePolicy?: IOIMSlotReleasePolicy;  // default release policy for every factory
 };
 
 db.clock               // TOIMChannelClock, the same object as db.defaultChannelSlot.clock
@@ -1176,9 +1172,8 @@ 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 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,
+The doors are free functions, one module each, so a consumer ships only the one they import. Every factory
+takes ONE options object and no `db`; the `db` goes to `createStoreSlot(db)`. Each builds a SERVICE,
 once per collection type; the store slot is made separately:
 
 | Door | Builds | Store slot |
@@ -1192,8 +1187,36 @@ once per collection type; the store slot is made separately:
 | `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.
+`entityWriter` and `slotReleasePolicy` on these doors default to those of the
+`defaults` option, so naming one overrides it for that service alone.
+
+**A store aggregate is the store slot with its store methods, so a call does not pass the store slot.**
+`service.createStoreAggregate(storeSlot)` wraps a store slot you have (the collection, single and index
+services each return their own aggregate); `createOIMSlotCollectionStoreAggregate(db, options)` and
+`createOIMSingleSlotStoreAggregate(db, options)` build service + store slot + aggregate in one call, with the
+options of `createOIMSlotCollectionService` / `createOIMSingleSlotService` (a new service per call: for many
+store slots of one type, build the service once).
+
+```ts
+import { createOIMSlotCollectionStoreAggregate } from '@oimdb/core';
+
+const deckStoreAggregate = createOIMSlotCollectionStoreAggregate(db, { slotContentService: createOIMSlotContentEntityService<Card>() });
+const aceSlot = deckStoreAggregate.writeSlotContentByKey('c1', { id: 'c1', title: 'Ace', rank: 1, deck: 'spades' });   // = service.writeSlotContentByKey(storeSlot, 'c1', …)
+deckStoreAggregate.slotContentService.updateEntity(aceSlot, { rank: 14 });
+deckStoreAggregate.storeSlot;      // for hooks, indexes and computeds
+deckStoreAggregate.slotService;    // the service itself
+```
+
+| Aggregate | Methods (the service's, minus the store slot argument) |
+|---|---|
+| `OIMSlotCollectionStoreAggregate` | `findSlotByKey`, `hasSlotContentByKey`, `getSlotByKey`, `holdSlotByKey`, `getSlots`, `getSlotCount`, `openBatch`, `closeBatch`, `writeInBatch` |
+| `OIMWritableSlotCollectionStoreAggregate` | + `writeSlotContentByKey` |
+| `OIMSingleSlotStoreAggregate` | `findSingleSlot`, `hasSingleSlotContent`, `getSingleSlot`, `holdSingleSlot` |
+| `OIMWritableSingleSlotStoreAggregate` | + `writeSingleSlotContent`, `clearSingleSlotContent` |
+| `OIMSlotCollectionIndexStoreAggregate` | the collection methods + `getEntitiesByKey`, `getSlotsByKeys`, `holdSlotsByKeys`, `get/holdBucketColumnByKey`, `get/holdAnyBucketColumnByKey`, `disposeIndexStoreSlot` |
+
+Every aggregate carries `storeSlot`, `slotService` (typed as the service it came from), `slotContentService`.
+Methods that take a slot stay on their service.
 
 **A DOOR ALWAYS PASSES; IT NEVER LETS A CLASS REACH FOR A GLOBAL.** Every option
 a service would otherwise answer with `?? OIMDefaults.x` is in the object its
@@ -3085,7 +3108,11 @@ that matches what you are comparing; they are not interchangeable.
 
 ## Full export list
 
-**230 names, every export of `packages/core/src/index.ts`, grouped by topic.**
+**237 names, every export of `packages/core/src/index.ts`, grouped by topic.**
+
+*Store aggregates* — `OIMSlotCollectionStoreAggregate` · `OIMWritableSlotCollectionStoreAggregate` ·
+`OIMSingleSlotStoreAggregate` · `OIMWritableSingleSlotStoreAggregate` · `OIMSlotCollectionIndexStoreAggregate` ·
+`createOIMSlotCollectionStoreAggregate` · `createOIMSingleSlotStoreAggregate`
 
 *Channel and database slots* — `OIMChannelService` · `TOIMChannelSlot` · `TOIMChannelSlotOptions` · `createOIMChannelSlot` ·
 `IOIMChannelMap` · `TOIMDBOptions` · `OIMFlushSchedulerService` · `TOIMFlushSchedulerSlot` · `IOIMFlushSchedulerListener`
@@ -3241,18 +3268,19 @@ source before generating code against it.
 `@oimdb/react` — `<OIMDBProvider db={db}>` carries the `OIMDB` (`useOIMDB()`) and nothing else: the effect
 service is stateless (`OIMEffectService.INSTANCE`) and every hook subscribes with
 `OIMEffectService.INSTANCE.subscribeEffect(db, …)`. A hook that resolves or takes a slot filed on another `OIMDB`
-throws, since nothing below would wake. Every hook that reads a collection takes the collection service, typed as a
-`Pick` of `OIMSlotCollectionService` with only the members it calls, and then the store slot:
-`useOIMEntity(entityCollectionService, entityStoreSlot, key)`,
-`useOIMField(entityCollectionService, slot, name)` (calls `getColumn(slot, name)`; no store slot, the slot carries it),
-`useOIMBucketSlots(bucketCollectionService, bucketSlot)` and
-`useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key)` (both read
-`bucketCollectionService.slotContentService.getBucketMemberSlots`; an index service and its index store slot fit too), and
+throws, since nothing below would wake. 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 it calls (a store aggregate passes its `storeSlot`):
+`useOIMEntity(entityStoreSlot, key)` and
+`useOIMBucketSlotsByKey(bucketStoreSlot, key)` (reads `bucketStoreSlot.slotService.slotContentService.getBucketMemberSlots`;
+an index store slot fits too). The hooks over a slot you already hold take the service and the slot:
+`useOIMField(entityCollectionService, slot, name)` (calls `getColumn(slot, name)`),
+`useOIMBucketSlots(bucketCollectionService, bucketSlot)`, and
 `useOIMValue(binding)`, where a binding is `{ sourceSlots?, sourceComputeds?, derive }` (a missing list means none)
 and must keep its identity across renders.
 `useOIMComputedValue(computedSlot: TOIMComputedSlot<TValue>): TValue` is the one-computed case: it subscribes to
 the slot, settles it and reads `computedSlot.value`, with no binding to memoise.
-`useOIMComputedValueByKey(computedService.computedCollectionService, computedStoreSlot, key)` reads one key of a
+`useOIMComputedValueByKey(computedStoreSlot, key)` reads one key of a
 computed store slot (plain, sorted, bucket memo) with the same by-key body as `useOIMEntity` /
 `useOIMBucketSlotsByKey`: resolve on commit with `holdSlotByKey`, effect over that slot, resolve-hold given back,
 a key built inline settled by meaning.
@@ -3261,16 +3289,15 @@ 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 `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
+service built with `createOIMSingleComputedService`, its slot read through the store slot's single slot service,
+so a flush between render and subscribe is safe.
+`useOIMSlotsByKeys(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: `createOIMSingleSlotService({ 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
+`useOIMSingleEntity(singleSlotStoreSlot): TEntity | undefined` and
+`useOIMSingleBucketSlots(singleSlotStoreSlot): readonly TOIMEntitySlot<TEntity>[]` — the by-key
 mechanics without a key (getSingleSlot on render, holdSingleSlot on commit, resolve-hold given back once the
 effect exists; the bucket members are copied per render). See `packages/react/README.md`.
 
@@ -4013,7 +4040,7 @@ createOIMBrowserLocationSingleSlotService(options?): TOIMBrowserSingleSlotServic
 ```
 
 Read it like any single: `const onlineSlot = onlineService.getSingleSlot(onlineService.createStoreSlot(db))`, then
-an effect over `[onlineSlot]`, or `useOIMSingleEntity(onlineService, online)` in React. `isOnline` is
+an effect over `[onlineSlot]`, or `useOIMSingleEntity(online)` in React. `isOnline` is
 `navigator.onLine` (a network interface exists, not a reachable internet); the location follows the
 Navigation API's `currententrychange` where it exists and `popstate` + `hashchange` otherwise, so without it a
 `history.pushState` is not seen until the next of those events. Without the API a sensor needs, the slot holds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oimdb/react",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "React bindings for @oimdb/core: hooks that subscribe through OIMChannel and read the slots it wakes.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -30,7 +30,7 @@
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
-    "@oimdb/core": "^4.2.0"
+    "@oimdb/core": "^4.3.0"
   },
   "license": "MIT",
   "author": "Andrei Baikov",