@north-light/crouter 0.3.204 → 0.3.206

package/dist/core/feed/feed.d.ts

@@ -1,8 +1,11 @@
+import type { InboxDisposition } from './inbox.js';
 export type PushKind = 'update' | 'urgent' | 'final';
 export interface PushOpts {
     kind: PushKind;
     body: string;
     from?: string;
+    /** Attribution snapshotted by the human-ticket settlement paths; absent means an ordinary report. */
+    disposition?: InboxDisposition;
 }
 export interface PushResult {
     reportPath: string;
@@ -28,6 +31,9 @@ export declare function pushUrgent(nodeId: string, body: string, opts?: {
 }): Promise<PushResult>;
 export declare function pushFinal(nodeId: string, body: string, opts?: {
     from?: string;
+    disposition?: InboxDisposition;
 }): Promise<PushResult>;
 /** Re-fan a previously committed final to its ticket origin without finalizing again. */
-export declare function redeliverFinalReport(nodeId: string, originNodeId: string, reportBasename: string, body: string): PushResult;
+export declare function redeliverFinalReport(nodeId: string, originNodeId: string, reportBasename: string, body: string, opts?: {
+    disposition?: InboxDisposition;
+}): PushResult;

package/dist/core/feed/feed.js

@@ -2,7 +2,7 @@
 import { existsSync, linkSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { openDb, reportsDir, subscribersOf, cancelCronsOnWake } from '../canvas/index.js';
+import { openDb, reportsDir, subscribersOf, cancelCronsOnWake, getNode } from '../canvas/index.js';
 import { appendInbox } from './inbox.js';
 import { appendPassive } from './passive.js';
 import { operationIdContext } from '../events/operation-id.js';
@@ -54,13 +54,13 @@ function firstLine(text, maxLen = 80) {
 function tierFor(kind) {
     return kind === 'urgent' ? 'urgent' : 'normal';
 }
-function deliver(subscribers, from, kind, reportRef, body) {
+function deliver(subscribers, from, fromName, kind, reportRef, body, disposition) {
     const deliveredTo = [];
     const failedTo = [];
     const label = firstLine(body);
     for (const sub of subscribers) {
         try {
-            const entry = { from, tier: tierFor(kind), kind, ref: reportRef, label };
+            const entry = { from, ...(fromName === undefined ? {} : { from_name: fromName }), tier: tierFor(kind), kind, ref: reportRef, label, ...(disposition === undefined ? {} : { disposition }) };
             if (sub.active)
                 appendInbox(sub.node_id, entry);
             else
@@ -110,6 +110,7 @@ async function pushWithContext(nodeId, opts) {
         throw new Error(`push: empty nodeId (kind=${opts.kind}) — a report must belong to a node`);
     const staged = stageReport(nodeId, opts.kind, opts.body);
     const from = opts.from ?? nodeId;
+    const fromName = getNode(from)?.name;
     if (opts.kind === 'final') {
         const { subscribers } = commitCanonicalFinal(nodeId, staged);
         // The finalization latch ends every wait this node was holding. It flips the
@@ -120,14 +121,14 @@ async function pushWithContext(nodeId, opts) {
         // cancel-on-wake rows anchored here go; standing crons survive. Outside
         // commitCanonicalFinal's transaction — it takes its own write boundary.
         cancelCronsOnWake(nodeId);
-        const { deliveredTo, failedTo } = deliver(subscribers, from, opts.kind, `${nodeId}:reports/${staged.basename}`, opts.body);
+        const { deliveredTo, failedTo } = deliver(subscribers, from, fromName, opts.kind, `${nodeId}:reports/${staged.basename}`, opts.body, opts.disposition);
         if (failedTo.length > 0)
             throw new FinalDeliveryError(staged.finalPath, deliveredTo, failedTo);
         return { reportPath: staged.finalPath, deliveredTo };
     }
     try {
         install(staged);
-        const { deliveredTo, failedTo } = deliver(subscribersOf(nodeId), from, opts.kind, `${nodeId}:reports/${staged.basename}`, opts.body);
+        const { deliveredTo, failedTo } = deliver(subscribersOf(nodeId), from, fromName, opts.kind, `${nodeId}:reports/${staged.basename}`, opts.body, opts.disposition);
         if (failedTo.length > 0)
             throw new Error(`report published at ${staged.finalPath}; delivery failed for ${failedTo.join(', ')}`);
         return { reportPath: staged.finalPath, deliveredTo };
@@ -151,11 +152,11 @@ export async function pushFinal(nodeId, body, opts) {
     return push(nodeId, { kind: 'final', body, ...opts });
 }
 /** Re-fan a previously committed final to its ticket origin without finalizing again. */
-export function redeliverFinalReport(nodeId, originNodeId, reportBasename, body) {
+export function redeliverFinalReport(nodeId, originNodeId, reportBasename, body, opts) {
     if (reportBasename === '' || reportBasename.includes('/') || reportBasename.includes('\\')) {
         throw new Error(`invalid canonical final report basename: ${reportBasename}`);
     }
-    const { deliveredTo, failedTo } = deliver([{ node_id: originNodeId, active: true, created: '' }], nodeId, 'final', `${nodeId}:reports/${reportBasename}`, body);
+    const { deliveredTo, failedTo } = deliver([{ node_id: originNodeId, active: true, created: '' }], nodeId, getNode(nodeId)?.name, 'final', `${nodeId}:reports/${reportBasename}`, body, opts?.disposition);
     const reportPath = join(reportsDir(nodeId), reportBasename);
     if (failedTo.length > 0)
         throw new FinalDeliveryError(reportPath, deliveredTo, failedTo);

package/dist/core/feed/inbox.d.ts

@@ -1,6 +1,7 @@
 import type { OperationId } from '../events/types.js';
 export type InboxTier = 'critical' | 'urgent' | 'normal' | 'deferred';
 export type InboxKind = 'update' | 'urgent' | 'final' | 'message' | 'completed';
+export type InboxDisposition = 'human-answer' | 'human-canceled';
 export type InboxEntryId = string & {
     readonly __inboxEntryId: unique symbol;
 };
@@ -18,6 +19,8 @@ export interface InboxEntry {
     ts: string;
     /** Node id of the sender, or null for system-generated entries. */
     from: string | null;
+    /** Display-name snapshot captured when a node created the entry. */
+    from_name?: string;
     /** Priority band for the receiver's attention. */
     tier: InboxTier;
     /** Semantic kind of the push event. */
@@ -30,6 +33,8 @@ export interface InboxEntry {
     label: string;
     /** Arbitrary structured payload for non-push message entries. */
     data?: Record<string, unknown>;
+    /** Set only by the human-ticket settlement paths; absent means an ordinary report. */
+    disposition?: InboxDisposition;
 }
 export type InboxEntryInput = Omit<InboxEntry, 'entry_id' | 'ts' | 'operation_id'> & {
     operation_id?: string;
@@ -70,15 +75,14 @@ export declare function clipBody(body: string): {
     text: string;
     clipped: boolean;
 };
-/**
- * Render many unread inbox pointers into one compact digest string.
- *
- * Format (per sender group):
- *   From <sender> — <N> update(s):
- *     [<kind>]
- *       <short report body>
- *       (report: <absolute report path>)
- *
- * Large reports remain canonical pointers and add one shared dereference hint.
- */
-export declare function coalesce(entries: InboxEntry[]): string;
+/** One deliverable user message: either a person's verbatim words or the whole
+ *  `<runtime kind="inbox">` envelope. Never both — a reader parses an envelope
+ *  only as a whole message, so mixing them attributes the card to the person. */
+export interface InboxDelivery {
+    kind: 'human' | 'card';
+    text: string;
+    entries: readonly InboxEntry[];
+}
+/** Split unread inbox pointers into ordered deliveries: each human entry
+ *  verbatim, and every other sender in one `<runtime kind="inbox">` card. */
+export declare function coalesce(entries: InboxEntry[]): readonly InboxDelivery[];

package/dist/core/feed/inbox.js

@@ -18,6 +18,7 @@ import { resolveRef } from '../canvas/history.js';
 import { emitEvent } from '../events/emit.js';
 import { errorClassFromError } from '../events/errors.js';
 import { generateOperationId, operationIdContext, validateOperationId } from '../events/operation-id.js';
+import { formatInboxCard } from '../../shared/generated-context.js';
 const INBOX_ENTRY_ID = /^(?!0{32}$)[0-9a-f]{32}$/;
 function validateInboxEntryId(value) {
     if (typeof value !== 'string' || !INBOX_ENTRY_ID.test(value))
@@ -311,8 +312,8 @@ export function clipBody(body) {
     }
     return { text: text.trimEnd(), clipped };
 }
-/** Resolve and inline a short pushed report. The report's absolute path remains
- * visible so the durable artifact is still available without a second command. */
+/** Resolve a short pushed report body for inlining. Larger reports stay
+ * pointers, carried by the entry's `ref` attribute alone. */
 function inlineReport(e) {
     if (e.ref === undefined || e.ref.startsWith('/'))
         return null;
@@ -320,7 +321,7 @@ function inlineReport(e) {
         const report = resolveRef(e.ref);
         if (report?.source !== 'report' || report.path === null || report.body.length >= INLINE_REPORT_MAX_CHARS)
             return null;
-        return { body: report.body, path: report.path };
+        return report.body;
     }
     catch {
         // A malformed or unavailable history ref remains a pointer in the digest.
@@ -328,55 +329,42 @@ function inlineReport(e) {
     }
 }
 /**
- * Render one entry's digest line(s).
+ * One entry's card body.
  *
- * A short pushed report is inlined as its own body, followed by a pointer to
- * the durable artifact. The label is NOT repeated above it: a report's label is
- * just its first line (feed.ts `firstLine`), so printing both reads as a
- * truncated preview stacked on the full text it previews. Larger reports stay
- * canonical history pointers. Direct messages retain their bounded
- * inline-body/spill behavior.
+ * A short pushed report is inlined as its own body; the label is NOT repeated
+ * above it, because a report's label is just its first line (feed.ts
+ * `firstLine`), so carrying both reads as a truncated preview stacked on the
+ * full text it previews. A larger report has only its label, with `ref`
+ * carrying the pointer. Direct messages keep their bounded inline-body/spill
+ * behavior.
  */
-function renderEntry(e) {
+function entryBody(e) {
     const report = inlineReport(e);
-    if (report !== null) {
-        const indented = report.body.trimEnd().split('\n').map((l) => `    ${l}`).join('\n');
-        return {
-            text: `  [${e.kind}]\n${indented}\n    (report: ${report.path})`,
-            hasCanonicalRef: false,
-        };
-    }
+    if (report !== null)
+        return report.trimEnd();
     const body = inlineBody(e);
-    if (body === '') {
-        const hasCanonicalRef = e.ref !== undefined && !e.ref.startsWith('/');
-        return {
-            text: e.ref !== undefined
-                ? `  [${e.kind}] ${e.label}  (ref: ${e.ref})`
-                : `  [${e.kind}] ${e.label}`,
-            hasCanonicalRef,
-        };
-    }
+    if (body === '')
+        return e.label;
     const { text, clipped } = clipBody(body);
-    const indented = text.split('\n').map((l) => `    ${l}`).join('\n');
-    const more = e.ref !== undefined
-        ? `\n    … (full body: ${e.ref})`
-        : clipped ? '\n    … (body clipped)' : '';
-    return { text: `  [${e.kind}]\n${indented}${more}`, hasCanonicalRef: false };
+    return clipped && e.ref === undefined ? `${text}\n… (body clipped)` : text;
 }
-/**
- * Render many unread inbox pointers into one compact digest string.
- *
- * Format (per sender group):
- *   From <sender> — <N> update(s):
- *     [<kind>]
- *       <short report body>
- *       (report: <absolute report path>)
- *
- * Large reports remain canonical pointers and add one shared dereference hint.
- */
+function cardEntry(e) {
+    return {
+        kind: e.kind,
+        body: entryBody(e),
+        ...(e.ref === undefined ? {} : { ref: e.ref }),
+        ...(e.disposition === undefined ? {} : { disposition: e.disposition }),
+    };
+}
+/** The sender's display name as its last entry snapshotted it. */
+function sectionName(items) {
+    return items.map((item) => item.from_name).filter((name) => name !== undefined && name !== '').at(-1);
+}
+/** Split unread inbox pointers into ordered deliveries: each human entry
+ *  verbatim, and every other sender in one `<runtime kind="inbox">` card. */
 export function coalesce(entries) {
     if (entries.length === 0)
-        return '(inbox empty)';
+        return [];
     // Group by `from` (null → 'system').
     const groups = new Map();
     for (const e of entries) {
@@ -385,27 +373,39 @@ export function coalesce(entries) {
             groups.set(key, []);
         groups.get(key).push(e);
     }
-    let hasCanonicalRef = false;
+    // Human words stay outside the card, so a batch mixing both keeps the card
+    // where the first node sender fell rather than reordering the digest.
+    const deliveries = [];
     const sections = [];
+    let cardSlot = -1;
     for (const [sender, items] of groups) {
         // A human typing directly into a node's box is a CONVERSATION TURN, not a
         // notification the node is being woken to triage. Deliver those words
-        // verbatim as the woken turn's user message — no "From … — N updates"
-        // digest framing, no `[message]` kind tag. This makes the dormant path
-        // identical to the live path (type "hi" → the node just reads "hi").
-        // Every other sender (a child push, a system notice) keeps the digest.
+        // verbatim as the woken turn's user message — no card, no `<from>` section.
+        // This makes the dormant path identical to the live path (type "hi" → the
+        // node just reads "hi"). Every other sender is digest content.
         if (sender === 'human') {
             for (const e of items) {
                 const body = inlineBody(e);
-                sections.push(body === '' ? e.label : body);
+                deliveries.push({ kind: 'human', text: body === '' ? e.label : body, entries: [e] });
             }
             continue;
         }
-        const lines = items.map(renderEntry);
-        if (lines.some((line) => line.hasCanonicalRef))
-            hasCanonicalRef = true;
-        sections.push(`From ${sender} — ${items.length} update${items.length === 1 ? '' : 's'}:\n${lines.map((line) => line.text).join('\n')}`);
+        if (cardSlot < 0) {
+            cardSlot = deliveries.length;
+            deliveries.push({ kind: 'card', text: '', entries: [] });
+        }
+        const name = sectionName(items);
+        sections.push({ id: sender, ...(name === undefined ? {} : { name }), entries: items.map(cardEntry) });
+    }
+    if (cardSlot >= 0) {
+        // Card sections group by sender, so its entry list comes from the input
+        // array instead, keeping physical inbox order.
+        deliveries[cardSlot] = {
+            kind: 'card',
+            text: formatInboxCard(sections),
+            entries: entries.filter((e) => (e.from ?? 'system') !== 'human'),
+        };
     }
-    const digest = sections.join('\n\n');
-    return hasCanonicalRef ? `${digest}\n\nDereference a ref with \`crtr canvas history read <ref>\`.` : digest;
+    return deliveries;
 }

package/dist/core/human/page-eval.d.ts

@@ -1,11 +1,16 @@
-/** One element of the tree an authored page returns. `tag` is the JSX identifier the
- *  author wrote: a registry component (`UserQuestion`), a display component (`Card`),
- *  or a plain element (`div`). Helper components are expanded before they get here. */
-export interface PageNode {
+/** One node in the rendered tree. Helper components are expanded before this point. */
+export type PageNode = PageElementNode | PageTextNode;
+export interface PageElementNode {
+    kind: 'element';
+    /** Registry component (`UserQuestion`), display component (`Card`), or plain element (`div`). */
     tag: string;
     props: Record<string, unknown>;
     children: PageNode[];
 }
+export interface PageTextNode {
+    kind: 'text';
+    text: string;
+}
 /** Evaluate the compiled page module and return the element tree its default export renders.
  *
  *  Each in-scope component name is bound to itself, so `<UserQuestion>` renders as the tag

package/dist/core/human/page-eval.js

@@ -84,6 +84,8 @@ export function evaluatePageTree(code, tags) {
             throw new PageAuthoringError('page nests deeper than a page can render; check for a component that renders itself');
         if (Date.now() > deadline)
             throw new PageAuthoringError('page took too long to render; check for a component that never finishes');
+        if (typeof value === 'string' || typeof value === 'number')
+            return [{ kind: 'text', text: String(value) }];
         if (Array.isArray(value))
             return value.flatMap((item) => normalize(item, depth + 1));
         if (!isRawElement(value))
@@ -95,7 +97,7 @@ export function evaluatePageTree(code, tags) {
         if (typeof type !== 'string')
             return nested;
         const { children: _children, ...rest } = props;
-        return [{ tag: type, props: rest, children: nested }];
+        return [{ kind: 'element', tag: type, props: rest, children: nested }];
     };
     try {
         return normalize(rendered, 0);

package/dist/core/human/page-markdown.d.ts

@@ -0,0 +1,3 @@
+import type { PageManifest } from './page-schema.js';
+/** Project the authored display JSX only. Manifest slots remain the authoritative terminal rendering for questions, inputs, charts, and product components. */
+export declare function projectPageDisplayMarkdown(document: string, manifest: PageManifest): string;

package/dist/core/human/page-markdown.js

@@ -0,0 +1,295 @@
+import { BUILTIN_KIND_BY_TAG, BUILTIN_PAGE_COMPONENT_TAGS, DISPLAY_PAGE_COMPONENT_TAGS, pageComponentTag } from './page-catalog.js';
+import { evaluatePageTree } from './page-eval.js';
+import { PageAuthoringError } from './page-errors.js';
+import { compilePage } from './page.js';
+const SLOT_TAGS = new Set(Object.keys(BUILTIN_KIND_BY_TAG));
+const BLOCK_TAGS = new Set([
+    'Page', 'Step',
+    'Card', 'CardHeader', 'CardTitle', 'CardDescription', 'CardContent', 'CardFooter', 'CardAction',
+    'Separator', 'Progress', 'Alert', 'AlertTitle', 'AlertDescription',
+    'Table', 'TableHeader', 'TableBody', 'TableFooter', 'TableRow', 'TableHead', 'TableCell', 'TableCaption',
+    'Tabs', 'TabsList', 'TabsTrigger', 'TabsContent',
+    'Accordion', 'AccordionItem', 'AccordionTrigger', 'AccordionContent',
+    'address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'div', 'dl', 'dt', 'dd', 'fieldset', 'figcaption', 'figure', 'footer', 'form',
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'li', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'summary', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td', 'ul',
+]);
+function isElement(node) {
+    return node.kind === 'element';
+}
+function markdownText(value) {
+    return value.replace(/\s+/g, ' ').replace(/([\\`*_[\]<>#])/g, '\\$1');
+}
+function cleanInline(value) {
+    return value.replace(/[ \t]+\n/g, '\n').replace(/\n[ \t]+/g, '\n').trim();
+}
+function rawText(nodes, context) {
+    let out = '';
+    for (const node of nodes) {
+        if (!isElement(node)) {
+            out += node.text;
+            continue;
+        }
+        if (context.slotTags.has(node.tag))
+            continue;
+        out += rawText(node.children, context);
+    }
+    return out;
+}
+function inlineCode(value) {
+    const text = value.replace(/\s+/g, ' ').trim();
+    if (text === '')
+        return '';
+    const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((match) => match[0].length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = /^`|`$|^ | $/.test(text) ? ' ' : '';
+    return `${fence}${pad}${text}${pad}${fence}`;
+}
+function inline(nodes, context) {
+    let out = '';
+    for (const node of nodes) {
+        if (!isElement(node)) {
+            out += markdownText(node.text);
+            continue;
+        }
+        if (context.slotTags.has(node.tag))
+            continue;
+        const body = () => inline(node.children, context);
+        switch (node.tag) {
+            case 'br':
+                out += '\n';
+                break;
+            case 'code':
+                out += inlineCode(rawText(node.children, context));
+                break;
+            case 'strong':
+            case 'b': {
+                const text = cleanInline(body());
+                if (text !== '')
+                    out += `**${text}**`;
+                break;
+            }
+            case 'em':
+            case 'i': {
+                const text = cleanInline(body());
+                if (text !== '')
+                    out += `*${text}*`;
+                break;
+            }
+            case 'del':
+            case 's': {
+                const text = cleanInline(body());
+                if (text !== '')
+                    out += `~~${text}~~`;
+                break;
+            }
+            case 'a': {
+                const text = cleanInline(body());
+                const href = node.props['href'];
+                out += typeof href === 'string' && href !== ''
+                    ? `[${text === '' ? markdownText(href) : text}](${href.replace(/([\\()])/g, '\\$1')})`
+                    : text;
+                break;
+            }
+            case 'img': {
+                const alt = typeof node.props['alt'] === 'string' ? markdownText(node.props['alt']) : 'image';
+                const src = node.props['src'];
+                out += typeof src === 'string' && src !== '' ? `![${alt}](${src.replace(/([\\()])/g, '\\$1')})` : alt;
+                break;
+            }
+            case 'Badge': {
+                const text = cleanInline(body());
+                if (text !== '')
+                    out += `**${text}**`;
+                break;
+            }
+            default:
+                out += body();
+        }
+    }
+    return out;
+}
+function quote(block) {
+    return block.split('\n').map((line) => line === '' ? '>' : `> ${line}`).join('\n');
+}
+function languageFor(node) {
+    const candidates = [node.props['className']];
+    const code = node.children.find((child) => isElement(child) && child.tag === 'code');
+    if (code !== undefined)
+        candidates.push(code.props['className']);
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'string')
+            continue;
+        const language = /(?:^|\s)language-([A-Za-z0-9_+-]+)/.exec(candidate)?.[1];
+        if (language !== undefined)
+            return language;
+    }
+    return '';
+}
+function codeBlock(node, context) {
+    const source = rawText(node.children, context).replace(/^\n/, '').replace(/\n$/, '');
+    if (source === '')
+        return '';
+    const longest = Math.max(0, ...[...source.matchAll(/`+/g)].map((match) => match[0].length));
+    const fence = '`'.repeat(Math.max(3, longest + 1));
+    return `${fence}${languageFor(node)}\n${source}\n${fence}`;
+}
+function list(node, ordered, context) {
+    const items = node.children.filter((child) => isElement(child) && child.tag === 'li');
+    return items.map((item, index) => {
+        const marker = ordered ? `${index + 1}.` : '-';
+        const body = flow(item.children, context);
+        if (body === '')
+            return '';
+        const continuation = ' '.repeat(marker.length + 1);
+        return body.split('\n').map((line, lineIndex) => lineIndex === 0 ? `${marker} ${line}` : line === '' ? '' : `${continuation}${line}`).join('\n');
+    }).filter((item) => item !== '').join('\n');
+}
+function table(node, context) {
+    const rows = [];
+    let caption = '';
+    const visit = (nodes) => {
+        for (const child of nodes) {
+            if (!isElement(child) || context.slotTags.has(child.tag))
+                continue;
+            if (child.tag === 'TableCaption' || child.tag === 'caption') {
+                caption = cleanInline(inline(child.children, context));
+                continue;
+            }
+            if (child.tag === 'TableRow' || child.tag === 'tr') {
+                const cells = child.children.filter((cell) => isElement(cell) && ['TableHead', 'TableCell', 'th', 'td'].includes(cell.tag));
+                if (cells.length > 0) {
+                    rows.push({
+                        header: cells.every((cell) => cell.tag === 'TableHead' || cell.tag === 'th'),
+                        cells: cells.map((cell) => cleanInline(inline(cell.children, context)).replaceAll('|', '\\|').replaceAll('\n', '<br>')),
+                    });
+                }
+                continue;
+            }
+            visit(child.children);
+        }
+    };
+    visit(node.children);
+    if (rows.length === 0)
+        return flow(node.children, context);
+    const headerIndex = rows.findIndex((row) => row.header);
+    const header = headerIndex === -1 ? rows[0] : rows[headerIndex];
+    const data = rows.filter((_row, index) => index !== (headerIndex === -1 ? 0 : headerIndex));
+    const width = Math.max(header.cells.length, ...data.map((row) => row.cells.length));
+    const cells = (row) => Array.from({ length: width }, (_value, index) => row[index] ?? '');
+    const lines = [
+        `| ${cells(header.cells).join(' | ')} |`,
+        `| ${Array.from({ length: width }, () => '---').join(' | ')} |`,
+        ...data.map((row) => `| ${cells(row.cells).join(' | ')} |`),
+    ];
+    if (caption !== '')
+        lines.push('', `*${caption}*`);
+    return lines.join('\n');
+}
+function block(node, context) {
+    if (context.slotTags.has(node.tag))
+        return '';
+    const contents = () => flow(node.children, context);
+    switch (node.tag) {
+        case 'Page': return contents();
+        case 'Step': {
+            const title = node.props['title'];
+            const body = contents();
+            const heading = typeof title === 'string' && title.trim() !== '' ? `## ${markdownText(title.trim())}` : '';
+            return [heading, body].filter((part) => part !== '').join('\n\n');
+        }
+        case 'p': return cleanInline(inline(node.children, context));
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6': {
+            const text = cleanInline(inline(node.children, context));
+            const level = Math.min(6, Number(node.tag[1]) + 1);
+            return text === '' ? '' : `${'#'.repeat(level)} ${text}`;
+        }
+        case 'ul': return list(node, false, context);
+        case 'ol': return list(node, true, context);
+        case 'li': return cleanInline(contents());
+        case 'pre': return codeBlock(node, context);
+        case 'blockquote': return quote(contents());
+        case 'hr':
+        case 'Separator': return '---';
+        case 'CardTitle':
+        case 'AlertTitle': {
+            const text = cleanInline(inline(node.children, context));
+            return text === '' ? '' : `**${text}**`;
+        }
+        case 'CardDescription': return cleanInline(inline(node.children, context));
+        case 'Alert': {
+            const body = contents();
+            return body === '' ? '' : quote(body);
+        }
+        case 'AlertDescription': return contents();
+        case 'Table':
+        case 'table': return table(node, context);
+        case 'TableRow':
+        case 'TableHead':
+        case 'TableCell':
+        case 'tr':
+        case 'th':
+        case 'td': return cleanInline(inline(node.children, context));
+        case 'TabsTrigger':
+        case 'AccordionTrigger':
+        case 'summary':
+        case 'dt': {
+            const text = cleanInline(inline(node.children, context));
+            return text === '' ? '' : `**${text}**`;
+        }
+        case 'Progress': {
+            const body = contents();
+            const value = node.props['value'];
+            return body !== '' ? body : typeof value === 'number' || typeof value === 'string' ? `Progress: ${markdownText(String(value))}%` : '';
+        }
+        default: return contents();
+    }
+}
+function flow(nodes, context) {
+    const blocks = [];
+    let pending = '';
+    const flush = () => {
+        const text = cleanInline(pending);
+        pending = '';
+        if (text !== '')
+            blocks.push(text);
+    };
+    for (const node of nodes) {
+        if (!isElement(node) || (!context.slotTags.has(node.tag) && !BLOCK_TAGS.has(node.tag))) {
+            pending += isElement(node) ? inline([node], context) : markdownText(node.text);
+            continue;
+        }
+        flush();
+        const rendered = block(node, context).trim();
+        if (rendered !== '')
+            blocks.push(rendered);
+    }
+    flush();
+    return blocks.join('\n\n');
+}
+/** Project the authored display JSX only. Manifest slots remain the authoritative terminal rendering for questions, inputs, charts, and product components. */
+export function projectPageDisplayMarkdown(document, manifest) {
+    if (manifest.dialect !== 'jsx')
+        return '';
+    const productTags = new Set(manifest.slots.filter((slot) => slot.unvalidated === true).map((slot) => pageComponentTag(slot.kind)));
+    const inScope = [...BUILTIN_PAGE_COMPONENT_TAGS, ...DISPLAY_PAGE_COMPONENT_TAGS, ...productTags];
+    const roots = evaluatePageTree(compilePage(document), inScope);
+    const pages = [];
+    const collect = (nodes) => {
+        for (const node of nodes) {
+            if (!isElement(node))
+                continue;
+            if (node.tag === 'Page')
+                pages.push(node);
+            collect(node.children);
+        }
+    };
+    collect(roots);
+    if (pages.length !== 1)
+        throw new PageAuthoringError(`page display projection expected one <Page> element; found ${pages.length}`);
+    return flow(pages[0].children, { slotTags: new Set([...SLOT_TAGS, ...productTags]) }).trim();
+}