akanjs 3.0.0-alpha.7 → 3.0.0-alpha.71

package/store/agentic/useFieldTool.ts

@@ -0,0 +1,183 @@
+"use client";
+import { capitalize } from "akanjs/common";
+import type { JsonSchema, ToolEntry } from "../../vendor/use-agentic";
+import { useScopePath, useSurface } from "../../vendor/use-agentic";
+import { actionTagOf } from "../actionTag";
+import { formSetterNames } from "../formSetterNames";
+
+import { useEffect, useRef } from "../hooks";
+import { StoreRegistry } from "../storeRegistry";
+import { type FormFieldRef, FormFields } from "./formFields";
+
+/**
+ * A control's `transform` is what it does to every value a person types, so an agent's write goes through it too —
+ * otherwise a `Field.Phone` stores `010-1234-5678` for the person and the raw digits for the agent. It normalizes
+ * one scalar, so an array-valued control (`TextList`, `Tags`, `DoubleNumber`) applies it per element. A cleared
+ * nullable field stays null: a normalizer written for a value would turn it into one.
+ */
+const normalized = (value: unknown, transform: unknown): unknown => {
+  if (typeof transform !== "function" || value === null) return value;
+  const apply = transform as (input: unknown) => unknown;
+  return Array.isArray(value) ? value.map((item) => apply(item)) : apply(value);
+};
+
+const dispatcherOf = (action: string) =>
+  StoreRegistry.instance.do[action] as ((...args: unknown[]) => unknown) | undefined;
+
+const rowsOf = (ref: FormFieldRef): unknown[] => {
+  const form = StoreRegistry.instance.get()[`${ref.refName}Form`] as { [key: string]: unknown } | undefined;
+  const rows = form?.[ref.key];
+  return Array.isArray(rows) ? rows : [];
+};
+
+/**
+ * Append and remove-by-index for an array of embedded rows, beside the whole-array setter.
+ *
+ * Not new authority: the setter this control already published can produce any array these two can, so they are
+ * strictly weaker — which is what makes deriving them from the same field sound. What they add is that neither can
+ * touch a row it was not given, so the agent stops having to retype the rows it is leaving alone.
+ *
+ * Both take a list and act atomically. Removing indices one call at a time would shift the ones not yet removed, so
+ * `sub` filters the whole set at once, the way the generated action already does.
+ *
+ * `add` appends and publishes no insert position: the `+` a person presses always appends, and the framework cannot
+ * see the `limit` an app may pass from its own `onAdd`. `addOrSub` is never published — it matches by `indexOf`, so
+ * on rows it compares by reference and every toggle would append.
+ */
+const rowEntries = (ref: FormFieldRef, arraySchema: JsonSchema): ToolEntry[] => {
+  if (!FormFields.rowModelOf(ref.field)) return [];
+  const names = formSetterNames(capitalize(ref.refName), ref.key);
+  if (!dispatcherOf(names.addFieldOnModel) || !dispatcherOf(names.subFieldOnModel)) return [];
+  return [
+    {
+      name: names.addFieldOnModel,
+      description: `Append rows to ${ref.key} on the ${ref.refName} form. Leaves every existing row untouched.`,
+      parameters: {
+        type: "object",
+        properties: { values: arraySchema },
+        required: ["values"],
+        additionalProperties: false,
+      },
+      run: (args) => {
+        const checked = FormFields.checked(names.addFieldOnModel, "values", ref.field, args.values);
+        return dispatcherOf(names.addFieldOnModel)?.(checked);
+      },
+    },
+    {
+      name: names.subFieldOnModel,
+      description: `Remove rows of ${ref.key} from the ${ref.refName} form by their positions, counting from 0.`,
+      parameters: {
+        type: "object",
+        properties: { idxs: { type: "array", items: { type: "integer" } } },
+        required: ["idxs"],
+        additionalProperties: false,
+      },
+      guard: (args) => {
+        const idxs = args.idxs;
+        if (!Array.isArray(idxs) || !idxs.length) return `"idxs" of ${names.subFieldOnModel} takes at least one index.`;
+        const length = rowsOf(ref).length;
+        const outside = idxs.filter(
+          (idx) => typeof idx !== "number" || !Number.isInteger(idx) || idx < 0 || idx >= length,
+        );
+        if (!outside.length) return true;
+        return `${ref.key} has ${length} ${length === 1 ? "row" : "rows"}, so ${outside.join(", ")} is out of range.`;
+      },
+      run: (args) => dispatcherOf(names.subFieldOnModel)?.(args.idxs),
+    },
+  ];
+};
+
+export interface FieldToolOptions {
+  /** The control's own normalizer. Applied to the agent's write exactly as it is 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. */
+  disabled?: boolean;
+  /** The person can drag entries into a new order, so `move<Field>On<Model>` is a lever the screen really has. */
+  sortable?: boolean;
+}
+
+/**
+ * Reorder-by-position for a list the person can drag, beside the whole-array setter.
+ *
+ * The drag is the lever the screen actually offers, and it changes no row's content — so an agent asked to move one
+ * row should not have to retype the nine it is leaving alone, which is the same argument that gives an embedded-row
+ * array its `add`/`sub`. There is no store action behind it: reordering *is* a whole-array write, so this splices
+ * the live rows and hands them to the setter the drag hands them to, `transform` deliberately not applied — the
+ * values are already stored, and normalizing them again is not something dragging does.
+ */
+const moveEntry = (ref: FormFieldRef, onChange: () => (value: unknown) => unknown): ToolEntry => {
+  const name = formSetterNames(capitalize(ref.refName), ref.key).moveFieldOnModel;
+  return {
+    name,
+    description: `Move one entry of ${ref.key} on the ${ref.refName} form to another position, counting from 0. Reorders only — no entry's content changes.`,
+    parameters: {
+      type: "object",
+      properties: { from: { type: "integer" }, to: { type: "integer" } },
+      required: ["from", "to"],
+      additionalProperties: false,
+    },
+    guard: (args) => {
+      const length = rowsOf(ref).length;
+      const outside = ["from", "to"].filter((key) => {
+        const idx = args[key];
+        return typeof idx !== "number" || !Number.isInteger(idx) || idx < 0 || idx >= length;
+      });
+      if (!outside.length) return true;
+      return `${ref.key} has ${length} ${length === 1 ? "entry" : "entries"}, so ${outside.join(" and ")} is out of range.`;
+    },
+    run: (args) => {
+      const rows = [...rowsOf(ref)];
+      const [moved] = rows.splice(args.from as number, 1);
+      rows.splice(args.to as number, 0, moved);
+      return onChange()(rows);
+    },
+  };
+};
+
+/**
+ * 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.
+ */
+export const useFieldTool = (onChange: unknown, { transform, disabled, sortable }: FieldToolOptions = {}) => {
+  const surface = useSurface();
+  const scope = useScopePath();
+  const action = actionTagOf(onChange)?.action ?? null;
+  const off = !!disabled;
+  const live = useRef({ onChange, transform });
+  live.current = { onChange, transform };
+  const scopeKey = scope.join(".");
+  useEffect(() => {
+    if (!action || off) return;
+    const ref = FormFields.ref(action);
+    const schema = ref && FormFields.schema(ref.field);
+    if (!ref || !schema) return;
+    const entries: ToolEntry[] = [
+      {
+        name: action,
+        description: `Set ${ref.key} on the ${ref.refName} form.`,
+        parameters: { type: "object", properties: { value: schema }, required: ["value"], additionalProperties: false },
+        run: (args) => {
+          const checked = FormFields.checked(action, "value", ref.field, args.value === undefined ? null : args.value);
+          return (live.current.onChange as (value: unknown) => unknown)(normalized(checked, live.current.transform));
+        },
+      },
+      ...rowEntries(ref, schema),
+      ...(sortable && ref.field.arrDepth > 0
+        ? [moveEntry(ref, () => live.current.onChange as (value: unknown) => unknown)]
+        : []),
+    ];
+    const registered = entries.map((entry) => surface.registerTool(scope, entry));
+    return () => {
+      for (const unregister of registered) unregister();
+    };
+  }, [surface, scopeKey, action, off, !!sortable]);
+};

package/store/agentic/useFormTools.ts

@@ -0,0 +1,77 @@
+"use client";
+import { capitalize } from "akanjs/common";
+import { AgenticSurface, useScopePath, useSurface } from "../../vendor/use-agentic";
+
+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.
+ */
+export const useFormTools = (refName: string | null, write: (action: string, value: unknown) => void) => {
+  const surface = useSurface();
+  const scope = useScopePath();
+  const live = useRef(write);
+  live.current = write;
+  const scopeKey = scope.join(".");
+  useEffect(() => {
+    if (!refName) return;
+    const fields = FormFields.patchable(refName);
+    if (!fields.length) return;
+    const byKey = new Map(fields.map((entry) => [entry.key, entry]));
+    const name = `fill${capitalize(refName)}Form`;
+    const offered = () =>
+      fields.filter(
+        (entry) =>
+          FormFields.isComposite(entry.field) || !!surface.tool(AgenticSurface.fullName(scope, entry.action), scope),
+      );
+    return surface.registerTool(scope, {
+      name,
+      description: `Fill fields of the ${refName} form. Sends a patch — a field left out keeps its value.`,
+      parameters: {
+        type: "object",
+        properties: Object.fromEntries(fields.map((entry) => [entry.key, entry.schema])),
+        additionalProperties: false,
+      },
+      guard: (args) => {
+        const keys = Object.keys(args);
+        if (!keys.length) return "Name at least one field to fill.";
+        const open = new Set(offered().map((entry) => entry.key));
+        const closed = keys.filter((key) => !open.has(key));
+        if (!closed.length) return true;
+        return `This screen offers no ${closed.join(", ")} on the ${refName} form. It offers: ${
+          [...open].join(", ") || "nothing"
+        }.`;
+      },
+      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 });
+          else live.current(entry.action, value);
+        }
+      },
+    });
+  }, [surface, scopeKey, refName]);
+};

package/store/agentic/useRelationFieldTool.ts

@@ -0,0 +1,113 @@
+"use client";
+import { type Cls, type DataList, PrimitiveRegistry } from "akanjs/base";
+import { capitalize } from "akanjs/common";
+import { type ConstantField, ConstantRegistry } from "akanjs/constant";
+import type { JsonSchema } from "../../vendor/use-agentic";
+import { useScopePath, useSurface } from "../../vendor/use-agentic";
+import { actionTagOf } from "../actionTag";
+
+import { useEffect, useRef } from "../hooks";
+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 database model a relation field points at, or null for anything else — a primitive, an enum, a scalar. */
+const relationOf = (field: ConstantField): string | null => {
+  const modelRef = field.modelRef as unknown as Cls;
+  if (field.fieldType !== "property" || field.enum || !modelRef || PrimitiveRegistry.has(modelRef)) return null;
+  const refName = ConstantRegistry.getRefName(modelRef, { allowEmpty: true });
+  return refName && ConstantRegistry.database.has(refName) ? refName : null;
+};
+
+/**
+ * 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.
+ */
+export const useRelationFieldTool = <T extends { id: string }>(
+  onChange: unknown,
+  { read, load, label, disabled }: RelationFieldSource<T>,
+) => {
+  const surface = useSurface();
+  const scope = useScopePath();
+  const action = actionTagOf(onChange)?.action ?? null;
+  const live = useRef({ onChange, read, load, label });
+  live.current = { onChange, read, load, label };
+  const scopeKey = scope.join(".");
+  useEffect(() => {
+    if (!action || disabled) return;
+    const ref = FormFields.ref(action);
+    const target = ref && relationOf(ref.field);
+
+    if (!ref || !target || FormFields.schema(ref.field)) return;
+    const many = ref.field.arrDepth > 0;
+    const nullable = !!ref.field.nullable && !many;
+    const listName = `load${capitalize(ref.key)}OptionsOn${capitalize(ref.refName)}`;
+    const argName = many ? `${ref.key}Ids` : `${ref.key}Id`;
+    const id: JsonSchema = { type: "string" };
+    const options = () => live.current.read().map((model) => ({ id: model.id, label: live.current.label(model) }));
+    const idsIn = (args: Record<string, unknown>): unknown => {
+      const value = args[argName];
+      if (nullable && (value === null || value === undefined)) return [];
+      return many ? value : [value];
+    };
+    const offList = surface.registerTool(scope, {
+      name: listName,
+      description: `List the ${target}s the ${ref.refName} form can pick for ${ref.key}, loading them first. Pass an id from it to ${action}.`,
+      settle: false,
+      run: async () => {
+        await live.current.load();
+        return options();
+      },
+    });
+    const offSet = surface.registerTool(scope, {
+      name: action,
+      description: `Set ${ref.key} on the ${ref.refName} form to ${many ? `${target}s` : `one ${target}`}, by id. Call ${listName} first for the ids.`,
+      parameters: {
+        type: "object",
+        properties: { [argName]: many ? { type: "array", items: id } : id },
+        ...(nullable ? {} : { required: [argName] }),
+        additionalProperties: false,
+      },
+      guard: (args) => {
+        const ids = idsIn(args);
+        if (!Array.isArray(ids)) return `"${argName}" of ${action} must be an array of ids.`;
+        const list = live.current.read();
+        const missing = ids.filter((value) => typeof value !== "string" || !list.get(value));
+        if (!missing.length) return true;
+        if (!list.length) return `No ${target} is loaded yet. Call ${listName} first for the ids.`;
+        return `The ${ref.refName} form offers no ${target} ${missing.join(", ")}. It offers: ${list
+          .map((model) => `${model.id} (${live.current.label(model)})`)
+          .join(", ")}.`;
+      },
+      run: (args) => {
+        const list = live.current.read();
+        const setter = live.current.onChange as (value: unknown) => unknown;
+        const picked = (idsIn(args) as string[]).flatMap((value) => {
+          const model = list.get(value);
+          return model ? [model] : [];
+        });
+        return setter(many ? picked : (picked[0] ?? null));
+      },
+    });
+    return () => {
+      offList();
+      offSet();
+    };
+  }, [surface, scopeKey, action, disabled]);
+};

package/store/baseSt.ts

@@ -33,7 +33,7 @@ export class BaseStore extends store("base" as const, () => ({
   messages: [] as (typeof defaultMessage)[],
   tryJwt: null as string | null,
   trySignalType: "restapi" as SignalType,
-  tryRoles: [] as string[], //[...roleTypes] as RoleType[],
+  tryGuards: [] as string[],
   tryAccount: getDefaultAccount() as Account<{ [key: string]: string | undefined }>,
   keyboardHeight: 0,
   pageState: {

package/store/databaseStateNames.ts

@@ -0,0 +1,31 @@
+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 {
+    model: refName,
+    modelLoading: `${refName}Loading`,
+    modelForm: `${refName}Form`,
+    modelFormLoading: `${refName}FormLoading`,
+    modelSubmit: `${refName}Submit`,
+    modelViewAt: `${refName}ViewAt`,
+    modelModal: `${refName}Modal`,
+    modelOperation: `${refName}Operation`,
+    defaultModel: `default${className}`,
+  };
+};
+
+/** 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",
+  defaultModel: "full",
+} as const satisfies { [key in keyof ReturnType<typeof databaseStateNames>]?: "full" | "input" | "light" | "insight" };

package/store/formSetterNames.ts

@@ -0,0 +1,35 @@
+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 {
+    field: lowerlize(key),
+    Field: classKeyName,
+    setFieldOnModel: `set${classKeyName}On${className}`,
+    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/index.ts

@@ -1,8 +1,16 @@
 export * from "./action";
+export * from "./actionTag";
+export * from "./agent";
+export * from "./agentic";
 export * from "./baseSt";
+export * from "./databaseStateNames";
+export * from "./formSetterNames";
 export * from "./rootStore";
+export * from "./sliceRole";
 export * from "./state";
 export * from "./stateBuilder";
 export * from "./store";
+
+export { StoreInstance } from "./storeInstance";
 export * from "./storeRegistry";
 export * from "./types";

package/store/rootStore.ts

@@ -1,5 +1,6 @@
-import type { ACTION_META, Cls, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
+import type { ACTION_META, ACTION_OWNER_META, Cls, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
 import type { SerializedSlice } from "akanjs/signal";
+import type { ActionOwner } from "./actionTag";
 import type { StateDerivedMeta, StateInitializerMap } from "./stateBuilder";
 import type { SetGetWritable } from "./types";
 
@@ -20,6 +21,7 @@ export type RootStoreCls<
     [STATE_INIT_META]: StateInitializerMap;
     [STATE_DERIVED_META]: StateDerivedMeta;
     [ACTION_META]: { [key: string]: (...args: any[]) => any };
+    [ACTION_OWNER_META]: { [key: string]: ActionOwner };
     slice: { [key: string]: { [key: string]: SerializedSlice } };
     _slice: SliceInfoObj;
   }

package/store/sliceRole.ts

@@ -0,0 +1,36 @@
+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"
+  | "selectModel"
+  | "setPageOfModel"
+  | "addPageOfModel"
+  | "setLimitOfModel"
+  | "setQueryArgsOfModel"
+  | "setSortOfModel";
+
+/**
+ * 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.
+ */
+export interface SliceActionRole {
+  role: SliceActionKey;
+  refName: string;
+  sliceName: string;
+  /** The slice's own arguments, which the `initModel` and `setQueryArgsOfModel` roles take positionally. */
+  args: SerializedArg[];
+}
+
+export interface SliceStateRole {
+  role: SliceStateKey;
+  refName: string;
+  sliceName: string;
+}

package/store/state.ts

@@ -14,6 +14,7 @@ import type {
   SlceDbSort,
   SliceCls,
 } from "akanjs/signal";
+import { databaseStateNames } from "./databaseStateNames";
 import type { StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap, Submit } from "./types";
 
 export type SliceStateKey =
@@ -151,18 +152,7 @@ export type DefaultState<
 
 export const createDatabaseState = (refName: string) => {
   const cnst = ConstantRegistry.getDatabase(refName);
-  const [fieldName, className] = [refName, capitalize(refName)];
-  const names = {
-    model: fieldName,
-    Model: className,
-    modelLoading: `${fieldName}Loading`,
-    modelForm: `${fieldName}Form`,
-    modelFormLoading: `${fieldName}FormLoading`,
-    modelSubmit: `${fieldName}Submit`,
-    modelViewAt: `${fieldName}ViewAt`,
-    modelModal: `${fieldName}Modal`,
-    modelOperation: `${fieldName}Operation`,
-  };
+  const names = databaseStateNames(refName);
   const baseState = {
     [names.model]: null,
     [names.modelLoading]: true,

package/store/store.ts

@@ -1,5 +1,6 @@
 import {
   ACTION_META,
+  ACTION_OWNER_META,
   type Cls,
   type MergeAllActionTypes,
   type MergeAllKeyOfObjects,
@@ -24,6 +25,7 @@ import type {
   SliceCls,
 } from "akanjs/signal";
 import { type DefaultAction, makeActions, makeFormSetter } from "./action";
+import type { ActionOwner } from "./actionTag";
 import { createDatabaseState, createSliceState, type DefaultState } from "./state";
 import {
   createDerivedStateBuilder,
@@ -120,6 +122,7 @@ export type StoreCls<
     [STATE_INIT_META]: StateInitializerMap;
     [STATE_DERIVED_META]: StateDerivedMeta;
     [ACTION_META]: { [key: string]: (...args: any[]) => any };
+    [ACTION_OWNER_META]: { [key: string]: ActionOwner };
     slice: { [key: string]: SerializedSlice };
     _slice: SlceCls[typeof SLICE_META];
   }
@@ -187,6 +190,7 @@ export function store<Sig extends ClientSignal<any, any, any> | string, State>(
     static [STATE_INIT_META] = {};
     static [STATE_DERIVED_META] = createEmptyDerivedMeta();
     static [ACTION_META] = {};
+    static [ACTION_OWNER_META] = {};
     static slice = {};
   } as StoreCls;
   const writableStateRaw = stateFactory(createWritableStateBuilder());
@@ -204,6 +208,7 @@ export function store<Sig extends ClientSignal<any, any, any> | string, State>(
     writable.meta,
   );
   Object.assign(storeCls[ACTION_META], ...libStores.map((libStore) => libStore[ACTION_META]));
+  Object.assign(storeCls[ACTION_OWNER_META], ...libStores.map((libStore) => libStore[ACTION_OWNER_META] ?? {}));
   applyMixins(storeCls, libStores);
   if (signal) {
     const signalState = {
@@ -218,6 +223,10 @@ export function store<Sig extends ClientSignal<any, any, any> | string, State>(
     };
     Object.assign(storeCls.prototype, actions);
     Object.assign(storeCls[ACTION_META], actions);
+    Object.assign(
+      storeCls[ACTION_OWNER_META],
+      Object.fromEntries(Object.keys(actions).map((key) => [key, { refName }])),
+    );
     Object.assign(storeCls.slice, signal.serializedSignal.slice ?? {});
   }
   if (derivedStateFactory) {