@protoyard/blueprint 0.0.0-stage → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `@protoyard/blueprint` — data-only blueprints (ADR-017). A `blueprint.json`
+ * describes a product (entities, fields, relations, roles, screens) without
+ * any executable code; this package validates it and derives what a
+ * prototype needs from it.
+ *
+ * Framework-agnostic: it depends only on `@protoyard/core` and zod and never
+ * imports Svelte (ADR-002).
+ */
+/** Version of the blueprint document format. Bumped only on breaking changes. */
+export declare const BLUEPRINT_FORMAT_VERSION = 1;
+/**
+ * Authoring APIs (brief synthesis and kind detection, outlines, deck lint and
+ * layout selection, authoring validation) are named exports of this entry and
+ * tree-shake: a prototype that only parses or generates never bundles them.
+ * Browser consumers that want them on demand can load them as one lazy chunk,
+ * together with the deck layout catalog, through `loadAuthoringApis()`.
+ */
+export declare function loadAuthoringApis(): Promise<typeof import('./authoring-apis.ts')>;
+/** What `loadAuthoringApis()` resolves to. */
+export type AuthoringApis = Awaited<ReturnType<typeof loadAuthoringApis>>;
+/** Layout catalog types for authoring tools (type-only; the catalog itself loads lazily). */
+export type { DeckLayoutEntry, DeckLayoutId, LayoutPacing } from '@protoyard/decks/layouts';
+export { type AggregateCell, type AggregateQuerySpec, type AggregateResult, type AggregateSpec, aggregate, type BucketUnit, bucketStartUtc, createAggregateQuery, MAX_BUCKETS, NO_GROUP, } from './aggregate.ts';
+export { type AppLayout, type AppModel, type AppNavGroup, type AppNavItem, type AppRoute, type AppRouteTarget, deriveAppModel, entityLabel, screenHasOwnView, screenNavIcon, } from './app-model.ts';
+export { ARCHETYPE_IDS as KIT_ARCHETYPE_IDS, ARCHETYPE_KIT_ENTRY_POINTS, type ArchetypeKitEntryPoint, ArchetypeSchema, type BlueprintArchetype, type BlueprintArchetypeInput, } from './archetypes/index.ts';
+export { AUDIT_REDACTED, type AuditAction, type AuditChange, type AuditEntry, type AuditEvent, auditDiff, type BlueprintAuditService, blueprintUsesAudit, createAuditService, createAuditWriter, } from './audit.ts';
+export { type DeckLintDiagnostic, type DeckLintResult, type DeckLintSeverity, lintDeckAssets, lintDeckContent, lintDeckStructure, } from './authoring/deck-lint.ts';
+export { type DeckLayoutSelection, type DeckLayoutSlideInput, propsForSelectedLayout, type SelectDeckLayoutsOptions, selectDeckLayouts, } from './authoring/index.ts';
+export { type BlueprintAuthoringDiagnostic, type BlueprintAuthoringValidation, type BlueprintDiagnosticPath, blockOrAssetHint, diagnosticCode, diagnosticsFromBlockIssues, issueToDiagnostic, toJsonPath as authoringToJsonPath, validateBlueprintForAuthoring, } from './authoring-validation.ts';
+export { AVATAR_IDS, type AvatarField, type AvatarId, avatarFields, isAvatarId, nextAvatar, primaryAvatarField, } from './avatar.ts';
+export { type BrandContrastFailure, BrandThemeError, brandLibraryThemeId, brandThemeExportName, brandThemeId, closestIds, emitBrandThemeModule, getStyleProfile, type ResolveBrandOptions, resolveBlueprintBrand, STYLE_PROFILES, type StyleProfile, } from './brand.ts';
+export { APP_CUES, type AppBriefResult, type ApplyOutlineBoundsResult, ARCHETYPE_IDS, ARCHETYPES, type Archetype, applyOutlineBounds, type BoundBriefInput, type BriefKindDetection, type BriefLimitCode, type BriefLimitIssue, type BriefOptions, type BriefResult, blueprintFromBrief, boundBriefInput, buildDocOutline, buildPageOutline, type ContentBriefOptions, type ContentBriefResult, type CueStrength, checkOutlineBounds, chooseDeckOutline, DECK_OUTLINE_IDS, DECK_OUTLINE_LIMITS, DECK_OUTLINES, type DeckOutlineId, type DeckOutlineOptions, type DeckOutlineResult, type DeckOutlineSlide, type DeckPacing, type DeckSlidePlan, type DetectKindOptions, DOC_OUTLINE_IDS, type DocOutlineId, type DocOutlineResult, deckOutlineRange, deckTitleFromBrief, detectBriefKind, detectPageDocOmissions, fieldFromPhrase, GENERIC_ARCHETYPE, isAppBriefResult, isContentBriefResult, KIND_CUES, type KindConfidence, type KindCue, MAX_BRIEF_LENGTH, MAX_CONTENT_BRIEF_LENGTH, OUTLINE_LIMITS, type OutlineBlock, type OutlineBoundsInput, type OutlineBuildOptions, type OutlineLimits, type OutlineSection, type OutlineUnitInput, PAGE_OUTLINE_IDS, type PageOutlineId, type PageOutlineResult, PEOPLE_ENTITIES, prepareBriefForSynthesis, requestedSlideCount, type SuggestedLayout, sectionIds, selectDocOutline, selectPageOutline, synthesizeAppFromBrief, synthesizeContentFromBrief, synthesizeDeckFromBrief, synthesizeDeckOutline, synthesizeDocFromBrief, synthesizePageFromBrief, } from './brief/index.ts';
+export { canvasScreenIssues } from './canvas-screen.ts';
+export { guardCsvFormula, needsCsvFormulaGuard, unguardCsvFormula } from './csv-guard.ts';
+export { type BlueprintFile, type BlueprintFileMetadata, createFileServices, DEFAULT_FILE_QUOTA_BYTES, type FileService, type FileServices, FileUploadError, type FileUploadProgress, } from './files.ts';
+export { ENTITY_FORM_CUSTOM_KINDS, type EntityFormField, type EntityFormFieldType, type EntityFormModel, type EntityFormOption, type EntityFormSchema, type EntityFormSchemaOptions, entityFormModel, HOSTED_FORM_KINDS, UNASSIGNED_OPTION, } from './form-schema.ts';
+export { BLUEPRINT_GENERATOR_SDK, blueprintGeneratorVersion } from './generator-version.ts';
+export { BLUEPRINT_NAMESPACE_PREFIX, type BlueprintIdentity, blueprintIdentity, canonicalJson, } from './identity.ts';
+export { type AnyBlueprint, type BlueprintBase, blueprintKind, type ContentBlueprint, type DeckBlueprint, type DocBlueprint, isAppBlueprint, isContentBlueprint, isDeckBlueprint, isDocBlueprint, isPageBlueprint, type KindBodies, type PageBlueprint, parseAnyBlueprint, safeParseAnyBlueprint, } from './kinds/envelope.ts';
+export { BLUEPRINT_KINDS, type BlueprintKind, CONTENT_KINDS, type ContentKind, DEFAULT_BLUEPRINT_KIND, detectBlueprintKind, isBlueprintKind, isContentKind, type KindDetection, unknownKindMessage, } from './kinds/kind.ts';
+export { DEFAULT_UNTRUSTED_DOCUMENT_LIMITS, type UntrustedDocumentLimits, } from './kinds/limits.ts';
+export { appendMigration, applyUpgradeOps, type BlueprintMigration, type DiffBlueprintsOptions, defaultForField, deriveDatabaseVersions, diffBlueprints, fieldProperty, latestSchemaVersion, MigrationError, toDatabaseVersion, type UpgradeOp, } from './migrations.ts';
+export { BLUEPRINT_MOTION_LEVELS, type BlueprintMotion, type BlueprintMotionLevel, BlueprintMotionSchema, blueprintMotionLevel, DEFAULT_BLUEPRINT_MOTION_LEVEL, deckWithMotionCeiling, isBlueprintMotionLevel, lowerMotionLevel, } from './motion.ts';
+export { type BlueprintNotificationService, createNotificationService, createNotificationWriter, type NotificationEvent, } from './notifications.ts';
+export { type ApplyBlueprintPatchOptions, applyBlueprintPatch, applyContentPatch, applyJsonPatch, BlueprintPatchError, type BlueprintPatchErrorCode, type BlueprintPatchResult, type ContentPatchResult, JSON_PATCH_MAX_NODES, JSON_PATCH_MAX_OPS, JSON_POINTER_MAX_LENGTH, type JsonPatchOperation, JsonPatchOperationSchema, JsonPatchSchema, jsonEqual, parseJsonPointer, } from './patch.ts';
+export { CAPABILITIES, derivePolicy, type EntityCapabilityMap } from './policy.ts';
+export { BLUEPRINT_DEFAULT_SCENARIO, blueprintBrandTheme, brandDefaultThemeId, definePrototypeFromBlueprint, type RuntimeDefinition, type RuntimeDefinitionOptions, } from './runtime-definition.ts';
+export { blueprintScenarios } from './scenarios.ts';
+export { AGGREGATES, type Aggregate, BLUEPRINT_SCHEMA_URL, type Blueprint, type BlueprintBrand, type BlueprintBrandInput, BlueprintBrandSchema, type BlueprintDashboardWidget, type BlueprintEntity, type BlueprintField, type BlueprintHistoryEntry, BlueprintHistoryEntrySchema, type BlueprintInput, type BlueprintNotificationRule, type BlueprintRole, BlueprintSchema, type BlueprintScreen, type BlueprintScreenFilter, type BlueprintScreenInput, type BlueprintScreenNav, BUCKET_UNITS, blueprintIssues, CHART_KINDS, DashboardWidgetSchema, type DateWindow, DateWindowSchema, DETAIL_TABS, dashboardWidgets, dateWindowDays, ENTITY_ACTIONS, type EntityAction, EntityFeaturesSchema, EntitySchema, entityTable, FIELD_KINDS, FIELD_TRENDS, type FieldKind, FieldSchema, PermissionActionSchema, parseBlueprint, RESERVED_FIELD_NAMES, RESERVED_SCREEN_PATHS, RoleSchema, SCREEN_NAV_ICONS, SCREEN_TYPES, ScreenBucketSchema, ScreenFilterSchema, type ScreenNavIcon, ScreenNavSchema, ScreenSchema, type ScreenType, SETTINGS_SECTIONS, safeParseBlueprint, screenPath, } from './schema.ts';
+export { blueprintJsonSchema } from './schema-json.ts';
+export { BULK_CHUNK, createEntityServices, EntityInUseError, EntityNotFoundError, type EntityService, type EntityServices, type ExportCsvFilter, ImportCsvError, type ImportCsvOptions, type ImportCsvResult, UNDO_WINDOW_MS, } from './services.ts';
+export { blueprintShareFragment, type DocumentShareDecodeResult, decodeBlueprintShare, decodeDocumentShare, encodeBlueprintShare, MAX_SHARE_DECODED_BYTES, MAX_SHARE_DOCUMENT_DECODED_BYTES, MAX_SHARE_ENCODED_LENGTH, readBlueprintShareFragment, SHARE_FRAGMENT_PARAM, SHARE_LINK_BROWSERS, SHARE_LINK_VERSION, type ShareDecodeResult, type ShareLinkIssue, ShareLinkTooLargeError, supportsShareLinks, } from './share.ts';
+export { SHEET_COLUMN_KINDS, SHEET_EDITABLE_KINDS, SHEET_MAX_COLUMNS, SHEET_READONLY_KINDS, SHEET_TOTAL_KINDS, sheetColumns, sheetScreenIssues, } from './sheet-screen.ts';
+export { deriveIntegrity, deriveStores, entityStoreString, FEATURE_STORE_STRINGS, FEATURE_TABLES, relationProperty, storeIndexForField, } from './storage.ts';
+export { MAX_STREAM_CANDIDATES, paintStreamedBlueprint, type StreamedBlueprint, truncatedJsonCandidates, } from './stream.ts';
+export { DEFAULT_UNTRUSTED_BLUEPRINT_LIMITS, loadUntrustedBlueprint, loadUntrustedDocument, type UntrustedBlueprintIssue, type UntrustedBlueprintLimits, type UntrustedBlueprintResult, type UntrustedDocumentResult, } from './untrusted.ts';
+export { deriveInputSchemas, type EntityInput, type EntityInputSchemas, fieldLabel, inputProperty, parseMoneyText, } from './validation.ts';
+export { type BlueprintValidation, CONTAINS_FIELD_KINDS, dataHolds, evaluateValidationSuccess, routeMatches, VALIDATION_DATA_OPS, VALIDATION_MAX_TASKS, type ValidationData, type ValidationDataOp, ValidationDataSchema, type ValidationObservation, type ValidationOutcome, type ValidationRoute, ValidationRouteSchema, ValidationSchema, type ValidationSuccess, ValidationSuccessSchema, type ValidationTask, ValidationTaskSchema, validationBaseline, } from './validation-tasks.ts';
+export { type BlueprintVariant, type DeriveKindVariantsOptions, type DeriveVariantsOptions, deriveKindVariants, deriveVariants, type KindBlueprintVariant, type KindVariantAxes, type KindVariantChanges, VARIANT_DECK_TRANSITIONS, VARIANT_DENSITIES, VARIANT_DENSITY_SCALE, VARIANT_MAX_COUNT, VARIANT_THEME_PRESETS, type VariantAxes, type VariantChanges, type VariantDeckTransition, type VariantDensity, } from './variants.ts';

package/dist/index.js

@@ -0,0 +1,58 @@
+/**
+ * `@protoyard/blueprint` — data-only blueprints (ADR-017). A `blueprint.json`
+ * describes a product (entities, fields, relations, roles, screens) without
+ * any executable code; this package validates it and derives what a
+ * prototype needs from it.
+ *
+ * Framework-agnostic: it depends only on `@protoyard/core` and zod and never
+ * imports Svelte (ADR-002).
+ */
+/** Version of the blueprint document format. Bumped only on breaking changes. */
+export const BLUEPRINT_FORMAT_VERSION = 1;
+/**
+ * Authoring APIs (brief synthesis and kind detection, outlines, deck lint and
+ * layout selection, authoring validation) are named exports of this entry and
+ * tree-shake: a prototype that only parses or generates never bundles them.
+ * Browser consumers that want them on demand can load them as one lazy chunk,
+ * together with the deck layout catalog, through `loadAuthoringApis()`.
+ */
+export function loadAuthoringApis() {
+    return import("./authoring-apis.js");
+}
+export { aggregate, bucketStartUtc, createAggregateQuery, MAX_BUCKETS, NO_GROUP, } from "./aggregate.js";
+export { deriveAppModel, entityLabel, screenHasOwnView, screenNavIcon, } from "./app-model.js";
+export { ARCHETYPE_IDS as KIT_ARCHETYPE_IDS, ARCHETYPE_KIT_ENTRY_POINTS, ArchetypeSchema, } from "./archetypes/index.js";
+export { AUDIT_REDACTED, auditDiff, blueprintUsesAudit, createAuditService, createAuditWriter, } from "./audit.js";
+export { lintDeckAssets, lintDeckContent, lintDeckStructure, } from "./authoring/deck-lint.js";
+export { propsForSelectedLayout, selectDeckLayouts, } from "./authoring/index.js";
+export { blockOrAssetHint, diagnosticCode, diagnosticsFromBlockIssues, issueToDiagnostic, toJsonPath as authoringToJsonPath, validateBlueprintForAuthoring, } from "./authoring-validation.js";
+export { AVATAR_IDS, avatarFields, isAvatarId, nextAvatar, primaryAvatarField, } from "./avatar.js";
+export { BrandThemeError, brandLibraryThemeId, brandThemeExportName, brandThemeId, closestIds, emitBrandThemeModule, getStyleProfile, resolveBlueprintBrand, STYLE_PROFILES, } from "./brand.js";
+export { APP_CUES, ARCHETYPE_IDS, ARCHETYPES, applyOutlineBounds, blueprintFromBrief, boundBriefInput, buildDocOutline, buildPageOutline, checkOutlineBounds, chooseDeckOutline, DECK_OUTLINE_IDS, DECK_OUTLINE_LIMITS, DECK_OUTLINES, DOC_OUTLINE_IDS, deckOutlineRange, deckTitleFromBrief, detectBriefKind, detectPageDocOmissions, fieldFromPhrase, GENERIC_ARCHETYPE, isAppBriefResult, isContentBriefResult, KIND_CUES, MAX_BRIEF_LENGTH, MAX_CONTENT_BRIEF_LENGTH, OUTLINE_LIMITS, PAGE_OUTLINE_IDS, PEOPLE_ENTITIES, prepareBriefForSynthesis, requestedSlideCount, sectionIds, selectDocOutline, selectPageOutline, synthesizeAppFromBrief, synthesizeContentFromBrief, synthesizeDeckFromBrief, synthesizeDeckOutline, synthesizeDocFromBrief, synthesizePageFromBrief, } from "./brief/index.js";
+export { canvasScreenIssues } from "./canvas-screen.js";
+export { guardCsvFormula, needsCsvFormulaGuard, unguardCsvFormula } from "./csv-guard.js";
+export { createFileServices, DEFAULT_FILE_QUOTA_BYTES, FileUploadError, } from "./files.js";
+export { ENTITY_FORM_CUSTOM_KINDS, entityFormModel, HOSTED_FORM_KINDS, UNASSIGNED_OPTION, } from "./form-schema.js";
+export { BLUEPRINT_GENERATOR_SDK, blueprintGeneratorVersion } from "./generator-version.js";
+export { BLUEPRINT_NAMESPACE_PREFIX, blueprintIdentity, canonicalJson, } from "./identity.js";
+export { blueprintKind, isAppBlueprint, isContentBlueprint, isDeckBlueprint, isDocBlueprint, isPageBlueprint, parseAnyBlueprint, safeParseAnyBlueprint, } from "./kinds/envelope.js";
+export { BLUEPRINT_KINDS, CONTENT_KINDS, DEFAULT_BLUEPRINT_KIND, detectBlueprintKind, isBlueprintKind, isContentKind, unknownKindMessage, } from "./kinds/kind.js";
+export { DEFAULT_UNTRUSTED_DOCUMENT_LIMITS, } from "./kinds/limits.js";
+export { appendMigration, applyUpgradeOps, defaultForField, deriveDatabaseVersions, diffBlueprints, fieldProperty, latestSchemaVersion, MigrationError, toDatabaseVersion, } from "./migrations.js";
+export { BLUEPRINT_MOTION_LEVELS, BlueprintMotionSchema, blueprintMotionLevel, DEFAULT_BLUEPRINT_MOTION_LEVEL, deckWithMotionCeiling, isBlueprintMotionLevel, lowerMotionLevel, } from "./motion.js";
+export { createNotificationService, createNotificationWriter, } from "./notifications.js";
+export { applyBlueprintPatch, applyContentPatch, applyJsonPatch, BlueprintPatchError, JSON_PATCH_MAX_NODES, JSON_PATCH_MAX_OPS, JSON_POINTER_MAX_LENGTH, JsonPatchOperationSchema, JsonPatchSchema, jsonEqual, parseJsonPointer, } from "./patch.js";
+export { CAPABILITIES, derivePolicy } from "./policy.js";
+export { BLUEPRINT_DEFAULT_SCENARIO, blueprintBrandTheme, brandDefaultThemeId, definePrototypeFromBlueprint, } from "./runtime-definition.js";
+export { blueprintScenarios } from "./scenarios.js";
+export { AGGREGATES, BLUEPRINT_SCHEMA_URL, BlueprintBrandSchema, BlueprintHistoryEntrySchema, BlueprintSchema, BUCKET_UNITS, blueprintIssues, CHART_KINDS, DashboardWidgetSchema, DateWindowSchema, DETAIL_TABS, dashboardWidgets, dateWindowDays, ENTITY_ACTIONS, EntityFeaturesSchema, EntitySchema, entityTable, FIELD_KINDS, FIELD_TRENDS, FieldSchema, PermissionActionSchema, parseBlueprint, RESERVED_FIELD_NAMES, RESERVED_SCREEN_PATHS, RoleSchema, SCREEN_NAV_ICONS, SCREEN_TYPES, ScreenBucketSchema, ScreenFilterSchema, ScreenNavSchema, ScreenSchema, SETTINGS_SECTIONS, safeParseBlueprint, screenPath, } from "./schema.js";
+export { blueprintJsonSchema } from "./schema-json.js";
+export { BULK_CHUNK, createEntityServices, EntityInUseError, EntityNotFoundError, ImportCsvError, UNDO_WINDOW_MS, } from "./services.js";
+export { blueprintShareFragment, decodeBlueprintShare, decodeDocumentShare, encodeBlueprintShare, MAX_SHARE_DECODED_BYTES, MAX_SHARE_DOCUMENT_DECODED_BYTES, MAX_SHARE_ENCODED_LENGTH, readBlueprintShareFragment, SHARE_FRAGMENT_PARAM, SHARE_LINK_BROWSERS, SHARE_LINK_VERSION, ShareLinkTooLargeError, supportsShareLinks, } from "./share.js";
+export { SHEET_COLUMN_KINDS, SHEET_EDITABLE_KINDS, SHEET_MAX_COLUMNS, SHEET_READONLY_KINDS, SHEET_TOTAL_KINDS, sheetColumns, sheetScreenIssues, } from "./sheet-screen.js";
+export { deriveIntegrity, deriveStores, entityStoreString, FEATURE_STORE_STRINGS, FEATURE_TABLES, relationProperty, storeIndexForField, } from "./storage.js";
+export { MAX_STREAM_CANDIDATES, paintStreamedBlueprint, truncatedJsonCandidates, } from "./stream.js";
+export { DEFAULT_UNTRUSTED_BLUEPRINT_LIMITS, loadUntrustedBlueprint, loadUntrustedDocument, } from "./untrusted.js";
+export { deriveInputSchemas, fieldLabel, inputProperty, parseMoneyText, } from "./validation.js";
+export { CONTAINS_FIELD_KINDS, dataHolds, evaluateValidationSuccess, routeMatches, VALIDATION_DATA_OPS, VALIDATION_MAX_TASKS, ValidationDataSchema, ValidationRouteSchema, ValidationSchema, ValidationSuccessSchema, ValidationTaskSchema, validationBaseline, } from "./validation-tasks.js";
+export { deriveKindVariants, deriveVariants, VARIANT_DECK_TRANSITIONS, VARIANT_DENSITIES, VARIANT_DENSITY_SCALE, VARIANT_MAX_COUNT, VARIANT_THEME_PRESETS, } from "./variants.js";

package/dist/kinds/anchors.d.ts

@@ -0,0 +1,18 @@
+import { type Block } from '@protoyard/blocks';
+import type { z } from 'zod';
+export type Path = (string | number)[];
+/** Every block id in a list (containers included), with its path. */
+export declare function blockIds(blocks: readonly Block[], base: Path): {
+    id: string;
+    path: Path;
+}[];
+/** Every `#fragment` link under `value`, by path. Nothing else is read. */
+export declare function fragmentLinks(value: unknown, base: Path): {
+    target: string;
+    path: Path;
+}[];
+/** Reports every `#fragment` link whose target is not in `targets`. */
+export declare function checkFragmentLinks(links: readonly {
+    target: string;
+    path: Path;
+}[], targets: ReadonlySet<string>, ctx: z.RefinementCtx, what: string): void;

package/dist/kinds/anchors.js

@@ -0,0 +1,46 @@
+import { forEachBlock } from '@protoyard/blocks';
+/** Every block id in a list (containers included), with its path. */
+export function blockIds(blocks, base) {
+    const out = [];
+    forEachBlock(blocks, (block, path) => {
+        const id = 'id' in block ? block.id : undefined;
+        if (typeof id === 'string')
+            out.push({ id, path: [...base, ...path, 'id'] });
+    });
+    return out;
+}
+/** Every `#fragment` link under `value`, by path. Nothing else is read. */
+export function fragmentLinks(value, base) {
+    const out = [];
+    const stack = [{ value, path: base }];
+    while (stack.length > 0) {
+        const { value: node, path } = stack.pop();
+        if (Array.isArray(node)) {
+            for (const [i, item] of node.entries())
+                stack.push({ value: item, path: [...path, i] });
+        }
+        else if (node !== null && typeof node === 'object') {
+            for (const [key, child] of Object.entries(node)) {
+                if (key === 'href' && typeof child === 'string' && child.startsWith('#')) {
+                    out.push({ target: child.slice(1), path: [...path, key] });
+                }
+                else {
+                    stack.push({ value: child, path: [...path, key] });
+                }
+            }
+        }
+    }
+    return out.sort((a, b) => JSON.stringify(a.path).localeCompare(JSON.stringify(b.path)));
+}
+/** Reports every `#fragment` link whose target is not in `targets`. */
+export function checkFragmentLinks(links, targets, ctx, what) {
+    for (const link of links) {
+        if (!targets.has(link.target)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: link.path,
+                message: `Link "#${link.target}" does not match ${what}`,
+            });
+        }
+    }
+}

package/dist/kinds/bodies.d.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod';
+import type { ContentKind } from './kind.ts';
+/** Load only the requested kind body, keeping all content schemas off the app path. */
+export declare function kindBodySchema(kind: ContentKind): Promise<z.ZodType | undefined>;
+/** @internal Used only by `kinds/testing.ts`. */
+export declare function setKindBodyOverride(kind: ContentKind, schema: z.ZodType | undefined): void;

package/dist/kinds/bodies.js

@@ -0,0 +1,32 @@
+/**
+ * Body schemas of the content kinds, one per kind, supplied by their engine
+ * packages (ADR-036): the deck from `@protoyard/decks/schema`, page and doc
+ * from `@protoyard/pages`. A kind without a schema here fails to parse with a
+ * "not available in this build yet" issue: there is no loose fallback.
+ *
+ * Wiring a kind is a static entry in `SHIPPED`, never runtime registration,
+ * so untrusted input can never be validated against a schema someone injected.
+ */
+/** Test-only overrides (see `kinds/testing.ts`); empty outside Vitest. */
+const overrides = new Map();
+/** Load only the requested kind body, keeping all content schemas off the app path. */
+export async function kindBodySchema(kind) {
+    const override = overrides.get(kind);
+    if (override)
+        return override;
+    switch (kind) {
+        case 'deck':
+            return (await import("./deck.js")).DeckBodySchema;
+        case 'page':
+            return (await import("./page.js")).PageBodySchema;
+        case 'doc':
+            return (await import("./doc.js")).DocBodySchema;
+    }
+}
+/** @internal Used only by `kinds/testing.ts`. */
+export function setKindBodyOverride(kind, schema) {
+    if (schema)
+        overrides.set(kind, schema);
+    else
+        overrides.delete(kind);
+}

package/dist/kinds/brand-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { PrototypeDefinition, Theme } from '@protoyard/core';
+import { type AnyContentBlueprint, type KindRuntimeOptions } from './runtime.ts';
+/**
+ * Brand resolution for content kinds, kept apart from `runtime.ts`: a seed
+ * brand needs the palette generator (`createThemeFromSeed`), so only callers
+ * that resolve a brand at run time (the player, `definePrototypeFromPage`)
+ * load it. Generated kind prototypes get the resolved theme from
+ * `protoyard generate` and call `defineKindPrototype` directly.
+ */
+/** The theme id a content blueprint opens in: its library theme, its built brand theme, or null. */
+export declare function kindDefaultThemeId(doc: AnyContentBlueprint): string | null;
+/** The built brand theme a content blueprint registers, or null (no brand, or a library brand). */
+export declare function kindBrandTheme(doc: AnyContentBlueprint): Theme | null;
+/**
+ * Builds a `definePrototype`-valid definition for a deck, page or doc. Throws
+ * `BrandThemeError` for an unknown library theme or a brand that fails AA,
+ * like the app path.
+ */
+export declare function defineKindRuntime(doc: AnyContentBlueprint, options: KindRuntimeOptions): PrototypeDefinition;

package/dist/kinds/brand-runtime.js

@@ -0,0 +1,35 @@
+import { brandLibraryThemeId, resolveBlueprintBrand } from "../brand.js";
+import { defineKindPrototype, } from "./runtime.js";
+/**
+ * Brand resolution for content kinds, kept apart from `runtime.ts`: a seed
+ * brand needs the palette generator (`createThemeFromSeed`), so only callers
+ * that resolve a brand at run time (the player, `definePrototypeFromPage`)
+ * load it. Generated kind prototypes get the resolved theme from
+ * `protoyard generate` and call `defineKindPrototype` directly.
+ */
+/** The theme id a content blueprint opens in: its library theme, its built brand theme, or null. */
+export function kindDefaultThemeId(doc) {
+    if (!doc.brand)
+        return null;
+    return (brandLibraryThemeId(doc.brand) ??
+        resolveBlueprintBrand(doc.brand, { blueprintName: doc.name }).id);
+}
+/** The built brand theme a content blueprint registers, or null (no brand, or a library brand). */
+export function kindBrandTheme(doc) {
+    if (!doc.brand || brandLibraryThemeId(doc.brand))
+        return null;
+    return resolveBlueprintBrand(doc.brand, { blueprintName: doc.name });
+}
+/**
+ * Builds a `definePrototype`-valid definition for a deck, page or doc. Throws
+ * `BrandThemeError` for an unknown library theme or a brand that fails AA,
+ * like the app path.
+ */
+export function defineKindRuntime(doc, options) {
+    const brandTheme = kindBrandTheme(doc);
+    return defineKindPrototype(doc, {
+        ...options,
+        brandTheme,
+        defaultThemeId: brandTheme?.id ?? kindDefaultThemeId(doc),
+    });
+}

package/dist/kinds/deck.d.ts

@@ -0,0 +1,8 @@
+import { type Deck } from '@protoyard/decks/schema';
+import type { z } from 'zod';
+/**
+ * Deck-wide slide and outline references are enforced by the engine schema. The explicit type keeps
+ * the published declarations portable (no inferred reference into another package's zod copy).
+ */
+export declare const DeckBodySchema: z.ZodType<Deck>;
+export type DeckBody = Deck;

package/dist/kinds/deck.js

@@ -0,0 +1,34 @@
+import { DeckSchema } from '@protoyard/decks/schema';
+import { safeParseBlueprint } from "../schema.js";
+import { checkContentLimits, containsEmbeddedApp, DEFAULT_UNTRUSTED_DOCUMENT_LIMITS, } from "./limits.js";
+/**
+ * Deck-wide slide and outline references are enforced by the engine schema. The explicit type keeps
+ * the published declarations portable (no inferred reference into another package's zod copy).
+ */
+export const DeckBodySchema = DeckSchema.superRefine((deck, ctx) => {
+    const checked = checkContentLimits({ deck }, 'deck', DEFAULT_UNTRUSTED_DOCUMENT_LIMITS);
+    if (checked.issue)
+        return;
+    for (const embedded of checked.embeddedApps) {
+        // `DeckBodySchema` is already mounted under the root `deck` property.
+        const bodyPath = embedded.path.slice(1);
+        if (containsEmbeddedApp(embedded.app)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: bodyPath,
+                message: 'An embedded app cannot embed another app (one level only).',
+            });
+            continue;
+        }
+        const parsed = safeParseBlueprint(embedded.app);
+        if (!parsed.success) {
+            for (const issue of parsed.error.issues) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [...bodyPath, ...issue.path],
+                    message: `Embedded app is invalid: ${issue.message}`,
+                });
+            }
+        }
+    }
+});

package/dist/kinds/doc.d.ts

@@ -0,0 +1,19 @@
+import { type DocDocument } from '@protoyard/pages';
+import type { z } from 'zod';
+/** The table of contents covers heading levels 2 to this one when `toc.depth` is unset. */
+export declare const DOC_DEFAULT_TOC_DEPTH = 3;
+/** The level a heading without `level` counts as in a doc's table of contents. */
+export declare const DOC_DEFAULT_HEADING_LEVEL = 2;
+/**
+ * The `kind: "doc"` body (ADR-036, ADR-039): `@protoyard/pages`'
+ * `DocDocumentSchema` (a block flow with unique block ids, plus TOC and print
+ * options) plus the checks that span the whole document:
+ *
+ * - a requested table of contents has at least one heading it would list
+ *   (level 2 up to `toc.depth`, 3 by default), so it is never an empty box;
+ * - every `#fragment` link in a block (`cta`, `cards`) points at a block id,
+ *   usually a heading's, in this document.
+ *
+ * Heading ids are block ids, so their uniqueness comes from the block list.
+ */
+export declare const DocBodySchema: z.ZodType<DocDocument>;

package/dist/kinds/doc.js

@@ -0,0 +1,41 @@
+import { forEachBlock } from '@protoyard/blocks';
+import { DocDocumentSchema } from '@protoyard/pages';
+import { blockIds, checkFragmentLinks, fragmentLinks } from "./anchors.js";
+/** The table of contents covers heading levels 2 to this one when `toc.depth` is unset. */
+export const DOC_DEFAULT_TOC_DEPTH = 3;
+/** The level a heading without `level` counts as in a doc's table of contents. */
+export const DOC_DEFAULT_HEADING_LEVEL = 2;
+/**
+ * The `kind: "doc"` body (ADR-036, ADR-039): `@protoyard/pages`'
+ * `DocDocumentSchema` (a block flow with unique block ids, plus TOC and print
+ * options) plus the checks that span the whole document:
+ *
+ * - a requested table of contents has at least one heading it would list
+ *   (level 2 up to `toc.depth`, 3 by default), so it is never an empty box;
+ * - every `#fragment` link in a block (`cta`, `cards`) points at a block id,
+ *   usually a heading's, in this document.
+ *
+ * Heading ids are block ids, so their uniqueness comes from the block list.
+ */
+export const DocBodySchema = DocDocumentSchema.superRefine((doc, ctx) => {
+    if (doc.toc) {
+        const depth = doc.toc.depth ?? DOC_DEFAULT_TOC_DEPTH;
+        let listed = 0;
+        forEachBlock(doc.blocks, (block) => {
+            if (block.type !== 'heading')
+                return;
+            const level = block.level ?? DOC_DEFAULT_HEADING_LEVEL;
+            if (level >= 2 && level <= depth)
+                listed += 1;
+        });
+        if (listed === 0) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['toc'],
+                message: `The table of contents lists headings of level 2 to ${depth}, and this document has none`,
+            });
+        }
+    }
+    const targets = new Set(blockIds(doc.blocks, ['blocks']).map((entry) => entry.id));
+    checkFragmentLinks(fragmentLinks(doc.blocks, ['blocks']), targets, ctx, 'a block id in this document');
+});

package/dist/kinds/embed/index.d.ts

@@ -0,0 +1,39 @@
+import { type UntrustedBlueprintResult } from '../../untrusted.ts';
+/** Same-origin protocol used by generated level-two hosts and their app frame. */
+export declare const EMBEDDED_APP_PROTOCOL = "protoyard-embedded-app/1";
+export interface EmbeddedAppReady {
+    protocol: typeof EMBEDDED_APP_PROTOCOL;
+    type: 'ready';
+}
+export interface EmbeddedAppStart {
+    protocol: typeof EMBEDDED_APP_PROTOCOL;
+    type: 'start';
+    requestId: string;
+    hostNamespace: string;
+    blockId: string;
+    app: unknown;
+}
+export interface EmbeddedAppLoaded {
+    protocol: typeof EMBEDDED_APP_PROTOCOL;
+    type: 'loaded';
+    requestId: string;
+    namespace: string;
+    name: string;
+}
+export interface EmbeddedAppFailure {
+    protocol: typeof EMBEDDED_APP_PROTOCOL;
+    type: 'error';
+    requestId: string;
+    message: string;
+}
+export type EmbeddedAppMessage = EmbeddedAppReady | EmbeddedAppStart | EmbeddedAppLoaded | EmbeddedAppFailure;
+/** The app-only untrusted loader; nested content kinds and malformed apps fail closed. */
+export declare function loadEmbeddedApp(input: unknown): UntrustedBlueprintResult;
+/** Checks the exact data shapes exchanged between the same-origin host and app frame. */
+export declare function isEmbeddedAppMessage(value: unknown): value is EmbeddedAppMessage;
+/**
+ * Stable isolated storage namespace for one embedded block in one host.
+ * SHA-256 avoids collisions between block ids while keeping the manifest's
+ * lowercase kebab-case namespace contract (48 characters total).
+ */
+export declare function embeddedAppNamespace(hostNamespace: string, blockId: string): Promise<string>;

package/dist/kinds/embed/index.js

@@ -0,0 +1,91 @@
+import { NamespaceSchema } from '@protoyard/core';
+import { loadUntrustedBlueprint } from "../../untrusted.js";
+import { containsEmbeddedApp } from "../limits.js";
+/** Same-origin protocol used by generated level-two hosts and their app frame. */
+export const EMBEDDED_APP_PROTOCOL = 'protoyard-embedded-app/1';
+/** The app-only untrusted loader; nested content kinds and malformed apps fail closed. */
+export function loadEmbeddedApp(input) {
+    const loaded = loadUntrustedBlueprint(input);
+    if (!loaded.success)
+        return loaded;
+    if (containsEmbeddedApp(loaded.blueprint)) {
+        return {
+            success: false,
+            blueprint: null,
+            issues: [
+                {
+                    code: 'too-deep',
+                    path: [],
+                    message: 'An embedded app cannot embed another app (one level only).',
+                    fix: 'Remove the nested embed-app block.',
+                },
+            ],
+        };
+    }
+    return loaded;
+}
+function isPlainRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function hasOnlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+const REQUEST_ID = /^embed-[1-9][0-9]{0,7}$/;
+/** Checks the exact data shapes exchanged between the same-origin host and app frame. */
+export function isEmbeddedAppMessage(value) {
+    if (!isPlainRecord(value) || value.protocol !== EMBEDDED_APP_PROTOCOL)
+        return false;
+    if (value.type === 'ready') {
+        return hasOnlyKeys(value, ['protocol', 'type']);
+    }
+    if (value.type === 'start') {
+        return (hasOnlyKeys(value, ['protocol', 'type', 'requestId', 'hostNamespace', 'blockId', 'app']) &&
+            typeof value.requestId === 'string' &&
+            REQUEST_ID.test(value.requestId) &&
+            typeof value.hostNamespace === 'string' &&
+            NamespaceSchema.safeParse(value.hostNamespace).success &&
+            typeof value.blockId === 'string' &&
+            value.blockId.length > 0 &&
+            value.blockId.length <= 120 &&
+            isPlainRecord(value.app));
+    }
+    if (value.type === 'loaded') {
+        return (hasOnlyKeys(value, ['protocol', 'type', 'requestId', 'namespace', 'name']) &&
+            typeof value.requestId === 'string' &&
+            REQUEST_ID.test(value.requestId) &&
+            typeof value.namespace === 'string' &&
+            NamespaceSchema.safeParse(value.namespace).success &&
+            typeof value.name === 'string');
+    }
+    if (value.type === 'error') {
+        return (hasOnlyKeys(value, ['protocol', 'type', 'requestId', 'message']) &&
+            typeof value.requestId === 'string' &&
+            REQUEST_ID.test(value.requestId) &&
+            typeof value.message === 'string' &&
+            value.message.length <= 500);
+    }
+    return false;
+}
+/**
+ * Stable isolated storage namespace for one embedded block in one host.
+ * SHA-256 avoids collisions between block ids while keeping the manifest's
+ * lowercase kebab-case namespace contract (48 characters total).
+ */
+export async function embeddedAppNamespace(hostNamespace, blockId) {
+    const host = NamespaceSchema.parse(hostNamespace);
+    if (blockId.length === 0 || blockId.length > 120) {
+        throw new Error('An embedded app needs a stable block id of at most 120 characters.');
+    }
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle)
+        throw new Error('This browser cannot create an isolated embedded-app namespace.');
+    const input = new TextEncoder().encode(`protoyard.embed.v1\0${host}\0${blockId}`);
+    const digest = new Uint8Array(await subtle.digest('SHA-256', input));
+    const suffix = [...digest.slice(0, 21)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+    return `embed-${suffix}`;
+}