akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/store/action.ts

@@ -37,13 +37,15 @@ import type {
   SlceDbSort,
   SliceCls,
 } from "akanjs/signal";
+import { expandQueryArgs, normalizeQueryArgs } from "../fetch/client/sliceQueryArgs";
 import { tagAction } from "./actionTag";
+import { databaseStateNames } from "./databaseStateNames";
 import { DraftStore } from "./draftStore";
 import { formSetterNames } from "./formSetterNames";
 import { type LiveSortableRow, livePlacementIndex } from "./liveInsert";
 import { SliceRequest } from "./SliceRequest";
-import type { SliceActionKey } from "./sliceRole";
-import type { DraftState, SliceStateKey } from "./state";
+import { sliceKeysOf } from "./sliceKeys";
+import type { DraftState } from "./state";
 import type { SetGet, StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap } from "./types";
 
 type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
@@ -62,20 +64,8 @@ type SliceRefreshForm<S extends SliceCls, Suffix extends keyof _SliceMap<S>> = S
 };
 
 const UPLOAD_POLL_INTERVAL_MS = 3000;
-/** Two minutes of polling. A file still `uploading` after that is a server that will not finish it. */
 const UPLOAD_POLL_ATTEMPTS = 40;
 
-const isNullableSliceArg = (arg: SerializedSlice["args"][number]) => arg.nullable ?? arg.type === "search";
-
-const normalizeQueryArgs = (queryArgs: unknown[], sliceArgs: SerializedSlice["args"]) => {
-  let length = Math.min(queryArgs.length, sliceArgs.length);
-  while (length > 0 && isNullableSliceArg(sliceArgs[length - 1]) && queryArgs[length - 1] == null) length--;
-  return queryArgs.slice(0, length);
-};
-
-const expandQueryArgs = (queryArgs: unknown[], sliceArgs: SerializedSlice["args"]) =>
-  sliceArgs.map((_, idx) => queryArgs[idx]);
-
 export interface CreateOption<Full extends { id: string }> {
   path?: string;
   modal?: string;
@@ -87,16 +77,12 @@ export interface NewOption {
   modal?: string;
   setDefault?: boolean;
   sliceName?: string;
-  /**
-   * The draft scope this form belongs to, already built by the shell that holds the raw seed. Absent means no
-   * draft: `new<Model>` merges its argument into `default<Model>`, whose date defaults would rotate the key on
-   * every open, so the scope cannot be derived from what arrives here.
-   */
+  /** Built by the shell from the raw seed (merged date defaults would rotate the key). Absent means no draft. */
   draftScope?: string;
 }
 export interface EditOption {
   modal?: string | null;
-  /** As `NewOption.draftScope`. For an edit the shell builds it from the record id. */
+  /** Built by the shell from the record id. Absent means no draft. */
   draftScope?: string;
 }
 type PartialOrNull<O> = { [K in keyof O]?: O[K] | null };
@@ -322,8 +308,6 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
   const fileUploadRefName = resolveFileUploadCapability(fetch.serializedSignal)?.refName;
 
   const names = {
-    model: fieldName,
-    Model: className,
     modelForm: `${fieldName}Form`,
     writeOnModel: `writeOn${className}`,
     addModelFiles: `add${className}Files`,
@@ -348,7 +332,7 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
                 : (value as object);
           (state[names.modelForm] as { [key: string]: any })[namesOfField.field] = setValue;
         });
-
+        
         const postSet = (this as unknown as { [key: string]: ((value: unknown) => unknown) | undefined })[
           namesOfField.postSetField
         ];
@@ -434,7 +418,6 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
                 let attemptsLeft = UPLOAD_POLL_ATTEMPTS;
                 const intervalKey = setInterval(() => {
                   void (async () => {
-
                     attemptsLeft -= 1;
                     try {
                       const currentFile = await (
@@ -466,7 +449,7 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
           }
         : {}),
     };
-
+    
     tagAction(singleFieldSetAction[namesOfField.setFieldOnModel] as (...args: never[]) => unknown, {
       action: namesOfField.setFieldOnModel,
       state: `${names.modelForm}.${namesOfField.field}`,
@@ -487,27 +470,19 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
   const [fieldName, className] = [refName, capitalize(refName)];
   const cnst = ConstantRegistry.getDatabase(refName);
   const modelRef = cnst.full;
-
+  
   let openFormBase: object | null = null;
   const slices = Object.entries(slice).map(([suffix, serializedSlice]) => ({
     sliceName: `${refName}${capitalize(suffix)}`,
-    suffix,
+    keys: sliceKeysOf(refName, suffix),
     slice: serializedSlice,
   }));
   const names = {
-    model: fieldName,
-    _model: `_${fieldName}`,
+    ...databaseStateNames(refName),
     Model: className,
-    modelOperation: `${fieldName}Operation`,
-    defaultModel: `default${className}`,
     modelInsight: `${fieldName}Insight`,
-    modelForm: `${fieldName}Form`,
-    modelSubmit: `${fieldName}Submit`,
-    modelLoading: `${fieldName}Loading`,
-    modelFormLoading: `${fieldName}FormLoading`,
     modelList: `${fieldName}List`,
     modelListLoading: `${fieldName}ListLoading`,
-    modelSelection: `${fieldName}Selection`,
     createModelInForm: `create${className}InForm`,
     updateModelInForm: `update${className}InForm`,
     createModel: `create${className}`,
@@ -521,49 +496,24 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     viewModel: `view${className}`,
     setModel: `set${className}`,
     resetModel: `reset${className}`,
-    modelViewAt: `${fieldName}ViewAt`,
-    modelModal: `${fieldName}Modal`,
-    modelDraft: `${fieldName}FormDraft`,
     loadModelDraft: `load${className}FormDraft`,
     restoreModelDraft: `restore${className}FormDraft`,
     discardModelDraft: `discard${className}FormDraft`,
-    initModel: `init${className}`,
-    modelInitList: `${fieldName}InitList`,
-    modelInitAt: `${fieldName}InitAt`,
-    modelStaleAt: `${fieldName}StaleAt`,
-    refreshModel: `refresh${className}`,
-    selectModel: `select${className}`,
-    setPageOfModel: `setPageOf${className}`,
-    loadMoreOfModel: `loadMoreOf${className}`,
-    setLimitOfModel: `setLimitOf${className}`,
-    setQueryArgsOfModel: `setQueryArgsOf${className}`,
-    setSortOfModel: `setSortOf${className}`,
-    applyLiveModel: `applyLive${className}`,
-    watchLiveModel: `watchLive${className}`,
-    lastPageOfModel: `lastPageOf${className}`,
-    pageOfModel: `pageOf${className}`,
-    limitOfModel: `limitOf${className}`,
-    hasMoreOfModel: `hasMoreOf${className}`,
-    isCumulativeOfModel: `isCumulativeOf${className}`,
-    queryArgsOfModel: `queryArgsOf${className}`,
-    sortOfModel: `sortOf${className}`,
   };
-
+  const defaultKeyOf = (sliceName: string) => capitalize(sliceName).replace(names.Model, names.defaultModel);
+  
   const staleAtOfSlices = () => {
     const staleAt = new Date();
-    return Object.fromEntries(
-      slices.map(({ sliceName }) => [sliceName.replace(names.model, names.modelStaleAt), staleAt]),
-    );
+    return Object.fromEntries(slices.map(({ keys }) => [keys.state.modelStaleAt, staleAt]));
   };
   const updatedAtOf = (model: Full): string | null => {
     const updatedAt = (model as unknown as { updatedAt?: { toISOString?: () => string } }).updatedAt;
     return typeof updatedAt?.toISOString === "function" ? updatedAt.toISOString() : null;
   };
-  /** Turns draft saving on for this form and records what "unchanged" means for it. */
   function armDraft(this: SetGet, draftScope: string | undefined, form: object, baseUpdatedAt: string | null) {
     openFormBase = draftScope ? form : null;
     if (!draftScope) return null;
-
+    
     void DraftStore.reconcileIdentity();
     return {
       key: DraftStore.keyOf(refName, draftScope),
@@ -573,12 +523,6 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       appliedAt: null,
     };
   }
-  /**
-   * Reads the saved draft and either puts it in the form or leaves it pending.
-   *
-   * Runs after the form has already been set from its own source, so a failed read, a stale record, or a
-   * conflicting one all leave the editor exactly as it would have been without drafts at all.
-   */
   async function applyDraft(this: SetGet, { auto }: { auto: boolean }) {
     const draft = (this.get() as { [key: string]: any })[names.modelDraft] as DraftState | null;
     if (!draft) return;
@@ -587,7 +531,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     
     const current = (this.get() as { [key: string]: any })[names.modelDraft] as DraftState | null;
     if (current?.key !== draft.key) return;
-
+    
     const openedForm = (this.get() as { [key: string]: any })[names.modelForm] as object;
     if (DraftStore.contentHash(record.form) === DraftStore.contentHash(DraftStore.encodeForm(refName, openedForm))) {
       await DraftStore.remove(draft.key);
@@ -608,39 +552,38 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     }
     this.set({ [names.modelDraft]: { ...draft, pending: { savedAt, form } } });
   }
-  /** Disarms saving and forgets the record. Called by every path that ends the form for good. */
   const clearDraft = (draft: DraftState | null) => {
     openFormBase = null;
     if (draft) void DraftStore.remove(draft.key);
     return null;
   };
-  /**
-   * Puts a just-created row into the slice's own list.
-   *
-   * A live slice goes through the same action a remote event does, so the row lands where the sort puts it rather
-   * than at the top — and when the server's own event for this create comes back, the list already holds the id,
-   * which is what stops the count being raised twice. Every other slice keeps the head insertion it had.
-   */
-  function applyLocalCreate(
-    this: SetGet,
-    sliceName: string,
-    model: Full,
-    seen: { modelList: DataList<Light>; modelListLoading: boolean; modelInsight: Insight & BaseInsight },
-  ) {
-    if (slices.find((entry) => entry.sliceName === sliceName)?.slice.live) {
-      const applyLive = (this as unknown as DynamicRecord)[
-        capitalize(sliceName).replace(names.Model, names.applyLiveModel)
-      ] as ((event: LiveEventPayload) => void) | undefined;
+  
+  function applyLocalCreate(this: SetGet, sliceName: string, model: Full, seen: { [key: string]: any }) {
+    const target = slices.find((entry) => entry.sliceName === sliceName);
+    if (target?.slice.live) {
+      const applyLive = (this as unknown as DynamicRecord)[target.keys.action.applyLiveModel] as
+        | ((event: LiveEventPayload) => void)
+        | undefined;
       applyLive?.({ op: "enter", id: model.id, light: new cnst.light().set(model) as unknown as object });
       return;
     }
-    if (seen.modelListLoading) return;
+    if (seen[sliceName.replace(names.model, names.modelListLoading)]) return;
+    const listKey = sliceName.replace(names.model, names.modelList);
+    const insightKey = sliceName.replace(names.model, names.modelInsight);
+    const modelInsight = seen[insightKey] as Insight & BaseInsight;
     this.set({
-      [sliceName.replace(names.model, names.modelList)]: new DataList([model, ...seen.modelList]),
-      [sliceName.replace(names.model, names.modelInsight)]: new cnst.insight().set({
-        ...seen.modelInsight,
-        count: seen.modelInsight.count + 1,
-      }),
+      [listKey]: new DataList([model, ...(seen[listKey] as DataList<Light>)]),
+      [insightKey]: new cnst.insight().set({ ...modelInsight, count: modelInsight.count + 1 }),
+    });
+  }
+  function patchLists(this: SetGet, updatedModel: Full) {
+    const updatedLightModel = new cnst.light().set(updatedModel) as unknown as Light;
+    slices.forEach(({ keys: { state: namesOfSlice } }) => {
+      const currentState = this.get() as { [key: string]: any };
+      const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
+      const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
+      if (modelListLoading || !modelList.has(updatedModel.id)) return;
+      this.set({ [namesOfSlice.modelList]: new DataList(modelList).set(updatedLightModel) });
     });
   }
   const baseAction = {
@@ -648,19 +591,9 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       this: SetGet,
       { path, modal, sliceName = names.model, onError, onSuccess }: CreateOption<Full> = {},
     ) {
-      const SliceName = capitalize(sliceName);
-      const namesOfSlice = {
-        defaultModel: SliceName.replace(names.Model, names.defaultModel),
-        modelList: sliceName.replace(names.model, names.modelList),
-        modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        modelInsight: sliceName.replace(names.model, names.modelInsight),
-      };
       const currentState = this.get() as { [key: string]: any };
       const modelForm = currentState[names.modelForm] as Input;
-      const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
-      const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
-      const modelInsight = currentState[namesOfSlice.modelInsight] as Insight & BaseInsight;
-      const defaultModel = currentState[namesOfSlice.defaultModel] as Full;
+      const defaultModel = currentState[defaultKeyOf(sliceName)] as Full;
       const modelInput = (cnst.input.purify as (form: any) => DefaultOf<Input> | null)(modelForm);
 
       if (!modelInput) return;
@@ -676,21 +609,17 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         ...staleAtOfSlices(),
         ...(typeof path === "string" && path ? { [path]: model } : {}),
       });
-      applyLocalCreate.call(this, sliceName, model, { modelList, modelListLoading, modelInsight });
+      applyLocalCreate.call(this, sliceName, model, currentState);
       await onSuccess?.(model);
     },
     [names.updateModelInForm]: async function (
       this: SetGet,
       { path, modal, sliceName = names.model, onError, onSuccess }: CreateOption<Full> = {},
     ) {
-      const SliceName = capitalize(sliceName);
-      const namesOfSlice = {
-        defaultModel: SliceName.replace(names.Model, names.defaultModel),
-      };
       const currentState = this.get() as { [key: string]: any };
       const model = currentState[names.model] as Full | null;
       const modelForm = currentState[names.modelForm] as Input & { id: string };
-      const defaultModel = currentState[namesOfSlice.defaultModel] as Full;
+      const defaultModel = currentState[defaultKeyOf(sliceName)] as Full;
       const modelInput = (cnst.input.purify as (form: any) => DefaultOf<Input> | null)(modelForm);
       if (!modelInput) return;
       if (model?.id === modelForm.id) this.set({ [names.modelLoading]: modelForm.id });
@@ -709,19 +638,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         ...staleAtOfSlices(),
         ...(typeof path === "string" && path ? { [path]: updatedModel } : {}),
       });
-      const updatedLightModel = new cnst.light().set(updatedModel) as unknown as Light;
-      slices.forEach(({ sliceName }) => {
-        const namesOfSlice = {
-          modelList: sliceName.replace(names.model, names.modelList),
-          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        };
-        const currentState = this.get() as { [key: string]: any };
-        const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
-        const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
-        if (modelListLoading || !modelList.has(updatedModel.id)) return;
-        const newModelList = new DataList(modelList).set(updatedLightModel);
-        this.set({ [namesOfSlice.modelList]: newModelList });
-      });
+      patchLists.call(this, updatedModel);
       await onSuccess?.(updatedModel);
     },
     [names.createModel]: async function (
@@ -729,15 +646,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       data: GetStateObject<Input>,
       { path, modal, sliceName = names.model, onError, onSuccess }: CreateOption<Full> = {},
     ) {
-      const namesOfSlice = {
-        modelList: sliceName.replace(names.model, names.modelList),
-        modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        modelInsight: sliceName.replace(names.model, names.modelInsight),
-      };
       const currentState = this.get() as { [key: string]: any };
-      const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
-      const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
-      const modelInsight = currentState[namesOfSlice.modelInsight] as Insight & BaseInsight;
       const modelInput = (cnst.input.purify as (data: any) => Input | null)(data);
       if (!modelInput) return;
       this.set({ [names.modelLoading]: true });
@@ -750,14 +659,14 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         ...staleAtOfSlices(),
         ...(typeof path === "string" && path ? { [path]: model } : {}),
       });
-      applyLocalCreate.call(this, sliceName, model, { modelList, modelListLoading, modelInsight });
+      applyLocalCreate.call(this, sliceName, model, currentState);
       await onSuccess?.(model);
     },
     [names.updateModel]: async function (
       this: SetGet,
       id: string,
       data: GetStateObject<Input>,
-      { path, modal, sliceName = names.model, onError, onSuccess }: CreateOption<Full> = {},
+      { path, modal, onError, onSuccess }: CreateOption<Full> = {},
     ) {
       const currentState = this.get() as { [key: string]: any };
       const model = currentState[names.model] as Full | null;
@@ -775,19 +684,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         ...staleAtOfSlices(),
         ...(typeof path === "string" && path ? { [path]: updatedModel } : {}),
       });
-      const updatedLightModel = new cnst.light().set(updatedModel) as unknown as Light;
-      slices.forEach(({ sliceName }) => {
-        const namesOfSlice = {
-          modelList: sliceName.replace(names.model, names.modelList),
-          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        };
-        const currentState = this.get() as { [key: string]: any };
-        const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
-        const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
-        if (modelListLoading || !modelList.has(updatedModel.id)) return;
-        const newModelList = new DataList(modelList).set(updatedLightModel);
-        this.set({ [namesOfSlice.modelList]: newModelList });
-      });
+      patchLists.call(this, updatedModel);
       await onSuccess?.(updatedModel);
     },
     [names.removeModel]: async function (this: SetGet, id: string, options?: FetchPolicy & { modal?: string | null }) {
@@ -797,13 +694,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         fetchPolicyOptions,
       );
       const lightModel = new cnst.light().set(model) as unknown as Light;
-      slices.forEach(({ sliceName }) => {
-        const namesOfSlice = {
-          modelList: sliceName.replace(names.model, names.modelList),
-          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-          modelSelection: sliceName.replace(names.model, names.modelSelection),
-          modelInsight: sliceName.replace(names.model, names.modelInsight),
-        };
+      slices.forEach(({ keys: { state: namesOfSlice } }) => {
         const currentState = this.get() as { [key: string]: any };
         const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
         const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
@@ -862,17 +753,14 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       partial: Partial<Full> = {},
       { modal, setDefault, sliceName = names.model, draftScope }: NewOption = {},
     ) {
-      const SliceName = capitalize(sliceName);
-      const namesOfSlice = {
-        defaultModel: SliceName.replace(names.Model, names.defaultModel),
-      };
+      const defaultModelKey = defaultKeyOf(sliceName);
       const currentState = this.get() as { [key: string]: any };
-      const defaultModel = currentState[namesOfSlice.defaultModel] as Full;
+      const defaultModel = currentState[defaultModelKey] as Full;
       const merged = { ...plainFieldsOf(defaultModel), ...partial };
       const modelForm = immerify(modelRef, merged);
       this.set({
         [names.modelForm]: modelForm,
-        [namesOfSlice.defaultModel]: setDefault ? immerify(modelRef, merged) : defaultModel,
+        [defaultModelKey]: setDefault ? immerify(modelRef, merged) : defaultModel,
         [names.model]: null,
         [names.modelModal]: modal ?? "edit",
         [names.modelFormLoading]: false,
@@ -897,7 +785,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         [names.modelForm]: modelForm,
         [names.modelDraft]: armDraft.call(this, draftScope, modelForm, updatedAtOf(model)),
       });
-
+      
       if (draftScope) void applyDraft.call(this, { auto: false });
     },
     [names.mergeModel]: async function (
@@ -920,19 +808,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         [names.modelLoading]: false,
         ...staleAtOfSlices(),
       });
-      const updatedLightModel = new cnst.light().set(updatedModel) as unknown as Light;
-      slices.forEach(({ sliceName }) => {
-        const namesOfSlice = {
-          modelList: sliceName.replace(names.model, names.modelList),
-          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        };
-        const currentState = this.get() as { [key: string]: any };
-        const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
-        const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
-        if (modelListLoading || !modelList.has(updatedModel.id)) return;
-        const newModelList = new DataList(modelList).set(updatedLightModel);
-        this.set({ [namesOfSlice.modelList]: newModelList });
-      });
+      patchLists.call(this, updatedModel);
     },
     [names.viewModel]: async function (
       this: SetGet,
@@ -947,7 +823,6 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     [names.setModel]: function (this: SetGet, ...fullOrLightModels: Full[]) {
       const currentState = this.get() as { [key: string]: any };
       if (fullOrLightModels.length === 0) return;
-
       const firstModel = fullOrLightModels[0];
       const model = currentState[names.model] as Full | null;
       const isFull = firstModel instanceof modelRef;
@@ -958,15 +833,10 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const crystalizedModel = new cnst.full().set(model).set(firstModel) as unknown as Full;
         this.set({ [names.model]: crystalizedModel });
       }
-
       const lightModels = withSharedInstances(() =>
         fullOrLightModels.map((fullOrLightModel) => new cnst.light().set(fullOrLightModel) as unknown as Light),
       );
-      slices.forEach(({ sliceName }) => {
-        const namesOfSlice = {
-          modelList: sliceName.replace(names.model, names.modelList),
-          modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-        };
+      slices.forEach(({ keys: { state: namesOfSlice } }) => {
         const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
         const modelListLoading = currentState[namesOfSlice.modelListLoading] as boolean;
         if (modelListLoading) return;
@@ -990,13 +860,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       });
       return model ?? null;
     },
-    /**
-     * Reads whatever was saved for this scope into a form that is already filled, and turns saving on for it.
-     *
-     * `edit<Model>` does this itself once its fetch lands. This is for the shell that seeds the form straight
-     * from an RSC payload and has no reason to fetch again — without it, a fresh payload would open an editor
-     * that recovers nothing, and refetching just to reach this would undo the reason the payload was handed over.
-     */
+    
     [names.loadModelDraft]: async function (this: SetGet, draftScope?: string) {
       const currentState = this.get() as { [key: string]: any };
       const model = currentState[names.model] as Full | null;
@@ -1020,60 +884,47 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       void DraftStore.remove(draft.key);
       
       this.set({
-        
         ...(draft.appliedAt && openFormBase ? { [names.modelForm]: openFormBase } : {}),
         [names.modelDraft]: { ...draft, pending: null, appliedAt: null },
       });
     },
   };
-  const sliceAction = slices.reduce((acc, { sliceName, slice }) => {
-    const SliceName = capitalize(sliceName);
-
+  const sliceAction = slices.reduce((acc, { sliceName, keys, slice }) => {
+    
     const requests = new SliceRequest();
-
-    let liveWatch: { signature: string; dispose: () => void } | null = null;
     
+    let liveWatch: { signature: string; dispose: () => void } | null = null;
     const livePauseIdxs = (slice.live?.pauseOn ?? [])
       .map((name) => slice.args.findIndex((arg) => arg.name === name))
       .filter((idx) => idx >= 0);
-    const namesOfSlice: { [key in SliceActionKey | SliceStateKey | "modelList"]: string } = {
-      defaultModel: SliceName.replace(names.Model, names.defaultModel),
-      modelInsight: sliceName.replace(names.model, names.modelInsight),
-      modelList: sliceName.replace(names.model, names.modelList),
-      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
-      initModel: SliceName.replace(names.Model, names.initModel),
-      modelInitList: SliceName.replace(names.Model, names.modelInitList),
-      modelInitAt: SliceName.replace(names.Model, names.modelInitAt),
-      modelStaleAt: SliceName.replace(names.Model, names.modelStaleAt),
-      refreshModel: SliceName.replace(names.Model, names.refreshModel),
-      selectModel: SliceName.replace(names.Model, names.selectModel),
-      setPageOfModel: SliceName.replace(names.Model, names.setPageOfModel),
-      loadMoreOfModel: SliceName.replace(names.Model, names.loadMoreOfModel),
-      setLimitOfModel: SliceName.replace(names.Model, names.setLimitOfModel),
-      setQueryArgsOfModel: SliceName.replace(names.Model, names.setQueryArgsOfModel),
-      setSortOfModel: SliceName.replace(names.Model, names.setSortOfModel),
-      applyLiveModel: SliceName.replace(names.Model, names.applyLiveModel),
-      watchLiveModel: SliceName.replace(names.Model, names.watchLiveModel),
-      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),
-      modelSelection: SliceName.replace(names.Model, names.modelSelection),
-    };
-    /**
-     * Whether the server still holds rows past the ones just returned.
-     *
-     * Read off the batch rather than off `<model>Insight`, because the count is a second query — absent entirely
-     * under `{ insight: false }`, and one live event out of step with the list the rest of the time. A short
-     * batch is the server saying it had nothing more; a full one costs at most one extra request that comes back
-     * empty when the total happens to be a multiple of the limit.
-     */
+    const namesOfSlice = { ...keys.state, ...keys.action };
+    
     const hasMoreFrom = (batch: unknown[], askedFor: number) => ({
       [namesOfSlice.hasMoreOfModel]: batch.length >= askedFor && askedFor > 0,
     });
+    const fetchList = (queryArgs: unknown[], skip: number, limit: number, sort: Sort, options?: object) =>
+      (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
+        ...expandQueryArgs(queryArgs, slice.args),
+        skip,
+        limit,
+        sort,
+        options,
+      );
+    const fetchInsight = (queryArgs: unknown[], options?: object) =>
+      (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(
+        ...expandQueryArgs(queryArgs, slice.args),
+        options,
+      );
+    const loadList = async <T>(self: SetGet, load: () => Promise<T>, commit: (loaded: T) => object) => {
+      self.set({ [namesOfSlice.modelListLoading]: true });
+      const ticket = requests.claim();
+      try {
+        const loaded = await load();
+        if (requests.isCurrent(ticket)) self.set(commit(loaded));
+      } finally {
+        if (requests.isCurrent(ticket)) self.set({ [namesOfSlice.modelListLoading]: false });
+      }
+    };
     const singleSliceAction = {
       [namesOfSlice.initModel]: async function (
         this: SetGet,
@@ -1118,7 +969,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const modelOperation = currentState[names.modelOperation] as string;
         const isCumulative = currentState[namesOfSlice.isCumulativeOfModel] as boolean;
         const loadedLength = (currentState[namesOfSlice.modelList] as DataList<Light>).length;
-
+        
         const fetchLimit = isCumulative ? Math.max(limit, loadedLength) : limit;
         const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel] as object[];
         const pageOfModel = currentState[namesOfSlice.pageOfModel] as number;
@@ -1132,49 +983,34 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
           limit === limitOfModel &&
           isQueryEqual(sort as unknown as object, sortOfModel as unknown as object)
         )
-          return; 
-        else this.set({ [namesOfSlice.modelListLoading]: true });
-        const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
-
-        try {
-          
-          const [modelDataList, modelObjInsight] = await Promise.all([
-            (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-              ...fetchQueryArgs,
-              (page - 1) * limit,
-              fetchLimit,
-              sort,
-              { ...fetchPolicy, onError: initForm.onError },
-            ),
-            insight === false
-              ? null
-              : (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(
-                  ...fetchQueryArgs,
-                  { ...fetchPolicy, onError: initForm.onError },
-                ),
-          ]);
-          if (!requests.isCurrent(ticket)) return;
-          const modelList = new DataList(modelDataList);
-          const modelInsight =
-            modelObjInsight ??
-            (new cnst.insight().set({ count: modelDataList.length }) as unknown as Insight & BaseInsight);
-          this.set({
-            [namesOfSlice.modelList]: modelList,
-            [namesOfSlice.modelInsight]: modelInsight,
-            [namesOfSlice.modelInitList]: modelList,
-            [namesOfSlice.modelInitAt]: new Date(),
-            [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / (limit || 20)) + 1, 1),
-            ...hasMoreFrom(modelDataList, fetchLimit),
-            [namesOfSlice.limitOfModel]: limit,
-            [namesOfSlice.queryArgsOfModel]: queryArgs,
-            [namesOfSlice.sortOfModel]: sort,
-            [namesOfSlice.pageOfModel]: page,
-            [names.modelOperation]: "idle",
-          });
-        } finally {
-          if (requests.isCurrent(ticket)) this.set({ [namesOfSlice.modelListLoading]: false });
-        }
+          return;
+        await loadList(
+          this,
+          () =>
+            Promise.all([
+              fetchList(queryArgs, (page - 1) * limit, fetchLimit, sort, { ...fetchPolicy, onError: initForm.onError }),
+              insight === false ? null : fetchInsight(queryArgs, { ...fetchPolicy, onError: initForm.onError }),
+            ]),
+          ([modelDataList, modelObjInsight]) => {
+            const modelList = new DataList(modelDataList);
+            const modelInsight =
+              modelObjInsight ??
+              (new cnst.insight().set({ count: modelDataList.length }) as unknown as Insight & BaseInsight);
+            return {
+              [namesOfSlice.modelList]: modelList,
+              [namesOfSlice.modelInsight]: modelInsight,
+              [namesOfSlice.modelInitList]: modelList,
+              [namesOfSlice.modelInitAt]: new Date(),
+              [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / (limit || 20)) + 1, 1),
+              ...hasMoreFrom(modelDataList, fetchLimit),
+              [namesOfSlice.limitOfModel]: limit,
+              [namesOfSlice.queryArgsOfModel]: queryArgs,
+              [namesOfSlice.sortOfModel]: sort,
+              [namesOfSlice.pageOfModel]: page,
+              [names.modelOperation]: "idle",
+            };
+          },
+        );
       },
       [namesOfSlice.selectModel]: function (
         this: SetGet,
@@ -1200,48 +1036,21 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const limitOfModel = currentState[namesOfSlice.limitOfModel] as number;
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (pageOfModel === page) return;
-        this.set({ [namesOfSlice.modelListLoading]: true });
-        const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
-        try {
-          const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-            ...fetchQueryArgs,
-            (page - 1) * limitOfModel,
-            limitOfModel,
-            sortOfModel,
-            options,
-          );
-          if (!requests.isCurrent(ticket)) return;
-          this.set({
+        await loadList(
+          this,
+          () => fetchList(queryArgsOfModel, (page - 1) * limitOfModel, limitOfModel, sortOfModel, options),
+          (modelDataList) => ({
             [namesOfSlice.modelList]: new DataList(modelDataList),
             [namesOfSlice.pageOfModel]: page,
             [namesOfSlice.isCumulativeOfModel]: false,
             ...hasMoreFrom(modelDataList, limitOfModel),
-          });
-        } finally {
-          if (requests.isCurrent(ticket)) this.set({ [namesOfSlice.modelListLoading]: false });
-        }
+          }),
+        );
       },
-      /**
-       * Appends the rows after the ones already loaded, turning this slice's window into a cumulative list.
-       *
-       * The offset is the list on screen rather than a page number, and that is the whole point. A page number
-       * assumes the server's ordering baseline has not moved, which a live insertion at the front breaks on the
-       * first event; the rows in hand are the first `n` the query returns whatever has been inserted since, so
-       * asking for what comes after them cannot drift from what is displayed. It also leaves `pageOf<Model>` at
-       * 1, which is what keeps live placement — refused anywhere but the first page — working past the first
-       * "more".
-       *
-       * It reads `<model>ListLoading` and never sets it: an append leaves the rows on screen, so raising it
-       * would put the whole-list spinner over one and would make `applyLive<Model>` drop every live event until
-       * the batch lands. So concurrent calls are NOT rejected — two of them fetch the same offset, since the
-       * list they measure has not grown yet. That is a wasted round trip and never a wrong list: the ticket
-       * makes only the newest response apply, and both asked for the same rows. A caller that minds the wasted
-       * request holds its own in-flight flag, the way `InfiniteScroll` does.
-       */
+
       [namesOfSlice.loadMoreOfModel]: async function (this: SetGet, options?: FetchPolicy) {
         const currentState = this.get() as { [key: string]: any };
-
+        
         if (currentState[namesOfSlice.modelListLoading] as boolean) return;
         if (!(currentState[namesOfSlice.hasMoreOfModel] as boolean)) return;
         const modelList = currentState[namesOfSlice.modelList] as DataList<Light>;
@@ -1250,17 +1059,15 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const limitOfModel = (currentState[namesOfSlice.limitOfModel] as number) || 20;
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
-        const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-          ...fetchQueryArgs,
+        const modelDataList = await fetchList(
+          queryArgsOfModel,
           (pageOfModel - 1) * limitOfModel + modelList.length,
           limitOfModel,
           sortOfModel,
           options,
         );
-
         if (!requests.isCurrent(ticket)) return;
-
+        
         const currentModelList = (this.get() as { [key: string]: any })[namesOfSlice.modelList] as DataList<Light>;
         this.set({
           [namesOfSlice.modelList]: new DataList([...currentModelList.values, ...modelDataList]),
@@ -1278,29 +1085,18 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         if (limitOfModel === limit) return;
         const skip = (pageOfModel - 1) * limitOfModel;
         const page = Math.max(Math.floor((skip - 1) / limit) + 1, 1);
-        this.set({ [namesOfSlice.modelListLoading]: true });
-        const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
-        try {
-          const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-            ...fetchQueryArgs,
-            (page - 1) * limit,
-            limit,
-            sortOfModel,
-            options,
-          );
-          if (!requests.isCurrent(ticket)) return;
-          this.set({
+        await loadList(
+          this,
+          () => fetchList(queryArgsOfModel, (page - 1) * limit, limit, sortOfModel, options),
+          (modelDataList) => ({
             [namesOfSlice.modelList]: new DataList(modelDataList),
             [namesOfSlice.lastPageOfModel]: Math.max(Math.floor((modelInsight.count - 1) / limit) + 1, 1),
             [namesOfSlice.limitOfModel]: limit,
             [namesOfSlice.pageOfModel]: page,
             [namesOfSlice.isCumulativeOfModel]: false,
             ...hasMoreFrom(modelDataList, limit),
-          });
-        } finally {
-          if (requests.isCurrent(ticket)) this.set({ [namesOfSlice.modelListLoading]: false });
-        }
+          }),
+        );
       },
       [namesOfSlice.setQueryArgsOfModel]: async function (
         this: SetGet,
@@ -1322,27 +1118,16 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (isQueryEqual(queryArgsOfModel, queryArgs)) {
           Logger.trace(`${namesOfSlice.queryArgsOfModel} store-level cache hit`);
-          return; 
+          return;
         }
-        this.set({ [namesOfSlice.modelListLoading]: true });
-        const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
-        try {
-          const [modelDataList, modelInsight] = await Promise.all([
-            (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-              ...fetchQueryArgs,
-              0,
-              limitOfModel,
-              sortOfModel,
-              options,
-            ),
-            (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(
-              ...fetchQueryArgs,
-              options,
-            ),
-          ]);
-          if (!requests.isCurrent(ticket)) return;
-          this.set({
+        await loadList(
+          this,
+          () =>
+            Promise.all([
+              fetchList(queryArgs, 0, limitOfModel, sortOfModel, options),
+              fetchInsight(queryArgs, options),
+            ]),
+          ([modelDataList, modelInsight]) => ({
             [namesOfSlice.queryArgsOfModel]: queryArgs,
             [namesOfSlice.modelList]: new DataList(modelDataList),
             [namesOfSlice.modelInsight]: modelInsight,
@@ -1351,49 +1136,28 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
             [namesOfSlice.isCumulativeOfModel]: false,
             ...hasMoreFrom(modelDataList, limitOfModel),
             [namesOfSlice.modelSelection]: new Map(),
-          });
-        } finally {
-          if (requests.isCurrent(ticket)) this.set({ [namesOfSlice.modelListLoading]: false });
-        }
+          }),
+        );
       },
       [namesOfSlice.setSortOfModel]: async function (this: SetGet, sort: Sort, options?: FetchPolicy) {
         const currentState = this.get() as { [key: string]: any };
         const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel] as object[];
         const limitOfModel = currentState[namesOfSlice.limitOfModel] as number;
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
-        if (sortOfModel === sort) return; 
-        this.set({ [namesOfSlice.modelListLoading]: true });
-        const ticket = requests.claim();
-        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
-        try {
-          const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-            ...fetchQueryArgs,
-            0,
-            limitOfModel,
-            sort,
-            options,
-          );
-          if (!requests.isCurrent(ticket)) return;
-          this.set({
+        if (sortOfModel === sort) return;
+        await loadList(
+          this,
+          () => fetchList(queryArgsOfModel, 0, limitOfModel, sort, options),
+          (modelDataList) => ({
             [namesOfSlice.modelList]: new DataList(modelDataList),
             [namesOfSlice.sortOfModel]: sort,
             [namesOfSlice.pageOfModel]: 1,
             [namesOfSlice.isCumulativeOfModel]: false,
             ...hasMoreFrom(modelDataList, limitOfModel),
-          });
-        } finally {
-          if (requests.isCurrent(ticket)) this.set({ [namesOfSlice.modelListLoading]: false });
-        }
+          }),
+        );
       },
-      /**
-       * Applies one live event to this slice's window.
-       *
-       * The verb already answers membership — the server evaluated this slice's own query against the document
-       * before and after the write, so arriving here at all is the proof, and nothing is re-checked. What is left
-       * is the window: `<slice>List` is a prefix of the list, not the list, so an insertion is only ever attempted
-       * where its position can be known. Everywhere else the list is stamped stale and refetched, which is always
-       * correct and merely costs a round trip.
-       */
+      
       [namesOfSlice.applyLiveModel]: function (this: SetGet, event: LiveEventPayload) {
         const currentState = this.get() as { [key: string]: any };
         if (currentState[namesOfSlice.modelListLoading] as boolean) return;
@@ -1421,12 +1185,12 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         }
         const light = event.light ? (new cnst.light().set(event.light) as unknown as Light) : null;
         if (event.op === "update") {
-
+          
           if (!light || !modelList.has(event.id)) return;
           this.set({ [namesOfSlice.modelList]: new DataList(modelList).set(light).save() });
           return;
         }
-
+        
         const placement =
           light && !modelList.has(event.id)
             ? livePlacementIndex({
@@ -1445,7 +1209,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
           this.set({ ...(modelList.has(event.id) ? {} : countedTo(modelInsight.count + 1)), ...staleAt });
           return;
         }
-
+        
         const inserted = [...modelList.slice(0, placement), light, ...modelList.slice(placement)];
         const placed = isCumulative ? inserted : inserted.slice(0, limit);
         this.set({
@@ -1454,17 +1218,11 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
           ...staleAt,
         });
       },
-      /**
-       * Opens this slice's live room for `queryArgs`, or closes it when given null.
-       *
-       * One room per slice, not per component. The list a room writes into is a single piece of store state, so a
-       * second subscription would apply every event to it twice — a count off by one per extra reader, which is
-       * exactly the kind of drift nothing surfaces until someone counts.
-       */
+      
       [namesOfSlice.watchLiveModel]: function (this: SetGet, queryArgs: unknown[] | null) {
         if (!slice.live) return;
         const args = queryArgs ? expandQueryArgs(normalizeQueryArgs(queryArgs, slice.args), slice.args) : null;
-
+        
         const paused = !!args && livePauseIdxs.some((idx) => args[idx] != null);
         const signature = args && !paused ? JSON.stringify(args) : null;
         if (liveWatch && signature !== liveWatch.signature) {
@@ -1475,7 +1233,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const self = this as unknown as DynamicRecord;
         const apply = self[namesOfSlice.applyLiveModel] as (event: unknown) => void;
         const refresh = self[namesOfSlice.refreshModel] as (form: object) => Promise<void>;
-
+        
         const subscribe = fetch[`subscribe${capitalize(sliceName.replace(names.model, `${names.model}Live`))}`] as
           | ((...args: unknown[]) => () => void)
           | undefined;