schema-components 1.23.0 → 1.26.0

package/dist/adapter-MiEFkRVV.d.mts

@@ -0,0 +1,172 @@
+import { m as JsonObject, w as SchemaMeta } from "./types-BTB73MB8.mjs";
+import { i as DiagnosticsOptions } from "./diagnostics-Cbwak-ZX.mjs";
+
+//#region src/core/adapter.d.ts
+type SchemaInput = Record<string, unknown>;
+type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
+/**
+ * Classify the input schema by its structural markers.
+ *
+ * - `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.
+ */
+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.
+ */
+/**
+ * IO side passed to {@link callToJsonSchema}. The Zod runtime accepts
+ * `"input" | "output"` for the corresponding `io` option on
+ * `z.toJSONSchema`. Defaults to `"output"` everywhere in the adapter
+ * pipeline; the parameter exists so a future renderer or component
+ * (currently SchemaComponent — see TODO below) can request the input
+ * side without forking the helper.
+ */
+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;
+}[];
+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;
+}
+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;
+}
+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 { SchemaKind as a, extractRootMetaFromJson as c, SchemaIoSide as i, isCodecSchema as l, NormalisedSchema as n, __CLASSIFIER_RULES_FOR_TEST as o, SchemaInput as r, detectSchemaKind as s, NormaliseOptions as t, normaliseSchema as u };

package/dist/core/adapter.d.mts

@@ -1,142 +1,3 @@
 import { m as JsonObject, w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
-
-//#region src/core/adapter.d.ts
-type SchemaInput = Record<string, unknown>;
-type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
-/**
- * Classify the input schema by its structural markers.
- *
- * - `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.
- */
-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.
- */
-/**
- * IO side passed to {@link callToJsonSchema}. The Zod runtime accepts
- * `"input" | "output"` for the corresponding `io` option on
- * `z.toJSONSchema`. Defaults to `"output"` everywhere in the adapter
- * pipeline; the parameter exists so a future renderer or component
- * (currently SchemaComponent — see TODO below) can request the input
- * side without forking the helper.
- */
-type SchemaIoSide = "input" | "output";
-/**
- * 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;
-}[];
-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;
-}
-interface NormaliseOptions {
-  /** Diagnostics channel for surfacing silent fallbacks. */
-  diagnostics?: DiagnosticsOptions;
-}
-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, SchemaInput, SchemaIoSide, SchemaKind, type SchemaMeta, __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, normaliseSchema };
+import { a as SchemaKind, c as extractRootMetaFromJson, i as SchemaIoSide, l as isCodecSchema, n as NormalisedSchema, o as __CLASSIFIER_RULES_FOR_TEST, r as SchemaInput, s as detectSchemaKind, t as NormaliseOptions, u as normaliseSchema } from "../adapter-MiEFkRVV.mjs";
+export { JsonObject, NormaliseOptions, NormalisedSchema, SchemaInput, SchemaIoSide, SchemaKind, SchemaMeta, __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, isCodecSchema, normaliseSchema };

package/dist/core/adapter.mjs

@@ -80,6 +80,15 @@ function extractStandardSchemaVendor(input) {
 	const vendor = getProperty(getProperty(input, "~standard"), "vendor");
 	return typeof vendor === "string" && vendor.length > 0 ? vendor : void 0;
 }
+/**
+* The `io` parameter is propagated by `normaliseSchema` →
+* `normaliseZod4` so the renderer can select between the OUTPUT side
+* (default — historic behaviour) and the INPUT side of every
+* transform / pipe / codec. Pinning the option here lets the
+* consumer-facing `<SchemaComponent io="…">` and
+* `<SchemaView io="…">` props decide a single conversion direction
+* for the whole tree without a fork at every Zod call site.
+*/
 function callToJsonSchema(schema, io = "output") {
 	try {
 		return z.toJSONSchema(schema, {
@@ -282,6 +291,30 @@ function hasTrait(zod, traitName) {
 	return false;
 }
 /**
+* 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.
+*/
+function isCodecSchema(value) {
+	const zod = getProperty(value, "_zod");
+	if (!isObject(zod)) return false;
+	return hasTrait(zod, "$ZodCodec");
+}
+/**
 * Type guard narrowing `unknown` to a zero-argument function returning
 * `unknown`. The narrowing is genuinely structural: `typeof === "function"`
 * at runtime is exactly the membership test we want, and Zod has no
@@ -593,7 +626,8 @@ function classifyZodConversionError(err, schema) {
 const __CLASSIFIER_RULES_FOR_TEST = CLASSIFIER_RULES;
 function normaliseSchema(input, ref, options) {
 	const usesDiagnostics = options?.diagnostics !== void 0;
-	const cacheEligible = ref === void 0 && isObject(input) && !usesDiagnostics;
+	const nonDefaultIo = options?.io !== void 0 && options.io !== "output";
+	const cacheEligible = ref === void 0 && isObject(input) && !usesDiagnostics && !nonDefaultIo;
 	if (cacheEligible) {
 		const cached = schemaCache.get(input);
 		if (cached !== void 0) return cached;
@@ -602,7 +636,7 @@ function normaliseSchema(input, ref, options) {
 	let result;
 	switch (kind) {
 		case "zod4":
-			result = normaliseZod4(input, options?.diagnostics);
+			result = normaliseZod4(input, options?.diagnostics, options?.io);
 			break;
 		case "zod3":
 			result = normaliseZod3(input);
@@ -623,12 +657,12 @@ function normaliseSchema(input, ref, options) {
 	if (cacheEligible) schemaCache.set(input, result);
 	return result;
 }
-function normaliseZod4(input, diagnostics) {
+function normaliseZod4(input, diagnostics, io) {
 	const zod = getProperty(input, "_zod");
 	if (!isObject(zod)) throw new SchemaNormalisationError("Input is not a valid Zod 4 schema: `_zod` is present but is not an object. schema-components expected a Zod 4 schema produced by the `zod` package version 4 or later. See the Zod 4 migration guide at https://zod.dev/v4/migration or run: pnpm add zod@^4", input, "unsupported-schema");
 	if (!isObject(getProperty(zod, "def"))) throw new SchemaNormalisationError("Input is not a valid Zod 4 schema: `_zod.def` is missing or not an object. schema-components expected a Zod 4 schema produced by the `zod` package version 4 or later. See the Zod 4 migration guide at https://zod.dev/v4/migration or run: pnpm add zod@^4", input, "unsupported-schema");
 	screenPreConversion(input, diagnostics);
-	const jsonSchema = callToJsonSchema(input);
+	const jsonSchema = callToJsonSchema(input, io);
 	if (!isObject(jsonSchema)) throw new SchemaNormalisationError("z.toJSONSchema() did not produce an object", input, "invalid-zod");
 	return {
 		jsonSchema,
@@ -780,4 +814,4 @@ function extractRootMetaFromJson(jsonSchema) {
 	return Object.keys(meta).length > 0 ? meta : void 0;
 }
 //#endregion
-export { __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, normaliseSchema };
+export { __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, isCodecSchema, normaliseSchema };

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-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 
 //#region src/core/constraints.d.ts
 declare function extractStringConstraints(schema: Record<string, unknown>, diagnostics?: DiagnosticsOptions, pointer?: string): StringConstraints;

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-BS2kaUyE.mjs";
+import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-Cbwak-ZX.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-g_MCTQel.mjs";
+import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DQSIK4n1.mjs";
 export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError };

package/dist/core/formats.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 
 //#region src/core/formats.d.ts
 /**

package/dist/core/limits.d.mts

@@ -1,2 +1,2 @@
-import { i as MaxRefDepth, n as MAX_REF_DEPTH, r as MAX_RENDER_DEPTH, t as MAX_PATH_ITEM_REF_HOPS } from "../limits-Cw5QZND8.mjs";
+import { i as MaxRefDepth, n as MAX_REF_DEPTH, r as MAX_RENDER_DEPTH, t as MAX_PATH_ITEM_REF_HOPS } from "../limits-DJhgx5Ay.mjs";
 export { MAX_PATH_ITEM_REF_HOPS, MAX_REF_DEPTH, MAX_RENDER_DEPTH, MaxRefDepth };

package/dist/core/merge.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 
 //#region src/core/merge.d.ts
 /**

package/dist/core/normalise.d.mts

@@ -1,5 +1,5 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
-import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-BFTVLsdb.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-ZzL5R6cS.mjs";
 
 //#region src/core/normalise.d.ts
 type NodeTransform = (node: Record<string, unknown>) => Record<string, unknown>;

package/dist/core/ref.d.mts

@@ -1,2 +1,2 @@
-import { a as dereference, i as countDistinctRefs, n as RECURSIVE_ANCHOR_SENTINEL, o as findAnchor, r as RefOptions, s as resolveRef, t as ExternalResolver } from "../ref-DjLEKa_E.mjs";
+import { a as dereference, i as countDistinctRefs, n as RECURSIVE_ANCHOR_SENTINEL, o as findAnchor, r as RefOptions, s as resolveRef, t as ExternalResolver } from "../ref-TdeMfaV_.mjs";
 export { ExternalResolver, RECURSIVE_ANCHOR_SENTINEL, RefOptions, countDistinctRefs, dereference, findAnchor, resolveRef };

package/dist/core/ref.mjs

@@ -24,11 +24,10 @@ const RECURSIVE_ANCHOR_SENTINEL = "__recursive__";
 *   `false` → `{ not: {} }`      (never-valid schema)
 *
 * Used by {@link resolveRef} so callers that expect an object schema
-* can continue without per-call-site boolean handling.
-*
-* TODO(round7-integration): once Agent D widens the walker's resolved-
-* ref handling to dispatch through `walkSubSchema`, drop this
-* translation and surface the boolean directly.
+* can continue without per-call-site boolean handling. The walker's
+* sub-schema dispatch (`walkSubSchema`) handles booleans natively at
+* non-root positions; this translation covers the degenerate case
+* where a top-level `$ref` resolves to a boolean schema.
 */
 function booleanSchemaToObject(value) {
 	if (value) return {};

package/dist/core/renderer.d.mts

@@ -1,2 +1,2 @@
-import { a as HtmlRenderProps, c as RenderFunction, d as getHtmlRenderFn, f as getRenderFunction, h as typeToKey, i as HtmlRenderFunction, l as RenderProps, m as mergeResolvers, n as BaseFieldProps, o as HtmlResolver, p as mergeHtmlResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as buildRenderProps } from "../renderer-CXJ8y0qw.mjs";
+import { a as HtmlRenderProps, c as RenderFunction, d as getHtmlRenderFn, f as getRenderFunction, h as typeToKey, i as HtmlRenderFunction, l as RenderProps, m as mergeResolvers, n as BaseFieldProps, o as HtmlResolver, p as mergeHtmlResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as buildRenderProps } from "../renderer-Ul9taFYp.mjs";
 export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, buildRenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/swagger2.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 import { NodeTransform } from "./normalise.mjs";
 
 //#region src/core/swagger2.d.ts

package/dist/core/typeInference.d.mts

@@ -1,5 +1,5 @@
 import { d as FieldOverrides, u as FieldOverride } from "../types-BTB73MB8.mjs";
-import { i as MaxRefDepth } from "../limits-Cw5QZND8.mjs";
+import { i as MaxRefDepth } from "../limits-DJhgx5Ay.mjs";
 import { z } from "zod";
 
 //#region src/core/typeInference.d.ts

package/dist/core/version.d.mts

@@ -1,2 +1,2 @@
-import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-BFTVLsdb.mjs";
+import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-ZzL5R6cS.mjs";
 export { InferredDraft, JsonSchemaDialectInfo, JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2, matchJsonSchemaDraftUri, readJsonSchemaDialect };

package/dist/core/walkBuilders.d.mts

@@ -1,6 +1,6 @@
 import { A as UnknownField, D as StringField, b as NumberField, c as FieldBase, j as WalkedField, o as Editability, p as FileField, r as BooleanField, v as NullField, w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
-import { t as ExternalResolver } from "../ref-DjLEKa_E.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { t as ExternalResolver } from "../ref-TdeMfaV_.mjs";
 
 //#region src/core/walkBuilders.d.ts
 declare function getString(obj: Record<string, unknown>, key: string): string | undefined;

package/dist/{diagnostics-BS2kaUyE.d.mts → diagnostics-Cbwak-ZX.d.mts}

@@ -16,7 +16,7 @@
  * Machine-readable codes identifying each class of diagnostic.
  * Stable across releases — consumers can pattern-match on these.
  */
-type DiagnosticCode = "allof-conflict" | "assumed-draft" | "bare-exclusive-bound" | "conditional-fallback" | "cross-schema-relative-ref-unsupported" | "cyclic-path-item-ref" | "dependencies-conflict" | "dependent-required-invalid" | "depth-exceeded" | "discriminator-inconsistent" | "divisible-by-conflict" | "doc-not-object" | "dropped-swagger-feature" | "duplicate-body-parameter" | "duplicate-operation-id" | "dynamic-ref-degraded" | "enum-value-filtered" | "external-ref" | "invalid-const" | "invalid-id-fragment" | "keyword-out-of-draft" | "legacy-dependencies-split" | "legacy-dependencies-split-2019" | "non-json-media-type-fallback" | "parameter-missing-schema" | "path-item-ref-too-deep" | "path-webhook-name-collision" | "pattern-invalid" | "prototype-polluting-property" | "recursive-anchor-collision" | "relative-ref-resolved" | "required-non-string" | "schema-allof-incompatible" | "swagger-collection-format-dropped" | "swagger-cyclic-parameter-ref" | "swagger-invalid-file-parameter" | "swagger-malformed-oauth-flow" | "swagger-missing-consumes" | "swagger-missing-host" | "type-mismatch" | "type-negation-fallback" | "unknown-format" | "unknown-json-schema-dialect" | "unknown-keyword" | "unknown-openapi-version" | "unknown-parameter-location" | "unknown-security-scheme-type" | "unresolved-ref" | "unsupported-type" | "zod-codec-nested-output-only" | "zod-codec-output-only" | "zod-preprocess-output-only" | "zod-promise-nested-unwrap";
+type DiagnosticCode = "allof-conflict" | "assumed-draft" | "bare-exclusive-bound" | "conditional-fallback" | "cross-schema-relative-ref-unsupported" | "cyclic-header-ref" | "cyclic-link-ref" | "cyclic-parameter-ref" | "cyclic-path-item-ref" | "dependencies-conflict" | "dependent-required-invalid" | "depth-exceeded" | "discriminator-inconsistent" | "divisible-by-conflict" | "doc-not-object" | "dropped-swagger-feature" | "header-ref-too-deep" | "duplicate-body-parameter" | "duplicate-operation-id" | "dynamic-ref-degraded" | "enum-value-filtered" | "external-ref" | "invalid-const" | "invalid-id-fragment" | "keyword-out-of-draft" | "link-ref-too-deep" | "legacy-dependencies-split" | "legacy-dependencies-split-2019" | "non-json-media-type-fallback" | "parameter-missing-schema" | "parameter-ref-too-deep" | "path-item-ref-too-deep" | "path-webhook-name-collision" | "pattern-invalid" | "prototype-polluting-property" | "recursive-anchor-collision" | "relative-ref-resolved" | "required-non-string" | "schema-allof-incompatible" | "swagger-collection-format-dropped" | "swagger-cyclic-parameter-ref" | "swagger-invalid-file-parameter" | "swagger-malformed-oauth-flow" | "swagger-missing-consumes" | "swagger-missing-host" | "type-mismatch" | "type-negation-fallback" | "unknown-format" | "unknown-json-schema-dialect" | "unknown-keyword" | "unknown-openapi-version" | "unknown-parameter-location" | "unknown-security-scheme-type" | "unresolved-ref" | "unsupported-type" | "zod-codec-nested-output-only" | "zod-codec-output-only" | "zod-preprocess-output-only" | "zod-promise-nested-unwrap";
 /**
  * A single diagnostic emitted during schema processing.
  */

package/dist/html/a11y.d.mts

@@ -1,5 +1,5 @@
 import { j as WalkedField } from "../types-BTB73MB8.mjs";
-import { t as AllConstraints } from "../renderer-CXJ8y0qw.mjs";
+import { t as AllConstraints } from "../renderer-Ul9taFYp.mjs";
 import { HtmlAttributes, HtmlNode } from "./html.mjs";
 
 //#region src/html/a11y.d.ts

package/dist/html/renderToHtml.d.mts

@@ -1,5 +1,5 @@
 import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { o as HtmlResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/html/renderToHtml.d.ts
 /**

package/dist/html/renderToHtmlStream.d.mts

@@ -1,5 +1,5 @@
 import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { o as HtmlResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 interface StreamRenderOptions {

package/dist/html/renderers.d.mts

@@ -1,5 +1,5 @@
 import { dateInputType } from "../core/formats.mjs";
-import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { o as HtmlResolver } from "../renderer-Ul9taFYp.mjs";
 import { matchUnionOption } from "../core/unionMatch.mjs";
 
 //#region src/html/renderers.d.ts
@@ -9,16 +9,11 @@ import { matchUnionOption } from "../core/unionMatch.mjs";
  * `aria-controls`, `aria-labelledby`, and `htmlFor` references resolve
  * consistently across the React, sync-HTML, and streaming-HTML outputs.
  *
- * The wrapper tolerates an empty path here (returning `sc-`) for the
- * sole reason that a leaf renderer at the schema root would otherwise
- * throw — `renderToHtml(z.string())` is a rare but valid call shape.
- * Container renderers thread a non-empty path through `renderChild`, so
- * the empty-id fallback can never produce sibling collisions inside a
- * structured form.
- *
- * TODO(round7-integration): once `renderToHtml` always threads a stable
- * root path (e.g. `"$"`) into the leaf renderers, drop this wrapper and
- * call `fieldDomId` directly so the throw fires as designed.
+ * The wrapper tolerates an empty path here (returning `sc-`) so that
+ * a leaf renderer at the schema root — `renderToHtml(z.string())` — has
+ * a usable id without throwing. Container renderers always thread a
+ * non-empty path through `renderChild`, so the empty-id fallback can
+ * never produce sibling collisions inside a structured form.
  */
 declare function fieldId(path: string): string;
 /**
@@ -32,17 +27,11 @@ declare function fieldId(path: string): string;
  * Exported because `streamRenderers.ts` needs to derive identical ids
  * — the panel id on the `<div role="tabpanel">` must match the
  * `aria-controls` on every tab regardless of which pipeline rendered it.
- *
- * TODO(round7-integration): drop the empty-path branch once `renderToHtml`
- * threads a stable root path so `panelIdFor` can be called directly.
  */
 declare function panelId(path: string): string;
 /**
  * Tab id for tab `i` within a discriminated union at `path`. Mirror of
  * `panelId` above — see its comment.
- *
- * TODO(round7-integration): drop the empty-path branch once `renderToHtml`
- * threads a stable root path so `tabIdFor` can be called directly.
  */
 declare function tabId(path: string, i: number): string;
 declare const defaultHtmlResolver: HtmlResolver;