schema-components 1.28.2 → 1.29.0

package/dist/{adapter-DqlAnZ_w.d.mts → adapter-DcWi4XXn.d.mts}

@@ -1,11 +1,28 @@
-import { m as JsonObject, w as SchemaMeta } from "./types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "./diagnostics-Cbwak-ZX.mjs";
+import { m as JsonObject, w as SchemaMeta } from "./types-C2Ay1FEh.mjs";
+import { i as DiagnosticsOptions } from "./diagnostics-ByEzkjrA.mjs";
 
 //#region src/core/adapter.d.ts
+/**
+ * Permissive input alias accepted by {@link normaliseSchema}. Every
+ * supported source (Zod 4 schema, plain JSON Schema, OpenAPI document)
+ * is reachable through `Record<string, unknown>`, so consumers can
+ * accept the union without committing to a specific shape at the API
+ * boundary.
+ *
+ * @group Adapter
+ */
 type SchemaInput = Record<string, unknown>;
+/**
+ * Classification produced by {@link detectSchemaKind} when inspecting a
+ * runtime schema input.
+ *
+ * @group Adapter
+ */
 type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
 /**
- * Classify the input schema by its structural markers.
+ * Classify a runtime schema input by structural markers — Zod 4, Zod 3,
+ * OpenAPI document, plain JSON Schema, or an unsupported third-party
+ * schema library.
  *
  * - `zod4` — has a `_zod` marker (further validation that `_zod.def` is a
  *   non-null object happens inside `normaliseZod4`).
@@ -20,6 +37,8 @@ type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-sche
  *   implementations (valibot, arktype, etc.) that would otherwise flow
  *   through as "malformed JSON Schema".
  * - `jsonSchema` — fallback for anything that does not match the above.
+ *
+ * @group Adapter
  */
 declare function detectSchemaKind(input: unknown): SchemaKind;
 /**
@@ -90,12 +109,16 @@ declare function detectSchemaKind(input: unknown): SchemaKind;
  * field so consumers can still inspect the Zod stack trace.
  */
 /**
- * IO side passed to the internal `callToJsonSchema` helper. The Zod runtime accepts
- * `"input" | "output"` for the corresponding `io` option on
- * `z.toJSONSchema`. Defaults to `"output"` everywhere in the adapter
- * pipeline; the parameter exists so a future renderer or component
- * (currently SchemaComponent — see TODO below) can request the input
- * side without forking the helper.
+ * Direction of the Zod transform / pipe / codec that
+ * {@link normaliseSchema} should surface to the renderer.
+ *
+ * - `"output"` (default) — the server-facing side of every transform,
+ *   matching `z.toJSONSchema`'s default and the historic adapter
+ *   behaviour.
+ * - `"input"` — the client-facing side; flips a `z.codec(...)` chain
+ *   so consumers can render its input shape.
+ *
+ * @group Adapter
  */
 type SchemaIoSide = "input" | "output";
 /**
@@ -125,6 +148,14 @@ declare function isCodecSchema(value: unknown): boolean;
 declare const __CLASSIFIER_RULES_FOR_TEST: readonly {
   readonly prefix: string;
 }[];
+/**
+ * Result of {@link normaliseSchema}. Carries the canonical Draft 2020-12
+ * JSON Schema the walker consumes, the optional original Zod schema
+ * (used for validation), and the resolved root document so cross-document
+ * `$ref`s can be dereferenced downstream.
+ *
+ * @group Adapter
+ */
 interface NormalisedSchema {
   /** JSON Schema object — the authoritative schema for rendering. */
   jsonSchema: JsonObject;
@@ -135,6 +166,11 @@ interface NormalisedSchema {
   /** The root document for $ref resolution. */
   rootDocument: JsonObject;
 }
+/**
+ * Options accepted by {@link normaliseSchema}.
+ *
+ * @group Adapter
+ */
 interface NormaliseOptions {
   /** Diagnostics channel for surfacing silent fallbacks. */
   diagnostics?: DiagnosticsOptions;
@@ -149,6 +185,21 @@ interface NormaliseOptions {
    */
   io?: SchemaIoSide;
 }
+/**
+ * Normalise any supported schema input — Zod 4 schema, plain JSON
+ * Schema (any draft), Swagger 2.0, OpenAPI 3.0 or 3.1 document — into
+ * a canonical Draft 2020-12 {@link NormalisedSchema} the walker can
+ * consume.
+ *
+ * Dispatches on {@link detectSchemaKind}, applies the appropriate
+ * version normaliser, and returns the JSON Schema alongside the
+ * original Zod schema (for validation) and the resolved root document
+ * (for cross-document `$ref` resolution). Throws
+ * `SchemaNormalisationError` for unsupported inputs (Zod 3, valibot,
+ * arktype, codec or other unrepresentable Zod types).
+ *
+ * @group Adapter
+ */
 declare function normaliseSchema(input: unknown, ref?: string, options?: NormaliseOptions): NormalisedSchema;
 /**
  * Surface root-level metadata from the JSON Schema into the `rootMeta`

package/dist/core/adapter.d.mts

@@ -1,3 +1,3 @@
-import { m as JsonObject, w as SchemaMeta } from "../types-BTB73MB8.mjs";
-import { a as SchemaKind, c as extractRootMetaFromJson, i as SchemaIoSide, l as isCodecSchema, n as NormalisedSchema, o as __CLASSIFIER_RULES_FOR_TEST, r as SchemaInput, s as detectSchemaKind, t as NormaliseOptions, u as normaliseSchema } from "../adapter-DqlAnZ_w.mjs";
+import { m as JsonObject, w as SchemaMeta } from "../types-C2Ay1FEh.mjs";
+import { a as SchemaKind, c as extractRootMetaFromJson, i as SchemaIoSide, l as isCodecSchema, n as NormalisedSchema, o as __CLASSIFIER_RULES_FOR_TEST, r as SchemaInput, s as detectSchemaKind, t as NormaliseOptions, u as normaliseSchema } from "../adapter-DcWi4XXn.mjs";
 export { JsonObject, NormaliseOptions, NormalisedSchema, SchemaInput, SchemaIoSide, SchemaKind, SchemaMeta, __CLASSIFIER_RULES_FOR_TEST, detectSchemaKind, extractRootMetaFromJson, isCodecSchema, normaliseSchema };

package/dist/core/adapter.mjs

@@ -20,7 +20,9 @@ import { z } from "zod";
 */
 const schemaCache = /* @__PURE__ */ new WeakMap();
 /**
-* Classify the input schema by its structural markers.
+* Classify a runtime schema input by structural markers — Zod 4, Zod 3,
+* OpenAPI document, plain JSON Schema, or an unsupported third-party
+* schema library.
 *
 * - `zod4` — has a `_zod` marker (further validation that `_zod.def` is a
 *   non-null object happens inside `normaliseZod4`).
@@ -35,6 +37,8 @@ const schemaCache = /* @__PURE__ */ new WeakMap();
 *   implementations (valibot, arktype, etc.) that would otherwise flow
 *   through as "malformed JSON Schema".
 * - `jsonSchema` — fallback for anything that does not match the above.
+*
+* @group Adapter
 */
 function detectSchemaKind(input) {
 	if (hasProperty(input, "_zod")) return "zod4";
@@ -624,6 +628,21 @@ function classifyZodConversionError(err, schema) {
 * `prefix` value and assert mutual non-prefixing.
 */
 const __CLASSIFIER_RULES_FOR_TEST = CLASSIFIER_RULES;
+/**
+* Normalise any supported schema input — Zod 4 schema, plain JSON
+* Schema (any draft), Swagger 2.0, OpenAPI 3.0 or 3.1 document — into
+* a canonical Draft 2020-12 {@link NormalisedSchema} the walker can
+* consume.
+*
+* Dispatches on {@link detectSchemaKind}, applies the appropriate
+* version normaliser, and returns the JSON Schema alongside the
+* original Zod schema (for validation) and the resolved root document
+* (for cross-document `$ref` resolution). Throws
+* `SchemaNormalisationError` for unsupported inputs (Zod 3, valibot,
+* arktype, codec or other unrepresentable Zod types).
+*
+* @group Adapter
+*/
 function normaliseSchema(input, ref, options) {
 	const usesDiagnostics = options?.diagnostics !== void 0;
 	const nonDefaultIo = options?.io !== void 0 && options.io !== "output";

package/dist/core/constraints.d.mts

@@ -1,11 +1,43 @@
-import { E as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { E as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-C2Ay1FEh.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-ByEzkjrA.mjs";
 
 //#region src/core/constraints.d.ts
+/**
+ * Read the JSON Schema string constraint keywords (`minLength`,
+ * `maxLength`, `pattern`, `format`, `contentEncoding`,
+ * `contentMediaType`) from a schema node and return them in the
+ * `StringConstraints` shape consumed by string field renderers.
+ * Emits an `unknown-format` diagnostic for unrecognised `format`
+ * values.
+ */
 declare function extractStringConstraints(schema: Record<string, unknown>, diagnostics?: DiagnosticsOptions, pointer?: string): StringConstraints;
+/**
+ * Read the JSON Schema number constraint keywords (`minimum`,
+ * `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`)
+ * from a schema node and return them in the `NumberConstraints` shape
+ * consumed by number field renderers.
+ */
 declare function extractNumberConstraints(schema: Record<string, unknown>): NumberConstraints;
+/**
+ * Read the JSON Schema array constraint keywords (`minItems`,
+ * `maxItems`, `uniqueItems`, `minContains`, `maxContains`) from a
+ * schema node and return them in the `ArrayConstraints` shape. The
+ * `contains` and `unevaluatedItems` sub-schemas are walked separately
+ * and surfaced on the `ArrayField` / `TupleField` directly rather
+ * than as raw constraints.
+ */
 declare function extractArrayConstraints(schema: Record<string, unknown>): ArrayConstraints;
+/**
+ * Read the JSON Schema object constraint keywords (`minProperties`,
+ * `maxProperties`) from a schema node and return them in the
+ * `ObjectConstraints` shape.
+ */
 declare function extractObjectConstraints(schema: Record<string, unknown>): ObjectConstraints;
+/**
+ * Read the JSON Schema file constraints from a schema node — currently
+ * just `contentMediaType`, which surfaces as the single-entry
+ * `mimeTypes` array on `FileConstraints`.
+ */
 declare function extractFileConstraints(schema: Record<string, unknown>): FileConstraints;
 /**
  * Return a copy of the schema with constraint keywords that don't apply

package/dist/core/constraints.mjs

@@ -9,6 +9,14 @@ function getNumber(obj, key) {
 	const value = obj[key];
 	return typeof value === "number" ? value : void 0;
 }
+/**
+* Read the JSON Schema string constraint keywords (`minLength`,
+* `maxLength`, `pattern`, `format`, `contentEncoding`,
+* `contentMediaType`) from a schema node and return them in the
+* `StringConstraints` shape consumed by string field renderers.
+* Emits an `unknown-format` diagnostic for unrecognised `format`
+* values.
+*/
 function extractStringConstraints(schema, diagnostics, pointer = "") {
 	const c = {};
 	const minLength = getNumber(schema, "minLength");
@@ -35,6 +43,12 @@ function extractStringConstraints(schema, diagnostics, pointer = "") {
 	if (contentMediaType !== void 0) c.contentMediaType = contentMediaType;
 	return c;
 }
+/**
+* Read the JSON Schema number constraint keywords (`minimum`,
+* `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`)
+* from a schema node and return them in the `NumberConstraints` shape
+* consumed by number field renderers.
+*/
 function extractNumberConstraints(schema) {
 	const c = {};
 	const minimum = getNumber(schema, "minimum");
@@ -49,6 +63,14 @@ function extractNumberConstraints(schema) {
 	if (multipleOf !== void 0) c.multipleOf = multipleOf;
 	return c;
 }
+/**
+* Read the JSON Schema array constraint keywords (`minItems`,
+* `maxItems`, `uniqueItems`, `minContains`, `maxContains`) from a
+* schema node and return them in the `ArrayConstraints` shape. The
+* `contains` and `unevaluatedItems` sub-schemas are walked separately
+* and surfaced on the `ArrayField` / `TupleField` directly rather
+* than as raw constraints.
+*/
 function extractArrayConstraints(schema) {
 	const c = {};
 	const minItems = getNumber(schema, "minItems");
@@ -62,6 +84,11 @@ function extractArrayConstraints(schema) {
 	if (maxContains !== void 0) c.maxContains = maxContains;
 	return c;
 }
+/**
+* Read the JSON Schema object constraint keywords (`minProperties`,
+* `maxProperties`) from a schema node and return them in the
+* `ObjectConstraints` shape.
+*/
 function extractObjectConstraints(schema) {
 	const c = {};
 	const minProperties = getNumber(schema, "minProperties");
@@ -70,6 +97,11 @@ function extractObjectConstraints(schema) {
 	if (maxProperties !== void 0) c.maxProperties = maxProperties;
 	return c;
 }
+/**
+* Read the JSON Schema file constraints from a schema node — currently
+* just `contentMediaType`, which surfaces as the single-entry
+* `mimeTypes` array on `FileConstraints`.
+*/
 function extractFileConstraints(schema) {
 	const c = {};
 	const contentMediaType = getString(schema, "contentMediaType");

package/dist/core/cssClasses.d.mts

@@ -47,6 +47,7 @@ declare const SC_CLASSES: {
   readonly never: "sc-never";
   readonly recursive: "sc-recursive";
 };
+/** Stable string-literal key into the canonical {@link SC_CLASSES} map. */
 type ScClassKey = keyof typeof SC_CLASSES;
 //#endregion
 export { ELLIPSIS, EM_DASH, SC_CLASSES, SC_ID_PREFIX, ScClassKey };

package/dist/core/diagnostics.d.mts

@@ -1,2 +1,2 @@
-import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-Cbwak-ZX.mjs";
+import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-ByEzkjrA.mjs";
 export { Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticsOptions, appendPointer, emitDiagnostic };

package/dist/core/errors.d.mts

@@ -1,2 +1,2 @@
-import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DQSIK4n1.mjs";
+import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-D8JndRwI.mjs";
 export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError };

package/dist/core/errors.mjs

@@ -1,12 +1,15 @@
 //#region src/core/errors.ts
 /**
-* Base class for all schema-components errors.
-* Catch this to handle any library error uniformly.
+* Base class for every schema-components error. Catch this to handle
+* any library error uniformly.
 *
-* Forwards the optional `cause` to the native ES2022 `Error` constructor so
-* `error.cause` is wired up by the runtime and rendered correctly by
-* `util.inspect` ("Caused by: ..."). Subclasses that need a typed `cause`
-* field still get it via the platform's own `Error.cause` getter.
+* Forwards the optional `cause` to the native ES2022 `Error` constructor
+* so `error.cause` is wired up by the runtime and rendered correctly by
+* `util.inspect` ("Caused by: ..."). Subclasses that need a typed
+* `cause` field still get it via the platform's own `Error.cause`
+* getter.
+*
+* @group Errors
 */
 var SchemaError = class extends Error {
 	/** The schema input that caused the error. */
@@ -21,7 +24,12 @@ var SchemaError = class extends Error {
 * The adapter failed to convert the input schema to JSON Schema.
 *
 * Causes: invalid Zod schema, Zod 3 schema (unsupported), malformed
-* JSON Schema, missing OpenAPI ref, unsupported ref format.
+* JSON Schema, missing OpenAPI ref, unsupported ref format,
+* unrepresentable Zod types, conversion bugs, cycles, and duplicate
+* ids. The `kind` field carries the precise classification — see the
+* union declaration below.
+*
+* @group Errors
 */
 var SchemaNormalisationError = class extends SchemaError {
 	kind;
@@ -38,9 +46,10 @@ var SchemaNormalisationError = class extends SchemaError {
 	}
 };
 /**
-* A theme adapter's render function threw during rendering.
+* A theme adapter's render function threw during rendering. The
+* original error is preserved on `cause`.
 *
-* The `cause` is the original error from the render function.
+* @group Errors
 */
 var SchemaRenderError = class extends SchemaError {
 	/**
@@ -56,10 +65,11 @@ var SchemaRenderError = class extends SchemaError {
 	}
 };
 /**
-* A field path couldn't be resolved against the walked schema tree.
+* A field path could not be resolved against the walked schema tree.
+* Produced by `<SchemaField>` when the `path` prop does not match any
+* field in the schema.
 *
-* This is produced by `<SchemaField>` when the `path` prop doesn't
-* match any field in the schema.
+* @group Errors
 */
 var SchemaFieldError = class extends SchemaError {
 	/** The unresolvable dot-separated path. */

package/dist/core/fieldOrder.d.mts

@@ -1,4 +1,4 @@
-import { j as WalkedField } from "../types-BTB73MB8.mjs";
+import { j as WalkedField } from "../types-C2Ay1FEh.mjs";
 
 //#region src/core/fieldOrder.d.ts
 /**

package/dist/core/formats.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-ByEzkjrA.mjs";
 
 //#region src/core/formats.d.ts
 /**
@@ -52,6 +52,12 @@ type FormatValidator = RegExp | ((value: string) => boolean);
  * directly. Used by the URI safety helpers for mailto address checks.
  */
 declare const EMAIL_FORMAT_PATTERN: RegExp;
+/**
+ * Map of recognised JSON Schema string `format` values to RegExp
+ * patterns. Consumed by `extractStringConstraints` to derive a
+ * client-side `formatPattern` for renderers, and by
+ * {@link validateFormat} for runtime checks.
+ */
 declare const FORMAT_PATTERNS: Readonly<Record<string, RegExp>>;
 /**
  * Validate a string value against format constraints.

package/dist/core/formats.mjs

@@ -51,6 +51,12 @@ function dateInputType(format) {
 * directly. Used by the URI safety helpers for mailto address checks.
 */
 const EMAIL_FORMAT_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/**
+* Map of recognised JSON Schema string `format` values to RegExp
+* patterns. Consumed by `extractStringConstraints` to derive a
+* client-side `formatPattern` for renderers, and by
+* {@link validateFormat} for runtime checks.
+*/
 const FORMAT_PATTERNS = {
 	uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
 	email: EMAIL_FORMAT_PATTERN,

package/dist/core/limits.d.mts

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

package/dist/core/limits.mjs

@@ -12,6 +12,7 @@
 * — the only safe response to a cyclic walked-field graph.
 */
 const MAX_RENDER_DEPTH = 10;
+/** Runtime constant matching the type-level {@link MaxRefDepth} bound. */
 const MAX_REF_DEPTH = 64;
 /**
 * Maximum number of `$ref` hops permitted when walking a chain of

package/dist/core/merge.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-ByEzkjrA.mjs";
 
 //#region src/core/merge.d.ts
 /**
@@ -45,6 +45,11 @@ declare function mergeRefSiblings(referencer: Record<string, unknown>, resolvedM
  * inputs that cannot represent a schema; skip them as before.
  */
 declare function mergeAllOf(schemas: unknown[], diagnostics?: DiagnosticsOptions, pointer?: string): Record<string, unknown> | false;
+/**
+ * Result returned by {@link normaliseAnyOf} when an `anyOf` schema
+ * collapses to a nullable shape: the non-null branch and the nullable
+ * flag.
+ */
 interface NormalisedAnyOf {
   inner: Record<string, unknown>;
   isNullable: boolean;
@@ -54,6 +59,11 @@ interface NormalisedAnyOf {
  * Returns the non-null schema and a nullable flag.
  */
 declare function normaliseAnyOf(options: unknown[]): NormalisedAnyOf | undefined;
+/**
+ * Result returned by {@link detectDiscriminated} when a `oneOf` schema
+ * is structurally a discriminated union: the option schemas plus the
+ * shared property name carrying the const discriminator.
+ */
 interface Discriminated {
   options: Record<string, unknown>[];
   discriminator: string;

package/dist/core/normalise.d.mts

@@ -1,7 +1,15 @@
-import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
-import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-ZzL5R6cS.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-ByEzkjrA.mjs";
+import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-DL8U5RuA.mjs";
 
 //#region src/core/normalise.d.ts
+/**
+ * Per-node transform applied by {@link deepNormalise} when no
+ * diagnostics context needs to be threaded — see
+ * {@link NodeTransformWithContext} for the variant used by the JSON
+ * Schema normalisation path.
+ *
+ * @group Adapter
+ */
 type NodeTransform = (node: Record<string, unknown>) => Record<string, unknown>;
 /**
  * Deep-normalise a JSON Schema object by applying a per-node transform
@@ -43,6 +51,13 @@ interface NodeContext {
   documentHasRecursiveAnchor: boolean;
   declaredDraft: JsonSchemaDraft | undefined;
 }
+/**
+ * Per-node transform applied by {@link deepNormaliseWithContext}.
+ * Receives the supplied {@link NodeContext} alongside the node so
+ * draft-specific rewrites can emit diagnostics with accurate pointers.
+ *
+ * @group Adapter
+ */
 type NodeTransformWithContext = (node: Record<string, unknown>, ctx: NodeContext) => Record<string, unknown>;
 /**
  * Deep-normalise a JSON Schema object, threading a context (diagnostics

package/dist/core/openapiConstants.d.mts

@@ -12,6 +12,7 @@
  * Spec: https://spec.openapis.org/oas/v3.1.1#path-item-object
  */
 declare const HTTP_METHODS: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+/** Canonical OpenAPI 3.x HTTP method literal, derived from {@link HTTP_METHODS}. */
 type HttpMethod = (typeof HTTP_METHODS)[number];
 /**
  * Swagger 2.0 omits `trace` — the keyword was introduced in OpenAPI 3.0.

package/dist/core/ref.d.mts

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

package/dist/core/renderer.d.mts

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

package/dist/core/renderer.mjs

@@ -29,6 +29,11 @@ function buildRenderProps(tree, value, onChange, renderChild, path) {
 	if (tree.examples !== void 0) props.examples = tree.examples;
 	return props;
 }
+/**
+* Canonical list of resolver keys, one per {@link WalkedField} variant.
+* Iterated by the resolver merge helpers so adding a new key here is the
+* single point of change when a new field variant is introduced.
+*/
 const RESOLVER_KEYS = [
 	"string",
 	"number",

package/dist/core/swagger2.d.mts

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

package/dist/core/typeInference.d.mts

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

package/dist/core/types.d.mts

@@ -1,2 +1,2 @@
-import { A as UnknownField, B as isNeverField, C as RecordField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isNumberField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as ObjectField, T as SchemaType, U as isObjectField, V as isNullField, W as isRecordField, Y as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as SchemaMeta, x as ObjectConstraints, y as NumberConstraints, z as isNegationField } from "../types-BTB73MB8.mjs";
+import { A as UnknownField, B as isNeverField, C as RecordField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isNumberField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as ObjectField, T as SchemaType, U as isObjectField, V as isNullField, W as isRecordField, Y as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as SchemaMeta, x as ObjectConstraints, y as NumberConstraints, z as isNegationField } from "../types-C2Ay1FEh.mjs";
 export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NeverField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/types.mjs

@@ -38,54 +38,71 @@ function resolveEditability(propertyMeta, componentMeta, rootMeta) {
 function isField(field, t) {
 	return field.type === t;
 }
+/** Type guard: narrows a `WalkedField` to its `string` variant. */
 function isStringField(field) {
 	return isField(field, "string");
 }
+/** Type guard: narrows a `WalkedField` to its `number` variant. */
 function isNumberField(field) {
 	return isField(field, "number");
 }
+/** Type guard: narrows a `WalkedField` to its `boolean` variant. */
 function isBooleanField(field) {
 	return isField(field, "boolean");
 }
+/** Type guard: narrows a `WalkedField` to its `null` variant. */
 function isNullField(field) {
 	return isField(field, "null");
 }
+/** Type guard: narrows a `WalkedField` to its `enum` variant. */
 function isEnumField(field) {
 	return isField(field, "enum");
 }
+/** Type guard: narrows a `WalkedField` to its `literal` variant. */
 function isLiteralField(field) {
 	return isField(field, "literal");
 }
+/** Type guard: narrows a `WalkedField` to its `object` variant. */
 function isObjectField(field) {
 	return isField(field, "object");
 }
+/** Type guard: narrows a `WalkedField` to its `array` variant. */
 function isArrayField(field) {
 	return isField(field, "array");
 }
+/** Type guard: narrows a `WalkedField` to its `tuple` variant. */
 function isTupleField(field) {
 	return isField(field, "tuple");
 }
+/** Type guard: narrows a `WalkedField` to its `record` variant. */
 function isRecordField(field) {
 	return isField(field, "record");
 }
+/** Type guard: narrows a `WalkedField` to its plain `union` variant. */
 function isUnionField(field) {
 	return isField(field, "union");
 }
+/** Type guard: narrows a `WalkedField` to its `discriminatedUnion` variant. */
 function isDiscriminatedUnionField(field) {
 	return isField(field, "discriminatedUnion");
 }
+/** Type guard: narrows a `WalkedField` to its `conditional` (if/then/else) variant. */
 function isConditionalField(field) {
 	return isField(field, "conditional");
 }
+/** Type guard: narrows a `WalkedField` to its `negation` (`not`) variant. */
 function isNegationField(field) {
 	return isField(field, "negation");
 }
+/** Type guard: narrows a `WalkedField` to its `file` variant. */
 function isFileField(field) {
 	return isField(field, "file");
 }
+/** Type guard: narrows a `WalkedField` to its `never` variant (false schema). */
 function isNeverField(field) {
 	return isField(field, "never");
 }
+/** Type guard: narrows a `WalkedField` to its `unknown` variant (permissive). */
 function isUnknownField(field) {
 	return isField(field, "unknown");
 }

package/dist/core/unionMatch.d.mts

@@ -1,4 +1,4 @@
-import { j as WalkedField } from "../types-BTB73MB8.mjs";
+import { j as WalkedField } from "../types-C2Ay1FEh.mjs";
 
 //#region src/core/unionMatch.d.ts
 /**

package/dist/core/version.d.mts

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