@ggui-ai/protocol 0.9.0 → 0.10.0

package/dist/validation/contract-validator.js

@@ -1,5 +1,5 @@
 import { deriveContextDefault } from '../types/data-contract.js';
-import { compileForValidation, compileValidatorModule, mapAjvErrorsToViolations, prefixViolations, } from './ajv-runtime.js';
+import { compileForValidation, compileValidatorFunctionExpr, compileValidatorModule, mapAjvErrorsToViolations, prefixViolations, } from './ajv-runtime.js';
 import { checkCrossReferences } from './cross-references.js';
 import { checkNameInvariants } from './name-invariants.js';
 import { isRecord } from './is-record.js';
@@ -32,6 +32,28 @@ export function buildPropsWrapperSchema(spec) {
             .map(([name]) => name),
     };
 }
+/**
+ * Validate runtime props against an EXPLICIT enforced schema — the
+ * persisted-schema render path of the schema-precise render contract
+ * (docs/plans/2026-08-19-schema-precise-render.md P1). The paired
+ * `ggui_handshake` persists the exact `buildEnforcedPropsSchema`
+ * artifact it returned on the wire; `ggui_render` validates against
+ * that PERSISTED schema rather than recomputing from the propsSpec,
+ * so the returned and enforced schemas cannot diverge under
+ * rolling-deploy version skew (the AUTHORITY obligation is structural,
+ * not best-effort). Closed-shape injection at compile is idempotent —
+ * a pre-injected enforced schema round-trips unchanged.
+ */
+export function validatePropsDataWithSchema(props, schema) {
+    const validate = compileForValidation(schema);
+    const ok = validate(props);
+    if (ok)
+        return { valid: true, violations: [] };
+    return {
+        valid: false,
+        violations: mapAjvErrorsToViolations(validate.errors, props),
+    };
+}
 /**
  * Validate runtime props data against a PropsSpec contract.
  *
@@ -353,30 +375,80 @@ export function compileContractValidators(specs) {
     return Object.keys(out).length > 0 ? out : undefined;
 }
 /**
- * Wrap a {@link CompiledContractValidators} object as the source text of
- * an ES module whose `default` export is the same object. This is the
- * wire format served from the content-addressable contract route
- * (`GET /contract/<hash>.js`) in #109's decomposition slice — one URL,
- * one fetch, one dynamic-import per unique contract.
- *
- * Why a wrapping module rather than emitting the validator-modules
- * raw: each inner validator-module is independently `export default ...`,
- * so they can't share a single file without name collisions. The
- * iframe-runtime's existing `loadCompiledValidators` already knows how
- * to take a `CompiledContractValidators` and load each inner module via
- * `blob:` import; this wrapper just hands it the same shape it expects,
- * sourced from one HTTP round-trip instead of inline.
- *
- * `JSON.stringify` is deterministic on objects with string keys in V8
- * + Node — the producer's iteration order is preserved, so a given
- * contract always serializes to identical bytes. {@link computeContractBundle}
- * leans on that determinism so the resulting hash is stable across
- * renders of the same contract.
+ * Compile a contract's runtime-validated sub-schemas into
+ * expression-form validators ({@link ContractValidatorExprs}) — the
+ * same four surfaces, guards, and closed-shape semantics as
+ * {@link compileContractValidators}, differing only in emission form.
+ * Returns `undefined` when the contract declares no runtime-validated
+ * schema at all.
+ */
+export function compileContractValidatorExprs(specs) {
+    const compilePerEntry = (spec) => {
+        if (!spec)
+            return undefined;
+        const collected = {};
+        for (const [name, entry] of Object.entries(spec)) {
+            if (entry && entry.schema) {
+                collected[name] = compileValidatorFunctionExpr(entry.schema);
+            }
+        }
+        return Object.keys(collected).length > 0 ? collected : undefined;
+    };
+    const out = {};
+    if (specs.propsSpec &&
+        specs.propsSpec.properties &&
+        Object.keys(specs.propsSpec.properties).length > 0) {
+        out.props = compileValidatorFunctionExpr(buildPropsWrapperSchema(specs.propsSpec));
+    }
+    const actions = compilePerEntry(specs.actionSpec);
+    if (actions)
+        out.actions = actions;
+    const streams = compilePerEntry(specs.streamSpec);
+    if (streams)
+        out.streams = streams;
+    const context = compilePerEntry(specs.contextSpec);
+    if (context)
+        out.context = context;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * Wrap {@link ContractValidatorExprs} as the source text of ONE plain
+ * ES module whose `default` export carries the validate FUNCTIONS
+ * themselves — the v2 wire format of the content-addressable contract
+ * route (`GET /contract/<hash>.js`), ggui#522 slice 2.
+ *
+ * The v1 format exported the validator-module SOURCES as strings, so
+ * the iframe still needed one `blob:` dynamic import per validator —
+ * exactly the scheme-source grant a strict host CSP refuses, which
+ * made client-side validation silently fail open on such hosts. Here
+ * the expressions concatenate at BUILD time into ordinary code: the
+ * frame does one `import(validatorsUrl)` (a plain https module load,
+ * governed by `script-src` origins alone) and receives functions. No
+ * `blob:`, no `data:`, no eval anywhere.
+ *
+ * Key emission order follows the producer's iteration order, which is
+ * deterministic in V8/Node for string keys — {@link computeContractBundle}
+ * hashes the INPUT specs anyway, so byte-level determinism of this
+ * source is a courtesy, not a correctness requirement.
  *
  * @public
  */
-export function bundleCompiledValidatorsAsModule(compiled) {
-    return `export default ${JSON.stringify(compiled)};\n`;
+export function bundleValidatorExprsAsExecutableModule(exprs) {
+    const lines = ['"use strict";', 'const v = {};'];
+    if (exprs.props !== undefined) {
+        lines.push(`v.props = ${exprs.props};`);
+    }
+    for (const group of ['actions', 'streams', 'context']) {
+        const entries = exprs[group];
+        if (entries === undefined)
+            continue;
+        lines.push(`v.${group} = {};`);
+        for (const [name, expr] of Object.entries(entries)) {
+            lines.push(`v.${group}[${JSON.stringify(name)}] = ${expr};`);
+        }
+    }
+    lines.push('export default v;');
+    return `${lines.join('\n')}\n`;
 }
 /**
  * Recursive canonical-JSON serializer with object keys sorted
@@ -410,21 +482,35 @@ function canonicalJsonStringify(value) {
     return 'null';
 }
 /**
- * Convenience over {@link compileContractValidators} +
- * {@link bundleCompiledValidatorsAsModule} + sha256 — produces the
- * `{contractHash, bundleSource, validators}` triple the emitter (render.ts
- * / update.ts in #109 C4) writes to the content-addressable store and
- * emits as `_meta["ai.ggui/contract"] = {contractHash, validatorsUrl}`.
- *
- * `contractHash` is `sha256(canonicalJsonStringify(specs))` (hex). Hashing
- * the INPUT specs — not the compiled output — guarantees a stable hash
- * across server processes and Ajv version bumps: the same contract
- * definition always lands at the same URL. Compiled output bytes may
- * differ across calls (Ajv's standalone emitter uses incrementing
- * counter names like `validate10`/`validate11`), but the CodeStore is
- * idempotent (first write wins) and the URL response carries
- * `Cache-Control: immutable`, so browsers + CDNs lock in the
- * first-served bytes and never observe a counter-name reshuffle.
+ * Version salt for {@link computeContractBundle}'s hash. The bundle's
+ * URL + store key are `Cache-Control: immutable` and the CodeStore is
+ * first-write-wins, so a FORMAT change under an unchanged key would be
+ * invisible to every cache in the chain — the salt moves the whole
+ * family to fresh keys instead. `v2` = the executable-module format
+ * ({@link bundleValidatorExprsAsExecutableModule}); v1 (unsalted) was
+ * the string-carrying format whose per-validator `blob:` loads a
+ * strict CSP refuses.
+ */
+const CONTRACT_BUNDLE_HASH_SALT = 'ggui-validators-v2\n';
+/**
+ * Convenience over {@link compileContractValidatorExprs} +
+ * {@link bundleValidatorExprsAsExecutableModule} + sha256 — produces
+ * the `{contractHash, bundleSource, validators}` triple the emitter
+ * (render.ts / the resource read / the /state route) writes to the
+ * content-addressable store and emits as
+ * `{contractHash, validatorsUrl}` on the render slice.
+ *
+ * `contractHash` is `sha256(salt + canonicalJsonStringify(specs))`
+ * (hex). Hashing the INPUT specs — not the compiled output —
+ * guarantees a stable hash across server processes and Ajv version
+ * bumps: the same contract definition always lands at the same URL.
+ * Compiled output bytes may differ across calls (Ajv's standalone
+ * emitter uses incrementing counter names like `validate10`/
+ * `validate11`), but the CodeStore is idempotent (first write wins)
+ * and the URL response carries `Cache-Control: immutable`, so browsers
+ * + CDNs lock in the first-served bytes and never observe a
+ * counter-name reshuffle. The salt exists precisely because of that
+ * immutability — see {@link CONTRACT_BUNDLE_HASH_SALT}.
  *
  * Returns `undefined` when the contract declares no runtime-validated
  * schema at all (matches {@link compileContractValidators}'s posture).
@@ -432,16 +518,16 @@ function canonicalJsonStringify(value) {
  * @public
  */
 export async function computeContractBundle(specs) {
-    const validators = compileContractValidators(specs);
+    const validators = compileContractValidatorExprs(specs);
     if (validators === undefined)
         return undefined;
-    const bundleSource = bundleCompiledValidatorsAsModule(validators);
+    const bundleSource = bundleValidatorExprsAsExecutableModule(validators);
     // Web Crypto's subtle.digest is universal (Node 19+, all modern
     // browsers, Workers). The protocol package ships into iframe-runtime
     // bundles too — `node:crypto` would force esbuild to mark a Node
     // builtin unresolved at browser bundle time even though this
     // function is server-only at call time.
-    const bytes = new TextEncoder().encode(canonicalJsonStringify(specs));
+    const bytes = new TextEncoder().encode(`${CONTRACT_BUNDLE_HASH_SALT}${canonicalJsonStringify(specs)}`);
     const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
     const contractHash = Array.from(new Uint8Array(digest))
         .map((b) => b.toString(16).padStart(2, '0'))
@@ -729,7 +815,12 @@ function validateSchemaStructure(schema, path, violations) {
         });
         return;
     }
-    if (schema.type === 'array' && !schema.items) {
+    // `type` may be a draft-07 type ARRAY (`['array','null']`) since
+    // draft-2026-08-19 — read it as a SET so the structural rules below
+    // apply to nullable array/object schemas too (a single-string
+    // comparison silently skipped them).
+    const typeSet = new Set(Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : []);
+    if (typeSet.has('array') && !schema.items) {
         violations.push({
             field: path,
             message: `Array schema at '${path}' has no items — cannot validate array elements`,
@@ -737,7 +828,7 @@ function validateSchemaStructure(schema, path, violations) {
             received: 'undefined',
         });
     }
-    if (schema.type === 'object' && schema.required?.length) {
+    if (typeSet.has('object') && schema.required?.length) {
         const definedProps = Object.keys(schema.properties ?? {});
         for (const req of schema.required) {
             if (!definedProps.includes(req)) {
@@ -789,6 +880,19 @@ export class ContractViolationError extends Error {
     violations;
     tool;
     hint;
+    /**
+     * sha256 (lowercase hex) of the RFC 8785 canonical bytes of the
+     * ENFORCED props schema this violation was validated against —
+     * present when the enforcing site holds one (the handshake-persisted
+     * schema on the render path). The breach classifier of the
+     * schema-precise render contract: a caller holding the handshake's
+     * `propsSchemaHash` compares it to this value — mismatch means the
+     * server enforced a different schema than it returned (server
+     * breach); match means the props themselves were at fault. Absent on
+     * violations produced without an enforced-schema identity (synthetic
+     * violations, stream/context/action validation).
+     */
+    propsSchemaHash;
     constructor(opts) {
         const formattedViolations = formatViolations(opts.violations);
         super(`Contract violation in ${opts.tool}:\n${formattedViolations}`);
@@ -796,6 +900,9 @@ export class ContractViolationError extends Error {
         this.violations = opts.violations;
         this.tool = opts.tool;
         this.hint = opts.hint ?? defaultHintFor(opts.tool);
+        if (opts.propsSchemaHash !== undefined) {
+            this.propsSchemaHash = opts.propsSchemaHash;
+        }
     }
     /** Structured payload for MCP error response `data` field. */
     toErrorData() {
@@ -804,6 +911,9 @@ export class ContractViolationError extends Error {
             tool: this.tool,
             violations: this.violations,
             hint: this.hint,
+            ...(this.propsSchemaHash !== undefined
+                ? { propsSchemaHash: this.propsSchemaHash }
+                : {}),
         };
     }
 }

package/dist/validation/enforced-props-schema.d.ts

@@ -0,0 +1,56 @@
+import type { JsonSchema, PropsSpec } from '../types/data-contract.js';
+/** Frozen wire values for the handshake's `propsSchemaProfile` field. */
+export type PropsSchemaProfile = 'grammar-safe' | 'full';
+/**
+ * The grammar-safe core — the closed keyword set a `'grammar-safe'`
+ * schema may use (P3 pin 4; purely syntactic). `aliases` is enumerated
+ * now (it is the P4 in-contract alias keyword) so arming P4 needs no
+ * grammar change; until P4 ships it simply never appears in emitted
+ * bytes.
+ */
+export declare const GRAMMAR_SAFE_KEYWORDS: ReadonlySet<string>;
+/**
+ * The restricted `format` vocabulary admitted to the grammar-safe core
+ * (P3 pin 5). A consumer grammar MAY enforce any subset its engine
+ * supports; unenforced formats remain server-validated — AUTHORITY is
+ * one-directional, so an under-enforcing grammar is safe. A schema
+ * carrying a format outside this list classifies `'full'`.
+ */
+export declare const GRAMMAR_SAFE_FORMATS: ReadonlySet<string>;
+/**
+ * RFC 8785 (JCS) serialization of a props schema — the canonical
+ * bytes `propsSchemaHash` is computed over, and the byte form the
+ * emitted `propsSchema` value is constructed to match. Consumers
+ * verify by re-canonicalizing the received value with any JCS
+ * library and hashing — raw received bytes are equivalent whenever
+ * the transport preserves key order (JS enumeration reorders
+ * integer-like property names, so re-canonicalization is the
+ * guaranteed path).
+ */
+export declare function canonicalPropsSchemaBytes(schema: JsonSchema): string;
+/**
+ * Build the enforced props schema for a {@link PropsSpec} — the exact
+ * schema `ggui_render` compiles and validates against for the paired
+ * handshake, in emission form (closed shape materialized, `nullable`
+ * rewritten, metadata keywords stripped, canonical key order).
+ *
+ * An empty / degenerate spec yields the empty closed wrapper
+ * `{additionalProperties:false, properties:{}, required:[], type:'object'}`
+ * — never omitted for a non-declined handshake: under it, any
+ * non-empty props are invalid, which makes the props-without-propsSpec
+ * rejection schema-derivable and the accept-path drop documented
+ * leniency (one-directional AUTHORITY).
+ *
+ * `injectClosedShape` is idempotent, so compiling this pre-injected
+ * tree (`compileForValidation`) enforces byte-identical semantics to
+ * `validatePropsData` over the source spec — the AUTHORITY property
+ * the conformance kit's drift fixture pins.
+ */
+export declare function buildEnforcedPropsSchema(spec: PropsSpec): JsonSchema;
+/**
+ * Classify an (emission-form) props schema against the grammar-safe
+ * core — P3 pins 4+5. Purely syntactic; the conformance kit's profile
+ * fixture asserts the wire flag agrees with this reference checker.
+ */
+export declare function classifyPropsSchemaProfile(schema: JsonSchema): PropsSchemaProfile;
+//# sourceMappingURL=enforced-props-schema.d.ts.map

package/dist/validation/enforced-props-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforced-props-schema.d.ts","sourceRoot":"","sources":["../../src/validation/enforced-props-schema.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAIvE,yEAAyE;AACzE,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,MAAM,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAcpD,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAWnD,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEpE;AAuED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAIpE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,GACjB,kBAAkB,CAiCpB"}

package/dist/validation/enforced-props-schema.js

@@ -0,0 +1,232 @@
+/**
+ * ENFORCED PROPS SCHEMA — the wire artifact of the schema-precise
+ * render arc (P1, docs/plans/2026-08-19-schema-precise-render.md;
+ * shape frozen 2026-08-19 per the P3 consumer review, guuey#271).
+ *
+ * `buildEnforcedPropsSchema(propsSpec)` produces the EXACT JSON Schema
+ * the paired `ggui_render` enforces for a handshake — the same
+ * synthesis (`buildPropsWrapperSchema`) and the same closed-shape
+ * injection (`injectClosedShape`) the render-time validator compiles,
+ * with the emission normalizations applied IN the bytes:
+ *
+ *   - `additionalProperties: false` materialized at every object node
+ *     (render injects it at Ajv compile; the wire artifact carries it
+ *     explicitly so a consumer reading the schema sees the enforced
+ *     closed shape, not a pre-injection approximation).
+ *   - `nullable: true` rewritten to the canonical `type: [X, 'null']`
+ *     union (the validating engine type-widens on `nullable`; a strict
+ *     reader of the emitted schema must see the same acceptance).
+ *   - Metadata keywords that are no-ops at the emission layer
+ *     (`example`, `nullable`) stripped — they are non-standard at this
+ *     layer and can fail a strict downstream compiler.
+ *   - Constructed in canonical key order (sorted at every schema
+ *     node), so the serialized value is byte-stable across authors'
+ *     key ordering and across handshakes of the same contract —
+ *     load-bearing for consumer compile caches keyed on the bytes.
+ *
+ * Canonical bytes are RFC 8785 (JCS) — the SAME standard the
+ * `contractHash` pipeline pins (`registry/canonicalize-contract.ts`),
+ * so an external implementation reproduces them with any JCS library.
+ * The hash over those bytes lives server-side at
+ * `@ggui-ai/protocol/props-schema-hash` (node:crypto — the
+ * `blueprint-key` subpath convention).
+ *
+ * `classifyPropsSchemaProfile` implements the frozen profile rule
+ * (pins 4+5): purely SYNTACTIC membership — a schema is
+ * `'grammar-safe'` iff every keyword appearing at any schema node is
+ * in {@link GRAMMAR_SAFE_KEYWORDS}, every `format` value is in
+ * {@link GRAMMAR_SAFE_FORMATS}, and every `additionalProperties` is
+ * the literal `false`. Anything else is `'full'` — the consumer falls
+ * back to schema-as-context instead of grammar compilation. Consumers
+ * MUST treat unknown profile values as `'full'` (new profiles are
+ * additive minors).
+ */
+import canonicalize from 'canonicalize';
+import { buildPropsWrapperSchema } from './contract-validator.js';
+import { injectClosedShape } from './ajv-runtime.js';
+/**
+ * The grammar-safe core — the closed keyword set a `'grammar-safe'`
+ * schema may use (P3 pin 4; purely syntactic). `aliases` is enumerated
+ * now (it is the P4 in-contract alias keyword) so arming P4 needs no
+ * grammar change; until P4 ships it simply never appears in emitted
+ * bytes.
+ */
+export const GRAMMAR_SAFE_KEYWORDS = new Set([
+    'type',
+    'enum',
+    'const',
+    'properties',
+    'required',
+    'items',
+    'additionalProperties',
+    'oneOf',
+    'anyOf',
+    'format',
+    'description',
+    'title',
+    'aliases',
+]);
+/**
+ * The restricted `format` vocabulary admitted to the grammar-safe core
+ * (P3 pin 5). A consumer grammar MAY enforce any subset its engine
+ * supports; unenforced formats remain server-validated — AUTHORITY is
+ * one-directional, so an under-enforcing grammar is safe. A schema
+ * carrying a format outside this list classifies `'full'`.
+ */
+export const GRAMMAR_SAFE_FORMATS = new Set([
+    'date-time',
+    'time',
+    'date',
+    'duration',
+    'email',
+    'hostname',
+    'uri',
+    'ipv4',
+    'ipv6',
+    'uuid',
+]);
+/**
+ * RFC 8785 (JCS) serialization of a props schema — the canonical
+ * bytes `propsSchemaHash` is computed over, and the byte form the
+ * emitted `propsSchema` value is constructed to match. Consumers
+ * verify by re-canonicalizing the received value with any JCS
+ * library and hashing — raw received bytes are equivalent whenever
+ * the transport preserves key order (JS enumeration reorders
+ * integer-like property names, so re-canonicalization is the
+ * guaranteed path).
+ */
+export function canonicalPropsSchemaBytes(schema) {
+    return canonicalize(schema) ?? '{}';
+}
+/**
+ * Schema-position-aware canonical rebuild of one node: strips
+ * emission-layer metadata keywords, rewrites `nullable`, recurses into
+ * the schema-valued positions (`properties` values, `items`,
+ * schema-valued `additionalProperties`, `oneOf`/`anyOf` branches), and
+ * inserts keys in sorted order. Data-valued positions (`enum` members,
+ * `const`, `default`) pass through verbatim — they are values, not
+ * schemas, and JCS canonicalizes their serialization regardless of
+ * construction order.
+ */
+function canonicalizeSchemaNode(node) {
+    const out = {};
+    const nullableWidens = node.nullable === true && typeof node.type === 'string';
+    for (const key of Object.keys(node).sort()) {
+        if (key === 'example' || key === 'nullable')
+            continue;
+        const value = node[key];
+        if (key === 'type') {
+            const t = node.type;
+            if (nullableWidens && typeof t === 'string') {
+                out.type = [t, 'null'];
+            }
+            else if (node.nullable === true && Array.isArray(t)) {
+                out.type = t.includes('null') ? [...t] : [...t, 'null'];
+            }
+            else {
+                out.type = t;
+            }
+            continue;
+        }
+        if (key === 'properties' && isSchemaMap(value)) {
+            const props = {};
+            for (const name of Object.keys(value).sort()) {
+                props[name] = canonicalizeSchemaNode(value[name]);
+            }
+            out.properties = props;
+            continue;
+        }
+        if (key === 'items' && isSchemaValue(value)) {
+            out.items = canonicalizeSchemaNode(value);
+            continue;
+        }
+        if (key === 'additionalProperties' && isSchemaValue(value)) {
+            out.additionalProperties = canonicalizeSchemaNode(value);
+            continue;
+        }
+        if (key === 'oneOf' || key === 'anyOf') {
+            const branches = key === 'oneOf' ? node.oneOf : node.anyOf;
+            if (branches !== undefined) {
+                out[key] = branches.map(canonicalizeSchemaNode);
+                continue;
+            }
+        }
+        out[key] = value;
+    }
+    return out;
+}
+function isSchemaValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isSchemaMap(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.values(value).every(isSchemaValue));
+}
+/**
+ * Build the enforced props schema for a {@link PropsSpec} — the exact
+ * schema `ggui_render` compiles and validates against for the paired
+ * handshake, in emission form (closed shape materialized, `nullable`
+ * rewritten, metadata keywords stripped, canonical key order).
+ *
+ * An empty / degenerate spec yields the empty closed wrapper
+ * `{additionalProperties:false, properties:{}, required:[], type:'object'}`
+ * — never omitted for a non-declined handshake: under it, any
+ * non-empty props are invalid, which makes the props-without-propsSpec
+ * rejection schema-derivable and the accept-path drop documented
+ * leniency (one-directional AUTHORITY).
+ *
+ * `injectClosedShape` is idempotent, so compiling this pre-injected
+ * tree (`compileForValidation`) enforces byte-identical semantics to
+ * `validatePropsData` over the source spec — the AUTHORITY property
+ * the conformance kit's drift fixture pins.
+ */
+export function buildEnforcedPropsSchema(spec) {
+    return canonicalizeSchemaNode(injectClosedShape(buildPropsWrapperSchema(spec)));
+}
+/**
+ * Classify an (emission-form) props schema against the grammar-safe
+ * core — P3 pins 4+5. Purely syntactic; the conformance kit's profile
+ * fixture asserts the wire flag agrees with this reference checker.
+ */
+export function classifyPropsSchemaProfile(schema) {
+    for (const key of Object.keys(schema)) {
+        if (!GRAMMAR_SAFE_KEYWORDS.has(key))
+            return 'full';
+        const value = schema[key];
+        if (key === 'format') {
+            if (typeof value !== 'string' || !GRAMMAR_SAFE_FORMATS.has(value)) {
+                return 'full';
+            }
+            continue;
+        }
+        if (key === 'additionalProperties') {
+            if (value !== false)
+                return 'full';
+            continue;
+        }
+        if (key === 'properties' && isSchemaMap(value)) {
+            for (const nested of Object.values(value)) {
+                if (classifyPropsSchemaProfile(nested) === 'full')
+                    return 'full';
+            }
+            continue;
+        }
+        if (key === 'items' && isSchemaValue(value)) {
+            if (classifyPropsSchemaProfile(value) === 'full')
+                return 'full';
+            continue;
+        }
+        if ((key === 'oneOf' || key === 'anyOf') && Array.isArray(value)) {
+            for (const branch of value) {
+                if (!isSchemaValue(branch))
+                    return 'full';
+                if (classifyPropsSchemaProfile(branch) === 'full')
+                    return 'full';
+            }
+            continue;
+        }
+    }
+    return 'grammar-safe';
+}

package/dist/validation/schema-subset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-subset.d.ts","sourceRoot":"","sources":["../../src/validation/schema-subset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAC7B,eAAe;AACjB;sDACsD;GACpD,gBAAgB;AAClB;;;;mDAImD;GACjD,iBAAiB;AACnB;sEACsE;GACpE,kBAAkB;AACpB,mCAAmC;GACjC,gBAAgB;AAClB,sEAAsE;GACpE,8BAA8B;AAChC;;mDAEmD;GACjD,aAAa,CAAC;AAElB;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC;;sDAEkD;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;4CACwC;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;gDAG4C;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;CACjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,UAAU,GACjB,kBAAkB,CAiBpB;AAoTD,YAAY,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"schema-subset.d.ts","sourceRoot":"","sources":["../../src/validation/schema-subset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,OAAO,KAAK,EACV,UAAU,EAEV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAC7B,eAAe;AACjB;sDACsD;GACpD,gBAAgB;AAClB;;;;mDAImD;GACjD,iBAAiB;AACnB;sEACsE;GACpE,kBAAkB;AACpB,mCAAmC;GACjC,gBAAgB;AAClB,sEAAsE;GACpE,8BAA8B;AAChC;;mDAEmD;GACjD,aAAa,CAAC;AAElB;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC;;sDAEkD;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;4CACwC;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;gDAG4C;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;CACjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,UAAU,GACjB,kBAAkB,CAiBpB;AA8TD,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/validation/schema-subset.js

@@ -88,17 +88,22 @@ function compare(superset, subset, path, out) {
     // Type match. Superset `undefined` is a wildcard (accepts any
     // type). Subset `undefined` against a specific superset type is a
     // violation — "no declared type" is wider than any specific type.
-    const sup = normalizeType(superset);
-    const sub = normalizeType(subset);
+    const sup = normalizeTypeSet(superset);
+    const sub = normalizeTypeSet(subset);
     if (sup !== undefined) {
-        if (sub === undefined || sub !== sup) {
+        // Draft-07 type ARRAYS (e.g. `['string','null']`, the canonical
+        // nullability form the enforced-props-schema emission produces)
+        // compare as SETS: every type the subset can emit must be accepted
+        // by the superset.
+        const subsetOk = sub !== undefined && [...sub].every((t) => sup.has(t));
+        if (!subsetOk) {
             out.push({
                 path,
                 reason: 'type-mismatch',
-                superset: sup,
-                subset: sub ?? '(unspecified)',
+                superset: formatTypeSet(sup),
+                subset: sub === undefined ? '(unspecified)' : formatTypeSet(sub),
                 message: `${pathLabel(path)}: type mismatch — superset accepts ` +
-                    `'${sup}' but subset ${sub === undefined ? 'does not declare a type' : `declares '${sub}'`}.`,
+                    `'${formatTypeSet(sup)}' but subset ${sub === undefined ? 'does not declare a type' : `declares '${formatTypeSet(sub)}'`}.`,
             });
             // Type mismatch invalidates downstream object/array structural
             // checks — if the types don't match, deeper comparison is noise.
@@ -106,14 +111,14 @@ function compare(superset, subset, path, out) {
         }
     }
     // Object structure.
-    if (sup === 'object' || sub === 'object') {
+    if (sup?.has('object') || sub?.has('object')) {
         compareObject(superset, subset, path, out);
     }
     // Array items. We descend through items only when both sides have
     // `type: 'array'` (or superset omitted type and subset declares
     // array — but that case is caught by the type block above as a
     // mismatch). Omission on either side is permissive.
-    if (sup === 'array' || sub === 'array') {
+    if (sup?.has('array') || sub?.has('array')) {
         compareArray(superset, subset, path, out);
     }
 }
@@ -235,8 +240,20 @@ function compareArray(superset, subset, path, out) {
     const childPath = path === '' ? 'items' : `${path}.items`;
     compare(supItems, subItems, childPath, out);
 }
-function normalizeType(schema) {
-    return schema.type;
+// ── Helpers ───────────────────────────────────────────────────────
+/**
+ * The declared type(s) as a SET — single declarations and draft-07
+ * type arrays normalize to the same shape so subset comparison is
+ * uniform. `undefined` = no type declared (permissive).
+ */
+function normalizeTypeSet(schema) {
+    const t = schema.type;
+    if (t === undefined)
+        return undefined;
+    return new Set(Array.isArray(t) ? t : [t]);
+}
+function formatTypeSet(set) {
+    return [...set].join('|');
 }
 function resolveAdditional(value) {
     // JSON Schema draft-07: omitted ⇒ additionalProperties `true`.