nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/AuditEntries.js

@@ -0,0 +1,96 @@
+/*
+ * The words of a record's history entry (Components/Forms/CrudHistory.tsx) that are worked out rather than drawn, so Node
+ * tests run them, and the app's way of naming the people behind the entries' tokens. Only `setAuditActorNames` and its
+ * type are exported from the package.
+ */
+/**
+ * A token, short. It names nobody and only tells two apart, so its first characters are enough. A token is the same
+ * text for one id on every entry this reader is given (the id is encrypted for the reader, not at random).
+ */
+export const shortToken = (token) => (token.length > 8 ? `${token.slice(0, 6)}…` : token);
+let actorResolver = null;
+/** What the app answered, by token, for the page's life: a second history asks only for the people it has not seen. */
+const actorNames = new Map();
+/** Tokens the app answered nothing for: not asked again, so a history full of one stranger never asks on every page. */
+const actorUnknown = new Set();
+/**
+ * Sets, once for the app, how a record's history (`AuditHistory`) names the person behind an entry its answer names
+ * nobody for (no `creatorName`). The history collects the tokens of every page it shows (the first and each "Show
+ * more"), asks once per page for those it has had no answer for, and says "by Sita Rai (sita.rai)" for each one
+ * answered. A token is the same text for one person on every entry this reader is given, so the app can look it up (its
+ * own list of people, or a call to the server that made it). A call that fails keeps the line's "User 3fA9b2…" and is
+ * asked again by the next history; a token left out of the answer keeps it for the page's life. Answers are kept for the
+ * page's life; `null` stops asking and forgets them.
+ *
+ * @example
+ * setAuditActorNames(async (tokens, signal) => {
+ *   const answer = await api.post<Record<string, string>>(USERS.names, tokens, { signal, toast: false });
+ *   return answer.ok ? answer.result : {};
+ * });
+ */
+export function setAuditActorNames(resolver) {
+    actorResolver = resolver;
+    actorNames.clear();
+    actorUnknown.clear();
+}
+/** The name the app gave for a token, once it has given one. */
+export const knownAuditActorName = (token) => (token ? actorNames.get(token) : undefined);
+/**
+ * The tokens of these entries the app is still to be asked for: entries with no name in the answer, whose token has had
+ * no answer yet, each token once. Empty without a resolver.
+ */
+export function unnamedAuditActors(entries) {
+    if (!actorResolver)
+        return [];
+    const tokens = new Set();
+    for (const entry of entries) {
+        const token = entry.creatorUserId;
+        if (!token || entry.creatorName?.trim() || actorNames.has(token) || actorUnknown.has(token))
+            continue;
+        tokens.add(token);
+    }
+    return [...tokens];
+}
+/**
+ * Asks the app, in one call, for the names of these entries' unnamed people (`unnamedAuditActors`) and keeps the answer.
+ * Resolves `true` when it learnt a name. A failed or aborted call keeps nothing, so a later history asks again.
+ */
+export async function resolveAuditActors(entries, signal) {
+    const resolver = actorResolver;
+    const tokens = unnamedAuditActors(entries);
+    if (!resolver || tokens.length === 0)
+        return false;
+    let answer;
+    try {
+        answer = await resolver(tokens, signal);
+    }
+    catch {
+        return false;
+    }
+    // The history went away, or the app set another resolver meanwhile: this answer is not kept.
+    if (signal.aborted || resolver !== actorResolver)
+        return false;
+    let learnt = false;
+    for (const token of tokens) {
+        const given = answer?.[token];
+        const name = typeof given === "string" ? given.trim() : "";
+        if (name) {
+            actorNames.set(token, name);
+            learnt = true;
+        }
+        else
+            actorUnknown.add(token);
+    }
+    return learnt;
+}
+/**
+ * Who made a change, as the entry's line says it: "by Sita Rai" when the history's answer names them (`creatorName`) or
+ * the app has named their token (`setAuditActorNames`), else the start of their token ("User 3fA9b2…"), which still
+ * tells two people apart; `null` when it says neither.
+ */
+export function auditActorText(entry) {
+    const name = entry.creatorName?.trim() || knownAuditActorName(entry.creatorUserId);
+    if (name)
+        return `by ${name}`;
+    return entry.creatorUserId ? `User ${shortToken(entry.creatorUserId)}` : null;
+}

package/dist/Helpers/BusyHooks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether to say that something is still under way: `true` only once `busy` has lasted 400ms, and then for at least
+ * 300ms, however soon `busy` ends. A status line that reads it says "Loading…" for a slow read and nothing for a quick
+ * one. A Crud's details footer and `DocumentFrame` use it.
+ */
+export declare function useSlowBusy(busy: boolean): boolean;

package/dist/Helpers/BusyHooks.js

@@ -0,0 +1,39 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+/**
+ * A read that ends sooner than this says nothing: most backends answer sooner, and a word shown for a frame or two is
+ * the flicker this avoids. Longer than a popup's 160ms fade, so the word never lands on a half-faded popup.
+ */
+const SLOW_DELAY = 400;
+/** Once the word shows, it stays at least this long, so a read that ends just after the delay does not blink it. */
+const SLOW_HOLD = 300;
+/**
+ * Whether to say that something is still under way: `true` only once `busy` has lasted 400ms, and then for at least
+ * 300ms, however soon `busy` ends. A status line that reads it says "Loading…" for a slow read and nothing for a quick
+ * one. A Crud's details footer and `DocumentFrame` use it.
+ */
+export function useSlowBusy(busy) {
+    const [said, setSaid] = useState(false);
+    const since = useRef(0);
+    useEffect(() => {
+        if (busy) {
+            if (said)
+                return;
+            const timer = window.setTimeout(() => {
+                since.current = performance.now();
+                setSaid(true);
+            }, SLOW_DELAY);
+            return () => window.clearTimeout(timer);
+        }
+        if (!said)
+            return;
+        const left = since.current + SLOW_HOLD - performance.now();
+        if (left <= 0) {
+            setSaid(false);
+            return;
+        }
+        const timer = window.setTimeout(() => setSaid(false), left);
+        return () => window.clearTimeout(timer);
+    }, [busy, said]);
+    return said;
+}

package/dist/Helpers/ChatBackend.d.ts

@@ -1,5 +1,5 @@
 import { type ApiEndpoint, type ApiModuleValue } from "../Interfaces/ApiInterfaces.ts";
-import type { AppChatDomain, ChatConversation, ChatDomainInfo, ChatDomainValue, ChatDraft, ChatHistory, ChatHistoryRequest, ChatId, ChatMessage, ChatParticipant, ChatParticipantPage, ChatParticipantQuery, ChatScope, ChatSummary, NewChatRequest } from "../Interfaces/ChatInterfaces.ts";
+import type { AppChatDomain, ChatConversation, ChatDomainInfo, ChatDomainValue, ChatDraft, ChatHistory, ChatHistoryRequest, ChatId, ChatMessage, ChatMessageKind, ChatParticipant, ChatParticipantPage, ChatParticipantQuery, ChatScope, ChatSummary, NewChatRequest } from "../Interfaces/ChatInterfaces.ts";
 /** The actions a chat needs from a backend. A backend that does not serve one takes that feature off the panel. */
 export declare const CHAT_ACTIONS: {
     /** The conversations a record holds, for this reader. */
@@ -106,6 +106,11 @@ export declare class NexusChatBackend<TDomain extends ChatDomainValue = AppChatD
     protected toConversation(row: Row): ChatConversation;
     /** One message row. The names are the ones a Nexus contract uses; override this alone for a backend that differs. */
     protected toMessage(row: Row): ChatMessage;
+    /**
+     * What a message is, from the backend's `EChatMessageTypes` (0 a chat line, 1 the mail a thread opens with, 2 a
+     * notification) or a word. Anything else is a chat line.
+     */
+    protected toKind(value: unknown): ChatMessageKind;
     /** One set of counts. */
     protected toSummary(row: Row): ChatSummary;
     /** One participant row. */
@@ -125,6 +130,8 @@ export declare function getChatBackend(): ChatBackend<any>;
  *   { domain: EDomainTypes.Leave, key: "leave", label: "Leave request" },
  *   { domain: EDomainTypes.Procurement, key: "procurement", label: "Purchase order" },
  * ]);
+ *
+ * A row's `card` shows a message's record as a card read live from its module (`domainCard`, `DomainCard`).
  */
 export declare function defineChatDomains<TDomain extends ChatDomainValue>(list: readonly ChatDomainInfo<TDomain>[]): readonly ChatDomainInfo<TDomain>[];
 /** The registered domains. Empty until an app calls `defineChatDomains`. */

package/dist/Helpers/ChatBackend.js

@@ -254,10 +254,23 @@ export class NexusChatBackend extends ChatBackend {
                 })),
             }),
             ...(row.isSystem === true && { isSystem: true }),
+            ...((row.messageType ?? row.kind) !== undefined && { kind: this.toKind(row.messageType ?? row.kind) }),
             ...(Array.isArray(row.deliveredTo) && { deliveredTo: row.deliveredTo.map(id).filter((value) => value !== null) }),
             ...(Array.isArray(row.readBy) && { readBy: row.readBy.map(id).filter((value) => value !== null) }),
         };
     }
+    /**
+     * What a message is, from the backend's `EChatMessageTypes` (0 a chat line, 1 the mail a thread opens with, 2 a
+     * notification) or a word. Anything else is a chat line.
+     */
+    toKind(value) {
+        const written = String(value).toLowerCase();
+        if (written === "1" || written === "mail")
+            return "mail";
+        if (written === "2" || written === "notification")
+            return "notification";
+        return "chat";
+    }
     /** One set of counts. */
     toSummary(row) {
         const lastText = text(row.lastMessageText ?? row.lastMessage ?? row.lastBody);
@@ -309,6 +322,8 @@ let domains = [];
  *   { domain: EDomainTypes.Leave, key: "leave", label: "Leave request" },
  *   { domain: EDomainTypes.Procurement, key: "procurement", label: "Purchase order" },
  * ]);
+ *
+ * A row's `card` shows a message's record as a card read live from its module (`domainCard`, `DomainCard`).
  */
 export function defineChatDomains(list) {
     const seen = new Set();
@@ -317,6 +332,9 @@ export function defineChatDomains(list) {
         if (seen.has(key))
             throw new Error(`Two chat domains have the value ${key}.`);
         seen.add(key);
+        if (info.card && (typeof info.card.load !== "function" || typeof info.card.view !== "function")) {
+            throw new Error(`The chat domain ${key}'s card needs a load and a view.`);
+        }
     }
     domains = list;
     return list;

package/dist/Helpers/ChatHelpers.d.ts

@@ -77,6 +77,8 @@ export interface ChatRun {
     mine: boolean;
     /** Written by the system: a centered note, with no avatar and no side. */
     system: boolean;
+    /** Notifications (`kind: "notification"`): event lines, with the author's name and no side. */
+    notification: boolean;
     /** The "New messages" line goes before this run. */
     startsUnread: boolean;
     messages: readonly ChatMessage[];

package/dist/Helpers/ChatHelpers.js

@@ -225,10 +225,12 @@ export function groupChatMessages(messages, options) {
         }
         const at = Date.parse(message.createdAt);
         const system = message.isSystem === true;
+        const notification = !system && message.kind === "notification";
         const unread = unreadFrom !== null && sameChatId(message.id, unreadFrom);
         const joins = run !== null &&
             !unread &&
             run.system === system &&
+            run.notification === notification &&
             sameChatId(run.authorId, message.authorId) &&
             Number.isFinite(at) &&
             Number.isFinite(run.last) &&
@@ -242,8 +244,9 @@ export function groupChatMessages(messages, options) {
             authorId: message.authorId,
             authorName: message.authorName?.trim() || (system ? "" : CHAT_UNKNOWN_AUTHOR),
             authorAvatar: message.authorAvatar ?? null,
-            mine: !system && sameChatId(message.authorId, userId),
+            mine: !system && !notification && sameChatId(message.authorId, userId),
             system,
+            notification,
             startsUnread: unread,
             messages: [message],
             last: Number.isFinite(at) ? at : 0,

package/dist/Helpers/CrudBackend.d.ts

@@ -105,10 +105,19 @@ export declare abstract class CrudBackend {
     answeredRow<TRow extends TableRow>(result: unknown): Partial<TRow> | null;
     /**
      * The key an answer gives in place of the record: `Create` answering the new record's id. `null` when the answer
-     * is the record itself, or says nothing. With a key the new record goes straight into the list, and where there is
-     * a `details` endpoint it is read back on its own - one small request, never the whole list again.
+     * is the record itself, or says nothing. With a key the new record goes straight into the list, finished by `savedRow`;
+     * only a record whose list still cannot be told is read back on its own through `details` - never the whole list again.
      */
     answeredKey(result: unknown): TableKey | null;
+    /**
+     * A record a save wrote - what the form sent, under what the answer said - with the fields only the server keeps
+     * filled in as this backend writes them, so nothing has to be read back: a status, the times, the marks. `before` is
+     * the record as the page holds it now (an edit; `undefined` for a new one): an edit's form carries its own copy of those
+     * fields from when it opened, which a flag or a mark made since has left behind. Default: the record as it is - and a
+     * record whose list still cannot be told from it (`listMembership`) is read back once through `details`, where there is
+     * one.
+     */
+    savedRow<TRow extends TableRow>(action: "create" | "edit", record: TRow, before?: TRow): TRow;
     /**
      * Whether a record belongs in a list, read from the record itself. It is what lets one answer be written into the
      * lists that are **not** on screen: a flagged record joins the flagged list, a trashed one leaves the active list
@@ -176,6 +185,15 @@ export declare class NexusCrudBackend extends CrudBackend {
     answeredRow<TRow extends TableRow>(result: unknown): Partial<TRow> | null;
     /** `Create` and `Update` answer the record's id: a token when ids are encrypted, the number as text when not. */
     answeredKey(result: unknown): TableKey | null;
+    /**
+     * What a Nexus save leaves to the server, written as the server writes it, so nothing is read back (the owner,
+     * 2026-10-10: "the creationTime, recordStatus we will provide fake or just right now"). A new record lacking them is
+     * Active (every Create writes `NEXUS_ACTIVE_STATUS`), has no marks, was added now and never changed; what its answer
+     * said stays. An Update writes none of the status, the marks and the time added, so an edited record has the ones the
+     * page holds (`before`) - over its form's older copies - and was changed now. Times are UTC ISO strings, as a date-time
+     * column reads them.
+     */
+    savedRow<TRow extends TableRow>(action: "create" | "edit", record: TRow, before?: TRow): TRow;
     /**
      * The bands the owner settled on: under 40 is live, 25–29 of that is flagged, 40–59 is the trash, and 60 and up is
      * deleted. A row without a `recordStatus` says nothing, and the lists it cannot answer for load again.

package/dist/Helpers/CrudBackend.js

@@ -1,4 +1,5 @@
 import { CRUD_MARK_BITS, hasMark, withMark } from "./CrudHelpers.js";
+import { nowUtcDateTime } from "./DateTimeHelpers.js";
 const NO_AUDIT_WORDS = { commands: {}, directions: {}, parts: {} };
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 export class CrudBackend {
@@ -117,13 +118,26 @@ export class CrudBackend {
     }
     /**
      * The key an answer gives in place of the record: `Create` answering the new record's id. `null` when the answer
-     * is the record itself, or says nothing. With a key the new record goes straight into the list, and where there is
-     * a `details` endpoint it is read back on its own - one small request, never the whole list again.
+     * is the record itself, or says nothing. With a key the new record goes straight into the list, finished by `savedRow`;
+     * only a record whose list still cannot be told is read back on its own through `details` - never the whole list again.
      */
     answeredKey(result) {
         void result;
         return null;
     }
+    /**
+     * A record a save wrote - what the form sent, under what the answer said - with the fields only the server keeps
+     * filled in as this backend writes them, so nothing has to be read back: a status, the times, the marks. `before` is
+     * the record as the page holds it now (an edit; `undefined` for a new one): an edit's form carries its own copy of those
+     * fields from when it opened, which a flag or a mark made since has left behind. Default: the record as it is - and a
+     * record whose list still cannot be told from it (`listMembership`) is read back once through `details`, where there is
+     * one.
+     */
+    savedRow(action, record, before) {
+        void action;
+        void before;
+        return record;
+    }
     /**
      * Whether a record belongs in a list, read from the record itself. It is what lets one answer be written into the
      * lists that are **not** on screen: a flagged record joins the flagged list, a trashed one leaves the active list
@@ -328,6 +342,36 @@ export class NexusCrudBackend extends CrudBackend {
     answeredKey(result) {
         return typeof result === "string" && result !== "" ? result : null;
     }
+    /**
+     * What a Nexus save leaves to the server, written as the server writes it, so nothing is read back (the owner,
+     * 2026-10-10: "the creationTime, recordStatus we will provide fake or just right now"). A new record lacking them is
+     * Active (every Create writes `NEXUS_ACTIVE_STATUS`), has no marks, was added now and never changed; what its answer
+     * said stays. An Update writes none of the status, the marks and the time added, so an edited record has the ones the
+     * page holds (`before`) - over its form's older copies - and was changed now. Times are UTC ISO strings, as a date-time
+     * column reads them.
+     */
+    savedRow(action, record, before) {
+        const row = { ...record };
+        const now = nowUtcDateTime();
+        const fill = (field, value) => {
+            if (value !== undefined && (row[field] === undefined || row[field] === null))
+                row[field] = value;
+        };
+        if (action === "create") {
+            fill("recordStatus", NEXUS_ACTIVE_STATUS);
+            fill("bookmarkTypes", 0);
+            fill("creationTime", now);
+            fill("modificationTime", null);
+            return row;
+        }
+        const held = (before ?? {});
+        for (const field of ["recordStatus", "bookmarkTypes", "creationTime"]) {
+            if (held[field] !== undefined)
+                row[field] = held[field];
+        }
+        row.modificationTime = now;
+        return row;
+    }
     /**
      * The bands the owner settled on: under 40 is live, 25–29 of that is flagged, 40–59 is the trash, and 60 and up is
      * deleted. A row without a `recordStatus` says nothing, and the lists it cannot answer for load again.

package/dist/Helpers/CrudColumns.d.ts

@@ -1,11 +1,24 @@
 import type { ApiEndpoint } from "../Interfaces/ApiInterfaces.ts";
-import type { InputParams } from "../Interfaces/FormInterfaces.ts";
+import { type InputParams } from "../Interfaces/FormInterfaces.ts";
 import type { TableColumn, TableJoin, TableRow } from "../Interfaces/TableInterfaces.ts";
 import { type CrudBackend } from "./CrudBackend.ts";
+import { type PriceLadderOptions } from "./NumberHelpers.ts";
 /** The longest description a record keeps: the owner's rule for every model (the column holds 4000). */
 export declare const CRUD_DESCRIPTION_MAX = 1000;
+/**
+ * The fields a record keeps its price's figures in (`crudInputs.netAmount`, `crudInputs.lineAmount`,
+ * `crudColumns.amounts`). Defaults: `price`, `discountPercentage` and `vatPercentage`, no quantity (one of it), and no
+ * `other`: an amount added whole after VAT, such as a line's carriage (`otherCostAmount`), rounded to 2 places.
+ */
+export type PriceKeys = {
+    price?: string;
+    quantity?: string;
+    discount?: string;
+    vat?: string;
+    other?: string;
+};
 export declare const crudColumns: {
-    /** The record's status in words ("Active", "Flagged", "Trashed"), from the backend's own numbers; blank until a new record is read back. */
+    /** The record's status in words ("Active", "Flagged", "Trashed"), from the backend's own numbers; blank for a record that says none. */
     status<TRow extends TableRow>(changes?: Partial<TableColumn<TRow>>, backend?: CrudBackend): TableColumn<TRow>;
     /** The description, as Markdown: text in the table, formatted in the details. */
     description<TRow extends TableRow>(changes?: Partial<TableColumn<TRow>>): TableColumn<TRow>;
@@ -16,11 +29,14 @@ export declare const crudColumns: {
     /**
      * Another record's name the **database** joined into the row: the row carries the name (`key`) and that record's own
      * status (`status`), and the cell shows the name with a short tag when the record is no longer available ("Trashed",
-     * "Deleted": `CrudBackend.unavailableTag`). One call, nothing looked up.
+     * "Deleted": `CrudBackend.unavailableTag`). One call, nothing looked up. Give it `from` - the field holding that
+     * record's key, an input of the form: a save answers what was sent, not the names the database joins, so a CRUD names
+     * it again from the record picked for the key, with no call (`crudJoinedNames`). Without `from` a CRUD reads a new
+     * record back once (`details`) to name it.
      *
-     * @example crudColumns.dbJoin({ key: "regionName", label: "Region", status: "regionRecordStatus" })
+     * @example crudColumns.dbJoin({ key: "regionName", label: "Region", status: "regionRecordStatus", from: "regionId" })
      */
-    dbJoin<TRow extends TableRow>({ status, ...column }: DbJoinColumn<TRow>, backend?: CrudBackend): TableColumn<TRow>;
+    dbJoin<TRow extends TableRow>({ status, from, ...column }: DbJoinColumn<TRow>, backend?: CrudBackend): TableColumn<TRow>;
     /**
      * Another record's name the **table** joins: the row carries only that record's key (`from`), and the table names it
      * from the other controller's `findListing` - every key the rows hold in one call, kept for every table and form on the
@@ -30,13 +46,51 @@ export declare const crudColumns: {
      * @example crudColumns.clientJoin(SUB_REGIONS, { key: "subRegionName", label: "Sub-region", from: "subRegionId" })
      */
     clientJoin<TRow extends TableRow>(api: JoinController, { from, field, ...column }: ClientJoinColumn<TRow>, backend?: CrudBackend): TableColumn<TRow>;
+    /**
+     * A price's figures under one band, "Amount details" (2026-06-20's): **Price** (money), **Discount** and **VAT**
+     * (percents), and the **Calculated amount** - the price less the discount, plus VAT on the rest, worked out from the
+     * row's own figures by the server's rule (`priceAmounts`), so a row a save just answered shows it at once. A page
+     * spreads them where its price columns go: `...crudColumns.amounts()`. The Calculated amount's key is `netAmount`.
+     *
+     * @example const COLUMNS = [crudColumns.dbJoin({ ... }), ...crudColumns.amounts(), crudColumns.status()];
+     */
+    amounts<TRow extends TableRow>(keys?: PriceKeys, changes?: {
+        group?: string;
+    }): TableColumn<TRow>[];
+    /**
+     * A receipt's money ladder as columns for a record's details (`CrudDetails`), in one section (`group`, default
+     * "Money"): Rate, Amount, Discount (5%), VAT (13%) - each left out when it is none - and the Calculated amount, money
+     * with 2 places, each read from the row's own field (`priceLadder`, on the server's `CounterAmounts` names unless
+     * `keys` says otherwise). Pass the person's number locale, so the percentages are written as they read numbers.
+     *
+     * @example ...crudColumns.priceLadder(line, { locale: useNumberLocale() })
+     */
+    priceLadder<TRow extends TableRow>(row: Readonly<Record<string, unknown>>, options?: PriceLadderOptions & {
+        group?: string;
+    }): TableColumn<TRow>[];
 };
-/** What `crudColumns.dbJoin` takes: a column, and the row's field that holds the joined record's status. */
+/** What `crudColumns.dbJoin` takes: a column, the row's field that holds the joined record's status, and the one with its key. */
 export type DbJoinColumn<TRow extends TableRow> = Partial<TableColumn<TRow>> & Pick<TableColumn<TRow>, "key" | "label"> & {
     status: string;
+    from?: string;
 };
 /** What `crudColumns.clientJoin` takes: a column, the row's field that holds the other record's key, and its own field. */
 export type ClientJoinColumn<TRow extends TableRow> = Partial<TableColumn<TRow>> & Pick<TableColumn<TRow>, "key" | "label"> & Pick<TableJoin, "from" | "field">;
+/** How `crudInputs.netAmount` works: whether it can be typed in, the price's places, and whether discount and VAT count. */
+export interface NetAmountOptions {
+    /** The figure can be typed in, setting the price that comes to it (`priceFromNet`). Default `true`. */
+    editable?: boolean;
+    /** The places the price input keeps (its `decimals`), so the price set is one it can hold. Default 2. */
+    priceDecimals?: number;
+    /**
+     * Whether the discount and VAT count, asked with the form's (or the rows') `computeWith` and the values: a receipt's
+     * lines are discounted and taxed only for a purchase, not a donation. `false` counts both as 0, in the figure and when
+     * it is typed in. Default: they always count.
+     *
+     * @example crudInputs.lineAmount({}, {}, { taxed: (receipt: { purchase: boolean } | undefined) => receipt?.purchase !== false })
+     */
+    taxed?: (withValue: any, values: Readonly<Record<string, unknown>>) => boolean;
+}
 /** The controller a client join names its records from: any with a `findListing` (`MODULES.controller(...)`). */
 export interface JoinController {
     findListing: ApiEndpoint;
@@ -48,4 +102,35 @@ export declare const crudInputs: {
      * in a form, such as `span`.
      */
     description(changes?: Partial<InputParams>): InputParams;
+    /**
+     * The **Calculated amount** in a price's form: a box after Price, Discount and VAT that follows them as they are typed
+     * (`compute`), by the server's rule (`priceAmounts`) - never sent and never a change of its own. Blank while the price
+     * is empty, so a cleared price never reads 0.00. Span 3, so Price | Discount | VAT | Calculated amount fill a row (two
+     * pairs on a narrow form).
+     *
+     * **It can be typed in** (2026-06-20's, the owner's 2026-11-10 ask): a person who knows the final figure (2,500.00) and
+     * the discount and VAT types it, and on leaving the box the price is set to the one that comes to it exactly by the
+     * server's rule (`priceFromNet`: 2,458.21 at 10 % and 13 %), or, when no price does, to the nearest, and the line under
+     * the box says so. The price is set as if the person typed it, so its rules, the unsaved-changes state and Save see it.
+     * `options.editable: false` keeps it read-only; `options.priceDecimals` is the price input's places (default 2).
+     *
+     * `changes` may replace any key, `compute` included: a counter's box shows the server's preview instead
+     * (`compute: { from: [], value: (_values, line) => line?.netAmount }` with the form's `computeWith`), which is read-only,
+     * since that `compute` has no `solve`.
+     *
+     * @example INPUTS = [..., price, discountPercentage, vatPercentage, crudInputs.netAmount()]
+     * @example crudInputs.netAmount({ price: "unitPrice", quantity: "quantity" }, { span: 4 }, { priceDecimals: 4 })
+     */
+    netAmount(keys?: PriceKeys, changes?: Partial<InputParams>, options?: NetAmountOptions): InputParams;
+    /**
+     * The **Calculated amount** of a line in a table of lines (a receipt's, an invoice's): `netAmount` on the line's own
+     * figures - the rate (`unitPrice`) times the `quantity`, less the discount, plus VAT, plus any `other` amount - worked
+     * out on each row as it is typed, sized as a table column (`width`, no growing). **It can be typed in**: a line's total
+     * typed in sets that line's rate to the one that comes to it exactly by the server's rule (`priceFromNet`, per row), or
+     * the nearest, and the line under the table says which. The rows hold no value under its name, so they never send it.
+     * `keys`, `changes` and `options` as `netAmount`'s.
+     *
+     * @example inputs: [item, quantity, unitPrice, discountPercentage, vatPercentage, otherCostAmount, crudInputs.lineAmount({ other: "otherCostAmount" })]
+     */
+    lineAmount(keys?: PriceKeys, changes?: Partial<InputParams>, options?: NetAmountOptions): InputParams;
 };