schema-components 1.23.0 → 1.26.0

package/dist/html/renderers.mjs

@@ -15,16 +15,11 @@ import { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAt
 * `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.
 */
 function fieldId(path) {
 	if (path.length === 0) return "sc-";
@@ -41,9 +36,6 @@ function fieldId(path) {
 * 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.
 */
 function panelId(path) {
 	if (path.length === 0) return `${fieldId(path)}-panel`;
@@ -52,9 +44,6 @@ function panelId(path) {
 /**
 * 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.
 */
 function tabId(path, i) {
 	if (path.length === 0) return `${fieldId(path)}-tab-${String(i)}`;

package/dist/html/streamRenderers.d.mts

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

package/dist/openapi/components.d.mts

@@ -1,5 +1,5 @@
 import { u as FieldOverride, w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { r as DiagnosticSink } from "../diagnostics-BS2kaUyE.mjs";
+import { r as DiagnosticSink } from "../diagnostics-Cbwak-ZX.mjs";
 import { InferParameterOverrides, InferRequestBodyFields, InferResponseFields } from "../core/typeInference.mjs";
 import { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";

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/openapi/parser.d.mts

@@ -1,5 +1,5 @@
 import { m as JsonObject } from "../types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {
@@ -87,17 +87,26 @@ interface LinkInfo {
 }
 declare function parseOpenApiDocument(doc: JsonObject): OpenApiDocument;
 declare function getSchema(parsed: OpenApiDocument, ref: string): JsonObject | undefined;
-declare function listOperations(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions): OperationInfo[];
+declare function listOperations(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions, seenIds?: Map<string, string>): OperationInfo[];
 declare function getParameters(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ParameterInfo[];
 declare function getRequestBody(parsed: OpenApiDocument, path: string, method: string): RequestBodyInfo | undefined;
 declare function getResponses(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ResponseInfo[];
 declare function getSecurityRequirements(parsed: OpenApiDocument, path: string, method: string): SecurityRequirement[];
 declare function getSecuritySchemes(parsed: OpenApiDocument): Map<string, SecurityScheme>;
 declare function getResponseHeaders(response: JsonObject, doc?: JsonObject, diagnostics?: DiagnosticsOptions): Map<string, HeaderInfo>;
-declare function listWebhooks(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions): WebhookInfo[];
+declare function listWebhooks(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions, seenIds?: Map<string, string>): WebhookInfo[];
+/**
+ * Enumerate every operation in the document — both the `paths` map and
+ * the OpenAPI 3.1 `webhooks` map — sharing a single `seenIds` cache so
+ * cross-list `operationId` collisions surface the same way as same-list
+ * collisions. Returns the path-operation list followed by webhook
+ * operations (flattened); callers that need the structured webhook
+ * grouping should call `listWebhooks` directly.
+ */
+declare function listAllOperations(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions): OperationInfo[];
 declare function getExternalDocs(obj: JsonObject): ExternalDocs | undefined;
 declare function getXmlInfo(schema: JsonObject): XmlInfo | undefined;
 declare function listCallbacks(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): CallbackInfo[];
 declare function getLinks(parsed: OpenApiDocument, path: string, method: string, statusCode: string, diagnostics?: DiagnosticsOptions): LinkInfo[];
 //#endregion
-export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };
+export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listAllOperations, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };

package/dist/openapi/parser.mjs

@@ -96,11 +96,39 @@ function lookupPathItem(parsed, path) {
 	if (resolved !== void 0) return resolved;
 	return resolvePathItem(parsed, getProperty(getProperty(parsed.doc, "webhooks"), path));
 }
-function listOperations(parsed, diagnostics) {
+/**
+* Record an `operationId` against a shared `seenIds` map and emit a
+* `duplicate-operation-id` diagnostic when a subsequent location reuses
+* the same identifier. Returns the original `operationId` so the caller
+* can pass the value straight onto its `OperationInfo`.
+*
+* When the same map is threaded through `listOperations` and
+* `listWebhooks` (see `listAllOperations`), cross-list collisions
+* between a path operation and a webhook operation surface as the same
+* diagnostic class as same-list collisions.
+*/
+function recordOperationId(operationId, location, pointer, seenIds, diagnostics) {
+	if (operationId === void 0) return;
+	const firstSeenAt = seenIds.get(operationId);
+	if (firstSeenAt !== void 0) {
+		emitDiagnostic(diagnostics, {
+			code: "duplicate-operation-id",
+			message: `operationId "${operationId}" is declared more than once (first at ${firstSeenAt}, again at ${location})`,
+			pointer,
+			detail: {
+				operationId,
+				firstSeenAt,
+				duplicateAt: location
+			}
+		});
+		return;
+	}
+	seenIds.set(operationId, location);
+}
+function listOperations(parsed, diagnostics, seenIds = /* @__PURE__ */ new Map()) {
 	const operations = [];
 	const paths = getProperty(parsed.doc, "paths");
 	if (!isObject(paths)) return operations;
-	const seenIds = /* @__PURE__ */ new Map();
 	for (const [path, rawPathItem] of Object.entries(paths)) {
 		const pathItem = resolvePathItem(parsed, rawPathItem, diagnostics);
 		if (pathItem === void 0) continue;
@@ -108,20 +136,7 @@ function listOperations(parsed, diagnostics) {
 			const operation = getProperty(pathItem, method);
 			if (!isObject(operation)) continue;
 			const operationId = getString(operation, "operationId");
-			if (operationId !== void 0) {
-				const firstSeenAt = seenIds.get(operationId);
-				if (firstSeenAt !== void 0) emitDiagnostic(diagnostics, {
-					code: "duplicate-operation-id",
-					message: `operationId "${operationId}" is declared more than once (first at ${firstSeenAt}, again at ${method.toUpperCase()} ${path})`,
-					pointer: `/paths/${jsonPointerEscape(path)}/${method}/operationId`,
-					detail: {
-						operationId,
-						firstSeenAt,
-						duplicateAt: `${method.toUpperCase()} ${path}`
-					}
-				});
-				else seenIds.set(operationId, `${method.toUpperCase()} ${path}`);
-			}
+			recordOperationId(operationId, `${method.toUpperCase()} ${path}`, `/paths/${jsonPointerEscape(path)}/${method}/operationId`, seenIds, diagnostics);
 			operations.push({
 				path,
 				method,
@@ -179,26 +194,21 @@ function extractParameterList(doc, parameters, pointerBase, diagnostics) {
 * length — a Reference Object whose target is itself a Reference Object
 * is legal. `resolveRefChain` centralises cycle and depth-cap protection.
 *
-* Cycles and over-deep chains reuse the existing `cyclic-path-item-ref`
-* and `path-item-ref-too-deep` diagnostic codes with a
-* `detail.kind: "<node-kind>"` discriminator (e.g. `"parameter"`,
-* `"header"`, `"link"`). There is no dedicated code per node kind in the
-* current `DiagnosticCode` union; consumers filter by `detail.kind` when
-* they care to distinguish the source.
-*
-* TODO(round7-integration): consider adding dedicated `cyclic-*-ref` /
-* `*-ref-too-deep` codes per node kind to `core/diagnostics.ts` so the
-* kind discriminator on `detail` is not needed. The existing Swagger
-* 2.0 path already uses a dedicated `swagger-cyclic-parameter-ref` for
-* the equivalent failure mode.
+* Cycles and over-deep chains emit a dedicated diagnostic code per node
+* kind (`cyclic-parameter-ref`, `parameter-ref-too-deep`, and the
+* `header` / `link` equivalents), mirroring the existing
+* `swagger-cyclic-parameter-ref` precedent so consumers can pattern-match
+* directly on the code instead of filtering by `detail.kind`.
 */
 function resolveReferenceObjectChain(doc, node, kind, diagnostics) {
 	const kindLabel = kind === "parameter" ? "Parameter Object" : kind === "header" ? "Header Object" : "Link Object";
+	const cyclicCode = kind === "parameter" ? "cyclic-parameter-ref" : kind === "header" ? "cyclic-header-ref" : "cyclic-link-ref";
+	const tooDeepCode = kind === "parameter" ? "parameter-ref-too-deep" : kind === "header" ? "header-ref-too-deep" : "link-ref-too-deep";
 	return resolveRefChain(node, {
 		lookup: (ref) => ref.startsWith("#/") ? resolveRefInDoc(doc, ref) : void 0,
 		onCycle: (ref) => {
 			emitDiagnostic(diagnostics, {
-				code: "cyclic-path-item-ref",
+				code: cyclicCode,
 				message: `Cyclic ${kindLabel} $ref "${ref}"`,
 				pointer: ref,
 				detail: {
@@ -209,7 +219,7 @@ function resolveReferenceObjectChain(doc, node, kind, diagnostics) {
 		},
 		onDepthExceeded: (ref) => {
 			emitDiagnostic(diagnostics, {
-				code: "path-item-ref-too-deep",
+				code: tooDeepCode,
 				message: `${kindLabel} $ref chain exceeded the hop cap starting from "${ref}"`,
 				pointer: ref,
 				detail: {
@@ -451,7 +461,7 @@ function getResponseHeaders(response, doc, diagnostics) {
 	}
 	return result;
 }
-function listWebhooks(parsed, diagnostics) {
+function listWebhooks(parsed, diagnostics, seenIds = /* @__PURE__ */ new Map()) {
 	const result = [];
 	const webhooks = getProperty(parsed.doc, "webhooks");
 	if (!isObject(webhooks)) return result;
@@ -462,10 +472,12 @@ function listWebhooks(parsed, diagnostics) {
 		for (const method of HTTP_METHODS) {
 			const operation = getProperty(hookItem, method);
 			if (!isObject(operation)) continue;
+			const operationId = getString(operation, "operationId");
+			recordOperationId(operationId, `${method.toUpperCase()} webhook:${name}`, `/webhooks/${jsonPointerEscape(name)}/${method}/operationId`, seenIds, diagnostics);
 			operations.push({
 				path: name,
 				method,
-				operationId: getString(operation, "operationId"),
+				operationId,
 				summary: getString(operation, "summary"),
 				description: getString(operation, "description"),
 				deprecated: getProperty(operation, "deprecated") === true,
@@ -479,6 +491,20 @@ function listWebhooks(parsed, diagnostics) {
 	}
 	return result;
 }
+/**
+* Enumerate every operation in the document — both the `paths` map and
+* the OpenAPI 3.1 `webhooks` map — sharing a single `seenIds` cache so
+* cross-list `operationId` collisions surface the same way as same-list
+* collisions. Returns the path-operation list followed by webhook
+* operations (flattened); callers that need the structured webhook
+* grouping should call `listWebhooks` directly.
+*/
+function listAllOperations(parsed, diagnostics) {
+	const seenIds = /* @__PURE__ */ new Map();
+	const pathOps = listOperations(parsed, diagnostics, seenIds);
+	const webhookOps = listWebhooks(parsed, diagnostics, seenIds).flatMap((w) => w.operations);
+	return [...pathOps, ...webhookOps];
+}
 function getExternalDocs(obj) {
 	const docs = getProperty(obj, "externalDocs");
 	if (!isObject(docs)) return void 0;
@@ -559,4 +585,4 @@ function getLinks(parsed, path, method, statusCode, diagnostics) {
 	return result;
 }
 //#endregion
-export { getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };
+export { getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listAllOperations, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };

package/dist/openapi/resolve.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BS2kaUyE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequestBody } from "./parser.mjs";
 
 //#region src/openapi/resolve.d.ts

package/dist/openapi/resolve.mjs

@@ -5,7 +5,7 @@ import { isPrototypePollutingKey } from "../core/uri.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
 import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-DCYp06Sr.mjs";
 import { resolveRefChain } from "../core/refChain.mjs";
-import { getParameters, getRequestBody, getResponses, listOperations, listWebhooks, parseOpenApiDocument } from "./parser.mjs";
+import { getParameters, getRequestBody, getResponses, listAllOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
 * OpenAPI document resolution and caching.
@@ -325,7 +325,7 @@ function extractPathItemInfo(pathItem) {
 */
 function resolveOperationFromParsed(parsed, path, method, diagnostics) {
 	const pathItemNode = lookupPathItemNode(parsed, path, diagnostics);
-	const operation = [...listOperations(parsed), ...listWebhooks(parsed).flatMap((w) => w.operations)].find((op) => op.path === path && op.method === method);
+	const operation = listAllOperations(parsed).find((op) => op.path === path && op.method === method);
 	if (operation === void 0) throw new Error(`Operation not found: ${method.toUpperCase()} ${path}`);
 	if (pathItemNode === void 0) throw new Error(`Path item missing for ${method.toUpperCase()} ${path}`);
 	return {

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-BS2kaUyE.mjs";
-import { t as SchemaError } from "../errors-g_MCTQel.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-CXJ8y0qw.mjs";
+import { t as Diagnostic } from "../diagnostics-Cbwak-ZX.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
-   * round-7 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 };