schema-components 2.0.1 → 2.0.2

package/dist/core/adapter.d.mts

@@ -37,7 +37,7 @@ declare function detectSchemaKind(input: unknown): SchemaKind;
  * 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.
+ * `object → Record<string, unknown>` — the type mismatch is genuinely unavoidable.
  *
  * # Options
  *

package/dist/core/adapter.mjs

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

package/dist/core/guards.d.mts

@@ -8,8 +8,8 @@
  *
  * The `object → Record<string, unknown>` conversion (`toRecord`) is
  * the one place where a cast is genuinely unavoidable — TypeScript's
- * `object` type has no index signature. See AGENTS.md: "object →
- * Record<string, unknown>".
+ * `object` type has no index signature. See AGENTS.md
+ * (`object → Record<string, unknown>`).
  */
 /**
  * Narrows `unknown` to a non-null, non-array object.

package/dist/core/guards.mjs

@@ -8,8 +8,8 @@
 *
 * The `object → Record<string, unknown>` conversion (`toRecord`) is
 * the one place where a cast is genuinely unavoidable — TypeScript's
-* `object` type has no index signature. See AGENTS.md: "object →
-* Record<string, unknown>".
+* `object` type has no index signature. See AGENTS.md
+* (`object → Record<string, unknown>`).
 */
 /**
 * Narrows `unknown` to a non-null, non-array object.

package/dist/core/inferValue.d.mts

@@ -1,2 +1,2 @@
-import { a as InferredValue, i as InferredOutputValue, n as InferSchemaValue, r as InferredInputValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
+import { a as InferredValue, i as InferredOutputValue, n as InferSchemaValue, r as InferredInputValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
 export { InferFields, InferSchemaValue, InferredInputValue, InferredOutputValue, InferredValue };

package/dist/core/normalise.d.mts

@@ -75,12 +75,12 @@ declare function deepNormaliseWithContext(schema: Record<string, unknown>, trans
  * single node.
  *
  * In Draft 04:
- * - `exclusiveMinimum: true` + `minimum: 5` → value must be > 5
- * - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be >= 5
+ * - `exclusiveMinimum: true` + `minimum: 5` → value must be \> 5
+ * - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be \>= 5
  *
  * In Draft 06+:
- * - `exclusiveMinimum: 5` → value must be > 5 (no separate `minimum`)
- * - `minimum: 5` → value must be >= 5
+ * - `exclusiveMinimum: 5` → value must be \> 5 (no separate `minimum`)
+ * - `minimum: 5` → value must be \>= 5
  *
  * The transform converts boolean form to number form so the walker can
  * treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.

package/dist/core/normalise.mjs

@@ -1,2 +1,2 @@
-import { a as normaliseJsonSchema, i as normaliseDraft04Node, n as deepNormaliseWithContext, o as normaliseOpenApiSchemas, r as documentContainsKeyword, s as selectDraftTransform, t as deepNormalise } from "../normalise-DB-Xtjmn.mjs";
+import { a as normaliseJsonSchema, i as normaliseDraft04Node, n as deepNormaliseWithContext, o as normaliseOpenApiSchemas, r as documentContainsKeyword, s as selectDraftTransform, t as deepNormalise } from "../normalise-BkePrJ4v.mjs";
 export { deepNormalise, deepNormaliseWithContext, documentContainsKeyword, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas, selectDraftTransform };

package/dist/core/openapi30.d.mts

@@ -31,7 +31,7 @@ declare function normaliseOpenApi30Node(node: Record<string, unknown>): Record<s
  * values into each `oneOf`/`anyOf` option's discriminator property.
  *
  * In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
- *   discriminator: { propertyName: "type" }
+ *   `discriminator: { propertyName: "type" }`
  * The walker detects discriminated unions from `oneOf` + `const` on a
  * property, so this normaliser injects the `const` values from the
  * `mapping` or infers them from `$ref` fragment names.

package/dist/core/openapi30.mjs

@@ -1,2 +1,2 @@
-import { d as deepNormaliseOpenApiDoc, f as liftExampleToExamples, h as normaliseOpenApi30Node, l as applyDiscriminatorAllOfPrepass, m as normaliseOpenApi30Discriminator, p as normaliseOpenApi30Combined, u as deepNormaliseOpenApi30Doc } from "../normalise-DB-Xtjmn.mjs";
+import { d as deepNormaliseOpenApiDoc, f as liftExampleToExamples, h as normaliseOpenApi30Node, l as applyDiscriminatorAllOfPrepass, m as normaliseOpenApi30Discriminator, p as normaliseOpenApi30Combined, u as deepNormaliseOpenApi30Doc } from "../normalise-BkePrJ4v.mjs";
 export { applyDiscriminatorAllOfPrepass, deepNormaliseOpenApi30Doc, deepNormaliseOpenApiDoc, liftExampleToExamples, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/swagger2.mjs

@@ -1,2 +1,2 @@
-import { c as normaliseSwagger2Document } from "../normalise-DB-Xtjmn.mjs";
+import { c as normaliseSwagger2Document } from "../normalise-BkePrJ4v.mjs";
 export { normaliseSwagger2Document };

package/dist/core/typeInference.d.mts

@@ -117,23 +117,23 @@ type FromJSONSchemaMode = "input" | "output" | "both";
  *
  * Supports all JSON Schema draft versions (04-2020-12) and OpenAPI 3.x:
  * - Primitive types: string, number, integer, boolean, null
- * - type as array: `["string", "null"]` -> `string | null` (nullable)
- * - enum -> union of literal types
- * - const -> literal type
- * - object with properties/required -> specific object type
- * - object with properties + additionalProperties -> object & Record<string, V>
- * - object with additionalProperties only -> Record<string, T>
- * - array with items -> T[]
- * - array with prefixItems -> tuple type
- * - allOf -> intersection type
- * - anyOf -> union type
- * - oneOf -> union type (plain union, or tagged union when `discriminator` is set)
- * - $ref -> resolved via $defs/definitions/$anchor context
- * - $dynamicRef -> resolved via $dynamicAnchor in definitions
- * - $recursiveRef -> unknown (recursive types not expressible in TS)
- * - if/then/else -> base schema (conditionals not expressible in TS)
- * - not -> unknown (negation not expressible in TS)
- * - patternProperties -> merged into loose index signature
+ * - type as array: `["string", "null"]` -\> `string | null` (nullable)
+ * - enum -\> union of literal types
+ * - const -\> literal type
+ * - object with properties/required -\> specific object type
+ * - object with properties + additionalProperties -\> object & `Record<string, V>`
+ * - object with additionalProperties only -\> `Record<string, T>`
+ * - array with items -\> `T[]`
+ * - array with prefixItems -\> tuple type
+ * - allOf -\> intersection type
+ * - anyOf -\> union type
+ * - oneOf -\> union type (plain union, or tagged union when `discriminator` is set)
+ * - $ref -\> resolved via $defs/definitions/$anchor context
+ * - $dynamicRef -\> resolved via $dynamicAnchor in definitions
+ * - $recursiveRef -\> unknown (recursive types not expressible in TS)
+ * - if/then/else -\> base schema (conditionals not expressible in TS)
+ * - not -\> unknown (negation not expressible in TS)
+ * - patternProperties -\> merged into loose index signature
  *
  * The `Mode` parameter controls how `readOnly` / `writeOnly` keywords
  * influence inferred object properties — see {@link FromJSONSchemaMode}.
@@ -279,11 +279,12 @@ interface __SchemaInferenceFellBack {
  * a silent default.
  *
  * Earlier revisions made the brand optional (`__unsafe?: true`).
- * That defeated the brand's purpose: any plain `Record<string,
- * FieldOverride>` literal silently satisfied the type and the
- * "unsafe" intent was invisible to readers and reviewers. Marking
- * the brand required forces callers to write `{ __unsafe: true,
- * ... }`, making the escape-hatch use visible at the call site.
+ * That defeated the brand's purpose: any plain
+ * `Record<string, FieldOverride>` literal silently satisfied the type
+ * and the "unsafe" intent was invisible to readers and reviewers.
+ * Marking the brand required forces callers to write
+ * `{ __unsafe: true, ... }`, making the escape-hatch use visible at
+ * the call site.
  *
  * The brand key is carved out of the field-name index signature so
  * `__unsafe: true` does not collide with the `FieldOverride` value
@@ -367,8 +368,8 @@ type ResolveSchemaRef<R extends string, Defs extends Record<string, unknown>, De
  * but TypeScript's mapped-type machinery — combined with the conditional
  * dispatch above — does not always recover that distribution when the
  * union arises from a `FromJSONSchema` expansion. The pinned regression
- * test `allOf of unions is treated as the intersection of the union
- * members` in `tests/type-inference-issue-fixes.test.ts` documents the
+ * test "allOf of unions is treated as the intersection of the union
+ * members" in `tests/type-inference-issue-fixes.test.ts` documents the
  * current behaviour so future refactors do not silently make it worse.
  * There is no known way to express "distribute every member-side union
  * across the intersection" in TypeScript today without losing the
@@ -487,7 +488,7 @@ type NullableResult<Base, S> = S extends {
   type: readonly (infer T)[];
 } ? "null" extends T ? Base | null : Base : Base;
 /**
- * Parse an array schema: prefixItems -> tuple, items -> T[], or unknown[].
+ * Parse an array schema: prefixItems -\> tuple, items -\> `T[]`, or `unknown[]`.
  *
  * Draft 04 used tuple-form `items` (an array of schemas) for tuple typing;
  * Draft 2020-12 renamed this to `prefixItems`. The runtime normaliser in
@@ -511,19 +512,19 @@ type ArraySchemaToTs<S, Defs extends Record<string, unknown>, Depth extends read
  */
 type PrefixItemsToTuple<P, Defs extends Record<string, unknown>, Depth extends readonly unknown[] = [], Mode extends FromJSONSchemaMode = "both"> = P extends readonly [infer First, ...infer Rest] ? [FromJSONSchema<First, Defs, Depth, Mode>, ...PrefixItemsToTuple<Rest, Defs, Depth, Mode>] : [];
 /**
- * Parse an object schema: properties + required -> specific object,
- * additionalProperties -> Record, or empty object.
+ * Parse an object schema: properties + required -\> specific object,
+ * additionalProperties -\> Record, or empty object.
  *
  * Handles:
- * - `properties` + `required` -> specific object type with required/optional keys
- * - `additionalProperties` as schema -> Record<string, T>
- * - `properties` + `additionalProperties` -> base object intersected with
+ * - `properties` + `required` -\> specific object type with required/optional keys
+ * - `additionalProperties` as schema -\> `Record<string, T>`
+ * - `properties` + `additionalProperties` -\> base object intersected with
  *   `Record<string, V>`, preserving the typed value shape of the extra props
- * - `patternProperties` -> merged into a loose index signature alongside specific props
+ * - `patternProperties` -\> merged into a loose index signature alongside specific props
  *   (TypeScript cannot express regex-keyed properties)
- * - `propertyNames` -> ignored at type level (TS cannot validate key shapes)
- * - `dependentSchemas` / `dependentRequired` -> ignored (runtime-only conditionals)
- * - `unevaluatedProperties` -> ignored (runtime-only)
+ * - `propertyNames` -\> ignored at type level (TS cannot validate key shapes)
+ * - `dependentSchemas` / `dependentRequired` -\> ignored (runtime-only conditionals)
+ * - `unevaluatedProperties` -\> ignored (runtime-only)
  *
  * Properties marked `readOnly: true` are omitted when `Mode` is
  * `"input"`; properties marked `writeOnly: true` are omitted when
@@ -628,7 +629,7 @@ type RawComponentSchemasOf<S> = S extends {
   };
 } ? D extends Record<string, unknown> ? D : Record<string, never> : Record<string, never>;
 /**
- * Build a map of `$anchor` name -> schema from a definitions block.
+ * Build a map of `$anchor` name -\> schema from a definitions block.
  * Scans each definition value for `$anchor`, `$dynamicAnchor`, or the
  * Draft 2019-09 `$recursiveAnchor` keyword and creates entries like
  * `{ Tree: <schema-with-$anchor-Tree> }`.
@@ -651,7 +652,7 @@ type ExtractAnchors<D extends Record<string, unknown>> = { [K in keyof D as D[K]
 } ? "__recursive__" : never]: D[K] };
 /**
  * Convert a union to an intersection.
- * `A | B` -> `A & B`. Used for allOf merging.
+ * `A | B` -\> `A & B`. Used for allOf merging.
  */
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
@@ -702,11 +703,11 @@ type ExtractDefinitions<Spec> = Spec extends {
 /**
  * Resolve a path-based $ref after the `#/paths/` prefix.
  * Splits on `/` and navigates the document tree, decoding JSON Pointer
- * tilde escapes (`~1` -> `/`, `~0` -> `~`) on every segment.
+ * tilde escapes (`~1` -\> `/`, `~0` -\> `~`) on every segment.
  *
  * SOURCE-OF-TRUTH: mirrors runtime `dereference` in
  * `packages/core/src/core/ref.ts` (line 226), which applies the same
- * `~1` -> `/`, `~0` -> `~` substitutions per RFC 6901 §4. The runtime
+ * `~1` -\> `/`, `~0` -\> `~` substitutions per RFC 6901 §4. The runtime
  * uses ordered string replacement; the type-level mirror does the same
  * via {@link DecodeJsonPointerSegment}.
  */
@@ -721,14 +722,14 @@ type ResolvePathBasedRef<Spec extends Record<string, unknown>, PathRest extends
 type ReplaceAll<S extends string, From extends string, To extends string> = S extends `${infer Head}${From}${infer Tail}` ? `${Head}${To}${ReplaceAll<Tail, From, To>}` : S;
 /**
  * Decode a single JSON Pointer reference token per RFC 6901 §4:
- * apply `~1` -> `/` first, then `~0` -> `~`. The order matters — an
+ * apply `~1` -\> `/` first, then `~0` -\> `~`. The order matters — an
  * encoded `~` containing a literal `1` (e.g. `~01`) must remain `~1`
  * after decoding, which only works when `~1` is processed first.
  */
 type DecodeJsonPointerSegment<S extends string> = ReplaceAll<ReplaceAll<S, "~1", "/">, "~0", "~">;
 /**
  * Split a path string on `/` into a tuple of segments.
- * The first segment is the path key (may be empty for `/pets` -> `""` / `"pets"`).
+ * The first segment is the path key (may be empty for `/pets` -\> `""` / `"pets"`).
  */
 type SplitPath<S extends string> = S extends `${infer Head}/${infer Tail}` ? [Head, ...SplitPath<Tail>] : [S];
 /**
@@ -801,7 +802,7 @@ type ResponseSchemaOf<Op, Status extends string, ContentType extends string = DE
 } ? S : unknown : unknown : unknown : unknown : unknown : unknown : unknown;
 /**
  * Resolve a response entry from a status code following the OpenAPI
- * priority order: concrete > class wildcard > `default`. When none of
+ * priority order: concrete \> class wildcard \> `default`. When none of
  * the three matches, the result is `never` and the caller's outer
  * conditional falls through to `unknown`.
  */
@@ -895,7 +896,7 @@ type OpenAPIRequestBodyType<Doc, Path extends string, Method extends string, Con
  * declared content type when the default is absent.
  *
  * Status-code resolution follows the OpenAPI priority order: concrete
- * code > class wildcard (e.g. `"2XX"`) > `"default"`. See
+ * code \> class wildcard (e.g. `"2XX"`) \> `"default"`. See
  * {@link ResponseSchemaOf}.
  *
  * Swagger 2.0 documents are not normalised at the type level. When the
@@ -928,8 +929,8 @@ type OpenAPIResponseType<Doc, Path extends string, Method extends string, Status
  * documents, and the existing `@ts-expect-error` regressions in
  * `type-inference.test.ts` rely on the current widening behaviour.
  * The trade-off is pinned by the
- * `FieldsFromInferred widens to Record<string, FieldOverride> when the
- * operation is unknown` regression test.
+ * "FieldsFromInferred widens to `Record<string, FieldOverride>` when the
+ * operation is unknown" regression test.
  */
 type FieldsFromInferred<T> = [T] extends [__SchemaInferenceFellBack] ? __SchemaInferenceFellBack : unknown extends T ? Record<string, FieldOverride> : FieldOverrides<T>;
 /**

package/dist/core/uri.d.mts

@@ -33,8 +33,8 @@ declare function isSafeHyperlink(value: string): boolean;
  * the resulting `mailto:` URI. Refuse any value containing `%` to close
  * that header-injection vector. The plain email-format regex stays a
  * pure email-syntax check; the additional `%` filter lives here so other
- * callers of the format pattern (form validators, JSON Schema `format:
- * email` checks) are not affected.
+ * callers of the format pattern (form validators, JSON Schema
+ * `format: email` checks) are not affected.
  */
 declare function isSafeMailtoAddress(value: string): boolean;
 /**

package/dist/core/uri.mjs

@@ -70,8 +70,8 @@ function isSafeHyperlink(value) {
 * the resulting `mailto:` URI. Refuse any value containing `%` to close
 * that header-injection vector. The plain email-format regex stays a
 * pure email-syntax check; the additional `%` filter lives here so other
-* callers of the format pattern (form validators, JSON Schema `format:
-* email` checks) are not affected.
+* callers of the format pattern (form validators, JSON Schema
+* `format: email` checks) are not affected.
 */
 function isSafeMailtoAddress(value) {
 	if (value.includes("%")) return false;

package/dist/core/walkBuilders.d.mts

@@ -115,7 +115,7 @@ declare function buildFileField(schema: Record<string, unknown>, ctx: WalkContex
  * cannot represent a JSON Schema and have no walk-time meaning.
  */
 declare function walkSubSchemaMap<T>(map: Record<string, unknown>, walkSubSchema: (schema: unknown, ctx: WalkContext) => T, ctx: WalkContext): Record<string, T>;
-/** Walk a dependentRequired map (Record<string, string[]>). */
+/** Walk a dependentRequired map (`Record<string, string[]>`). */
 declare function walkDependentRequiredMap(map: Record<string, unknown>): Record<string, string[]>;
 /**
  * Return a copy of the schema without the specified keys.

package/dist/core/walkBuilders.mjs

@@ -161,7 +161,7 @@ function walkSubSchemaMap(map, walkSubSchema, ctx) {
 	for (const [key, value] of Object.entries(map)) if (isObject(value) || typeof value === "boolean") result[key] = walkSubSchema(value, ctx);
 	return result;
 }
-/** Walk a dependentRequired map (Record<string, string[]>). */
+/** Walk a dependentRequired map (`Record<string, string[]>`). */
 function walkDependentRequiredMap(map) {
 	const result = {};
 	for (const [key, value] of Object.entries(map)) if (Array.isArray(value)) result[key] = value.filter((x) => typeof x === "string");

package/dist/core/walker.mjs

@@ -47,9 +47,9 @@ function walkSubSchema(value, ctx) {
 * JSON Schema 2020-12 §11.2/§11.3 semantics:
 *
 *   false (forbid all extras)
-*     > schema-object (extras must match the schema)
-*     > true (extras explicitly permitted)
-*     > absent (extras implicitly permitted)
+*     \> schema-object (extras must match the schema)
+*     \> true (extras explicitly permitted)
+*     \> absent (extras implicitly permitted)
 *
 * Unknown shapes (numbers, arrays, strings) sort below absent — we
 * cannot reason about them, so do not let them override anything.

package/dist/html/html.d.mts

@@ -12,16 +12,18 @@
  *
  * Usage:
  *
- *     import { h, serialize } from "./html.ts";
+ * ```ts
+ * import { h, serialize } from "./html.ts";
  *
- *     const el = h("input", { type: "text", id: "name", "aria-required": true });
- *     serialize(el); // → '<input type="text" id="name" aria-required>'
+ * const el = h("input", { type: "text", id: "name", "aria-required": true });
+ * serialize(el); // → '<input type="text" id="name" aria-required>'
  *
- *     const form = h("form", {},
- *         h("label", { for: "name" }, "Name"),
- *         h("input", { type: "text", id: "name" }),
- *     );
- *     serialize(form); // → '<form><label for="name">Name</label><input type="text" id="name"></form>'
+ * const form = h("form", {},
+ *     h("label", { for: "name" }, "Name"),
+ *     h("input", { type: "text", id: "name" }),
+ * );
+ * serialize(form); // → '<form><label for="name">Name</label><input type="text" id="name"></form>'
+ * ```
  */
 /**
  * An HTML element node. Void elements (input, br, etc.) have no children

package/dist/html/renderToHtml.d.mts

@@ -2,7 +2,7 @@ import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
 import { SchemaIoSide } from "../core/adapter.mjs";
 import { HtmlResolver } from "../core/renderer.mjs";
 import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
 
 //#region src/html/renderToHtml.d.ts
 /**

package/dist/html/renderToHtml.mjs

@@ -18,14 +18,20 @@ import { defaultHtmlResolver } from "./renderers.mjs";
 * compile-time tag/attribute checking and automatic escaping.
 *
 * Usage:
-*   import { renderToHtml } from "schema-components/html/renderToHtml";
-*   const html = renderToHtml(userSchema, { value: userData });
+*
+* ```ts
+* import { renderToHtml } from "schema-components/html/renderToHtml";
+* const html = renderToHtml(userSchema, { value: userData });
+* ```
 *
 * Custom resolver:
-*   const html = renderToHtml(schema, {
-*     value,
-*     resolver: { string: (props) => h("b", {}, String(props.value)) },
-*   });
+*
+* ```ts
+* const html = renderToHtml(schema, {
+*   value,
+*   resolver: { string: (props) => h("b", {}, String(props.value)) },
+* });
+* ```
 */
 /**
 * Build the recursion-cap sentinel element used when the renderer

package/dist/html/renderToHtmlStream.d.mts

@@ -2,7 +2,7 @@ import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
 import { SchemaIoSide } from "../core/adapter.mjs";
 import { HtmlResolver } from "../core/renderer.mjs";
 import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 /**

package/dist/{inferValue-PPXWJpbN.d.mts → inferValue-Ce-PviSD.d.mts}

@@ -46,9 +46,9 @@ type NarrowAtPath<V, P extends string | undefined> = P extends string ? TypeAtPa
  * Public alias mapping a schema input to the rendered value type.
  *
  * 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`.
+ * codec. For a `<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>;
 /**

package/dist/{normalise-DB-Xtjmn.mjs → normalise-BkePrJ4v.mjs}

@@ -125,7 +125,7 @@ function compositeAlreadyAllowsNull(options) {
 * values into each `oneOf`/`anyOf` option's discriminator property.
 *
 * In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
-*   discriminator: { propertyName: "type" }
+*   `discriminator: { propertyName: "type" }`
 * The walker detects discriminated unions from `oneOf` + `const` on a
 * property, so this normaliser injects the `const` values from the
 * `mapping` or infers them from `$ref` fragment names.
@@ -1308,7 +1308,7 @@ function normaliseSwaggerHeader(header, diagnostics, pointer = "") {
 * Deep-rewrite $ref strings in a normalised Swagger 2.0 document
 * from Swagger 2.0 locations to OpenAPI 3.x locations using the
 * shared {@link rewriteSwaggerRefPrefix} mapping. Mutates the object
-* in place \u2014 called only on the fresh clone produced by
+* in place — called only on the fresh clone produced by
 * normaliseSwagger2Document.
 */
 function rewriteSwaggerRefs(node) {
@@ -1764,12 +1764,12 @@ function applyDraft04Translations(node, ctx) {
 * single node.
 *
 * In Draft 04:
-* - `exclusiveMinimum: true` + `minimum: 5` → value must be > 5
-* - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be >= 5
+* - `exclusiveMinimum: true` + `minimum: 5` → value must be \> 5
+* - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be \>= 5
 *
 * In Draft 06+:
-* - `exclusiveMinimum: 5` → value must be > 5 (no separate `minimum`)
-* - `minimum: 5` → value must be >= 5
+* - `exclusiveMinimum: 5` → value must be \> 5 (no separate `minimum`)
+* - `minimum: 5` → value must be \>= 5
 *
 * The transform converts boolean form to number form so the walker can
 * treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.

package/dist/openapi/components.d.mts

@@ -363,7 +363,7 @@ interface ApiResponseProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKey
  * picked out of `schema` by `path`, `method`, and `status`.
  *
  * Status resolution follows the OpenAPI priority order: concrete code
- * (e.g. `"200"`) > class wildcard (e.g. `"2XX"`) > `"default"`. When
+ * (e.g. `"200"`) \> class wildcard (e.g. `"2XX"`) \> `"default"`. When
  * `schema` is typed `as const`, `fields` autocomplete resolves from
  * the response schema; pass `contentType` to narrow inference to a
  * specific media type.

package/dist/openapi/components.mjs

@@ -286,7 +286,7 @@ function ApiRequestBody({ schema: doc, path, method, value, onChange, meta, fiel
 * picked out of `schema` by `path`, `method`, and `status`.
 *
 * Status resolution follows the OpenAPI priority order: concrete code
-* (e.g. `"200"`) > class wildcard (e.g. `"2XX"`) > `"default"`. When
+* (e.g. `"200"`) \> class wildcard (e.g. `"2XX"`) \> `"default"`. When
 * `schema` is typed `as const`, `fields` autocomplete resolves from
 * the response schema; pass `contentType` to narrow inference to a
 * specific media type.

package/dist/openapi/resolve.mjs

@@ -3,7 +3,7 @@ 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-DB-Xtjmn.mjs";
+import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-BkePrJ4v.mjs";
 import { resolveRefChain } from "../core/refChain.mjs";
 import { extractParameters, extractRequestBody, extractResponses, listAllOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts

package/dist/react/SchemaComponent.d.mts

@@ -4,7 +4,7 @@ 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 { a as InferredValue, i as InferredOutputValue, n as InferSchemaValue, r as InferredInputValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
 import { z } from "zod";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
@@ -102,9 +102,9 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
    */
   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.
+   * 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` when the schema's value type cannot be
    * statically inferred (runtime `Record<string, unknown>` JSON

package/dist/react/SchemaComponent.mjs

@@ -19,10 +19,10 @@ import { createContext, isValidElement, useCallback, useContext, useId, useMemo
 * ComponentResolver (theme adapter). Falls back to headless HTML.
 *
 * The `fields` prop type is inferred from the `schema` prop:
-* - Zod schemas → FieldOverrides<z.infer<T>> (full autocomplete)
-* - JSON Schema `as const` → FieldOverrides<FromJSONSchema<T>> (full autocomplete)
-* - OpenAPI `as const` + `ref` → FieldOverrides<ResolveOpenAPIRef<T, Ref>>
-* - Runtime schemas → Record<string, FieldOverride> (no autocomplete)
+* - Zod schemas → `FieldOverrides<z.infer<T>>` (full autocomplete)
+* - JSON Schema `as const` → `FieldOverrides<FromJSONSchema<T>>` (full autocomplete)
+* - OpenAPI `as const` + `ref` → `FieldOverrides<ResolveOpenAPIRef<T, Ref>>`
+* - Runtime schemas → `Record<string, FieldOverride>` (no autocomplete)
 */
 const UserResolverContext = createContext(void 0);
 const WidgetsContext = createContext(void 0);
@@ -384,9 +384,9 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 * (`FieldOverrides<U>`) and the loose `Record<string, FieldOverride>`
 * fallback share the same structural shape, so the dispatch logic only
 * needs the loose record. The previous parameter union
-* (`Record<string, FieldOverride> | FieldOverrides<unknown> |
-* undefined`) collapsed because `FieldOverrides<unknown>` reduces to
-* `{}`, contributing no extra precision while adding noise to readers.
+* (`Record<string, FieldOverride> | FieldOverrides<unknown> | undefined`)
+* collapsed because `FieldOverrides<unknown>` reduces to `{}`,
+* contributing no extra precision while adding noise to readers.
 */
 function dispatchFieldErrors(fields, error) {
 	if (fields === void 0 || !isObject(error)) return;

package/dist/react/SchemaErrorBoundary.mjs

@@ -10,11 +10,14 @@ import { Component } from "react";
 * crashes the entire React tree.
 *
 * Usage:
-*   import { SchemaErrorBoundary } from "schema-components/react/SchemaErrorBoundary";
 *
-*   <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
-*     <SchemaComponent schema={userSchema} value={user} />
-*   </SchemaErrorBoundary>
+* ```tsx
+* import { SchemaErrorBoundary } from "schema-components/react/SchemaErrorBoundary";
+*
+* <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
+*   <SchemaComponent schema={userSchema} value={user} />
+* </SchemaErrorBoundary>
+* ```
 *
 * The boundary catches `SchemaRenderError` from theme adapters and any
 * other errors thrown during rendering. It does NOT catch:

package/dist/react/SchemaView.d.mts

@@ -3,7 +3,7 @@ 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 { a as InferredValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/SchemaView.d.ts
@@ -38,10 +38,11 @@ interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefine
    */
   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.
+   * 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?: InferredValue<T, Ref, undefined, Mode>;
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "schema-components",
-    "version": "2.0.1",
+    "version": "2.0.2",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
     "exports": {