@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/core/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The planner without a UI: what a Node server needs to implement the host
+ * contract (`docs/inference-host.md`). Rune-free and importable by plain Node,
+ * no Vite and no Svelte compiler.
+ *
+ * - command tool schemas and input types, and the `PlanSnapshot` type;
+ * - `buildHostPrompt`: the system prompt and messages for one chat call;
+ * - `replySchema` / `buildReplySchema`: the JSON Schema of the model's answer;
+ * - `parseHostReply`: validate that answer into the response body;
+ * - `parseHostRequest`: validate the request body;
+ * - the library catalog (recipes and cookbooks) the prompt is built from;
+ * - `createHeadlessPlanner`: the command set over a plain-object plan (many may
+ *   coexist): smrt's cookbook command engine behind the planner's names, the
+ *   same commands, validation and snapshots as the browser controller.
+ *
+ * The browser controller (`createPlannerController`) is not here: it drives
+ * the UI's stores and lives in `./commands` (Svelte source).
+ *
+ * @module
+ */
+export { HOST_HISTORY_CHARS, HOST_HISTORY_TURNS, HOST_MESSAGE_CHARS, HOST_WIRE_VERSION, type HostRequest, } from '../inference/host.ts';
+export { buildCommandTools, COMMAND_NAMES, type CommandTool, checkSchema, commandSchemas, commandTools, type JsonSchema, } from '../planner/commands/schemas.ts';
+export { type BatchResult, type CommandError, type CommandErrorCode, type CommandInputs, type CommandName, type CommandReceipt, type CommandResult, type ExportData, PLANNER_COMMANDS_VERSION, PLANNER_TAB_IDS, type PlannerCommand, type PlannerTabId, type PlanSnapshot, type RecipeChanges, type RunOptions, } from '../planner/commands/types.ts';
+export { type CookbookBrief, defaultCatalog, getLibraryCookbook, getRecipe, type LibraryCookbook, libraryCookbooks, type PromptCatalog, type Recipe, recipes, recipesById, } from './catalog.ts';
+export { createHeadlessPlanner, type HeadlessPlanner, type HeadlessPlannerOptions, } from './headless.ts';
+export { buildHostPrompt, type HostPrompt, type HostPromptInput, type HostTurn, } from './prompt.ts';
+export { buildReplySchema, type HostReply, type ParsedHostReply, parseHostReply, replySchema, } from './reply.ts';
+export { type HostRequestParse, parseHostRequest } from './request.ts';

package/dist/core/index.js

@@ -0,0 +1,28 @@
+/**
+ * The planner without a UI: what a Node server needs to implement the host
+ * contract (`docs/inference-host.md`). Rune-free and importable by plain Node,
+ * no Vite and no Svelte compiler.
+ *
+ * - command tool schemas and input types, and the `PlanSnapshot` type;
+ * - `buildHostPrompt`: the system prompt and messages for one chat call;
+ * - `replySchema` / `buildReplySchema`: the JSON Schema of the model's answer;
+ * - `parseHostReply`: validate that answer into the response body;
+ * - `parseHostRequest`: validate the request body;
+ * - the library catalog (recipes and cookbooks) the prompt is built from;
+ * - `createHeadlessPlanner`: the command set over a plain-object plan (many may
+ *   coexist): smrt's cookbook command engine behind the planner's names, the
+ *   same commands, validation and snapshots as the browser controller.
+ *
+ * The browser controller (`createPlannerController`) is not here: it drives
+ * the UI's stores and lives in `./commands` (Svelte source).
+ *
+ * @module
+ */
+export { HOST_HISTORY_CHARS, HOST_HISTORY_TURNS, HOST_MESSAGE_CHARS, HOST_WIRE_VERSION, } from "../inference/host.js";
+export { buildCommandTools, COMMAND_NAMES, checkSchema, commandSchemas, commandTools, } from "../planner/commands/schemas.js";
+export { PLANNER_COMMANDS_VERSION, PLANNER_TAB_IDS, } from "../planner/commands/types.js";
+export { defaultCatalog, getLibraryCookbook, getRecipe, libraryCookbooks, recipes, recipesById, } from "./catalog.js";
+export { createHeadlessPlanner, } from "./headless.js";
+export { buildHostPrompt, } from "./prompt.js";
+export { buildReplySchema, parseHostReply, replySchema, } from "./reply.js";
+export { parseHostRequest } from "./request.js";

package/dist/core/prompt.d.ts

@@ -0,0 +1,38 @@
+import type { PlanSnapshot } from '../planner/commands/types.ts';
+import { type PromptCatalog } from './catalog.ts';
+/** One earlier turn of the conversation. */
+export interface HostTurn {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface HostPromptInput {
+    /** The visitor's text (clipped to the contract's 2000 characters). */
+    message: string;
+    /** The plan as the planner reports it. */
+    snapshot: PlanSnapshot;
+    /** Recent turns, oldest first. Anything but user or assistant is ignored. */
+    history?: readonly {
+        role: string;
+        content: string;
+    }[];
+    /** The recipes and cookbooks the model may use; the planner's library by default. */
+    catalog?: PromptCatalog;
+}
+/** A chat call's input: `system` apart, so it fits OpenAI- and Anthropic-style APIs. */
+export interface HostPrompt {
+    /** The system prompt. OpenAI-style: send it as a leading `system` message. Anthropic-style: the `system` parameter. */
+    system: string;
+    /** The conversation, oldest first; the last entry is the visitor's message. */
+    messages: HostTurn[];
+}
+/**
+ * The chat call for one host-mode turn. The system prompt is the browser
+ * assistant's own (`buildSystemPrompt`: same wording, worked examples, focused
+ * recipe lines for what the message matches, settings and theme from the
+ * snapshot), plus the host-only `commands` section. The messages are the recent
+ * history and then the visitor's message.
+ *
+ * Ask the model for JSON matching `buildReplySchema()` and read the answer with
+ * `parseHostReply`.
+ */
+export declare function buildHostPrompt(input: HostPromptInput): HostPrompt;

package/dist/core/prompt.js

@@ -0,0 +1,95 @@
+import { buildMatchIndex, matchText, } from "../assistant/match.js";
+import { buildSystemPrompt } from "../assistant/prompt.js";
+import { HOST_HISTORY_CHARS, HOST_HISTORY_TURNS, HOST_MESSAGE_CHARS, } from "../inference/host.js";
+import { commandTools } from "../planner/commands/schemas.js";
+import { defaultCatalog } from "./catalog.js";
+const indexes = new WeakMap();
+function indexOf(catalog) {
+    let index = indexes.get(catalog);
+    if (!index) {
+        index = buildMatchIndex(catalog.recipes, catalog.cookbooks, {
+            theme: true,
+        });
+        indexes.set(catalog, index);
+    }
+    return index;
+}
+/** The snapshot's theme as the setting the prompt describes. */
+function themeOf(snapshot) {
+    const { preset, primary, colorScheme } = snapshot.theme;
+    const theme = {};
+    if (preset)
+        theme.preset = preset;
+    if (primary)
+        theme.custom = { primary };
+    if (colorScheme && colorScheme !== 'system') {
+        theme.colorScheme = colorScheme;
+    }
+    return Object.keys(theme).length ? theme : undefined;
+}
+/** `rename_item(id, label)`: required inputs bare, optional ones with `?`. */
+function signature(tool) {
+    const schema = tool.inputSchema;
+    const required = new Set(schema.required ?? []);
+    const keys = Object.keys(schema.properties ?? {}).map((key) => required.has(key) ? key : `${key}?`);
+    return `${tool.name}(${keys.join(', ')})`;
+}
+/**
+ * What only a host server adds to the browser prompt: the `commands` field and
+ * the menu ids it needs. Everything above it is the browser assistant's prompt.
+ */
+function commandSection(snapshot) {
+    const out = [
+        '',
+        '"commands": optional, at most 8 {"name", "input"} run in order, only for what add/remove/settings/theme cannot do. Commands:',
+        ...commandTools.map((tool) => `- ${signature(tool)}: ${tool.description}`),
+    ];
+    const menu = snapshot.sections
+        .filter((section) => !section.hidden)
+        .map((section) => {
+        const items = section.items
+            .filter((item) => !item.hidden)
+            .map((item) => `${item.id} (${item.label})`);
+        return `- ${section.id} (${section.label})${items.length ? `: ${items.join(', ')}` : ''}`;
+    });
+    if (menu.length) {
+        out.push('', 'Menu ids for rename/hide/show/focus:', ...menu);
+    }
+    if (snapshot.undo.length) {
+        out.push('', `Undo ids available: ${snapshot.undo.join(', ')}.`);
+    }
+    return out;
+}
+const clip = (text, max) => text.length > max ? text.slice(0, max) : text;
+/**
+ * The chat call for one host-mode turn. The system prompt is the browser
+ * assistant's own (`buildSystemPrompt`: same wording, worked examples, focused
+ * recipe lines for what the message matches, settings and theme from the
+ * snapshot), plus the host-only `commands` section. The messages are the recent
+ * history and then the visitor's message.
+ *
+ * Ask the model for JSON matching `buildReplySchema()` and read the answer with
+ * `parseHostReply`.
+ */
+export function buildHostPrompt(input) {
+    const catalog = input.catalog ?? defaultCatalog;
+    const { snapshot } = input;
+    const message = clip(input.message, HOST_MESSAGE_CHARS);
+    const system = [
+        buildSystemPrompt(catalog.recipes, snapshot.recipes.map((recipe) => recipe.id), catalog.cookbooks, {
+            currency: snapshot.settings.currency,
+            taxRate: Number((snapshot.settings.taxRate / 100).toFixed(6)),
+            paymentTerms: snapshot.settings.paymentTerms,
+        }, matchText(indexOf(catalog), message), { current: themeOf(snapshot) }),
+        ...commandSection(snapshot),
+    ].join('\n');
+    const history = (input.history ?? [])
+        .filter((turn) => (turn.role === 'user' || turn.role === 'assistant') &&
+        typeof turn.content === 'string')
+        .slice(-HOST_HISTORY_TURNS)
+        .map((turn) => ({
+        role: turn.role,
+        content: clip(turn.content, HOST_HISTORY_CHARS),
+    }));
+    return { system, messages: [...history, { role: 'user', content: message }] };
+}

package/dist/core/reply.d.ts

@@ -0,0 +1,60 @@
+import { type PromptCatalog } from './catalog.ts';
+/**
+ * The body a host answers the planner with (wire version 1, see
+ * `docs/inference-host.md`): the action JSON the browser assistant reads from a
+ * model. Only `reply` is required; empty parts are left out.
+ */
+export interface HostReply {
+    /** The sentence shown to the visitor. */
+    reply: string;
+    /** Recipe ids to switch on. */
+    add?: string[];
+    /** Recipe ids to switch off. */
+    remove?: string[];
+    /** A library cookbook to offer. */
+    cookbook?: string;
+    /** Settings to change; `taxRate` in percent. */
+    settings?: {
+        currency?: string;
+        taxRate?: number;
+        paymentTerms?: string;
+    };
+    /** Theme tokens: a preset or `#rrggbb`, and light or dark. */
+    theme?: {
+        preset?: string;
+        primary?: string;
+        colorScheme?: string;
+    };
+    /** Up to 8 planner commands, run in order by the planner. */
+    commands?: {
+        name: string;
+        input: unknown;
+    }[];
+}
+/**
+ * The JSON Schema of one model turn in host mode: `reply`, `add`, `remove`,
+ * `cookbook`, `settings`, `theme` and `commands`. Recipe and cookbook ids are
+ * enums, so constrained decoding cannot invent one. Pass it as the response
+ * format of an OpenAI-style call; `commands[].input` is checked afterwards
+ * against `commandSchemas` by `parseHostReply`.
+ */
+export declare function buildReplySchema(catalog?: PromptCatalog): Record<string, unknown>;
+/** The reply schema for the planner's own library. */
+export declare const replySchema: Record<string, unknown>;
+export interface ParsedHostReply {
+    /** False when the model's text was not a JSON object (the reply is a fallback or its prose). */
+    ok: boolean;
+    /** Safe to send back to the planner as the response body. */
+    reply: HostReply;
+    /** What was dropped or repaired, for the server's log. Never shown to the visitor. */
+    issues: string[];
+}
+/**
+ * Read a model's text into a reply the planner accepts, with the same rules the
+ * browser assistant applies: thinking tags are dropped, unknown recipe and
+ * cookbook ids are removed, settings and theme are cut to valid values, and
+ * malformed JSON still yields its `reply` text (never raw model output).
+ * Commands are checked here against their input schemas; an unknown or invalid
+ * one is dropped and listed in `issues`. The planner validates again.
+ */
+export declare function parseHostReply(text: string, catalog?: PromptCatalog): ParsedHostReply;

package/dist/core/reply.js

@@ -0,0 +1,89 @@
+import { buildResponseSchema, FALLBACK_REPLY, MAX_COMMANDS, parseChange, stripThinking, } from "../assistant/change.js";
+import { checkSchema, commandSchemas, commandTools, } from "../planner/commands/schemas.js";
+import { defaultCatalog } from "./catalog.js";
+/**
+ * The JSON Schema of one model turn in host mode: `reply`, `add`, `remove`,
+ * `cookbook`, `settings`, `theme` and `commands`. Recipe and cookbook ids are
+ * enums, so constrained decoding cannot invent one. Pass it as the response
+ * format of an OpenAI-style call; `commands[].input` is checked afterwards
+ * against `commandSchemas` by `parseHostReply`.
+ */
+export function buildReplySchema(catalog = defaultCatalog) {
+    const schema = buildResponseSchema(catalog.recipes, catalog.cookbooks, true, true);
+    schema.properties.commands = {
+        type: 'array',
+        maxItems: MAX_COMMANDS,
+        items: {
+            type: 'object',
+            properties: {
+                name: { enum: commandTools.map((tool) => tool.name) },
+                input: { type: 'object' },
+            },
+            required: ['name', 'input'],
+            additionalProperties: false,
+        },
+    };
+    return schema;
+}
+/** The reply schema for the planner's own library. */
+export const replySchema = buildReplySchema();
+const nonEmpty = (value) => Object.keys(value).length > 0;
+function toHostReply(change) {
+    return {
+        reply: change.reply,
+        ...(change.add.length ? { add: change.add } : {}),
+        ...(change.remove.length ? { remove: change.remove } : {}),
+        ...(change.cookbook ? { cookbook: change.cookbook } : {}),
+        ...(nonEmpty(change.settings) ? { settings: change.settings } : {}),
+        ...(nonEmpty(change.theme) ? { theme: change.theme } : {}),
+        ...(change.commands?.length ? { commands: change.commands } : {}),
+    };
+}
+/**
+ * Read a model's text into a reply the planner accepts, with the same rules the
+ * browser assistant applies: thinking tags are dropped, unknown recipe and
+ * cookbook ids are removed, settings and theme are cut to valid values, and
+ * malformed JSON still yields its `reply` text (never raw model output).
+ * Commands are checked here against their input schemas; an unknown or invalid
+ * one is dropped and listed in `issues`. The planner validates again.
+ */
+export function parseHostReply(text, catalog = defaultCatalog) {
+    const issues = [];
+    const change = parseChange(text, catalog.recipes, catalog.cookbooks, {
+        commands: true,
+    });
+    let ok = true;
+    try {
+        const value = JSON.parse(stripThinking(text));
+        ok = typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    catch {
+        ok = false;
+    }
+    if (!ok)
+        issues.push('the reply was not a JSON object');
+    if (!change.reply) {
+        change.reply = FALLBACK_REPLY;
+        issues.push('the reply had no "reply" sentence');
+    }
+    if (change.commands) {
+        const valid = [];
+        for (const call of change.commands) {
+            const schema = Object.hasOwn(commandSchemas, call.name)
+                ? commandSchemas[call.name]
+                : undefined;
+            if (!schema) {
+                issues.push(`dropped unknown command "${call.name}"`);
+                continue;
+            }
+            const problem = checkSchema(schema, call.input);
+            if (problem) {
+                issues.push(`dropped ${call.name}: ${problem}`);
+                continue;
+            }
+            valid.push(call);
+        }
+        change.commands = valid;
+    }
+    return { ok, reply: toHostReply(change), issues };
+}

package/dist/core/request.d.ts

@@ -0,0 +1,15 @@
+import { type HostRequest } from '../inference/host.ts';
+export type HostRequestParse = {
+    ok: true;
+    request: HostRequest;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Check the JSON body the planner POSTs in host mode. Strict about the shape
+ * (version, a non-empty message, a snapshot object of a known version, history
+ * of user and assistant turns only), and clips lengths to the contract's limits
+ * rather than refusing. The result feeds `buildHostPrompt`.
+ */
+export declare function parseHostRequest(body: unknown): HostRequestParse;

package/dist/core/request.js

@@ -0,0 +1,55 @@
+import { HOST_HISTORY_CHARS, HOST_HISTORY_TURNS, HOST_MESSAGE_CHARS, HOST_WIRE_VERSION, } from "../inference/host.js";
+import { PLANNER_COMMANDS_VERSION, } from "../planner/commands/types.js";
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Check the JSON body the planner POSTs in host mode. Strict about the shape
+ * (version, a non-empty message, a snapshot object of a known version, history
+ * of user and assistant turns only), and clips lengths to the contract's limits
+ * rather than refusing. The result feeds `buildHostPrompt`.
+ */
+export function parseHostRequest(body) {
+    if (!isObject(body))
+        return { ok: false, error: 'the body must be an object' };
+    if (body.version !== HOST_WIRE_VERSION) {
+        return {
+            ok: false,
+            error: `unsupported version (this server speaks ${HOST_WIRE_VERSION})`,
+        };
+    }
+    if (typeof body.message !== 'string' || !body.message.trim()) {
+        return { ok: false, error: '"message" must be a non-empty string' };
+    }
+    const snapshot = body.snapshot;
+    if (!isObject(snapshot) || snapshot.version !== PLANNER_COMMANDS_VERSION) {
+        return { ok: false, error: '"snapshot" must be a version-1 plan snapshot' };
+    }
+    const history = [];
+    if (body.history !== undefined) {
+        if (!Array.isArray(body.history)) {
+            return { ok: false, error: '"history" must be an array' };
+        }
+        for (const turn of body.history.slice(-HOST_HISTORY_TURNS)) {
+            if (!isObject(turn) ||
+                (turn.role !== 'user' && turn.role !== 'assistant') ||
+                typeof turn.content !== 'string') {
+                return {
+                    ok: false,
+                    error: '"history" entries need role user or assistant and content',
+                };
+            }
+            history.push({
+                role: turn.role,
+                content: turn.content.slice(0, HOST_HISTORY_CHARS),
+            });
+        }
+    }
+    return {
+        ok: true,
+        request: {
+            version: HOST_WIRE_VERSION,
+            message: body.message.slice(0, HOST_MESSAGE_CHARS),
+            snapshot: snapshot,
+            ...(history.length ? { history } : {}),
+        },
+    };
+}

package/dist/data/children.d.ts

@@ -0,0 +1,20 @@
+import type { CatalogModel } from '../catalog/types.ts';
+import { type ModelRecord } from './fakes.ts';
+/** A child model and the field holding its parent's id (see `childLinks`). */
+export interface ChildOf {
+    model: CatalogModel;
+    fk: string;
+}
+/**
+ * Sample child rows for one parent record: one to four (journals, an even
+ * number of balanced entries), each pointing at the parent through `fk`. Ids
+ * and values are seeded from the parent's id, so the same parent always gets
+ * the same children. A line item's `amount` is `quantity * unitPrice` so it
+ * reads right next to the parent's totals.
+ */
+export declare function fakeChildrenOf(child: CatalogModel, fk: string, parent: ModelRecord, seed: number): ModelRecord[];
+/**
+ * Bring a parent's totals in line with the line items just generated for it
+ * (see `withTotals`).
+ */
+export declare function syncTotals(parent: ModelRecord, parentModel: CatalogModel, items: readonly ModelRecord[]): void;

package/dist/data/children.js

@@ -0,0 +1,80 @@
+import { isLineModel, settleLine, withTotals } from "./derived.js";
+import { createRandom, fakeId, fakeRecord, hashString, packLine, } from "./fakes.js";
+import { getSamplePack } from "./packs.js";
+const MAX_CHILDREN = 4;
+const hasField = (model, name) => model.fields.some((f) => f.name === name);
+/**
+ * Sample child rows for one parent record: one to four (journals, an even
+ * number of balanced entries), each pointing at the parent through `fk`. Ids
+ * and values are seeded from the parent's id, so the same parent always gets
+ * the same children. A line item's `amount` is `quantity * unitPrice` so it
+ * reads right next to the parent's totals.
+ */
+export function fakeChildrenOf(child, fk, parent, seed) {
+    const random = createRandom(hashString(`${seed}:${child.id}:${parent.id}`));
+    const ledger = hasField(child, 'debit') && hasField(child, 'credit');
+    const count = ledger
+        ? 2 * (1 + Math.floor(random() * 2))
+        : 1 + Math.floor(random() * MAX_CHILDREN);
+    const lines = isLineModel(child);
+    const balance = 1000 * (1 + Math.floor(random() * 90));
+    return Array.from({ length: count }, (_, i) => {
+        const index = hashString(`${parent.id}:${i}`) % 997;
+        const record = {
+            ...fakeRecord(child, index, seed),
+            id: fakeId(`${child.id}:${parent.id}:${i}`),
+            [fk]: parent.id,
+        };
+        if (hasField(child, 'sortOrder'))
+            record.sortOrder = i;
+        if (lines) {
+            // A line pointing at a product reads as that product, at its price.
+            const productField = child.fields.find((f) => f.related?.endsWith(':Product') && f.name in record);
+            const pack = getSamplePack();
+            const { products } = pack;
+            const item = products[(index % 5) % products.length];
+            const described = packLine(index);
+            if (described) {
+                // Labour and fabrication are not products: no product to point at.
+                if (hasField(child, 'description')) {
+                    record.description = described.description;
+                }
+                record.unitPrice = described.price;
+                if (productField)
+                    record[productField.name] = '';
+            }
+            else if (productField && item) {
+                if (hasField(child, 'description'))
+                    record.description = item.name;
+                record.unitPrice = item.price;
+            }
+            // How many a line sells is the pack's call: one membership, a few hours
+            // of labour, a handful of parts. The draw is always taken so a pack
+            // without ranges leaves the rest of the stream as it was.
+            const [low, high] = described?.quantity ??
+                item?.quantity ??
+                pack.lineQuantity ?? [1, 5];
+            const quantity = low + Math.floor(random() * (high - low + 1));
+            if (hasField(child, 'quantity'))
+                record.quantity = quantity;
+            if (hasField(child, 'discount'))
+                record.discount = 0;
+            record.amount = settleLine(record).amount;
+        }
+        if (ledger) {
+            const debit = i % 2 === 0;
+            record.debit = debit ? balance / 100 : 0;
+            record.credit = debit ? 0 : balance / 100;
+        }
+        return record;
+    });
+}
+/**
+ * Bring a parent's totals in line with the line items just generated for it
+ * (see `withTotals`).
+ */
+export function syncTotals(parent, parentModel, items) {
+    if (!items.length || !items.every((r) => 'unitPrice' in r))
+        return;
+    Object.assign(parent, withTotals(parentModel, parent, items));
+}

package/dist/data/columns.d.ts

@@ -0,0 +1,56 @@
+import type { CatalogModel } from '../catalog/types.ts';
+import type { ViewField } from '../recipes/policy.ts';
+/** A list column: a field, or a value worked out from the row (Amount due). */
+export interface ListColumn extends ViewField {
+    /** A datetime that shows its time of day, not only the date (a class start). */
+    showTime?: boolean;
+    derive?: (row: Readonly<Record<string, unknown>>) => unknown;
+}
+/**
+ * The columns of a list: what names the row, who it is for, its status, its
+ * money and its dates first; then the other numeric/boolean/date fields and
+ * choices so a row reads like a record, not a wall of text. A record that
+ * tracks payments (`totalAmount` and `amountPaid`) also gets "Amount due".
+ */
+export declare function listColumns(fields: readonly ViewField[], max?: number): ListColumn[];
+/** The value a list cell shows for a row. */
+export declare function cellValue(column: ListColumn, row: Readonly<Record<string, unknown>>): unknown;
+/** The rows whose foreign key points at the parent record. */
+export declare function rowsOf<T extends Record<string, unknown>>(rows: readonly T[], fk: string, parentId: string): T[];
+/**
+ * The value a new record starts with: the field's default; an enumeration with
+ * none (a `status`, or a required choice) starts at "draft" or its first value
+ * rather than empty.
+ */
+export declare function blankValue(field: ViewField): unknown;
+/** Starting values for a new record of the fields shown. */
+export declare function blankRecord(fields: readonly ViewField[]): Record<string, unknown>;
+/** Starting values for a new child row: field defaults, the foreign key preset. */
+export declare function blankChild(fields: readonly ViewField[], fk: string, parentId: string): Record<string, unknown>;
+/**
+ * Required fields without a value, as `{ name: message }`. A switch always has
+ * a value; fields in `skip` (derived or preset ones) are not asked for.
+ */
+export declare function missingRequired(fields: readonly ViewField[], values: Readonly<Record<string, unknown>>, skip?: ReadonlySet<string>): Record<string, string>;
+/**
+ * One line for near the Save button: which fields still need a value.
+ * Empty when nothing is missing, so it clears itself as the errors do.
+ */
+export declare function errorSummary(fields: readonly {
+    name: string;
+    label: string;
+}[], errors: Readonly<Record<string, string>>): string;
+/**
+ * What names a record to a person (see `recordName`): its label, else its
+ * number and who it is for ("WIL-1133 · Lantern Collective"), else the record
+ * it points at plus its reference.
+ */
+export declare function recordTitle(model: CatalogModel, fields: readonly ViewField[], row: Readonly<Record<string, unknown>>, labels: ReadonlyMap<string, string>): string;
+/** A child table shown inside its parent's record view. */
+export interface ChildTable {
+    model: CatalogModel;
+    fields: ViewField[];
+    /** The child's field holding the parent record's id. */
+    fk: string;
+    title: string;
+}