every-plugin 0.4.9 → 0.4.11

package/dist/plugins-hpi2GlaX.mjs

@@ -0,0 +1,790 @@
+import { _ as value, a as toHttpPath, c as fallbackORPCErrorStatus, d as findDeepMatches, f as isObject, h as toArray, i as standardizeHTTPPath, l as isORPCErrorStatus, m as stringifyJSON, p as once, r as getDynamicParams, s as fallbackORPCErrorMessage, t as StandardOpenAPIJsonSerializer, u as clone } from "./standard-CYaRay89.mjs";
+import { isProcedure, resolveContractProcedures } from "@orpc/server";
+import { fallbackContractConfig, getEventIteratorSchemaDetails } from "@orpc/contract";
+
+//#region ../../node_modules/.bun/@orpc+interop@1.10.4/node_modules/@orpc/interop/dist/json-schema-typed/index.mjs
+var ContentEncoding;
+(function(ContentEncoding1) {
+	ContentEncoding1["7bit"] = "7bit";
+	ContentEncoding1["8bit"] = "8bit";
+	ContentEncoding1["Base64"] = "base64";
+	ContentEncoding1["Binary"] = "binary";
+	ContentEncoding1["IETFToken"] = "ietf-token";
+	ContentEncoding1["QuotedPrintable"] = "quoted-printable";
+	ContentEncoding1["XToken"] = "x-token";
+})(ContentEncoding || (ContentEncoding = {}));
+var Format;
+(function(Format1) {
+	Format1["Date"] = "date";
+	Format1["DateTime"] = "date-time";
+	Format1["Duration"] = "duration";
+	Format1["Email"] = "email";
+	Format1["Hostname"] = "hostname";
+	Format1["IDNEmail"] = "idn-email";
+	Format1["IDNHostname"] = "idn-hostname";
+	Format1["IPv4"] = "ipv4";
+	Format1["IPv6"] = "ipv6";
+	Format1["IRI"] = "iri";
+	Format1["IRIReference"] = "iri-reference";
+	Format1["JSONPointer"] = "json-pointer";
+	Format1["JSONPointerURIFragment"] = "json-pointer-uri-fragment";
+	Format1["RegEx"] = "regex";
+	Format1["RelativeJSONPointer"] = "relative-json-pointer";
+	Format1["Time"] = "time";
+	Format1["URI"] = "uri";
+	Format1["URIReference"] = "uri-reference";
+	Format1["URITemplate"] = "uri-template";
+	Format1["UUID"] = "uuid";
+})(Format || (Format = {}));
+var TypeName;
+(function(TypeName1) {
+	TypeName1["Array"] = "array";
+	TypeName1["Boolean"] = "boolean";
+	TypeName1["Integer"] = "integer";
+	TypeName1["Null"] = "null";
+	TypeName1["Number"] = "number";
+	TypeName1["Object"] = "object";
+	TypeName1["String"] = "string";
+})(TypeName || (TypeName = {}));
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/shared/openapi.DrTcell5.mjs
+const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function getCustomOpenAPIOperation(o) {
+	return o[OPERATION_EXTENDER_SYMBOL];
+}
+function applyCustomOpenAPIOperation(operation, contract) {
+	const operationCustoms = [];
+	for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
+		const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+		if (maybeExtender) operationCustoms.push(maybeExtender);
+	}
+	if (isProcedure(contract)) for (const middleware of contract["~orpc"].middlewares) {
+		const maybeExtender = getCustomOpenAPIOperation(middleware);
+		if (maybeExtender) operationCustoms.push(maybeExtender);
+	}
+	let currentOperation = operation;
+	for (const custom of operationCustoms) if (typeof custom === "function") currentOperation = custom(currentOperation, contract);
+	else currentOperation = {
+		...currentOperation,
+		...custom
+	};
+	return currentOperation;
+}
+const LOGIC_KEYWORDS = [
+	"$dynamicRef",
+	"$ref",
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"const",
+	"contains",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema",
+	"dependencies",
+	"dependentRequired",
+	"dependentSchemas",
+	"else",
+	"enum",
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"format",
+	"if",
+	"items",
+	"maxContains",
+	"maximum",
+	"maxItems",
+	"maxLength",
+	"maxProperties",
+	"minContains",
+	"minimum",
+	"minItems",
+	"minLength",
+	"minProperties",
+	"multipleOf",
+	"not",
+	"oneOf",
+	"pattern",
+	"patternProperties",
+	"prefixItems",
+	"properties",
+	"propertyNames",
+	"required",
+	"then",
+	"type",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"uniqueItems"
+];
+function isFileSchema(schema) {
+	return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+	return isObject(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+	if (schema === true) return true;
+	if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) return true;
+	return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+	if (Object.keys(schema).some((k) => ![
+		"type",
+		"properties",
+		"required",
+		"additionalProperties"
+	].includes(k) && LOGIC_KEYWORDS.includes(k) && schema[k] !== void 0)) return [{ type: "object" }, schema];
+	const matched = { ...schema };
+	const rest = { ...schema };
+	matched.properties = separatedProperties.reduce((acc, key) => {
+		const keySchema = schema.properties?.[key] ?? schema.additionalProperties;
+		if (keySchema !== void 0) acc[key] = keySchema;
+		return acc;
+	}, {});
+	matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
+	matched.examples = schema.examples?.map((example) => {
+		if (!isObject(example)) return example;
+		return Object.entries(example).reduce((acc, [key, value$1]) => {
+			if (separatedProperties.includes(key)) acc[key] = value$1;
+			return acc;
+		}, {});
+	});
+	rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value$1]) => {
+		acc[key] = value$1;
+		return acc;
+	}, {});
+	rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
+	rest.examples = schema.examples?.map((example) => {
+		if (!isObject(example)) return example;
+		return Object.entries(example).reduce((acc, [key, value$1]) => {
+			if (!separatedProperties.includes(key)) acc[key] = value$1;
+			return acc;
+		}, {});
+	});
+	return [matched, rest];
+}
+function filterSchemaBranches(schema, check, matches = []) {
+	if (check(schema)) {
+		matches.push(schema);
+		return [matches, void 0];
+	}
+	if (isObject(schema)) {
+		for (const keyword of ["anyOf", "oneOf"]) if (schema[keyword] && Object.keys(schema).every((k) => k === keyword || !LOGIC_KEYWORDS.includes(k))) {
+			const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
+			if (rest.length === 1 && typeof rest[0] === "object") return [matches, {
+				...schema,
+				[keyword]: void 0,
+				...rest[0]
+			}];
+			return [matches, {
+				...schema,
+				[keyword]: rest
+			}];
+		}
+	}
+	return [matches, schema];
+}
+function applySchemaOptionality(required, schema) {
+	if (required) return schema;
+	return { anyOf: [schema, { not: {} }] };
+}
+function expandUnionSchema(schema) {
+	if (typeof schema === "object") {
+		for (const keyword of ["anyOf", "oneOf"]) if (schema[keyword] && Object.keys(schema).every((k) => k === keyword || !LOGIC_KEYWORDS.includes(k))) return schema[keyword].flatMap((s) => expandUnionSchema(s));
+	}
+	return [schema];
+}
+function expandArrayableSchema(schema) {
+	const schemas = expandUnionSchema(schema);
+	if (schemas.length !== 2) return;
+	const arraySchema = schemas.find((s) => typeof s === "object" && s.type === "array" && Object.keys(s).filter((k) => LOGIC_KEYWORDS.includes(k)).every((k) => k === "type" || k === "items"));
+	if (arraySchema === void 0) return;
+	const items1 = arraySchema.items;
+	const items2 = schemas.find((s) => s !== arraySchema);
+	if (stringifyJSON(items1) !== stringifyJSON(items2)) return;
+	return [items2, arraySchema];
+}
+const PRIMITIVE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+	TypeName.String,
+	TypeName.Number,
+	TypeName.Integer,
+	TypeName.Boolean,
+	TypeName.Null
+]);
+function isPrimitiveSchema(schema) {
+	return expandUnionSchema(schema).every((s) => {
+		if (typeof s === "boolean") return false;
+		if (typeof s.type === "string" && PRIMITIVE_SCHEMA_TYPES.has(s.type)) return true;
+		if (s.const !== void 0) return true;
+		return false;
+	});
+}
+function toOpenAPIPath(path) {
+	return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+	return method.toLocaleLowerCase();
+}
+function toOpenAPIContent(schema) {
+	const content = {};
+	const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+	for (const file of matches) content[file.contentMediaType] = { schema: toOpenAPISchema(file) };
+	if (restSchema !== void 0) {
+		content["application/json"] = { schema: toOpenAPISchema(restSchema) };
+		if (findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0) content["multipart/form-data"] = { schema: toOpenAPISchema(restSchema) };
+	}
+	return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+	return { "text/event-stream": { schema: toOpenAPISchema({ oneOf: [
+		{
+			type: "object",
+			properties: {
+				event: { const: "message" },
+				data: yieldsSchema,
+				id: { type: "string" },
+				retry: { type: "number" }
+			},
+			required: yieldsRequired ? ["event", "data"] : ["event"]
+		},
+		{
+			type: "object",
+			properties: {
+				event: { const: "done" },
+				data: returnsSchema,
+				id: { type: "string" },
+				retry: { type: "number" }
+			},
+			required: returnsRequired ? ["event", "data"] : ["event"]
+		},
+		{
+			type: "object",
+			properties: {
+				event: { const: "error" },
+				data: {},
+				id: { type: "string" },
+				retry: { type: "number" }
+			},
+			required: ["event"]
+		}
+	] }) } };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+	const parameters = [];
+	for (const key in schema.properties) {
+		const keySchema = schema.properties[key];
+		let isDeepObjectStyle = true;
+		if (parameterIn !== "query") isDeepObjectStyle = false;
+		else if (isPrimitiveSchema(keySchema)) isDeepObjectStyle = false;
+		else {
+			const [item] = expandArrayableSchema(keySchema) ?? [];
+			if (item !== void 0 && isPrimitiveSchema(item)) isDeepObjectStyle = false;
+		}
+		parameters.push({
+			name: key,
+			in: parameterIn,
+			required: schema.required?.includes(key),
+			schema: toOpenAPISchema(keySchema),
+			style: isDeepObjectStyle ? "deepObject" : void 0,
+			explode: isDeepObjectStyle ? true : void 0,
+			allowEmptyValue: parameterIn === "query" ? true : void 0,
+			allowReserved: parameterIn === "query" ? true : void 0
+		});
+	}
+	return parameters;
+}
+function checkParamsSchema(schema, params) {
+	const properties = Object.keys(schema.properties ?? {});
+	const required = schema.required ?? [];
+	if (properties.length !== params.length || properties.some((v) => !params.includes(v))) return false;
+	if (required.length !== params.length || required.some((v) => !params.includes(v))) return false;
+	return true;
+}
+function toOpenAPISchema(schema) {
+	return schema === true ? {} : schema === false ? { not: {} } : schema;
+}
+const OPENAPI_JSON_SCHEMA_REF_PREFIX = "#/components/schemas/";
+function resolveOpenAPIJsonSchemaRef(doc, schema) {
+	if (typeof schema !== "object" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) return schema;
+	const name = schema.$ref.slice(21);
+	return doc.components?.schemas?.[name] ?? schema;
+}
+var CompositeSchemaConverter = class {
+	converters;
+	constructor(converters) {
+		this.converters = converters;
+	}
+	async convert(schema, options) {
+		for (const converter of this.converters) if (await converter.condition(schema, options)) return converter.convert(schema, options);
+		return [false, {}];
+	}
+};
+var OpenAPIGeneratorError = class extends Error {};
+var OpenAPIGenerator = class {
+	serializer;
+	converter;
+	constructor(options = {}) {
+		this.serializer = new StandardOpenAPIJsonSerializer(options);
+		this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));
+	}
+	/**
+	* Generates OpenAPI specifications from oRPC routers/contracts.
+	*
+	* @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+	*/
+	async generate(router, { customErrorResponseBodySchema, commonSchemas, filter: baseFilter, exclude,...baseDoc } = {}) {
+		const filter = baseFilter ?? (({ contract, path }) => {
+			return !(exclude?.(contract, path) ?? false);
+		});
+		const doc = {
+			...clone(baseDoc),
+			info: baseDoc.info ?? {
+				title: "API Reference",
+				version: "0.0.0"
+			},
+			openapi: "3.1.1"
+		};
+		const { baseSchemaConvertOptions, undefinedErrorJsonSchema } = await this.#resolveCommonSchemas(doc, commonSchemas);
+		const contracts = [];
+		await resolveContractProcedures({
+			path: [],
+			router
+		}, (traverseOptions) => {
+			if (!value(filter, traverseOptions)) return;
+			contracts.push(traverseOptions);
+		});
+		const errors = [];
+		for (const { contract, path } of contracts) {
+			const stringPath = path.join(".");
+			try {
+				const def = contract["~orpc"];
+				const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
+				const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
+				let operationObjectRef;
+				if (def.route.spec !== void 0 && typeof def.route.spec !== "function") operationObjectRef = def.route.spec;
+				else {
+					operationObjectRef = {
+						operationId: def.route.operationId ?? stringPath,
+						summary: def.route.summary,
+						description: def.route.description,
+						deprecated: def.route.deprecated,
+						tags: def.route.tags?.map((tag) => tag)
+					};
+					await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
+					await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
+					await this.#errorResponse(operationObjectRef, def, baseSchemaConvertOptions, undefinedErrorJsonSchema, customErrorResponseBodySchema);
+				}
+				if (typeof def.route.spec === "function") operationObjectRef = def.route.spec(operationObjectRef);
+				doc.paths ??= {};
+				doc.paths[httpPath] ??= {};
+				doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
+			} catch (e) {
+				if (!(e instanceof OpenAPIGeneratorError)) throw e;
+				errors.push(`[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${stringPath}
+${e.message}`);
+			}
+		}
+		if (errors.length) throw new OpenAPIGeneratorError(`Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`);
+		return this.serializer.serialize(doc)[0];
+	}
+	async #resolveCommonSchemas(doc, commonSchemas) {
+		let undefinedErrorJsonSchema = {
+			type: "object",
+			properties: {
+				defined: { const: false },
+				code: { type: "string" },
+				status: { type: "number" },
+				message: { type: "string" },
+				data: {}
+			},
+			required: [
+				"defined",
+				"code",
+				"status",
+				"message"
+			]
+		};
+		const baseSchemaConvertOptions = {};
+		if (commonSchemas) {
+			baseSchemaConvertOptions.components = [];
+			for (const key in commonSchemas) {
+				const options = commonSchemas[key];
+				if (options.schema === void 0) continue;
+				const { schema, strategy = "input" } = options;
+				const [required, json] = await this.converter.convert(schema, { strategy });
+				const allowedStrategies = [strategy];
+				if (strategy === "input") {
+					const [outputRequired, outputJson] = await this.converter.convert(schema, { strategy: "output" });
+					if (outputRequired === required && stringifyJSON(outputJson) === stringifyJSON(json)) allowedStrategies.push("output");
+				} else if (strategy === "output") {
+					const [inputRequired, inputJson] = await this.converter.convert(schema, { strategy: "input" });
+					if (inputRequired === required && stringifyJSON(inputJson) === stringifyJSON(json)) allowedStrategies.push("input");
+				}
+				baseSchemaConvertOptions.components.push({
+					schema,
+					required,
+					ref: `#/components/schemas/${key}`,
+					allowedStrategies
+				});
+			}
+			doc.components ??= {};
+			doc.components.schemas ??= {};
+			for (const key in commonSchemas) {
+				const options = commonSchemas[key];
+				if (options.schema === void 0) {
+					if (options.error === "UndefinedError") {
+						doc.components.schemas[key] = toOpenAPISchema(undefinedErrorJsonSchema);
+						undefinedErrorJsonSchema = { $ref: `#/components/schemas/${key}` };
+					}
+					continue;
+				}
+				const { schema, strategy = "input" } = options;
+				const [, json] = await this.converter.convert(schema, {
+					...baseSchemaConvertOptions,
+					strategy,
+					minStructureDepthForRef: 1
+				});
+				doc.components.schemas[key] = toOpenAPISchema(json);
+			}
+		}
+		return {
+			baseSchemaConvertOptions,
+			undefinedErrorJsonSchema
+		};
+	}
+	async #request(doc, ref, def, baseSchemaConvertOptions) {
+		const method = fallbackContractConfig("defaultMethod", def.route.method);
+		const details = getEventIteratorSchemaDetails(def.inputSchema);
+		if (details) {
+			ref.requestBody = {
+				required: true,
+				content: toOpenAPIEventIteratorContent(await this.converter.convert(details.yields, {
+					...baseSchemaConvertOptions,
+					strategy: "input"
+				}), await this.converter.convert(details.returns, {
+					...baseSchemaConvertOptions,
+					strategy: "input"
+				}))
+			};
+			return;
+		}
+		const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
+		const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
+		let [required, schema] = await this.converter.convert(def.inputSchema, {
+			...baseSchemaConvertOptions,
+			strategy: "input",
+			minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+		});
+		if (isAnySchema(schema) && !dynamicParams?.length) return;
+		if (inputStructure === "compact") {
+			if (dynamicParams?.length) {
+				const error2 = new OpenAPIGeneratorError("When input structure is \"compact\", and path has dynamic params, input schema must be an object with all dynamic params as required.");
+				if (!isObjectSchema(schema)) throw error2;
+				const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+				schema = rest;
+				required = rest.required ? rest.required.length !== 0 : false;
+				if (!checkParamsSchema(paramsSchema, dynamicParams)) throw error2;
+				ref.parameters ??= [];
+				ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+			}
+			if (method === "GET") {
+				const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);
+				if (!isObjectSchema(resolvedSchema)) throw new OpenAPIGeneratorError("When method is \"GET\", input schema must satisfy: object | any | unknown");
+				ref.parameters ??= [];
+				ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
+			} else ref.requestBody = {
+				required,
+				content: toOpenAPIContent(schema)
+			};
+			return;
+		}
+		const error = new OpenAPIGeneratorError("When input structure is \"detailed\", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }");
+		if (!isObjectSchema(schema)) throw error;
+		const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;
+		if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) throw new OpenAPIGeneratorError("When input structure is \"detailed\" and path has dynamic params, the \"params\" schema must be an object with all dynamic params as required.");
+		for (const from of [
+			"params",
+			"query",
+			"headers"
+		]) {
+			const fromSchema = schema.properties?.[from];
+			if (fromSchema !== void 0) {
+				const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);
+				if (!isObjectSchema(resolvedSchema)) throw error;
+				const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
+				ref.parameters ??= [];
+				ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
+			}
+		}
+		if (schema.properties?.body !== void 0) ref.requestBody = {
+			required: schema.required?.includes("body"),
+			content: toOpenAPIContent(schema.properties.body)
+		};
+	}
+	async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
+		const outputSchema = def.outputSchema;
+		const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
+		const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
+		const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
+		const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
+		if (eventIteratorSchemaDetails) {
+			ref.responses ??= {};
+			ref.responses[status] = {
+				description,
+				content: toOpenAPIEventIteratorContent(await this.converter.convert(eventIteratorSchemaDetails.yields, {
+					...baseSchemaConvertOptions,
+					strategy: "output"
+				}), await this.converter.convert(eventIteratorSchemaDetails.returns, {
+					...baseSchemaConvertOptions,
+					strategy: "output"
+				}))
+			};
+			return;
+		}
+		const [required, json] = await this.converter.convert(outputSchema, {
+			...baseSchemaConvertOptions,
+			strategy: "output",
+			minStructureDepthForRef: outputStructure === "detailed" ? 1 : 0
+		});
+		if (outputStructure === "compact") {
+			ref.responses ??= {};
+			ref.responses[status] = { description };
+			ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required, json));
+			return;
+		}
+		const handledStatuses = /* @__PURE__ */ new Set();
+		for (const item of expandUnionSchema(json)) {
+			const error = new OpenAPIGeneratorError(`
+        When output structure is "detailed", output schema must satisfy:
+        { 
+          status?: number, // must be a literal number and in the range of 200-399
+          headers?: Record<string, unknown>, 
+          body?: unknown 
+        }
+        
+        But got: ${stringifyJSON(item)}
+      `);
+			if (!isObjectSchema(item)) throw error;
+			let schemaStatus;
+			let schemaDescription;
+			if (item.properties?.status !== void 0) {
+				const statusSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.status);
+				if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) throw error;
+				schemaStatus = statusSchema.const;
+				schemaDescription = statusSchema.description;
+			}
+			const itemStatus = schemaStatus ?? status;
+			const itemDescription = schemaDescription ?? description;
+			if (handledStatuses.has(itemStatus)) throw new OpenAPIGeneratorError(`
+          When output structure is "detailed", each success status must be unique.
+          But got status: ${itemStatus} used more than once.
+        `);
+			handledStatuses.add(itemStatus);
+			ref.responses ??= {};
+			ref.responses[itemStatus] = { description: itemDescription };
+			if (item.properties?.headers !== void 0) {
+				const headersSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.headers);
+				if (!isObjectSchema(headersSchema)) throw error;
+				for (const key in headersSchema.properties) {
+					const headerSchema = headersSchema.properties[key];
+					if (headerSchema !== void 0) {
+						ref.responses[itemStatus].headers ??= {};
+						ref.responses[itemStatus].headers[key] = {
+							schema: toOpenAPISchema(headerSchema),
+							required: item.required?.includes("headers") && headersSchema.required?.includes(key)
+						};
+					}
+				}
+			}
+			if (item.properties?.body !== void 0) ref.responses[itemStatus].content = toOpenAPIContent(applySchemaOptionality(item.required?.includes("body") ?? false, item.properties.body));
+		}
+	}
+	async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema, customErrorResponseBodySchema) {
+		const errorMap = def.errorMap;
+		const errorResponsesByStatus = {};
+		for (const code in errorMap) {
+			const config = errorMap[code];
+			if (!config) continue;
+			const status = fallbackORPCErrorStatus(code, config.status);
+			const defaultMessage = fallbackORPCErrorMessage(code, config.message);
+			errorResponsesByStatus[status] ??= {
+				status,
+				definedErrorDefinitions: [],
+				errorSchemaVariants: []
+			};
+			const [dataRequired, dataSchema] = await this.converter.convert(config.data, {
+				...baseSchemaConvertOptions,
+				strategy: "output"
+			});
+			errorResponsesByStatus[status].definedErrorDefinitions.push([
+				code,
+				defaultMessage,
+				dataRequired,
+				dataSchema
+			]);
+			errorResponsesByStatus[status].errorSchemaVariants.push({
+				type: "object",
+				properties: {
+					defined: { const: true },
+					code: { const: code },
+					status: { const: status },
+					message: {
+						type: "string",
+						default: defaultMessage
+					},
+					data: dataSchema
+				},
+				required: dataRequired ? [
+					"defined",
+					"code",
+					"status",
+					"message",
+					"data"
+				] : [
+					"defined",
+					"code",
+					"status",
+					"message"
+				]
+			});
+		}
+		ref.responses ??= {};
+		for (const statusString in errorResponsesByStatus) {
+			const errorResponse = errorResponsesByStatus[statusString];
+			const customBodySchema = value(customErrorResponseBodySchema, errorResponse.definedErrorDefinitions, errorResponse.status);
+			ref.responses[statusString] = {
+				description: statusString,
+				content: toOpenAPIContent(customBodySchema ?? { oneOf: [...errorResponse.errorSchemaVariants, undefinedErrorSchema] })
+			};
+		}
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/plugins/index.mjs
+var OpenAPIReferencePlugin = class {
+	generator;
+	specGenerateOptions;
+	specPath;
+	docsPath;
+	docsTitle;
+	docsHead;
+	docsProvider;
+	docsScriptUrl;
+	docsCssUrl;
+	docsConfig;
+	renderDocsHtml;
+	constructor(options = {}) {
+		this.specGenerateOptions = options.specGenerateOptions;
+		this.docsPath = options.docsPath ?? "/";
+		this.docsTitle = options.docsTitle ?? "API Reference";
+		this.docsConfig = options.docsConfig ?? void 0;
+		this.docsProvider = options.docsProvider ?? "scalar";
+		this.docsScriptUrl = options.docsScriptUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js" : "https://cdn.jsdelivr.net/npm/@scalar/api-reference");
+		this.docsCssUrl = options.docsCssUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui.css" : void 0);
+		this.docsHead = options.docsHead ?? "";
+		this.specPath = options.specPath ?? "/spec.json";
+		this.generator = new OpenAPIGenerator(options);
+		const esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+		this.renderDocsHtml = options.renderDocsHtml ?? ((specUrl, title, head, scriptUrl, config, spec, docsProvider, cssUrl) => {
+			let body;
+			if (docsProvider === "swagger") {
+				const swaggerConfig = {
+					dom_id: "#app",
+					spec,
+					deepLinking: true,
+					presets: ["SwaggerUIBundle.presets.apis", "SwaggerUIBundle.presets.standalone"],
+					plugins: ["SwaggerUIBundle.plugins.DownloadUrl"],
+					...config
+				};
+				body = `
+        <body>
+          <div id="app"></div>
+
+          <script src="${esc(scriptUrl)}"><\/script>
+
+          <script>
+            window.onload = () => {
+              window.ui = SwaggerUIBundle(${stringifyJSON(swaggerConfig).replace(/"(SwaggerUIBundle\.[^"]+)"/g, "$1")})
+            }
+          <\/script>
+        </body>
+        `;
+			} else body = `
+        <body>
+          <div id="app" data-config="${esc(stringifyJSON({
+				content: stringifyJSON(spec),
+				...config
+			}))}"></div>
+
+          <script src="${esc(scriptUrl)}"><\/script>
+
+          <script>
+            Scalar.createApiReference('#app', JSON.parse(document.getElementById('app').dataset.config))
+          <\/script>
+        </body>
+        `;
+			return `
+        <!doctype html>
+        <html>
+          <head>
+            <meta charset="utf-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1" />
+            <title>${esc(title)}</title>
+            ${cssUrl ? `<link rel="stylesheet" type="text/css" href="${esc(cssUrl)}" />` : ""}
+            ${head}
+          </head>
+          ${body}
+        </html>
+        `;
+		});
+	}
+	init(options, router) {
+		options.interceptors ??= [];
+		options.interceptors.push(async (options2) => {
+			const res = await options2.next();
+			if (res.matched || options2.request.method !== "GET") return res;
+			const prefix = options2.prefix ?? "";
+			const requestPathname = options2.request.url.pathname.replace(/\/$/, "") || "/";
+			const docsUrl = new URL(`${prefix}${this.docsPath}`.replace(/\/$/, ""), options2.request.url.origin);
+			const specUrl = new URL(`${prefix}${this.specPath}`.replace(/\/$/, ""), options2.request.url.origin);
+			const generateSpec = once(async () => {
+				return await this.generator.generate(router, {
+					servers: [{ url: new URL(prefix, options2.request.url.origin).toString() }],
+					...await value(this.specGenerateOptions, options2)
+				});
+			});
+			if (requestPathname === specUrl.pathname) {
+				const spec = await generateSpec();
+				return {
+					matched: true,
+					response: {
+						status: 200,
+						headers: {},
+						body: new File([stringifyJSON(spec)], "spec.json", { type: "application/json" })
+					}
+				};
+			}
+			if (requestPathname === docsUrl.pathname) {
+				const html = this.renderDocsHtml(specUrl.toString(), await value(this.docsTitle, options2), await value(this.docsHead, options2), await value(this.docsScriptUrl, options2), await value(this.docsConfig, options2), await generateSpec(), this.docsProvider, await value(this.docsCssUrl, options2));
+				return {
+					matched: true,
+					response: {
+						status: 200,
+						headers: {},
+						body: new File([html], "api-reference.html", { type: "text/html" })
+					}
+				};
+			}
+			return res;
+		});
+	}
+};
+
+//#endregion
+export { OpenAPIReferencePlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugins-hpi2GlaX.mjs","names":["value","#resolveCommonSchemas","#request","#successResponse","#errorResponse"],"sources":["../../../node_modules/.bun/@orpc+interop@1.10.4/node_modules/@orpc/interop/dist/json-schema-typed/index.mjs","../../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/shared/openapi.DrTcell5.mjs","../../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/plugins/index.mjs"],"sourcesContent":["/// <reference types=\"./draft-2020-12.ts\" />\n// @generated\n// deno-fmt-ignore-file\n// deno-lint-ignore-file\n// This code was bundled using `deno bundle` and it's not recommended to edit it manually\n\nconst draft = \"2020-12\";\nconst $schema = \"https://json-schema.org/draft/2020-12/schema\";\nvar ContentEncoding;\n(function(ContentEncoding1) {\n    ContentEncoding1[\"7bit\"] = \"7bit\";\n    ContentEncoding1[\"8bit\"] = \"8bit\";\n    ContentEncoding1[\"Base64\"] = \"base64\";\n    ContentEncoding1[\"Binary\"] = \"binary\";\n    ContentEncoding1[\"IETFToken\"] = \"ietf-token\";\n    ContentEncoding1[\"QuotedPrintable\"] = \"quoted-printable\";\n    ContentEncoding1[\"XToken\"] = \"x-token\";\n})(ContentEncoding || (ContentEncoding = {}));\nvar Format;\n(function(Format1) {\n    Format1[\"Date\"] = \"date\";\n    Format1[\"DateTime\"] = \"date-time\";\n    Format1[\"Duration\"] = \"duration\";\n    Format1[\"Email\"] = \"email\";\n    Format1[\"Hostname\"] = \"hostname\";\n    Format1[\"IDNEmail\"] = \"idn-email\";\n    Format1[\"IDNHostname\"] = \"idn-hostname\";\n    Format1[\"IPv4\"] = \"ipv4\";\n    Format1[\"IPv6\"] = \"ipv6\";\n    Format1[\"IRI\"] = \"iri\";\n    Format1[\"IRIReference\"] = \"iri-reference\";\n    Format1[\"JSONPointer\"] = \"json-pointer\";\n    Format1[\"JSONPointerURIFragment\"] = \"json-pointer-uri-fragment\";\n    Format1[\"RegEx\"] = \"regex\";\n    Format1[\"RelativeJSONPointer\"] = \"relative-json-pointer\";\n    Format1[\"Time\"] = \"time\";\n    Format1[\"URI\"] = \"uri\";\n    Format1[\"URIReference\"] = \"uri-reference\";\n    Format1[\"URITemplate\"] = \"uri-template\";\n    Format1[\"UUID\"] = \"uuid\";\n})(Format || (Format = {}));\nvar TypeName;\n(function(TypeName1) {\n    TypeName1[\"Array\"] = \"array\";\n    TypeName1[\"Boolean\"] = \"boolean\";\n    TypeName1[\"Integer\"] = \"integer\";\n    TypeName1[\"Null\"] = \"null\";\n    TypeName1[\"Number\"] = \"number\";\n    TypeName1[\"Object\"] = \"object\";\n    TypeName1[\"String\"] = \"string\";\n})(TypeName || (TypeName = {}));\nconst keywords = [\n    \"$anchor\",\n    \"$comment\",\n    \"$defs\",\n    \"$dynamicAnchor\",\n    \"$dynamicRef\",\n    \"$id\",\n    \"$ref\",\n    \"$schema\",\n    \"$vocabulary\",\n    \"additionalItems\",\n    \"additionalProperties\",\n    \"allOf\",\n    \"anyOf\",\n    \"const\",\n    \"contains\",\n    \"contentEncoding\",\n    \"contentMediaType\",\n    \"contentSchema\",\n    \"default\",\n    \"definitions\",\n    \"dependencies\",\n    \"dependentRequired\",\n    \"dependentSchemas\",\n    \"deprecated\",\n    \"description\",\n    \"else\",\n    \"enum\",\n    \"examples\",\n    \"exclusiveMaximum\",\n    \"exclusiveMinimum\",\n    \"format\",\n    \"if\",\n    \"items\",\n    \"maxContains\",\n    \"maximum\",\n    \"maxItems\",\n    \"maxLength\",\n    \"maxProperties\",\n    \"minContains\",\n    \"minimum\",\n    \"minItems\",\n    \"minLength\",\n    \"minProperties\",\n    \"multipleOf\",\n    \"not\",\n    \"oneOf\",\n    \"pattern\",\n    \"patternProperties\",\n    \"prefixItems\",\n    \"properties\",\n    \"propertyNames\",\n    \"readOnly\",\n    \"required\",\n    \"then\",\n    \"title\",\n    \"type\",\n    \"unevaluatedItems\",\n    \"unevaluatedProperties\",\n    \"uniqueItems\",\n    \"writeOnly\", \n];\n\nexport { $schema, ContentEncoding, Format, TypeName, draft, keywords };\n","import { isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';\nimport { toHttpPath } from '@orpc/client/standard';\nimport { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';\nimport { standardizeHTTPPath, StandardOpenAPIJsonSerializer, getDynamicParams } from '@orpc/openapi-client/standard';\nimport { isProcedure, resolveContractProcedures } from '@orpc/server';\nimport { isObject, stringifyJSON, findDeepMatches, toArray, clone, value } from '@orpc/shared';\nimport { TypeName } from '@orpc/interop/json-schema-typed/draft-2020-12';\n\nconst OPERATION_EXTENDER_SYMBOL = Symbol(\"ORPC_OPERATION_EXTENDER\");\nfunction customOpenAPIOperation(o, extend) {\n  return new Proxy(o, {\n    get(target, prop, receiver) {\n      if (prop === OPERATION_EXTENDER_SYMBOL) {\n        return extend;\n      }\n      return Reflect.get(target, prop, receiver);\n    }\n  });\n}\nfunction getCustomOpenAPIOperation(o) {\n  return o[OPERATION_EXTENDER_SYMBOL];\n}\nfunction applyCustomOpenAPIOperation(operation, contract) {\n  const operationCustoms = [];\n  for (const errorItem of Object.values(contract[\"~orpc\"].errorMap)) {\n    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;\n    if (maybeExtender) {\n      operationCustoms.push(maybeExtender);\n    }\n  }\n  if (isProcedure(contract)) {\n    for (const middleware of contract[\"~orpc\"].middlewares) {\n      const maybeExtender = getCustomOpenAPIOperation(middleware);\n      if (maybeExtender) {\n        operationCustoms.push(maybeExtender);\n      }\n    }\n  }\n  let currentOperation = operation;\n  for (const custom of operationCustoms) {\n    if (typeof custom === \"function\") {\n      currentOperation = custom(currentOperation, contract);\n    } else {\n      currentOperation = {\n        ...currentOperation,\n        ...custom\n      };\n    }\n  }\n  return currentOperation;\n}\n\nconst LOGIC_KEYWORDS = [\n  \"$dynamicRef\",\n  \"$ref\",\n  \"additionalItems\",\n  \"additionalProperties\",\n  \"allOf\",\n  \"anyOf\",\n  \"const\",\n  \"contains\",\n  \"contentEncoding\",\n  \"contentMediaType\",\n  \"contentSchema\",\n  \"dependencies\",\n  \"dependentRequired\",\n  \"dependentSchemas\",\n  \"else\",\n  \"enum\",\n  \"exclusiveMaximum\",\n  \"exclusiveMinimum\",\n  \"format\",\n  \"if\",\n  \"items\",\n  \"maxContains\",\n  \"maximum\",\n  \"maxItems\",\n  \"maxLength\",\n  \"maxProperties\",\n  \"minContains\",\n  \"minimum\",\n  \"minItems\",\n  \"minLength\",\n  \"minProperties\",\n  \"multipleOf\",\n  \"not\",\n  \"oneOf\",\n  \"pattern\",\n  \"patternProperties\",\n  \"prefixItems\",\n  \"properties\",\n  \"propertyNames\",\n  \"required\",\n  \"then\",\n  \"type\",\n  \"unevaluatedItems\",\n  \"unevaluatedProperties\",\n  \"uniqueItems\"\n];\n\nfunction isFileSchema(schema) {\n  return isObject(schema) && schema.type === \"string\" && typeof schema.contentMediaType === \"string\";\n}\nfunction isObjectSchema(schema) {\n  return isObject(schema) && schema.type === \"object\";\n}\nfunction isAnySchema(schema) {\n  if (schema === true) {\n    return true;\n  }\n  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {\n    return true;\n  }\n  return false;\n}\nfunction separateObjectSchema(schema, separatedProperties) {\n  if (Object.keys(schema).some(\n    (k) => ![\"type\", \"properties\", \"required\", \"additionalProperties\"].includes(k) && LOGIC_KEYWORDS.includes(k) && schema[k] !== void 0\n  )) {\n    return [{ type: \"object\" }, schema];\n  }\n  const matched = { ...schema };\n  const rest = { ...schema };\n  matched.properties = separatedProperties.reduce((acc, key) => {\n    const keySchema = schema.properties?.[key] ?? schema.additionalProperties;\n    if (keySchema !== void 0) {\n      acc[key] = keySchema;\n    }\n    return acc;\n  }, {});\n  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));\n  matched.examples = schema.examples?.map((example) => {\n    if (!isObject(example)) {\n      return example;\n    }\n    return Object.entries(example).reduce((acc, [key, value]) => {\n      if (separatedProperties.includes(key)) {\n        acc[key] = value;\n      }\n      return acc;\n    }, {});\n  });\n  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value]) => {\n    acc[key] = value;\n    return acc;\n  }, {});\n  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));\n  rest.examples = schema.examples?.map((example) => {\n    if (!isObject(example)) {\n      return example;\n    }\n    return Object.entries(example).reduce((acc, [key, value]) => {\n      if (!separatedProperties.includes(key)) {\n        acc[key] = value;\n      }\n      return acc;\n    }, {});\n  });\n  return [matched, rest];\n}\nfunction filterSchemaBranches(schema, check, matches = []) {\n  if (check(schema)) {\n    matches.push(schema);\n    return [matches, void 0];\n  }\n  if (isObject(schema)) {\n    for (const keyword of [\"anyOf\", \"oneOf\"]) {\n      if (schema[keyword] && Object.keys(schema).every(\n        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)\n      )) {\n        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);\n        if (rest.length === 1 && typeof rest[0] === \"object\") {\n          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];\n        }\n        return [matches, { ...schema, [keyword]: rest }];\n      }\n    }\n  }\n  return [matches, schema];\n}\nfunction applySchemaOptionality(required, schema) {\n  if (required) {\n    return schema;\n  }\n  return {\n    anyOf: [\n      schema,\n      { not: {} }\n    ]\n  };\n}\nfunction expandUnionSchema(schema) {\n  if (typeof schema === \"object\") {\n    for (const keyword of [\"anyOf\", \"oneOf\"]) {\n      if (schema[keyword] && Object.keys(schema).every(\n        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)\n      )) {\n        return schema[keyword].flatMap((s) => expandUnionSchema(s));\n      }\n    }\n  }\n  return [schema];\n}\nfunction expandArrayableSchema(schema) {\n  const schemas = expandUnionSchema(schema);\n  if (schemas.length !== 2) {\n    return void 0;\n  }\n  const arraySchema = schemas.find(\n    (s) => typeof s === \"object\" && s.type === \"array\" && Object.keys(s).filter((k) => LOGIC_KEYWORDS.includes(k)).every((k) => k === \"type\" || k === \"items\")\n  );\n  if (arraySchema === void 0) {\n    return void 0;\n  }\n  const items1 = arraySchema.items;\n  const items2 = schemas.find((s) => s !== arraySchema);\n  if (stringifyJSON(items1) !== stringifyJSON(items2)) {\n    return void 0;\n  }\n  return [items2, arraySchema];\n}\nconst PRIMITIVE_SCHEMA_TYPES = /* @__PURE__ */ new Set([\n  TypeName.String,\n  TypeName.Number,\n  TypeName.Integer,\n  TypeName.Boolean,\n  TypeName.Null\n]);\nfunction isPrimitiveSchema(schema) {\n  return expandUnionSchema(schema).every((s) => {\n    if (typeof s === \"boolean\") {\n      return false;\n    }\n    if (typeof s.type === \"string\" && PRIMITIVE_SCHEMA_TYPES.has(s.type)) {\n      return true;\n    }\n    if (s.const !== void 0) {\n      return true;\n    }\n    return false;\n  });\n}\n\nfunction toOpenAPIPath(path) {\n  return standardizeHTTPPath(path).replace(/\\/\\{\\+([^}]+)\\}/g, \"/{$1}\");\n}\nfunction toOpenAPIMethod(method) {\n  return method.toLocaleLowerCase();\n}\nfunction toOpenAPIContent(schema) {\n  const content = {};\n  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);\n  for (const file of matches) {\n    content[file.contentMediaType] = {\n      schema: toOpenAPISchema(file)\n    };\n  }\n  if (restSchema !== void 0) {\n    content[\"application/json\"] = {\n      schema: toOpenAPISchema(restSchema)\n    };\n    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;\n    if (isStillHasFileSchema) {\n      content[\"multipart/form-data\"] = {\n        schema: toOpenAPISchema(restSchema)\n      };\n    }\n  }\n  return content;\n}\nfunction toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {\n  return {\n    \"text/event-stream\": {\n      schema: toOpenAPISchema({\n        oneOf: [\n          {\n            type: \"object\",\n            properties: {\n              event: { const: \"message\" },\n              data: yieldsSchema,\n              id: { type: \"string\" },\n              retry: { type: \"number\" }\n            },\n            required: yieldsRequired ? [\"event\", \"data\"] : [\"event\"]\n          },\n          {\n            type: \"object\",\n            properties: {\n              event: { const: \"done\" },\n              data: returnsSchema,\n              id: { type: \"string\" },\n              retry: { type: \"number\" }\n            },\n            required: returnsRequired ? [\"event\", \"data\"] : [\"event\"]\n          },\n          {\n            type: \"object\",\n            properties: {\n              event: { const: \"error\" },\n              data: {},\n              id: { type: \"string\" },\n              retry: { type: \"number\" }\n            },\n            required: [\"event\"]\n          }\n        ]\n      })\n    }\n  };\n}\nfunction toOpenAPIParameters(schema, parameterIn) {\n  const parameters = [];\n  for (const key in schema.properties) {\n    const keySchema = schema.properties[key];\n    let isDeepObjectStyle = true;\n    if (parameterIn !== \"query\") {\n      isDeepObjectStyle = false;\n    } else if (isPrimitiveSchema(keySchema)) {\n      isDeepObjectStyle = false;\n    } else {\n      const [item] = expandArrayableSchema(keySchema) ?? [];\n      if (item !== void 0 && isPrimitiveSchema(item)) {\n        isDeepObjectStyle = false;\n      }\n    }\n    parameters.push({\n      name: key,\n      in: parameterIn,\n      required: schema.required?.includes(key),\n      schema: toOpenAPISchema(keySchema),\n      style: isDeepObjectStyle ? \"deepObject\" : void 0,\n      explode: isDeepObjectStyle ? true : void 0,\n      allowEmptyValue: parameterIn === \"query\" ? true : void 0,\n      allowReserved: parameterIn === \"query\" ? true : void 0\n    });\n  }\n  return parameters;\n}\nfunction checkParamsSchema(schema, params) {\n  const properties = Object.keys(schema.properties ?? {});\n  const required = schema.required ?? [];\n  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {\n    return false;\n  }\n  if (required.length !== params.length || required.some((v) => !params.includes(v))) {\n    return false;\n  }\n  return true;\n}\nfunction toOpenAPISchema(schema) {\n  return schema === true ? {} : schema === false ? { not: {} } : schema;\n}\nconst OPENAPI_JSON_SCHEMA_REF_PREFIX = \"#/components/schemas/\";\nfunction resolveOpenAPIJsonSchemaRef(doc, schema) {\n  if (typeof schema !== \"object\" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) {\n    return schema;\n  }\n  const name = schema.$ref.slice(OPENAPI_JSON_SCHEMA_REF_PREFIX.length);\n  const resolved = doc.components?.schemas?.[name];\n  return resolved ?? schema;\n}\n\nclass CompositeSchemaConverter {\n  converters;\n  constructor(converters) {\n    this.converters = converters;\n  }\n  async convert(schema, options) {\n    for (const converter of this.converters) {\n      if (await converter.condition(schema, options)) {\n        return converter.convert(schema, options);\n      }\n    }\n    return [false, {}];\n  }\n}\n\nclass OpenAPIGeneratorError extends Error {\n}\nclass OpenAPIGenerator {\n  serializer;\n  converter;\n  constructor(options = {}) {\n    this.serializer = new StandardOpenAPIJsonSerializer(options);\n    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));\n  }\n  /**\n   * Generates OpenAPI specifications from oRPC routers/contracts.\n   *\n   * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}\n   */\n  async generate(router, { customErrorResponseBodySchema, commonSchemas, filter: baseFilter, exclude, ...baseDoc } = {}) {\n    const filter = baseFilter ?? (({ contract, path }) => {\n      return !(exclude?.(contract, path) ?? false);\n    });\n    const doc = {\n      ...clone(baseDoc),\n      info: baseDoc.info ?? { title: \"API Reference\", version: \"0.0.0\" },\n      openapi: \"3.1.1\"\n    };\n    const { baseSchemaConvertOptions, undefinedErrorJsonSchema } = await this.#resolveCommonSchemas(doc, commonSchemas);\n    const contracts = [];\n    await resolveContractProcedures({ path: [], router }, (traverseOptions) => {\n      if (!value(filter, traverseOptions)) {\n        return;\n      }\n      contracts.push(traverseOptions);\n    });\n    const errors = [];\n    for (const { contract, path } of contracts) {\n      const stringPath = path.join(\".\");\n      try {\n        const def = contract[\"~orpc\"];\n        const method = toOpenAPIMethod(fallbackContractConfig(\"defaultMethod\", def.route.method));\n        const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));\n        let operationObjectRef;\n        if (def.route.spec !== void 0 && typeof def.route.spec !== \"function\") {\n          operationObjectRef = def.route.spec;\n        } else {\n          operationObjectRef = {\n            operationId: def.route.operationId ?? stringPath,\n            summary: def.route.summary,\n            description: def.route.description,\n            deprecated: def.route.deprecated,\n            tags: def.route.tags?.map((tag) => tag)\n          };\n          await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);\n          await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);\n          await this.#errorResponse(operationObjectRef, def, baseSchemaConvertOptions, undefinedErrorJsonSchema, customErrorResponseBodySchema);\n        }\n        if (typeof def.route.spec === \"function\") {\n          operationObjectRef = def.route.spec(operationObjectRef);\n        }\n        doc.paths ??= {};\n        doc.paths[httpPath] ??= {};\n        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);\n      } catch (e) {\n        if (!(e instanceof OpenAPIGeneratorError)) {\n          throw e;\n        }\n        errors.push(\n          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${stringPath}\n${e.message}`\n        );\n      }\n    }\n    if (errors.length) {\n      throw new OpenAPIGeneratorError(\n        `Some error occurred during OpenAPI generation:\n\n${errors.join(\"\\n\\n\")}`\n      );\n    }\n    return this.serializer.serialize(doc)[0];\n  }\n  async #resolveCommonSchemas(doc, commonSchemas) {\n    let undefinedErrorJsonSchema = {\n      type: \"object\",\n      properties: {\n        defined: { const: false },\n        code: { type: \"string\" },\n        status: { type: \"number\" },\n        message: { type: \"string\" },\n        data: {}\n      },\n      required: [\"defined\", \"code\", \"status\", \"message\"]\n    };\n    const baseSchemaConvertOptions = {};\n    if (commonSchemas) {\n      baseSchemaConvertOptions.components = [];\n      for (const key in commonSchemas) {\n        const options = commonSchemas[key];\n        if (options.schema === void 0) {\n          continue;\n        }\n        const { schema, strategy = \"input\" } = options;\n        const [required, json] = await this.converter.convert(schema, { strategy });\n        const allowedStrategies = [strategy];\n        if (strategy === \"input\") {\n          const [outputRequired, outputJson] = await this.converter.convert(schema, { strategy: \"output\" });\n          if (outputRequired === required && stringifyJSON(outputJson) === stringifyJSON(json)) {\n            allowedStrategies.push(\"output\");\n          }\n        } else if (strategy === \"output\") {\n          const [inputRequired, inputJson] = await this.converter.convert(schema, { strategy: \"input\" });\n          if (inputRequired === required && stringifyJSON(inputJson) === stringifyJSON(json)) {\n            allowedStrategies.push(\"input\");\n          }\n        }\n        baseSchemaConvertOptions.components.push({\n          schema,\n          required,\n          ref: `#/components/schemas/${key}`,\n          allowedStrategies\n        });\n      }\n      doc.components ??= {};\n      doc.components.schemas ??= {};\n      for (const key in commonSchemas) {\n        const options = commonSchemas[key];\n        if (options.schema === void 0) {\n          if (options.error === \"UndefinedError\") {\n            doc.components.schemas[key] = toOpenAPISchema(undefinedErrorJsonSchema);\n            undefinedErrorJsonSchema = { $ref: `#/components/schemas/${key}` };\n          }\n          continue;\n        }\n        const { schema, strategy = \"input\" } = options;\n        const [, json] = await this.converter.convert(\n          schema,\n          {\n            ...baseSchemaConvertOptions,\n            strategy,\n            minStructureDepthForRef: 1\n            // not allow use $ref for root schemas\n          }\n        );\n        doc.components.schemas[key] = toOpenAPISchema(json);\n      }\n    }\n    return { baseSchemaConvertOptions, undefinedErrorJsonSchema };\n  }\n  async #request(doc, ref, def, baseSchemaConvertOptions) {\n    const method = fallbackContractConfig(\"defaultMethod\", def.route.method);\n    const details = getEventIteratorSchemaDetails(def.inputSchema);\n    if (details) {\n      ref.requestBody = {\n        required: true,\n        content: toOpenAPIEventIteratorContent(\n          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: \"input\" }),\n          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: \"input\" })\n        )\n      };\n      return;\n    }\n    const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);\n    const inputStructure = fallbackContractConfig(\"defaultInputStructure\", def.route.inputStructure);\n    let [required, schema] = await this.converter.convert(\n      def.inputSchema,\n      {\n        ...baseSchemaConvertOptions,\n        strategy: \"input\",\n        minStructureDepthForRef: dynamicParams?.length || inputStructure === \"detailed\" ? 1 : 0\n      }\n    );\n    if (isAnySchema(schema) && !dynamicParams?.length) {\n      return;\n    }\n    if (inputStructure === \"compact\") {\n      if (dynamicParams?.length) {\n        const error2 = new OpenAPIGeneratorError(\n          'When input structure is \"compact\", and path has dynamic params, input schema must be an object with all dynamic params as required.'\n        );\n        if (!isObjectSchema(schema)) {\n          throw error2;\n        }\n        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);\n        schema = rest;\n        required = rest.required ? rest.required.length !== 0 : false;\n        if (!checkParamsSchema(paramsSchema, dynamicParams)) {\n          throw error2;\n        }\n        ref.parameters ??= [];\n        ref.parameters.push(...toOpenAPIParameters(paramsSchema, \"path\"));\n      }\n      if (method === \"GET\") {\n        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);\n        if (!isObjectSchema(resolvedSchema)) {\n          throw new OpenAPIGeneratorError(\n            'When method is \"GET\", input schema must satisfy: object | any | unknown'\n          );\n        }\n        ref.parameters ??= [];\n        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, \"query\"));\n      } else {\n        ref.requestBody = {\n          required,\n          content: toOpenAPIContent(schema)\n        };\n      }\n      return;\n    }\n    const error = new OpenAPIGeneratorError(\n      'When input structure is \"detailed\", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'\n    );\n    if (!isObjectSchema(schema)) {\n      throw error;\n    }\n    const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;\n    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {\n      throw new OpenAPIGeneratorError(\n        'When input structure is \"detailed\" and path has dynamic params, the \"params\" schema must be an object with all dynamic params as required.'\n      );\n    }\n    for (const from of [\"params\", \"query\", \"headers\"]) {\n      const fromSchema = schema.properties?.[from];\n      if (fromSchema !== void 0) {\n        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);\n        if (!isObjectSchema(resolvedSchema)) {\n          throw error;\n        }\n        const parameterIn = from === \"params\" ? \"path\" : from === \"headers\" ? \"header\" : \"query\";\n        ref.parameters ??= [];\n        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));\n      }\n    }\n    if (schema.properties?.body !== void 0) {\n      ref.requestBody = {\n        required: schema.required?.includes(\"body\"),\n        content: toOpenAPIContent(schema.properties.body)\n      };\n    }\n  }\n  async #successResponse(doc, ref, def, baseSchemaConvertOptions) {\n    const outputSchema = def.outputSchema;\n    const status = fallbackContractConfig(\"defaultSuccessStatus\", def.route.successStatus);\n    const description = fallbackContractConfig(\"defaultSuccessDescription\", def.route?.successDescription);\n    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);\n    const outputStructure = fallbackContractConfig(\"defaultOutputStructure\", def.route.outputStructure);\n    if (eventIteratorSchemaDetails) {\n      ref.responses ??= {};\n      ref.responses[status] = {\n        description,\n        content: toOpenAPIEventIteratorContent(\n          await this.converter.convert(eventIteratorSchemaDetails.yields, { ...baseSchemaConvertOptions, strategy: \"output\" }),\n          await this.converter.convert(eventIteratorSchemaDetails.returns, { ...baseSchemaConvertOptions, strategy: \"output\" })\n        )\n      };\n      return;\n    }\n    const [required, json] = await this.converter.convert(\n      outputSchema,\n      {\n        ...baseSchemaConvertOptions,\n        strategy: \"output\",\n        minStructureDepthForRef: outputStructure === \"detailed\" ? 1 : 0\n      }\n    );\n    if (outputStructure === \"compact\") {\n      ref.responses ??= {};\n      ref.responses[status] = {\n        description\n      };\n      ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required, json));\n      return;\n    }\n    const handledStatuses = /* @__PURE__ */ new Set();\n    for (const item of expandUnionSchema(json)) {\n      const error = new OpenAPIGeneratorError(`\n        When output structure is \"detailed\", output schema must satisfy:\n        { \n          status?: number, // must be a literal number and in the range of 200-399\n          headers?: Record<string, unknown>, \n          body?: unknown \n        }\n        \n        But got: ${stringifyJSON(item)}\n      `);\n      if (!isObjectSchema(item)) {\n        throw error;\n      }\n      let schemaStatus;\n      let schemaDescription;\n      if (item.properties?.status !== void 0) {\n        const statusSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.status);\n        if (typeof statusSchema !== \"object\" || statusSchema.const === void 0 || typeof statusSchema.const !== \"number\" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) {\n          throw error;\n        }\n        schemaStatus = statusSchema.const;\n        schemaDescription = statusSchema.description;\n      }\n      const itemStatus = schemaStatus ?? status;\n      const itemDescription = schemaDescription ?? description;\n      if (handledStatuses.has(itemStatus)) {\n        throw new OpenAPIGeneratorError(`\n          When output structure is \"detailed\", each success status must be unique.\n          But got status: ${itemStatus} used more than once.\n        `);\n      }\n      handledStatuses.add(itemStatus);\n      ref.responses ??= {};\n      ref.responses[itemStatus] = {\n        description: itemDescription\n      };\n      if (item.properties?.headers !== void 0) {\n        const headersSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.headers);\n        if (!isObjectSchema(headersSchema)) {\n          throw error;\n        }\n        for (const key in headersSchema.properties) {\n          const headerSchema = headersSchema.properties[key];\n          if (headerSchema !== void 0) {\n            ref.responses[itemStatus].headers ??= {};\n            ref.responses[itemStatus].headers[key] = {\n              schema: toOpenAPISchema(headerSchema),\n              required: item.required?.includes(\"headers\") && headersSchema.required?.includes(key)\n            };\n          }\n        }\n      }\n      if (item.properties?.body !== void 0) {\n        ref.responses[itemStatus].content = toOpenAPIContent(\n          applySchemaOptionality(item.required?.includes(\"body\") ?? false, item.properties.body)\n        );\n      }\n    }\n  }\n  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema, customErrorResponseBodySchema) {\n    const errorMap = def.errorMap;\n    const errorResponsesByStatus = {};\n    for (const code in errorMap) {\n      const config = errorMap[code];\n      if (!config) {\n        continue;\n      }\n      const status = fallbackORPCErrorStatus(code, config.status);\n      const defaultMessage = fallbackORPCErrorMessage(code, config.message);\n      errorResponsesByStatus[status] ??= { status, definedErrorDefinitions: [], errorSchemaVariants: [] };\n      const [dataRequired, dataSchema] = await this.converter.convert(config.data, { ...baseSchemaConvertOptions, strategy: \"output\" });\n      errorResponsesByStatus[status].definedErrorDefinitions.push([code, defaultMessage, dataRequired, dataSchema]);\n      errorResponsesByStatus[status].errorSchemaVariants.push({\n        type: \"object\",\n        properties: {\n          defined: { const: true },\n          code: { const: code },\n          status: { const: status },\n          message: { type: \"string\", default: defaultMessage },\n          data: dataSchema\n        },\n        required: dataRequired ? [\"defined\", \"code\", \"status\", \"message\", \"data\"] : [\"defined\", \"code\", \"status\", \"message\"]\n      });\n    }\n    ref.responses ??= {};\n    for (const statusString in errorResponsesByStatus) {\n      const errorResponse = errorResponsesByStatus[statusString];\n      const customBodySchema = value(customErrorResponseBodySchema, errorResponse.definedErrorDefinitions, errorResponse.status);\n      ref.responses[statusString] = {\n        description: statusString,\n        content: toOpenAPIContent(customBodySchema ?? {\n          oneOf: [\n            ...errorResponse.errorSchemaVariants,\n            undefinedErrorSchema\n          ]\n        })\n      };\n    }\n  }\n}\n\nexport { CompositeSchemaConverter as C, LOGIC_KEYWORDS as L, OpenAPIGenerator as O, applyCustomOpenAPIOperation as a, toOpenAPIMethod as b, customOpenAPIOperation as c, toOpenAPIContent as d, toOpenAPIEventIteratorContent as e, toOpenAPIParameters as f, getCustomOpenAPIOperation as g, checkParamsSchema as h, toOpenAPISchema as i, isFileSchema as j, isObjectSchema as k, isAnySchema as l, filterSchemaBranches as m, applySchemaOptionality as n, expandUnionSchema as o, expandArrayableSchema as p, isPrimitiveSchema as q, resolveOpenAPIJsonSchemaRef as r, separateObjectSchema as s, toOpenAPIPath as t };\n","import { stringifyJSON, once, value } from '@orpc/shared';\nimport { O as OpenAPIGenerator } from '../shared/openapi.DrTcell5.mjs';\nimport '@orpc/client';\nimport '@orpc/client/standard';\nimport '@orpc/contract';\nimport '@orpc/openapi-client/standard';\nimport '@orpc/server';\nimport '@orpc/interop/json-schema-typed/draft-2020-12';\n\nclass OpenAPIReferencePlugin {\n  generator;\n  specGenerateOptions;\n  specPath;\n  docsPath;\n  docsTitle;\n  docsHead;\n  docsProvider;\n  docsScriptUrl;\n  docsCssUrl;\n  docsConfig;\n  renderDocsHtml;\n  constructor(options = {}) {\n    this.specGenerateOptions = options.specGenerateOptions;\n    this.docsPath = options.docsPath ?? \"/\";\n    this.docsTitle = options.docsTitle ?? \"API Reference\";\n    this.docsConfig = options.docsConfig ?? void 0;\n    this.docsProvider = options.docsProvider ?? \"scalar\";\n    this.docsScriptUrl = options.docsScriptUrl ?? (this.docsProvider === \"swagger\" ? \"https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js\" : \"https://cdn.jsdelivr.net/npm/@scalar/api-reference\");\n    this.docsCssUrl = options.docsCssUrl ?? (this.docsProvider === \"swagger\" ? \"https://unpkg.com/swagger-ui-dist/swagger-ui.css\" : void 0);\n    this.docsHead = options.docsHead ?? \"\";\n    this.specPath = options.specPath ?? \"/spec.json\";\n    this.generator = new OpenAPIGenerator(options);\n    const esc = (s) => s.replace(/&/g, \"&amp;\").replace(/\"/g, \"&quot;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\");\n    this.renderDocsHtml = options.renderDocsHtml ?? ((specUrl, title, head, scriptUrl, config, spec, docsProvider, cssUrl) => {\n      let body;\n      if (docsProvider === \"swagger\") {\n        const swaggerConfig = {\n          dom_id: \"#app\",\n          spec,\n          deepLinking: true,\n          presets: [\n            \"SwaggerUIBundle.presets.apis\",\n            \"SwaggerUIBundle.presets.standalone\"\n          ],\n          plugins: [\n            \"SwaggerUIBundle.plugins.DownloadUrl\"\n          ],\n          ...config\n        };\n        body = `\n        <body>\n          <div id=\"app\"></div>\n\n          <script src=\"${esc(scriptUrl)}\"><\\/script>\n\n          <script>\n            window.onload = () => {\n              window.ui = SwaggerUIBundle(${stringifyJSON(swaggerConfig).replace(/\"(SwaggerUIBundle\\.[^\"]+)\"/g, \"$1\")})\n            }\n          <\\/script>\n        </body>\n        `;\n      } else {\n        const scalarConfig = {\n          content: stringifyJSON(spec),\n          ...config\n        };\n        body = `\n        <body>\n          <div id=\"app\" data-config=\"${esc(stringifyJSON(scalarConfig))}\"></div>\n\n          <script src=\"${esc(scriptUrl)}\"><\\/script>\n\n          <script>\n            Scalar.createApiReference('#app', JSON.parse(document.getElementById('app').dataset.config))\n          <\\/script>\n        </body>\n        `;\n      }\n      return `\n        <!doctype html>\n        <html>\n          <head>\n            <meta charset=\"utf-8\" />\n            <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n            <title>${esc(title)}</title>\n            ${cssUrl ? `<link rel=\"stylesheet\" type=\"text/css\" href=\"${esc(cssUrl)}\" />` : \"\"}\n            ${head}\n          </head>\n          ${body}\n        </html>\n        `;\n    });\n  }\n  init(options, router) {\n    options.interceptors ??= [];\n    options.interceptors.push(async (options2) => {\n      const res = await options2.next();\n      if (res.matched || options2.request.method !== \"GET\") {\n        return res;\n      }\n      const prefix = options2.prefix ?? \"\";\n      const requestPathname = options2.request.url.pathname.replace(/\\/$/, \"\") || \"/\";\n      const docsUrl = new URL(`${prefix}${this.docsPath}`.replace(/\\/$/, \"\"), options2.request.url.origin);\n      const specUrl = new URL(`${prefix}${this.specPath}`.replace(/\\/$/, \"\"), options2.request.url.origin);\n      const generateSpec = once(async () => {\n        return await this.generator.generate(router, {\n          servers: [{ url: new URL(prefix, options2.request.url.origin).toString() }],\n          ...await value(this.specGenerateOptions, options2)\n        });\n      });\n      if (requestPathname === specUrl.pathname) {\n        const spec = await generateSpec();\n        return {\n          matched: true,\n          response: {\n            status: 200,\n            headers: {},\n            body: new File([stringifyJSON(spec)], \"spec.json\", { type: \"application/json\" })\n          }\n        };\n      }\n      if (requestPathname === docsUrl.pathname) {\n        const html = this.renderDocsHtml(\n          specUrl.toString(),\n          await value(this.docsTitle, options2),\n          await value(this.docsHead, options2),\n          await value(this.docsScriptUrl, options2),\n          await value(this.docsConfig, options2),\n          await generateSpec(),\n          this.docsProvider,\n          await value(this.docsCssUrl, options2)\n        );\n        return {\n          matched: true,\n          response: {\n            status: 200,\n            headers: {},\n            body: new File([html], \"api-reference.html\", { type: \"text/html\" })\n          }\n        };\n      }\n      return res;\n    });\n  }\n}\n\nexport { OpenAPIReferencePlugin };\n"],"x_google_ignoreList":[0,1,2],"mappings":"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"}