@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/page/render.js

@@ -0,0 +1,1060 @@
+/**
+ * A page's envelope → `RenderedPage` (15 §10.9 output). Runs on the platform, after the page script
+ * returned its page from the sandbox: the envelope the page module made of its JSX (31 §8).
+ *
+ * The document is walked once. Every slot becomes a cell joined with its schema definition; its value
+ * is taken from what the platform itself read (`PageReads`), never from the document, and a slot
+ * whose row this run did not read is shown as plain read-only content (anti-forgery). Every action
+ * becomes a button with the function-call arguments the AI fills; what the page prefilled stays here,
+ * on the server. An action that cannot be pressed is left off the page.
+ *
+ * The rows on the page are the rows with a cell on it: a lookup cell, and an action's row parameter,
+ * choose among the rows of their table there (15 §10.15 point 9). So lookups and actions are rendered
+ * after the walk, once every row on the page is known.
+ *
+ * Cells are addressed by slot id `table:<uuid tail>.field` (`RowNames`: the row's own, layout-free);
+ * actions and blocks by their page path (`injuries.rows.0.markError`), resolved against the very page
+ * the AI saw.
+ */
+import { parentOf } from '../slot/company-metadata.js';
+import { ROW_ID_FIELD } from '../slot/schema.js';
+import { getCompiledTable, getTableField } from '../slot/compile-schema.js';
+import { isChoose, PAGE_TOOLS } from './define.js';
+import { isEnvelope } from './envelope.js';
+import { CONTACT_TABLE } from '../slot/company-metadata.js';
+import { fallbackSpoken } from '../conversation/index.js';
+// ---------------------------------------------------------------------------------------------
+// Row names (15 §10.6.2)
+/**
+ * `table:` and the last 12 hex digits of the row's uuid (33): what the row is called in logs, the
+ * timeline and the database too, so the same in every conversation and every process; nothing to keep.
+ * A name comes from the id alone, never from which row came first: two rows of a table alike in those
+ * digits (one page of n rows: about n² / 2⁴⁹) are both named by their whole id from then on, and the
+ * short name they share resolves to neither. So a name from an earlier conversation, or another
+ * process, means the row it meant or no row (the AI is told), never another row. A name resolves only
+ * to a row named here, and the AI's names are checked against the page's own (`one-of`, `enum`) first.
+ */
+export class RowNames {
+    /** The rows named here: id → table. */
+    tables = new Map();
+    /** A short name → the ids of its table ending in its digits. */
+    byShort = new Map();
+    name(table, id) {
+        this.tables.set(id, table);
+        const short = shortRowName(table, id);
+        let ids = this.byShort.get(short);
+        if (!ids)
+            this.byShort.set(short, (ids = new Set()));
+        ids.add(id);
+        return ids.size > 1 ? `${table}:${id}` : short;
+    }
+    resolve(name) {
+        const at = name.indexOf(':');
+        if (at < 0)
+            return undefined;
+        const table = name.slice(0, at);
+        const rest = name.slice(at + 1);
+        if (this.tables.get(rest) === table)
+            return { table, id: rest };
+        const ids = this.byShort.get(name);
+        if (ids?.size !== 1)
+            return undefined;
+        const [id] = ids;
+        return { table, id: id };
+    }
+    nameOf(id) {
+        const table = this.tables.get(id);
+        if (table === undefined)
+            return undefined;
+        const short = shortRowName(table, id);
+        return this.byShort.get(short).size > 1 ? `${table}:${id}` : short;
+    }
+}
+function shortRowName(table, id) {
+    return `${table}:${id.slice(-12)}`;
+}
+export class PageDocumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PageDocumentError';
+    }
+}
+const MAX_DEPTH = 32;
+/** Channel actions only a call can do; by text only `end` (17b §9.8). */
+const CALL_ONLY = new Set(['transfer', 'keypad', 'announce', 'voicemail']);
+/** Tools only a call can use (76 §2.18). */
+const CALL_ONLY_TOOLS = new Set(['pressKeypad']);
+export function renderDocument(input) {
+    // Only what the page module marked (31 §8): an object shaped like a button is not one.
+    if (!isEnvelope(input.document))
+        throw new PageDocumentError('the page function returns page(…) or doNow(…) (76 §2.1)');
+    const envelope = input.document;
+    if ('do' in envelope)
+        return renderDo(input, envelope.do);
+    const { schema, reads, names } = input;
+    const envelopePage = envelope.page;
+    const cells = {};
+    const actions = {};
+    const rows = {};
+    const warnings = [];
+    const pendingActions = [];
+    const extractions = pageExtractions(envelopePage.extraction, schema, warnings);
+    const rowName = (table, id) => {
+        const name = names.name(table, id);
+        if (!rows[name]) {
+            const parent = parentOf(getCompiledTable(schema, table));
+            const parentValue = parent ? reads.row(id)?.slots[parent.field]?.value : null;
+            rows[name] = { table, id, parentId: typeof parentValue === 'string' ? parentValue : null };
+        }
+        return name;
+    };
+    const cellOf = (key, path, value) => {
+        const refCell = isRefFieldCell(value) ? value : null;
+        const fieldCell = isFieldCell(value) ? value : refCell ? { $field: true, slot: refCell.slot, ...(refCell.readOnly ? { readOnly: true } : {}) } : null;
+        const slot = fieldCell ? fieldCell.slot : value;
+        if (!isSlotLike(slot))
+            return null;
+        const ref = slot.ref;
+        const read = reads.row(ref.id);
+        const table = getCompiledTable(schema, ref.table);
+        const def = table?.fields[ref.field];
+        // The row id and the parent never change and never are empty: nothing a field could show or open.
+        // Who the row belongs to is said in words, `text(…)` (31 §4).
+        const isParent = table ? parentOf(table)?.field === ref.field : false;
+        if (isParent || ref.field === ROW_ID_FIELD) {
+            throw new PageDocumentError(`${path}: ${ref.table}.${ref.field} is ${isParent ? 'the parent' : 'the row id'}: it never changes, so it is not a field on the page; say who the row belongs to with text(…), e.g. case: text("Zhang San's car accident case")`);
+        }
+        if (!read || read.table !== ref.table || !def || !(ref.field in read.slots)) {
+            warnings.push(`${path}: a slot this run did not read (${ref.table}.${ref.field}); shown as read-only text`);
+            return { kind: 'text', key, path, value: displayable(slot.value) };
+        }
+        const truth = read.slots[ref.field];
+        const name = rowName(ref.table, ref.id);
+        const slotId = `${name}.${ref.field}`;
+        const isLookup = Boolean(def.ref);
+        // A ref field is placed with refField, read-only too: its candidates and their labels, or who its value
+        // is, are the page's (26 §16.2 #7); a bare row name says nothing (31 §4).
+        if (isLookup && !refCell)
+            throw new PageDocumentError(`${path}: ${ref.table}.${ref.field} is a ref field: place it with refField(slot, { options }) (read-only, refField(slot, { readOnly: true, label: '…' }))`);
+        if (refCell && !isLookup)
+            throw new PageDocumentError(`${path}: refField(...) is for a ref field; ${ref.table}.${ref.field} is not a ref`);
+        const offered = refCell ? refOptions(path, refCell, def.ref.table) : null;
+        // The page decides (19-page-writable-cells): `field(slot, { readOnly: true })` is read-only, `field(slot)` opens it.
+        // A ref field with no row to offer is shown, not opened: nothing to choose (data, not a page mistake).
+        const placeWritable = fieldCell !== null && !fieldCell.readOnly && (!offered || offered.length > 0);
+        const existing = cells[slotId];
+        if (existing) {
+            existing.writable ||= placeWritable;
+            existing.paths.push(path);
+        }
+        else {
+            const cell = {
+                slotId,
+                ref: { table: ref.table, id: ref.id, field: ref.field },
+                row: name,
+                label: def.label,
+                type: def.dataType,
+                choices: def.options,
+                value: truth.value,
+                state: truth.state,
+                reason: truth.reason,
+                updatedAt: truth.updatedAt,
+                writable: placeWritable,
+                paths: [path],
+            };
+            if (def.description)
+                cell.description = def.description;
+            if (def.extraction)
+                cell.extraction = def.extraction;
+            if (isLookup)
+                cell.type = 'ref';
+            cells[slotId] = cell;
+            // The row a ref holds is named even when nothing else of it is on the page (33): the AI reads
+            // `case_contact:3f9a2c1d7e04`, never a bare id. Named only: it does not join `rows`, which is
+            // what the page's actions may write.
+            if (def.ref && truth.state === 'filled' && typeof truth.value === 'string')
+                cell.valueRow = names.name(def.ref.table, truth.value);
+        }
+        if (offered) {
+            const target = cells[slotId];
+            // Writable, the rows offered; read-only, only the labels (who the current value is).
+            if (placeWritable)
+                target.options = [...new Set([...(target.options ?? []), ...offered.map((o) => o.name)])];
+            target.optionLabels = { ...target.optionLabels, ...Object.fromEntries(offered.map((o) => [o.name, o.label])) };
+        }
+        const node = { kind: 'cell', key, path, slotId, readOnly: !placeWritable };
+        // A ref field's definition is always on the page: its meaning is not in its name (26 §16.2 #7).
+        if (fieldCell?.expand || refCell)
+            node.expand = true;
+        return node;
+    };
+    /** A refField's rows: each must be a row this run read, of the table the field points at (it goes on the page). */
+    const refOptions = (path, cell, target) => cell.options.map((option) => {
+        const read = reads.row(option.id);
+        if (!read || read.table !== target)
+            throw new PageDocumentError(`${path}: refField offers ${option.id}, not a ${target} row this run read`);
+        return { name: rowName(target, option.id), label: option.label };
+    });
+    /**
+     * Data (31 §4): shown as it is, blocks, lists and text, whatever keys it has (`$action` too). Nothing in
+     * it is a field or a button: the page module marked those, and data cannot carry the mark.
+     */
+    const walkData = (key, path, value, depth) => {
+        if (depth > MAX_DEPTH)
+            throw new PageDocumentError(`${path || 'page'}: nested deeper than ${MAX_DEPTH}`);
+        if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+            return { kind: 'text', key, path, value };
+        if (Array.isArray(value))
+            return { kind: 'block', key, path, list: true, children: value.map((item, i) => walkData(String(i), join(path, String(i)), item, depth + 1)) };
+        if (isPlainObject(value)) {
+            return { kind: 'block', key, path, list: false, children: Object.entries(value).map(([k, item]) => walkData(k, join(path, k), item, depth + 1)) };
+        }
+        return { kind: 'text', key, path, value: String(value) };
+    };
+    /** One node of the envelope (31 §8): what the page module marked as a block, a field, a button, or data. */
+    const walkEnvelope = (node, parent, place, depth) => {
+        if (depth > MAX_DEPTH)
+            throw new PageDocumentError(`${parent || 'page'}: nested deeper than ${MAX_DEPTH}`);
+        // Where it is, for messages: its name, or its place when it has none (46 §2.2).
+        const path = join(parent, node.key || `#${place}`);
+        switch (node.k) {
+            case 'block': {
+                const block = { kind: 'block', key: node.key, path, list: node.list, children: [] };
+                if (node.title !== undefined)
+                    block.title = node.title;
+                if (node.description !== undefined)
+                    block.description = node.description;
+                node.children.forEach((child, i) => {
+                    const out = walkEnvelope(child, path, i, depth + 1);
+                    if (out)
+                        block.children.push(out);
+                });
+                return block;
+            }
+            case 'field': {
+                const cell = cellOf(node.key, path, node.cell);
+                if (!cell)
+                    throw new PageDocumentError(`${path}: not a field`);
+                return cell;
+            }
+            case 'button': {
+                // Its id comes once every button is known (46 §2.1).
+                const action = { kind: 'action', key: '', path, actionId: '' };
+                pendingActions.push({ path, value: node.action, node: action });
+                return action;
+            }
+            case 'data':
+                return walkData(node.key, path, node.value, depth);
+            case 'toolbox': {
+                // The tools as buttons in their own block (76 §2.18): the AI presses one like any button.
+                const block = { kind: 'block', key: node.key, path, list: false, title: 'Tools', children: [] };
+                node.tools.forEach((tool, i) => {
+                    if (!PAGE_TOOLS.includes(tool))
+                        throw new PageDocumentError(`${path}: ${tool} is not a platform tool (${PAGE_TOOLS.join(', ')})`);
+                    const at = join(path, String(i));
+                    // A call tool on a text or an email page (76 §2.12): left off, said in the log.
+                    if (input.channel !== undefined && input.channel !== 'call' && CALL_ONLY_TOOLS.has(tool)) {
+                        warnings.push(`${at}: ${tool}() is a call tool, and this is ${input.channel}: left off the page (place it only on a call)`);
+                        return;
+                    }
+                    const action = { kind: 'action', key: '', path: at, actionId: '' };
+                    pendingActions.push({ path: action.path, value: { $action: 'tool', tool: tool }, node: action });
+                    block.children.push(action);
+                });
+                // Every tool left off (or none given): no toolbox on the page (76 §2.12).
+                return block.children.length ? block : null;
+            }
+        }
+    };
+    const root = { kind: 'block', key: '', path: '', list: false, children: [] };
+    if (envelopePage.title !== undefined)
+        root.title = envelopePage.title;
+    if (envelopePage.description !== undefined)
+        root.description = envelopePage.description;
+    if (envelopePage.guide?.trim())
+        root.guide = envelopePage.guide;
+    envelopePage.children.forEach((child, i) => {
+        const out = walkEnvelope(child, '', i, 1);
+        if (out)
+            root.children.push(out);
+    });
+    const voice = envelopePage.voice;
+    // Every row on the page is known now: what lookups and row parameters may choose.
+    const env = { schema, reads, rowName, warnings, ...(input.channel ? { channel: input.channel } : {}), ...(input.functions ? { functions: input.functions } : {}), ...(input.actions ? { actions: input.actions } : {}) };
+    const placed = [];
+    for (const { path, value, node } of pendingActions) {
+        const rendered = renderAction(path, value, env);
+        if (rendered)
+            placed.push({ action: rendered, node });
+    }
+    const ids = buttonIds(placed.map((p) => p.action), rows);
+    placed.forEach(({ action, node }, i) => {
+        const id = ids[i];
+        node.actionId = id;
+        actions[id] = { ...action, id };
+    });
+    // An action that cannot be pressed is not on the page.
+    const prune = (block) => {
+        block.children = block.children.filter((child) => child.kind !== 'action' || child.actionId in actions);
+        for (const child of block.children)
+            if (child.kind === 'block')
+                prune(child);
+    };
+    prune(root);
+    const page = { root, cells, actions, rows, warnings };
+    if (extractions.size)
+        page.extractions = Object.fromEntries(extractions);
+    if (voice !== undefined)
+        page.voice = voice;
+    return page;
+}
+/**
+ * `doNow()` (76): what the page does now, rendered as a button would be so its rows are checked the same
+ * way. Nobody fills what the page left out: a required parameter it did not prefill is an error (30 §7.2).
+ */
+function renderDo(input, run) {
+    if (run.action.$action === 'channel' && input.channel !== undefined && input.channel !== 'call' && CALL_ONLY.has(run.action.channel)) {
+        throw new PageDocumentError(`the page function returned ${run.action.channel}, which only a call can do (this is ${input.channel})`);
+    }
+    const inner = renderDocument({ ...input, document: { $envelope: 1, page: { children: [{ k: 'button', key: '', action: run.action }] } } });
+    const action = Object.values(inner.actions)[0];
+    if (!action)
+        throw new PageDocumentError(`the action the page function returned cannot run: ${inner.warnings.join('; ') || 'no row to run it on'}`);
+    const missing = action.input?.required ?? [];
+    if (missing.length)
+        throw new PageDocumentError(`doNow(): ${action.name} runs with nobody to fill ${missing.join(', ')}: prefill ${missing.length > 1 ? 'them' : 'it'}`);
+    return { ...inner, auto: { action, key: run.key ?? actionKey(run.action), wait: run.wait ?? true } };
+}
+/**
+ * The action as the AI presses it, or null when it cannot be pressed on this page: with a warning when
+ * the page placed it wrong; silently when a required row choice has no row on the page (no injury yet
+ * to link a provider to), which is the data, not a mistake.
+ */
+function renderAction(path, action, env) {
+    const rendered = renderActionOf(path, action, env);
+    if (!rendered?.input)
+        return rendered;
+    const missing = unfillable(rendered.input.properties, rendered.input.required);
+    if (!missing)
+        return rendered;
+    // Said, so whoever reads the logs knows why the AI had no such button (25 §10).
+    env.warnings.push(`${path}: ${rendered.name} left off the page: no ${missing.table} row to choose for ${missing.key}`);
+    return null;
+}
+/** The first required row choice with no row to choose, at any depth; null when every one can be filled. */
+function unfillable(properties, required, prefix = '') {
+    for (const key of required ?? []) {
+        const prop = properties[key];
+        if (prop?.type === 'ref' && !prop.enum.length)
+            return { key: `${prefix}${key}`, table: prop.table };
+        if (prop?.type === 'object') {
+            const inner = unfillable(prop.properties, prop.required, `${prefix}${key}.`);
+            if (inner)
+                return inner;
+        }
+    }
+    return null;
+}
+function renderActionOf(path, action, env) {
+    const { schema, reads, rowName, warnings } = env;
+    if (action.$action === 'channel') {
+        // Not on this channel (a transfer by text, 76 §2.12): left off the page, said in the log; the page
+        // should check the channel itself.
+        if (env.channel !== undefined && env.channel !== 'call' && CALL_ONLY.has(action.channel)) {
+            env.warnings.push(`${path}: ${action.channel} is a call action, and this is ${env.channel}: left off the page (place it only on a call)`);
+            return null;
+        }
+        return channelButton(path, action);
+    }
+    if (action.$action === 'tool') {
+        if (env.channel !== undefined && env.channel !== 'call' && CALL_ONLY_TOOLS.has(action.tool)) {
+            env.warnings.push(`${path}: ${action.tool}() is a call tool, and this is ${env.channel}: left off the page (place it only on a call)`);
+            return null;
+        }
+        return toolButton(path, action.tool);
+    }
+    if (action.$action === 'createRow') {
+        const table = getCompiledTable(schema, action.table);
+        if (!table)
+            throw new PageDocumentError(`${path}: createRow on ${action.table}, not a table of this sequence`);
+        const parent = parentOf(table);
+        const fieldParam = (field) => ({ $schemaField: `${action.table}.${field}` });
+        const properties = {};
+        // A ref field is chosen among the rows the page gives (`options`, 35 §2), or fixed (`prefill`).
+        const chosen = [];
+        for (const [key, value] of Object.entries(action.prefill)) {
+            if (!getTableField(table, key))
+                throw new PageDocumentError(`${path}: createRow(${action.table}) prefills ${key}, not a field of it`);
+            if (isChoose(value)) {
+                if (parent?.field === key)
+                    throw new PageDocumentError(`${path}: the parent ${key} is where the row goes, not the AI's choice: prefill it`);
+                const offered = chooseParam(`${path}: options.${key}`, fieldParam(key), value, env);
+                if (emptyOptional(offered, key, action.required))
+                    continue;
+                properties[key] = offered;
+                chosen.push(key);
+            }
+            else if (parent?.field !== key) {
+                checkPrefill(`${path}: prefill.${key}`, fieldParam(key), value, env);
+            }
+        }
+        // A required field the page prefilled empty (null or '', as the write counts it): nobody fills it,
+        // and the write would fail (76 §2.14).
+        for (const key of action.required) {
+            const value = Object.hasOwn(action.prefill, key) ? action.prefill[key] : undefined;
+            if (value === null || value === '') {
+                throw new PageDocumentError(`${path}: createRow(${action.table}) ${key} is required: prefill a value, not ${value === null ? 'null' : "''"}, or leave it to the AI (fields)`);
+            }
+        }
+        for (const fieldName of action.fields) {
+            const def = getTableField(table, fieldName);
+            if (!def)
+                throw new PageDocumentError(`${path}: createRow field ${action.table}.${fieldName} is not in this sequence`);
+            if (parent?.field === fieldName)
+                throw new PageDocumentError(`${path}: the parent ${fieldName} is prefilled, not a field to fill`);
+            if (fieldName in action.prefill)
+                continue;
+            if (def.ref)
+                throw new PageDocumentError(`${path}: ${action.table}.${fieldName} is a ref field: give the rows the AI chooses among, options: { ${fieldName}: choose(rows, label) }, or prefill it`);
+            properties[fieldName] = expandParam(path, fieldParam(fieldName), env);
+        }
+        // Where the new row hangs: prefilled, else the one parent this run's reads of the table were anchored on.
+        let parentId = null;
+        if (parent) {
+            const preset = action.prefill[parent.field];
+            const parents = reads.parentsOf(action.table);
+            parentId = typeof preset === 'string' ? preset : parents.length === 1 ? parents[0] : null;
+            if (!parentId) {
+                warnings.push(`${path}: createRow(${action.table}) needs ${parent.field} prefilled: this run read ${parents.length} parents of it; left off the page`);
+                return null;
+            }
+            // The parent row must be a row this run read, of the parent field's table: it goes on the page,
+            // so pressing the button can write under it.
+            const parentRow = reads.row(parentId);
+            if (!parentRow || parentRow.table !== parent.table) {
+                warnings.push(`${path}: createRow(${action.table}) parent ${parentId} is not a ${parent.table} row this run read; left off the page`);
+                return null;
+            }
+            rowName(parentRow.table, parentId);
+        }
+        const set = Object.fromEntries(Object.entries(action.prefill).filter(([key, value]) => !isChoose(value) && key !== parent?.field));
+        const under = parent && parentId ? ` under ${rowName(parent.table, parentId)}` : '';
+        return {
+            id: path,
+            kind: 'createRow',
+            name: action.label ?? `Add ${table.label}`,
+            description: action.description ?? `Adds a new ${table.label} (${action.table})${under}.`,
+            input: { type: 'object', properties, required: action.required.filter((r) => r in properties) },
+            server: { kind: 'createRow', table: action.table, parentId, set, fields: [...action.fields, ...chosen], required: action.required, ...(action.key ? { key: action.key } : {}) },
+        };
+    }
+    if (action.$action === 'deleteRow') {
+        const read = reads.row(action.rowId);
+        if (!read) {
+            warnings.push(`${path}: deleteRow on a row this run did not read; left off the page`);
+            return null;
+        }
+        const name = rowName(read.table, action.rowId);
+        return {
+            id: path,
+            kind: 'deleteRow',
+            name: action.label ?? `Delete ${name}`,
+            description: action.description ?? `Delete ${name} and everything under it.`,
+            input: null,
+            server: { kind: 'deleteRow', table: read.table, rowId: action.rowId, ...(action.reason ? { reason: action.reason } : {}), ...(action.key ? { key: action.key } : {}) },
+        };
+    }
+    if (action.$action === 'followUp')
+        return followUpButton(path, action, env);
+    if (action.$action === 'cancelFollowUp')
+        return cancelFollowUpButton(path, action);
+    if (action.$action === 'function') {
+        // The function's parameters are its definition's (31 §7); a page may still declare them on the button.
+        const parameters = action.parameters ?? env.functions?.[action.name]?.parameters;
+        const { input, prefill } = actionInput(path, action.name, parameters, action.prefill ?? {}, env, action.args);
+        return {
+            id: path,
+            kind: 'function',
+            name: action.label ?? action.name,
+            description: action.description ?? `Runs ${action.name}.`,
+            input,
+            server: { kind: 'function', name: action.name, ...(action.say ? { say: action.say } : {}), ...(Object.keys(prefill).length ? { prefill } : {}), ...(action.key ? { key: action.key } : {}) },
+        };
+    }
+    // A page action's parameters are its `args` type's, as the build read it (38 §2.9).
+    const parameters = action.parameters ?? env.actions?.[action.name]?.parameters;
+    const { input, prefill } = actionInput(path, action.name, parameters, action.prefill, env, action.args);
+    return {
+        id: path,
+        kind: 'custom',
+        name: action.label ?? action.name,
+        description: action.description ?? `Runs ${action.name}.`,
+        input,
+        server: { kind: 'custom', name: action.name, prefill, ...(action.key ? { key: action.key } : {}) },
+    };
+}
+/** An optional row with no row to choose: not asked (a required one leaves its button off, `renderAction`). */
+function emptyOptional(offered, key, required) {
+    return offered.type === 'ref' && offered.enum.length === 0 && !required.includes(key);
+}
+/**
+ * What the AI fills of an action's parameters, and what the page fixed (35 §2). A prefilled row is
+ * checked and put on the page; a row in `options` (`choose(...)`) becomes the AI's choice among exactly
+ * those rows, each shown with its label. A row parameter with neither is the page's mistake: the AI is
+ * never left to guess among unlabelled rows. A required row with no row to choose stays, and
+ * `renderAction` leaves the button off; an optional one is not asked.
+ */
+function actionInput(path, name, parameters, given, env, args = {}) {
+    const declared = parameters?.properties ?? {};
+    const properties = {};
+    const prefill = {};
+    for (const key of Object.keys(given)) {
+        if (!(key in declared))
+            throw new PageDocumentError(`${path}: ${name} prefills ${key}, not one of its parameters`);
+    }
+    // How to fill each one on this page is the page's (31 §7): the AI fills only what is not prefilled.
+    for (const [key, text] of Object.entries(args)) {
+        if (!(key in declared))
+            throw new PageDocumentError(`${path}: ${name} has no parameter ${key} to describe`);
+        if (key in given && !isChoose(given[key]))
+            throw new PageDocumentError(`${path}: ${name}'s ${key} is prefilled: the AI does not fill it, so it needs no description`);
+        if (typeof text !== 'string')
+            throw new PageDocumentError(`${path}: the description of ${key} must be text`);
+    }
+    const required = parameters?.required ?? [];
+    for (const [key, param] of Object.entries(declared)) {
+        const value = given[key];
+        if (isChoose(value)) {
+            const chosen = chooseParam(`${path}: ${name} options.${key}`, param, value, env);
+            if (!emptyOptional(chosen, key, required))
+                properties[key] = chosen;
+            continue;
+        }
+        if (key in given) {
+            // Prefilled, nobody fills it: a required one must have a value (30 §7.2).
+            if ((value === null || value === undefined) && (parameters?.required ?? []).includes(key)) {
+                throw new PageDocumentError(`${path}: ${name} prefills its required ${key} with ${value === null ? 'null' : 'nothing'}: nobody fills it after the page`);
+            }
+            // An optional one fixed as none: not asked, and not passed (its parameter is `T | undefined`).
+            if (value === null || value === undefined)
+                continue;
+            checkPrefill(`${path}: ${name}({ ${key} })`, param, value, env);
+            prefill[key] = value;
+            continue;
+        }
+        if (isRefParam(param) || (isSchemaFieldParam(param) && rowTableOf(`${path}.${key}`, param, env.schema))) {
+            throw new PageDocumentError(`${path}: ${name}'s ${key} is a row: give the rows the AI chooses among, options: { ${key}: choose(rows, label) }, or prefill it`);
+        }
+        properties[key] = expandParam(`${path}.${key}`, param, env);
+    }
+    for (const [key, text] of Object.entries(args)) {
+        if (properties[key] && text.trim())
+            properties[key] = { ...properties[key], description: text };
+    }
+    const input = Object.keys(properties).length
+        ? { type: 'object', properties, required: required.filter((r) => r in properties) }
+        : null;
+    return { input, prefill };
+}
+/** A row parameter's candidates, as `choose(...)` gave them: rows this run read, of the parameter's table. */
+function chooseParam(where, param, chosen, env) {
+    const table = isRefParam(param) ? param.table : isSchemaFieldParam(param) ? rowTableOf(where, param, env.schema) : null;
+    if (!table)
+        throw new PageDocumentError(`${where}: choose(...) is for a row parameter (Id<'table'>)`);
+    if (chosen.table !== null && chosen.table !== table)
+        throw new PageDocumentError(`${where}: choose(...) gives ${chosen.table} rows, the parameter takes ${table}`);
+    const names = [];
+    const labels = {};
+    for (const option of chosen.options) {
+        const read = env.reads.row(option.id);
+        if (!read || read.table !== table)
+            throw new PageDocumentError(`${where}: choose(...) offers ${option.id}, not a ${table} row this run read`);
+        const rowName = env.rowName(table, option.id);
+        names.push(rowName);
+        labels[rowName] = option.label;
+    }
+    // Each row with its label, as a ref field's candidates are written (26 §16.2 #7).
+    const help = isSchemaFieldParam(param) ? (param.extraction ?? schemaFieldOf(where, param, env.schema).def?.extraction) : undefined;
+    return { type: 'ref', table, enum: names, labels, ...(help ? { description: help } : {}) };
+}
+/** `table.field` of a schema-field parameter, checked against this sequence. */
+function schemaFieldOf(where, param, schema) {
+    const [table, field, ...rest] = param.$schemaField.split('.');
+    const def = table ? getCompiledTable(schema, table) : undefined;
+    if (!table || !field || rest.length || !def)
+        throw new PageDocumentError(`${where}: '${param.$schemaField}' is not a table.field of this sequence`);
+    if (field === 'id')
+        return { table, field, def: null };
+    const fieldDef = getTableField(def, field);
+    if (!fieldDef)
+        throw new PageDocumentError(`${where}: '${param.$schemaField}' is not a field of this sequence`);
+    return { table, field, def: fieldDef };
+}
+/** The table a parameter chooses a row of (`table.id`, a lookup), or null. */
+function rowTableOf(where, param, schema) {
+    const { table, def } = schemaFieldOf(where, param, schema);
+    if (!def)
+        return table;
+    return def.ref ? def.ref.table : null;
+}
+/** A parameter as JSON Schema for the AI: schema fields filled in from the schema, row choices as enums. */
+function expandParam(where, param, env) {
+    if (isRefParam(param))
+        throw new PageDocumentError(`${where}: a row inside a list or an object cannot be chosen: make it a parameter of its own, chosen with options`);
+    if (isSchemaFieldParam(param)) {
+        const rowTable = rowTableOf(where, param, env.schema);
+        const { table, def } = schemaFieldOf(where, param, env.schema);
+        // A row inside a list or an object: `options` cannot reach it (35 §2).
+        if (rowTable)
+            throw new PageDocumentError(`${where}: a row inside a list or an object cannot be chosen: make it a parameter of its own, chosen with options`);
+        // The page's extraction replaces the schema's; type and allowed values stay the schema's.
+        const fieldDef = param.extraction !== undefined ? { ...def, extraction: param.extraction } : def;
+        return fieldDef.dataType === 'contact_schedule' ? scheduleProperty(fieldDef.extraction || undefined) : scalarProperty(fieldDef);
+    }
+    if (param.type === 'array') {
+        const out = { type: 'array', items: expandParam(`${where}[]`, param.items, env) };
+        if (param.description)
+            out.description = param.description;
+        return out;
+    }
+    if (param.type === 'object') {
+        const properties = {};
+        for (const [key, child] of Object.entries(param.properties))
+            properties[key] = expandParam(`${where}.${key}`, child, env);
+        const out = { type: 'object', properties };
+        if (param.required)
+            out.required = [...param.required];
+        if (param.description)
+            out.description = param.description;
+        return out;
+    }
+    if (param.type === 'contact_schedule')
+        return scheduleProperty(param.description);
+    return { ...param };
+}
+/**
+ * A prefilled row argument, at any depth (`{ target: { id } }`, a list of rows), must be a row this run
+ * read, of its table: it then goes on the page, so the action may write it.
+ */
+function checkPrefill(where, param, value, env) {
+    if (value === null || value === undefined)
+        return;
+    if (isRefParam(param)) {
+        const read = typeof value === 'string' ? env.reads.row(value) : undefined;
+        if (!read || read.table !== param.table)
+            throw new PageDocumentError(`${where} is not a ${param.table} row this run read`);
+        env.rowName(read.table, value);
+        return;
+    }
+    if (isSchemaFieldParam(param)) {
+        const rowTable = rowTableOf(where, param, env.schema);
+        if (!rowTable)
+            return;
+        const read = typeof value === 'string' ? env.reads.row(value) : undefined;
+        if (!read || read.table !== rowTable)
+            throw new PageDocumentError(`${where} is not a ${rowTable} row this run read`);
+        env.rowName(read.table, value);
+        return;
+    }
+    if (param.type === 'array') {
+        if (!Array.isArray(value))
+            throw new PageDocumentError(`${where} must be a list`);
+        value.forEach((item, i) => checkPrefill(`${where}[${i}]`, param.items, item, env));
+        return;
+    }
+    if (param.type === 'object') {
+        if (!isPlainObject(value))
+            throw new PageDocumentError(`${where} must be an object`);
+        // A prefilled object is the page's whole: the AI cannot fill a part of it (30 §7.2).
+        const missing = (param.required ?? []).filter((key) => value[key] === undefined || value[key] === null);
+        if (missing.length)
+            throw new PageDocumentError(`${where} is prefilled without ${missing.join(', ')}: a prefilled object needs every required part, nobody fills the rest`);
+        for (const [key, child] of Object.entries(param.properties))
+            checkPrefill(`${where}.${key}`, child, value[key], env);
+    }
+}
+/** A schema field's argument: the field's own type and options. */
+function scalarProperty(def) {
+    const help = describeField(def);
+    if (def.dataType === 'multi_select')
+        return { type: 'multi_select', enum: def.options ?? [], ...help };
+    if (def.dataType === 'select')
+        return { type: 'select', enum: def.options ?? [], ...help };
+    return { type: def.dataType, ...help };
+}
+/** A contact's hours (a `contact_schedule` field, a `ContactSchedule` argument): its own structure, not text. */
+function scheduleProperty(help) {
+    const window = {
+        type: 'object',
+        properties: {
+            start: { type: 'string', description: 'HH:mm' },
+            end: { type: 'string', description: 'HH:mm, after start; may be 24:00' },
+        },
+        required: ['start', 'end'],
+    };
+    const windows = { type: 'array', items: window, description: 'sorted by start, not overlapping; empty: no contact' };
+    const days = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+    return {
+        type: 'object',
+        'x-type': 'contact_schedule',
+        ...(help ? { description: help } : {}),
+        properties: {
+            weekly: {
+                type: 'object',
+                nullable: true,
+                description: 'all seven weekdays; null: no weekly restriction',
+                properties: Object.fromEntries(days.map((day) => [day, windows])),
+                required: [...days],
+            },
+            dateOverrides: {
+                type: 'array',
+                description: 'dates whose windows replace weekly',
+                items: {
+                    type: 'object',
+                    properties: { dates: { type: 'array', items: { type: 'string', description: 'YYYY-MM-DD' } }, windows },
+                    required: ['dates', 'windows'],
+                },
+            },
+        },
+        required: ['weekly', 'dateOverrides'],
+    };
+}
+/**
+ * An argument's help (26 §16.2 #5a): how to fill it, the page's (`page({ extraction })`) or else
+ * the field's; none when neither says. The label is not repeated in it; how its type is written is the
+ * system message's (26 §15.8).
+ */
+function describeField(def) {
+    return def.extraction ? { description: def.extraction } : {};
+}
+// ---------------------------------------------------------------------------------------------
+/**
+ * The buttons' ids (46 §2.1), in page order: what each does (its run key's words: a function's name,
+ * `add:injury`, `remove`, `transfer`, …); where several on the page do the same, the rows that tell them
+ * apart, by page name (`voidInjury@injury:3f9a2c1d7e04`); where that still leaves two alike, `#2`, `#3`
+ * after the first. Unique on the page, and the same from one render to the next while the button does
+ * the same thing to the same rows.
+ */
+export function buttonIds(buttons, rows) {
+    const nameOf = new Map(Object.entries(rows).map(([name, row]) => [row.id, name]));
+    const bases = buttons.map(buttonBase);
+    const rowsOf = buttons.map((button) => boundRows(button, nameOf));
+    const ids = buttons.map((_, i) => {
+        const alike = bases.flatMap((base, j) => (base === bases[i] ? [j] : []));
+        if (alike.length === 1)
+            return bases[i];
+        // Only the rows that differ among them: the case or contact they all share says nothing.
+        const shared = rowsOf[alike[0]].filter((name) => alike.every((j) => rowsOf[j].includes(name)));
+        const own = rowsOf[i].filter((name) => !shared.includes(name));
+        return own.length ? `${bases[i]}@${own.join(',')}` : bases[i];
+    });
+    const seen = new Map();
+    return ids.map((id) => {
+        const n = (seen.get(id) ?? 0) + 1;
+        seen.set(id, n);
+        return n === 1 ? id : `${id}#${n}`;
+    });
+}
+/**
+ * The button the AI means by `id` on this page (46 §2.1), or null. Its own id first; else an id it read
+ * on an earlier page, where alike buttons needed their rows (`bookSlot@slot_option:d12f648904ec`) and now
+ * one is left (`bookSlot`): the one button doing that to those rows. Never a guess among several.
+ */
+export function pressedButton(page, id) {
+    if (id in page.actions)
+        return id;
+    const plain = id.replace(/#\d+$/, '');
+    const at = plain.lastIndexOf('@');
+    if (at < 0)
+        return null;
+    const base = plain.slice(0, at);
+    const rows = plain.slice(at + 1).split(',').filter(Boolean);
+    const nameOf = new Map(Object.entries(page.rows).map(([name, row]) => [row.id, name]));
+    const found = Object.values(page.actions).filter((button) => {
+        if (buttonBase(button) !== base)
+            return false;
+        const bound = boundRows(button, nameOf);
+        return rows.every((row) => bound.includes(row));
+    });
+    return found.length === 1 ? found[0].id : null;
+}
+/** What a button does, as its id says it (46 §2.1): its run key, in words the AI reads. */
+function buttonBase(button) {
+    const server = button.server;
+    if (server.kind === 'createRow')
+        return server.key ?? `add:${server.table}`;
+    if (server.kind === 'deleteRow')
+        return server.key ?? 'remove';
+    if (server.kind === 'channel' && server.spec.channel === 'keypad')
+        return `keypad:${server.spec.key}`;
+    return runKeyOf(button);
+}
+/** The page names of the rows a button works on: the row it removes, where it adds, the rows it is prefilled with. */
+function boundRows(button, nameOf) {
+    const server = button.server;
+    const values = [];
+    if (server.kind === 'deleteRow')
+        values.push(server.rowId);
+    if (server.kind === 'createRow')
+        values.push(server.parentId, ...Object.values(server.set));
+    if (server.kind === 'custom' || server.kind === 'function')
+        values.push(...Object.values(server.prefill ?? {}));
+    if (server.kind === 'followUp')
+        values.push(server.prefill.contactId);
+    const names = [];
+    const visit = (value) => {
+        if (typeof value === 'string') {
+            const name = nameOf.get(value);
+            if (name && !names.includes(name))
+                names.push(name);
+        }
+        else if (Array.isArray(value))
+            value.forEach(visit);
+        else if (isPlainObject(value))
+            Object.values(value).forEach(visit);
+    };
+    values.forEach(visit);
+    return names;
+}
+function join(path, key) {
+    return path ? `${path}.${key}` : key;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isSlotLike(value) {
+    if (!isPlainObject(value) || !isPlainObject(value.ref) || !('state' in value))
+        return false;
+    const ref = value.ref;
+    return typeof ref.table === 'string' && typeof ref.id === 'string' && typeof ref.field === 'string';
+}
+function isFieldCell(value) {
+    return isPlainObject(value) && value.$field === true;
+}
+function isRefFieldCell(value) {
+    return isPlainObject(value) && value.$refField === true && Array.isArray(value.options);
+}
+/**
+ * The run key of a button on the page (17b §7): the action's own key, whoever runs it — the model
+ * pressing it, or the page function returning it — not its place on the page, which moves with rows.
+ */
+export function runKeyOf(action) {
+    const server = action.server;
+    if (server.kind === 'custom')
+        return server.key ?? server.name;
+    if (server.kind === 'createRow')
+        return server.key ?? `createRow:${server.table}`;
+    if (server.kind === 'deleteRow')
+        return server.key ?? `deleteRow:${server.rowId}`;
+    if (server.kind === 'function')
+        return server.key ?? server.name;
+    if (server.kind === 'followUp' || server.kind === 'cancelFollowUp')
+        return server.key;
+    // A tool's run key is its name, fixed (76 §2.18): a page has one toolbox, each tool once.
+    if (server.kind === 'tool')
+        return server.tool;
+    return actionKey(server.spec);
+}
+/** The run key of an action the page function returned, when it names none. */
+export function actionKey(action) {
+    if (action.$action === 'custom')
+        return action.key ?? action.name;
+    if (action.$action === 'function')
+        return action.key ?? action.name;
+    if (action.$action === 'followUp' || action.$action === 'cancelFollowUp')
+        return action.key;
+    if (action.$action === 'createRow')
+        return action.key ?? `createRow:${action.table}`;
+    if (action.$action === 'deleteRow')
+        return action.key ?? `deleteRow:${action.rowId}`;
+    if (action.$action === 'tool')
+        return action.tool;
+    if (action.channel === 'keypad' || action.channel === 'announce')
+        return action.key;
+    return action.key ?? action.channel;
+}
+/**
+ * The page's `$extraction` (26 §15.3): how to fill a field on this page, by `table.field`, replacing the
+ * schema's for every place it is on the page. One per field for the whole page, so a field means the
+ * same everywhere on it. A `table.field` the schema does not have is warned and left out.
+ */
+/** `page({ extraction })` (26 §15.3): how to fill a field on this page, by `table.field`. */
+function pageExtractions(value, schema, warnings) {
+    const out = new Map();
+    if (value === undefined || value === null)
+        return out;
+    if (!isPlainObject(value))
+        throw new PageDocumentError('page({ extraction }): an object of table.field → text');
+    for (const [key, text] of Object.entries(value)) {
+        if (typeof text !== 'string')
+            throw new PageDocumentError(`page({ extraction }): '${key}' must be text`);
+        const [table, field, ...rest] = key.split('.');
+        if (!table || !field || rest.length || !getCompiledTable(schema, table)?.fields[field]) {
+            warnings.push(`page({ extraction }): '${key}' is not a table.field of the schema; left out`);
+            continue;
+        }
+        out.set(key, text);
+    }
+    return out;
+}
+const CHANNEL_NAMES = {
+    transfer: ['Transfer to a person', 'Hand the call to a person. Press it only when the customer wants a person or the page says so.'],
+    keypad: ['Collect a keypress', 'The customer answers by pressing a key on their phone.'],
+    announce: ['Play a fixed statement', 'Plays a fixed statement, word for word.'],
+    end: ['End the conversation', 'Ends the conversation after your last line (say goodbye in the same step).'],
+    voicemail: ['Leave the voicemail', 'Leaves a fixed message after the beep, then hangs up.'],
+};
+const BACKGROUND_TRANSFER = [
+    'Call a person in the background',
+    'Calls a person while you keep helping the customer; the customer is put through once the person takes the call. Press it only when the customer wants a person or the page says so.',
+];
+/** What the AI sees of each tool (76 §2.18). */
+const TOOL_BUTTONS = {
+    pressKeypad: {
+        name: 'Press keys on their phone menu',
+        description: "Press keys on the other side's automated phone menu, e.g. 'Press 1 for prescriptions'. Give the keys as one string: digits 0–9, * and #; w waits half a second (\"1w2\"). Only for an automated menu, never to talk to a person.",
+        input: { type: 'object', properties: { keys: { type: 'string', description: 'The keys to press, in order: 0–9, *, #, w (wait half a second)' } }, required: ['keys'] },
+    },
+    convertTime: {
+        name: 'Convert a time',
+        description: 'Convert between a local time in a time zone and an instant in UTC. Give local and time_zone to get the instant in UTC; give at and time_zone to get the weekday, date and time there.',
+        input: {
+            type: 'object',
+            properties: {
+                time_zone: { type: 'string', description: 'IANA time zone, e.g. America/Chicago' },
+                local: { type: 'string', description: 'A local date and time there, YYYY-MM-DDTHH:mm' },
+                at: { type: 'datetime', description: 'An instant, UTC (…Z)' },
+            },
+            required: ['time_zone'],
+        },
+    },
+};
+/** A platform tool as a button (76 §2.18): the platform runs it with what the AI gave. */
+function toolButton(path, tool) {
+    const { name, description, input } = TOOL_BUTTONS[tool];
+    return { id: path, kind: 'tool', name, description, input: structuredClone(input), server: { kind: 'tool', tool } };
+}
+/** A channel action as a button: nothing for the AI to fill; what it does stays on the server. */
+function channelButton(path, action) {
+    const [name, description] = action.channel === 'transfer' && action.mode === 'background' ? BACKGROUND_TRANSFER : CHANNEL_NAMES[action.channel];
+    const label = 'label' in action ? action.label : undefined;
+    const text = 'description' in action ? action.description : undefined;
+    return {
+        id: path,
+        kind: 'channel',
+        name: label ?? name,
+        description: text ?? (action.channel === 'keypad' ? `${description} It says: "${fallbackSpoken(action.say).text}"` : description),
+        input: null,
+        server: { kind: 'channel', spec: action },
+    };
+}
+const CHANNEL_WORDS = { call: 'a call', sms: 'a text', email: 'an email' };
+/**
+ * The next-step button (40 §2.2): the AI gives when, the channel, why, and the customer's own words when
+ * they asked for it (an agreed follow-up, 09). Whom: the conversation's contact, unless the page fixed one
+ * (`prefill.contactId`) or gave the contacts the AI chooses among (`choose(...)`). Independent
+ * appointments coexist; an optional explicit target edits one (51).
+ */
+function followUpButton(path, action, env) {
+    const given = action.prefill ?? {};
+    // One channel offered, or the page fixed it: nothing for the AI to choose.
+    const channel = given.channel ?? (action.channels.length === 1 ? action.channels[0] : undefined);
+    const ways = (channel ? [channel] : action.channels).map((c) => CHANNEL_WORDS[c]).join(' or ');
+    const properties = {};
+    if (!channel)
+        properties.channel = { type: 'select', enum: [...action.channels], description: 'How to reach them' };
+    properties.scheduled_action = { type: 'string', description: 'To edit one existing appointment, its step-… ID shown below; leave out to ADD an independent appointment' };
+    properties.name = { type: 'string', description: 'Optional business label, only when the page gives a naming convention; do not invent one for deduplication' };
+    // Every time the AI writes is UTC (76 §2.19): it asks the customer's time and time zone and converts.
+    properties.at = {
+        type: 'datetime',
+        description: 'When, in UTC (ending in Z): ask them the time and their time zone (unless the page says it), then convert; for a time the customer said vaguely ("tomorrow afternoon") a time inside it',
+    };
+    properties.reason = { type: 'string', description: 'Why, in a few words: what the contact is for' };
+    properties.customer_quote = { type: 'string', description: 'When the customer asked for it or agreed to it: their own words, as said; leave out otherwise' };
+    const prefill = channel ? { channel } : {};
+    const contact = given.contactId;
+    if (typeof contact === 'string') {
+        checkPrefill(`${path}: prefill.contactId`, { type: 'ref', table: CONTACT_TABLE }, contact, env);
+        prefill.contactId = contact;
+    }
+    else if (contact) {
+        const offered = chooseParam(`${path}: options.contactId`, { type: 'ref', table: CONTACT_TABLE }, contact, env);
+        // The choice adds people besides the conversation's contact (always the default): none to add, and
+        // the button books for that contact, as when the AI leaves the choice out.
+        if (offered.type === 'ref' && offered.enum.length)
+            properties.contact = { ...offered, description: 'Whom to contact; leave out for the person in this conversation' };
+    }
+    return {
+        id: path,
+        kind: 'followUp',
+        name: action.label ?? 'Book the next step',
+        description: action.description ??
+            [
+                `Books the case's next step: ${ways} at a set time, and why.`,
+                "Press it when the customer asks to be contacted at a time or agrees to one you offered (give their words), or when the case needs a contact at a set time; tell them it is booked only once it is.",
+                "Independent appointments can coexist, even for the same person and channel. Adding does not replace any appointment.",
+                "To change one appointment, give its scheduled_action ID from the list below. Only that appointment changes; leave contact out to keep its contact.",
+            ].join(' '),
+        input: { type: 'object', properties, required: [...(channel ? [] : ['channel']), 'at', 'reason'] },
+        server: { kind: 'followUp', key: action.key, channels: [...action.channels], prefill },
+    };
+}
+/** The cancel-next-step button (40 §2.2): the AI says why. */
+function cancelFollowUpButton(path, action) {
+    return {
+        id: path,
+        kind: 'cancelFollowUp',
+        name: action.label ?? 'Cancel the next step',
+        description: action.description ??
+            "Cancels ONE appointment by its scheduled_action ID from the list below, with a reason. Other appointments stay. Talking to someone does not automatically complete their appointments; cancel only what is no longer needed.",
+        input: { type: 'object', properties: { scheduled_action: { type: 'string', description: 'The step-… ID of the appointment to cancel' }, reason: { type: 'string', description: 'Why it is no longer needed' } }, required: ['scheduled_action', 'reason'] },
+        server: { kind: 'cancelFollowUp', key: action.key },
+    };
+}
+function isRefParam(param) {
+    return !isSchemaFieldParam(param) && param.type === 'ref';
+}
+function isSchemaFieldParam(value) {
+    return isPlainObject(value) && typeof value.$schemaField === 'string';
+}
+function displayable(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    return JSON.stringify(value);
+}
+/**
+ * The page to show when the page script failed (15 §10.9): the last good page, every cell read-only
+ * and no actions, marked stale; without one, an empty page.
+ */
+export function fallbackPage(last, reason) {
+    if (!last) {
+        return {
+            root: { kind: 'block', key: '', path: '', list: false, children: [] },
+            cells: {},
+            actions: {},
+            rows: {},
+            warnings: [reason],
+            fallback: { reason, stale: false },
+        };
+    }
+    const readOnly = (node) => node.kind === 'cell'
+        ? { ...node, readOnly: true }
+        : node.kind === 'action'
+            ? null
+            : node.kind === 'block'
+                ? { ...node, children: node.children.map(readOnly).filter((n) => n !== null) }
+                : node;
+    return {
+        root: readOnly(last.root),
+        cells: Object.fromEntries(Object.entries(last.cells).map(([id, cell]) => [id, { ...cell, writable: false }])),
+        actions: {},
+        rows: last.rows,
+        ...(last.extractions ? { extractions: last.extractions } : {}),
+        warnings: [...last.warnings, reason],
+        fallback: { reason, stale: true },
+    };
+}
+//# sourceMappingURL=render.js.map