@protoyard/blueprint 0.0.0-stage → 1.1.1

package/dist/kinds/page-doc-runtime.js

@@ -0,0 +1,55 @@
+import { defineKindPrototype, KIND_DEFAULT_SCENARIO, KIND_GENERATOR_VERSION, } from "./runtime.js";
+/** Kind default scenario id (shared content-kind runtime). */
+export const PAGES_DEFAULT_SCENARIO = KIND_DEFAULT_SCENARIO;
+/** Kind generator version (shared content-kind runtime). */
+export const PAGES_GENERATOR_VERSION = KIND_GENERATOR_VERSION;
+/**
+ * Builds the shared content-kind runtime for a page document body by wrapping
+ * it as a `kind: "page"` blueprint and calling {@link defineKindPrototype}.
+ * The wrapper has no `brand` (the default theme), so it never loads brand
+ * resolution or the palette generator a seed brand needs.
+ * Lives in `@protoyard/blueprint/kinds` so `@protoyard/pages` stays free of a
+ * blueprint dependency (no package cycle).
+ */
+export function definePrototypeFromPage(page, options) {
+    return defineKindPrototype(pageBlueprint(page, options), toKindOptions(options));
+}
+/**
+ * Builds the shared content-kind runtime for a doc document body.
+ */
+export function definePrototypeFromDoc(doc, options) {
+    return defineKindPrototype(docBlueprint(doc, options), toKindOptions(options));
+}
+function toKindOptions(options) {
+    return {
+        namespace: options.namespace,
+        slug: options.slug,
+        version: options.version,
+        defaultThemeId: null,
+        brandTheme: null,
+    };
+}
+function pageBlueprint(page, options) {
+    return {
+        formatVersion: 1,
+        name: options.name ?? page.title,
+        description: options.description ?? page.description ?? '',
+        tags: options.tags ?? ['page'],
+        ...(options.category ? { category: options.category } : {}),
+        ...(options.icon ? { icon: options.icon } : {}),
+        kind: 'page',
+        page,
+    };
+}
+function docBlueprint(doc, options) {
+    return {
+        formatVersion: 1,
+        name: options.name ?? doc.title,
+        description: options.description ?? doc.description ?? '',
+        tags: options.tags ?? ['doc'],
+        ...(options.category ? { category: options.category } : {}),
+        ...(options.icon ? { icon: options.icon } : {}),
+        kind: 'doc',
+        doc,
+    };
+}

package/dist/kinds/page.d.ts

@@ -0,0 +1,16 @@
+import { type PageDocument } from '@protoyard/pages';
+import type { z } from 'zod';
+/**
+ * The `kind: "page"` body (ADR-036, ADR-039): `@protoyard/pages`'
+ * `PageDocumentSchema` (sections of blocks, nav, form refs; unique section ids
+ * and anchors, nav and `forms[].formId` resolved) plus the checks that span
+ * the whole page:
+ *
+ * - block ids, headings included, are unique across all sections (a page is
+ *   one DOM and one form-response store, so `#id` and form ids must be too);
+ * - a block id never equals a section id or anchor (both are hash targets);
+ * - `forms[].sectionId`, when set, is the section that holds the form;
+ * - every `#fragment` link in a block (`cta`, `cards`) points at a section
+ *   anchor or a block id on the page.
+ */
+export declare const PageBodySchema: z.ZodType<PageDocument>;

package/dist/kinds/page.js

@@ -0,0 +1,67 @@
+import { forEachBlock } from '@protoyard/blocks';
+import { PageDocumentSchema } from '@protoyard/pages';
+import { blockIds, checkFragmentLinks, fragmentLinks } from "./anchors.js";
+/**
+ * The `kind: "page"` body (ADR-036, ADR-039): `@protoyard/pages`'
+ * `PageDocumentSchema` (sections of blocks, nav, form refs; unique section ids
+ * and anchors, nav and `forms[].formId` resolved) plus the checks that span
+ * the whole page:
+ *
+ * - block ids, headings included, are unique across all sections (a page is
+ *   one DOM and one form-response store, so `#id` and form ids must be too);
+ * - a block id never equals a section id or anchor (both are hash targets);
+ * - `forms[].sectionId`, when set, is the section that holds the form;
+ * - every `#fragment` link in a block (`cta`, `cards`) points at a section
+ *   anchor or a block id on the page.
+ */
+export const PageBodySchema = PageDocumentSchema.superRefine((page, ctx) => {
+    const sectionTargets = new Set();
+    for (const section of page.sections) {
+        sectionTargets.add(section.id);
+        sectionTargets.add(section.anchor ?? section.id);
+    }
+    const seen = new Map();
+    const blockTargets = new Set();
+    const formSection = new Map();
+    page.sections.forEach((section, s) => {
+        for (const { id, path } of blockIds(section.blocks, ['sections', s, 'blocks'])) {
+            blockTargets.add(id);
+            const first = seen.get(id);
+            if (first !== undefined) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path,
+                    message: `Block id "${id}" is already used in section "${first}"; block ids must be unique on a page`,
+                });
+            }
+            else {
+                seen.set(id, section.id);
+            }
+            if (sectionTargets.has(id)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path,
+                    message: `Block id "${id}" is also a section id or anchor; use a different id`,
+                });
+            }
+        }
+        // Forms anywhere in the section, containers included.
+        forEachBlock(section.blocks, (block) => {
+            if (block.type === 'form' && !formSection.has(block.id))
+                formSection.set(block.id, section.id);
+        });
+    });
+    page.forms?.forEach((ref, i) => {
+        if (ref.sectionId === undefined)
+            return;
+        const holder = formSection.get(ref.formId);
+        if (holder !== undefined && holder !== ref.sectionId) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['forms', i, 'sectionId'],
+                message: `Form "${ref.formId}" is in section "${holder}", not "${ref.sectionId}"`,
+            });
+        }
+    });
+    checkFragmentLinks(fragmentLinks(page.sections, ['sections']), new Set([...sectionTargets, ...blockTargets]), ctx, 'a section anchor or block id on this page');
+});

package/dist/kinds/parse.d.ts

@@ -0,0 +1,18 @@
+import { type DeckBlueprint, type DocBlueprint, type PageBlueprint } from './envelope.ts';
+/**
+ * `@protoyard/blueprint/kinds/parse` — synchronous parsers for one content
+ * kind, for code that already knows its kind and ships its body schema
+ * anyway: a generated deck, page or doc prototype. Each validates exactly
+ * what `parseAnyBlueprint` validates for that kind (the same envelope and body
+ * schema) and throws a `ZodError` on failure.
+ *
+ * `parseAnyBlueprint` loads the body schema on demand. Awaiting it at a
+ * module's top level deadlocks a single-chunk build (the Claude artifact
+ * target): the dynamic import resolves to a facade that re-imports the chunk
+ * still waiting on it. These parsers import the schema statically instead.
+ * The package has no side effects, so a deck prototype keeps only the deck
+ * schema. The universal player never imports this module.
+ */
+export declare function parseDeckBlueprint(input: unknown): DeckBlueprint;
+export declare function parsePageBlueprint(input: unknown): PageBlueprint;
+export declare function parseDocBlueprint(input: unknown): DocBlueprint;

package/dist/kinds/parse.js

@@ -0,0 +1,27 @@
+import { DeckBodySchema } from "./deck.js";
+import { DocBodySchema } from "./doc.js";
+import { contentBlueprintSchema, } from "./envelope.js";
+import { PageBodySchema } from "./page.js";
+/**
+ * `@protoyard/blueprint/kinds/parse` — synchronous parsers for one content
+ * kind, for code that already knows its kind and ships its body schema
+ * anyway: a generated deck, page or doc prototype. Each validates exactly
+ * what `parseAnyBlueprint` validates for that kind (the same envelope and body
+ * schema) and throws a `ZodError` on failure.
+ *
+ * `parseAnyBlueprint` loads the body schema on demand. Awaiting it at a
+ * module's top level deadlocks a single-chunk build (the Claude artifact
+ * target): the dynamic import resolves to a facade that re-imports the chunk
+ * still waiting on it. These parsers import the schema statically instead.
+ * The package has no side effects, so a deck prototype keeps only the deck
+ * schema. The universal player never imports this module.
+ */
+export function parseDeckBlueprint(input) {
+    return contentBlueprintSchema('deck', DeckBodySchema).parse(input);
+}
+export function parsePageBlueprint(input) {
+    return contentBlueprintSchema('page', PageBodySchema).parse(input);
+}
+export function parseDocBlueprint(input) {
+    return contentBlueprintSchema('doc', DocBodySchema).parse(input);
+}

package/dist/kinds/runtime.d.ts

@@ -0,0 +1,128 @@
+import { type PolicyDefinition, type PrototypeDefinition, type Scenario, type ScenarioDefinition, type Theme, type WorldSeed } from '@protoyard/core';
+import type { ContentBlueprint } from './envelope.ts';
+import type { ContentKind } from './kind.ts';
+/**
+ * The runtime definition of a content-kind blueprint (deck, page, doc;
+ * ADR-036): what `definePrototypeFromBlueprint` is for apps, without the
+ * entity derivations. Both the player and generated kind prototypes use it,
+ * so a deck behaves the same at both levels.
+ *
+ * - **Storage:** three stores: `blockStates` (interactive block state, keyed
+ *   by `stateKey(documentId, blockId)`), `formResponses` (submitted form
+ *   blocks) and, from database version 2, `docEdits` (a doc's saved edits,
+ *   `@protoyard/pages` `createDocEditServices`). Writes go through services,
+ *   never components.
+ * - **World:** one `default` scenario and three simulated personas, a
+ *   presenter, an audience member and a viewer, built from fixed data (no
+ *   world generator, no Faker). `generateWorld` makes the runtime skip the
+ *   generation context entirely.
+ * - **Policy:** presenters interact, answer and read every response;
+ *   audience members interact and answer; viewers only look. Simulated, not
+ *   security.
+ */
+/** The scenario every content kind opens in (the only one it declares). */
+export declare const KIND_DEFAULT_SCENARIO = "default";
+/** Bump when the kind world (personas, organization) can change for the same scenario. */
+export declare const KIND_GENERATOR_VERSION = 1;
+/** The Dexie stores of a content-kind prototype. */
+export declare const KIND_STORES: Readonly<{
+    /** Interactive block state: `key` is `stateKey(documentId, blockId)`. */
+    blockStates: "key, documentId, blockId, updatedAt";
+    /**
+     * Submitted form blocks — same row contract and indexes as
+     * `@protoyard/pages` `FORM_RESPONSES_STORE_STRING` (lead form contract).
+     */
+    formResponses: "id, formId, createdAt, personaId, documentId, [formId+createdAt]";
+    /**
+     * Saved doc edits, one row per doc and world — same row contract as
+     * `@protoyard/pages` `DOC_EDITS_STORE_STRING` (PLAN_008 decision D3).
+     */
+    docEdits: "key, documentId, docId, updatedAt";
+}>;
+/**
+ * The database versions of a content-kind prototype. Version 1 had no
+ * `docEdits`; version 2 adds it, so a browser that holds version 1 data
+ * upgrades in place and keeps its block states and form responses.
+ */
+export declare const KIND_DATABASE_VERSIONS: readonly ({
+    version: number;
+    stores: {
+        blockStates: "key, documentId, blockId, updatedAt";
+        formResponses: "id, formId, createdAt, personaId, documentId, [formId+createdAt]";
+    };
+} | {
+    version: number;
+    stores: {
+        blockStates: "key, documentId, blockId, updatedAt";
+        formResponses: "id, formId, createdAt, personaId, documentId, [formId+createdAt]";
+        docEdits: "key, documentId, docId, updatedAt";
+    };
+})[];
+/** The latest kind database version (the manifest's `storage.schemaVersion`). */
+export declare const KIND_SCHEMA_VERSION = 2;
+/**
+ * Capabilities the kind services assert (simulated policy, not security).
+ * Form caps are the canonical `@protoyard/pages` FORM_CAPABILITIES strings so
+ * createFormServices and createKindServices share one policy vocabulary.
+ */
+export declare const KIND_CAPABILITIES: Readonly<{
+    /** Vote, answer, change a calculator, open a tab… on an interactive block. */
+    interact: "blocks:interact";
+    /** Submit a form block (`form:submit`). */
+    respond: "form:submit";
+    /** Read form responses (`form:read`). */
+    readResponses: "form:read";
+    /** Clear / administer responses (`form:admin`). */
+    adminResponses: "form:admin";
+}>;
+/** The simulated roles of a content-kind prototype. */
+export declare const KIND_ROLES: Readonly<{
+    /** Presenter: interact, submit/read forms, and administer responses. */
+    presenter: ("blocks:interact" | "form:submit" | "form:read" | "form:admin")[];
+    /** Audience: interact and submit/read forms. */
+    audience: ("blocks:interact" | "form:submit" | "form:read")[];
+    /** Viewer: submit and read forms (no interactive block mutations). */
+    viewer: ("form:submit" | "form:read")[];
+}>;
+export type KindRole = keyof typeof KIND_ROLES;
+/** Fixed persona ids (valid block viewer ids). */
+export declare const KIND_PERSONAS: Readonly<{
+    presenter: string;
+    audience: string;
+    viewer: string;
+}>;
+export interface KindRuntimeOptions {
+    /** Storage namespace (IndexedDB names): usually the content namespace (`bp-…`). */
+    namespace: string;
+    /** Manifest slug; defaults to the namespace. */
+    slug?: string;
+    /** Manifest version (default `0.1.0`). */
+    version?: string;
+}
+/** {@link defineKindPrototype} options: the blueprint brand, already resolved. */
+export interface KindPrototypeOptions extends KindRuntimeOptions {
+    /** The theme the prototype opens in (`kindDefaultThemeId`); `null` for the default theme. */
+    defaultThemeId: string | null;
+    /** The built brand theme to register (`kindBrandTheme`); `null` for none or a library brand. */
+    brandTheme: Theme | null;
+}
+/** Any parsed content-kind blueprint. */
+/** One content blueprint of any kind (a union over kinds, not an intersection of bodies). */
+export type AnyContentBlueprint = {
+    [K in ContentKind]: ContentBlueprint<K>;
+}[ContentKind];
+export declare function kindScenarios(): ScenarioDefinition[];
+export declare function kindPolicy(): PolicyDefinition;
+/**
+ * The kind world for a scenario: an organization and the three personas,
+ * from fixed data and the scenario's reference time only, so the same
+ * scenario always gives the same world.
+ */
+export declare function kindWorld(scenario: Pick<Scenario, 'referenceTime' | 'organization'>): WorldSeed;
+/**
+ * Builds a `definePrototype`-valid definition for a deck, page or doc whose
+ * brand is already resolved. Generated kind prototypes call it with the theme
+ * `protoyard generate` resolved, so their first chunk never loads the palette
+ * generator a seed brand needs; `defineKindRuntime` resolves the brand first.
+ */
+export declare function defineKindPrototype(doc: AnyContentBlueprint, options: KindPrototypeOptions): PrototypeDefinition;

package/dist/kinds/runtime.js

@@ -0,0 +1,206 @@
+import { definePrototype, parseManifest, } from '@protoyard/core';
+import { DOC_EDITS_STORE_STRING, FORM_CAPABILITIES, FORM_RESPONSES_STORE_STRING, } from '@protoyard/pages';
+/**
+ * The runtime definition of a content-kind blueprint (deck, page, doc;
+ * ADR-036): what `definePrototypeFromBlueprint` is for apps, without the
+ * entity derivations. Both the player and generated kind prototypes use it,
+ * so a deck behaves the same at both levels.
+ *
+ * - **Storage:** three stores: `blockStates` (interactive block state, keyed
+ *   by `stateKey(documentId, blockId)`), `formResponses` (submitted form
+ *   blocks) and, from database version 2, `docEdits` (a doc's saved edits,
+ *   `@protoyard/pages` `createDocEditServices`). Writes go through services,
+ *   never components.
+ * - **World:** one `default` scenario and three simulated personas, a
+ *   presenter, an audience member and a viewer, built from fixed data (no
+ *   world generator, no Faker). `generateWorld` makes the runtime skip the
+ *   generation context entirely.
+ * - **Policy:** presenters interact, answer and read every response;
+ *   audience members interact and answer; viewers only look. Simulated, not
+ *   security.
+ */
+/** The scenario every content kind opens in (the only one it declares). */
+export const KIND_DEFAULT_SCENARIO = 'default';
+/** Bump when the kind world (personas, organization) can change for the same scenario. */
+export const KIND_GENERATOR_VERSION = 1;
+/** The Dexie stores of a content-kind prototype. */
+export const KIND_STORES = Object.freeze({
+    /** Interactive block state: `key` is `stateKey(documentId, blockId)`. */
+    blockStates: 'key, documentId, blockId, updatedAt',
+    /**
+     * Submitted form blocks — same row contract and indexes as
+     * `@protoyard/pages` `FORM_RESPONSES_STORE_STRING` (lead form contract).
+     */
+    formResponses: FORM_RESPONSES_STORE_STRING,
+    /**
+     * Saved doc edits, one row per doc and world — same row contract as
+     * `@protoyard/pages` `DOC_EDITS_STORE_STRING` (PLAN_008 decision D3).
+     */
+    docEdits: DOC_EDITS_STORE_STRING,
+});
+/**
+ * The database versions of a content-kind prototype. Version 1 had no
+ * `docEdits`; version 2 adds it, so a browser that holds version 1 data
+ * upgrades in place and keeps its block states and form responses.
+ */
+export const KIND_DATABASE_VERSIONS = Object.freeze([
+    {
+        version: 1,
+        stores: { blockStates: KIND_STORES.blockStates, formResponses: KIND_STORES.formResponses },
+    },
+    { version: 2, stores: { ...KIND_STORES } },
+]);
+/** The latest kind database version (the manifest's `storage.schemaVersion`). */
+export const KIND_SCHEMA_VERSION = 2;
+/**
+ * Capabilities the kind services assert (simulated policy, not security).
+ * Form caps are the canonical `@protoyard/pages` FORM_CAPABILITIES strings so
+ * createFormServices and createKindServices share one policy vocabulary.
+ */
+export const KIND_CAPABILITIES = Object.freeze({
+    /** Vote, answer, change a calculator, open a tab… on an interactive block. */
+    interact: 'blocks:interact',
+    /** Submit a form block (`form:submit`). */
+    respond: FORM_CAPABILITIES.submit,
+    /** Read form responses (`form:read`). */
+    readResponses: FORM_CAPABILITIES.read,
+    /** Clear / administer responses (`form:admin`). */
+    adminResponses: FORM_CAPABILITIES.admin,
+});
+/** The simulated roles of a content-kind prototype. */
+export const KIND_ROLES = Object.freeze({
+    /** Presenter: interact, submit/read forms, and administer responses. */
+    presenter: [
+        KIND_CAPABILITIES.interact,
+        KIND_CAPABILITIES.respond,
+        KIND_CAPABILITIES.readResponses,
+        KIND_CAPABILITIES.adminResponses,
+    ],
+    /** Audience: interact and submit/read forms. */
+    audience: [
+        KIND_CAPABILITIES.interact,
+        KIND_CAPABILITIES.respond,
+        KIND_CAPABILITIES.readResponses,
+    ],
+    /** Viewer: submit and read forms (no interactive block mutations). */
+    viewer: [KIND_CAPABILITIES.respond, KIND_CAPABILITIES.readResponses],
+});
+/** Fixed persona ids (valid block viewer ids). */
+export const KIND_PERSONAS = Object.freeze({
+    presenter: 'presenter',
+    audience: 'audience',
+    viewer: 'viewer',
+});
+const ORGANIZATION_ID = 'org_kind';
+export function kindScenarios() {
+    return [
+        {
+            id: KIND_DEFAULT_SCENARIO,
+            name: 'Default',
+            description: 'The presenter with an audience member and a viewer to switch to.',
+            seed: 136_001,
+            referenceTime: '2026-06-01T09:00:00.000Z',
+            density: 'empty',
+            organization: { id: ORGANIZATION_ID, size: 3, ageDays: 30, subscription: 'free' },
+            actor: { id: KIND_PERSONAS.presenter, role: 'presenter', onboardingComplete: true },
+        },
+    ];
+}
+export function kindPolicy() {
+    return {
+        roles: Object.fromEntries(Object.entries(KIND_ROLES).map(([role, caps]) => [role, [...caps]])),
+    };
+}
+const PEOPLE = [
+    { role: 'presenter', name: 'Rowan Presenter', title: 'Presenter', avatar: 'av-012' },
+    { role: 'audience', name: 'Sam Audience', title: 'Audience member', avatar: 'av-047' },
+    { role: 'viewer', name: 'Vera Viewer', title: 'Viewer (read only)', avatar: 'av-103' },
+];
+/**
+ * The kind world for a scenario: an organization and the three personas,
+ * from fixed data and the scenario's reference time only, so the same
+ * scenario always gives the same world.
+ */
+export function kindWorld(scenario) {
+    const joinedAt = new Date(Date.parse(scenario.referenceTime) - 30 * 86_400_000).toISOString();
+    const organizationId = scenario.organization?.id ?? ORGANIZATION_ID;
+    const organization = {
+        id: organizationId,
+        name: 'Example audience',
+        type: 'audience',
+        plan: 'free',
+        billingStatus: 'none',
+        createdAt: joinedAt,
+        size: PEOPLE.length,
+        featureFlags: {},
+    };
+    const personas = PEOPLE.map((person) => ({
+        id: KIND_PERSONAS[person.role],
+        name: person.name,
+        email: `${person.role}@example.com`,
+        avatar: person.avatar,
+        title: person.title,
+        locale: 'en-US',
+        timezone: 'UTC',
+        joinedAt,
+        onboardingComplete: true,
+        preferences: {},
+        summary: `${person.title}. Simulated persona.`,
+    }));
+    const memberships = PEOPLE.map((person) => ({
+        id: `m_${person.role}`,
+        personaId: KIND_PERSONAS[person.role],
+        organizationId,
+        role: person.role,
+        joinedAt,
+        capabilities: [],
+    }));
+    return {
+        organizations: [organization],
+        personas,
+        memberships,
+        tables: { blockStates: [], formResponses: [], docEdits: [] },
+    };
+}
+/**
+ * Builds a `definePrototype`-valid definition for a deck, page or doc whose
+ * brand is already resolved. Generated kind prototypes call it with the theme
+ * `protoyard generate` resolved, so their first chunk never loads the palette
+ * generator a seed brand needs; `defineKindRuntime` resolves the brand first.
+ */
+export function defineKindPrototype(doc, options) {
+    const slug = options.slug ?? options.namespace;
+    const theme = options.brandTheme;
+    const scenarios = kindScenarios();
+    const manifest = parseManifest({
+        id: `local.${slug}`,
+        slug,
+        kind: 'prototype',
+        name: doc.name,
+        description: doc.description ?? '',
+        version: options.version ?? '0.1.0',
+        category: doc.category ?? doc.catalog?.category ?? doc.kind,
+        tags: doc.tags,
+        ...(doc.icon ? { icon: doc.icon } : {}),
+        defaultScenario: KIND_DEFAULT_SCENARIO,
+        defaultTheme: options.defaultThemeId ?? 'violet',
+        preview: { viewport: 'desktop' },
+        storage: { namespace: options.namespace, schemaVersion: KIND_SCHEMA_VERSION },
+        scenarios: scenarios.map((scenario) => scenario.id),
+    });
+    return definePrototype({
+        manifest,
+        database: {
+            versions: KIND_DATABASE_VERSIONS.map((entry) => ({
+                version: entry.version,
+                stores: { ...entry.stores },
+            })),
+        },
+        scenarios,
+        policy: kindPolicy(),
+        ...(theme ? { themes: [theme] } : {}),
+        generate: (ctx) => kindWorld(ctx.scenario),
+        generateWorld: async (scenario) => kindWorld(scenario),
+        generatorVersion: KIND_GENERATOR_VERSION,
+    });
+}

package/dist/kinds/services.d.ts

@@ -0,0 +1,49 @@
+import { type Block, type FormBlock } from '@protoyard/blocks';
+import { type BlockStateHost } from '@protoyard/blocks/interactive';
+import { type PrototypeRuntime } from '@protoyard/core';
+import { type FormResponse as PageFormResponse } from '@protoyard/pages';
+import { z } from 'zod';
+import { type AnyContentBlueprint } from './runtime.ts';
+/**
+ * Finds a block by id anywhere in a document body (slides, sections, columns,
+ * tabs, reveal panels…). Interactive blocks always carry an id, and the
+ * document is the one the runtime was defined from, so a caller can never
+ * substitute its own block definition.
+ */
+export declare function findDocumentBlock(doc: AnyContentBlueprint, blockId: string): Block | null;
+/**
+ * One stored form submission — canonical `@protoyard/pages` FormResponse.
+ * `createdAt` is the submission time; `personaId` / `documentId` when present.
+ */
+export type FormResponse = PageFormResponse;
+/** A form block's fields as a strict zod schema for one submission. */
+export declare function formResponseSchema(form: FormBlock): z.ZodType<FormResponse['values']>;
+/** A refused form submission: the values do not fit the form, or the form does not exist. */
+export declare class FormResponseError extends Error {
+    readonly formId: string;
+    /** The first message per field name; `''` holds form-level issues such as unknown fields. */
+    readonly issues: Record<string, string>;
+    constructor(formId: string, message: string, issues?: Record<string, string>);
+}
+export interface KindServicesOptions {
+    /** The document id in state keys (default: the runtime's storage namespace). */
+    documentId?: string;
+}
+export interface KindServices {
+    readonly documentId: string;
+    /** The persistent host interactive blocks render from (`read` is a cache of the table). */
+    readonly blockStates: BlockStateHost & {
+        /** Loads every stored state for this document into the cache and notifies listeners. */
+        refresh(): Promise<void>;
+    };
+    readonly responses: {
+        /** Stores one submission for a form block, as the active persona. */
+        submit(formId: string, values: unknown): Promise<FormResponse>;
+        /** Presenters see every response; everyone else sees their own. */
+        list(formId?: string): Promise<FormResponse[]>;
+    };
+    /** Stops following scenario loads. */
+    destroy(): void;
+}
+/** The kind services for a runtime defined by `defineKindRuntime(doc, …)`. */
+export declare function createKindServices(runtime: PrototypeRuntime, doc: AnyContentBlueprint, options?: KindServicesOptions): Promise<KindServices>;