schema-components 1.29.0 → 2.0.0

package/dist/openapi/resolve.d.mts

@@ -1,5 +1,5 @@
-import { i as DiagnosticsOptions } from "../diagnostics-ByEzkjrA.mjs";
-import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequestBody } from "./parser.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { OpenApiDocument, OperationInfo, ParameterInfo, RequestBodyInfo, ResponseInfo } from "./parser.mjs";
 
 //#region src/openapi/resolve.d.ts
 /**
@@ -11,7 +11,7 @@ import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequest
  * keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
  * `discriminator`, and Swagger 2.0 documents are all converted to
  * canonical Draft 2020-12 form. The parser and downstream extractors
- * (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+ * (`extractRequestBody`, `extractResponses`, etc.) then observe schemas in the
  * same form `<SchemaComponent>` does, keeping the OpenAPI components on
  * the same pipeline as the top-level adapter.
  *
@@ -61,77 +61,66 @@ interface PathItemInfo {
 /**
  * Aggregate view of a single OpenAPI operation: the operation itself,
  * its Path Item Object context, merged parameters, request body, and
- * responses. Produced by {@link resolveOperation} /
- * {@link resolveOperationFromParsed} for rendering and inspection.
+ * responses. Produced by {@link resolveOperation} for rendering and
+ * inspection.
  */
 interface ResolvedOperation {
   operation: OperationInfo;
   pathItem: PathItemInfo;
   parameters: ParameterInfo[];
-  requestBody: ReturnType<typeof getRequestBody>;
+  requestBody: RequestBodyInfo | undefined;
   responses: ResponseInfo[];
 }
-/**
- * Resolve an operation against an already-parsed document. Throws if
- * the operation is not found.
- *
- * Used by callers that have already obtained a parsed document via
- * {@link getParsed} — most importantly the React components, which
- * supply `diagnostics` to `getParsed` and must avoid re-running the
- * normalisation pipeline (every re-run would emit each diagnostic
- * again into the sink).
- */
-declare function resolveOperationFromParsed(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ResolvedOperation;
 /**
  * Resolve an operation from an OpenAPI document by path and method.
  * Throws if the operation is not found.
  *
- * `diagnostics` is forwarded to {@link getParsed} so normalisation
- * events surface to the caller's sink.
- */
-declare function resolveOperation(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ResolvedOperation;
-/**
- * Resolve parameters against an already-parsed document. See
- * {@link resolveOperationFromParsed} for the rationale.
- */
-declare function resolveParametersFromParsed(parsed: OpenApiDocument, path: string, method: string): ParameterInfo[];
-/**
- * Resolve parameters for an operation. Returns empty array if none.
+ * Accepts either a raw document (parsed lazily via {@link getParsed}'s
+ * WeakMap cache) or an already-parsed {@link OpenApiDocument}. Callers
+ * that have a parsed document at hand can pass it directly to avoid
+ * an extra cache lookup; everyone else trusts the cache.
  *
  * `diagnostics` is forwarded to {@link getParsed} so normalisation
- * events surface to the caller's sink.
- */
-declare function resolveParameters(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ParameterInfo[];
-/**
- * Resolve a request body against an already-parsed document. See
- * {@link resolveOperationFromParsed} for the rationale.
+ * events surface to the caller's sink exactly once per `(doc, sink)`
+ * pair, no matter how many times this function is called.
  */
-declare function resolveRequestBodyFromParsed(parsed: OpenApiDocument, path: string, method: string): ReturnType<typeof getRequestBody>;
+declare function resolveOperation(doc: Record<string, unknown> | OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ResolvedOperation;
 /**
- * Resolve request body for an operation. Returns undefined if none.
+ * Resolve parameters for an operation. Returns an empty array if none.
  *
- * `diagnostics` is forwarded to {@link getParsed} so normalisation
- * events surface to the caller's sink.
+ * Accepts either a raw document or an already-parsed
+ * {@link OpenApiDocument}. `diagnostics` is forwarded to
+ * {@link getParsed} so normalisation events surface to the caller's
+ * sink.
  */
-declare function resolveRequestBody(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ReturnType<typeof getRequestBody>;
+declare function resolveParameters(doc: Record<string, unknown> | OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ParameterInfo[];
 /**
- * Resolve a specific response against an already-parsed document. See
- * {@link resolveOperationFromParsed} for the rationale.
+ * Resolve the request body for an operation. Returns `undefined` if
+ * the operation declares no request body.
+ *
+ * Accepts either a raw document or an already-parsed
+ * {@link OpenApiDocument}. `diagnostics` is forwarded to
+ * {@link getParsed} so normalisation events surface to the caller's
+ * sink.
  */
-declare function resolveResponseFromParsed(parsed: OpenApiDocument, path: string, method: string, statusCode: string): ResponseInfo;
+declare function resolveRequestBody(doc: Record<string, unknown> | OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): RequestBodyInfo | undefined;
 /**
  * Resolve a specific response by status code. Throws if not found.
  *
- * `diagnostics` is forwarded to {@link getParsed} so normalisation
- * events surface to the caller's sink.
+ * Accepts either a raw document or an already-parsed
+ * {@link OpenApiDocument}. `diagnostics` is forwarded to
+ * {@link getParsed} so normalisation events surface to the caller's
+ * sink.
  */
-declare function resolveResponse(doc: Record<string, unknown>, path: string, method: string, statusCode: string, diagnostics?: DiagnosticsOptions): ResponseInfo;
+declare function resolveResponse(doc: Record<string, unknown> | OpenApiDocument, path: string, method: string, statusCode: string, diagnostics?: DiagnosticsOptions): ResponseInfo;
 /**
  * Resolve all responses for an operation.
  *
- * `diagnostics` is forwarded to {@link getParsed} so normalisation
- * events surface to the caller's sink.
+ * Accepts either a raw document or an already-parsed
+ * {@link OpenApiDocument}. `diagnostics` is forwarded to
+ * {@link getParsed} so normalisation events surface to the caller's
+ * sink.
  */
-declare function resolveResponses(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ResponseInfo[];
+declare function resolveResponses(doc: Record<string, unknown> | OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ResponseInfo[];
 //#endregion
-export { PathItemInfo, ResolvedOperation, getParsed, resolveOperation, resolveOperationFromParsed, resolveParameters, resolveParametersFromParsed, resolveRequestBody, resolveRequestBodyFromParsed, resolveResponse, resolveResponseFromParsed, resolveResponses, toDoc };
+export { PathItemInfo, ResolvedOperation, getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };

package/dist/openapi/resolve.mjs

@@ -3,9 +3,9 @@ import "../core/limits.mjs";
 import { emitDiagnostic } from "../core/diagnostics.mjs";
 import { isPrototypePollutingKey } from "../core/uri.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
-import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-Db1xaxgx.mjs";
+import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-DB-Xtjmn.mjs";
 import { resolveRefChain } from "../core/refChain.mjs";
-import { getParameters, getRequestBody, getResponses, listAllOperations, parseOpenApiDocument } from "./parser.mjs";
+import { extractParameters, extractRequestBody, extractResponses, listAllOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
 * OpenAPI document resolution and caching.
@@ -24,7 +24,7 @@ const docCache = /* @__PURE__ */ new WeakMap();
 * keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
 * `discriminator`, and Swagger 2.0 documents are all converted to
 * canonical Draft 2020-12 form. The parser and downstream extractors
-* (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+* (`extractRequestBody`, `extractResponses`, etc.) then observe schemas in the
 * same form `<SchemaComponent>` does, keeping the OpenAPI components on
 * the same pipeline as the top-level adapter.
 *
@@ -314,16 +314,20 @@ function extractPathItemInfo(pathItem) {
 	};
 }
 /**
-* Resolve an operation against an already-parsed document. Throws if
-* the operation is not found.
+* Resolve an operation from an OpenAPI document by path and method.
+* Throws if the operation is not found.
 *
-* Used by callers that have already obtained a parsed document via
-* {@link getParsed} — most importantly the React components, which
-* supply `diagnostics` to `getParsed` and must avoid re-running the
-* normalisation pipeline (every re-run would emit each diagnostic
-* again into the sink).
+* Accepts either a raw document (parsed lazily via {@link getParsed}'s
+* WeakMap cache) or an already-parsed {@link OpenApiDocument}. Callers
+* that have a parsed document at hand can pass it directly to avoid
+* an extra cache lookup; everyone else trusts the cache.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink exactly once per `(doc, sink)`
+* pair, no matter how many times this function is called.
 */
-function resolveOperationFromParsed(parsed, path, method, diagnostics) {
+function resolveOperation(doc, path, method, diagnostics) {
+	const parsed = ensureParsed(doc, diagnostics);
 	const pathItemNode = lookupPathItemNode(parsed, path, diagnostics);
 	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}`);
@@ -331,79 +335,81 @@ function resolveOperationFromParsed(parsed, path, method, diagnostics) {
 	return {
 		operation,
 		pathItem: extractPathItemInfo(pathItemNode),
-		parameters: getParameters(parsed, path, method),
-		requestBody: getRequestBody(parsed, path, method),
-		responses: getResponses(parsed, path, method)
+		parameters: extractParameters(parsed, path, method),
+		requestBody: extractRequestBody(parsed, path, method),
+		responses: extractResponses(parsed, path, method)
 	};
 }
 /**
-* Resolve an operation from an OpenAPI document by path and method.
-* Throws if the operation is not found.
-*
-* `diagnostics` is forwarded to {@link getParsed} so normalisation
-* events surface to the caller's sink.
+* Coerce the first argument of every `resolveX` function — either a
+* raw OpenAPI document or an already-parsed {@link OpenApiDocument} —
+* into a parsed view. Distinguishes the two by the presence of the
+* `schemas` map on the parsed shape; falls through to {@link getParsed}
+* for raw documents (which itself short-circuits on a WeakMap cache).
 */
-function resolveOperation(doc, path, method, diagnostics) {
-	return resolveOperationFromParsed(getParsed(doc, diagnostics), path, method, diagnostics);
+function ensureParsed(doc, diagnostics) {
+	if (isParsedDocument(doc)) {
+		const cached = docCache.get(doc.doc);
+		if (cached !== void 0 && (diagnostics?.diagnostics !== void 0 || diagnostics?.strict === true)) replayCapturedDiagnostics(cached, diagnostics);
+		return doc;
+	}
+	return getParsed(doc, diagnostics);
 }
 /**
-* Resolve parameters against an already-parsed document. See
-* {@link resolveOperationFromParsed} for the rationale.
+* Decide whether `value` is an already-parsed {@link OpenApiDocument}.
+* The parsed shape carries a `schemas` Map alongside the raw `doc`
+* object; a raw OpenAPI document has neither — its keys are
+* `openapi`/`swagger`, `info`, `paths`, etc.
 */
-function resolveParametersFromParsed(parsed, path, method) {
-	return getParameters(parsed, path, method);
+function isParsedDocument(value) {
+	return isObject(value.doc) && value.schemas instanceof Map;
 }
 /**
-* Resolve parameters for an operation. Returns empty array if none.
+* Resolve parameters for an operation. Returns an empty array if none.
 *
-* `diagnostics` is forwarded to {@link getParsed} so normalisation
-* events surface to the caller's sink.
+* Accepts either a raw document or an already-parsed
+* {@link OpenApiDocument}. `diagnostics` is forwarded to
+* {@link getParsed} so normalisation events surface to the caller's
+* sink.
 */
 function resolveParameters(doc, path, method, diagnostics) {
-	return resolveParametersFromParsed(getParsed(doc, diagnostics), path, method);
+	return extractParameters(ensureParsed(doc, diagnostics), path, method);
 }
 /**
-* Resolve a request body against an already-parsed document. See
-* {@link resolveOperationFromParsed} for the rationale.
-*/
-function resolveRequestBodyFromParsed(parsed, path, method) {
-	return getRequestBody(parsed, path, method);
-}
-/**
-* Resolve request body for an operation. Returns undefined if none.
+* Resolve the request body for an operation. Returns `undefined` if
+* the operation declares no request body.
 *
-* `diagnostics` is forwarded to {@link getParsed} so normalisation
-* events surface to the caller's sink.
+* Accepts either a raw document or an already-parsed
+* {@link OpenApiDocument}. `diagnostics` is forwarded to
+* {@link getParsed} so normalisation events surface to the caller's
+* sink.
 */
 function resolveRequestBody(doc, path, method, diagnostics) {
-	return resolveRequestBodyFromParsed(getParsed(doc, diagnostics), path, method);
-}
-/**
-* Resolve a specific response against an already-parsed document. See
-* {@link resolveOperationFromParsed} for the rationale.
-*/
-function resolveResponseFromParsed(parsed, path, method, statusCode) {
-	const response = getResponses(parsed, path, method).find((r) => r.statusCode === statusCode);
-	if (response === void 0) throw new Error(`Response not found: ${statusCode}`);
-	return response;
+	return extractRequestBody(ensureParsed(doc, diagnostics), path, method);
 }
 /**
 * Resolve a specific response by status code. Throws if not found.
 *
-* `diagnostics` is forwarded to {@link getParsed} so normalisation
-* events surface to the caller's sink.
+* Accepts either a raw document or an already-parsed
+* {@link OpenApiDocument}. `diagnostics` is forwarded to
+* {@link getParsed} so normalisation events surface to the caller's
+* sink.
 */
 function resolveResponse(doc, path, method, statusCode, diagnostics) {
-	return resolveResponseFromParsed(getParsed(doc, diagnostics), path, method, statusCode);
+	const response = extractResponses(ensureParsed(doc, diagnostics), path, method).find((r) => r.statusCode === statusCode);
+	if (response === void 0) throw new Error(`Response not found: ${statusCode}`);
+	return response;
 }
 /**
 * Resolve all responses for an operation.
 *
-* `diagnostics` is forwarded to {@link getParsed} so normalisation
-* events surface to the caller's sink.
+* Accepts either a raw document or an already-parsed
+* {@link OpenApiDocument}. `diagnostics` is forwarded to
+* {@link getParsed} so normalisation events surface to the caller's
+* sink.
 */
 function resolveResponses(doc, path, method, diagnostics) {
-	return getResponses(getParsed(doc, diagnostics), path, method);
+	return extractResponses(ensureParsed(doc, diagnostics), path, method);
 }
 //#endregion
-export { getParsed, resolveOperation, resolveOperationFromParsed, resolveParameters, resolveParametersFromParsed, resolveRequestBody, resolveRequestBodyFromParsed, resolveResponse, resolveResponseFromParsed, resolveResponses, toDoc };
+export { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };

package/dist/react/SchemaComponent.d.mts

@@ -1,25 +1,15 @@
-import { d as FieldOverrides, j as WalkedField, u as FieldOverride, w as SchemaMeta } from "../types-C2Ay1FEh.mjs";
-import { t as Diagnostic } from "../diagnostics-ByEzkjrA.mjs";
-import { i as SchemaIoSide } from "../adapter-DcWi4XXn.mjs";
-import { t as SchemaError } from "../errors-D8JndRwI.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-OaOz-n6-.mjs";
-import { FromJSONSchema, FromJSONSchemaMode, IsSwagger2Doc, PathOfType, RejectUnrepresentableZod, ResolveOpenAPIRef, TypeAtPath, __SchemaInferenceFellBack } from "../core/typeInference.mjs";
+import { j as WalkedField, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { t as Diagnostic } from "../diagnostics-BTrm3O6J.mjs";
+import { SchemaIoSide } from "../core/adapter.mjs";
+import { ComponentResolver, RenderProps, WidgetMap } from "../core/renderer.mjs";
+import { t as SchemaError } from "../errors-Dki7tji4.mjs";
+import { FromJSONSchema, PathOfType, RejectUnrepresentableZod } from "../core/typeInference.mjs";
+import { a as InferredValue, i as InferredOutputValue, n as InferSchemaValue, r as InferredInputValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
 import { z } from "zod";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
 
 //#region src/react/SchemaComponent.d.ts
-/**
- * Widget map — maps component hints (from `.meta({ component })`) to render
- * functions. Scoped at three levels:
- *
- * 1. **Per-instance** — `widgets` prop on `<SchemaComponent>`
- * 2. **Context-scoped** — `widgets` prop on `<SchemaProvider>`
- * 3. **Global** — `registerWidget()` (app-wide defaults)
- *
- * Resolution order: instance → context → global → resolver → headless.
- */
-type WidgetMap = ReadonlyMap<string, (props: RenderProps) => unknown>;
 /**
  * Provide a theme resolver and scoped widgets to every `<SchemaComponent>`
  * and `<SchemaView>` rendered inside the subtree.
@@ -58,64 +48,15 @@ declare function SchemaProvider({
  * or `<SchemaProvider>` instead.
  */
 declare function registerWidget(name: string, render: (props: RenderProps) => unknown): void;
-type InferFields<T, Ref extends string | undefined> = IsSwagger2Doc<T> extends true ? __SchemaInferenceFellBack : T extends z.ZodType ? FieldOverrides<z.infer<T>> : T extends {
-  openapi: unknown;
-} ? Ref extends string ? FieldOverrides<ResolveOpenAPIRef<T & Record<string, unknown>, Ref>> : Record<string, FieldOverride> : T extends object ? unknown extends FromJSONSchema<T> ? Record<string, FieldOverride> : FieldOverrides<FromJSONSchema<T>> : Record<string, FieldOverride>;
-/**
- * Infer the data type carried by the schema input.
- *
- * Mirrors {@link InferFields}'s dispatch order: Zod schema → `z.infer`,
- * OpenAPI doc + ref → `ResolveOpenAPIRef`, plain JSON Schema object →
- * `FromJSONSchema`, everything else → `unknown`. The `Mode` parameter
- * is plumbed through to `FromJSONSchema` / `ResolveOpenAPIRef` so
- * `readOnly` / `writeOnly` keywords participate in the inferred
- * object shape — `"output"` for the rendered value, `"input"` for the
- * `onChange` argument.
- *
- * When the schema's value type cannot be statically determined (e.g.
- * a runtime `Record<string, unknown>` JSON Schema, or an OpenAPI doc
- * without a ref), the result falls back to `unknown` so callers can
- * still supply arbitrary values.
- */
-type InferSchemaValue<T, Ref extends string | undefined, Mode extends FromJSONSchemaMode> = IsSwagger2Doc<T> extends true ? __SchemaInferenceFellBack : T extends z.ZodType ? Mode extends "input" ? z.input<T> : z.output<T> : T extends {
-  openapi: unknown;
-} ? Ref extends string ? ResolveOpenAPIRef<T & Record<string, unknown>, Ref, [], Mode> : unknown : T extends object ? FromJSONSchema<T, Record<string, never>, [], Mode> | (unknown extends FromJSONSchema<T> ? unknown : never) extends infer V ? V : unknown : unknown;
-/**
- * Narrow an inferred value type to the sub-shape at `P`, or return
- * the original value type when `P` is `undefined` (no path supplied).
- */
-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.
+ * Clear every globally registered widget. Intended for test isolation —
+ * `registerWidget` writes to module-level state and that state otherwise
+ * leaks across test cases, making the test suite order-dependent. Tests
+ * should call this from an `afterEach` hook.
  *
- * 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`.
+ * @internal
  */
-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.
- *
- * 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>;
-/**
- * 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>;
+declare function __clearGlobalWidgets(): void;
 /**
  * Props accepted by {@link SchemaComponent}.
  *
@@ -125,7 +66,7 @@ type InferredValue<T, Ref extends string | undefined = undefined, P extends stri
  *
  * @group Components
  */
-interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined, P extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
+interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
   /**
    * Zod schema, JSON Schema object, or OpenAPI document.
    *
@@ -139,21 +80,6 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
   schema: RejectUnrepresentableZod<T>;
   /** For OpenAPI: a ref string like "#/components/schemas/User" or "/users/post". */
   ref?: Ref;
-  /**
-   * Optional dot-separated path used purely for type narrowing.
-   * When the schema is typed, the path is restricted to the valid
-   * dot-paths reachable through the schema's inferred value.
-   *
-   * RUNTIME CAVEAT: this prop is currently type-level only. The
-   * render pipeline still operates on the root schema; sub-path
-   * value resolution is provided by the dedicated `<SchemaField>`
-   * component, which already implements `resolvePath` /
-   * `setNestedValue`. The `path` prop here documents intent at the
-   * type level (and prepares the API surface) so consumers can
-   * declare narrow typed wrappers without runtime regressions. Use
-   * `<SchemaField>` when a sub-path render is required at runtime.
-   */
-  path?: P;
   /**
    * Which side of every transform / pipe / codec to render.
    *
@@ -178,9 +104,7 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
   /**
    * 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}).
+   * the chosen `io` direction.
    *
    * Falls back to `unknown` when the schema's value type cannot be
    * statically inferred (runtime `Record<string, unknown>` JSON
@@ -195,7 +119,7 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
    * <SchemaComponent schema={userSchema} value={user} readOnly />
    * ```
    */
-  value?: NarrowAtPath<InferSchemaValue<T, Ref, Mode>, P>;
+  value?: InferSchemaValue<T, Ref, Mode>;
   /**
    * Called when the value changes (editable fields). The parameter
    * shares the same shape as {@link SchemaComponentProps.value} so
@@ -205,7 +129,7 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
    * Falls back to `unknown` for schemas whose value type cannot be
    * statically inferred — see {@link SchemaComponentProps.value}.
    */
-  onChange?: (value: NarrowAtPath<InferSchemaValue<T, Ref, Mode>, P>) => void;
+  onChange?: (value: InferSchemaValue<T, Ref, Mode>) => void;
   /** Run schema.safeParse() on change and surface errors via onValidationError. */
   validate?: boolean;
   /** Called with the ZodError when validation fails. */
@@ -259,7 +183,7 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
  * <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
  * ```
  */
-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;
+declare function SchemaComponent<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output">(props: SchemaComponentProps<T, Ref, 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
@@ -343,4 +267,4 @@ declare function SchemaField<T = unknown, Ref extends string | undefined = undef
   onValidationError
 }: SchemaFieldProps<T, Ref, P>): ReactNode;
 //#endregion
-export { InferredInputValue, InferredOutputValue, InferredValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, WidgetMap, joinPath, registerWidget, renderField, sanitisePrefix };
+export { type InferFields, type InferredInputValue, type InferredOutputValue, type InferredValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, __clearGlobalWidgets, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaComponent.mjs

@@ -69,6 +69,17 @@ function registerWidget(name, render) {
 	globalWidgets.set(name, render);
 }
 /**
+* Clear every globally registered widget. Intended for test isolation —
+* `registerWidget` writes to module-level state and that state otherwise
+* leaks across test cases, making the test suite order-dependent. Tests
+* should call this from an `afterEach` hook.
+*
+* @internal
+*/
+function __clearGlobalWidgets() {
+	globalWidgets.clear();
+}
+/**
 * Render an editable (or read-only) UI from a Zod schema, JSON Schema, or
 * OpenAPI document.
 *
@@ -405,4 +416,4 @@ function isCallable(value) {
 	return typeof value === "function";
 }
 //#endregion
-export { SchemaComponent, SchemaField, SchemaProvider, joinPath, registerWidget, renderField, sanitisePrefix };
+export { SchemaComponent, SchemaField, SchemaProvider, __clearGlobalWidgets, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaView.d.mts

@@ -1,9 +1,9 @@
-import { w as SchemaMeta } from "../types-C2Ay1FEh.mjs";
-import { t as Diagnostic } from "../diagnostics-ByEzkjrA.mjs";
-import { i as SchemaIoSide } from "../adapter-DcWi4XXn.mjs";
-import { r as ComponentResolver } from "../renderer-OaOz-n6-.mjs";
+import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { t as Diagnostic } from "../diagnostics-BTrm3O6J.mjs";
+import { SchemaIoSide } from "../core/adapter.mjs";
+import { ComponentResolver, WidgetMap } from "../core/renderer.mjs";
 import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { InferredValue, WidgetMap } from "./SchemaComponent.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/SchemaView.d.ts
@@ -44,8 +44,12 @@ interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefine
    * schemas where the value type cannot be statically inferred.
    */
   value?: InferredValue<T, Ref, undefined, Mode>;
-  /** Per-field meta overrides. */
-  fields?: Record<string, unknown>;
+  /**
+   * Per-field meta overrides — nested object mirroring schema shape.
+   * Typed against {@link InferFields} so a typed `schema` prop drives
+   * autocomplete on the override map, matching `<SchemaComponent>`.
+   */
+  fields?: InferFields<T, Ref>;
   /** Meta overrides applied to the root schema. */
   meta?: SchemaMeta;
   /** Convenience: sets description on the root. */

package/dist/react/SchemaView.mjs

@@ -1,3 +1,4 @@
+import { toRecordOrUndefined } from "../core/guards.mjs";
 import "../core/limits.mjs";
 import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
@@ -84,10 +85,11 @@ function SchemaView({ schema: schemaInput, ref: refInput, io, value, fields, met
 		if (err instanceof SchemaNormalisationError) throw err;
 		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 	}
+	const fieldsRecord = toRecordOrUndefined(fields);
 	const walkOptions = {
 		componentMeta: mergedMeta,
 		rootMeta,
-		fieldOverrides: fields,
+		fieldOverrides: fieldsRecord,
 		rootDocument,
 		...diagnostics !== void 0 ? { diagnostics } : {}
 	};