schema-components 1.12.10 → 1.13.0

package/dist/core/openapi30.mjs

@@ -0,0 +1,223 @@
+import { isObject } from "./guards.mjs";
+//#region src/core/openapi30.ts
+/**
+* OpenAPI 3.0.x schema normalisation.
+*
+* Transforms `nullable`, `discriminator`, `example` keywords, and walks
+* all schema locations (components, paths, parameters, request bodies,
+* responses) to apply normalisation.
+*/
+/**
+* Normalise OpenAPI 3.0.x `nullable` keyword to `anyOf [T, null]`.
+*
+* OpenAPI 3.0 uses `nullable: true` instead of the JSON Schema standard
+* `anyOf: [T, { type: "null" }]`. The walker understands the latter form
+* natively, so this normaliser converts `nullable` to `anyOf`.
+*
+* Only applied when `nullable` is explicitly `true`. `nullable: false` or
+* absent is the default and requires no transformation.
+*/
+function normaliseOpenApi30Node(node) {
+	if ("example" in node && !("examples" in node)) {
+		node.examples = [node.example];
+		delete node.example;
+	} else if ("example" in node) delete node.example;
+	if (node.nullable !== true) {
+		if ("nullable" in node) delete node.nullable;
+		return node;
+	}
+	const nullOption = { type: "null" };
+	if (Array.isArray(node.anyOf)) {
+		node.anyOf = [...node.anyOf, nullOption];
+		delete node.nullable;
+		return node;
+	}
+	if (Array.isArray(node.oneOf)) {
+		node.anyOf = [...node.oneOf, nullOption];
+		delete node.oneOf;
+		delete node.nullable;
+		return node;
+	}
+	if (Array.isArray(node.allOf)) {
+		node.anyOf = [{ allOf: node.allOf }, nullOption];
+		delete node.allOf;
+		delete node.nullable;
+		return node;
+	}
+	const wrapper = {};
+	for (const [key, value] of Object.entries(node)) if (key !== "nullable") wrapper[key] = value;
+	return { anyOf: [wrapper, nullOption] };
+}
+/**
+* Normalise OpenAPI 3.0.x `discriminator` keyword by injecting `const`
+* values into each `oneOf`/`anyOf` option's discriminator property.
+*
+* In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
+*   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.
+*/
+function normaliseOpenApi30Discriminator(node) {
+	const discriminator = node.discriminator;
+	if (!isObject(discriminator)) return node;
+	const propertyName = discriminator.propertyName;
+	if (typeof propertyName !== "string") return node;
+	const mapping = isObject(discriminator.mapping) ? discriminator.mapping : void 0;
+	const composite = node.oneOf ?? node.anyOf;
+	if (!Array.isArray(composite)) return node;
+	const refToValue = /* @__PURE__ */ new Map();
+	if (mapping !== void 0) {
+		for (const [value, ref] of Object.entries(mapping)) if (typeof ref === "string") refToValue.set(ref, value);
+	}
+	const normalisedComposite = [];
+	for (const option of composite) {
+		if (!isObject(option)) {
+			normalisedComposite.push(option);
+			continue;
+		}
+		const props = isObject(option.properties) ? { ...option.properties } : void 0;
+		const discProp = props?.[propertyName];
+		if (isObject(discProp) && "const" in discProp) {
+			normalisedComposite.push(option);
+			continue;
+		}
+		let constValue;
+		if (isObject(discProp) && typeof discProp.$ref === "string") constValue = refToValue.get(discProp.$ref);
+		if (constValue === void 0 && typeof option.$ref === "string") {
+			constValue = refToValue.get(option.$ref);
+			if (constValue === void 0) {
+				const fragment = option.$ref.split("/").pop();
+				if (fragment !== void 0) constValue = fragment;
+			}
+		}
+		if (constValue === void 0 && mapping !== void 0) {
+			const optionIndex = composite.indexOf(option);
+			const mappingEntries = Object.entries(mapping);
+			const entry = optionIndex >= 0 && optionIndex < mappingEntries.length ? mappingEntries[optionIndex] : void 0;
+			if (entry !== void 0) constValue = entry[0];
+		}
+		if (constValue !== void 0) {
+			const normalisedProps = props ?? {};
+			normalisedProps[propertyName] = {
+				...isObject(discProp) ? discProp : {},
+				const: constValue
+			};
+			normalisedComposite.push({
+				...option,
+				properties: normalisedProps
+			});
+		} else normalisedComposite.push(option);
+	}
+	if ("oneOf" in node) node.oneOf = normalisedComposite;
+	else if ("anyOf" in node) node.anyOf = normalisedComposite;
+	delete node.discriminator;
+	return node;
+}
+/**
+* Combined OpenAPI 3.0.x node transform: nullable + discriminator.
+* Applied to every schema node in an OpenAPI 3.0 document.
+*/
+function normaliseOpenApi30Combined(node) {
+	return normaliseOpenApi30Discriminator(normaliseOpenApi30Node(node));
+}
+/**
+* Deep-normalise all schemas in an OpenAPI 3.0.x document.
+* Walks components/schemas, path operations, parameters, request bodies,
+* and responses — applying `nullable` normalisation to each schema.
+*/
+function deepNormaliseOpenApi30Doc(doc, deepNormalise) {
+	const result = { ...doc };
+	const components = doc.components;
+	if (isObject(components)) {
+		const schemas = components.schemas;
+		if (isObject(schemas)) {
+			const normalisedSchemas = {};
+			for (const [name, schema] of Object.entries(schemas)) normalisedSchemas[name] = isObject(schema) ? deepNormalise(schema, normaliseOpenApi30Combined) : schema;
+			result.components = {
+				...components,
+				schemas: normalisedSchemas
+			};
+		}
+	}
+	const paths = doc.paths;
+	if (isObject(paths)) {
+		const normalisedPaths = {};
+		for (const [path, pathItem] of Object.entries(paths)) normalisedPaths[path] = isObject(pathItem) ? normalisePathItem(pathItem, deepNormalise) : pathItem;
+		result.paths = normalisedPaths;
+	}
+	return result;
+}
+function normalisePathItem(pathItem, deepNormalise) {
+	const result = { ...pathItem };
+	for (const method of [
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete"
+	]) {
+		const operation = pathItem[method];
+		if (!isObject(operation)) continue;
+		result[method] = normaliseOperation(operation, deepNormalise);
+	}
+	const parameters = pathItem.parameters;
+	if (Array.isArray(parameters)) result.parameters = parameters.map((param) => isObject(param) ? normaliseParameter(param, deepNormalise) : param);
+	return result;
+}
+function normaliseOperation(operation, deepNormalise) {
+	const result = { ...operation };
+	const parameters = operation.parameters;
+	if (Array.isArray(parameters)) result.parameters = parameters.map((param) => isObject(param) ? normaliseParameter(param, deepNormalise) : param);
+	const requestBody = operation.requestBody;
+	if (isObject(requestBody)) result.requestBody = normaliseRequestBody(requestBody, deepNormalise);
+	const responses = operation.responses;
+	if (isObject(responses)) {
+		const normalisedResponses = {};
+		for (const [code, response] of Object.entries(responses)) normalisedResponses[code] = isObject(response) ? normaliseResponse(response, deepNormalise) : response;
+		result.responses = normalisedResponses;
+	}
+	return result;
+}
+function normaliseParameter(param, deepNormalise) {
+	const result = { ...param };
+	const schema = param.schema;
+	if (isObject(schema)) result.schema = deepNormalise(schema, normaliseOpenApi30Combined);
+	if ("example" in result && !("examples" in result)) {
+		result.examples = [result.example];
+		delete result.example;
+	} else if ("example" in result) delete result.example;
+	return result;
+}
+function normaliseRequestBody(requestBody, deepNormalise) {
+	const result = { ...requestBody };
+	const content = requestBody.content;
+	if (isObject(content)) result.content = normaliseContentMap(content, deepNormalise);
+	return result;
+}
+function normaliseResponse(response, deepNormalise) {
+	const result = { ...response };
+	const content = response.content;
+	if (isObject(content)) result.content = normaliseContentMap(content, deepNormalise);
+	return result;
+}
+function normaliseContentMap(content, deepNormalise) {
+	const result = {};
+	for (const [mediaType, mediaObj] of Object.entries(content)) {
+		if (!isObject(mediaObj)) {
+			result[mediaType] = mediaObj;
+			continue;
+		}
+		const normalised = { ...mediaObj };
+		const schema = mediaObj.schema;
+		if (isObject(schema)) normalised.schema = deepNormalise(schema, normaliseOpenApi30Combined);
+		if ("example" in normalised && !("examples" in normalised)) {
+			normalised.examples = { value: normalised.example };
+			delete normalised.example;
+		} else if ("example" in normalised) delete normalised.example;
+		result[mediaType] = normalised;
+	}
+	return result;
+}
+//#endregion
+export { deepNormaliseOpenApi30Doc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/ref.d.mts

@@ -0,0 +1,25 @@
+//#region src/core/ref.d.ts
+/**
+ * $ref resolution for JSON Schema.
+ *
+ * Handles JSON Pointer dereference, $anchor lookup, cycle detection,
+ * and maximum depth limiting.
+ */
+/**
+ * Resolve a `$ref` in a schema against a root document.
+ * Returns the original schema if no `$ref` is present.
+ * Returns an unknown-schema placeholder on cycle or depth exceeded.
+ */
+declare function resolveRef(schema: Record<string, unknown>, rootDocument: Record<string, unknown>, visited: Set<string>): Record<string, unknown>;
+/**
+ * Dereference a JSON Pointer fragment (`#/path/to/schema`) or an
+ * `$anchor` (`#SomeName`) against a root document.
+ */
+declare function dereference(ref: string, root: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * Recursively scan a schema document for a `$anchor` matching the given name.
+ * Returns the schema object containing the anchor, or undefined.
+ */
+declare function findAnchor(node: unknown, anchorName: string): Record<string, unknown> | undefined;
+//#endregion
+export { dereference, findAnchor, resolveRef };

package/dist/core/ref.mjs

@@ -0,0 +1,86 @@
+import { isObject } from "./guards.mjs";
+//#region src/core/ref.ts
+/**
+* $ref resolution for JSON Schema.
+*
+* Handles JSON Pointer dereference, $anchor lookup, cycle detection,
+* and maximum depth limiting.
+*/
+function getString(obj, key) {
+	const value = obj[key];
+	return typeof value === "string" ? value : void 0;
+}
+const MAX_REF_DEPTH = 10;
+/**
+* Resolve a `$ref` in a schema against a root document.
+* Returns the original schema if no `$ref` is present.
+* Returns an unknown-schema placeholder on cycle or depth exceeded.
+*/
+function resolveRef(schema, rootDocument, visited) {
+	const ref = getString(schema, "$ref");
+	if (ref === void 0) return schema;
+	if (visited.has(ref)) return {
+		type: "unknown",
+		editability: "editable",
+		meta: {},
+		constraints: {}
+	};
+	if (visited.size >= MAX_REF_DEPTH) return {
+		type: "unknown",
+		editability: "editable",
+		meta: {},
+		constraints: {}
+	};
+	const resolved = dereference(ref, rootDocument);
+	if (resolved === void 0) return {
+		type: "unknown",
+		editability: "editable",
+		meta: {},
+		constraints: {}
+	};
+	const nextVisited = new Set(visited);
+	nextVisited.add(ref);
+	return resolveRef(resolved, rootDocument, nextVisited);
+}
+/**
+* Dereference a JSON Pointer fragment (`#/path/to/schema`) or an
+* `$anchor` (`#SomeName`) against a root document.
+*/
+function dereference(ref, root) {
+	if (ref === "#") return root;
+	if (ref.startsWith("#/")) {
+		const parts = ref.slice(2).split("/");
+		if (parts.length === 1 && parts[0] === "") return root;
+		let current = root;
+		for (const part of parts) {
+			if (!isObject(current)) return void 0;
+			const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+			current = current[decoded];
+		}
+		return isObject(current) ? current : void 0;
+	}
+	if (ref.startsWith("#") && ref.length > 1) {
+		const found = findAnchor(root, ref.slice(1));
+		if (found !== void 0) return found;
+	}
+}
+/**
+* Recursively scan a schema document for a `$anchor` matching the given name.
+* Returns the schema object containing the anchor, or undefined.
+*/
+function findAnchor(node, anchorName) {
+	if (!isObject(node)) return void 0;
+	if (node.$anchor === anchorName) return node;
+	for (const value of Object.values(node)) {
+		if (isObject(value)) {
+			const found = findAnchor(value, anchorName);
+			if (found !== void 0) return found;
+		}
+		if (Array.isArray(value)) for (const item of value) {
+			const found = findAnchor(item, anchorName);
+			if (found !== void 0) return found;
+		}
+	}
+}
+//#endregion
+export { dereference, findAnchor, resolveRef };

package/dist/core/renderer.d.mts

@@ -1,2 +1,2 @@
-import { A as mergeResolvers, C as HtmlResolver, D as getHtmlRenderFn, E as RenderProps, O as getRenderFunction, S as HtmlRenderProps, T as RenderFunction, b as ComponentResolver, j as typeToKey, k as mergeHtmlResolvers, w as RESOLVER_KEYS, x as HtmlRenderFunction, y as BaseFieldProps } from "../types-BJzEgJdX.mjs";
-export { BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };
+import { a as HtmlRenderProps, c as RenderFunction, d as getRenderFunction, f as mergeHtmlResolvers, i as HtmlRenderFunction, l as RenderProps, m as typeToKey, n as BaseFieldProps, o as HtmlResolver, p as mergeResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as getHtmlRenderFn } from "../renderer-DseHeliw.mjs";
+export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/renderer.mjs

@@ -6,9 +6,13 @@ const RESOLVER_KEYS = [
 	"enum",
 	"object",
 	"array",
+	"tuple",
 	"record",
 	"union",
 	"discriminatedUnion",
+	"conditional",
+	"negation",
+	"recursive",
 	"literal",
 	"file",
 	"unknown"
@@ -25,9 +29,13 @@ function typeToKey(type) {
 		case "enum":
 		case "object":
 		case "array":
+		case "tuple":
 		case "record":
 		case "union":
 		case "discriminatedUnion":
+		case "conditional":
+		case "negation":
+		case "recursive":
 		case "literal":
 		case "file":
 		case "unknown": return type;

package/dist/core/swagger2.d.mts

@@ -0,0 +1,10 @@
+import { NodeTransform } from "./normalise.mjs";
+
+//#region src/core/swagger2.d.ts
+/**
+ * Transform a Swagger 2.0 document into an OpenAPI 3.1-compatible
+ * structure.
+ */
+declare function normaliseSwagger2Document(doc: Record<string, unknown>, deepNormalise: (schema: Record<string, unknown>, transform: NodeTransform) => Record<string, unknown>, normaliseDraft04Node: NodeTransform): Record<string, unknown>;
+//#endregion
+export { normaliseSwagger2Document };

package/dist/core/swagger2.mjs

@@ -0,0 +1,294 @@
+import { isObject } from "./guards.mjs";
+import { normaliseOpenApi30Combined } from "./openapi30.mjs";
+//#region src/core/swagger2.ts
+/**
+* Swagger 2.0 → OpenAPI 3.1 document normalisation.
+*
+* Transforms a Swagger 2.0 document into an OpenAPI 3.1-compatible
+* structure: host/basePath/schemes → servers, definitions → components,
+* body/formData params → requestBody, response schemas → content.
+*
+* Individual schemas within the document are also normalised for
+* Draft 04 semantics (exclusiveMinimum/exclusiveMaximum booleans).
+*/
+/**
+* Transform a Swagger 2.0 document into an OpenAPI 3.1-compatible
+* structure.
+*/
+function normaliseSwagger2Document(doc, deepNormalise, normaliseDraft04Node) {
+	const result = {
+		openapi: "3.1.0",
+		info: isObject(doc.info) ? { ...doc.info } : {
+			title: "API",
+			version: "0.0.0"
+		}
+	};
+	if (typeof doc.host === "string" || typeof doc.basePath === "string" || Array.isArray(doc.schemes)) {
+		const host = typeof doc.host === "string" ? doc.host : "localhost";
+		const basePath = typeof doc.basePath === "string" ? doc.basePath : "/";
+		const schemes = Array.isArray(doc.schemes) ? doc.schemes : ["https"];
+		result.servers = [{ url: `${typeof schemes[0] === "string" ? schemes[0] : "https"}://${host}${basePath}` }];
+	}
+	const paths = doc.paths;
+	if (isObject(paths)) result.paths = normaliseSwaggerPaths(paths, doc);
+	const components = {};
+	const definitions = doc.definitions;
+	if (isObject(definitions)) {
+		const schemas = {};
+		for (const [name, schema] of Object.entries(definitions)) schemas[name] = isObject(schema) ? deepNormalise(schema, (node) => normaliseOpenApi30Combined(normaliseDraft04Node(node))) : schema;
+		components.schemas = schemas;
+	}
+	const parameters = doc.parameters;
+	if (isObject(parameters)) components.parameters = { ...parameters };
+	const responses = doc.responses;
+	if (isObject(responses)) components.responses = { ...responses };
+	const securityDefinitions = doc.securityDefinitions;
+	if (isObject(securityDefinitions)) components.securitySchemes = { ...securityDefinitions };
+	if (Object.keys(components).length > 0) result.components = components;
+	if (Array.isArray(doc.tags)) result.tags = doc.tags;
+	if (isObject(doc.externalDocs)) result.externalDocs = doc.externalDocs;
+	rewriteSwaggerRefs(result);
+	return result;
+}
+function normaliseSwaggerPaths(paths, doc) {
+	const result = {};
+	const METHODS = [
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete",
+		"head",
+		"options"
+	];
+	for (const [path, pathItem] of Object.entries(paths)) {
+		if (!isObject(pathItem)) {
+			result[path] = pathItem;
+			continue;
+		}
+		const normalisedPath = {};
+		for (const method of METHODS) {
+			const operation = pathItem[method];
+			if (!isObject(operation)) continue;
+			normalisedPath[method] = normaliseSwaggerOperation(operation, doc);
+		}
+		const pathParams = pathItem.parameters;
+		if (Array.isArray(pathParams)) normalisedPath.parameters = pathParams.map((p) => isObject(p) ? normaliseSwaggerParameter(p, doc) : p);
+		result[path] = normalisedPath;
+	}
+	return result;
+}
+function normaliseSwaggerOperation(operation, doc) {
+	const result = {};
+	const globalProduces = Array.isArray(doc.produces) ? doc.produces : ["application/json"];
+	const globalConsumes = Array.isArray(doc.consumes) ? doc.consumes : ["application/json"];
+	const produces = Array.isArray(operation.produces) ? operation.produces : globalProduces;
+	const consumes = Array.isArray(operation.consumes) ? operation.consumes : globalConsumes;
+	for (const [key, value] of Object.entries(operation)) if (key !== "parameters" && key !== "responses" && key !== "produces" && key !== "consumes") result[key] = value;
+	const params = operation.parameters;
+	if (Array.isArray(params)) {
+		const nonBodyParams = [];
+		let bodyParam;
+		let usesFormData = false;
+		for (const param of params) {
+			if (!isObject(param)) {
+				nonBodyParams.push(param);
+				continue;
+			}
+			const resolvedParam = resolveSwaggerParameter(param, doc);
+			const location = resolvedParam.in;
+			if (location === "body") bodyParam = resolvedParam;
+			else if (location === "formData") {
+				bodyParam = buildFormDataBody(resolvedParam, params);
+				usesFormData = true;
+			} else nonBodyParams.push(normaliseSwaggerParameter(resolvedParam, doc));
+		}
+		if (nonBodyParams.length > 0) result.parameters = nonBodyParams;
+		if (bodyParam !== void 0) result.requestBody = buildRequestBody(bodyParam, usesFormData ? ["multipart/form-data"] : consumes);
+	}
+	const responses = operation.responses;
+	if (isObject(responses)) result.responses = normaliseSwaggerResponses(responses, doc, produces);
+	return result;
+}
+/**
+* Resolve a Swagger parameter that may be a `$ref`.
+*/
+function resolveSwaggerParameter(param, doc, visited = /* @__PURE__ */ new Set()) {
+	const ref = param.$ref;
+	if (typeof ref !== "string" || !ref.startsWith("#/parameters/")) return param;
+	if (visited.has(ref)) return param;
+	const nextVisited = new Set(visited);
+	nextVisited.add(ref);
+	const name = ref.slice(13);
+	const globalParams = doc.parameters;
+	if (isObject(globalParams)) {
+		const resolved = globalParams[name];
+		if (isObject(resolved)) {
+			if (typeof resolved.$ref === "string") return resolveSwaggerParameter(resolved, doc, nextVisited);
+			return resolved;
+		}
+	}
+	return param;
+}
+/**
+* Normalise a single Swagger parameter to OpenAPI 3.x form.
+*/
+function normaliseSwaggerParameter(param, doc) {
+	if (typeof param.$ref === "string") {
+		const resolved = resolveSwaggerParameter(param, doc);
+		if (resolved !== param) return normaliseSwaggerParameter(resolved, doc);
+	}
+	const result = {};
+	for (const [key, value] of Object.entries(param)) {
+		if (key === "type" || key === "format" || key === "collectionFormat") continue;
+		result[key] = value;
+	}
+	if (typeof param.type === "string") {
+		const schema = { type: param.type };
+		if (typeof param.format === "string") schema.format = param.format;
+		if (param.enum !== void 0) schema.enum = param.enum;
+		if (param.default !== void 0) schema.default = param.default;
+		if (param.minimum !== void 0) schema.minimum = param.minimum;
+		if (param.maximum !== void 0) schema.maximum = param.maximum;
+		result.schema = schema;
+	}
+	const cf = param.collectionFormat;
+	if (typeof cf === "string") switch (cf) {
+		case "csv":
+			result.style = "form";
+			result.explode = false;
+			break;
+		case "ssv":
+			result.style = "spaceDelimited";
+			result.explode = false;
+			break;
+		case "tsv":
+			result.style = "tabDelimited";
+			result.explode = false;
+			break;
+		case "pipes":
+			result.style = "pipeDelimited";
+			result.explode = false;
+			break;
+		case "multi":
+			result.style = "form";
+			result.explode = true;
+			break;
+	}
+	return result;
+}
+/**
+* Build a request body from a `formData` parameter.
+*/
+function buildFormDataBody(param, allParams) {
+	const properties = {};
+	const required = [];
+	for (const p of allParams) {
+		if (!isObject(p) || p.in !== "formData") continue;
+		const name = p.name;
+		if (typeof name !== "string") continue;
+		const schema = {};
+		if (p.type === "file") {
+			schema.type = "string";
+			schema.format = "binary";
+		} else {
+			if (typeof p.type === "string") schema.type = p.type;
+			if (typeof p.format === "string") schema.format = p.format;
+			if (p.enum !== void 0) schema.enum = p.enum;
+		}
+		properties[name] = schema;
+		if (p.required === true) required.push(name);
+	}
+	return {
+		name: param.name,
+		in: "body",
+		schema: {
+			type: "object",
+			properties,
+			...required.length > 0 ? { required } : {}
+		}
+	};
+}
+/**
+* Build an OpenAPI 3.x request body from a Swagger 2.0 body parameter.
+*/
+function buildRequestBody(bodyParam, consumes) {
+	const schema = bodyParam.schema;
+	const content = {};
+	const contentTypes = consumes.length > 0 ? consumes : ["application/json"];
+	for (const ct of contentTypes) if (typeof ct === "string") content[ct] = isObject(schema) ? { schema } : {};
+	const result = { content };
+	if (bodyParam.required === true) result.required = true;
+	if (typeof bodyParam.description === "string") result.description = bodyParam.description;
+	return result;
+}
+/**
+* Resolve a Swagger 2.0 response `$ref` (e.g. `#/responses/NotFound`).
+*/
+function resolveSwaggerResponse(response, doc, visited = /* @__PURE__ */ new Set()) {
+	const ref = response.$ref;
+	if (typeof ref !== "string" || !ref.startsWith("#/responses/")) return response;
+	if (visited.has(ref)) return response;
+	const nextVisited = new Set(visited);
+	nextVisited.add(ref);
+	const name = ref.slice(12);
+	const globalResponses = doc.responses;
+	if (isObject(globalResponses)) {
+		const resolved = globalResponses[name];
+		if (isObject(resolved)) {
+			if (typeof resolved.$ref === "string") return resolveSwaggerResponse(resolved, doc, nextVisited);
+			return resolved;
+		}
+	}
+	return response;
+}
+function normaliseSwaggerResponses(responses, doc, produces) {
+	const result = {};
+	for (const [code, response] of Object.entries(responses)) {
+		if (!isObject(response)) {
+			result[code] = response;
+			continue;
+		}
+		const resolved = resolveSwaggerResponse(response, doc);
+		const normalised = {};
+		for (const [key, value] of Object.entries(resolved)) if (key !== "schema") normalised[key] = value;
+		const schema = resolved.schema;
+		if (isObject(schema)) {
+			const content = {};
+			const contentTypes = produces.length > 0 ? produces : ["application/json"];
+			for (const ct of contentTypes) if (typeof ct === "string") content[ct] = { schema };
+			normalised.content = content;
+		}
+		result[code] = normalised;
+	}
+	return result;
+}
+/**
+* Mapping of Swagger 2.0 $ref prefixes to OpenAPI 3.x equivalents.
+* Applied after document restructuring so all $ref strings point
+* to the correct locations in the normalised document.
+*/
+const REF_REWRITES = [
+	["#/definitions/", "#/components/schemas/"],
+	["#/parameters/", "#/components/parameters/"],
+	["#/responses/", "#/components/responses/"]
+];
+/**
+* Deep-rewrite $ref strings in a normalised Swagger 2.0 document
+* from Swagger 2.0 locations to OpenAPI 3.x locations.
+* Mutates the object in place \u2014 called only on the fresh clone
+* produced by normaliseSwagger2Document.
+*/
+function rewriteSwaggerRefs(node) {
+	if (!isObject(node)) return;
+	if (typeof node.$ref === "string") {
+		for (const [from, to] of REF_REWRITES) if (node.$ref.startsWith(from)) {
+			node.$ref = to + node.$ref.slice(from.length);
+			break;
+		}
+	}
+	for (const value of Object.values(node)) if (isObject(value)) rewriteSwaggerRefs(value);
+	else if (Array.isArray(value)) for (const item of value) rewriteSwaggerRefs(item);
+}
+//#endregion
+export { normaliseSwagger2Document };

package/dist/core/typeInference.d.mts

@@ -0,0 +1,2 @@
+import { a as OpenAPIRequestBodyType, c as ResolveOpenAPIRef, i as InferResponseFields, l as TypeAtPath, n as InferParameterOverrides, o as OpenAPIResponseType, r as InferRequestBodyFields, s as PathOfType, t as FromJSONSchema } from "../typeInference-CRPqVwKu.mjs";
+export { FromJSONSchema, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, ResolveOpenAPIRef, TypeAtPath };

package/dist/core/typeInference.mjs

@@ -0,0 +1 @@
+export {};