akanjs 3.0.0-beta.2 → 3.0.0-beta.21

package/types/store/agentic/useFieldTool.d.ts

@@ -1,22 +1,25 @@
 export interface FieldToolOptions {
-    /** The control's own normalizer. Applied to the agent's write exactly as it is to the person's typing. */
+    /** Applied to the agent's write exactly as to the person's typing. */
     transform?: unknown;
-    /** True while the person cannot use the control. Publishes nothing, so the agent gets no lever the screen withholds. */
+    /** While true, nothing is published. */
     disabled?: boolean;
-    /** The person can drag entries into a new order, so `move<Field>On<Model>` is a lever the screen really has. */
+    /** Also publishes `move<Field>On<Model>`, for a list the person can drag. */
     sortable?: boolean;
 }
-/**
- * Publishes the setter a form control is already holding, for exactly as long as the control is usable.
- *
- * The control is the declaration — the same rule the rest of the surface follows. A handler passed by reference
- * (`onChange={st.do.setTitleOnTask}`) names the field it writes, so the tool and the person press one function;
- * an inline arrow names nothing and publishes nothing, which is the existing `data-akan-action` rule with
- * consequences. Publishing from the form's subscription instead would offer every field of the model, including
- * the ones this template draws no control for.
- *
- * `disabled` withdraws the tool for the same reason the whole surface is declaration-only: a field the person
- * cannot type into is not one an agent may write in their place. It also closes the field to `fill<Model>Form`,
- * whose guard offers only what a control published — so one gate covers both writers.
- */
+/** Publishes a by-reference setter while its control is usable; `disabled` also closes it to `fill<Model>Form`. */
 export declare const useFieldTool: (onChange: unknown, { transform, disabled, sortable }?: FieldToolOptions) => void;
+export interface FileFieldSource<T extends {
+    id: string;
+}> {
+    /** Read live on every call. Omitted publishes nothing. */
+    read?: () => readonly T[];
+    label: (file: T) => string;
+    /** The list's cap; nothing derives it from the field, so without it the limit is only the server's `Err`. */
+    max?: number;
+    min?: number;
+    disabled?: boolean;
+}
+/** Lists offered files and sets the field by id; `add`/`sub` are the only way to keep files `read` does not offer. */
+export declare const useFileFieldTool: <T extends {
+    id: string;
+}>(onChange: unknown, { read, label, max, min, disabled }: FileFieldSource<T>) => void;

package/types/store/agentic/useFormTools.d.ts

@@ -1,19 +1,2 @@
-/**
- * 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 declare const useFormTools: (refName: string | null, write: (action: string, value: unknown) => void) => void;

package/types/store/agentic/useRelationFieldTool.d.ts

@@ -4,24 +4,11 @@ export interface RelationFieldSource<T extends {
 }> {
     /** 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 declare const useRelationFieldTool: <T extends {
     id: string;
 }>(onChange: unknown, { read, load, label, disabled }: RelationFieldSource<T>) => void;

package/types/store/baseSt.d.ts

@@ -35,7 +35,6 @@ declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, unknown, any, unknown, import("./stateBuilder.d.ts").WritableStateOf<{
     csrLoaded: boolean;
@@ -60,7 +59,6 @@ declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, any, any, any, any, any, any, any, any>;
 export declare class BaseStore extends BaseStore_base {
@@ -95,7 +93,6 @@ declare const RootStore_base: import("./rootStore.d.ts").RootStoreCls<"root", im
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, Omit<BaseStore, "slice" | keyof import("./types.d.ts").SetGet<any>>, {
     [x: `base${Capitalize<string>}`]: {
@@ -154,7 +151,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>, prev: import("./stateBuilder.d.ts").WritableStateOf<{
             csrLoaded: boolean;
@@ -179,7 +175,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>) => void): () => void;
         <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
@@ -205,7 +200,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>) => U, listener: (state: U, prev: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
@@ -235,7 +229,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => U) => import("react").RefObject<U>;
     sel: <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
@@ -261,7 +254,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => U, equals?: ((a: U, b: U) => boolean) | undefined) => U;
     use: {
@@ -276,7 +268,7 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         innerWidth: (options?: import("./types.d.ts").StoreUseOptions) => number;
         innerHeight: (options?: import("./types.d.ts").StoreUseOptions) => number;
         responsive: (options?: import("./types.d.ts").StoreUseOptions) => "xl" | "lg" | "md" | "sm" | "xs";
-        uiOperation: (options?: import("./types.d.ts").StoreUseOptions) => "loading" | "idle" | "sleep";
+        uiOperation: (options?: import("./types.d.ts").StoreUseOptions) => "idle" | "loading" | "sleep";
         messages: (options?: import("./types.d.ts").StoreUseOptions) => {
             type: "info" | "success" | "error" | "warning" | "loading";
             content: string;
@@ -292,7 +284,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: (options?: import("./types.d.ts").StoreUseOptions) => number;
         pageState: (options?: import("./types.d.ts").StoreUseOptions) => PageState;
         devMode: (options?: import("./types.d.ts").StoreUseOptions) => boolean;
-        deviceToken: (options?: import("./types.d.ts").StoreUseOptions) => string;
         currentPath: (options?: import("./types.d.ts").StoreUseOptions) => string;
     };
     do: import("./types.d.ts").VoidActions<RootStore> & {
@@ -307,7 +298,7 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         setInnerWidth: (value: number) => void;
         setInnerHeight: (value: number) => void;
         setResponsive: (value: "xl" | "lg" | "md" | "sm" | "xs") => void;
-        setUiOperation: (value: "loading" | "idle" | "sleep") => void;
+        setUiOperation: (value: "idle" | "loading" | "sleep") => void;
         setMessages: (value: {
             type: "info" | "success" | "error" | "warning" | "loading";
             content: string;
@@ -323,7 +314,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         setKeyboardHeight: (value: number) => void;
         setPageState: (value: PageState) => void;
         setDevMode: (value: boolean) => void;
-        setDeviceToken: (value: string) => void;
         setCurrentPath: (value: string) => void;
     };
     get: () => import("./stateBuilder.d.ts").WritableStateOf<{
@@ -349,7 +339,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>;
     set: (state: Partial<import("./stateBuilder.d.ts").WritableStateOf<{
@@ -375,7 +364,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>> | ((state: import("./stateBuilder.d.ts").WritableStateOf<{
         csrLoaded: boolean;
@@ -400,7 +388,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => any)) => void;
     slice: {

package/types/store/databaseStateNames.d.ts

@@ -1,11 +1,3 @@
-/**
- * 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 declare const databaseStateNames: (refName: string) => {
     model: string;
     modelLoading: string;
@@ -18,7 +10,6 @@ export declare const databaseStateNames: (refName: string) => {
     modelOperation: string;
     defaultModel: string;
 };
-/** Which of the model's classes each generated state key holds, for the keys that hold one at all. */
 export declare const databaseStateModelTypes: {
     readonly model: "full";
     readonly modelForm: "input";

package/types/store/draftStore.d.ts

@@ -13,35 +13,18 @@ interface NewScopeInput {
     sliceName: string;
     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 declare class DraftStore {
     #private;
-    /**
-     * 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;
     static editScope(modelId: string): string;
     static newScope({ seed, modal, sliceName, routePath }: NewScopeInput): string;
     static keyOf(refName: string, scope: string, identity?: string): string;
     static encodeForm(refName: string, form: object): Record<string, unknown>;
     static decodeForm(refName: string, plain: Record<string, unknown>): 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;
-    /**
-     * 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;
     static read(key: string): Promise<DraftRecord | null>;
     static write(key: string, record: DraftRecord): Promise<void>;
@@ -49,16 +32,7 @@ export declare class DraftStore {
     /** Every draft held for one identity. Called on sign-out, so a shared device leaves nothing for the next user. */
     static removeIdentity(identity?: string): Promise<void>;
     static sweep(): Promise<void>;
-    /**
-     * 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 reconcileIdentity(): Promise<void>;
 }
 export {};

package/types/store/formSetterNames.d.ts

@@ -1,10 +1,3 @@
-/**
- * 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 declare const formSetterNames: (className: string, key: string) => {
     field: string;
     Field: string;
@@ -12,19 +5,7 @@ export declare const formSetterNames: (className: string, key: string) => {
     addFieldOnModel: string;
     subFieldOnModel: string;
     addOrSubFieldOnModel: string;
-    /**
-     * 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: string;
     uploadFieldOnModel: string;
-    /**
-     * 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: string;
 };

package/types/store/hooks.d.ts

@@ -1 +1 @@
-export { useEffect, useRef, useSyncExternalStore } from "react";
+export { useContext, useEffect, useRef, useSyncExternalStore } from "react";

package/types/store/liveInsert.d.ts

@@ -1,44 +1,21 @@
-/** 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 declare const livePlacementIndex: ({ list, row, page, limit, cumulative, hasMore, sortKey, allowedSorts, sorts, }: LivePlacementProps) => number | null;

package/types/store/sliceKeys.d.ts

@@ -0,0 +1,31 @@
+export declare const sliceKeysOf: (refName: string, suffix?: string) => {
+    state: {
+        defaultModel: string;
+        modelInsight: string;
+        modelList: string;
+        modelListLoading: string;
+        modelInitList: string;
+        modelInitAt: string;
+        modelStaleAt: string;
+        modelSelection: string;
+        lastPageOfModel: string;
+        pageOfModel: string;
+        limitOfModel: string;
+        hasMoreOfModel: string;
+        isCumulativeOfModel: string;
+        queryArgsOfModel: string;
+        sortOfModel: string;
+    };
+    action: {
+        initModel: string;
+        refreshModel: string;
+        selectModel: string;
+        setPageOfModel: string;
+        loadMoreOfModel: string;
+        setLimitOfModel: string;
+        setQueryArgsOfModel: string;
+        setSortOfModel: string;
+        applyLiveModel: string;
+        watchLiveModel: string;
+    };
+};

package/types/store/sliceRole.d.ts

@@ -1,16 +1,7 @@
 import type { SerializedArg } from "akanjs/signal";
 import type { SliceStateKey } from "./state.d.ts";
-/** 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" | "selectModel" | "setPageOfModel" | "loadMoreOfModel" | "setLimitOfModel" | "setQueryArgsOfModel" | "setSortOfModel" | "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/types/store/state.d.ts

@@ -3,17 +3,10 @@ import { type DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
 import type { SerializedSlice, SlceCnstCapitalizedRefName, SlceCnstDefault, SlceCnstFull, SlceCnstInsight, SlceCnstLight, SlceCnstRefName, SlceDbFilter, SlceDbSort, SliceCls } from "akanjs/signal";
 import type { StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap, Submit } from "./types.d.ts";
-/**
- * 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;

package/types/store/stateBuilder.d.ts

@@ -24,12 +24,6 @@ export interface ComputedMeta {
     selector: (...values: any[]) => any;
     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;
@@ -132,14 +126,6 @@ export interface DerivedStateBuilder<WritableState> {
         options: ComputedOptions<Result>;
     };
 }
-/**
- * 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 declare const draftMetaOf: (refName: string) => DraftMeta;
 export declare const createEmptyDerivedMeta: () => StateDerivedMeta;
 export declare const mergeDerivedMeta: (...metas: (StateDerivedMeta | undefined)[]) => StateDerivedMeta;

package/types/store/storeInstance.d.ts

@@ -37,36 +37,22 @@ export declare class StoreInstance {
     slice: {
         [key: string]: unknown;
     };
-    /**
-     * How many mounted components are reading each state key right now. `st.use.*` is a hook, so subscription is
-     * presence — this is how an agent context knows which keys the screen is actually built from.
-     */
+    /** How many mounted components read each state key right now. */
     get liveKeys(): ReadonlyMap<string, number>;
-    /**
-     * The live keys as one zone view sees them: retentions tagged at the view's scope or below. The empty view is the
-     * whole screen. Zones are views, not walls — a key read inside a zone counts for that zone and for the root alike.
-     */
+    /** Live keys retained at `viewKey`'s scope or below; `""` is the whole screen. */
     liveKeysIn(viewKey: string): ReadonlyMap<string, number>;
-    /** Which module declared each action. See `ActionOwner`. */
     get actionOwners(): ReadonlyMap<string, ActionOwner>;
-    /**
-     * How many arguments each action declares.
-     *
-     * Recorded because `do[key]` is a rest-argument wrapper around the real method, so its own `length` is zero for
-     * everything — the arity is gone by the time anyone holding the instance could ask. A rest parameter on the method
-     * itself still reads as zero; nothing can recover that.
-     */
+    /** Each method's own `length`: `do[key]` is a rest-argument wrapper whose `length` is 0. */
     get actionArity(): ReadonlyMap<string, number>;
-    /** What each generated slice key is, for a reader that has only the finished store. See `SliceActionRole`. */
     get sliceActionRoles(): ReadonlyMap<string, SliceActionRole>;
     get sliceStateRoles(): ReadonlyMap<string, SliceStateRole>;
-    /** Keys the store materializes from a computation, the URL, or storage. `set` throws on them. */
+    /** `search()` and `computed()` keys; `set` throws on them. */
     get derivedKeys(): ReadonlySet<string>;
-    /** The `set<Key>` conveniences `#extendAccessors` writes for every plain state key. Their value is untyped. */
+    /** The generated `set<Key>` setters for plain state keys; their value is untyped. */
     get generatedSetters(): ReadonlySet<string>;
     constructor(store?: RootStoreCls);
     addStore(store: RootStoreCls): this;
-    /** Lands every pending write before the page or the app goes away. */
+    /** Writes every pending draft now, cancelling its debounce. */
     flushDrafts: () => void;
 }
 export {};

package/types/store/storeRegistry.d.ts

@@ -7,11 +7,9 @@ import type { SetGet } from "./types.d.ts";
 import type { WithSelectors } from "./withSelector.d.ts";
 export declare class StoreRegistry {
     #private;
-    /** The one store every `st.use` / `st.do` in the process goes through. What an agent bridge drives. */
     static get instance(): StoreInstance;
     static register<StrCls extends StoreCls>(store: StrCls): StrCls;
     static get(refName: string): StoreCls | undefined;
-    /** Every registered module store by refName. What the agent surface derives key ownership and exposure from. */
     static get stores(): ReadonlyMap<string, StoreCls>;
     static merge<RefName extends string, StoreClses extends (StoreCls | RootStoreCls)[]>(refName: RefName, ...stores: StoreClses): RootStoreCls<RefName, MergeAllKeyOfObjects<StoreClses, typeof STATE_META>, MergeAllTypes<StoreClses, keyof SetGet | "slice">, MergeAllKeyOfTypes<StoreClses, "slice">, MergeAllKeyOfObjects<StoreClses, "_slice">>;
     static build<RtStoreCls extends RootStoreCls>(store: RtStoreCls): WithSelectors<RtStoreCls>;

package/types/test/conformance.d.ts

@@ -0,0 +1,73 @@
+import { LibsqlDatabase, PostgresDatabase, RedisCache, type SearchConfig, SolidCache, type SqlDialect, SqliteDatabase } from "akanjs/service";
+type ConformanceBackend = "redis" | "postgres" | "libsql";
+export type ConformanceCacheKind = "solid" | "redis";
+/** `libsqlRemote` is a sqld server shared by every run, so it only hosts cases that bring their own table. */
+export type SqlDriverKind = "sqlite" | "libsql" | "postgres" | "libsqlRemote";
+export interface SqlDriverOptions {
+    insight?: boolean;
+    memory?: boolean;
+    search?: SearchConfig;
+}
+export interface SqlDriver {
+    kind: SqlDriverKind;
+    database: SqliteDatabase | LibsqlDatabase | PostgresDatabase;
+    dialect: SqlDialect;
+    /** A new adaptor on the same storage — what a process restart sees, so only what was committed. */
+    restart: () => Promise<SqlDriver>;
+    /** A second adaptor on the same storage while this one stays open: another process, with these search settings. */
+    sibling: (search?: SearchConfig) => Promise<SqlDriver>;
+    /** A restart with other text search settings — a redeploy that changed `AKAN_SEARCH_*`. */
+    reconfigure: (search: SearchConfig) => Promise<SqlDriver>;
+    close: () => Promise<void>;
+}
+/** `bun run testConformance` (`infra/test/compose.yaml`) sets all three backends; plain `bun test` runs SQLite. */
+export declare class ConformanceEnv {
+    #private;
+    /** Where a deployment points an app at its data. A test that hands its storage in has these cleared first. */
+    static readonly deploymentEnvKeys: readonly ["AKAN_DATABASE_MODES", "AKAN_SOLID_DB_PATH", "SQLITE_DATABASE_PATH", "LIBSQL_URL", "LIBSQL_URI", "LIBSQL_AUTH_TOKEN", "POSTGRES_URL", "POSTGRES_URI", "POSTGRES_HOST", "POSTGRES_PORT", "POSTGRES_DATABASE", "POSTGRES_DB", "POSTGRES_USER", "POSTGRES_PASSWORD", "POSTGRES_INSIGHT_URL"];
+    /** This process's env without what a deployment would point the app at. */
+    static isolatedProcessEnv(): Record<string, string | undefined>;
+    static url(backend: ConformanceBackend): string | null;
+    /** Says once per suite and backend when it is missing: a skipped suite must never read as a passing one. */
+    static has(suite: string, backend: ConformanceBackend): boolean;
+    static uniqueName(prefix: string): string;
+    static tempDir(prefix: string): Promise<{
+        dir: string;
+        remove: () => Promise<void>;
+    }>;
+    /**
+     * A throwaway schema and a URL pinning every pooled connection to it: postgres.js forwards unknown query parameters
+     * as startup parameters, so `search_path` holds on later connections too. `insight` adds a login role, dropped too.
+     */
+    static postgresSchema(prefix: string, { insight }?: {
+        insight?: boolean;
+    }): Promise<{
+        schema: string;
+        url: string;
+        insightUrl: string | undefined;
+        drop: () => Promise<void>;
+    }>;
+    /** A login role with no privilege and no membership, and the URL that logs in as it. */
+    static createPostgresLoginRole(role: string): Promise<{
+        url: string;
+        drop: () => Promise<void>;
+    }>;
+    static cacheKinds(suite: string): ConformanceCacheKind[];
+    /** `app` stands for the app that built the cache: on Redis it is the key prefix, and closing deletes under it. */
+    static openCache(kind: ConformanceCacheKind, { app }?: {
+        app?: string;
+    }): Promise<{
+        cache: SolidCache | RedisCache;
+        close: () => Promise<void>;
+    }>;
+    /** The local drivers always, and each remote one whose backend the suite can reach. */
+    static sqlDrivers(suite: string, { remote }?: {
+        remote?: boolean;
+    }): SqlDriverKind[];
+    /**
+     * The real adaptor, initialised as the DI container would, on storage nothing else sees. `insight` gives Postgres a
+     * login role for `InsightQuery`; `memory` puts SQLite in memory, as `TestServer` does.
+     */
+    static openSqlDriver(kind: SqlDriverKind, options?: SqlDriverOptions): Promise<SqlDriver>;
+}
+export {};

package/types/test/index.d.ts

@@ -1,4 +1,4 @@
-export { sample } from "./sample.d.ts";
-export { sampleOf } from "./sampleOf.d.ts";
+export { type ConformanceCacheKind, ConformanceEnv, type SqlDriver, type SqlDriverKind } from "./conformance.d.ts";
+export { sample, sampleOf } from "./sampleOf.d.ts";
 export { configureSignalTest, getOrSetupSignalTestContext, getOrSetupSignalTestFetch, getSignalTestContext, getSignalTestFetch, hasSignalTestContext, type SignalTestContext, type SignalTestOptions, type SignalTestTarget, setupSignalTestTarget, terminateSignalTestContext, } from "./signalTestRuntime.d.ts";
 export { type TestEnv, TestServer, type TestServerOptions } from "./testServer.d.ts";

package/types/test/sampleOf.d.ts

@@ -1,5 +1,20 @@
-import type { BaseObject, ConstantCls, DocumentModel, FieldObject } from "akanjs/constant";
+import { type Dayjs } from "akanjs/base";
+import { type BaseObject, type ConstantCls, type DocumentModel, type FieldObject } from "akanjs/constant";
+import Chance from "chance";
+export declare const sample: Chance.Chance & {
+    dayjs: (opt?: {
+        string?: boolean | undefined;
+        american?: boolean | undefined;
+        year?: number | undefined;
+        month?: number | undefined;
+        day?: number | undefined;
+        min?: Dayjs | undefined;
+        max?: Dayjs | undefined;
+    }) => Dayjs;
+    pick: <T = unknown>(arr: T[] | readonly T[]) => T;
+    picks: <T>(arr: T[] | readonly T[], count?: number, allowDuplicate?: boolean) => T[];
+};
 export type SampleOf<Model> = DocumentModel<{
     [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>;
 }>;
-export declare const sampleOf: <Model, FieldObj extends FieldObject>(modelRef: ConstantCls<Model, FieldObj>) => DocumentModel<{ [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>; }>;
+export declare const sampleOf: <Model, FieldObj extends FieldObject>(modelRef: ConstantCls<Model, FieldObj>) => SampleOf<Model>;

package/types/test/signalTestRuntime.d.ts

@@ -13,7 +13,7 @@ export interface SignalTestContext<Fetch = FetchProxy> {
     target: SignalTestTarget;
     terminate: () => Promise<void>;
 }
-export type SignalTestOptions = Pick<TestServerOptions, "databaseMode" | "workerId" | "port" | "serverMode">;
+export type SignalTestOptions = Pick<TestServerOptions, "storage" | "workerId" | "port" | "serverMode">;
 export declare const hasSignalTestContext: () => boolean;
 export declare const getSignalTestContext: <Fetch = FetchProxy>() => SignalTestContext<Fetch>;
 export declare const getSignalTestFetch: <Fetch = FetchProxy>() => Fetch;