nexus-shared 4.0.0 → 4.1.0

package/dist/Helpers/TreeStore.js

@@ -12,6 +12,17 @@
  * itself: the view asks, and tells the store what came back (`beginLoad`, `receivePage`, `failLoad`).
  */
 import { RequestCache } from "./RequestCache.js";
+/** Where a tree keeps the filter chosen in this browser: per `key` and `viewer`, nothing without a viewer. */
+export function treeFilterStorageKey(remember) {
+    const viewer = remember?.viewer?.trim();
+    return remember?.key && viewer ? `nx-tree-filter:${remember.key}:${viewer}` : null;
+}
+/** The filter on: the one chosen, else the default, else the first; `undefined` without filters. An id no filter has is passed over. */
+export function shownTreeFilter(filters, chosen, defaultId) {
+    if (!filters || filters.length === 0)
+        return undefined;
+    return filters.find(filter => filter.id === chosen) ?? filters.find(filter => filter.id === defaultId) ?? filters[0];
+}
 /** Children's pages kept for every lazy tree on the page that names a `cacheKey`, for 5 minutes: see `RequestCache`. */
 export const treePages = new RequestCache();
 /** The start of every key a tree keeps its pages under, or one parent's pages (`null`: the top level). */
@@ -310,6 +321,11 @@ export class TreeStore {
     openNodes = 0;
     openCheckedNodes = 0;
     indexCache = null;
+    /** The leaves shown (`setFilter`); `null`: all. */
+    match = null;
+    /** Goes up whenever a node's counts are worked out again, so what is kept from them knows it is old. */
+    counted = 0;
+    shownRoots = null;
     constructor(items = [], options = {}, value) {
         this.valueKey = options.valueKey ?? TREE_DEFAULT_KEYS.value;
         this.parentKey = options.parentKey ?? TREE_DEFAULT_KEYS.parent;
@@ -322,8 +338,40 @@ export class TreeStore {
         this.isChecked = options.isItemChecked ?? defaultChecked;
         if (this.lazy && options.lazyRoots)
             this.rootPages = idlePages();
+        this.match = options.filter ?? null;
         this.setItems(items, value);
     }
+    /** Whether a filter is on (`setFilter`). */
+    get filtered() {
+        return this.match !== null;
+    }
+    /**
+     * Shows only the leaves `match` takes, and the parents that hold one (`null`: every item). Nothing is checked or
+     * unchecked by it, and the value is the same whatever filter is on. While one is on, a parent's box, its count, and a
+     * check of it - or of "select all" - work on the leaves shown only: checking a parent checks its shown leaves, and a
+     * leaf the filter hides keeps its check exactly as it was. Expanded items stay expanded.
+     */
+    setFilter(match) {
+        this.match = match;
+        this.recount(preOrder(this.roots));
+        this.rows = this.visibleRows(this.roots, null);
+    }
+    /** Children of a parent (`null`: the top level) that are rows of the filtered tree: all of them without a filter. */
+    shownChildCount(parent) {
+        if (parent)
+            return parent.shownChildren;
+        if (this.match === null)
+            return this.roots.length;
+        // Counted once per change of counts, not once per row drawn.
+        if (this.shownRoots?.counted !== this.counted) {
+            let count = 0;
+            for (const root of this.roots)
+                if (root.shown)
+                    count++;
+            this.shownRoots = { counted: this.counted, count };
+        }
+        return this.shownRoots.count;
+    }
     /** Items in the tree, drafts included. */
     get size() {
         return this.byKey.size;
@@ -456,15 +504,22 @@ export class TreeStore {
      * unloaded items are not in the value - unless the value names it (`valueMode: "checked"`, where it stands for all).
      */
     state(node) {
+        return this.stateOver(node, node.shownChecked, node.shownLeaves);
+    }
+    /** The state of a parent over all of its leaves, whatever the filter shows. */
+    wholeState(node) {
+        return this.stateOver(node, node.checkedLeaves, node.leaves);
+    }
+    stateOver(node, checked, leaves) {
         if (!this.cascade || node.children.length === 0)
             return node.checked ? "checked" : "unchecked";
         if (node.partial)
-            return this.pending.has(node.key) ? "checked" : node.checkedLeaves > 0 ? "mixed" : "unchecked";
-        if (node.checkedLeaves === 0)
+            return this.pending.has(node.key) ? "checked" : checked > 0 ? "mixed" : "unchecked";
+        if (checked === 0)
             return "unchecked";
-        return node.checkedLeaves === node.leaves ? "checked" : "mixed";
+        return checked === leaves ? "checked" : "mixed";
     }
-    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. */
+    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. The filter does not narrow it. */
     counts() {
         if (!this.cascade)
             return { checked: this.checkedNodes, total: this.byKey.size };
@@ -476,6 +531,29 @@ export class TreeStore {
         }
         return { checked, total };
     }
+    /** `counts` over what the filter shows: the leaves shown with `cascade`, the rows of items without it. */
+    shownCounts() {
+        if (this.match === null)
+            return this.counts();
+        let checked = 0;
+        let total = 0;
+        if (this.cascade) {
+            for (const root of this.roots) {
+                checked += root.shownChecked;
+                total += root.shownLeaves;
+            }
+        }
+        else {
+            for (const node of this.byKey.values()) {
+                if (!node.shown)
+                    continue;
+                total++;
+                if (node.checked)
+                    checked++;
+            }
+        }
+        return { checked, total };
+    }
     /**
      * The checked values, in tree order, following `valueMode`. In a lazy tree, values whose items are not loaded yet
      * (or not settled) follow the others, so a saved value survives until its items come.
@@ -543,9 +621,12 @@ export class TreeStore {
             return false;
         if (!this.cascade)
             return this.setNodeChecked(node, !node.checked);
-        return this.setChecked(node, node.openChecked < node.openLeaves);
+        return this.setChecked(node, node.shownOpenChecked < node.shownOpenLeaves);
     }
-    /** Checks or unchecks a node; with `cascade`, every item under it that is not locked. Returns whether anything changed. */
+    /**
+     * Checks or unchecks a node; with `cascade`, every item under it that is not locked - and, while a filter is on, that
+     * the filter shows: the hidden ones keep their checks. Returns whether anything changed.
+     */
     setChecked(node, checked) {
         if (node.locked || node.status)
             return false;
@@ -559,7 +640,7 @@ export class TreeStore {
             this.dropClaimsAbove(node);
         return changed;
     }
-    /** The state of a "select all" box, over the items that are not locked; `null` when every item is locked. */
+    /** The state of a "select all" box, over the items that are not locked (and shown); `null` when every one is locked. */
     allState() {
         let open = this.openNodes;
         let checked = this.openCheckedNodes;
@@ -567,8 +648,19 @@ export class TreeStore {
             open = 0;
             checked = 0;
             for (const root of this.roots) {
-                open += root.openLeaves;
-                checked += root.openChecked;
+                open += root.shownOpenLeaves;
+                checked += root.shownOpenChecked;
+            }
+        }
+        else if (this.match !== null) {
+            open = 0;
+            checked = 0;
+            for (const node of this.byKey.values()) {
+                if (!node.shown || node.locked)
+                    continue;
+                open++;
+                if (node.checked)
+                    checked++;
             }
         }
         if (open === 0)
@@ -581,9 +673,9 @@ export class TreeStore {
         return state !== null && this.checkAll(state !== "checked");
     }
     /**
-     * Checks or unchecks every item that is not locked. Returns whether anything changed. In a lazy tree with `cascade`,
-     * a node whose items are not all loaded is passed over and the loaded parts under it are changed; values whose
-     * items are not loaded stay as they are.
+     * Checks or unchecks every item that is not locked, and that the filter shows. Returns whether anything changed. In a
+     * lazy tree with `cascade`, a node whose items are not all loaded is passed over and the loaded parts under it are
+     * changed; values whose items are not loaded stay as they are.
      */
     checkAll(checked) {
         let changed = false;
@@ -593,7 +685,7 @@ export class TreeStore {
         }
         else {
             for (const node of preOrder(this.roots))
-                changed = (!node.locked && this.setNodeChecked(node, checked)) || changed;
+                changed = (!node.locked && node.shown && this.setNodeChecked(node, checked)) || changed;
         }
         return changed;
     }
@@ -602,6 +694,9 @@ export class TreeStore {
     isVisible(node) {
         if (node.status)
             return this.indexOf(node) >= 0;
+        // A node the filter hides is no row; a shown node's parents are shown too.
+        if (!node.shown)
+            return false;
         for (let parent = node.parent; parent; parent = parent.parent)
             if (!parent.expanded)
                 return false;
@@ -888,7 +983,7 @@ export class TreeStore {
         const removed = preOrder([node]);
         // A parent that loses its last child becomes a leaf, checked when all of its items were.
         if (parent && this.cascade && siblings.length === 1)
-            parent.checked = this.state(parent) === "checked";
+            parent.checked = this.wholeState(parent) === "checked";
         siblings.splice(index, 1);
         if (parent && parent.children.length === 0 && !this.canExpand(parent))
             parent.expanded = false;
@@ -1086,6 +1181,12 @@ export class TreeStore {
             draft: false,
             pages: this.lazy ? this.newPages(item) : undefined,
             partial: false,
+            shown: true,
+            shownChildren: 0,
+            shownLeaves: 1,
+            shownChecked: 0,
+            shownOpenLeaves: 0,
+            shownOpenChecked: 0,
         };
     }
     /** A lazy node's pages before anything is asked: none to ask for when its item says it has no children. */
@@ -1134,6 +1235,8 @@ export class TreeStore {
         }
         for (let index = path.length - 1; index >= 0; index--)
             this.aggregate(path[index]);
+        if (this.match !== null && added.length > 0)
+            shownPositions(siblings);
         this.count(path, 1);
         this.count(added, 1);
         return added;
@@ -1287,6 +1390,9 @@ export class TreeStore {
             stack.push(nodes[index]);
         while (stack.length > 0) {
             const node = stack.pop();
+            // Hidden by the filter, with everything under it.
+            if (!node.shown)
+                continue;
             list.push(node);
             if (!node.expanded)
                 continue;
@@ -1336,6 +1442,12 @@ export class TreeStore {
                 openChecked: 0,
                 draft: false,
                 partial: false,
+                shown: true,
+                shownChildren: 0,
+                shownLeaves: 0,
+                shownChecked: 0,
+                shownOpenLeaves: 0,
+                shownOpenChecked: 0,
             };
             this.statusRows.set(parentKey, row);
         }
@@ -1371,6 +1483,12 @@ export class TreeStore {
         }
         for (let index = ordered.length - 1; index >= 0; index--)
             this.aggregate(ordered[index]);
+        // Under a filter a row's place among its siblings (aria-posinset) counts the shown ones only.
+        if (this.match !== null) {
+            shownPositions(this.roots);
+            for (const node of ordered)
+                shownPositions(node.children);
+        }
         this.checkedNodes = 0;
         this.openNodes = 0;
         this.openCheckedNodes = 0;
@@ -1381,6 +1499,7 @@ export class TreeStore {
      * does for every node, and what a page of children does for each node on its parent's path.
      */
     aggregate(node) {
+        this.counted++;
         const pages = node.pages;
         const own = pages !== undefined && (pages.status !== "ready" || pages.hasMore);
         if (node.children.length === 0) {
@@ -1392,6 +1511,14 @@ export class TreeStore {
             node.checkedLeaves = node.checked ? 1 : 0;
             node.openLeaves = fixed ? 0 : 1;
             node.openChecked = fixed ? 0 : node.checkedLeaves;
+            // A draft being named shows whatever the filter says: its name box must not vanish.
+            const matched = this.match === null || node.draft || this.match(node.item);
+            node.shown = matched || own;
+            node.shownChildren = 0;
+            node.shownLeaves = matched ? 1 : 0;
+            node.shownChecked = matched ? node.checkedLeaves : 0;
+            node.shownOpenLeaves = matched ? node.openLeaves : 0;
+            node.shownOpenChecked = matched ? node.openChecked : 0;
             return;
         }
         let leaves = 0;
@@ -1399,7 +1526,13 @@ export class TreeStore {
         let openLeaves = 0;
         let openChecked = 0;
         let allLocked = true;
+        let shownLocked = true;
         let partial = own;
+        let shownChildren = 0;
+        let shownLeaves = 0;
+        let shownChecked = 0;
+        let shownOpenLeaves = 0;
+        let shownOpenChecked = 0;
         for (const child of node.children) {
             leaves += child.leaves;
             checked += child.checkedLeaves;
@@ -1407,14 +1540,29 @@ export class TreeStore {
             openChecked += child.openChecked;
             allLocked &&= child.locked;
             partial ||= child.partial;
+            if (!child.shown)
+                continue;
+            shownChildren++;
+            shownLeaves += child.shownLeaves;
+            shownChecked += child.shownChecked;
+            shownOpenLeaves += child.shownOpenLeaves;
+            shownOpenChecked += child.shownOpenChecked;
+            shownLocked &&= child.locked;
         }
         node.leaves = leaves;
         node.checkedLeaves = checked;
         node.openLeaves = openLeaves;
         node.openChecked = openChecked;
         node.partial = partial;
-        // A parent's box follows its items only with cascade; without it, a parent stays free.
-        node.locked = node.disabledPath || (this.cascade && allLocked);
+        node.shown = this.match === null || shownChildren > 0 || own;
+        node.shownChildren = shownChildren;
+        node.shownLeaves = shownLeaves;
+        node.shownChecked = shownChecked;
+        node.shownOpenLeaves = shownOpenLeaves;
+        node.shownOpenChecked = shownOpenChecked;
+        // A parent's box follows its items only with cascade; without it, a parent stays free. Under a filter it follows the
+        // items shown: a parent whose shown items are all locked has nothing a check could change.
+        node.locked = node.disabledPath || (this.cascade && (this.match !== null && shownChildren > 0 ? shownLocked : allLocked));
     }
     /** Sets every open leaf under a node (the node itself for a leaf), updating counts up the path of each leaf that changes. */
     setLeaves(node, checked) {
@@ -1422,8 +1570,9 @@ export class TreeStore {
         const stack = [node];
         while (stack.length > 0) {
             const current = stack.pop();
-            // A subtree that is locked, or already all checked or all unchecked, has nothing to change.
-            if (current.locked || current.openChecked === (checked ? current.openLeaves : 0))
+            // A subtree that is locked, or whose shown leaves are already all checked or all unchecked, has nothing to change:
+            // a leaf the filter hides counts in no `shown` number, so it is never reached.
+            if (current.locked || current.shownOpenChecked === (checked ? current.shownOpenLeaves : 0))
                 continue;
             if (current.children.length > 0) {
                 for (const child of current.children)
@@ -1435,6 +1584,8 @@ export class TreeStore {
             for (let path = current; path; path = path.parent) {
                 path.checkedLeaves += step;
                 path.openChecked += step;
+                path.shownChecked += step;
+                path.shownOpenChecked += step;
             }
             changed = true;
         }
@@ -1449,10 +1600,16 @@ export class TreeStore {
         if (!node.locked)
             this.openCheckedNodes += step;
         if (node.children.length === 0) {
+            const shown = node.shownLeaves === 1;
             for (let path = node; path; path = path.parent) {
                 path.checkedLeaves += step;
                 if (!node.locked)
                     path.openChecked += step;
+                if (!shown)
+                    continue;
+                path.shownChecked += step;
+                if (!node.locked)
+                    path.shownOpenChecked += step;
             }
         }
         return true;
@@ -1517,6 +1674,13 @@ function valueMap(values) {
     }
     return map;
 }
+/** Numbers siblings among the shown ones (`position`), as a filtered tree's rows are read out. */
+function shownPositions(siblings) {
+    let position = 0;
+    for (const node of siblings)
+        if (node.shown)
+            node.position = position++;
+}
 /** Nodes in tree order: each node, then its children. No recursion, so even a chain 100,000 levels deep works. */
 export function preOrder(nodes) {
     const list = [];

package/dist/Interfaces/ApiInterfaces.d.ts

@@ -8,7 +8,9 @@ export type ApiModuleValue = string | number;
  * **These numbers are the backend's, not this package's.** A permission is a bitmask of them, so a value that differs
  * from the backend by one bit does not fail loudly: it silently grants or denies the wrong module. `Chat` was added
  * at bit 6 in the backend on 2026-09-25 and every module after it moved up one bit; this list moved with it, which
- * changed the value of `Accounting` through `Portfolio`. See CHANGELOG.md.
+ * changed the value of `Accounting` through `Portfolio`. `Inventory` was added at bit 17 on 2026-11-09, after
+ * `Portfolio`: no value moved. `Report` (bit 8) was retired on 2026-11-11 and keeps its bit, which no module may take.
+ * A new module takes the next bit at the end, never one in between. See CHANGELOG.md.
  */
 export declare const NexusModule: {
     /** The app's own API routes (`/api/...`), not a backend module. */
@@ -21,6 +23,11 @@ export declare const NexusModule: {
     readonly Message: number;
     readonly Chat: number;
     readonly Accounting: number;
+    /**
+     * @deprecated Retired by the backend on 2026-11-11: its print layouts and print door are the Configuration module's
+     * now (`NexusModule.Configuration`). The value stays so that bit 8 is never given to another module, and old
+     * permission masks that hold it still read; no backend serves it, so offer it nowhere and call it never.
+     */
     readonly Report: number;
     readonly Requisition: number;
     readonly Tenant: number;
@@ -30,6 +37,8 @@ export declare const NexusModule: {
     readonly Pharmacy: number;
     readonly Staffing: number;
     readonly Portfolio: number;
+    /** Stores, items, stock received (Dakhila) and issued (Nikasha), demands, purchase orders, write-off. */
+    readonly Inventory: number;
 };
 export type NexusModule = (typeof NexusModule)[keyof typeof NexusModule];
 /**

package/dist/Interfaces/ApiInterfaces.js

@@ -5,7 +5,9 @@
  * **These numbers are the backend's, not this package's.** A permission is a bitmask of them, so a value that differs
  * from the backend by one bit does not fail loudly: it silently grants or denies the wrong module. `Chat` was added
  * at bit 6 in the backend on 2026-09-25 and every module after it moved up one bit; this list moved with it, which
- * changed the value of `Accounting` through `Portfolio`. See CHANGELOG.md.
+ * changed the value of `Accounting` through `Portfolio`. `Inventory` was added at bit 17 on 2026-11-09, after
+ * `Portfolio`: no value moved. `Report` (bit 8) was retired on 2026-11-11 and keeps its bit, which no module may take.
+ * A new module takes the next bit at the end, never one in between. See CHANGELOG.md.
  */
 export const NexusModule = {
     /** The app's own API routes (`/api/...`), not a backend module. */
@@ -18,6 +20,11 @@ export const NexusModule = {
     Message: 1 << 5,
     Chat: 1 << 6,
     Accounting: 1 << 7,
+    /**
+     * @deprecated Retired by the backend on 2026-11-11: its print layouts and print door are the Configuration module's
+     * now (`NexusModule.Configuration`). The value stays so that bit 8 is never given to another module, and old
+     * permission masks that hold it still read; no backend serves it, so offer it nowhere and call it never.
+     */
     Report: 1 << 8,
     Requisition: 1 << 9,
     Tenant: 1 << 10,
@@ -27,4 +34,6 @@ export const NexusModule = {
     Pharmacy: 1 << 14,
     Staffing: 1 << 15,
     Portfolio: 1 << 16,
+    /** Stores, items, stock received (Dakhila) and issued (Nikasha), demands, purchase orders, write-off. */
+    Inventory: 1 << 17,
 };

package/dist/Interfaces/ChatInterfaces.d.ts

@@ -1,3 +1,5 @@
+import type { ReactNode } from "react";
+import type { DomainCardDefinition } from "./DomainInterfaces.ts";
 import type { DropdownPage, DropdownPageRequest } from "./InputInterfaces.ts";
 /** An id, as the backend hands it out: a number, or text (a GUID, an encrypted id). */
 export type ChatId = string | number;
@@ -45,9 +47,22 @@ export interface ChatDomainInfo<TDomain extends ChatDomainValue = AppChatDomain>
     key: string;
     /** Its name on screen: "Leave request". */
     label: string;
+    /**
+     * How a message about a record of this kind shows the record: read live from its module and drawn as a card
+     * (`DomainCard`; a mail thread draws it at its head). Without one, the message shows the kind and the record's words.
+     */
+    card?: DomainCardDefinition<any>;
+    /** Its icon where its kind is listed (a mail client's Types): `<Icon name="beach" />`. Default a clipboard. */
+    icon?: ReactNode;
 }
 /** `sent`: the server has it. `sending`: on its way. `failed`: it did not arrive, and the text is kept to send again. */
 export type ChatMessageStatus = "sent" | "sending" | "failed";
+/**
+ * What a message is. `chat`: a line in a conversation, or a reply. `mail`: the message a mail thread opens with, which a
+ * person wrote. `notification`: what an app wrote about an event (approved, sent back), under the name of the person who
+ * acted - drawn as a quiet event line, not a bubble, and unread for everyone but its author.
+ */
+export type ChatMessageKind = "chat" | "mail" | "notification";
 /** A file on a message. The chat shows and links it; uploading is the app's `ChatSource`. */
 export interface ChatAttachment {
     id?: ChatId;
@@ -81,6 +96,8 @@ export interface ChatMessage {
     attachments?: readonly ChatAttachment[];
     /** Written by the system, not a person ("Sita approved the request."): a centered note, with no avatar or side. */
     isSystem?: boolean;
+    /** What it is. Default `chat`. A `notification` is drawn as an event line: who acted, what happened, when. */
+    kind?: ChatMessageKind;
     /** Who it has reached. Two ticks once anyone has it, filled once anyone has read it. */
     deliveredTo?: readonly ChatId[];
     /** Who has read it. */
@@ -147,6 +164,11 @@ export interface ChatDraft {
     files?: readonly File[];
     /** This browser's id for the message, so the answer replaces the right one and Retry sends the same draft. */
     clientId: string;
+    /**
+     * What the line is. Default: the source's own, a chat line. A mail thread's Reply sends `mail` (a new mail in the
+     * thread, drawn as mail), its discussion `chat`.
+     */
+    kind?: ChatMessageKind;
 }
 /** Someone in a conversation, or someone who could be added to it. */
 export interface ChatParticipant {

package/dist/Interfaces/CrudInterfaces.d.ts

@@ -113,12 +113,23 @@ export interface CrudFormOptions<TRow extends FormValues = FormValues> {
     aside?: ReactNode | ((context: CrudFormAsideContext<TRow>) => ReactNode);
     /** Values of a new record, over each input's default. */
     newValues?: Partial<TRow> | (() => Partial<TRow>);
+    /**
+     * Values of a new record read when the Add form opens, over `newValues`: who a new message goes to by default, a
+     * counter's usual account. The inputs show disabled until they land, and a draft of the form comes back over them.
+     * They are a help, not the record: when the read fails the form opens on `newValues` alone, and a toast says why.
+     * The values given to `create(values)` (a parent it is added under) still win.
+     */
+    createDefaults?: (signal: AbortSignal) => Promise<Partial<TRow> | null | undefined>;
     /**
      * What Edit opens with: the row as the table has it (`row`, the default), the record from the `details` endpoint
      * (`details`, for fields a list leaves out), or a function that loads it.
      */
     load?: "row" | "details" | ((row: TRow, signal: AbortSignal) => Promise<Partial<TRow> | null | undefined>);
-    /** Shapes what is sent, e.g. to add a parent's id. Default: the values, with the fields the record came with. */
+    /**
+     * Shapes what is sent, e.g. to add a parent's id. Default: the values, with the fields the record came with. The row the
+     * save leaves is built from what this sends (`crudSavedRecord`): a field it sends as null is empty on the row, whatever
+     * the form still holds.
+     */
     transform?: (values: TRow, context: {
         action: "create" | "edit";
         row: TRow | null;
@@ -132,6 +143,21 @@ export interface CrudFormOptions<TRow extends FormValues = FormValues> {
     validate?: FormProps<TRow>["validate"];
     /** Derived values: return values to set after a change. */
     onFieldChange?: FormProps<TRow>["onFieldChange"];
+    /**
+     * What the inputs worked out from others (`compute`) are handed - the form's own and those of its Tabular and Group
+     * rows (`crudInputs.lineAmount`) - worked out from the form's values as they change: a goods receipt hands its lines
+     * `{ taxed: values.source === Purchase }`, so a donation's lines count no discount or VAT. It is read after every
+     * change and compared field by field with the last answer (a shallow compare), so a fresh object of the same figures
+     * redraws nothing; a different one redraws the worked-out cells alone, with nothing remounted and the focus kept. A
+     * rule that throws keeps the last answer and says why in the console.
+     *
+     * @example
+     * form={{ computeWith: values => ({ purchase: values.source !== DONATION }) }}
+     */
+    computeWith?: (values: TRow, context: {
+        action: "create" | "edit";
+        row: TRow | null;
+    }) => unknown;
     /** Label design of every input that does not set its own. */
     design?: InputDesign;
     /**
@@ -217,6 +243,33 @@ export interface CrudDetailsOptions<TRow extends FormValues = FormValues> {
         key: string;
         viewer?: string | null;
     };
+    /**
+     * The Details tab's sections (the runs of columns with one `group`) that change on their own: an Edit button at the
+     * end of the section's numbered heading opens a form for that part only - the Crud's own Edit form (`edit: "edit"`)
+     * or one of its `rowForms` (by its `id`) - and once it is saved the workspace reads the record again (`refresh()`), so
+     * the section shows what was saved. The button is there only where the form itself is offered (Edit: a list that
+     * offers Edit, the update endpoint allowed, no `rowActionLock` on it; a row form: `crudRowFormOffered` and no `lock`),
+     * and the focus comes back to it when the form closes. Only in a record's workspace (`tabs` or `profile`).
+     *
+     * @example
+     * sections: [
+     *   { group: "KYC details", edit: "edit" },
+     *   { group: "Contact details", edit: "contacts" },   // a rowForms entry's id
+     *   { group: "Public profile", edit: "public-profile", label: "Edit", hidden: row => row.isLocked },
+     * ]
+     */
+    sections?: readonly CrudDetailsSection<TRow>[];
+}
+/** A section of a record's Details tab that changes on its own (`CrudDetailsOptions.sections`). */
+export interface CrudDetailsSection<TRow extends FormValues = FormValues> {
+    /** The `group` its columns name. */
+    group: string;
+    /** What its button opens: `"edit"`, the Crud's own Edit form, or the `id` of one of the Crud's `rowForms`. */
+    edit?: "edit" | (string & {});
+    /** The button's word. Default "Edit". */
+    label?: string;
+    /** Leaves the button out for this record. */
+    hidden?: (row: TRow) => boolean;
 }
 /**
  * A button in the details popup's footer. One that names the endpoint it calls shows only to a user who may call
@@ -516,7 +569,7 @@ export interface CrudScopes<TRow extends FormValues = FormValues> {
  * beside its Edit. The page gives its inputs, where its values are read and where a save goes, and which of the answer's
  * fields change the record; the CRUD offers it, opens it (one popup per record, brought back if open), and writes those
  * fields into the record wherever it holds it - the table, every list kept, the pinned sections - with no list read
- * again.
+ * again. With no inputs it is a question alone (a pay run's Lock): it asks over the record's figures and sends.
  *
  * @example
  * {
@@ -526,6 +579,12 @@ export interface CrudScopes<TRow extends FormValues = FormValues> {
  *   transform: (values, row) => ({ branchUserId: row.id, permissionKeys: values.permissionKeys ?? [], description: values.description }),
  *   writes: ["assignedPermissionCount"],
  * }
+ * @example
+ * {
+ *   id: "lock", label: "Lock", icon: <Icon name="lock" />, when: run => run.payRunState === PAY_RUN_DRAFT, submit: PAY_RUN_LOCK,
+ *   transform: (_values, run) => ({ id: run.id, generatedTime: run.generatedTime }), writes: result => result as Partial<PayRun>,
+ *   confirm: run => ({ title: `Lock ${run.runCode}?`, message: "It is made again first.", details: () => ({ row: run, columns: TOTALS }) }),
+ * }
  */
 export interface CrudRowForm<TRow extends FormValues = FormValues, TValues extends FormValues = FormValues> {
     /** Unique among the record's actions. */
@@ -548,8 +607,22 @@ export interface CrudRowForm<TRow extends FormValues = FormValues, TValues exten
     lock?: (row: TRow) => string | null | undefined;
     /** What the endpoints are called with in `{id}` (the record the form is about, by its token). Default the record's key. */
     target?: (row: TRow) => string | number;
-    /** The form's inputs, or a function of the record and of what `load` read (`null` until it has, and without one); it may answer a promise. */
-    inputs: readonly InputParams[] | ((row: TRow, loaded: TValues | null) => readonly InputParams[] | Promise<readonly InputParams[]>);
+    /**
+     * The form's inputs, or a function of the record and of what `load` read (`null` until it has, and without one); it may
+     * answer a promise. Without inputs the action is its question alone: no popup, it asks (`confirm`, else "{label}
+     * {the record's name}?") and saves on Confirm - the values sent are what `load` read, else the record as the list has
+     * it, through `transform`; a refusal shows as the API's message, and nothing is written.
+     */
+    inputs?: readonly InputParams[] | ((row: TRow, loaded: TValues | null) => readonly InputParams[] | Promise<readonly InputParams[]>);
+    /**
+     * Asks before it saves, showing what will be saved in full (as a form's `confirm`, `FormConfirmParams`): after every
+     * value has passed its checks, Confirm holding the focus, read out with its details, and a hasty second Enter never
+     * answering it. Params, or a function of the record and of what `load` read, for a question that names the record:
+     * `confirm: run => ({ title: "Lock " + run.runCode + "?", details: () => ({ row: run, columns: TOTALS }), confirmLabel: "Lock" })`.
+     * A form with inputs keeps "Confirm and save" and "Back to the form" unless told; a question alone defaults to its
+     * `submitLabel` (else its `label`) and "Cancel".
+     */
+    confirm?: FormConfirmParams<TValues> | ((row: TRow, loaded: TValues | null) => FormConfirmParams<TValues>);
     /**
      * Where the form's values are read: an endpoint called with the record's key (`{id}`, as the details are), or a
      * function. Until they are read the form waits, and a read that fails - an answer that is not ok, or no record - shows
@@ -582,7 +655,7 @@ export type CrudLockableAction = "edit" | "flag" | "trash" | "recover" | "delete
 /** A record's own locks, by action: the sentence that says why (`rowActionLock`). Nothing, or null, for an action that may run. */
 export type CrudActionLocks = Partial<Record<CrudLockableAction, string | null | undefined>>;
 /** Table settings a CRUD passes on to its `DataTable`. */
-export type CrudTableOptions<TRow extends FormValues = FormValues> = Pick<DataTableProps<TRow>, "pager" | "pageSize" | "pageSizes" | "defaultSort" | "numbered" | "maxHeight" | "fill" | "excel" | "size" | "searchPlaceholder" | "maxSelection" | "emptyMessage" | "columnsMenu" | "stateKey" | "currency" | "searchDelay" | "filterInputs" | "reorderable" | "resizable" | "pinnable" | "moreActions" | "exportable" | "printable" | "exportName" | "onImport" | "openOnClick">;
+export type CrudTableOptions<TRow extends FormValues = FormValues> = Pick<DataTableProps<TRow>, "pager" | "pageSize" | "pageSizes" | "defaultSort" | "numbered" | "maxHeight" | "fill" | "excel" | "size" | "searchPlaceholder" | "maxSelection" | "emptyMessage" | "columnsMenu" | "stateKey" | "currency" | "searchDelay" | "filterInputs" | "reorderable" | "resizable" | "pinnable" | "moreActions" | "exportable" | "printable" | "exportName" | "onImport" | "openOnClick" | "rowStrong">;
 /** Props of `Crud`. */
 export interface CrudProps<TRow extends FormValues = FormValues> {
     /** The endpoints: `MODULES.controller(NexusModule.Reservation, "Guest", "guest")`, or an object of your own. */