@north-light/crouter 0.3.197 → 0.3.199

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

@@ -1,47 +1,23 @@
 import { z } from 'zod';
+import { BUILTIN_PAGE_KINDS } from './page-catalog.js';
+import type { ProductPageComponents } from '../../types.js';
 export declare const PAGE_SLOT_ID_PATTERN: RegExp;
 export declare const commentAnchorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"whole">;
-}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"option">;
     optionId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"row">;
     rowId: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"column">;
-    columnId: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"card">;
-    cardId: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"range">;
-    start: z.ZodNumber;
-    end: z.ZodNumber;
-    quote: z.ZodString;
 }, z.core.$strict>], "kind">;
 export type CommentAnchor = z.infer<typeof commentAnchorSchema>;
 export declare const commentSchema: z.ZodObject<{
     id: z.ZodString;
     anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"whole">;
-    }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"option">;
         optionId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"row">;
         rowId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"column">;
-        columnId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"card">;
-        cardId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"range">;
-        start: z.ZodNumber;
-        end: z.ZodNumber;
-        quote: z.ZodString;
     }, z.core.$strict>], "kind">;
     text: z.ZodString;
 }, z.core.$strict>;
@@ -52,6 +28,8 @@ export declare const optionSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const optionsConfigSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
     options: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
@@ -71,24 +49,11 @@ export declare const optionsResponseSchema: z.ZodObject<{
     comments: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"whole">;
-        }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"option">;
             optionId: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"row">;
             rowId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"column">;
-            columnId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"card">;
-            cardId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"range">;
-            start: z.ZodNumber;
-            end: z.ZodNumber;
-            quote: z.ZodString;
         }, z.core.$strict>], "kind">;
         text: z.ZodString;
     }, z.core.$strict>>;
@@ -96,38 +61,15 @@ export declare const optionsResponseSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type OptionsResponse = z.infer<typeof optionsResponseSchema>;
 export declare const textConfigSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
     initialText: z.ZodString;
-    editable: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
+    singleLine: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type TextConfig = z.infer<typeof textConfigSchema>;
 export declare const textResponseSchema: z.ZodObject<{
     text: z.ZodString;
     edited: z.ZodBoolean;
-    comments: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"whole">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"option">;
-            optionId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"row">;
-            rowId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"column">;
-            columnId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"card">;
-            cardId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"range">;
-            start: z.ZodNumber;
-            end: z.ZodNumber;
-            quote: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        text: z.ZodString;
-    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type TextResponse = z.infer<typeof textResponseSchema>;
 export declare const tableColumnSchema: z.ZodObject<{
@@ -144,7 +86,14 @@ export declare const tableRowSchema: z.ZodObject<{
     id: z.ZodString;
     cells: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
 }, z.core.$strict>;
+export declare const tableRowsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cells: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+}, z.core.$strict>>;
+/** Table config: its data is always embedded. */
 export declare const tableConfigSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
     columns: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
@@ -158,7 +107,6 @@ export declare const tableConfigSchema: z.ZodObject<{
         id: z.ZodString;
         cells: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
     }, z.core.$strict>>>;
-    source: z.ZodOptional<z.ZodString>;
     rowSelect: z.ZodDefault<z.ZodEnum<{
         none: "none";
         single: "single";
@@ -169,7 +117,6 @@ export declare const tableConfigSchema: z.ZodObject<{
         single: "single";
         multi: "multi";
     }>>;
-    caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type TableConfig = z.infer<typeof tableConfigSchema>;
 export declare const tableResponseSchema: z.ZodObject<{
@@ -178,24 +125,11 @@ export declare const tableResponseSchema: z.ZodObject<{
     comments: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"whole">;
-        }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"option">;
             optionId: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"row">;
             rowId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"column">;
-            columnId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"card">;
-            cardId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"range">;
-            start: z.ZodNumber;
-            end: z.ZodNumber;
-            quote: z.ZodString;
         }, z.core.$strict>], "kind">;
         text: z.ZodString;
     }, z.core.$strict>>;
@@ -208,7 +142,17 @@ export declare const cardSchema: z.ZodObject<{
     body: z.ZodOptional<z.ZodString>;
     tag: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const cardsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+/** Cards config: its data is always embedded. */
 export declare const cardsConfigSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
     cards: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
@@ -216,7 +160,6 @@ export declare const cardsConfigSchema: z.ZodObject<{
         body: z.ZodOptional<z.ZodString>;
         tag: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    source: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
         single: "single";
         multi: "multi";
@@ -226,36 +169,14 @@ export declare const cardsConfigSchema: z.ZodObject<{
 export type CardsConfig = z.infer<typeof cardsConfigSchema>;
 export declare const cardsResponseSchema: z.ZodObject<{
     selectedCardIds: z.ZodArray<z.ZodString>;
-    comments: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"whole">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"option">;
-            optionId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"row">;
-            rowId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"column">;
-            columnId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"card">;
-            cardId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"range">;
-            start: z.ZodNumber;
-            end: z.ZodNumber;
-            quote: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        text: z.ZodString;
-    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type CardsResponse = z.infer<typeof cardsResponseSchema>;
 export declare const chartSeriesSchema: z.ZodObject<{
     field: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const chartDataRowsSchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+/** Chart config: its data is always embedded. */
 export declare const chartConfigSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         line: "line";
@@ -268,8 +189,7 @@ export declare const chartConfigSchema: z.ZodObject<{
         label: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     title: z.ZodOptional<z.ZodString>;
-    data: z.ZodOptional<z.ZodUnknown>;
-    source: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strict>;
 export type ChartConfig = z.infer<typeof chartConfigSchema>;
 export type SlotConfig = OptionsConfig | TextConfig | TableConfig | CardsConfig | ChartConfig | Record<string, unknown>;
@@ -280,33 +200,45 @@ export interface PageSlot {
     step: number;
     config: SlotConfig;
     unvalidated?: true;
+    /** Product registration declares this component display-only, so it carries no response. */
+    display?: true;
 }
 export interface PageSource {
     sessionName?: string;
     askedBy?: string;
-    blockedSince?: string;
+    emittedAt?: string;
+    profileName?: string;
     nodeId?: string;
 }
+export interface PageDelivery {
+    placement: 'inline' | 'panel';
+    inbox: boolean;
+    reply: boolean;
+}
 export interface PageManifest {
-    schema: 'crtr.page/v1';
-    dialect: 'md' | 'html';
+    schema: 'crtr.page/v2';
+    dialect: 'jsx' | 'html';
     title: string;
     subtitle?: string;
-    placement: 'inline' | 'panel';
-    document: 'page.md' | 'page.html';
+    delivery: PageDelivery;
+    document: 'page.tsx' | 'page.html';
     steps: number;
     slots: PageSlot[];
     source?: PageSource;
 }
+export declare const BUILTIN_PAGE_CONFIG_SCHEMAS: Record<(typeof BUILTIN_PAGE_KINDS)[number], z.ZodType>;
+export declare const BUILTIN_PAGE_RESPONSE_SCHEMAS: Partial<Record<(typeof BUILTIN_PAGE_KINDS)[number], z.ZodType>>;
+export declare function issueText(error: z.ZodError): string;
 /** The canonical response-bearing predicate used by every page consumer. */
 export declare function isResponseBearingSlot(slot: PageSlot): boolean;
-/** Validate and normalize a derived or stored manifest against the resolved product catalog. */
-export declare function validatePageManifest(parsed: unknown, productKinds?: string[]): PageManifest;
-export declare function createPageManifestSchema(productKinds?: string[]): z.ZodType<PageManifest>;
-/** Built-in-only manifest schema; product-aware callers use createPageManifestSchema. */
+/** Validate a persisted manifest. Publish-time validation made its slots authoritative, so reads do not resolve a component catalog. */
+export declare function validatePageManifest(parsed: unknown): PageManifest;
+/** Validate a manifest derived from an authored page, where the display flag comes from the registration rather than the source. */
+export declare function validateAuthoredPageManifest(parsed: unknown, productComponents?: ProductPageComponents): PageManifest;
+export declare function createPageManifestSchema(): z.ZodType<PageManifest>;
 export declare const pageManifestSchema: z.ZodType<PageManifest, unknown, z.core.$ZodTypeInternals<PageManifest, unknown>>;
 export type PageResponses = Record<string, SlotResponse>;
 /** Validate a complete final response map. */
 export declare function validatePageResponses(manifest: PageManifest, responses: unknown): PageResponses;
-/** Validate an autosaved response map, permitting omitted response-bearing slots. */
+/** Validate an autosaved response map, permitting omitted response-bearing components. */
 export declare function validatePartialPageResponses(manifest: PageManifest, responses: unknown): PageResponses;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { BUILTIN_PAGE_KINDS, isRegisteredPageKind } from './page-catalog.js';
+import { BUILTIN_PAGE_KINDS, productPageComponent } from './page-catalog.js';
 export const PAGE_SLOT_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
 const idSchema = z.string().regex(PAGE_SLOT_ID_PATTERN, { error: 'slot id must match /^[A-Za-z0-9_-]{1,64}$/' });
 const itemIdSchema = z.string().min(1);
@@ -13,20 +13,19 @@ function uniqueIds(items, ctx, label) {
         seen.add(item.id);
     });
 }
+// Response comments qualify the answer itself, so anchors name only answerable structure:
+// one of a question's options, or a table row. Feedback on rendered page content — including
+// the question text itself — is a ticket-level feedback comment (feedback.ts), not part of
+// any response.
 export const commentAnchorSchema = z.discriminatedUnion('kind', [
-    z.object({ kind: z.literal('whole') }).strict(),
     z.object({ kind: z.literal('option'), optionId: itemIdSchema }).strict(),
     z.object({ kind: z.literal('row'), rowId: itemIdSchema }).strict(),
-    z.object({ kind: z.literal('column'), columnId: itemIdSchema }).strict(),
-    z.object({ kind: z.literal('card'), cardId: itemIdSchema }).strict(),
-    z.object({ kind: z.literal('range'), start: z.number().int().nonnegative(), end: z.number().int().nonnegative(), quote: z.string() }).strict().superRefine((anchor, ctx) => {
-        if (anchor.end < anchor.start)
-            ctx.addIssue({ code: 'custom', path: ['end'], message: 'range end must be greater than or equal to start' });
-    }),
 ]);
 export const commentSchema = z.object({ id: z.string().min(1), anchor: commentAnchorSchema, text: z.string() }).strict();
 export const optionSchema = z.object({ id: itemIdSchema, label: z.string().min(1), description: z.string().optional() }).strict();
 export const optionsConfigSchema = z.object({
+    label: z.string().optional(),
+    body: z.string().optional(),
     options: z.array(optionSchema).min(1).superRefine((items, ctx) => uniqueIds(items, ctx, 'option')),
     mode: z.enum(['single', 'multi']),
     allowFreetext: z.boolean().optional(),
@@ -34,68 +33,88 @@ export const optionsConfigSchema = z.object({
     freetextPlaceholder: z.string().optional(),
 }).strict();
 export const optionsResponseSchema = z.object({ selectedOptionIds: z.array(itemIdSchema), comments: z.array(commentSchema), freetext: z.string().optional() }).strict();
-export const textConfigSchema = z.object({ initialText: z.string(), editable: z.boolean().optional(), placeholder: z.string().optional() }).strict();
-export const textResponseSchema = z.object({ text: z.string(), edited: z.boolean(), comments: z.array(commentSchema) }).strict();
+// Text is a writing surface, always: its whole point is the string the user hands back, so
+// there is no read-only mode. `singleLine` only swaps the multi-line surface for one compact
+// form field — a subject line, a name, a URL.
+export const textConfigSchema = z.object({ label: z.string().optional(), initialText: z.string(), placeholder: z.string().optional(), singleLine: z.boolean().optional() }).strict();
+export const textResponseSchema = z.object({ text: z.string(), edited: z.boolean() }).strict();
 export const tableColumnSchema = z.object({ id: itemIdSchema, label: z.string().min(1), align: z.enum(['left', 'right']).optional(), mono: z.boolean().optional() }).strict();
 export const tableCellSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 export const tableRowSchema = z.object({ id: itemIdSchema, cells: z.record(z.string(), tableCellSchema) }).strict();
-export const tableConfigSchema = z.object({
+export const tableRowsSchema = z.array(tableRowSchema).superRefine((items, ctx) => uniqueIds(items, ctx, 'row'));
+const tableConfigFields = {
+    label: z.string().optional(),
+    body: z.string().optional(),
     columns: z.array(tableColumnSchema).min(1).superRefine((items, ctx) => uniqueIds(items, ctx, 'column')),
-    rows: z.array(tableRowSchema).superRefine((items, ctx) => uniqueIds(items, ctx, 'row')).optional(),
-    source: z.string().optional(),
+    rows: tableRowsSchema.optional(),
     rowSelect: selectModeSchema.default('none'),
     columnSelect: selectModeSchema.default('none'),
-    caption: z.string().optional(),
-}).strict().superRefine((config, ctx) => {
-    if (config.rows !== undefined && config.source !== undefined)
-        ctx.addIssue({ code: 'custom', message: 'table rows and source are mutually exclusive' });
-});
+};
+/** Table config: its data is always embedded. */
+export const tableConfigSchema = z.object(tableConfigFields).strict();
 export const tableResponseSchema = z.object({ selectedRowIds: z.array(itemIdSchema), selectedColumnIds: z.array(itemIdSchema), comments: z.array(commentSchema) }).strict();
 export const cardSchema = z.object({ id: itemIdSchema, title: z.string().min(1), subtitle: z.string().optional(), body: z.string().optional(), tag: z.string().optional() }).strict();
-export const cardsConfigSchema = z.object({
-    cards: z.array(cardSchema).superRefine((items, ctx) => uniqueIds(items, ctx, 'card')).optional(),
-    source: z.string().optional(),
+export const cardsSchema = z.array(cardSchema).superRefine((items, ctx) => uniqueIds(items, ctx, 'card'));
+const cardsConfigFields = {
+    label: z.string().optional(),
+    body: z.string().optional(),
+    cards: cardsSchema.optional(),
     mode: z.enum(['single', 'multi']),
     columns: z.union([z.literal(2), z.literal(3)]).optional(),
-}).strict().superRefine((config, ctx) => {
-    if (config.cards !== undefined && config.source !== undefined)
-        ctx.addIssue({ code: 'custom', message: 'cards data and source are mutually exclusive' });
-});
-export const cardsResponseSchema = z.object({ selectedCardIds: z.array(itemIdSchema), comments: z.array(commentSchema) }).strict();
+};
+/** Cards config: its data is always embedded. */
+export const cardsConfigSchema = z.object(cardsConfigFields).strict();
+export const cardsResponseSchema = z.object({ selectedCardIds: z.array(itemIdSchema) }).strict();
 export const chartSeriesSchema = z.object({ field: z.string().min(1), label: z.string().optional() }).strict();
-export const chartConfigSchema = z.object({
+export const chartDataRowsSchema = z.array(z.record(z.string(), z.unknown()));
+const chartConfigFields = {
     kind: z.enum(['line', 'bar', 'area']),
     x: z.string().min(1),
     y: z.array(chartSeriesSchema).min(1),
     title: z.string().optional(),
-    data: z.unknown().optional(),
-    source: z.string().optional(),
-}).strict();
-const sourceSchema = z.object({ sessionName: z.string().optional(), askedBy: z.string().optional(), blockedSince: z.string().optional(), nodeId: z.string().optional() }).strict();
-const rawSlotSchema = z.object({ id: idSchema.optional(), kind: z.string().min(1), step: z.number().int().nonnegative(), config: jsonObjectSchema, unvalidated: z.literal(true).optional() }).strict();
+    data: chartDataRowsSchema.optional(),
+};
+/** Chart config: its data is always embedded. */
+export const chartConfigSchema = z.object(chartConfigFields).strict();
+const sourceSchema = z.object({ sessionName: z.string().optional(), askedBy: z.string().optional(), emittedAt: z.string().datetime({ offset: true }).optional(), profileName: z.string().optional(), nodeId: z.string().optional() }).strict();
+const deliverySchema = z.object({ placement: z.enum(['inline', 'panel']), inbox: z.boolean(), reply: z.boolean() }).strict();
+const rawSlotSchema = z.object({ id: idSchema.optional(), kind: z.string().min(1), step: z.number().int().nonnegative(), config: jsonObjectSchema, unvalidated: z.literal(true).optional(), display: z.literal(true).optional() }).strict();
 const rawPageManifestSchema = z.object({
-    schema: z.literal('crtr.page/v1'),
-    dialect: z.enum(['md', 'html']),
+    schema: z.literal('crtr.page/v2'),
+    dialect: z.enum(['jsx', 'html']),
     title: z.string().trim().min(1),
     subtitle: z.string().optional(),
-    placement: z.enum(['inline', 'panel']),
-    document: z.enum(['page.md', 'page.html']),
+    delivery: deliverySchema,
+    document: z.enum(['page.tsx', 'page.html']),
     steps: z.number().int().positive(),
     slots: z.array(rawSlotSchema),
     source: sourceSchema.optional(),
-}).strict();
-const configSchemas = {
+}).strict().superRefine((manifest, ctx) => {
+    if ((manifest.dialect === 'jsx') !== (manifest.document === 'page.tsx'))
+        ctx.addIssue({ code: 'custom', path: ['document'], message: 'document must agree with dialect' });
+    if (manifest.dialect === 'html' && (manifest.steps !== 1 || manifest.slots.length !== 0))
+        ctx.addIssue({ code: 'custom', path: ['slots'], message: 'HTML pages have exactly one step and no slots' });
+});
+export const BUILTIN_PAGE_CONFIG_SCHEMAS = {
     options: optionsConfigSchema,
     text: textConfigSchema,
     table: tableConfigSchema,
     cards: cardsConfigSchema,
     chart: chartConfigSchema,
 };
-function issueText(error) {
+export const BUILTIN_PAGE_RESPONSE_SCHEMAS = {
+    options: optionsResponseSchema,
+    text: textResponseSchema,
+    table: tableResponseSchema,
+    cards: cardsResponseSchema,
+};
+export function issueText(error) {
     return error.issues.map((issue) => `${issue.path.length === 0 ? 'value' : issue.path.join('.')}: ${issue.message}`).join('; ');
 }
 /** The canonical response-bearing predicate used by every page consumer. */
 export function isResponseBearingSlot(slot) {
+    if (slot.display === true)
+        return false;
     if (slot.unvalidated === true)
         return true;
     if (slot.kind === 'options' || slot.kind === 'text' || slot.kind === 'cards')
@@ -105,13 +124,10 @@ export function isResponseBearingSlot(slot) {
     const config = slot.config;
     return (config.rowSelect ?? 'none') !== 'none' || (config.columnSelect ?? 'none') !== 'none';
 }
-/** Validate and normalize a derived or stored manifest against the resolved product catalog. */
-export function validatePageManifest(parsed, productKinds = []) {
+function validateManifest(parsed, productComponents, authored) {
     const manifest = rawPageManifestSchema.parse(parsed);
-    if (manifest.document !== (manifest.dialect === 'md' ? 'page.md' : 'page.html'))
-        throw new Error(`page document "${manifest.document}" does not match ${manifest.dialect} dialect`);
-    if (manifest.dialect === 'md' && manifest.steps !== 1)
-        throw new Error(`md page steps must be 1; received ${manifest.steps}`);
+    if (!authored && manifest.dialect === 'html')
+        return manifest;
     const seen = new Set();
     const slots = manifest.slots.map((raw, index) => {
         if (raw.step >= manifest.steps)
@@ -120,20 +136,41 @@ export function validatePageManifest(parsed, productKinds = []) {
         if (BUILTIN_PAGE_KINDS.includes(raw.kind)) {
             if (raw.unvalidated === true)
                 throw new Error(`built-in slot kind "${raw.kind}" cannot be unvalidated`);
-            const result = configSchemas[raw.kind].safeParse(raw.config);
+            if (raw.display === true)
+                throw new Error(`built-in slot kind "${raw.kind}" cannot set display: true`);
+            const result = BUILTIN_PAGE_CONFIG_SCHEMAS[raw.kind].safeParse(raw.config);
             if (!result.success)
                 throw new Error(`invalid config for slot ${raw.id === undefined ? `#${index}` : `"${raw.id}"`} (${raw.kind}): ${issueText(result.error)}`);
+            // Authoring-time only: persisted manifests predate this rule and must keep reading.
+            if (authored && raw.kind === 'options') {
+                const options = result.data;
+                const slotName = raw.id === undefined ? `#${index}` : `"${raw.id}"`;
+                if ((options.label ?? '').trim() === '')
+                    throw new Error(`slot ${slotName} (options): label is required — the question itself, drawn as the bold first line`);
+                if ((options.body ?? '').trim() === '')
+                    throw new Error(`slot ${slotName} (options): body is required — the context under the question a label cannot carry`);
+            }
             slot = { ...(raw.id === undefined ? {} : { id: raw.id }), kind: raw.kind, step: raw.step, config: result.data };
         }
         else {
-            if (!isRegisteredPageKind(raw.kind, productKinds))
+            const component = productComponents === undefined ? undefined : productPageComponent(raw.kind, productComponents);
+            if (authored && component === undefined)
                 throw new Error(`unregistered page slot kind "${raw.kind}" at slot #${index}`);
             if (raw.unvalidated !== true)
-                throw new Error(`registered product slot kind "${raw.kind}" must set unvalidated: true`);
-            slot = { ...(raw.id === undefined ? {} : { id: raw.id }), kind: raw.kind, step: raw.step, config: raw.config, unvalidated: true };
+                throw new Error(`registered page slot kind "${raw.kind}" must set unvalidated: true`);
+            if (!authored)
+                slot = { ...(raw.id === undefined ? {} : { id: raw.id }), kind: raw.kind, step: raw.step, config: raw.config, unvalidated: true, ...(raw.display === true ? { display: true } : {}) };
+            else {
+                if (raw.display === true && component?.display !== true)
+                    throw new Error(`non-display page slot kind "${raw.kind}" cannot set display: true`);
+                slot = { ...(raw.id === undefined ? {} : { id: raw.id }), kind: raw.kind, step: raw.step, config: raw.config, unvalidated: true, ...(component?.display === true ? { display: true } : {}) };
+            }
+        }
+        if (isResponseBearingSlot(slot) && slot.id === undefined) {
+            throw new Error(slot.unvalidated === true
+                ? `product slot kind "${slot.kind}" at slot #${index} requires an id prop`
+                : `response-bearing slot kind "${slot.kind}" at slot #${index} requires an id prop`);
         }
-        if (isResponseBearingSlot(slot) && slot.id === undefined)
-            throw new Error(`response-bearing slot kind "${slot.kind}" at slot #${index} requires an id`);
         if (slot.id !== undefined) {
             if (seen.has(slot.id))
                 throw new Error(`duplicate slot id "${slot.id}"`);
@@ -143,18 +180,25 @@ export function validatePageManifest(parsed, productKinds = []) {
     });
     return { ...manifest, slots };
 }
-export function createPageManifestSchema(productKinds = []) {
+/** Validate a persisted manifest. Publish-time validation made its slots authoritative, so reads do not resolve a component catalog. */
+export function validatePageManifest(parsed) {
+    return validateManifest(parsed, undefined, false);
+}
+/** Validate a manifest derived from an authored page, where the display flag comes from the registration rather than the source. */
+export function validateAuthoredPageManifest(parsed, productComponents = []) {
+    return validateManifest(parsed, productComponents, true);
+}
+export function createPageManifestSchema() {
     return z.custom((value) => {
         try {
-            validatePageManifest(value, productKinds);
+            validatePageManifest(value);
             return true;
         }
         catch {
             return false;
         }
-    }, { error: 'invalid page manifest' }).transform((value) => validatePageManifest(value, productKinds));
+    }, { error: 'invalid page manifest' }).transform((value) => validatePageManifest(value));
 }
-/** Built-in-only manifest schema; product-aware callers use createPageManifestSchema. */
 export const pageManifestSchema = createPageManifestSchema();
 function assertUnique(values, slotId, field) {
     if (new Set(values).size !== values.length)
@@ -164,30 +208,16 @@ function validateComments(slot, comments) {
     const config = slot.config;
     for (const comment of comments) {
         const anchor = comment.anchor;
-        if (anchor.kind === 'whole')
-            continue;
         if (slot.kind === 'options' && anchor.kind === 'option') {
             if (!config.options.some((option) => option.id === anchor.optionId))
                 throw new Error(`slot "${slot.id}" comment names unknown option id "${anchor.optionId}"`);
             continue;
         }
-        if (slot.kind === 'text' && anchor.kind === 'range')
-            continue;
         if (slot.kind === 'table' && anchor.kind === 'row') {
             if (!(config.rows ?? []).some((row) => row.id === anchor.rowId))
                 throw new Error(`slot "${slot.id}" comment names unknown row id "${anchor.rowId}"`);
             continue;
         }
-        if (slot.kind === 'table' && anchor.kind === 'column') {
-            if (!config.columns.some((column) => column.id === anchor.columnId))
-                throw new Error(`slot "${slot.id}" comment names unknown column id "${anchor.columnId}"`);
-            continue;
-        }
-        if (slot.kind === 'cards' && anchor.kind === 'card') {
-            if (!(config.cards ?? []).some((card) => card.id === anchor.cardId))
-                throw new Error(`slot "${slot.id}" comment names unknown card id "${anchor.cardId}"`);
-            continue;
-        }
         throw new Error(`slot "${slot.id}" does not allow comment anchor kind "${anchor.kind}"`);
     }
 }
@@ -224,7 +254,6 @@ function parseResponse(slot, raw) {
         const result = textResponseSchema.safeParse(raw);
         if (!result.success)
             throw new Error(`invalid response for slot "${slot.id}": ${issueText(result.error)}`);
-        validateComments(slot, result.data.comments);
         return result.data;
     }
     if (slot.kind === 'table') {
@@ -262,7 +291,6 @@ function parseResponse(slot, raw) {
                 throw new Error(`slot "${slot.id}" selects unknown card id "${id}"`);
         if (config.mode === 'single' && response.selectedCardIds.length > 1)
             throw new Error(`slot "${slot.id}" is single-select but received ${response.selectedCardIds.length} card ids`);
-        validateComments(slot, response.comments);
         return response;
     }
     throw new Error(`slot "${slot.id}" kind "${slot.kind}" does not accept a response`);
@@ -287,5 +315,5 @@ function validateResponses(manifest, raw, partial) {
 }
 /** Validate a complete final response map. */
 export function validatePageResponses(manifest, responses) { return validateResponses(manifest, responses, false); }
-/** Validate an autosaved response map, permitting omitted response-bearing slots. */
+/** Validate an autosaved response map, permitting omitted response-bearing components. */
 export function validatePartialPageResponses(manifest, responses) { return validateResponses(manifest, responses, true); }

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

@@ -1,8 +1,6 @@
-/** The single response slot every synthesized question page carries. */
-export declare const ASK_RESPONSE_SLOT = "```slot:text\n{ \"id\": \"response\", \"initialText\": \"\", \"editable\": true }\n```";
-/** Build a page document from title/subtitle/body — the shape crtr synthesizes when no page file is authored. */
+/** Build a complete TSX page from title, subtitle, and body for internal producers. */
 export declare function synthesizedPageDocument(title: string, subtitle: string, body: string, responseBearing: boolean): string;
-/** Materialize a synthesized document into a private temp dir; the caller removes that dir once submitted. */
+/** Materialize an internally generated document into a private temp dir; the caller removes it after submission. */
 export declare function writeSynthesizedPage(document: string): {
     dir: string;
     path: string;