schema-components 1.13.0 → 1.15.0

package/README.md

@@ -14,6 +14,10 @@ npm install schema-components
 
 Peer dependencies: `zod@^4.0.0`, `react@^18.0.0 || ^19.0.0`.
 
+### Zod version requirement
+
+schema-components requires **Zod 4**. If you are on Zod 3, see the [Zod 4 migration guide](https://zod.dev/v4/migration). The library detects Zod 3 inputs and throws a descriptive error rather than silently misbehaving.
+
 ## `SchemaComponent`
 
 The single entry point. Accepts Zod schemas, JSON Schema objects, or OpenAPI documents:

package/dist/core/adapter.d.mts

@@ -1,4 +1,5 @@
-import { m as JsonObject, w as SchemaMeta } from "../types-ag2jYLqQ.mjs";
+import { T as SchemaMeta, m as JsonObject } from "../types-D_5ST7SS.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
 
 //#region src/core/adapter.d.ts
 type SchemaInput = Record<string, unknown>;
@@ -14,6 +15,10 @@ interface NormalisedSchema {
   /** The root document for $ref resolution. */
   rootDocument: JsonObject;
 }
-declare function normaliseSchema(input: unknown, ref?: string): NormalisedSchema;
+interface NormaliseOptions {
+  /** Diagnostics channel for surfacing silent fallbacks. */
+  diagnostics?: DiagnosticsOptions;
+}
+declare function normaliseSchema(input: unknown, ref?: string, options?: NormaliseOptions): NormalisedSchema;
 //#endregion
-export { type JsonObject, NormalisedSchema, SchemaInput, SchemaKind, type SchemaMeta, detectSchemaKind, normaliseSchema };
+export { type JsonObject, NormaliseOptions, NormalisedSchema, SchemaInput, SchemaKind, type SchemaMeta, detectSchemaKind, normaliseSchema };

package/dist/core/adapter.mjs

@@ -1,7 +1,8 @@
 import { getProperty, hasProperty, isObject } from "./guards.mjs";
+import { emitDiagnostic } from "./diagnostics.mjs";
 import { dereference } from "./ref.mjs";
-import { detectJsonSchemaDraft, detectOpenApiVersion, isSwagger2 } from "./version.mjs";
-import { normaliseJsonSchema as normaliseJsonSchema$1, normaliseOpenApiSchemas } from "./normalise.mjs";
+import { detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraftWithReason, isSwagger2 } from "./version.mjs";
+import { i as normaliseOpenApiSchemas, r as normaliseJsonSchema$1 } from "../normalise-tL9FckAk.mjs";
 import { z } from "zod";
 //#region src/core/adapter.ts
 /**
@@ -33,7 +34,7 @@ function detectSchemaKind(input) {
 function callToJsonSchema(schema) {
 	return z.toJSONSchema(schema);
 }
-function normaliseSchema(input, ref) {
+function normaliseSchema(input, ref, options) {
 	if (ref === void 0 && isObject(input)) {
 		const cached = schemaCache.get(input);
 		if (cached !== void 0) return cached;
@@ -49,11 +50,11 @@ function normaliseSchema(input, ref) {
 			break;
 		case "openapi":
 			if (!isObject(input)) throw new Error("Invalid OpenAPI document");
-			result = normaliseOpenApi(input, ref);
+			result = normaliseOpenApi(input, ref, options);
 			break;
 		case "jsonSchema":
 			if (!isObject(input)) throw new Error("Invalid JSON Schema");
-			result = normaliseJsonSchema(input);
+			result = normaliseJsonSchema(input, options?.diagnostics);
 			break;
 	}
 	if (ref === void 0 && isObject(input)) schemaCache.set(input, result);
@@ -72,8 +73,22 @@ function normaliseZod4(input) {
 		rootDocument: jsonSchema
 	};
 }
-function normaliseJsonSchema(jsonSchema) {
-	const normalised = normaliseJsonSchema$1(jsonSchema, detectJsonSchemaDraft(jsonSchema));
+function normaliseJsonSchema(jsonSchema, diagnostics) {
+	let draft;
+	if (typeof jsonSchema.$schema !== "string") {
+		const inferred = inferJsonSchemaDraftWithReason(jsonSchema);
+		draft = inferred.draft;
+		emitDiagnostic(diagnostics, {
+			code: "assumed-draft",
+			message: `No $schema present; inferred ${inferred.draft} from keywords (${inferred.inferredFrom})`,
+			pointer: "",
+			detail: {
+				inferredFrom: inferred.inferredFrom,
+				draft: inferred.draft
+			}
+		});
+	} else draft = detectJsonSchemaDraft(jsonSchema);
+	const normalised = normaliseJsonSchema$1(jsonSchema, draft);
 	return {
 		jsonSchema: normalised,
 		rootMeta: extractRootMetaFromJson(normalised),
@@ -81,7 +96,7 @@ function normaliseJsonSchema(jsonSchema) {
 	};
 }
 function normaliseZod3() {
-	throw new Error("Zod 3 schemas are not yet supported. Convert to Zod 4 or provide JSON Schema directly.");
+	throw new Error("Zod 3 schemas are not supported. schema-components requires Zod 4. Detected: Zod 3 (has _def without _zod). See the Zod 4 migration guide at https://zod.dev/v4/migration or run: pnpm add zod@^4");
 }
 /**
 * Mapping of Swagger 2.0 $ref prefixes to their OpenAPI 3.x equivalents.
@@ -93,9 +108,9 @@ const REF_REWRITES_ADAPTER = [
 	["#/parameters/", "#/components/parameters/"],
 	["#/responses/", "#/components/responses/"]
 ];
-function normaliseOpenApi(doc, ref) {
+function normaliseOpenApi(doc, ref, options) {
 	const version = detectOpenApiVersion(doc);
-	const normalisedDoc = version !== void 0 ? normaliseOpenApiSchemas(doc, version) : doc;
+	const normalisedDoc = version !== void 0 ? normaliseOpenApiSchemas(doc, version, options?.diagnostics) : doc;
 	let rewrittenRef = ref;
 	if (rewrittenRef !== void 0 && version !== void 0 && isSwagger2(version)) {
 		for (const [from, to] of REF_REWRITES_ADAPTER) if (rewrittenRef.startsWith(from)) {

package/dist/core/constraints.d.mts

@@ -1,7 +1,8 @@
-import { E as StringConstraints, b as ObjectConstraints, f as FileConstraints, t as ArrayConstraints, v as NumberConstraints } from "../types-ag2jYLqQ.mjs";
+import { D as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-D_5ST7SS.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
 
 //#region src/core/constraints.d.ts
-declare function extractStringConstraints(schema: Record<string, unknown>): StringConstraints;
+declare function extractStringConstraints(schema: Record<string, unknown>, diagnostics?: DiagnosticsOptions, pointer?: string): StringConstraints;
 declare function extractNumberConstraints(schema: Record<string, unknown>): NumberConstraints;
 declare function extractArrayConstraints(schema: Record<string, unknown>): ArrayConstraints;
 declare function extractObjectConstraints(schema: Record<string, unknown>): ObjectConstraints;

package/dist/core/constraints.mjs

@@ -1,4 +1,6 @@
 import { isObject } from "./guards.mjs";
+import { emitDiagnostic } from "./diagnostics.mjs";
+import { FORMAT_PATTERNS } from "./formats.mjs";
 //#region src/core/constraints.ts
 function getString(obj, key) {
 	const value = obj[key];
@@ -12,7 +14,7 @@ function getObject(obj, key) {
 	const value = obj[key];
 	return isObject(value) ? value : void 0;
 }
-function extractStringConstraints(schema) {
+function extractStringConstraints(schema, diagnostics, pointer = "") {
 	const c = {};
 	const minLength = getNumber(schema, "minLength");
 	if (minLength !== void 0) c.minLength = minLength;
@@ -21,7 +23,17 @@ function extractStringConstraints(schema) {
 	const pattern = getString(schema, "pattern");
 	if (pattern !== void 0) c.pattern = pattern;
 	const format = getString(schema, "format");
-	if (format !== void 0) c.format = format;
+	if (format !== void 0) {
+		c.format = format;
+		const pattern = FORMAT_PATTERNS[format];
+		if (pattern !== void 0) c.formatPattern = pattern;
+		else if (format !== "binary") emitDiagnostic(diagnostics, {
+			code: "unknown-format",
+			message: `Unknown format: ${format}`,
+			pointer,
+			detail: { format }
+		});
+	}
 	const contentEncoding = getString(schema, "contentEncoding");
 	if (contentEncoding !== void 0) c.contentEncoding = contentEncoding;
 	const contentMediaType = getString(schema, "contentMediaType");

package/dist/core/diagnostics.d.mts

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

package/dist/core/diagnostics.mjs

@@ -0,0 +1,33 @@
+import { SchemaNormalisationError } from "./errors.mjs";
+//#region src/core/diagnostics.ts
+/**
+* Diagnostics channel for schema-components.
+*
+* Provides a structured way to surface silent fallbacks — unresolved `$ref`,
+* unknown keywords, unknown `format` values, invalid `const` values,
+* unsupported `type` entries, dropped Swagger 2.0 features, external
+* `$ref`, type-negation fallbacks, and conditional fallbacks.
+*
+* Consumers pass a `DiagnosticSink` callback to receive diagnostics
+* as they occur. By default, diagnostics are silently discarded.
+* Setting `strict: true` converts any diagnostic into a thrown
+* `SchemaCompatibilityError`.
+*/
+/**
+* Emit a diagnostic through the configured sink.
+* When `strict` is enabled, throws a `SchemaCompatibilityError` instead.
+*/
+function emitDiagnostic(opts, diagnostic) {
+	if (opts?.strict === true) throw new SchemaNormalisationError(`[${diagnostic.code}] ${diagnostic.message} (at ${diagnostic.pointer})`, diagnostic.detail, "unknown");
+	if (opts?.diagnostics !== void 0) opts.diagnostics(diagnostic);
+}
+/**
+* Append a segment to a JSON Pointer.
+* Encodes `/` and `~` per RFC 6901.
+*/
+function appendPointer(base, segment) {
+	const escaped = segment.replace(/~/g, "~0").replace(/\//g, "~1");
+	return base === "" ? `/${escaped}` : `${base}/${escaped}`;
+}
+//#endregion
+export { 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-DIKI2C78.mjs";
+import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-C5zRC2PU.mjs";
 export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError };

package/dist/core/formats.d.mts

@@ -0,0 +1,33 @@
+//#region src/core/formats.d.ts
+/**
+ * Built-in format patterns for JSON Schema string validation.
+ *
+ * Maps standard JSON Schema/OpenAPI `format` values to RegExp patterns
+ * or predicate validators. Used by the constraint extractor to derive
+ * `formatPattern` alongside the existing `format` string, and by the
+ * `validate` helper for runtime format checking.
+ *
+ * Formats that cannot be validated by regex (iri, regex) use predicate
+ * functions instead. `validateFormat` dispatches to whichever is available.
+ *
+ * The user's explicit `pattern` constraint always takes precedence —
+ * `formatPattern` is exposed as a separate field for renderers.
+ */
+/**
+ * A format validator: either a RegExp pattern or a predicate function.
+ */
+type FormatValidator = RegExp | ((value: string) => boolean);
+/**
+ * Recognised JSON Schema formats with their validation patterns.
+ * Unknown formats emit an `unknown-format` diagnostic and skip derivation.
+ */
+declare const FORMAT_PATTERNS: Readonly<Record<string, RegExp>>;
+/**
+ * Validate a string value against format constraints.
+ * Returns `true` when the value matches the format,
+ * `false` when it does not, and `undefined` when the format
+ * is not recognised (no validator available).
+ */
+declare function validateFormat(value: string, format: string): boolean | undefined;
+//#endregion
+export { FORMAT_PATTERNS, FormatValidator, validateFormat };

package/dist/core/formats.mjs

@@ -0,0 +1,67 @@
+//#region src/core/formats.ts
+/**
+* Recognised JSON Schema formats with their validation patterns.
+* Unknown formats emit an `unknown-format` diagnostic and skip derivation.
+*/
+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: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+	"date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
+	date: /^\d{4}-\d{2}-\d{2}$/,
+	time: /^\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/,
+	ipv4: /^(\d{1,3}\.){3}\d{1,3}$/,
+	ipv6: /^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$/i,
+	uri: /^[a-z][a-z0-9+\-.]*:/i,
+	hostname: /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i,
+	"uri-reference": /^(|[a-z][a-z0-9+\-.]*:|[?#][^\s]*)/i,
+	"uri-template": /^([^{}]|[{][+#/.;?&=,!@|]([a-zA-Z0-9_%.]+)?(:[1-9][0-9]*)?(,[a-zA-Z0-9_%.]+)*[}])*$/,
+	"json-pointer": /^(([/]([^/~]|~0|~1)*)*|)$/,
+	"relative-json-pointer": /^(0|[1-9][0-9]*)(#?([/]([^/~]|~0|~1)*)*)?$/,
+	duration: /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/,
+	"idn-email": /^[^\s@]+@[^\s@]+\.[^\s@]+$/u,
+	"idn-hostname": /^[a-z0-9\u00a1-\uffff]([a-z0-9\u00a1-\uffff-]{0,61}[a-z0-9\u00a1-\uffff])?(\.[a-z0-9\u00a1-\uffff]([a-z0-9\u00a1-\uffff-]{0,61}[a-z0-9\u00a1-\uffff])?)*$/iu
+};
+/**
+* Format validators that use predicate functions instead of regex.
+* These are checked in `validateFormat` when no regex pattern exists.
+*/
+const PREDICATE_VALIDATORS = {
+	iri: (value) => {
+		try {
+			return new URL(value).protocol.length > 0;
+		} catch {
+			return false;
+		}
+	},
+	"iri-reference": (value) => {
+		if (value === "") return true;
+		try {
+			new URL(value);
+			return true;
+		} catch {
+			return !/\s/.test(value);
+		}
+	},
+	regex: (value) => {
+		try {
+			new RegExp(value);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+/**
+* Validate a string value against format constraints.
+* Returns `true` when the value matches the format,
+* `false` when it does not, and `undefined` when the format
+* is not recognised (no validator available).
+*/
+function validateFormat(value, format) {
+	const pattern = FORMAT_PATTERNS[format];
+	if (pattern !== void 0) return pattern.test(value);
+	const predicate = PREDICATE_VALIDATORS[format];
+	if (predicate !== void 0) return predicate(value);
+}
+//#endregion
+export { FORMAT_PATTERNS, validateFormat };

package/dist/core/merge.d.mts

@@ -5,6 +5,22 @@
  * Used by the walker to handle `allOf`, `anyOf [T, null]`, and
  * `oneOf` with discriminator properties.
  */
+/**
+ * Annotation keywords that can appear as siblings of `$ref` per
+ * Draft 2020-12 / OpenAPI 3.1. Structural keywords (type, properties,
+ * etc.) are NOT annotation siblings and should not be merged.
+ */
+declare const ANNOTATION_SIBLINGS: ReadonlySet<string>;
+/**
+ * Merge annotation siblings from the referencing node onto the
+ * resolved target's annotations. The referencer wins for annotations.
+ *
+ * Structural keywords on the referencer are NOT merged — per spec,
+ * `$ref` with structural siblings was invalid pre-2019-09.
+ *
+ * Returns a new meta object with the merged annotations.
+ */
+declare function mergeRefSiblings(referencer: Record<string, unknown>, resolvedMeta: Record<string, unknown>): Record<string, unknown>;
 /**
  * Merge multiple JSON Schema objects from allOf into one.
  * Merges: properties, required, meta fields, and constraints.
@@ -29,4 +45,4 @@ interface Discriminated {
  */
 declare function detectDiscriminated(options: unknown[]): Discriminated | undefined;
 //#endregion
-export { Discriminated, NormalisedAnyOf, detectDiscriminated, mergeAllOf, normaliseAnyOf };
+export { ANNOTATION_SIBLINGS, Discriminated, NormalisedAnyOf, detectDiscriminated, mergeAllOf, mergeRefSiblings, normaliseAnyOf };

package/dist/core/merge.mjs

@@ -19,6 +19,35 @@ function getObject(obj, key) {
 	return isObject(value) ? value : void 0;
 }
 /**
+* Annotation keywords that can appear as siblings of `$ref` per
+* Draft 2020-12 / OpenAPI 3.1. Structural keywords (type, properties,
+* etc.) are NOT annotation siblings and should not be merged.
+*/
+const ANNOTATION_SIBLINGS = new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$comment"
+]);
+/**
+* Merge annotation siblings from the referencing node onto the
+* resolved target's annotations. The referencer wins for annotations.
+*
+* Structural keywords on the referencer are NOT merged — per spec,
+* `$ref` with structural siblings was invalid pre-2019-09.
+*
+* Returns a new meta object with the merged annotations.
+*/
+function mergeRefSiblings(referencer, resolvedMeta) {
+	const merged = { ...resolvedMeta };
+	for (const key of ANNOTATION_SIBLINGS) if (key in referencer) merged[key] = referencer[key];
+	return merged;
+}
+/**
 * Merge multiple JSON Schema objects from allOf into one.
 * Merges: properties, required, meta fields, and constraints.
 */
@@ -93,4 +122,4 @@ function detectDiscriminated(options) {
 	};
 }
 //#endregion
-export { detectDiscriminated, mergeAllOf, normaliseAnyOf };
+export { ANNOTATION_SIBLINGS, detectDiscriminated, mergeAllOf, mergeRefSiblings, normaliseAnyOf };

package/dist/core/normalise.d.mts

@@ -1,4 +1,5 @@
-import { n as OpenApiVersionInfo, t as JsonSchemaDraft } from "../version-CLchheaH.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { n as JsonSchemaDraft, r as OpenApiVersionInfo } from "../version-B5NV-35j.mjs";
 
 //#region src/core/normalise.d.ts
 type NodeTransform = (node: Record<string, unknown>) => Record<string, unknown>;
@@ -35,6 +36,6 @@ declare function normaliseJsonSchema(schema: Record<string, unknown>, draft: Jso
  * Returns the same object reference if no normalisation is needed
  * (OpenAPI 3.1.x), or a deep-cloned normalised copy otherwise.
  */
-declare function normaliseOpenApiSchemas(doc: Record<string, unknown>, version: OpenApiVersionInfo): Record<string, unknown>;
+declare function normaliseOpenApiSchemas(doc: Record<string, unknown>, version: OpenApiVersionInfo, diagnostics?: DiagnosticsOptions): Record<string, unknown>;
 //#endregion
 export { NodeTransform, deepNormalise, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };

package/dist/core/normalise.mjs

@@ -1,171 +1,2 @@
-import { isObject } from "./guards.mjs";
-import { isOpenApi30, isSwagger2 } from "./version.mjs";
-import { deepNormaliseOpenApi30Doc } from "./openapi30.mjs";
-import { normaliseSwagger2Document } from "./swagger2.mjs";
-//#region src/core/normalise.ts
-/**
-* Keys whose values are `Record<string, SubSchema>` — objects where each
-* property is a sub-schema.
-*/
-const OBJECT_SUBSCHEMA_KEYS = new Set([
-	"properties",
-	"patternProperties",
-	"$defs",
-	"definitions",
-	"dependentSchemas"
-]);
-/**
-* Keys whose values are `SubSchema[]` — arrays of sub-schemas.
-*/
-const ARRAY_SUBSCHEMA_KEYS = new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-/**
-* Keys whose values are a single sub-schema object.
-*/
-const SINGLE_SUBSCHEMA_KEYS = new Set([
-	"additionalProperties",
-	"not",
-	"contains",
-	"propertyNames",
-	"if",
-	"then",
-	"else",
-	"unevaluatedProperties",
-	"unevaluatedItems"
-]);
-/**
-* Normalise each element of an unknown array by applying deepNormalise
-* to object elements and passing others through unchanged.
-*/
-function normaliseArray(items, transform) {
-	const result = [];
-	for (const item of items) result.push(isObject(item) ? deepNormalise(item, transform) : item);
-	return result;
-}
-/**
-* Normalise each value of a sub-schema map (e.g. properties, $defs).
-*/
-function normaliseSubSchemaMap(map, transform) {
-	const result = {};
-	for (const [k, v] of Object.entries(map)) result[k] = isObject(v) ? deepNormalise(v, transform) : v;
-	return result;
-}
-/**
-* Deep-normalise a JSON Schema object by applying a per-node transform
-* and recursing into every sub-schema location.
-*/
-function deepNormalise(schema, transform) {
-	const node = transform({ ...schema });
-	const result = {};
-	for (const [key, value] of Object.entries(node)) if (isObject(value) && OBJECT_SUBSCHEMA_KEYS.has(key)) result[key] = normaliseSubSchemaMap(value, transform);
-	else if (Array.isArray(value) && ARRAY_SUBSCHEMA_KEYS.has(key)) result[key] = normaliseArray(value, transform);
-	else if (isObject(value) && SINGLE_SUBSCHEMA_KEYS.has(key)) result[key] = deepNormalise(value, transform);
-	else if (key === "items") if (Array.isArray(value)) result[key] = normaliseArray(value, transform);
-	else if (isObject(value)) result[key] = deepNormalise(value, transform);
-	else result[key] = value;
-	else result[key] = value;
-	return result;
-}
-/**
-* Normalise Draft 04 `exclusiveMinimum`/`exclusiveMaximum` from boolean
-* to number form.
-*
-* In Draft 04:
-* - `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
-*
-* The transform converts boolean form to number form so the walker can
-* treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.
-*/
-function normaliseDraft04Node(node) {
-	if (node.exclusiveMinimum === true && typeof node.minimum === "number") {
-		node.exclusiveMinimum = node.minimum;
-		delete node.minimum;
-	} else if (node.exclusiveMinimum === false) delete node.exclusiveMinimum;
-	if (node.exclusiveMaximum === true && typeof node.maximum === "number") {
-		node.exclusiveMaximum = node.maximum;
-		delete node.maximum;
-	} else if (node.exclusiveMaximum === false) delete node.exclusiveMaximum;
-	if (typeof node.id === "string" && !("$id" in node)) {
-		node.$id = node.id;
-		delete node.id;
-	}
-	if (Array.isArray(node.items) && !("prefixItems" in node)) {
-		node.prefixItems = node.items;
-		delete node.items;
-		if ("additionalItems" in node) {
-			node.items = node.additionalItems;
-			delete node.additionalItems;
-		}
-	}
-	return node;
-}
-/**
-* Normalise Draft 2019-09 `$recursiveRef` to `$ref`.
-*
-* `$recursiveRef` resolves to the nearest `$recursiveAnchor` in the
-* dynamic scope. For rendering, the common pattern is a root
-* `$recursiveAnchor: true` — the normaliser converts
-* `$recursiveRef: "#"` to `$ref: "#"` pointing to the root.
-*
-* If a `$recursiveAnchor` name is given (non-empty string), the ref
-* is converted to `$ref: "#<anchor>"` so the existing $anchor
-* resolution in ref.ts can find it.
-*/
-function normaliseDraft201909Node(node) {
-	if (typeof node.$recursiveRef === "string") {
-		node.$ref = "#";
-		delete node.$recursiveRef;
-	}
-	if (node.$recursiveAnchor === true) {
-		if (typeof node.$anchor !== "string") node.$anchor = "__recursive__";
-		delete node.$recursiveAnchor;
-	}
-	return node;
-}
-function normaliseDynamicRefNode(node) {
-	if (typeof node.$dynamicRef === "string") {
-		node.$ref = node.$dynamicRef;
-		delete node.$dynamicRef;
-	}
-	if (typeof node.$dynamicAnchor === "string") {
-		if (typeof node.$anchor !== "string") node.$anchor = node.$dynamicAnchor;
-		delete node.$dynamicAnchor;
-	}
-	return node;
-}
-/**
-* Normalise a JSON Schema to canonical Draft 2020-12 form.
-* Deep-clones the input — the original is never mutated.
-*/
-function normaliseJsonSchema(schema, draft) {
-	switch (draft) {
-		case "draft-04": return deepNormalise(schema, normaliseDraft04Node);
-		case "draft-2019-09": return deepNormalise(schema, normaliseDraft201909Node);
-		case "draft-2020-12": return deepNormalise(schema, normaliseDynamicRefNode);
-		case "draft-06":
-		case "draft-07": return schema;
-	}
-}
-/**
-* Normalise an OpenAPI document's schemas for walker consumption.
-* Handles version-specific keyword transformations.
-*
-* Returns the same object reference if no normalisation is needed
-* (OpenAPI 3.1.x), or a deep-cloned normalised copy otherwise.
-*/
-function normaliseOpenApiSchemas(doc, version) {
-	if (isSwagger2(version)) return normaliseSwagger2Document(doc, deepNormalise, normaliseDraft04Node);
-	if (isOpenApi30(version)) return deepNormaliseOpenApi30Doc(doc, deepNormalise);
-	return doc;
-}
-//#endregion
+import { i as normaliseOpenApiSchemas, n as normaliseDraft04Node, r as normaliseJsonSchema, t as deepNormalise } from "../normalise-tL9FckAk.mjs";
 export { deepNormalise, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };

package/dist/core/openapi30.d.mts

@@ -24,8 +24,11 @@ declare function normaliseOpenApi30Node(node: Record<string, unknown>): Record<s
  */
 declare function normaliseOpenApi30Discriminator(node: Record<string, unknown>): Record<string, unknown>;
 /**
- * Combined OpenAPI 3.0.x node transform: nullable + discriminator.
+ * Combined OpenAPI 3.0.x node transform: Draft 04 + nullable + discriminator.
  * Applied to every schema node in an OpenAPI 3.0 document.
+ *
+ * Draft 04 normalisation is included because OpenAPI 3.0 inherits
+ * Draft 04/05 schema semantics including `exclusiveMinimum: boolean`.
  */
 declare function normaliseOpenApi30Combined(node: Record<string, unknown>): Record<string, unknown>;
 /**