@rexeus/typeweaver-openapi 0.11.0

package/dist/index.mjs

@@ -0,0 +1,1294 @@
+import { pascalCase } from "polycase";
+import { fromZod } from "@rexeus/typeweaver-zod-to-json-schema";
+import "zod";
+import path from "node:path";
+import { BasePlugin } from "@rexeus/typeweaver-gen";
+//#region src/internal/zodIntrospection.ts
+const TRANSPARENT_WRAPPER_TYPES = new Set([
+	"optional",
+	"nullable",
+	"default",
+	"catch",
+	"prefault",
+	"readonly",
+	"nonoptional"
+]);
+function getSchemaDefinition(schema) {
+	if (schema === void 0) return;
+	const schemaWithDefinition = schema;
+	return schemaWithDefinition._zod?.def ?? schemaWithDefinition.def ?? schemaWithDefinition._def;
+}
+function getSchemaType(schema) {
+	if (schema === void 0) return;
+	return getSchemaDefinition(schema)?.type ?? "unknown";
+}
+function isZodTransparentWrapperType(schemaType, transparentWrapperTypes = TRANSPARENT_WRAPPER_TYPES) {
+	return schemaType !== void 0 && transparentWrapperTypes.has(schemaType);
+}
+//#endregion
+//#region src/internal/bodyContent.ts
+const OPEN_API_BINARY_SCHEMA = {
+	type: "string",
+	format: "binary"
+};
+const RAW_BODY_TRANSPARENT_WRAPPER_TYPES = new Set([
+	"optional",
+	"nullable",
+	"default",
+	"catch",
+	"prefault",
+	"readonly",
+	"nonoptional"
+]);
+function resolveOpenApiBodySchema(body, registerSchema) {
+	return shouldUseBinarySchema(body) ? {
+		schema: OPEN_API_BINARY_SCHEMA,
+		schemaKey: "openapi-binary",
+		warnings: []
+	} : registerSchema();
+}
+function shouldUseBinarySchema(body) {
+	return body.transport === "raw" && mediaTypeEssence(body.mediaType) === "application/octet-stream" && (body.mediaTypeSource === "raw-fallback" || isAmbiguousRawSchema(body.schema));
+}
+function mediaTypeEssence(mediaType) {
+	return mediaType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isAmbiguousRawSchema(schema) {
+	const schemaType = getSchemaType(unwrapTransparentSchema(schema));
+	return schemaType === "any" || schemaType === "unknown";
+}
+function unwrapTransparentSchema(schema) {
+	const visitedSchemas = /* @__PURE__ */ new Set();
+	let current = schema;
+	while (current !== void 0 && !visitedSchemas.has(current)) {
+		visitedSchemas.add(current);
+		const definition = getSchemaDefinition(current);
+		const schemaType = definition?.type;
+		if (isZodTransparentWrapperType(schemaType, RAW_BODY_TRANSPARENT_WRAPPER_TYPES)) {
+			current = definition?.innerType;
+			continue;
+		}
+		if (schemaType === "pipe") {
+			const outputType = getSchemaType(definition?.out);
+			if (outputType === void 0 || outputType === "transform") return;
+			current = definition?.out;
+			continue;
+		}
+		if (schemaType === "effects") {
+			current = definition?.schema;
+			continue;
+		}
+		return current;
+	}
+	return current;
+}
+//#endregion
+//#region src/internal/jsonPointer.ts
+function jsonPointer(segments) {
+	if (segments.length === 0) return "";
+	return `/${segments.map(escapeJsonPointerSegment).join("/")}`;
+}
+function appendJsonPointer(base, suffix) {
+	if (suffix === "") return base;
+	if (base === "") return suffix;
+	return `${base}${suffix}`;
+}
+function isJsonPointerAtOrBelow(path, prefix) {
+	return path === prefix || path.startsWith(`${prefix}/`);
+}
+function escapeJsonPointerSegment(segment) {
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+//#endregion
+//#region src/internal/openApiPath.ts
+function toOpenApiPath(path) {
+	return `/${normalizePathSegments(path).map((segment) => segment.replaceAll(pathParameterPattern, "{$1}")).join("/")}`;
+}
+function getPathParameterNames(path) {
+	return normalizePathSegments(path).flatMap((segment) => Array.from(segment.matchAll(pathParameterPattern), (match) => match[1] ?? ""));
+}
+const pathParameterPattern = /:([A-Za-z0-9_]+)/g;
+function normalizePathSegments(path) {
+	return path.split("/").filter((segment) => segment.length > 0);
+}
+//#endregion
+//#region src/internal/operationContext.ts
+function createOperationLocation(options) {
+	const isComponentResponseLocation = options.context.resourceName === "components.responses";
+	return {
+		resourceName: options.context.resourceName,
+		operationId: options.context.operation.operationId,
+		...isComponentResponseLocation ? {} : {
+			method: options.context.operation.method,
+			path: options.context.operation.path
+		},
+		openApiPath: options.context.openApiPath,
+		part: options.part,
+		parameterName: options.parameterName,
+		responseName: options.responseName,
+		statusCode: options.statusCode
+	};
+}
+//#endregion
+//#region src/internal/openApiSchemaNormalization.ts
+const SCHEMA_CHILD_KEYS = new Set([
+	"items",
+	"additionalProperties",
+	"not",
+	"if",
+	"then",
+	"else",
+	"contains",
+	"propertyNames"
+]);
+const SCHEMA_CHILD_MAP_KEYS = new Set([
+	"properties",
+	"patternProperties",
+	"$defs",
+	"definitions",
+	"dependentSchemas"
+]);
+const SCHEMA_CHILD_ARRAY_KEYS = new Set([
+	"prefixItems",
+	"allOf",
+	"anyOf",
+	"oneOf"
+]);
+function normalizeOpenApiSchema(schema) {
+	const hasConst = hasOwnSchemaKeyword(schema, "const");
+	const normalizedEntries = Object.entries(schema).filter(([key]) => key !== "const").map(([key, value]) => [key, normalizeSchemaKeyword(key, value)]);
+	const constValue = schema.const;
+	if (hasConst && constValue !== void 0) normalizedEntries.push(["enum", [constValue]]);
+	return Object.fromEntries(normalizedEntries);
+}
+function normalizeSchemaKeyword(key, value) {
+	if (SCHEMA_CHILD_KEYS.has(key) && isJsonSchema$1(value)) return normalizeOpenApiSchema(value);
+	if (SCHEMA_CHILD_MAP_KEYS.has(key) && isJsonSchema$1(value)) return Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [childKey, isJsonSchema$1(childValue) ? normalizeOpenApiSchema(childValue) : childValue]));
+	if (SCHEMA_CHILD_ARRAY_KEYS.has(key) && Array.isArray(value)) return value.map((entry) => isJsonSchema$1(entry) ? normalizeOpenApiSchema(entry) : entry);
+	return value;
+}
+function isJsonSchema$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwnSchemaKeyword(schema, keyword) {
+	return Object.prototype.hasOwnProperty.call(schema, keyword);
+}
+//#endregion
+//#region src/internal/schemaConversion.ts
+function convertSchema(schema, documentPath, location, options = {}) {
+	const result = fromZod(schema);
+	const shouldRebaseLocalRefs = options.rebaseLocalRefs ?? true;
+	const openApiSchema = normalizeOpenApiSchema(result.schema);
+	return {
+		schema: shouldRebaseLocalRefs ? rebaseLocalJsonSchemaRefs(openApiSchema, documentPath) : openApiSchema,
+		warnings: result.warnings.map((warning) => ({
+			origin: "schema-conversion",
+			code: warning.code,
+			message: warning.message,
+			schemaType: warning.schemaType,
+			schemaPath: warning.path,
+			documentPath: appendJsonPointer(documentPath, warning.path),
+			location
+		}))
+	};
+}
+function rebaseLocalJsonSchemaRefs(schema, documentPath) {
+	return rebaseJsonSchemaValue(schema, documentPath);
+}
+function unwrapRootOptional(schema) {
+	return {
+		schema: unwrapRootSchema(schema),
+		isOptional: omittedInputResult(schema) !== "rejects"
+	};
+}
+function unwrapRootSchema(schema) {
+	const visitedSchemas = /* @__PURE__ */ new Set();
+	let current = schema;
+	while (!visitedSchemas.has(current)) {
+		visitedSchemas.add(current);
+		const definition = getSchemaDefinition(current);
+		const schemaType = definition?.type;
+		if (schemaType === "nullable") return current;
+		if (schemaType === "optional" || schemaType === "default" || schemaType === "catch" || schemaType === "prefault" || schemaType === "readonly" || schemaType === "nonoptional") {
+			const innerType = definition?.innerType;
+			if (innerType === void 0) return current;
+			current = innerType;
+			continue;
+		}
+		return current;
+	}
+	return current;
+}
+function omittedInputResult(schema) {
+	const visitedSchemas = /* @__PURE__ */ new Set();
+	let current = schema;
+	while (!visitedSchemas.has(current)) {
+		visitedSchemas.add(current);
+		const definition = getSchemaDefinition(current);
+		const schemaType = definition?.type;
+		if (schemaType === "optional") return "accepts-undefined";
+		if (schemaType === "default" || schemaType === "prefault") return "accepts-defined";
+		if (schemaType === "catch") {
+			const innerType = definition?.innerType;
+			if (innerType === void 0) return "accepts-defined";
+			const innerResult = omittedInputResult(innerType);
+			return innerResult === "rejects" ? "accepts-defined" : innerResult;
+		}
+		if (schemaType === "nonoptional") {
+			const innerType = definition?.innerType;
+			if (innerType === void 0) return "rejects";
+			return omittedInputResult(innerType) === "accepts-defined" ? "accepts-defined" : "rejects";
+		}
+		if (schemaType === "nullable" || schemaType === "readonly") {
+			const innerType = definition?.innerType;
+			if (innerType === void 0) return "rejects";
+			current = innerType;
+			continue;
+		}
+		return "rejects";
+	}
+	return "rejects";
+}
+function getObjectProperties(schema) {
+	const properties = schema.properties;
+	if (!isJsonSchema(properties)) return {};
+	return Object.fromEntries(Object.entries(properties).filter((entry) => isJsonSchema(entry[1])));
+}
+function preserveReferencedRootDefinitions(schema, rootSchema) {
+	return ["$defs", "definitions"].reduce((selfContainedSchema, definitionKey) => preserveReferencedRootDefinitionKeyword({
+		schema: selfContainedSchema,
+		sourceSchema: selfContainedSchema,
+		rootSchema,
+		definitionKey
+	}), schema);
+}
+function getRequiredNames(schema) {
+	if (!Array.isArray(schema.required)) return /* @__PURE__ */ new Set();
+	return new Set(schema.required.filter((entry) => typeof entry === "string"));
+}
+function hasUnrepresentableAdditionalProperties(schema) {
+	return Object.prototype.hasOwnProperty.call(schema, "additionalProperties") && schema.additionalProperties !== false;
+}
+function isJsonSchema(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rebaseJsonSchemaValue(value, documentPath) {
+	if (Array.isArray(value)) return value.map((item) => rebaseJsonSchemaValue(item, documentPath));
+	if (!isJsonSchema(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key === "$ref" && typeof child === "string" ? rebaseLocalJsonSchemaRef(child, documentPath) : rebaseJsonSchemaValue(child, documentPath)]));
+}
+function rebaseLocalJsonSchemaRef(ref, documentPath) {
+	if (ref === "#") return `#${documentPath}`;
+	if (ref.startsWith("#/")) return `#${appendJsonPointer(documentPath, ref.slice(1))}`;
+	return ref;
+}
+function preserveReferencedRootDefinitionKeyword(options) {
+	const rootDefinitions = options.rootSchema[options.definitionKey];
+	if (!isJsonSchema(rootDefinitions)) return options.schema;
+	const referencedDefinitions = collectReferencedRootDefinitions({
+		schema: options.sourceSchema,
+		rootDefinitions,
+		definitionKey: options.definitionKey
+	});
+	if (Object.keys(referencedDefinitions).length === 0) return options.schema;
+	const existingDefinitions = options.schema[options.definitionKey];
+	return {
+		...options.schema,
+		[options.definitionKey]: {
+			...isJsonSchema(existingDefinitions) ? existingDefinitions : {},
+			...referencedDefinitions
+		}
+	};
+}
+function collectReferencedRootDefinitions(options) {
+	const pendingNames = [...collectReferencedDefinitionNames(options.schema, options.definitionKey)];
+	const copiedDefinitions = {};
+	for (const name of pendingNames) {
+		if (Object.prototype.hasOwnProperty.call(copiedDefinitions, name)) continue;
+		const definition = options.rootDefinitions[name];
+		if (definition === void 0) continue;
+		copiedDefinitions[name] = definition;
+		if (!isJsonSchema(definition)) continue;
+		for (const transitiveName of collectReferencedDefinitionNames(definition, options.definitionKey)) if (!Object.prototype.hasOwnProperty.call(copiedDefinitions, transitiveName)) pendingNames.push(transitiveName);
+	}
+	return copiedDefinitions;
+}
+function collectReferencedDefinitionNames(value, definitionKey) {
+	const names = /* @__PURE__ */ new Set();
+	collectReferencedDefinitionNamesFromValue(value, definitionKey, names);
+	return names;
+}
+function collectReferencedDefinitionNamesFromValue(value, definitionKey, names) {
+	if (Array.isArray(value)) {
+		value.forEach((item) => collectReferencedDefinitionNamesFromValue(item, definitionKey, names));
+		return;
+	}
+	if (!isJsonSchema(value)) return;
+	Object.entries(value).forEach(([key, child]) => {
+		if (key === "$ref" && typeof child === "string") {
+			const definitionName = getReferencedRootDefinitionName(child, definitionKey);
+			if (definitionName !== void 0) names.add(definitionName);
+			return;
+		}
+		collectReferencedDefinitionNamesFromValue(child, definitionKey, names);
+	});
+}
+function getReferencedRootDefinitionName(ref, definitionKey) {
+	const prefix = `#/${escapeJsonPointerSegment(definitionKey)}/`;
+	if (!ref.startsWith(prefix)) return;
+	const [encodedName] = ref.slice(prefix.length).split("/");
+	if (encodedName === void 0 || encodedName === "") return;
+	return unescapeJsonPointerSegment(encodedName);
+}
+function unescapeJsonPointerSegment(segment) {
+	return segment.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+//#endregion
+//#region src/internal/parameterContainer.ts
+function extractParameterContainer(options) {
+	if (options.schema === void 0) return {
+		properties: {},
+		requiredNames: /* @__PURE__ */ new Set(),
+		warnings: [],
+		isRootOptional: false
+	};
+	const optionalSchema = unwrapRootOptional(options.schema);
+	const converted = convertSchema(optionalSchema.schema, options.containerPointer, createOperationLocation({
+		context: options.context,
+		part: options.part,
+		responseName: options.responseName,
+		statusCode: options.statusCode
+	}), { rebaseLocalRefs: false });
+	const properties = Object.fromEntries(Object.entries(getObjectProperties(converted.schema)).map(([name, schema]) => [name, preserveReferencedRootDefinitions(schema, converted.schema)]));
+	const warnings = [...converted.warnings];
+	const hasFiniteProperties = Object.keys(properties).length > 0;
+	if (converted.schema.type !== "object") warnings.push(createContainerWarning({
+		code: "unrepresentable-parameter-container",
+		message: `${options.part} must be a finite object schema to become OpenAPI parameters.`,
+		documentPath: options.containerPointer,
+		context: options.context,
+		part: options.part,
+		responseName: options.responseName,
+		statusCode: options.statusCode
+	}));
+	else if (!hasFiniteProperties && hasUnrepresentableAdditionalProperties(converted.schema)) warnings.push(createContainerWarning({
+		code: "unrepresentable-parameter-container",
+		message: `${options.part} record entries cannot be represented as finite OpenAPI parameters.`,
+		documentPath: options.containerPointer,
+		context: options.context,
+		part: options.part,
+		responseName: options.responseName,
+		statusCode: options.statusCode
+	}));
+	else if (hasUnrepresentableAdditionalProperties(converted.schema)) warnings.push(createContainerWarning({
+		code: "unrepresentable-parameter-additional-properties",
+		message: `${options.part} additional properties cannot be represented as OpenAPI parameters.`,
+		documentPath: options.containerPointer,
+		context: options.context,
+		part: options.part,
+		responseName: options.responseName,
+		statusCode: options.statusCode
+	}));
+	return {
+		properties,
+		requiredNames: getRequiredNames(converted.schema),
+		warnings,
+		isRootOptional: optionalSchema.isOptional
+	};
+}
+function createContainerWarning(options) {
+	return {
+		origin: "openapi-builder",
+		code: options.code,
+		message: options.message,
+		documentPath: options.documentPath,
+		location: createOperationLocation(options)
+	};
+}
+//#endregion
+//#region src/internal/parameters.ts
+function buildRequestParameters(context) {
+	const operationPointer = jsonPointer([
+		"paths",
+		context.openApiPath,
+		context.method,
+		"parameters"
+	]);
+	const pathParameters = buildPathParameters(context, operationPointer);
+	const queryParameters = buildParametersFromContainer({
+		schema: context.operation.request?.query,
+		parameterIn: "query",
+		part: "request.query",
+		context,
+		startIndex: pathParameters.parameters.length,
+		parametersPointer: operationPointer
+	});
+	const headerParameters = buildParametersFromContainer({
+		schema: context.operation.request?.header,
+		parameterIn: "header",
+		part: "request.header",
+		context,
+		startIndex: pathParameters.parameters.length + queryParameters.parameters.length,
+		parametersPointer: operationPointer
+	});
+	return {
+		parameters: [
+			...pathParameters.parameters,
+			...queryParameters.parameters,
+			...headerParameters.parameters
+		],
+		warnings: [
+			...pathParameters.warnings,
+			...queryParameters.warnings,
+			...headerParameters.warnings
+		]
+	};
+}
+function buildPathParameters(context, parametersPointer) {
+	const pathNames = getPathParameterNames(context.operation.path);
+	const container = extractParameterContainer({
+		schema: context.operation.request?.param,
+		context,
+		part: "request.path",
+		containerPointer: parametersPointer
+	});
+	const pathNameSet = new Set(pathNames);
+	const missingWarnings = [];
+	const unusedWarnings = Object.keys(container.properties).filter((name) => !pathNameSet.has(name)).map((name) => createParameterWarning({
+		code: "unused-path-parameter-schema",
+		message: `Path parameter schema '${name}' is not used by '${context.operation.path}'.`,
+		documentPath: parametersPointer,
+		context,
+		part: "request.path",
+		parameterName: name
+	}));
+	return {
+		parameters: pathNames.map((name, index) => {
+			const schema = container.properties[name];
+			const parameterPointer = jsonPointer([
+				"paths",
+				context.openApiPath,
+				context.method,
+				"parameters",
+				String(index)
+			]);
+			if (schema === void 0) missingWarnings.push(createParameterWarning({
+				code: "missing-path-parameter-schema",
+				message: `Path parameter '${name}' is missing a schema.`,
+				documentPath: `${parameterPointer}/schema`,
+				context,
+				part: "request.path",
+				parameterName: name
+			}));
+			return {
+				name,
+				in: "path",
+				required: true,
+				schema: schema === void 0 ? {} : rebaseLocalJsonSchemaRefs(schema, `${parameterPointer}/schema`)
+			};
+		}),
+		warnings: [
+			...rebaseParameterSchemaWarnings({
+				warnings: container.warnings,
+				context,
+				parameterNames: pathNames,
+				startIndex: 0
+			}),
+			...unusedWarnings,
+			...missingWarnings
+		]
+	};
+}
+function buildParametersFromContainer(options) {
+	const container = extractParameterContainer({
+		schema: options.schema,
+		context: options.context,
+		part: options.part,
+		containerPointer: options.parametersPointer
+	});
+	return {
+		parameters: Object.entries(container.properties).map(([name, schema], index) => ({
+			name,
+			in: options.parameterIn,
+			required: !container.isRootOptional && container.requiredNames.has(name),
+			schema: rebaseLocalJsonSchemaRefs(schema, `${options.parametersPointer}/${options.startIndex + index}/schema`)
+		})),
+		warnings: rebaseParameterSchemaWarnings({
+			warnings: container.warnings,
+			context: options.context,
+			parameterNames: Object.keys(container.properties),
+			startIndex: options.startIndex
+		})
+	};
+}
+function rebaseParameterSchemaWarnings(options) {
+	return options.warnings.map((warning) => {
+		if (warning.origin !== "schema-conversion") return warning;
+		const parameterIndex = options.parameterNames.findIndex((name) => isJsonPointerAtOrBelow(warning.schemaPath, `/properties/${escapeJsonPointerSegment(name)}`));
+		if (parameterIndex === -1) return warning;
+		const parameterName = options.parameterNames[parameterIndex];
+		if (parameterName === void 0) return warning;
+		const schemaPath = `/properties/${escapeJsonPointerSegment(parameterName)}`;
+		const suffix = warning.schemaPath.slice(schemaPath.length);
+		const documentPath = `${jsonPointer([
+			"paths",
+			options.context.openApiPath,
+			options.context.method,
+			"parameters",
+			String(options.startIndex + parameterIndex),
+			"schema"
+		])}${suffix}`;
+		return {
+			...warning,
+			documentPath,
+			location: {
+				...warning.location,
+				parameterName
+			}
+		};
+	});
+}
+function createParameterWarning(options) {
+	return {
+		origin: "openapi-builder",
+		code: options.code,
+		message: options.message,
+		documentPath: options.documentPath,
+		location: createOperationLocation(options)
+	};
+}
+//#endregion
+//#region src/internal/headerObjects.ts
+function buildHeaderObjects(schema, context, responseContext) {
+	const container = extractParameterContainer({
+		schema,
+		context,
+		part: responseContext.part,
+		containerPointer: responseContext.headersPointer,
+		responseName: responseContext.responseName,
+		statusCode: responseContext.statusCode
+	});
+	return {
+		headers: Object.fromEntries(Object.entries(container.properties).map(([name, headerSchema]) => {
+			const headerPointer = `${responseContext.headersPointer}/${escapeJsonPointerSegment(name)}/schema`;
+			const description = headerDescription(headerSchema);
+			return [name, {
+				...description === void 0 ? {} : { description },
+				required: !container.isRootOptional && container.requiredNames.has(name),
+				schema: rebaseLocalJsonSchemaRefs(schemaWithoutDescription(headerSchema), headerPointer)
+			}];
+		})),
+		warnings: rebaseHeaderSchemaWarnings(container.warnings, Object.keys(container.properties), responseContext.headersPointer)
+	};
+}
+function headerDescription(schema) {
+	return typeof schema.description === "string" && schema.description.trim() !== "" ? schema.description : void 0;
+}
+function schemaWithoutDescription(schema) {
+	return Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "description"));
+}
+function rebaseHeaderSchemaWarnings(warnings, headerNames, headersPointer) {
+	return warnings.map((warning) => {
+		if (warning.origin !== "schema-conversion") return warning;
+		const headerName = headerNames.find((name) => isJsonPointerAtOrBelow(warning.schemaPath, `/properties/${escapeJsonPointerSegment(name)}`));
+		if (headerName === void 0) return warning;
+		const schemaPath = `/properties/${escapeJsonPointerSegment(headerName)}`;
+		const suffix = warning.schemaPath.slice(schemaPath.length);
+		return {
+			...warning,
+			documentPath: `${headersPointer}/${escapeJsonPointerSegment(headerName)}/schema${suffix}`,
+			location: {
+				...warning.location,
+				parameterName: headerName
+			}
+		};
+	});
+}
+//#endregion
+//#region src/internal/schemaRebasing.ts
+function rebaseSchemaDocumentRefs(schema, fromPointer, toPointer) {
+	return rebaseSchemaValueDocumentRefs(schema, fromPointer, toPointer);
+}
+function rebaseWarningDocumentPath(warning, fromPointer, toPointer) {
+	if (warning.origin !== "schema-conversion" || !isJsonPointerAtOrBelow(warning.documentPath, fromPointer)) return warning;
+	return {
+		...warning,
+		documentPath: `${toPointer}${warning.documentPath.slice(fromPointer.length)}`
+	};
+}
+function isWarningDocumentPathAtOrBelow(warning, pointer) {
+	return isJsonPointerAtOrBelow(warning.documentPath, pointer);
+}
+function rebaseSchemaValueDocumentRefs(value, fromPointer, toPointer) {
+	if (Array.isArray(value)) return value.map((item) => rebaseSchemaValueDocumentRefs(item, fromPointer, toPointer));
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key === "$ref" && typeof child === "string" ? rebaseDocumentRef(child, fromPointer, toPointer) : rebaseSchemaValueDocumentRefs(child, fromPointer, toPointer)]));
+}
+function rebaseDocumentRef(ref, fromPointer, toPointer) {
+	if (!ref.startsWith("#")) return ref;
+	const documentPath = ref.slice(1);
+	if (!isJsonPointerAtOrBelow(documentPath, fromPointer)) return ref;
+	return `#${toPointer}${documentPath.slice(fromPointer.length)}`;
+}
+//#endregion
+//#region src/internal/responseHeaderMerge.ts
+function buildMergedHeaders(variants, options) {
+	const variantHeaders = variants.map((variant) => buildVariantHeaders(variant, options));
+	const mergedHeaders = headerNamesFrom(variantHeaders).map((name) => mergeHeader(name, variantHeaders, options.responsePointer));
+	return {
+		headers: Object.fromEntries(mergedHeaders.map((merged) => [merged.name, merged.header])),
+		warnings: [...warningsOutsideMergedHeaderSchemas(variantHeaders, options.responsePointer), ...mergedHeaders.flatMap((merged) => merged.warnings)]
+	};
+}
+function buildVariantHeaders(variant, options) {
+	const built = buildHeaderObjects(variant.response.header, options.context, {
+		responseName: variant.usage.responseName,
+		statusCode: options.statusCode,
+		part: "response.header",
+		headersPointer: `${options.responsePointer}/headers`
+	});
+	return {
+		responseName: variant.usage.responseName,
+		headers: built.headers,
+		warnings: built.warnings
+	};
+}
+function warningsOutsideMergedHeaderSchemas(variants, responsePointer) {
+	return variants.flatMap((variant) => {
+		const headerSchemaPointers = Object.keys(variant.headers).map((name) => headerSchemaPointer(responsePointer, name));
+		return variant.warnings.filter((warning) => !headerSchemaPointers.some((pointer) => isWarningDocumentPathAtOrBelow(warning, pointer)));
+	});
+}
+function headerNamesFrom(variants) {
+	const namesByLowercase = /* @__PURE__ */ new Map();
+	for (const variant of variants) for (const name of Object.keys(variant.headers)) {
+		const lowercaseName = name.toLowerCase();
+		if (!namesByLowercase.has(lowercaseName)) namesByLowercase.set(lowercaseName, name);
+	}
+	return [...namesByLowercase.values()];
+}
+function mergeHeader(name, variants, responsePointer) {
+	const schemaPointer = headerSchemaPointer(responsePointer, name);
+	const appearances = headerAppearancesFor(name, variants, responsePointer, schemaPointer);
+	const distinctSchemaAppearances = distinctHeaderSchemaAppearances(appearances);
+	const schema = mergedHeaderSchema(distinctSchemaAppearances, schemaPointer);
+	const warnings = mergedHeaderSchemaWarnings({
+		appearances,
+		distinctSchemaAppearances,
+		schemaPointer
+	});
+	const description = mergedHeaderDescription(appearances);
+	if (schema === void 0) return {
+		name,
+		header: {
+			required: false,
+			schema: {}
+		},
+		warnings
+	};
+	return {
+		name,
+		header: {
+			...description === void 0 ? {} : { description },
+			required: variants.every((_, index) => appearances.some((appearance) => appearance.variantIndex === index)) && appearances.every((appearance) => appearance.header.required),
+			schema
+		},
+		warnings
+	};
+}
+function headerAppearancesFor(name, variants, responsePointer, schemaPointer) {
+	return variants.flatMap((variant, variantIndex) => {
+		const headerEntries = headerEntriesFor(variant.headers, name);
+		if (headerEntries.length === 0) return [];
+		return headerEntries.map((headerEntry) => {
+			const originalSchemaPointer = headerSchemaPointer(responsePointer, headerEntry.name);
+			const warnings = variant.warnings.filter((warning) => isWarningDocumentPathAtOrBelow(warning, originalSchemaPointer)).map((warning) => originalSchemaPointer === schemaPointer ? warning : rebaseWarningDocumentPath(warning, originalSchemaPointer, schemaPointer));
+			return {
+				variantIndex,
+				responseName: variant.responseName,
+				header: headerEntry.header,
+				warnings,
+				schemaKey: stableStringifyJsonSchema(headerEntry.header.schema)
+			};
+		});
+	});
+}
+function headerEntriesFor(headers, name) {
+	const lowerName = name.toLowerCase();
+	const entries = [];
+	for (const [headerName, header] of Object.entries(headers)) if (headerName.toLowerCase() === lowerName) entries.push({
+		name: headerName,
+		header
+	});
+	return entries;
+}
+function distinctHeaderSchemaAppearances(appearances) {
+	const seenSchemas = /* @__PURE__ */ new Set();
+	const distinctAppearances = [];
+	for (const appearance of appearances) {
+		if (seenSchemas.has(appearance.schemaKey)) continue;
+		seenSchemas.add(appearance.schemaKey);
+		distinctAppearances.push(appearance);
+	}
+	return distinctAppearances;
+}
+function mergedHeaderSchema(appearances, schemaPointer) {
+	const firstAppearance = appearances[0];
+	if (firstAppearance === void 0) return;
+	if (appearances.length === 1) return firstAppearance.header.schema;
+	return { anyOf: appearances.map((appearance, index) => rebaseSchemaDocumentRefs(appearance.header.schema, schemaPointer, `${schemaPointer}/anyOf/${index}`)) };
+}
+function mergedHeaderSchemaWarnings(options) {
+	if (options.distinctSchemaAppearances.length <= 1) return options.appearances.flatMap((appearance) => appearance.warnings);
+	return options.appearances.flatMap((appearance) => {
+		const schemaIndex = options.distinctSchemaAppearances.findIndex((distinctAppearance) => distinctAppearance.schemaKey === appearance.schemaKey);
+		const branchPointer = `${options.schemaPointer}/anyOf/${schemaIndex}`;
+		return appearance.warnings.map((warning) => rebaseWarningDocumentPath(warning, options.schemaPointer, branchPointer));
+	});
+}
+function headerSchemaPointer(responsePointer, name) {
+	return `${responsePointer}/headers/${escapeJsonPointerSegment(name)}/schema`;
+}
+function mergedHeaderDescription(appearances) {
+	const describedAppearances = appearances.filter((appearance) => appearance.header.description !== void 0);
+	const distinctDescriptions = new Set(describedAppearances.map((appearance) => appearance.header.description));
+	if (distinctDescriptions.size === 0) return;
+	if (distinctDescriptions.size === 1) return describedAppearances[0]?.header.description;
+	return ["Header description merged from response variants:", ...describedAppearances.map((appearance) => `- ${appearance.responseName}: ${appearance.header.description ?? ""}`)].join("\n");
+}
+function stableStringifyJsonSchema(schema) {
+	return JSON.stringify(canonicalizeJsonSchemaValue(schema));
+}
+function canonicalizeJsonSchemaValue(value) {
+	if (Array.isArray(value)) return value.map(canonicalizeJsonSchemaValue);
+	if (!isJsonSchemaObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, child]) => [key, canonicalizeJsonSchemaValue(child)]));
+}
+function isJsonSchemaObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/internal/responses.ts
+function buildComponentsResponses(responses, schemaRegistry) {
+	const warnings = [];
+	return {
+		responses: Object.fromEntries(responses.map((response) => {
+			const responsePointer = jsonPointer([
+				"components",
+				"responses",
+				response.name
+			]);
+			const built = buildResponseObject(response, {
+				schemaRegistry,
+				responseName: response.name,
+				statusCode: String(response.statusCode),
+				responsePointer,
+				bodyBaseName: `${response.name}Body`
+			});
+			warnings.push(...built.warnings);
+			return [response.name, built.response];
+		})),
+		warnings
+	};
+}
+function buildOperationResponses(usages, canonicalResponsesByName, context, schemaRegistry) {
+	const responsesPointer = operationResponsesPointer(context);
+	const resolved = resolveResponseVariants(usages, {
+		canonicalResponsesByName,
+		context,
+		responsesPointer
+	});
+	const warnings = [...resolved.warnings];
+	const responses = {};
+	for (const [statusCode, variants] of groupResponsesByStatus(resolved.variants)) {
+		const built = buildResponseForStatus(variants, {
+			schemaRegistry,
+			context,
+			statusCode,
+			responsePointer: `${responsesPointer}/${statusCode}`
+		});
+		if (built === void 0) continue;
+		responses[statusCode] = built.response;
+		warnings.push(...built.warnings);
+	}
+	return {
+		responses,
+		warnings
+	};
+}
+function operationResponsesPointer(context) {
+	return jsonPointer([
+		"paths",
+		context.openApiPath,
+		context.method,
+		"responses"
+	]);
+}
+function resolveResponseVariants(usages, options) {
+	const warnings = [];
+	const variants = [];
+	for (const usage of usages) {
+		const response = resolveResponse(usage, options.canonicalResponsesByName);
+		if (response === void 0) {
+			warnings.push(createBuilderWarning({
+				code: "missing-canonical-response",
+				message: `Canonical response '${usage.responseName}' is not defined.`,
+				documentPath: options.responsesPointer,
+				context: options.context,
+				part: "response",
+				responseName: usage.responseName
+			}));
+			continue;
+		}
+		variants.push({
+			response,
+			usage,
+			statusCode: String(response.statusCode)
+		});
+	}
+	return {
+		variants,
+		warnings
+	};
+}
+function buildResponseForStatus(variants, options) {
+	if (variants.length === 1) {
+		const variant = variants[0];
+		return variant === void 0 ? void 0 : buildSingleResponseVariant(variant, options);
+	}
+	return buildMergedResponseObject(variants, {
+		schemaRegistry: options.schemaRegistry,
+		context: options.context,
+		statusCode: options.statusCode,
+		responsePointer: options.responsePointer
+	});
+}
+function buildSingleResponseVariant(variant, options) {
+	if (variant.usage.source === "canonical") return {
+		response: { $ref: `#/components/responses/${escapeJsonPointerSegment(variant.usage.responseName)}` },
+		warnings: []
+	};
+	const built = buildResponseObject(variant.response, {
+		schemaRegistry: options.schemaRegistry,
+		context: options.context,
+		responseName: variant.usage.responseName,
+		statusCode: options.statusCode,
+		responsePointer: options.responsePointer,
+		bodyBaseName: inlineResponseBodyBaseName(options.context, variant.usage.responseName)
+	});
+	return {
+		response: built.response,
+		warnings: built.warnings
+	};
+}
+function groupResponsesByStatus(variants) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const variant of variants) {
+		const group = groups.get(variant.statusCode);
+		if (group === void 0) {
+			groups.set(variant.statusCode, [variant]);
+			continue;
+		}
+		group.push(variant);
+	}
+	return groups;
+}
+function resolveResponse(usage, canonicalResponsesByName) {
+	return usage.source === "inline" ? usage.response : canonicalResponsesByName.get(usage.responseName);
+}
+function buildResponseObject(response, options) {
+	const context = options.context ?? createComponentResponseContext(options.responseName);
+	const headers = buildHeaderObjects(response.header, context, {
+		responseName: options.responseName,
+		statusCode: options.statusCode,
+		part: "response.header",
+		headersPointer: `${options.responsePointer}/headers`
+	});
+	const body = buildResponseBody(response, {
+		schemaRegistry: options.schemaRegistry,
+		context,
+		responseName: options.responseName,
+		statusCode: options.statusCode,
+		baseName: options.bodyBaseName
+	});
+	return {
+		response: {
+			description: response.description,
+			...Object.keys(headers.headers).length > 0 ? { headers: headers.headers } : {},
+			...body.content === void 0 ? {} : { content: body.content }
+		},
+		warnings: [...headers.warnings, ...body.warnings]
+	};
+}
+function buildResponseBody(response, options) {
+	const body = response.body;
+	if (body === void 0) return { warnings: [] };
+	const registration = registerResponseBody(body, {
+		schemaRegistry: options.schemaRegistry,
+		context: options.context,
+		responseName: options.responseName,
+		statusCode: options.statusCode,
+		baseName: options.baseName
+	});
+	return {
+		content: { [body.mediaType]: { schema: registration.schema } },
+		warnings: registration.warnings
+	};
+}
+function buildMergedResponseObject(variants, options) {
+	const body = buildMergedResponseBody(variants, options);
+	const headers = buildMergedHeaders(variants, options);
+	return {
+		response: {
+			description: variants.map((variant) => `${variant.usage.responseName}: ${variant.response.description}`).join("\n\n"),
+			...Object.keys(headers.headers).length > 0 ? { headers: headers.headers } : {},
+			...body.content === void 0 ? {} : { content: body.content }
+		},
+		warnings: [...body.warnings, ...headers.warnings]
+	};
+}
+function buildMergedResponseBody(variants, options) {
+	const warnings = [];
+	const schemasByMediaType = /* @__PURE__ */ new Map();
+	for (const variant of variants) {
+		const body = variant.response.body;
+		if (body === void 0) continue;
+		const registration = registerResponseBody(body, {
+			schemaRegistry: options.schemaRegistry,
+			context: options.context,
+			baseName: responseBodyBaseName(options.context, variant.usage),
+			responseName: variant.usage.responseName,
+			statusCode: options.statusCode
+		});
+		const schemas = schemasByMediaType.get(body.mediaType) ?? [];
+		schemasByMediaType.set(body.mediaType, [...schemas, registration]);
+		warnings.push(...registration.warnings);
+	}
+	if (schemasByMediaType.size === 0) return { warnings };
+	return {
+		content: Object.fromEntries(Array.from(schemasByMediaType, ([mediaType, registrations]) => [mediaType, { schema: mergedMediaTypeSchema(registrations) }])),
+		warnings
+	};
+}
+function mergedMediaTypeSchema(registrations) {
+	const distinctSchemas = distinctBy(registrations, (registration) => registration.schemaKey).map((registration) => registration.schema);
+	const firstSchema = distinctSchemas[0];
+	if (firstSchema === void 0) return {};
+	return distinctSchemas.slice(1).length === 0 ? firstSchema : { anyOf: distinctSchemas };
+}
+function registerResponseBody(body, options) {
+	const resolvedSchema = resolveOpenApiBodySchema(body, () => {
+		const registration = options.schemaRegistry.register({
+			schema: body.schema,
+			baseName: options.baseName,
+			location: createOperationLocation({
+				context: options.context,
+				part: "response.body",
+				responseName: options.responseName,
+				statusCode: options.statusCode
+			})
+		});
+		return {
+			schema: registration.ref,
+			schemaKey: registration.ref.$ref,
+			warnings: registration.warnings
+		};
+	});
+	return {
+		mediaType: body.mediaType,
+		...resolvedSchema
+	};
+}
+function responseBodyBaseName(context, usage) {
+	return usage.source === "canonical" ? `${usage.responseName}Body` : inlineResponseBodyBaseName(context, usage.responseName);
+}
+function inlineResponseBodyBaseName(context, responseName) {
+	return `${pascalCase(context.operation.operationId)}${responseName}Body`;
+}
+function distinctBy(values, keyForValue) {
+	const seen = /* @__PURE__ */ new Set();
+	const distinctValues = [];
+	for (const value of values) {
+		const key = keyForValue(value);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		distinctValues.push(value);
+	}
+	return distinctValues;
+}
+function createComponentResponseContext(responseName) {
+	return {
+		resourceName: "components.responses",
+		operation: {
+			operationId: responseName,
+			method: "components",
+			path: "#/components/responses"
+		},
+		openApiPath: "#/components/responses",
+		method: "components"
+	};
+}
+function createBuilderWarning(options) {
+	return {
+		origin: "openapi-builder",
+		code: options.code,
+		message: options.message,
+		documentPath: options.documentPath,
+		location: createOperationLocation(options)
+	};
+}
+//#endregion
+//#region src/internal/schemaRegistry.ts
+function createSchemaRegistry() {
+	const entriesBySchema = /* @__PURE__ */ new WeakMap();
+	const components = /* @__PURE__ */ new Map();
+	return {
+		register: (options) => {
+			const schema = unwrapRootOptional(options.schema).schema;
+			const existingEntry = entriesBySchema.get(schema);
+			if (existingEntry !== void 0) return {
+				name: existingEntry.name,
+				ref: existingEntry.ref,
+				warnings: []
+			};
+			const name = nextComponentName(options.baseName, components);
+			const converted = convertSchema(schema, jsonPointer([
+				"components",
+				"schemas",
+				name
+			]), options.location);
+			const ref = { $ref: `#/components/schemas/${escapeJsonPointerSegment(name)}` };
+			const entry = {
+				name,
+				ref,
+				schema: converted.schema
+			};
+			entriesBySchema.set(schema, entry);
+			components.set(name, converted.schema);
+			return {
+				name,
+				ref,
+				warnings: converted.warnings
+			};
+		},
+		components: () => Object.fromEntries(components)
+	};
+}
+function nextComponentName(baseName, components) {
+	const sanitizedName = sanitizeComponentName(baseName);
+	if (!components.has(sanitizedName)) return sanitizedName;
+	for (let suffix = 2;; suffix += 1) {
+		const name = `${sanitizedName}_${suffix}`;
+		if (!components.has(name)) return name;
+	}
+}
+function sanitizeComponentName(name) {
+	const sanitizedName = name.trim().replaceAll(/[^A-Za-z0-9._-]/g, "_").replaceAll(/_+/g, "_").replaceAll(/^_+|_+$/g, "");
+	return sanitizedName === "" ? "Schema" : sanitizedName;
+}
+//#endregion
+//#region src/buildOpenApiDocument.ts
+function buildOpenApiDocument(normalizedSpec, options) {
+	const warnings = [...duplicateCanonicalResponseWarnings(normalizedSpec.responses)];
+	const schemaRegistry = createSchemaRegistry();
+	const canonicalResponses = buildComponentsResponses(normalizedSpec.responses, schemaRegistry);
+	const canonicalResponsesByName = new Map(normalizedSpec.responses.map((response) => [response.name, response]));
+	const paths = {};
+	warnings.push(...canonicalResponses.warnings);
+	for (const resource of normalizedSpec.resources) for (const operation of resource.operations) {
+		const method = operation.method.toLowerCase();
+		const openApiPath = toOpenApiPath(operation.path);
+		const operationObject = buildOperationObject({
+			resourceName: resource.name,
+			operation,
+			openApiPath,
+			method,
+			canonicalResponsesByName,
+			schemaRegistry
+		});
+		paths[openApiPath] = {
+			...paths[openApiPath],
+			[method]: operationObject.operation
+		};
+		warnings.push(...operationObject.warnings);
+	}
+	const schemas = schemaRegistry.components();
+	const responses = canonicalResponses.responses;
+	const hasResponses = Object.keys(responses).length > 0;
+	const hasSchemas = Object.keys(schemas).length > 0;
+	return {
+		document: {
+			openapi: "3.1.1",
+			jsonSchemaDialect: "https://json-schema.org/draft/2020-12/schema",
+			info: { ...options.info },
+			...options.servers === void 0 ? {} : { servers: [...options.servers] },
+			tags: normalizedSpec.resources.map((resource) => ({ name: resource.name })),
+			paths,
+			...!hasResponses && !hasSchemas ? {} : { components: {
+				...hasResponses ? { responses } : {},
+				...hasSchemas ? { schemas } : {}
+			} }
+		},
+		warnings
+	};
+}
+function buildOperationObject(options) {
+	const context = {
+		resourceName: options.resourceName,
+		operation: options.operation,
+		openApiPath: options.openApiPath,
+		method: options.method
+	};
+	const parameters = buildRequestParameters(context);
+	const requestBody = buildRequestBody(context, options.schemaRegistry);
+	const responses = buildOperationResponses(options.operation.responses, options.canonicalResponsesByName, context, options.schemaRegistry);
+	return {
+		operation: {
+			operationId: options.operation.operationId,
+			...options.operation.summary.trim() === "" ? {} : { summary: options.operation.summary },
+			tags: [options.resourceName],
+			...parameters.parameters.length === 0 ? {} : { parameters: parameters.parameters },
+			...requestBody.requestBody === void 0 ? {} : { requestBody: requestBody.requestBody },
+			responses: responses.responses
+		},
+		warnings: [
+			...parameters.warnings,
+			...requestBody.warnings,
+			...responses.warnings
+		]
+	};
+}
+function buildRequestBody(context, schemaRegistry) {
+	const body = context.operation.request?.body;
+	if (body === void 0) return { warnings: [] };
+	const optionalSchema = unwrapRootOptional(body.schema);
+	const resolvedSchema = resolveOpenApiBodySchema(body, () => {
+		const registration = schemaRegistry.register({
+			schema: optionalSchema.schema,
+			baseName: `${pascalCase(context.operation.operationId)}RequestBody`,
+			location: {
+				resourceName: context.resourceName,
+				operationId: context.operation.operationId,
+				method: context.operation.method,
+				path: context.operation.path,
+				openApiPath: context.openApiPath,
+				part: "request.body"
+			}
+		});
+		return {
+			schema: registration.ref,
+			schemaKey: registration.ref.$ref,
+			warnings: registration.warnings
+		};
+	});
+	return {
+		requestBody: {
+			required: !optionalSchema.isOptional,
+			content: { [body.mediaType]: { schema: resolvedSchema.schema } }
+		},
+		warnings: resolvedSchema.warnings
+	};
+}
+function duplicateCanonicalResponseWarnings(responses) {
+	const firstSeenAt = /* @__PURE__ */ new Map();
+	const warnings = [];
+	responses.forEach((response, index) => {
+		const previousIndex = firstSeenAt.get(response.name);
+		if (previousIndex === void 0) {
+			firstSeenAt.set(response.name, index);
+			return;
+		}
+		warnings.push({
+			origin: "openapi-builder",
+			code: "duplicate-canonical-response",
+			message: `Canonical response '${response.name}' is defined more than once; the entry at index ${index} overrides the entry at index ${previousIndex}.`,
+			documentPath: jsonPointer([
+				"components",
+				"responses",
+				response.name
+			]),
+			location: {
+				responseName: response.name,
+				part: "components.responses"
+			}
+		});
+	});
+	return warnings;
+}
+//#endregion
+//#region src/OpenApiPlugin.ts
+const DEFAULT_INFO = {
+	title: "Typeweaver API",
+	version: "0.0.0"
+};
+const DEFAULT_OUTPUT_PATH = "openapi/openapi.json";
+var OpenApiPlugin = class extends BasePlugin {
+	name = "openapi";
+	options;
+	constructor(options = {}) {
+		super({});
+		this.options = normalizeOptions(validateOptions(options));
+	}
+	generate(context) {
+		const result = buildOpenApiDocument(context.normalizedSpec, {
+			info: this.options.info,
+			servers: this.options.servers
+		});
+		const json = `${JSON.stringify(result.document, null, 2)}\n`;
+		context.writeFile(this.options.outputPath, json);
+		if (result.warnings.length > 0) console.warn(formatWarnings(result.warnings));
+	}
+};
+function validateOptions(options) {
+	if (!isPlainObject(options)) throwConfigError("options must be an object");
+	return options;
+}
+function normalizeOptions(options) {
+	const outputPath = options.outputPath === void 0 ? DEFAULT_OUTPUT_PATH : options.outputPath;
+	return {
+		info: normalizeInfo(options.info),
+		...options.servers === void 0 ? {} : { servers: normalizeServers(options.servers) },
+		outputPath: normalizeOutputPath(outputPath)
+	};
+}
+function normalizeInfo(info) {
+	if (info === void 0) return { ...DEFAULT_INFO };
+	if (!isPlainObject(info)) throwConfigError("info must be an object with string title and version");
+	if (typeof info.title !== "string" || typeof info.version !== "string") throwConfigError("info.title and info.version must be strings");
+	return { ...info };
+}
+function normalizeServers(servers) {
+	if (!Array.isArray(servers)) throwConfigError("servers must be an array of objects with string url");
+	return servers.map((server, index) => {
+		if (!isOpenApiServerObject(server)) throwConfigError(`servers[${index}].url must be a string`);
+		return { ...server };
+	});
+}
+function normalizeOutputPath(outputPath) {
+	if (typeof outputPath !== "string" || outputPath.length === 0) throwConfigError("outputPath must be a non-empty relative .json path");
+	if (!outputPath.endsWith(".json")) throwConfigError("outputPath must end with .json");
+	if (outputPath.includes("\0")) throwConfigError("outputPath must not contain null bytes");
+	if (path.isAbsolute(outputPath) || path.win32.isAbsolute(outputPath)) throwConfigError("outputPath must be relative");
+	const pathSegments = outputPath.replace(/\\/g, "/").split("/");
+	if (pathSegments.some((segment) => segment === "..")) throwConfigError("outputPath must not contain parent directory segments");
+	const normalizedPath = path.posix.normalize(pathSegments.join("/"));
+	if (normalizedPath === "." || normalizedPath.startsWith("../")) throwConfigError("outputPath must be a safe relative .json path");
+	return normalizedPath;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOpenApiServerObject(value) {
+	return isPlainObject(value) && typeof value.url === "string";
+}
+function throwConfigError(message) {
+	throw new Error(`OpenApiPlugin config error: ${message}`);
+}
+function formatWarnings(warnings) {
+	const warningLines = warnings.map((warning) => `- ${warning.code}: ${warning.message} (${warning.documentPath})`);
+	return [`OpenAPI generation completed with ${warnings.length} warning(s).`, ...warningLines].join("\n");
+}
+//#endregion
+export { OpenApiPlugin, buildOpenApiDocument };
+
+//# sourceMappingURL=index.mjs.map