schema-components 2.0.1 → 2.1.0

package/dist/adapter-ktQaheWB.d.mts

@@ -0,0 +1,213 @@
+import { m as JsonObject, w as SchemaMeta } from "./types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "./diagnostics-mftUZI7c.mjs";
+
+//#region src/core/adapter.d.ts
+/**
+ * Classification produced by {@link detectSchemaKind} when inspecting a
+ * runtime schema input.
+ *
+ * @group Adapter
+ */
+type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
+/**
+ * Classify a runtime schema input by structural markers — Zod 4, Zod 3,
+ * OpenAPI document, plain JSON Schema, or an unsupported third-party
+ * schema library.
+ *
+ * - `zod4` — has a `_zod` marker (further validation that `_zod.def` is a
+ *   non-null object happens inside `normaliseZod4`).
+ * - `zod3` — has `_def` and no `_zod`. The `typeName` field is no longer
+ *   required: any `_def` without `_zod` is treated as a probable Zod 3
+ *   schema. Third-party libraries that expose `_def` without `_zod` are
+ *   nearly always Zod 3 forks; surfacing the migration message is the
+ *   correct response.
+ * - `openapi` — has `openapi` or `swagger` at the root.
+ * - `unsupported-schema-lib` — has `parse` and `safeParse` callables but
+ *   no `_zod` and no `_def` marker. This catches Standard Schema
+ *   implementations (valibot, arktype, etc.) that would otherwise flow
+ *   through as "malformed JSON Schema".
+ * - `jsonSchema` — fallback for anything that does not match the above.
+ *
+ * @group Adapter
+ */
+declare function detectSchemaKind(input: unknown): SchemaKind;
+/**
+ * Wraps z.toJSONSchema() for a runtime-validated Zod schema.
+ *
+ * The _zod guard in normaliseZod4 has confirmed this is a valid Zod schema,
+ * but TypeScript cannot represent "has _zod.def" as the $ZodType parameter
+ * that z.toJSONSchema expects. This is the library boundary equivalent of
+ * `object → Record<string, unknown>` — the type mismatch is genuinely unavoidable.
+ *
+ * # Options
+ *
+ * `z.toJSONSchema` is invoked with an explicit options object rather than
+ * Zod's defaults so the conversion contract is pinned and stable:
+ *
+ * - `target: "draft-2020-12"` — matches the walker's draft target.
+ * - `unrepresentable: "throw"` — keeps the unrepresentable-type rules in
+ *   the classifier table firing instead of silently emitting `{}`.
+ * - `cycles: "ref"` — converts cyclic graphs into $ref pairs rather than
+ *   throwing. Cycles in user schemas surface through the walker's $ref
+ *   resolution rather than the adapter.
+ * - `io` — selects which side of every transform / pipe / codec is
+ *   converted. Defaults to `"output"` (the OUTPUT side); pass `"input"`
+ *   to render the INPUT side instead. The input side is invisible to
+ *   the converted schema when `io: "output"` is in force, even though
+ *   `safeParse` on the same Zod schema consumes the input shape. For
+ *   transforms this divergence is fatal and the call throws via
+ *   `Transforms cannot be represented`; for `z.codec(...)` the call
+ *   succeeds but only the selected side is rendered. Consumers receive
+ *   a `zod-codec-output-only` diagnostic in the codec case so the
+ *   asymmetry is visible — see `screenPreConversion`.
+ *
+ * # Error classification
+ *
+ * Any exception thrown by z.toJSONSchema is classified into a
+ * SchemaNormalisationError so the caller does not have to re-parse error
+ * message strings. The classification covers:
+ *
+ * - Nested Zod 3 schemas inside a Zod 4 tree → zod3-unsupported.
+ *   Detected structurally (presence of `_def.typeName` markers anywhere
+ *   in the schema tree) so the check works across V8, JavaScriptCore,
+ *   and SpiderMonkey, none of which agree on the wording of
+ *   "Cannot read properties of undefined".
+ * - Transforms → zod-transform-unsupported. This also catches `z.codec(…)`
+ *   because Zod implements codecs as a pipe + transform internally, so
+ * they trip the same processor when round-tripping is forced. (Plain
+ *   `z.toJSONSchema(codec)` itself does NOT throw because Zod picks one
+ *   side of the codec; the static rejection in `typeInference.ts` is the
+ *   compile-time guard.)
+ * - Dynamic catch values whose handler throws → zod-type-unrepresentable
+ *   with zodType "dynamic-catch".
+ * - Unrepresentable types — bigint, date, map, set, symbol, function, custom,
+ *   undefined, void, NaN, and the literal-only forms `z.literal(undefined)`
+ *   ("undefined-literal") and `z.literal(<bigint>)` ("bigint-literal") →
+ *   zod-type-unrepresentable.
+ * - The catch-all "Non-representable type encountered: <type>" fallback Zod
+ *   emits for any new schema kind without a registered processor →
+ *   zod-type-unrepresentable with zodType set to the offending def.type.
+ * - Cycle detected (`cycles: "throw"`) → zod-cycle-detected.
+ * - Duplicate schema id → zod-duplicate-id.
+ * - "Unprocessed schema. This is a bug in Zod." → zod-conversion-bug.
+ * - "Error converting schema to JSON." → zod-conversion-failed (explicit
+ *   classification rather than the generic fallback so the contract test
+ *   protects the prefix from drift).
+ * - Anything else → zod-conversion-failed.
+ *
+ * The original error is preserved on each classified error via the `cause`
+ * field so consumers can still inspect the Zod stack trace.
+ */
+/**
+ * Direction of the Zod transform / pipe / codec that
+ * {@link normaliseSchema} should surface to the renderer.
+ *
+ * - `"output"` (default) — the server-facing side of every transform,
+ *   matching `z.toJSONSchema`'s default and the historic adapter
+ *   behaviour.
+ * - `"input"` — the client-facing side; flips a `z.codec(...)` chain
+ *   so consumers can render its input shape.
+ *
+ * @group Adapter
+ */
+type SchemaIoSide = "input" | "output";
+/**
+ * True when `value` is a Zod schema implemented as a codec
+ * (`z.codec(...)`). Detection looks for the `$ZodCodec` marker on the
+ * schema's `_zod.traits` Set — the same structural check used by Zod
+ * itself in `to-json-schema.ts`'s `isTransforming` helper.
+ *
+ * Promoted from a duplicated local helper in `react/SchemaComponent.tsx`
+ * so the validation boundary inside `runValidation` can branch on
+ * codec-vs-not-codec without re-implementing the trait check. The
+ * shared helper anchors a single source of truth for codec detection:
+ * any future change to Zod's trait naming flows through here, not
+ * through two parallel copies.
+ *
+ * Returns `false` for non-objects, plain JSON Schema inputs, OpenAPI
+ * documents, or Zod schemas of any other kind. This is structural
+ * rather than nominal — a Zod 4 codec produced by any path that ends
+ * up tagging `_zod.traits` with `$ZodCodec` is recognised, including
+ * schemas wrapped by user-defined helpers.
+ */
+declare function isCodecSchema(value: unknown): boolean;
+/**
+ * Exposed for unit testing — lets the contract test enumerate every rule's
+ * `prefix` value and assert mutual non-prefixing.
+ */
+declare const __CLASSIFIER_RULES_FOR_TEST: readonly {
+  readonly prefix: string;
+}[];
+/**
+ * Result of {@link normaliseSchema}. Carries the canonical Draft 2020-12
+ * JSON Schema the walker consumes, the optional original Zod schema
+ * (used for validation), and the resolved root document so cross-document
+ * `$ref`s can be dereferenced downstream.
+ *
+ * @group Adapter
+ */
+interface NormalisedSchema {
+  /** JSON Schema object — the authoritative schema for rendering. */
+  jsonSchema: JsonObject;
+  /** Original Zod schema, if input was Zod. Used for validation. */
+  zodSchema?: unknown;
+  /** Root-level metadata. */
+  rootMeta: SchemaMeta | undefined;
+  /** The root document for $ref resolution. */
+  rootDocument: JsonObject;
+}
+/**
+ * Options accepted by {@link normaliseSchema}.
+ *
+ * @group Adapter
+ */
+interface NormaliseOptions {
+  /** Diagnostics channel for surfacing silent fallbacks. */
+  diagnostics?: DiagnosticsOptions;
+  /**
+   * Side of every transform / pipe / codec to render. Defaults to
+   * `"output"`, matching `z.toJSONSchema`'s default and the
+   * historic behaviour of the adapter. Passing `"input"` flips the
+   * conversion so consumers rendering the input shape of a
+   * `z.codec(...)` chain receive that side instead of the output
+   * side. Only the Zod 4 branch consults this option — JSON Schema
+   * and OpenAPI inputs are already a single canonical shape.
+   */
+  io?: SchemaIoSide;
+}
+/**
+ * Normalise any supported schema input — Zod 4 schema, plain JSON
+ * Schema (any draft), Swagger 2.0, OpenAPI 3.0 or 3.1 document — into
+ * a canonical Draft 2020-12 {@link NormalisedSchema} the walker can
+ * consume.
+ *
+ * Dispatches on {@link detectSchemaKind}, applies the appropriate
+ * version normaliser, and returns the JSON Schema alongside the
+ * original Zod schema (for validation) and the resolved root document
+ * (for cross-document `$ref` resolution). Throws
+ * `SchemaNormalisationError` for unsupported inputs (Zod 3, valibot,
+ * arktype, codec or other unrepresentable Zod types).
+ *
+ * @group Adapter
+ */
+declare function normaliseSchema(input: unknown, ref?: string, options?: NormaliseOptions): NormalisedSchema;
+/**
+ * Surface root-level metadata from the JSON Schema into the `rootMeta`
+ * shape consumed by the walker. Pulls `readOnly`, `writeOnly`,
+ * `description`, `title`, `deprecated`, `examples`, and `default`
+ * directly from the schema root.
+ *
+ * `examples` is forwarded only when present as an array (per JSON Schema
+ * Draft 2020-12 — Draft 04's `example` singular is normalised upstream).
+ * `default` is forwarded for any value the schema declares (any JSON
+ * value, including `null` and `false`); the presence check uses `in`
+ * so a literal `false` or `null` default is preserved.
+ *
+ * `examples` and `default` ride on the `[key: string]: unknown` index
+ * signature of {@link SchemaMeta}. They are not declared as named fields
+ * on `SchemaMeta` because that type lives in `types.ts` and is shared
+ * with the walker; the index signature is the agreed extension point.
+ */
+declare function extractRootMetaFromJson(jsonSchema: JsonObject): SchemaMeta | undefined;
+//#endregion
+export { __CLASSIFIER_RULES_FOR_TEST as a, isCodecSchema as c, SchemaKind as i, normaliseSchema as l, NormalisedSchema as n, detectSchemaKind as o, SchemaIoSide as r, extractRootMetaFromJson as s, NormaliseOptions as t };

package/dist/constructorTypes-BdCiMS6e.d.mts

@@ -0,0 +1,30 @@
+//#region src/lit/constructorTypes.d.ts
+/**
+ * Tiny structural-type helpers for the Lit adapter.
+ *
+ * Lives alongside `lit/registry.ts` rather than under `core/` because
+ * the Custom-Element constructor signature is only needed by the Lit
+ * surface — other adapter directories model their renderers as plain
+ * functions and have no use for it.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generic newable constructor type compatible with the DOM's
+ * `CustomElementConstructor`. Used by {@link BUILT_IN_ELEMENTS} (the
+ * canonical-tag → element-constructor map) so the map's value type
+ * carries enough structure for `customElements.define` to accept it
+ * without an `as` cast.
+ *
+ * Matches the DOM type-library signature
+ * `interface CustomElementConstructor { new (...params: any[]): HTMLElement; }`
+ * but parameterised over a `T extends HTMLElement` so it can also be
+ * used in narrower contexts.
+ *
+ * `unknown[]` is used in the parameter list — the DOM lib uses
+ * `any[]`, but `unknown[]` is the strict-mode equivalent that
+ * accepts any positional argument shape without using `any`.
+ */
+type Constructor<T extends HTMLElement> = new (...params: unknown[]) => T;
+//#endregion
+export { Constructor as t };

package/dist/core/adapter.d.mts

@@ -1,213 +1,3 @@
-import { m as JsonObject, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
-
-//#region src/core/adapter.d.ts
-/**
- * Classification produced by {@link detectSchemaKind} when inspecting a
- * runtime schema input.
- *
- * @group Adapter
- */
-type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
-/**
- * Classify a runtime schema input by structural markers — Zod 4, Zod 3,
- * OpenAPI document, plain JSON Schema, or an unsupported third-party
- * schema library.
- *
- * - `zod4` — has a `_zod` marker (further validation that `_zod.def` is a
- *   non-null object happens inside `normaliseZod4`).
- * - `zod3` — has `_def` and no `_zod`. The `typeName` field is no longer
- *   required: any `_def` without `_zod` is treated as a probable Zod 3
- *   schema. Third-party libraries that expose `_def` without `_zod` are
- *   nearly always Zod 3 forks; surfacing the migration message is the
- *   correct response.
- * - `openapi` — has `openapi` or `swagger` at the root.
- * - `unsupported-schema-lib` — has `parse` and `safeParse` callables but
- *   no `_zod` and no `_def` marker. This catches Standard Schema
- *   implementations (valibot, arktype, etc.) that would otherwise flow
- *   through as "malformed JSON Schema".
- * - `jsonSchema` — fallback for anything that does not match the above.
- *
- * @group Adapter
- */
-declare function detectSchemaKind(input: unknown): SchemaKind;
-/**
- * Wraps z.toJSONSchema() for a runtime-validated Zod schema.
- *
- * The _zod guard in normaliseZod4 has confirmed this is a valid Zod schema,
- * but TypeScript cannot represent "has _zod.def" as the $ZodType parameter
- * that z.toJSONSchema expects. This is the library boundary equivalent of
- * object → Record<string, unknown> — the type mismatch is genuinely unavoidable.
- *
- * # Options
- *
- * `z.toJSONSchema` is invoked with an explicit options object rather than
- * Zod's defaults so the conversion contract is pinned and stable:
- *
- * - `target: "draft-2020-12"` — matches the walker's draft target.
- * - `unrepresentable: "throw"` — keeps the unrepresentable-type rules in
- *   the classifier table firing instead of silently emitting `{}`.
- * - `cycles: "ref"` — converts cyclic graphs into $ref pairs rather than
- *   throwing. Cycles in user schemas surface through the walker's $ref
- *   resolution rather than the adapter.
- * - `io` — selects which side of every transform / pipe / codec is
- *   converted. Defaults to `"output"` (the OUTPUT side); pass `"input"`
- *   to render the INPUT side instead. The input side is invisible to
- *   the converted schema when `io: "output"` is in force, even though
- *   `safeParse` on the same Zod schema consumes the input shape. For
- *   transforms this divergence is fatal and the call throws via
- *   `Transforms cannot be represented`; for `z.codec(...)` the call
- *   succeeds but only the selected side is rendered. Consumers receive
- *   a `zod-codec-output-only` diagnostic in the codec case so the
- *   asymmetry is visible — see `screenPreConversion`.
- *
- * # Error classification
- *
- * Any exception thrown by z.toJSONSchema is classified into a
- * SchemaNormalisationError so the caller does not have to re-parse error
- * message strings. The classification covers:
- *
- * - Nested Zod 3 schemas inside a Zod 4 tree → zod3-unsupported.
- *   Detected structurally (presence of `_def.typeName` markers anywhere
- *   in the schema tree) so the check works across V8, JavaScriptCore,
- *   and SpiderMonkey, none of which agree on the wording of
- *   "Cannot read properties of undefined".
- * - Transforms → zod-transform-unsupported. This also catches `z.codec(…)`
- *   because Zod implements codecs as a pipe + transform internally, so
- * they trip the same processor when round-tripping is forced. (Plain
- *   `z.toJSONSchema(codec)` itself does NOT throw because Zod picks one
- *   side of the codec; the static rejection in `typeInference.ts` is the
- *   compile-time guard.)
- * - Dynamic catch values whose handler throws → zod-type-unrepresentable
- *   with zodType "dynamic-catch".
- * - Unrepresentable types — bigint, date, map, set, symbol, function, custom,
- *   undefined, void, NaN, and the literal-only forms `z.literal(undefined)`
- *   ("undefined-literal") and `z.literal(<bigint>)` ("bigint-literal") →
- *   zod-type-unrepresentable.
- * - The catch-all "Non-representable type encountered: <type>" fallback Zod
- *   emits for any new schema kind without a registered processor →
- *   zod-type-unrepresentable with zodType set to the offending def.type.
- * - Cycle detected (`cycles: "throw"`) → zod-cycle-detected.
- * - Duplicate schema id → zod-duplicate-id.
- * - "Unprocessed schema. This is a bug in Zod." → zod-conversion-bug.
- * - "Error converting schema to JSON." → zod-conversion-failed (explicit
- *   classification rather than the generic fallback so the contract test
- *   protects the prefix from drift).
- * - Anything else → zod-conversion-failed.
- *
- * The original error is preserved on each classified error via the `cause`
- * field so consumers can still inspect the Zod stack trace.
- */
-/**
- * Direction of the Zod transform / pipe / codec that
- * {@link normaliseSchema} should surface to the renderer.
- *
- * - `"output"` (default) — the server-facing side of every transform,
- *   matching `z.toJSONSchema`'s default and the historic adapter
- *   behaviour.
- * - `"input"` — the client-facing side; flips a `z.codec(...)` chain
- *   so consumers can render its input shape.
- *
- * @group Adapter
- */
-type SchemaIoSide = "input" | "output";
-/**
- * True when `value` is a Zod schema implemented as a codec
- * (`z.codec(...)`). Detection looks for the `$ZodCodec` marker on the
- * schema's `_zod.traits` Set — the same structural check used by Zod
- * itself in `to-json-schema.ts`'s `isTransforming` helper.
- *
- * Promoted from a duplicated local helper in `react/SchemaComponent.tsx`
- * so the validation boundary inside `runValidation` can branch on
- * codec-vs-not-codec without re-implementing the trait check. The
- * shared helper anchors a single source of truth for codec detection:
- * any future change to Zod's trait naming flows through here, not
- * through two parallel copies.
- *
- * Returns `false` for non-objects, plain JSON Schema inputs, OpenAPI
- * documents, or Zod schemas of any other kind. This is structural
- * rather than nominal — a Zod 4 codec produced by any path that ends
- * up tagging `_zod.traits` with `$ZodCodec` is recognised, including
- * schemas wrapped by user-defined helpers.
- */
-declare function isCodecSchema(value: unknown): boolean;
-/**
- * Exposed for unit testing — lets the contract test enumerate every rule's
- * `prefix` value and assert mutual non-prefixing.
- */
-declare const __CLASSIFIER_RULES_FOR_TEST: readonly {
-  readonly prefix: string;
-}[];
-/**
- * Result of {@link normaliseSchema}. Carries the canonical Draft 2020-12
- * JSON Schema the walker consumes, the optional original Zod schema
- * (used for validation), and the resolved root document so cross-document
- * `$ref`s can be dereferenced downstream.
- *
- * @group Adapter
- */
-interface NormalisedSchema {
-  /** JSON Schema object — the authoritative schema for rendering. */
-  jsonSchema: JsonObject;
-  /** Original Zod schema, if input was Zod. Used for validation. */
-  zodSchema?: unknown;
-  /** Root-level metadata. */
-  rootMeta: SchemaMeta | undefined;
-  /** The root document for $ref resolution. */
-  rootDocument: JsonObject;
-}
-/**
- * Options accepted by {@link normaliseSchema}.
- *
- * @group Adapter
- */
-interface NormaliseOptions {
-  /** Diagnostics channel for surfacing silent fallbacks. */
-  diagnostics?: DiagnosticsOptions;
-  /**
-   * Side of every transform / pipe / codec to render. Defaults to
-   * `"output"`, matching `z.toJSONSchema`'s default and the
-   * historic behaviour of the adapter. Passing `"input"` flips the
-   * conversion so consumers rendering the input shape of a
-   * `z.codec(...)` chain receive that side instead of the output
-   * side. Only the Zod 4 branch consults this option — JSON Schema
-   * and OpenAPI inputs are already a single canonical shape.
-   */
-  io?: SchemaIoSide;
-}
-/**
- * Normalise any supported schema input — Zod 4 schema, plain JSON
- * Schema (any draft), Swagger 2.0, OpenAPI 3.0 or 3.1 document — into
- * a canonical Draft 2020-12 {@link NormalisedSchema} the walker can
- * consume.
- *
- * Dispatches on {@link detectSchemaKind}, applies the appropriate
- * version normaliser, and returns the JSON Schema alongside the
- * original Zod schema (for validation) and the resolved root document
- * (for cross-document `$ref` resolution). Throws
- * `SchemaNormalisationError` for unsupported inputs (Zod 3, valibot,
- * arktype, codec or other unrepresentable Zod types).
- *
- * @group Adapter
- */
-declare function normaliseSchema(input: unknown, ref?: string, options?: NormaliseOptions): NormalisedSchema;
-/**
- * Surface root-level metadata from the JSON Schema into the `rootMeta`
- * shape consumed by the walker. Pulls `readOnly`, `writeOnly`,
- * `description`, `title`, `deprecated`, `examples`, and `default`
- * directly from the schema root.
- *
- * `examples` is forwarded only when present as an array (per JSON Schema
- * Draft 2020-12 — Draft 04's `example` singular is normalised upstream).
- * `default` is forwarded for any value the schema declares (any JSON
- * value, including `null` and `false`); the presence check uses `in`
- * so a literal `false` or `null` default is preserved.
- *
- * `examples` and `default` ride on the `[key: string]: unknown` index
- * signature of {@link SchemaMeta}. They are not declared as named fields
- * on `SchemaMeta` because that type lives in `types.ts` and is shared
- * with the walker; the index signature is the agreed extension point.
- */
-declare function extractRootMetaFromJson(jsonSchema: JsonObject): SchemaMeta | undefined;
-//#endregion
-export { type JsonObject, NormaliseOptions, NormalisedSchema, SchemaIoSide, SchemaKind, type SchemaMeta, __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, isCodecSchema, normaliseSchema };
+import { m as JsonObject, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { a as __CLASSIFIER_RULES_FOR_TEST, c as isCodecSchema, i as SchemaKind, l as normaliseSchema, n as NormalisedSchema, o as detectSchemaKind, r as SchemaIoSide, s as extractRootMetaFromJson, t as NormaliseOptions } from "../adapter-ktQaheWB.mjs";
+export { JsonObject, NormaliseOptions, NormalisedSchema, SchemaIoSide, SchemaKind, SchemaMeta, __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, isCodecSchema, normaliseSchema };

package/dist/core/adapter.mjs

@@ -4,7 +4,7 @@ import { SchemaNormalisationError } from "./errors.mjs";
 import { appendPointer, emitDiagnostic } from "./diagnostics.mjs";
 import { dereference } from "./ref.mjs";
 import { detectOpenApiVersion, inferJsonSchemaDraftWithReason, isSwagger2, matchJsonSchemaDraftUri } from "./version.mjs";
-import { a as normaliseJsonSchema$1, o as normaliseOpenApiSchemas } from "../normalise-DB-Xtjmn.mjs";
+import { a as normaliseJsonSchema$1, o as normaliseOpenApiSchemas } from "../normalise-BkePrJ4v.mjs";
 import { z } from "zod";
 //#region src/core/adapter.ts
 /**
@@ -118,8 +118,8 @@ function callToJsonSchema(schema, io = "output") {
 *   without ever being told the wrapping was lost.
 *
 * Detection happens BEFORE the call to `z.toJSONSchema` so the response is
-* an immediate `SchemaNormalisationError` with `kind:
-* "zod-type-unrepresentable"`, matching the philosophy of
+* an immediate `SchemaNormalisationError` with `kind: "zod-type-unrepresentable"`,
+* matching the philosophy of
 * `UnrepresentableZodType` in `typeInference.ts` — these types are
 * rejected, not coerced.
 */
@@ -373,33 +373,41 @@ function unrepresentableMessage(typeName, fullMessage) {
 }
 /**
 * Classifier rules ordered most-specific first. Order is load-bearing:
-* `Literal \`undefined\` cannot be represented` must precede the broader
-* `Undefined cannot be represented` so the literal classification wins
-* even when both share a leading word. A consistency check in the unit
-* test suite asserts no two `prefix` values are prefixes of each other —
-* any future rule that breaks the invariant fails the build.
+* the Literal-undefined message must precede the broader
+* Undefined-cannot-be-represented message so the literal classification
+* wins even when both share a leading word. A consistency check in the
+* unit test suite asserts no two `prefix` values are prefixes of each
+* other — any future rule that breaks the invariant fails the build.
 *
 * Verbatim sources (kept aligned with `tests/zod-error-wording-contract.unit.test.ts`).
 * Source files are referenced by message-content anchors rather than line
 * numbers — line numbers drift across Zod patch releases but the message
-* strings themselves are stable and protected by the contract test suite:
+* strings themselves are stable and protected by the contract test suite.
 *
-* - `zod/src/v4/core/json-schema-processors.ts` — emits `BigInt cannot be
-*   represented`, `Symbols cannot be represented`, `Undefined cannot be
-*   represented`, `Void cannot be represented`, `Date cannot be
-*   represented`, `Literal \`undefined\` cannot be represented`,
-*   `BigInt literals cannot be represented`, `NaN cannot be represented`,
-*   `Custom types cannot be represented`, `Function types cannot be
-*   represented`, `Transforms cannot be represented`, `Map cannot be
-*   represented`, `Set cannot be represented`, `Dynamic catch values are
-*   not supported`.
-* - `zod/src/v4/core/to-json-schema.ts` — emits `[toJSONSchema]:
-*   Non-representable type encountered: ${def.type}` (the catch-all
-*   fallback), `Unprocessed schema. This is a bug in Zod.` (the
-*   internal-bug branch), `Duplicate schema id "${id}" detected during
-*   JSON Schema conversion.` (the duplicate-id branch), `Cycle detected:
-*   ` (the cycle-throw branch), and `Error converting schema to JSON.`
-*   (the Standard Schema boundary wrapper).
+* Messages from `zod/src/v4/core/json-schema-processors.ts`:
+*
+* - `BigInt cannot be represented`
+* - `Symbols cannot be represented`
+* - `Undefined cannot be represented`
+* - `Void cannot be represented`
+* - `Date cannot be represented`
+* - the Literal-undefined message (the string literal at the matching `prefix` below holds the verbatim Zod text, including its own embedded backticks)
+* - `BigInt literals cannot be represented`
+* - `NaN cannot be represented`
+* - `Custom types cannot be represented`
+* - `Function types cannot be represented`
+* - `Transforms cannot be represented`
+* - `Map cannot be represented`
+* - `Set cannot be represented`
+* - `Dynamic catch values are not supported`
+*
+* Messages from `zod/src/v4/core/to-json-schema.ts`:
+*
+* - `[toJSONSchema]: Non-representable type encountered: ${def.type}` (the catch-all fallback)
+* - `Unprocessed schema. This is a bug in Zod.` (the internal-bug branch)
+* - `Duplicate schema id "${id}" detected during JSON Schema conversion.` (the duplicate-id branch)
+* - `Cycle detected: ` (the cycle-throw branch)
+* - `Error converting schema to JSON.` (the Standard Schema boundary wrapper)
 */
 const CLASSIFIER_RULES = [
 	{

package/dist/core/constraintHint.d.mts

@@ -1,4 +1,4 @@
-import { AllConstraints } from "./renderer.mjs";
+import { t as AllConstraints } from "../renderer-ab9E52Bp.mjs";
 
 //#region src/core/constraintHint.d.ts
 /**

package/dist/core/constraints.d.mts

@@ -1,5 +1,5 @@
-import { E as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { E as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
 
 //#region src/core/constraints.d.ts
 /**

package/dist/core/contexts.d.mts

@@ -0,0 +1,71 @@
+import { d as WidgetMap, i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
+
+//#region src/core/contexts.d.ts
+/**
+ * Abstract provide / consume port that framework adapters implement
+ * against their native context primitive. The {@link provide} step
+ * wraps its `children` in the framework's provider machinery so any
+ * descendant calling {@link consume} receives the supplied value;
+ * {@link consume} is called from inside a child renderer to read the
+ * current value.
+ *
+ * The return type of `provide` and the argument type of `consume` are
+ * deliberately `unknown` so the port works for both React-style
+ * "wrap children in a provider component" implementations and
+ * Svelte-style "set on the current component instance" implementations
+ * without forcing one shape on the other.
+ *
+ * @typeParam T - The value carried by the context.
+ */
+interface ContextPort<T> {
+  /**
+   * Provide `value` to every descendant of `children`. The exact
+   * shape of `children` is framework-specific — `ReactNode` for
+   * React, the slot's render function for Svelte, the `setup`
+   * return value for Vue. The implementation simply makes the
+   * supplied value available to subsequent {@link consume} calls
+   * within that scope.
+   */
+  provide(value: T, children: unknown): unknown;
+  /**
+   * Read the currently provided value. The exact host primitive is
+   * framework-specific — `useContext(ctx)` in React, `inject(key)`
+   * in Vue, `getContext(key)` in Svelte. When no provider is
+   * mounted in scope, adapter implementations may return their
+   * canonical "default" value or `undefined` — the choice is
+   * adapter-defined.
+   */
+  consume(): T;
+}
+/**
+ * Shape carried by the resolver context. Adapters expose this through
+ * a `ContextPort<ResolverContextShape>` so the dispatcher can read
+ * the active theme adapter without taking a direct dependency on the
+ * host framework's context system.
+ *
+ * Mirrors the value carried by the React adapter's
+ * `UserResolverContext` (defined in `react/SchemaComponent.tsx`) —
+ * an optional {@link ComponentResolver}. The `undefined` branch
+ * signals "no theme provider mounted; fall through to the headless
+ * resolver".
+ *
+ * @group Framework Adapters
+ */
+type ResolverContextShape = ComponentResolver | undefined;
+/**
+ * Shape carried by the widgets context. Adapters expose this through
+ * a `ContextPort<WidgetsContextShape>` so the dispatcher can read
+ * the active widget map without binding to the host framework's
+ * context system.
+ *
+ * Mirrors the value carried by the React adapter's `WidgetsContext`
+ * (defined in `react/SchemaComponent.tsx`) — an optional
+ * {@link WidgetMap}. The `undefined` branch signals "no scoped widgets
+ * for this subtree; fall through to per-instance widgets, then the
+ * global registry, then the resolver".
+ *
+ * @group Framework Adapters
+ */
+type WidgetsContextShape = WidgetMap | undefined;
+//#endregion
+export { ContextPort, ResolverContextShape, WidgetsContextShape };

package/dist/core/contexts.mjs

@@ -0,0 +1 @@
+export {};

package/dist/core/diagnostics.d.mts

@@ -1,2 +1,2 @@
-import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-BTrm3O6J.mjs";
+import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-mftUZI7c.mjs";
 export { Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticsOptions, appendPointer, emitDiagnostic };

package/dist/core/errors.d.mts

@@ -1,2 +1,2 @@
-import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-Dki7tji4.mjs";
+import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DbaI04x2.mjs";
 export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError };

package/dist/core/fieldOrder.d.mts

@@ -1,4 +1,4 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
 
 //#region src/core/fieldOrder.d.ts
 /**

package/dist/{react → core}/fieldPath.d.mts

@@ -1,6 +1,6 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
 
-//#region src/react/fieldPath.d.ts
+//#region src/core/fieldPath.d.ts
 /**
  * Resolve a dot-separated path through a WalkedField tree.
  * Supports array index notation: `field[0]`.