akanjs 3.0.0-beta.8 → 3.0.0

package/store/agentic/useFormTools.ts

@@ -5,24 +5,7 @@ import { AgenticSurface, useScopePath, useSurface } from "../../vendor/use-agent
 import { useEffect, useRef } from "../hooks";
 import { FormFields } from "./formFields";
 
-/**
- * One tool that fills several fields of a form at once, published while a component subscribes `<model>Form`.
- *
- * The per-field setters are published by the controls themselves (`useFieldTool`), which is what keeps them to
- * the fields this screen draws. This one exists for what a control cannot reach: a list, a map, an embedded
- * object — the shapes a `st.tool` argument cannot describe one control at a time — and for filling a fresh form
- * in one call. It is a patch, not a replacement, so it never clears what the person already typed.
- *
- * Its schema is every writable field of the model, because a declaration is mount-static and cannot know which
- * controls will render. The **guard** is where the screen gets its say: a plain field has to have published its
- * own setter, and a composite is waved through because its rows are written with `writeOn<Model>(path, value)`,
- * which no control can annotate — so this is the one place an agent can reach a field the screen may not show.
- *
- * The entry is a pure function of `refName`: the schema comes from the model, the guard re-reads the live surface,
- * and every `write` reaches the one store instance. So a form put on screen by a shell that subscribes it
- * (`Model.EditModal`) and by the `Template` inside it registers one declaration twice — the same description both
- * times, which is what the surface reads as interchangeable rather than as a clash an app has to suppress.
- */
+/** Publishes `fill<Model>Form`: a patch over every writable field, gated per field by the controls on screen. */
 export const useFormTools = (refName: string | null, write: (action: string, value: unknown) => void) => {
   const surface = useSurface();
   const scope = useScopePath();
@@ -59,16 +42,16 @@ export const useFormTools = (refName: string | null, write: (action: string, val
         }.`;
       },
       run: (args) => {
-
+        
         const patch = Object.entries(args).map(([key, value]) => {
           const entry = byKey.get(key);
           if (!entry) throw new Error(`The ${refName} form has no field "${key}".`);
           return { entry, value: FormFields.checked(name, key, entry.field, value) };
         });
-
+        
         for (const { entry, value } of patch) {
           const control = surface.tool(AgenticSurface.fullName(scope, entry.action), scope);
-          if (control) void control.run({ value });
+          if (control?.run) void control.run({ value });
           else live.current(entry.action, value);
         }
       },

package/store/agentic/useRelationFieldTool.ts

@@ -10,25 +10,12 @@ import { FormFields } from "./formFields";
 export interface RelationFieldSource<T extends { id: string }> {
   /** Read live from the store rather than closed over: `load` below changes the list mid-call. */
   read: () => DataList<T>;
-  /** Loads the options an agent never opened the dropdown to fetch. */
   load: () => Promise<unknown> | unknown;
-  /** How one option reads to a person, so the agent can match what it sees on screen. */
   label: (model: T) => string;
   disabled?: boolean;
 }
 
-/**
- * The two tools a relation picker owes an agent: list the documents it can pick, then pick by id.
- *
- * `FormFields` publishes no schema for a relation, and it is right not to — the form holds the whole related
- * document, so an id would need a lookup the store does not do. The picker is where that lookup lives: it holds
- * the slice list, the loader, and the label each option renders with. So the field reaches an agent from the one
- * component that can resolve it, which is the rule every other control follows — the control is the declaration.
- *
- * Listing is its own tool because loading is its own step for a person too: the options arrive when the dropdown
- * opens, and an agent never opens it. Folding the load into the setter would leave an agent guessing ids in order
- * to learn them from the refusal.
- */
+/** A relation picker's two tools: list the pickable documents (loading them first), then set by id. */
 export const useRelationFieldTool = <T extends { id: string }>(
   onChange: unknown,
   { read, load, label, disabled }: RelationFieldSource<T>,
@@ -43,7 +30,7 @@ export const useRelationFieldTool = <T extends { id: string }>(
     if (!action || disabled) return;
     const ref = FormFields.ref(action);
     const target = ref && FormFields.relationOf(ref.field);
-
+    
     if (!ref || !target || FormFields.schema(ref.field)) return;
     const many = ref.field.arrDepth > 0;
     const nullable = !!ref.field.nullable && !many;

package/store/baseSt.ts

@@ -49,7 +49,6 @@ export class BaseStore extends store("base" as const, () => ({
     bottomSafeAreaColor: "var(--color-background, Canvas)",
   } as PageState,
   devMode: false,
-  deviceToken: "" as string,
   currentPath: "" as string,
 })) {
   setDevMode(value: boolean) {

package/store/databaseStateNames.ts

@@ -1,13 +1,5 @@
 import { capitalize } from "akanjs/common";
 
-/**
- * The state keys every model store holds, and which of the model's five classes each one is an instance of.
- *
- * Shared with the agent catalogue, which needs the class rather than the key: a value read out of the store is
- * masked by the model it belongs to, and `immerify` drops the constructor, so the live value cannot say what it is.
- * `modelForm` is the one that matters most — it is an `Input` holding whatever the user has typed, credentials
- * included, and it reaches the catalogue as a plain object.
- */
 export const databaseStateNames = (refName: string) => {
   const className = capitalize(refName);
   return {
@@ -24,7 +16,6 @@ export const databaseStateNames = (refName: string) => {
   };
 };
 
-/** Which of the model's classes each generated state key holds, for the keys that hold one at all. */
 export const databaseStateModelTypes = {
   model: "full",
   modelForm: "input",

package/store/draftStore.ts

@@ -11,13 +11,8 @@ const MAX_DRAFT_CHARS = 256_000;
 const DRAFT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_DRAFTS_PER_IDENTITY = 30;
 
-/**
- * The claims a re-issued token rewrites. Hashing them would rotate the identity on every silent refresh and
- * orphan the draft the user is still typing into.
- */
 const VOLATILE_CLAIMS = ["iat", "exp", "nbf", "jti"] as const;
 
-/** The fields a form carries from its row rather than from what the user typed. */
 const RECORD_STAMPS = new Set(["createdAt", "updatedAt", "removedAt"]);
 
 export interface DraftRecord {
@@ -37,12 +32,7 @@ interface NewScopeInput {
   routePath: string;
 }
 
-/**
- * Where a form draft lives and what identifies it.
- *
- * Every method that touches storage is async even though localStorage is not, so the backend can move to
- * IndexedDB — which a model with a large `visual` field will eventually force — without a caller changing.
- */
+/** Storage methods are async although localStorage is not, so the backend can move to IndexedDB unchanged. */
 export class DraftStore {
   static #warnedKeys = new Set<string>();
   static #persistenceRequested = false;
@@ -63,7 +53,6 @@ export class DraftStore {
     return (hash >>> 0).toString(16).padStart(8, "0");
   }
 
-  /** Key-sorted JSON, so two objects that differ only in insertion order hash the same. */
   static #stableStringify(value: unknown): string {
     if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
     if (Array.isArray(value)) return `[${value.map((item) => DraftStore.#stableStringify(item)).join(",")}]`;
@@ -74,13 +63,6 @@ export class DraftStore {
     return `{${entries.join(",")}}`;
   }
 
-  /**
-   * A seed reduced to what actually names a context: primitive leaves and relation ids.
-   *
-   * Dates are dropped because a `default: () => dayjs()` in the seed would give the same form a different key on
-   * every open, and a relation collapses to its id because the rest of the object is display data the caller may
-   * or may not have hydrated.
-   */
   static #canonicalSeed(value: unknown, depth = 0): unknown {
     if (value === null || value === undefined || typeof value === "function") return undefined;
     if (value instanceof Date || isDayjs(value)) return undefined;
@@ -96,13 +78,7 @@ export class DraftStore {
     return Object.fromEntries(entries);
   }
 
-  /**
-   * Who this browser is holding a draft for, derived from the auth token rather than from a domain field.
-   *
-   * `Account` guarantees `appName` and `environment` and nothing else — `userId` lives in the app's own `AddData`,
-   * so naming it here would key the draft on a field that may not exist and silently share one scope between two
-   * signed-in users. Hashing the whole payload picks up whatever the app did put there under whatever name.
-   */
+  /** Hashes the whole JWT payload: the claim naming the user lives in the app's own `AddData`, not in `Account`. */
   static identity(): string {
     if (typeof window === "undefined") return "anon";
     const jwt = getAuthToken();
@@ -112,7 +88,6 @@ export class DraftStore {
       for (const claim of VOLATILE_CLAIMS) delete payload[claim];
       return DraftStore.#hash8(DraftStore.#stableStringify(payload));
     } catch {
-      
       return "anon";
     }
   }
@@ -141,17 +116,11 @@ export class DraftStore {
     return immerify(modelRef, new modelRef().set(plain) as object);
   }
 
-  /** What the dirty check compares. Cheap enough to take once per debounce window, not once per keystroke. */
   static formHash(refName: string, form: object): string {
     return DraftStore.#hash8(DraftStore.#stableStringify(DraftStore.encodeForm(refName, form)));
   }
 
-  /**
-   * What two encoded forms holding the same values hash to, whatever record stamps they carry.
-   *
-   * The stamps come from the row rather than from the user, so a save the form made itself moves `updatedAt` and
-   * would otherwise make a draft look different from the record that already holds it.
-   */
+  /** Ignores the record stamps, which a form's own save moves. */
   static contentHash(encoded: Record<string, unknown>): string {
     const content = Object.fromEntries(Object.entries(encoded).filter(([key]) => !RECORD_STAMPS.has(key)));
     return DraftStore.#hash8(DraftStore.#stableStringify(content));
@@ -176,7 +145,6 @@ export class DraftStore {
       }
       return record;
     } catch {
-      
       await DraftStore.remove(key);
       return null;
     }
@@ -243,16 +211,7 @@ export class DraftStore {
     }
   }
 
-  /**
-   * Clears what a previous user left on this device, on noticing that the signed-in user changed.
-   *
-   * Called at boot and whenever a form arms a draft, which covers both a reload and a sign-out followed by a
-   * sign-in inside the same page session. The gap is a sign-out with no sign-in and no reload after it: those
-   * drafts sit under a key the next user's identity cannot address, and the TTL sweep takes them.
-   *
-   * A sign-out on its own reads as `anon`, and `anon` is never wiped — nothing distinguishes two anonymous
-   * users, so there is no previous one to clear.
-   */
+  /** Removes the previous identity's drafts once the signed-in identity changes; `anon`'s are never removed. */
   static async reconcileIdentity(): Promise<void> {
     const storage = DraftStore.#storage();
     if (!storage) return;
@@ -264,19 +223,11 @@ export class DraftStore {
       if (last === current) return;
       storage.setItem(key, current);
     } catch {
-      
       return;
     }
     if (last && last !== "anon") await DraftStore.removeIdentity(last);
   }
 
-  /**
-   * Asks the browser to stop counting this origin as evictable.
-   *
-   * A WKWebView drops "best effort" storage under pressure, which is exactly the moment a user's unsaved work
-   * would disappear. Requested once, after a write has actually succeeded — asking before there is anything to
-   * protect can surface a permission prompt for nothing.
-   */
   static #requestPersistence() {
     if (DraftStore.#persistenceRequested) return;
     DraftStore.#persistenceRequested = true;
@@ -313,7 +264,6 @@ export class DraftStore {
       const time = new Date((JSON.parse(raw) as DraftRecord).savedAt).getTime();
       return Number.isNaN(time) ? null : time;
     } catch {
-      
       return null;
     }
   }

package/store/formSetterNames.ts

@@ -1,12 +1,5 @@
 import { capitalize, lowerlize } from "akanjs/common";
 
-/**
- * The keys `makeFormSetter` publishes for one field of one model.
- *
- * Computed forward from the field metadata rather than parsed back out of a key: `set(.+)On(.+)` has more than one
- * reading whenever a field or a model name contains `On`, so any reader that has only the name must build the same
- * names here instead of taking one apart.
- */
 export const formSetterNames = (className: string, key: string) => {
   const classKeyName = capitalize(key);
   return {
@@ -16,20 +9,10 @@ export const formSetterNames = (className: string, key: string) => {
     addFieldOnModel: `add${classKeyName}On${className}`,
     subFieldOnModel: `sub${classKeyName}On${className}`,
     addOrSubFieldOnModel: `addOrSub${classKeyName}On${className}`,
-    /**
-     * The agent tool a drag-sortable list publishes. No store action answers to it: reordering *is* the whole-array
-     * write the drag already performs, so the tool splices the live rows and hands them to the same setter.
-     */
+    
     moveFieldOnModel: `move${classKeyName}On${className}`,
     uploadFieldOnModel: `upload${classKeyName}On${className}`,
-    /**
-     * The optional hook a store declares to run after this field is written.
-     *
-     * It carries no model suffix and a leading `_`, so it can never collide with a generated action name — which is
-     * the whole point: every generated action lives in a mapped type, and a mapped type produces *properties*, so a
-     * subclass method of the same name is a TS2425 error and there is no legal way to override one. A hook under a
-     * name the base type does not declare is the only shape TypeScript permits.
-     */
+    
     postSetField: `_postSet${classKeyName}`,
   };
 };

package/store/liveInsert.ts

@@ -1,42 +1,19 @@
-/** A row as placement compares it: the sorted fields, plus the base fields every model carries. */
 export type LiveSortableRow = { [key: string]: unknown };
 
 export interface LivePlacementProps {
-  /** The rows this window currently holds, in the order the server returned them. */
   list: LiveSortableRow[];
   row: LiveSortableRow;
-  /** Which page of the list is on screen. Only the first can place a row. */
   page: number;
   limit: number;
   /** Whether the list is pages `1..N` concatenated rather than one window. */
   cumulative: boolean;
-  /** Whether the server still holds rows past the ones in hand. */
   hasMore: boolean;
-  /** The sort key the window is ordered by. */
   sortKey: string;
   /** The sort keys the slice declared a subscriber may reproduce. */
   allowedSorts: string[];
-  /** Every sort key the model has, by the fields it orders on. */
   sorts: { [key: string]: { [path: string]: 1 | -1 } } | undefined;
 }
 
-/**
- * Where a newly arrived row belongs in this window, or null when that cannot be known and the list has to refetch.
- *
- * Three things have to hold, and each guards a different way of being wrong.
- *
- * The sort key must be one the slice allowlisted, because the client compares values with JavaScript and the server
- * ordered them with SQL — those agree for a real column and need not agree for a field inside the document, where
- * SQLite and Postgres do not even agree with each other. The allowlist is the slice author saying which sorts are
- * safe to reproduce, rather than the framework claiming all of them are.
- *
- * The page must be the first, because a window's index is not the list's index anywhere else. Inserting on page
- * three moves that page's boundary by one and the row pushed off its end belongs to page four, which never learns
- * it moved — so the next page opened shows a duplicate.
- *
- * And every sorted field has to be on the row, because a comparison against a value that is not there silently
- * places the row at one end.
- */
 export const livePlacementIndex = ({
   list,
   row,
@@ -53,37 +30,53 @@ export const livePlacementIndex = ({
   const sort = sorts?.[sortKey];
   if (!sort || !Object.keys(sort).length) return null;
   const paths = Object.entries(sort);
-  if (paths.some(([path]) => comparableOf(row[path]) === null)) return null;
-  const index = list.findIndex((item) => compareRows(row, item, paths) < 0);
+  if (paths.some(([path]) => comparableOf(row[path]) === undefined)) return null;
+  let orderable = true;
+  const index = list.findIndex((item) => {
+    const order = compareRows(row, item, paths);
+    orderable = order !== null;
+    return order === null || order < 0;
+  });
+  if (!orderable) return null;
   if (index !== -1) return index;
-
+  
   if (cumulative) return hasMore ? null : list.length;
   return list.length < limit ? list.length : null;
 };
 
-const compareRows = (left: LiveSortableRow, right: LiveSortableRow, paths: [string, 1 | -1][]): number => {
+const compareRows = (left: LiveSortableRow, right: LiveSortableRow, paths: [string, 1 | -1][]): number | null => {
   for (const [path, direction] of paths) {
-    const a = comparableOf(left[path]);
-    const b = comparableOf(right[path]);
-    if (a === null || b === null) continue;
-    if (a === b) continue;
-    return (a < b ? -1 : 1) * direction;
+    const order = compareValues(comparableOf(left[path]), comparableOf(right[path]));
+    if (order !== 0) return order === null ? null : order * direction;
   }
-  return 0;
+  const order = compareValues(comparableOf(left.id), comparableOf(right.id));
+  return order === null ? null : order * (paths.at(-1)?.[1] ?? -1);
+};
+
+const compareValues = (a: Comparable | undefined, b: Comparable | undefined): number | null => {
+  if (a === undefined || b === undefined) return null;
+  if (a === b) return 0;
+  if (a === null) return -1;
+  if (b === null) return 1;
+  if (typeof a === "string" && typeof b === "string") return compareText(a, b);
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  return null;
 };
 
-/**
- * The value to order by, or null when the row does not carry one.
- *
- * A model's date fields arrive as `Dayjs` rather than as a primitive, so they have to be taken through `valueOf`
- * before a comparison means anything — `<` on two objects compares their string forms.
- */
-const comparableOf = (value: unknown): number | string | null => {
-  if (value === null || value === undefined) return null;
+const compareText = (a: string, b: string) => {
+  let idx = 0;
+  while (idx < a.length && idx < b.length && a[idx] === b[idx]) idx += 1;
+  return (a.codePointAt(idx) ?? -1) < (b.codePointAt(idx) ?? -1) ? -1 : 1;
+};
+
+type Comparable = number | string | null;
+
+const comparableOf = (value: unknown): Comparable | undefined => {
+  if (value === null) return null;
   if (typeof value === "number" || typeof value === "string") return value;
   if (typeof value === "boolean") return value ? 1 : 0;
   if (value instanceof Date) return value.getTime();
-  const valued: unknown = (value as { valueOf?: () => unknown }).valueOf?.();
+  const valued: unknown = (value as { valueOf?: () => unknown } | undefined)?.valueOf?.();
   if (typeof valued === "number" || typeof valued === "string") return valued;
-  return null;
+  return undefined;
 };

package/store/sliceKeys.ts

@@ -0,0 +1,37 @@
+import { capitalize } from "akanjs/common";
+import type { SliceActionKey } from "./sliceRole";
+import type { SliceStateKey } from "./state";
+
+export const sliceKeysOf = (refName: string, suffix = "") => {
+  const [Model, Suffix] = [capitalize(refName), capitalize(suffix)];
+  const state: { [key in SliceStateKey]: string } = {
+    defaultModel: `default${Model}${Suffix}`,
+    modelInitList: `${refName}InitList${Suffix}`,
+    modelInsight: `${refName}Insight${Suffix}`,
+    modelList: `${refName}List${Suffix}`,
+    modelListLoading: `${refName}ListLoading${Suffix}`,
+    modelInitAt: `${refName}InitAt${Suffix}`,
+    modelStaleAt: `${refName}StaleAt${Suffix}`,
+    lastPageOfModel: `lastPageOf${Model}${Suffix}`,
+    pageOfModel: `pageOf${Model}${Suffix}`,
+    limitOfModel: `limitOf${Model}${Suffix}`,
+    hasMoreOfModel: `hasMoreOf${Model}${Suffix}`,
+    isCumulativeOfModel: `isCumulativeOf${Model}${Suffix}`,
+    queryArgsOfModel: `queryArgsOf${Model}${Suffix}`,
+    sortOfModel: `sortOf${Model}${Suffix}`,
+    modelSelection: `${refName}Selection${Suffix}`,
+  };
+  const action: { [key in SliceActionKey]: string } = {
+    initModel: `init${Model}${Suffix}`,
+    refreshModel: `refresh${Model}${Suffix}`,
+    selectModel: `select${Model}${Suffix}`,
+    setPageOfModel: `setPageOf${Model}${Suffix}`,
+    loadMoreOfModel: `loadMoreOf${Model}${Suffix}`,
+    setLimitOfModel: `setLimitOf${Model}${Suffix}`,
+    setQueryArgsOfModel: `setQueryArgsOf${Model}${Suffix}`,
+    setSortOfModel: `setSortOf${Model}${Suffix}`,
+    applyLiveModel: `applyLive${Model}${Suffix}`,
+    watchLiveModel: `watchLive${Model}${Suffix}`,
+  };
+  return { state, action };
+};

package/store/sliceRole.ts

@@ -1,7 +1,6 @@
 import type { SerializedArg } from "akanjs/signal";
 import type { SliceStateKey } from "./state";
 
-/** The generated slice actions, named by what they do rather than by the key any one slice publishes them under. */
 export type SliceActionKey =
   | "initModel"
   | "refreshModel"
@@ -14,15 +13,7 @@ export type SliceActionKey =
   | "applyLiveModel"
   | "watchLiveModel";
 
-/**
- * What a generated key on `st.do` / `st.use` actually is.
- *
- * A slice publishes its keys with the model and the suffix spliced into the role name — `setPageOfUserInOrg` for the
- * `setPageOfModel` role of `user`'s `inOrg` slice — and the splicing is string replacement over capitalized names.
- * Recording the role while the key is being built is what saves a reader of the finished store from running that
- * replacement backwards, which does not have one answer: on a model named `page`, `setPageOfPage` is both the
- * paging action and a field setter.
- */
+/** Recorded while the key is built: reversing the splice is ambiguous (`setPageOfPage` on a model named `page`). */
 export interface SliceActionRole {
   role: SliceActionKey;
   refName: string;

package/store/state.ts

@@ -1,5 +1,4 @@
 import { DataList } from "akanjs/base";
-import { capitalize } from "akanjs/common";
 import { ConstantRegistry, type DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
 import type {
@@ -15,19 +14,13 @@ import type {
   SliceCls,
 } from "akanjs/signal";
 import { databaseStateNames } from "./databaseStateNames";
+import { sliceKeysOf } from "./sliceKeys";
 import type { StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap, Submit } from "./types";
 
-/**
- * The open form's draft slot, armed by `new<Model>` / `edit<Model>` and cleared by a submit or a reset.
- *
- * `pending` is a draft that was read and deliberately *not* applied, which is the whole point: an edit form whose
- * record moved since the draft was taken shows a restore bar instead of replacing what the server just returned.
- * The form the editor opened with is kept outside the store — restoring it is what "start fresh" does, and a
- * secret field in it has no business in a value a component can subscribe to.
- */
+/** Armed by `new<Model>` / `edit<Model>`, cleared by a submit or a reset. */
 export interface DraftState {
   key: string;
-  /** The hash of the form as it was opened. A write only becomes a draft once the form moves off it. */
+  /** Hash of the form as opened; a write only becomes a draft once the form moves off it. */
   baseHash: string;
   /** The edited record's `updatedAt` at open time, or null for a new form. */
   baseUpdatedAt: string | null;
@@ -200,48 +193,9 @@ export const createDatabaseState = (refName: string) => {
 };
 export const createSliceState = (refName: string, slice: { [key: string]: SerializedSlice }) => {
   const cnst = ConstantRegistry.getDatabase(refName);
-  const [fieldName, className] = [refName, capitalize(refName)];
-  const names = {
-    model: fieldName,
-    Model: className,
-    defaultModel: `default${className}`,
-    defaultModelInsight: `default${className}Insight`,
-    modelList: `${fieldName}List`,
-    modelListLoading: `${fieldName}ListLoading`,
-    modelInitList: `${fieldName}InitList`,
-    modelInitAt: `${fieldName}InitAt`,
-    modelStaleAt: `${fieldName}StaleAt`,
-    modelSelection: `${fieldName}Selection`,
-    modelInsight: `${fieldName}Insight`,
-    lastPageOfModel: `lastPageOf${className}`,
-    pageOfModel: `pageOf${className}`,
-    limitOfModel: `limitOf${className}`,
-    hasMoreOfModel: `hasMoreOf${className}`,
-    isCumulativeOfModel: `isCumulativeOf${className}`,
-    queryArgsOfModel: `queryArgsOf${className}`,
-    sortOfModel: `sortOf${className}`,
-  };
   const sliceState: Record<string, unknown> = {};
   Object.entries(slice).forEach(([suffix]) => {
-    const sliceName = `${refName}${capitalize(suffix)}`;
-    const SliceName = capitalize(sliceName);
-    const namesOfSlice: { [key in SliceStateKey]: string } = {
-      defaultModel: SliceName.replace(names.Model, names.defaultModel), //clusterInSelf Cluster
-      modelList: sliceName.replace(names.model, names.modelList),
-      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-      modelInitList: sliceName.replace(names.model, names.modelInitList),
-      modelInitAt: sliceName.replace(names.model, names.modelInitAt),
-      modelStaleAt: sliceName.replace(names.model, names.modelStaleAt),
-      modelSelection: sliceName.replace(names.model, names.modelSelection),
-      modelInsight: sliceName.replace(names.model, names.modelInsight),
-      lastPageOfModel: SliceName.replace(names.Model, names.lastPageOfModel),
-      pageOfModel: SliceName.replace(names.Model, names.pageOfModel),
-      limitOfModel: SliceName.replace(names.Model, names.limitOfModel),
-      hasMoreOfModel: SliceName.replace(names.Model, names.hasMoreOfModel),
-      isCumulativeOfModel: SliceName.replace(names.Model, names.isCumulativeOfModel),
-      queryArgsOfModel: SliceName.replace(names.Model, names.queryArgsOfModel),
-      sortOfModel: SliceName.replace(names.Model, names.sortOfModel),
-    };
+    const namesOfSlice = sliceKeysOf(refName, suffix).state;
     const singleSliceState = {
       [namesOfSlice.defaultModel]: new cnst.full(),
       [namesOfSlice.modelList]: new DataList(),

package/store/stateBuilder.ts

@@ -41,12 +41,6 @@ export interface ComputedMeta {
   equals: (a: any, b: any) => boolean;
 }
 
-/**
- * One model's form-draft wiring, keyed by the form state key.
- *
- * The draft is not a builder-declared state — it comes with every model store — so the metadata is registered
- * where `createDatabaseState` runs rather than resolved out of a `persist()` marker.
- */
 export interface DraftMeta {
   refName: string;
   formKey: string;
@@ -158,14 +152,6 @@ export interface DerivedStateBuilder<WritableState> {
 
 const draftMetaByRefName = new Map<string, DraftMeta>();
 
-/**
- * The one `DraftMeta` for a model, memoized.
- *
- * Every field of it is derived from the refName, so two stores for the same model describe the same thing. They
- * have to describe it with the *same object*, though: an app store that extends a lib store for one model carries
- * the lib's copy and registers its own, and both reach `mergeDerivedMeta` — where an entry is a conflict only when
- * two declarations disagree, which is decided by identity.
- */
 export const draftMetaOf = (refName: string): DraftMeta => {
   const cached = draftMetaByRefName.get(refName);
   if (cached) return cached;
@@ -192,19 +178,11 @@ export const mergeDerivedMeta = (...metas: (StateDerivedMeta | undefined)[]): St
     mergeMetaRecord(merged.search, meta.search);
     mergeMetaRecord(merged.computed, meta.computed);
   }
-
+  
   for (const key of [...Object.keys(merged.search), ...Object.keys(merged.computed)]) merged.derivedKeys.add(key);
   return merged;
 };
 
-/**
- * Copies `source` over `target`, rejecting only a genuine conflict.
- *
- * The same key arriving twice is normal: a store lists another as a lib store, so it already carries that store's
- * metadata when both are registered and `StoreRegistry.merge` sees each of them. What arrives then is the very
- * object the first declaration produced, because merging copies the reference. Two *different* objects under one
- * key are two declarations claiming the same state, which is the mistake this is here to catch.
- */
 const mergeMetaRecord = <T>(target: Record<string, T>, source: Record<string, T>) => {
   for (const [key, value] of Object.entries(source)) {
     if (key in target) {