@texuli/spec 0.3.0 → 0.4.0

package/dist/contract.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The 0.3.0 interaction contract in code (ADR-008): the closed action set,
+ * the closed event vocabulary, the state types, the limits and the name
+ * patterns, mirrored from the schemas (`tests/spec.test.ts` asserts they
+ * stay equal), plus the helpers that turn a catalog property schema into a
+ * dialect schema and build the `$ref` root property schemas resolve against.
+ */
+import type { SpecPropSchema } from './generated/typescript/catalog-schema.js';
+import { type Schema } from './dialect.js';
+/** The binding key that reads local state: `{ "$state": name }`. */
+export declare const STATE_BINDING_KEY = "$state";
+/** The binding key that reads host data (read-only): `{ "$data": name }`. */
+export declare const DATA_BINDING_KEY = "$data";
+/** Every state variable type (`$defs.stateDeclaration.type`). */
+export declare const SPEC_STATE_TYPES: readonly ["boolean", "number", "enum", "string", "list", "workflow"];
+export type SpecStateType = (typeof SPEC_STATE_TYPES)[number];
+/** The closed action set (`$defs.action.op`). Never open to code. */
+export declare const SPEC_ACTION_OPS: readonly ["setState", "toggleState", "moveItem", "flowGo", "emit", "submit"];
+export type SpecActionOp = (typeof SPEC_ACTION_OPS)[number];
+/** The closed event vocabulary (catalog `$defs.eventName`). */
+export declare const SPEC_EVENT_NAMES: readonly ["press", "change", "select", "submit", "dismiss", "move"];
+export type SpecEventName = (typeof SPEC_EVENT_NAMES)[number];
+/** The `$ref` targets a catalog property schema may name. */
+export declare const SPEC_PROP_REFS: readonly ["binding", "reorder", "action", "eventMap", "condition", "workflowGraph"];
+/** The fields each action op takes (besides `op`) and the ones it needs. */
+export declare const ACTION_FIELDS: Readonly<Record<SpecActionOp, {
+    readonly allowed: readonly string[];
+    readonly required: readonly string[];
+}>>;
+/** The fields each state type takes (besides `type`). */
+export declare const STATE_FIELDS: Readonly<Record<SpecStateType, readonly string[]>>;
+/** Every bound of the contract. Strings are counted in UTF-16 units, like the player. */
+export declare const SPEC_LIMITS: Readonly<{
+    stateVars: 64;
+    enumValues: 32;
+    enumValueLength: 64;
+    stringLength: 1000;
+    defaultStringLength: 200;
+    flowViews: 16;
+    flowTransitions: 64;
+    actionsPerEvent: 8;
+    emitValues: 32;
+    emitValueLength: 2048;
+    listItems: 500;
+    /** Fields one list item may carry besides its `id`. */
+    listItemFields: 16;
+    workflowNodes: 500;
+    workflowEdges: 2000;
+    workflowNodeTypes: 64;
+    workflowGroups: 64;
+    workflowPorts: 16;
+    workflowFields: 32;
+    workflowLabelLength: 200;
+    workflowStringLength: 2000;
+    /** Deepest prop value walked for nested bindings. */
+    propDepth: 32;
+}>;
+/** The name patterns, as the schemas write them. */
+export declare const SPEC_PATTERNS: Readonly<{
+    stateName: "^[a-z][A-Za-z0-9_]{0,31}$";
+    dataName: "^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z0-9_]+)*$";
+    flowName: "^[a-z][a-z0-9-]{0,31}$";
+    intentName: "^[A-Za-z][A-Za-z0-9_-]{0,63}$";
+    itemKey: "^[A-Za-z0-9._:-]{1,64}$";
+    groupName: "^[a-z][a-z0-9-]{0,31}$";
+    workflowId: "^[A-Za-z0-9._:-]{1,64}$";
+    workflowFieldName: "^[a-z][A-Za-z0-9_]{0,31}$";
+    /** Multi-line display text (workflow string field values): tab and newline allowed. */
+    workflowText: "^[^\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f\\u202a-\\u202e\\u2066-\\u2069]*$";
+    workflowLabel: "^[^\\u0000-\\u001f\\u007f-\\u009f\\u202a-\\u202e\\u2066-\\u2069]*$";
+    /**
+     * List item text (list state fields): the workflowLabel rule (no C0 or C1
+     * controls, bidirectional overrides or isolates) plus the invisible
+     * formatting characters that hide or reorder text: the Arabic letter mark,
+     * the Mongolian vowel separator, zero-width space, the left-to-right and
+     * right-to-left marks, word joiner and invisible operators, and the byte
+     * order mark. ZWNJ and ZWJ (U+200C, U+200D) stay allowed: scripts such as
+     * Persian and Devanagari, and emoji sequences, need them.
+     */
+    listText: "^[^\\u0000-\\u001f\\u007f-\\u009f\\u061c\\u180e\\u200b\\u200e\\u200f\\u202a-\\u202e\\u2060-\\u2064\\u2066-\\u2069\\ufeff]*$";
+}>;
+/**
+ * The patterns the blueprint validator tests, compiled once; `u` so classes
+ * count code points. The workflow validator compiles its own.
+ */
+export declare const SPEC_REGEX: Readonly<{
+    stateName: RegExp;
+    dataName: RegExp;
+    intentName: RegExp;
+    itemKey: RegExp;
+    listText: RegExp;
+}>;
+/**
+ * A catalog property schema as a dialect schema: the same keywords, with
+ * every object closed unless `additionalProperties` gives a map.
+ */
+export declare function toDialectSchema(schema: SpecPropSchema): Schema;
+/**
+ * Problems with one catalog property schema: it must stay in the dialect,
+ * name only {@link SPEC_PROP_REFS} in `$ref`, and give a `type` wherever it
+ * has no `$ref`. Empty means usable.
+ */
+export declare function checkPropSchema(schema: SpecPropSchema): string[];
+/** Def names both documents declare; the contract root needs them disjoint. */
+export declare function defCollisions(blueprintSchema: Schema, workflowSchema?: Schema): string[];
+/**
+ * The root property schemas resolve `$ref`s against: the blueprint `$defs`,
+ * the workflow `$defs` and a synthetic `workflowGraph` (the workflow root).
+ * Without a workflow schema there is no `workflowGraph`, so a property that
+ * names it fails closed.
+ */
+export declare function contractRoot(blueprintSchema: Schema, workflowSchema?: Schema): Schema;

package/dist/contract.js

@@ -0,0 +1,196 @@
+import { LIST_TEXT_PATTERN } from "./surface.js";
+import { checkSchemaDocument, DIALECT_URI, isRecord } from "./dialect.js";
+/** The binding key that reads local state: `{ "$state": name }`. */
+export const STATE_BINDING_KEY = '$state';
+/** The binding key that reads host data (read-only): `{ "$data": name }`. */
+export const DATA_BINDING_KEY = '$data';
+/** Every state variable type (`$defs.stateDeclaration.type`). */
+export const SPEC_STATE_TYPES = [
+    'boolean',
+    'number',
+    'enum',
+    'string',
+    'list',
+    'workflow',
+];
+/** The closed action set (`$defs.action.op`). Never open to code. */
+export const SPEC_ACTION_OPS = [
+    'setState',
+    'toggleState',
+    'moveItem',
+    'flowGo',
+    'emit',
+    'submit',
+];
+/** The closed event vocabulary (catalog `$defs.eventName`). */
+export const SPEC_EVENT_NAMES = ['press', 'change', 'select', 'submit', 'dismiss', 'move'];
+/** The `$ref` targets a catalog property schema may name. */
+export const SPEC_PROP_REFS = [
+    'binding',
+    'reorder',
+    'action',
+    'eventMap',
+    'condition',
+    'workflowGraph',
+];
+/** The fields each action op takes (besides `op`) and the ones it needs. */
+export const ACTION_FIELDS = Object.freeze({
+    setState: { allowed: ['state', 'value', 'fromEvent'], required: ['state'] },
+    toggleState: { allowed: ['state'], required: ['state'] },
+    moveItem: { allowed: ['from', 'item', 'to', 'index'], required: ['from', 'item'] },
+    flowGo: { allowed: ['event'], required: ['event'] },
+    emit: { allowed: ['intent', 'values'], required: ['intent'] },
+    submit: { allowed: [], required: [] },
+});
+/** The fields each state type takes (besides `type`). */
+export const STATE_FIELDS = Object.freeze({
+    boolean: ['initial', 'source'],
+    number: ['min', 'max', 'initial', 'source'],
+    enum: ['values', 'initial', 'source'],
+    string: ['maxLength', 'initial', 'source'],
+    list: ['maxItems', 'initial'],
+    workflow: ['initial'],
+});
+/** Every bound of the contract. Strings are counted in UTF-16 units, like the player. */
+export const SPEC_LIMITS = Object.freeze({
+    stateVars: 64,
+    enumValues: 32,
+    enumValueLength: 64,
+    stringLength: 1000,
+    defaultStringLength: 200,
+    flowViews: 16,
+    flowTransitions: 64,
+    actionsPerEvent: 8,
+    emitValues: 32,
+    emitValueLength: 2048,
+    listItems: 500,
+    /** Fields one list item may carry besides its `id`. */
+    listItemFields: 16,
+    workflowNodes: 500,
+    workflowEdges: 2000,
+    workflowNodeTypes: 64,
+    workflowGroups: 64,
+    workflowPorts: 16,
+    workflowFields: 32,
+    workflowLabelLength: 200,
+    workflowStringLength: 2000,
+    /** Deepest prop value walked for nested bindings. */
+    propDepth: 32,
+});
+/** The name patterns, as the schemas write them. */
+export const SPEC_PATTERNS = Object.freeze({
+    stateName: '^[a-z][A-Za-z0-9_]{0,31}$',
+    dataName: '^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z0-9_]+)*$',
+    flowName: '^[a-z][a-z0-9-]{0,31}$',
+    intentName: '^[A-Za-z][A-Za-z0-9_-]{0,63}$',
+    itemKey: '^[A-Za-z0-9._:-]{1,64}$',
+    groupName: '^[a-z][a-z0-9-]{0,31}$',
+    workflowId: '^[A-Za-z0-9._:-]{1,64}$',
+    workflowFieldName: '^[a-z][A-Za-z0-9_]{0,31}$',
+    /** Multi-line display text (workflow string field values): tab and newline allowed. */
+    workflowText: '^[^\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f\\u202a-\\u202e\\u2066-\\u2069]*$',
+    workflowLabel: '^[^\\u0000-\\u001f\\u007f-\\u009f\\u202a-\\u202e\\u2066-\\u2069]*$',
+    /**
+     * List item text (list state fields): the workflowLabel rule (no C0 or C1
+     * controls, bidirectional overrides or isolates) plus the invisible
+     * formatting characters that hide or reorder text: the Arabic letter mark,
+     * the Mongolian vowel separator, zero-width space, the left-to-right and
+     * right-to-left marks, word joiner and invisible operators, and the byte
+     * order mark. ZWNJ and ZWJ (U+200C, U+200D) stay allowed: scripts such as
+     * Persian and Devanagari, and emoji sequences, need them.
+     */
+    listText: LIST_TEXT_PATTERN,
+});
+/**
+ * The patterns the blueprint validator tests, compiled once; `u` so classes
+ * count code points. The workflow validator compiles its own.
+ */
+export const SPEC_REGEX = Object.freeze({
+    stateName: new RegExp(SPEC_PATTERNS.stateName, 'u'),
+    dataName: new RegExp(SPEC_PATTERNS.dataName, 'u'),
+    intentName: new RegExp(SPEC_PATTERNS.intentName, 'u'),
+    itemKey: new RegExp(SPEC_PATTERNS.itemKey, 'u'),
+    listText: new RegExp(SPEC_PATTERNS.listText, 'u'),
+});
+/**
+ * A catalog property schema as a dialect schema: the same keywords, with
+ * every object closed unless `additionalProperties` gives a map.
+ */
+export function toDialectSchema(schema) {
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'properties' && isRecord(value)) {
+            out.properties = Object.fromEntries(Object.entries(value).map(([name, child]) => [
+                name,
+                toDialectSchema(child),
+            ]));
+        }
+        else if ((key === 'items' || key === 'additionalProperties') && isRecord(value)) {
+            out[key] = toDialectSchema(value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    if (out.type === 'object' && out.additionalProperties === undefined) {
+        out.additionalProperties = false;
+    }
+    return out;
+}
+/**
+ * Problems with one catalog property schema: it must stay in the dialect,
+ * name only {@link SPEC_PROP_REFS} in `$ref`, and give a `type` wherever it
+ * has no `$ref`. Empty means usable.
+ */
+export function checkPropSchema(schema) {
+    const issues = [];
+    const dialect = { $schema: DIALECT_URI, ...toDialectSchema(schema) };
+    for (const issue of checkSchemaDocument(dialect)) {
+        if (issue.code !== 'bad-ref')
+            issues.push(`${issue.path} ${issue.code}`);
+    }
+    const visit = (node, path) => {
+        if (node.$ref !== undefined) {
+            const name = /^#\/\$defs\/([A-Za-z]+)$/.exec(node.$ref)?.[1];
+            if (name === undefined || !SPEC_PROP_REFS.includes(name)) {
+                issues.push(`${path}.$ref names no contract $defs entry`);
+            }
+            if (Object.keys(node).some((key) => key !== '$ref' && key !== 'description')) {
+                issues.push(`${path} mixes $ref with other keywords`);
+            }
+            return;
+        }
+        if (node.type === undefined)
+            issues.push(`${path} needs a type`);
+        for (const [name, child] of Object.entries(node.properties ?? {})) {
+            visit(child, `${path}.properties.${name}`);
+        }
+        if (node.items)
+            visit(node.items, `${path}.items`);
+        if (node.additionalProperties)
+            visit(node.additionalProperties, `${path}.additionalProperties`);
+    };
+    visit(schema, '$');
+    return issues;
+}
+/** Def names both documents declare; the contract root needs them disjoint. */
+export function defCollisions(blueprintSchema, workflowSchema) {
+    const own = Object.keys(blueprintSchema.$defs ?? {});
+    const other = new Set([...Object.keys(workflowSchema?.$defs ?? {}), 'workflowGraph']);
+    return own.filter((name) => other.has(name));
+}
+/**
+ * The root property schemas resolve `$ref`s against: the blueprint `$defs`,
+ * the workflow `$defs` and a synthetic `workflowGraph` (the workflow root).
+ * Without a workflow schema there is no `workflowGraph`, so a property that
+ * names it fails closed.
+ */
+export function contractRoot(blueprintSchema, workflowSchema) {
+    const defs = { ...(blueprintSchema.$defs ?? {}) };
+    if (workflowSchema) {
+        Object.assign(defs, workflowSchema.$defs ?? {});
+        const { $schema: _s, $id: _i, $defs: _d, title: _t, ...graph } = workflowSchema;
+        defs.workflowGraph = graph;
+    }
+    return { $defs: defs };
+}

package/dist/dialect.d.ts

@@ -48,9 +48,18 @@ export declare function refName(ref: string): string | undefined;
  * (`additionalProperties: false`) or an explicit map. Fails closed.
  */
 export declare function checkSchemaDocument(document: unknown): SchemaIssue[];
+/**
+ * Optional callbacks for {@link validateInstance}. `value` runs at every
+ * schema node a value meets (after `$ref` resolution, so a caller can match
+ * a `$defs` entry by identity). Returning `undefined` lets the dialect check
+ * the value as usual; returning issues (possibly none) replaces that check.
+ */
+export interface DialectHooks {
+    value?(node: Schema, value: unknown, path: string): readonly SchemaIssue[] | undefined;
+}
 /**
  * Validate a JSON value against a dialect schema. `root` resolves `$ref`s
  * (defaults to `schema`). Returns every issue, with JSON paths from `$`.
  */
-export declare function validateInstance(schema: Schema, value: unknown, root?: Schema): SchemaIssue[];
+export declare function validateInstance(schema: Schema, value: unknown, root?: Schema, hooks?: DialectHooks): SchemaIssue[];
 export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/dialect.js

@@ -153,7 +153,7 @@ export function checkSchemaDocument(document) {
  * Validate a JSON value against a dialect schema. `root` resolves `$ref`s
  * (defaults to `schema`). Returns every issue, with JSON paths from `$`.
  */
-export function validateInstance(schema, value, root = schema) {
+export function validateInstance(schema, value, root = schema, hooks = {}) {
     const issues = [];
     const fail = (code, path, message) => {
         issues.push({ code, path, message });
@@ -172,6 +172,11 @@ export function validateInstance(schema, value, root = schema) {
                 visit(target, current, path, depth + 1);
             return;
         }
+        const handled = hooks.value?.(node, current, path);
+        if (handled !== undefined) {
+            issues.push(...handled);
+            return;
+        }
         if (node.const !== undefined && current !== node.const) {
             fail('const', path, `Must be ${JSON.stringify(node.const)}.`);
             return;

package/dist/generated/typescript/blueprint.d.ts

@@ -47,7 +47,7 @@ export interface BlueprintEditOp {
     tree?: BlueprintNode;
 }
 export type BlueprintNodePath = readonly number[];
-/** One catalog node: id, props, children, and an optional named slot and condition. */
+/** One catalog node: id, props, children (each with an optional named slot), when, bind and on. */
 export interface BlueprintNode {
     /** A catalog component id. */
     id: string;
@@ -60,6 +60,9 @@ export interface BlueprintNode {
      */
     slot?: string;
     when?: BlueprintCondition;
+    /** Two-way bindings: a prop the component lists as bindable → a $state binding it writes back. */
+    bind?: Readonly<Record<string, BlueprintBinding>>;
+    on?: BlueprintEventMap;
 }
 /**
  * Shows the node when true (audit G07): the closed Condition AST of the blocks formula grammar.
@@ -97,11 +100,96 @@ export interface BlueprintNumberFormula {
     ifTrue?: BlueprintNumberFormula;
     ifFalse?: BlueprintNumberFormula;
 }
+/** A local state variable name. */
+export type BlueprintStateName = string;
+/** A host data source name, such as tickets.open. */
+export type BlueprintDataName = string;
+/** A flow view or event name. */
+export type BlueprintFlowName = string;
+/** A host intent (action) name. */
+export type BlueprintIntentName = string;
+/** The id of one item in a list variable. */
+export type BlueprintItemKey = string;
+/** A reorder group name. */
+export type BlueprintGroupName = string;
 /**
- * Envelope version 1 around one catalog tree (ADR-003, audit G13). Mirrors what
- * @texuli/catalog/envelope reads today; a declared status, activation or tier is display data,
- * never authority. Planned minor additions: a spec version range, the native profile and several
- * roots.
+ * Reads one value: {"$state": name} (local state) or {"$data": name} (host data, read-only).
+ * Exactly one key; checked by the validator.
+ */
+export interface BlueprintBinding {
+    $state?: BlueprintStateName;
+    $data?: BlueprintDataName;
+}
+/**
+ * One typed, bounded variable (mirrors @texuli/player parseStateDeclarations; list and workflow are
+ * new). Per-type fields and initial values are checked by the validator.
+ */
+export interface BlueprintStateDeclaration {
+    type: 'boolean' | 'number' | 'enum' | 'string' | 'list' | 'workflow';
+    /** A value of the declared type. */
+    initial?: unknown;
+    min?: number;
+    max?: number;
+    values?: readonly string[];
+    maxLength?: number;
+    maxItems?: number;
+    source?: BlueprintDataName;
+}
+/** Named views and a closed transition table (mirrors @texuli/player parseFlowDeclaration). */
+export interface BlueprintFlow {
+    views: readonly BlueprintFlowName[];
+    initial?: BlueprintFlowName;
+    transitions: readonly BlueprintFlowTransition[];
+}
+/**
+ * One transition: from a view (or * for any view) to a view on an event, with an optional guard.
+ */
+export interface BlueprintFlowTransition {
+    from: string;
+    to: BlueprintFlowName;
+    on: BlueprintFlowName;
+    when?: BlueprintCondition;
+}
+/**
+ * One closed action. Per-op fields are checked by the validator (setState: state + value|fromEvent;
+ * toggleState: state; moveItem: from, item, to?, index?; flowGo: event; emit: intent, values?;
+ * submit: none).
+ */
+export interface BlueprintAction {
+    op: 'setState' | 'toggleState' | 'moveItem' | 'flowGo' | 'emit' | 'submit';
+    state?: BlueprintStateName;
+    /** setState: a JSON literal of the variable's type. */
+    value?: unknown;
+    fromEvent?: 'value';
+    from?: BlueprintStateName;
+    to?: BlueprintStateName;
+    item?: BlueprintItemKey;
+    index?: number;
+    event?: BlueprintFlowName;
+    intent?: BlueprintIntentName;
+    /** emit: name → scalar or $state binding, at most 32. */
+    values?: Readonly<Record<string, unknown>>;
+}
+/** Event → actions run in order. Keys must be events the component declares (catalog events). */
+export type BlueprintEventMap = Readonly<Record<string, readonly BlueprintAction[]>>;
+/**
+ * Drag as data: the container's items are the bound list; a drop or keyboard move runs the closed
+ * moveItem reducer. Containers sharing a group exchange items when accepts allows.
+ */
+export interface BlueprintReorder {
+    bind: BlueprintBinding;
+    axis?: 'vertical' | 'horizontal' | 'grid';
+    group?: BlueprintGroupName;
+    accepts?: readonly BlueprintGroupName[];
+    locked?: readonly BlueprintItemKey[];
+    pull?: 'move' | 'clone' | 'none';
+    disabled?: boolean;
+}
+/**
+ * Envelope version 1 around one catalog tree (ADR-004, audit G13). Mirrors what
+ * @texuli/catalog/envelope reads; a declared status, activation or tier is display data, never
+ * authority. Spec 0.4.0 (ADR-008 + PLAN_008 deck encoding) adds an optional spec version, local
+ * state and a flow. Planned minor additions: the native profile and several roots.
  */
 export interface BlueprintEnvelope {
     format: 'texuli-blueprint';
@@ -122,4 +210,14 @@ export interface BlueprintEnvelope {
     activatedBy?: BlueprintActivation;
     provenance?: readonly BlueprintProvenanceEntry[];
     tree: BlueprintNode;
+    /**
+     * The spec version the envelope was written for. Omitted means 0.2.0; migrateBlueprint stamps it.
+     */
+    spec?: '0.3.0' | '0.4.0';
+    /**
+     * Local state declarations (ADR-008), at most 64. Names, counts and per-type rules are checked by
+     * the validator.
+     */
+    state?: Readonly<Record<string, BlueprintStateDeclaration>>;
+    flow?: BlueprintFlow;
 }

package/dist/generated/typescript/blueprint.js

@@ -1,3 +1,3 @@
 // Generated by @texuli/spec from schemas/blueprint.schema.json. Do not edit: run the spec generator.
-// Spec 0.2.0, digest d9eccaba1826e7d87648a4a33787d873245592dda843607a10b2c68a77f1806f
+// Spec 0.4.0, digest fac29f542b16ddb78ab401c508e5b8346f655991c56e25aa811f4931661a8cb3
 export {};

package/dist/generated/typescript/catalog-schema.d.ts

@@ -10,6 +10,11 @@ export interface SpecComponent {
     /** ADR-003 portability. unknown until audited. */
     capability: 'portable-core' | 'web-only' | 'native-only' | 'unknown';
     props: readonly SpecProp[];
+    /** The closed events the component fires; a node's on keys must be listed here. */
+    events?: readonly SpecEventName[];
+    /** Props a node may two-way bind (node bind). */
+    bindable?: readonly string[];
+    deprecated?: SpecDeprecation;
 }
 export interface SpecProp {
     name: string;
@@ -21,6 +26,36 @@ export interface SpecProp {
      * unknown kinds).
      */
     extension?: 'web';
+    schema?: SpecPropSchema;
+    deprecated?: SpecDeprecation;
+}
+/** The closed event vocabulary. */
+export type SpecEventName = 'press' | 'change' | 'select' | 'submit' | 'dismiss' | 'move';
+/** Deprecated since a spec version; warns for one minor before removal. */
+export interface SpecDeprecation {
+    since: string;
+    replacement?: string;
+}
+/**
+ * A dialect subset an array or object prop's value must match. Objects are closed unless
+ * additionalProperties gives a map. No pattern (cross-target regex parity). $ref names one of
+ * binding, reorder, action, eventMap, condition (blueprint $defs) or workflowGraph.
+ */
+export interface SpecPropSchema {
+    type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean';
+    description?: string;
+    properties?: Readonly<Record<string, SpecPropSchema>>;
+    required?: readonly string[];
+    additionalProperties?: SpecPropSchema;
+    items?: SpecPropSchema;
+    enum?: readonly string[];
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    $ref?: string;
 }
 /**
  * The platform-neutral catalog vocabulary, bootstrapped from the built catalog. Placement, emission

package/dist/generated/typescript/catalog-schema.js

@@ -1,3 +1,3 @@
 // Generated by @texuli/spec from schemas/catalog.schema.json. Do not edit: run the spec generator.
-// Spec 0.2.0, digest d9eccaba1826e7d87648a4a33787d873245592dda843607a10b2c68a77f1806f
+// Spec 0.4.0, digest fac29f542b16ddb78ab401c508e5b8346f655991c56e25aa811f4931661a8cb3
 export {};

package/dist/generated/typescript/diagnostics.d.ts

@@ -4,9 +4,18 @@ export interface SpecDiagnostic {
     message: string;
     id?: string;
 }
-export type SpecDiagnosticCode = 'schema' | 'unknown-id' | 'unknown-prop' | 'prop-type' | 'enum-value' | 'missing-required' | 'extension-prop' | 'catalog-mismatch' | 'unsupported-profile' | 'unknown-slot';
+export type SpecDiagnosticCode = 'schema' | 'unknown-id' | 'unknown-prop' | 'prop-type' | 'enum-value' | 'missing-required' | 'extension-prop' | 'catalog-mismatch' | 'unsupported-profile' | 'unknown-slot' | 'state' | 'unknown-state' | 'binding' | 'action' | 'unknown-event' | 'workflow';
+export interface SpecWarning {
+    code: SpecWarningCode;
+    path: string;
+    message: string;
+    id?: string;
+}
+export type SpecWarningCode = 'deprecated';
 /** The stable result shape of validating a blueprint against the spec. */
 export interface SpecValidation {
     ok: boolean;
     diagnostics: readonly SpecDiagnostic[];
+    /** Advisory findings; ok still means no diagnostics. */
+    warnings?: readonly SpecWarning[];
 }

package/dist/generated/typescript/diagnostics.js

@@ -1,3 +1,3 @@
 // Generated by @texuli/spec from schemas/diagnostics.schema.json. Do not edit: run the spec generator.
-// Spec 0.2.0, digest d9eccaba1826e7d87648a4a33787d873245592dda843607a10b2c68a77f1806f
+// Spec 0.4.0, digest fac29f542b16ddb78ab401c508e5b8346f655991c56e25aa811f4931661a8cb3
 export {};

package/dist/generated/typescript/manifest.js

@@ -1,3 +1,3 @@
 // Generated by @texuli/spec from schemas/manifest.schema.json. Do not edit: run the spec generator.
-// Spec 0.2.0, digest d9eccaba1826e7d87648a4a33787d873245592dda843607a10b2c68a77f1806f
+// Spec 0.4.0, digest fac29f542b16ddb78ab401c508e5b8346f655991c56e25aa811f4931661a8cb3
 export {};