schema-components 1.24.0 → 1.26.1

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-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";
-/**
- * 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/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/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/normalise.d.mts

@@ -1,5 +1,5 @@
 import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
-import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-BFTVLsdb.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-DCDuswPe.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/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/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-Cbwak-ZX.mjs";
-import { t as ExternalResolver } from "../ref-DCDuswPe.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/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

package/dist/html/streamRenderers.d.mts

@@ -1,6 +1,6 @@
 import { j as WalkedField } from "../types-BTB73MB8.mjs";
 import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
-import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { o as HtmlResolver } from "../renderer-Ul9taFYp.mjs";
 import { HtmlElement } from "./html.mjs";
 
 //#region src/html/streamRenderers.d.ts

package/dist/openapi/components.mjs

@@ -2,15 +2,15 @@ import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { emitDiagnostic } from "../core/diagnostics.mjs";
 import { extractRootMetaFromJson } from "../core/adapter.mjs";
 import { walk } from "../core/walker.mjs";
+import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { ApiCallbacks } from "./ApiCallbacks.mjs";
 import { ApiLinks } from "./ApiLinks.mjs";
 import { ApiResponseHeaders } from "./ApiResponseHeaders.mjs";
 import { ApiSecurity } from "./ApiSecurity.mjs";
 import { getExternalDocs, getLinks, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listWebhooks } from "./parser.mjs";
-import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { getParsed, resolveOperationFromParsed, resolveParametersFromParsed, resolveRequestBodyFromParsed, resolveResponseFromParsed, toDoc } from "./resolve.mjs";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useId } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/openapi/components.tsx
 /**
 * OpenAPI React components with type-safe generics.

package/dist/react/SchemaComponent.d.mts

@@ -1,11 +1,12 @@
 import { d as FieldOverrides, j as WalkedField, u as FieldOverride, w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { t as Diagnostic } from "../diagnostics-Cbwak-ZX.mjs";
-import { t as SchemaError } from "../errors-g_MCTQel.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { i as SchemaIoSide } from "../adapter-MiEFkRVV.mjs";
+import { t as SchemaError } from "../errors-DQSIK4n1.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 import { FromJSONSchema, FromJSONSchemaMode, IsSwagger2Doc, PathOfType, RejectUnrepresentableZod, ResolveOpenAPIRef, TypeAtPath, __SchemaInferenceFellBack } from "../core/typeInference.mjs";
 import { z } from "zod";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/react/SchemaComponent.d.ts
 /**
@@ -65,28 +66,36 @@ type InferSchemaValue<T, Ref extends string | undefined, Mode extends FromJSONSc
 type NarrowAtPath<V, P extends string | undefined> = P extends string ? TypeAtPath<V, P> : V;
 /**
  * Public alias mapping a schema input to the rendered value type.
- * Use to narrow a runtime callback inside the body of an `onChange`
- * handler:
- *
- * ```tsx
- * <SchemaComponent
- *   schema={userSchema}
- *   onChange={(v) => {
- *     const user = v as InferredOutputValue<typeof userSchema>;
- *     // ...narrowly typed access on `user`
- *   }}
- * />
- * ```
  *
- * The `onChange` argument is typed `unknown` at the props boundary
- * because the walker propagates `unknown` values through the render
- * pipeline. Narrowing on the consumer side is therefore an explicit
- * step and never a silent contract gap.
+ * Picks the OUTPUT side (server → client) of every transform / pipe /
+ * codec. For an `<SchemaComponent io="output">` or `<SchemaView
+ * io="output">` (both defaults), this is the inferred shape of
+ * `value` and the parameter of `onChange`.
  */
 type InferredOutputValue<T, Ref extends string | undefined = undefined, P extends string | undefined = undefined> = NarrowAtPath<InferSchemaValue<T, Ref, "output">, P>;
-/** Companion to {@link InferredOutputValue} for `"input"`-mode shapes. */
+/**
+ * Companion to {@link InferredOutputValue} for `"input"`-mode shapes.
+ *
+ * Picks the INPUT side (client → server) of every transform / pipe /
+ * codec. Surfaces as the inferred shape of `value` / `onChange` when
+ * a consumer renders `<SchemaComponent io="input">`. For JSON Schema
+ * inputs with `readOnly`/`writeOnly` annotations, the INPUT mode
+ * omits properties marked `readOnly: true`.
+ */
 type InferredInputValue<T, Ref extends string | undefined = undefined, P extends string | undefined = undefined> = NarrowAtPath<InferSchemaValue<T, Ref, "input">, P>;
-interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined, P extends string | undefined = undefined> {
+/**
+ * Resolve the schema-driven value type for either I/O direction.
+ *
+ * Thin convenience over {@link InferredOutputValue} /
+ * {@link InferredInputValue} so consumers that decide between the
+ * two at the type level (e.g. a generic wrapper component) can pass
+ * the chosen direction as a type argument rather than branch on it
+ * with conditional types. Falls back to `unknown` when the schema's
+ * value type cannot be statically inferred, identical to the
+ * underlying helpers.
+ */
+type InferredValue<T, Ref extends string | undefined = undefined, P extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> = NarrowAtPath<InferSchemaValue<T, Ref, Mode>, P>;
+interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined, P extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
   /**
    * Zod schema, JSON Schema object, or OpenAPI document.
    *
@@ -116,56 +125,57 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
    */
   path?: P;
   /**
-   * Current value to render.
+   * Which side of every transform / pipe / codec to render.
    *
-   * TYPE BOUNDARY NOTE: kept as `unknown` at the props boundary so
-   * existing call sites — including legitimate edge-case fixtures
-   * that pass deliberately invalid values to exercise fallback code
-   * paths — continue to typecheck. Use {@link InferredOutputValue}
-   * to narrow on the consumer side:
+   * - `"output"` (default) — renderer draws the OUTPUT side of the
+   *   schema. For a `z.codec(z.string(), z.number(), …)` chain
+   *   this renders a number input. `value` and `onChange` therefore
+   *   carry the OUTPUT shape, and `validate` runs `safeEncode`
+   *   (the reverse direction) so user-supplied OUTPUT values are
+   *   validated against the codec.
+   * - `"input"` — renderer draws the INPUT side instead. For the
+   *   same codec this renders a string input, `value` and
+   *   `onChange` carry the INPUT shape, and `validate` runs
+   *   `safeParse` (the forward direction).
+   *
+   * The choice is propagated through `normaliseSchema` →
+   * `normaliseZod4` → `z.toJSONSchema(..., { io })` so a single
+   * source of truth drives both the rendered JSON Schema shape and
+   * the validation direction. Has no effect for plain JSON Schema
+   * or OpenAPI inputs — those advertise a single canonical shape.
+   */
+  io?: Mode;
+  /**
+   * Current value to render. Typed against `InferSchemaValue<T,
+   * Ref, Mode>` so the prop tracks the schema's inferred shape for
+   * the chosen `io` direction. Narrowed further by `P` when a
+   * `path` is supplied (currently type-level only — see the JSDoc
+   * on {@link SchemaComponentProps.path}).
+   *
+   * Falls back to `unknown` when the schema's value type cannot be
+   * statically inferred (runtime `Record<string, unknown>` JSON
+   * Schemas, OpenAPI documents without a ref, etc.), so untyped
+   * call sites still compile.
+   *
+   * Use {@link InferredOutputValue} or {@link InferredInputValue}
+   * to narrow a value declared at the call site:
    *
    * ```tsx
    * const user: InferredOutputValue<typeof userSchema> = { ... };
    * <SchemaComponent schema={userSchema} value={user} readOnly />
    * ```
-   *
-   * The narrowing is fully expressible through the helper alias
-   * without forcing every existing caller to update their value
-   * shapes for `exactOptionalPropertyTypes` / enum literal widening.
-   *
-   * TODO(round7-integration): promote to
-   * `NarrowAtPath<InferSchemaValue<T, Ref, "output">, P>` once the
-   * test fixtures (headless union, discriminated union,
-   * schemaview equivalence, type-inference issue fixes) are
-   * migrated to either narrow their fixtures or accept the loose
-   * boundary. The retype cascades through call sites that
-   * intentionally pass invalid values to exercise fallback paths
-   * (`value={undefined}`, off-discriminator values, etc.) and
-   * through fixtures whose enum/literal types widen at the call
-   * site. Coordinated migration is required.
    */
-  value?: unknown;
+  value?: NarrowAtPath<InferSchemaValue<T, Ref, Mode>, P>;
   /**
-   * Called when the value changes (editable fields).
+   * Called when the value changes (editable fields). The parameter
+   * shares the same shape as {@link SchemaComponentProps.value} so
+   * a controlled component can round-trip the value through React
+   * state without re-shaping.
    *
-   * TYPE BOUNDARY NOTE: the parameter is typed `unknown` rather
-   * than the inferred input shape because the walker pipeline only
-   * propagates `unknown` values and a narrow contravariant callback
-   * signature is not assignable from an `unknown`-emitting source
-   * without an unsafe boundary cast. The {@link InferredInputValue}
-   * alias is the recommended way for callers to narrow on the
-   * consumer side — `onChange={(v) => { const u = v as InferredInputValue<typeof schema>; ... }}`.
-   *
-   * TODO(round7-integration): promote to
-   * `(value: NarrowAtPath<InferSchemaValue<T, Ref, "input">, P>) => void`
-   * alongside the `value` retype. The contravariant boundary needs
-   * an internal cast at the only call site (`onChange?.(nextValue)`
-   * in `handleChange`) that the project's no-`as` rule disallows
-   * without explicit justification. The right place to introduce
-   * the cast is a tiny typed boundary helper accompanied by the
-   * fixture migration noted above.
+   * Falls back to `unknown` for schemas whose value type cannot be
+   * statically inferred — see {@link SchemaComponentProps.value}.
    */
-  onChange?: (value: unknown) => void;
+  onChange?: (value: NarrowAtPath<InferSchemaValue<T, Ref, Mode>, P>) => void;
   /** Run schema.safeParse() on change and surface errors via onValidationError. */
   validate?: boolean;
   /** Called with the ZodError when validation fails. */
@@ -196,7 +206,7 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
    */
   idPrefix?: string;
 }
-declare function SchemaComponent<T = unknown, Ref extends string | undefined = undefined, P extends string | undefined = undefined>(props: SchemaComponentProps<T, Ref, P>): ReactNode;
+declare function SchemaComponent<T = unknown, Ref extends string | undefined = undefined, P extends string | undefined = undefined, Mode extends SchemaIoSide = "output">(props: SchemaComponentProps<T, Ref, P, Mode>): ReactNode;
 /**
  * Append a child path suffix to a parent path. When the suffix is omitted
  * (e.g. transparent wrappers like union options), the parent path is
@@ -255,4 +265,4 @@ declare function SchemaField<T = unknown, Ref extends string | undefined = undef
   onValidationError
 }: SchemaFieldProps<T, Ref, P>): ReactNode;
 //#endregion
-export { InferredInputValue, InferredOutputValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, WidgetMap, joinPath, registerWidget, renderField, sanitisePrefix };
+export { InferredInputValue, InferredOutputValue, InferredValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, WidgetMap, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaComponent.mjs

@@ -1,15 +1,15 @@
 "use client";
-import { getProperty, isObject, toRecordOrUndefined } from "../core/guards.mjs";
+import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import "../core/limits.mjs";
 import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
-import { normaliseSchema } from "../core/adapter.mjs";
+import { isCodecSchema, normaliseSchema } from "../core/adapter.mjs";
 import { buildRenderProps, getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { resolvePath, resolveValue, setNestedValue } from "./fieldPath.mjs";
 import { z } from "zod";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { createContext, isValidElement, useCallback, useContext, useId, useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/SchemaComponent.tsx
 /**
 * <SchemaComponent> — renders UI from Zod, JSON Schema, or OpenAPI schemas.
@@ -48,7 +48,7 @@ function registerWidget(name, render) {
 	globalWidgets.set(name, render);
 }
 function SchemaComponent(props) {
-	const { schema: schemaInput, ref: refInput, value, onChange, validate, onValidationError, onError, onDiagnostic, strict, fields, meta: componentMeta, readOnly, writeOnly, description, widgets: instanceWidgets, idPrefix } = props;
+	const { schema: schemaInput, ref: refInput, io, value, onChange, validate, onValidationError, onError, onDiagnostic, strict, fields, meta: componentMeta, readOnly, writeOnly, description, widgets: instanceWidgets, idPrefix } = props;
 	const userResolver = useContext(UserResolverContext);
 	const contextWidgets = useContext(WidgetsContext);
 	const generatedId = useId();
@@ -74,7 +74,10 @@ function SchemaComponent(props) {
 	let rootMeta;
 	let rootDocument;
 	try {
-		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 ? { diagnostics } : void 0);
+		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 || io !== void 0 ? {
+			...diagnostics !== void 0 ? { diagnostics } : {},
+			...io !== void 0 ? { io } : {}
+		} : void 0);
 		jsonSchema = normalised.jsonSchema;
 		zodSchema = normalised.zodSchema;
 		rootMeta = normalised.rootMeta;
@@ -92,7 +95,7 @@ function SchemaComponent(props) {
 		if (validate) {
 			let error;
 			try {
-				error = runValidation(zodSchema, jsonSchema, nextValue, onDiagnostic);
+				error = runValidation(zodSchema, jsonSchema, nextValue, io, onDiagnostic);
 			} catch (err) {
 				const normalised = err instanceof SchemaNormalisationError ? err : new SchemaNormalisationError(err instanceof Error ? err.message : "Fallback validation failed", schemaInput, "zod-conversion-failed", void 0, err);
 				if (onError !== void 0) {
@@ -106,11 +109,12 @@ function SchemaComponent(props) {
 				dispatchFieldErrors(fieldsRecord, error);
 			}
 		}
-		onChange?.(nextValue);
+		if (onChange !== void 0) onChange(nextValue);
 	}, [
 		validate,
 		zodSchema,
 		jsonSchema,
+		io,
 		onChange,
 		onValidationError,
 		fieldsRecord,
@@ -174,10 +178,19 @@ function sanitisePrefix(value) {
 * to surface somewhere — diagnostics if the consumer opted in, an error
 * otherwise — so the caller can route it through `onError` / an error
 * boundary rather than have validation quietly disappear.
+*
+* The `io` argument mirrors the prop on `<SchemaComponent>` and
+* `<SchemaView>`. It determines which Zod entry point validates a
+* codec: `safeEncode` for the OUTPUT side (the default, matching the
+* renderer's default direction), `safeParse` for the INPUT side. For
+* non-codec schemas the choice is irrelevant — both `safeEncode` and
+* `safeParse` behave identically — so `safeParse` is used
+* unconditionally.
 */
-function runValidation(zodSchema, jsonSchema, value, onDiagnostic) {
+function runValidation(zodSchema, jsonSchema, value, io, onDiagnostic) {
 	if (zodSchema !== void 0 && isObject(zodSchema)) {
-		const validateFn = isCodecSchema(zodSchema) ? zodSchema.safeEncode : zodSchema.safeParse;
+		const resolvedIo = io ?? "output";
+		const validateFn = isCodecSchema(zodSchema) && resolvedIo === "output" ? zodSchema.safeEncode : zodSchema.safeParse;
 		if (isCallable(validateFn)) {
 			const result = validateFn(value);
 			if (isObject(result) && "success" in result && result.success !== true) return result.error;
@@ -270,7 +283,7 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 	const handleChange = useCallback((nextFieldValue) => {
 		const newRootValue = setNestedValue(value, path, nextFieldValue);
 		if (validate) {
-			const error = runValidation(zodSchema, jsonSchema, newRootValue);
+			const error = runValidation(zodSchema, jsonSchema, newRootValue, void 0);
 			if (error !== void 0) onValidationError?.(error);
 		}
 		onChange?.(newRootValue);
@@ -330,26 +343,5 @@ function isFieldErrorCallback(value) {
 function isCallable(value) {
 	return typeof value === "function";
 }
-/**
-* True when `value` is a Zod schema implemented as a codec.
-*
-* Detection looks for `"$ZodCodec"` in the schema's `_zod.traits`
-* Set, mirroring the runtime detection used inside
-* `core/adapter.ts` (`isCodecSchema` there) and Zod's own
-* `isTransforming` helper. Duplicated here rather than imported
-* because adapter.ts does not export the helper and is outside this
-* fix-cycle's owned files.
-*
-* TODO(round7-integration): replace with an `import` once
-* `isCodecSchema` is exported from `core/adapter.ts` (or promoted to
-* `core/guards.ts`) by a coordinating commit.
-*/
-function isCodecSchema(value) {
-	const zod = getProperty(value, "_zod");
-	if (!isObject(zod)) return false;
-	const traits = zod.traits;
-	if (traits instanceof Set) return traits.has("$ZodCodec");
-	return false;
-}
 //#endregion
 export { SchemaComponent, SchemaField, SchemaProvider, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaView.d.mts

@@ -1,37 +1,40 @@
 import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { t as Diagnostic } from "../diagnostics-Cbwak-ZX.mjs";
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { i as SchemaIoSide } from "../adapter-MiEFkRVV.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { WidgetMap } from "./SchemaComponent.mjs";
+import { InferredValue, WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/SchemaView.d.ts
-interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefined> {
+interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
   /**
    * Zod schema, JSON Schema object, or OpenAPI document.
    *
    * Subject to the same compile-time rejection of unrepresentable
-   * Zod 4 types as {@link SchemaComponentProps.schema} — see
+   * Zod 4 types as the `schema` prop on `<SchemaComponent>` — see
    * {@link RejectUnrepresentableZod}.
    */
   schema: RejectUnrepresentableZod<T>;
   /** For OpenAPI: a ref string like "#/components/schemas/User". */
   ref?: Ref;
   /**
-   * Current value to render.
-   *
-   * TYPE BOUNDARY NOTE: mirrors `SchemaComponentProps.value` — kept
-   * as `unknown` so the same boundary holds for both the editable
-   * (`SchemaComponent`) and read-only (`SchemaView`) entry points.
-   * The {@link InferredOutputValue} alias is the recommended way
-   * for callers to narrow on the consumer side.
-   *
-   * TODO(round7-integration): promote to
-   * `InferSchemaValue<T, Ref, "output">` alongside the matching
-   * `SchemaComponent` change. See the type-boundary note on
-   * `SchemaComponentProps.value` for the migration coordination.
+   * Which side of every transform / pipe / codec to render. Mirrors
+   * `<SchemaComponent io>`. Defaults to `"output"` — the inferred
+   * shape consumers receive from the server. Switch to `"input"`
+   * to render the INPUT side (omits `readOnly` properties for
+   * JSON Schema inputs, picks the input half of a `z.codec(...)`).
+   * Has no effect for plain JSON Schema or OpenAPI inputs without
+   * codec/transform constructs.
+   */
+  io?: Mode;
+  /**
+   * Current value to render. Typed against `InferSchemaValue<T,
+   * Ref, Mode>` so the prop tracks the schema's inferred shape for
+   * the chosen `io` direction. Falls back to `unknown` for runtime
+   * schemas where the value type cannot be statically inferred.
    */
-  value?: unknown;
+  value?: InferredValue<T, Ref, undefined, Mode>;
   /** Per-field meta overrides. */
   fields?: Record<string, unknown>;
   /** Meta overrides applied to the root schema. */
@@ -64,9 +67,10 @@ interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefine
  * Always renders in read-only mode. For editable forms, use
  * `<SchemaComponent>` with `"use client"`.
  */
-declare function SchemaView<T = unknown, Ref extends string | undefined = undefined>({
+declare function SchemaView<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output">({
   schema: schemaInput,
   ref: refInput,
+  io,
   value,
   fields,
   meta: componentMeta,
@@ -76,6 +80,6 @@ declare function SchemaView<T = unknown, Ref extends string | undefined = undefi
   onDiagnostic,
   strict,
   idPrefix
-}: SchemaViewProps<T, Ref>): ReactNode;
+}: SchemaViewProps<T, Ref, Mode>): ReactNode;
 //#endregion
 export { SchemaView, SchemaViewProps };

package/dist/react/SchemaView.mjs

@@ -5,8 +5,8 @@ import { buildRenderProps, getRenderFunction, mergeResolvers } from "../core/ren
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { joinPath, sanitisePrefix } from "./SchemaComponent.mjs";
-import { jsx } from "react/jsx-runtime";
 import { createElement, isValidElement, useId } from "react";
+import { jsx } from "react/jsx-runtime";
 //#region src/react/SchemaView.tsx
 /**
 * React Server Component for read-only schema rendering.
@@ -42,7 +42,7 @@ import { createElement, isValidElement, useId } from "react";
 * Always renders in read-only mode. For editable forms, use
 * `<SchemaComponent>` with `"use client"`.
 */
-function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: componentMeta, description, resolver, widgets, onDiagnostic, strict, idPrefix }) {
+function SchemaView({ schema: schemaInput, ref: refInput, io, value, fields, meta: componentMeta, description, resolver, widgets, onDiagnostic, strict, idPrefix }) {
 	const generatedId = useId();
 	const rootPath = idPrefix ?? sanitisePrefix(generatedId);
 	const mergedMeta = {
@@ -58,7 +58,10 @@ function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: c
 	let rootMeta;
 	let rootDocument;
 	try {
-		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 ? { diagnostics } : void 0);
+		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 || io !== void 0 ? {
+			...diagnostics !== void 0 ? { diagnostics } : {},
+			...io !== void 0 ? { io } : {}
+		} : void 0);
 		jsonSchema = normalised.jsonSchema;
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;

package/dist/react/headless.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/react/headless.d.ts
 /**

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
 import { j as WalkedField } from "../types-BTB73MB8.mjs";
-import { l as RenderProps } from "../renderer-CXJ8y0qw.mjs";
+import { l as RenderProps } from "../renderer-Ul9taFYp.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/headlessRenderers.d.ts

package/dist/react/headlessRenderers.mjs

@@ -7,8 +7,8 @@ import { fieldDomId, panelIdFor, tabIdFor } from "../core/idPath.mjs";
 import { matchUnionOption, resolveDiscriminatedActive } from "../core/unionMatch.mjs";
 import { displayJsonValue } from "../core/walkBuilders.mjs";
 import { buildAriaAttrs } from "./a11y.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { isValidElement, useCallback, useEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/headlessRenderers.tsx
 /**
 * Headless renderer functions — one per schema type.

package/dist/themes/mantine.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/themes/mantine.d.ts
 /**

package/dist/themes/mui.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/themes/mui.d.ts
 /**

package/dist/themes/mui.mjs

@@ -2,8 +2,8 @@ import { isObject } from "../core/guards.mjs";
 import { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { inputId, toReactNode } from "../react/headlessRenderers.mjs";
 import { headlessResolver } from "../react/headless.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { isValidElement } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/themes/mui.tsx
 function ariaRequired(tree) {
 	return { required: tree.isOptional === false };

package/dist/themes/radix.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/themes/radix.d.ts
 /**

package/dist/themes/shadcn.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { r as ComponentResolver } from "../renderer-Ul9taFYp.mjs";
 
 //#region src/themes/shadcn.d.ts
 declare const shadcnResolver: ComponentResolver;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "schema-components",
-    "version": "1.24.0",
+    "version": "1.26.1",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
     "exports": {
@@ -40,6 +40,7 @@
         "_test:e2e": "vitest run --project=e2e",
         "_test:coverage": "vitest run --project=unit --coverage",
         "_build": "tsdown && cp src/html/styles.css dist/html/styles.css",
+        "_typedoc": "typedoc",
         "typecheck": "turbo run _typecheck",
         "lint": "turbo run _lint",
         "lint:fix": "turbo run _lint:fix",
@@ -47,7 +48,8 @@
         "test:coverage": "turbo run _test:coverage",
         "check": "turbo run _check",
         "validate": "turbo run _validate",
-        "build": "turbo run _build"
+        "build": "turbo run _build",
+        "typedoc": "turbo run _typedoc"
     },
     "keywords": [
         "react",
@@ -91,6 +93,8 @@
         "react-dom": "19.2.6",
         "tsdown": "0.22.0",
         "tslib": "2.8.1",
+        "typedoc": "0.28.19",
+        "typedoc-plugin-missing-exports": "4.1.3",
         "typescript": "6.0.3",
         "typescript-eslint": "8.59.2",
         "vitest": "4.1.5",