@trpc/openapi 11.15.1-alpha → 11.15.2-alpha

package/dist/index.d.mts

@@ -1,32 +1,100 @@
-//#region src/generate.d.ts
-/**
- * A minimal JSON Schema subset used for OpenAPI 3.1 schemas.
- */
-interface JsonSchema {
+import { __export } from "./chunk-CJ2cON1m.mjs";
+import { OpenAPIV3_1 } from "openapi-types";
+
+//#region src/types.d.ts
+declare namespace types_d_exports {
+  export { ArraySchemaObject, CallbackObject, ComponentsObject, DiscriminatorObject, Document, ExampleObject, ExternalDocumentationObject, HeaderObject, HttpMethods, LinkObject, MediaTypeObject, OperationObject, ParameterBaseObject, ParameterObject, PathItemObject, PathsObject, PrimitiveSchemaType, ReferenceObject, Replace, RequestBodyObject, ResponseObject, ResponsesObject, SchemaLike, SchemaObject, SchemaType, SecuritySchemeObject, XMLObject };
+}
+type Replace<TTarget, TReplaceWith> = Omit<TTarget, keyof TReplaceWith> & TReplaceWith;
+type SchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+type PrimitiveSchemaType = SchemaType;
+type HttpMethods = OpenAPIV3_1.HttpMethods;
+type ReferenceObject = OpenAPIV3_1.ReferenceObject;
+type ExampleObject = OpenAPIV3_1.ExampleObject;
+type DiscriminatorObject = OpenAPIV3_1.DiscriminatorObject;
+type ExternalDocumentationObject = OpenAPIV3_1.ExternalDocumentationObject;
+type XMLObject = OpenAPIV3_1.XMLObject;
+type LinkObject = OpenAPIV3_1.LinkObject;
+type SecuritySchemeObject = OpenAPIV3_1.SecuritySchemeObject;
+type SchemaObject = Replace<OpenAPIV3_1.BaseSchemaObject, {
   $ref?: string;
-  $defs?: Record<string, JsonSchema>;
+  $defs?: Record<string, SchemaObject>;
+  $schema?: string;
   type?: string | string[];
-  properties?: Record<string, JsonSchema>;
+  properties?: Record<string, SchemaObject>;
   required?: string[];
-  items?: JsonSchema | false;
-  prefixItems?: JsonSchema[];
+  items?: SchemaObject | false;
+  prefixItems?: SchemaObject[];
   const?: string | number | boolean | null;
   enum?: (string | number | boolean | null)[];
-  oneOf?: JsonSchema[];
-  anyOf?: JsonSchema[];
-  allOf?: JsonSchema[];
-  not?: JsonSchema;
-  additionalProperties?: JsonSchema | boolean;
-  discriminator?: {
-    propertyName: string;
-    mapping?: Record<string, string>;
-  };
-  format?: string;
-  description?: string;
-  minItems?: number;
-  maxItems?: number;
-  $schema?: string;
+  oneOf?: SchemaObject[];
+  anyOf?: SchemaObject[];
+  allOf?: SchemaObject[];
+  not?: SchemaObject;
+  additionalProperties?: boolean | SchemaObject;
+  discriminator?: DiscriminatorObject;
+  externalDocs?: ExternalDocumentationObject;
+  xml?: XMLObject;
+  contentMediaType?: string;
+  exclusiveMinimum?: boolean | number;
+  exclusiveMaximum?: boolean | number;
+}>;
+type SchemaLike = SchemaObject;
+interface ArraySchemaObject extends SchemaObject {
+  type: 'array';
+  items: SchemaObject | false;
+}
+type MediaTypeObject = Replace<OpenAPIV3_1.MediaTypeObject, {
+  schema?: SchemaObject | ReferenceObject;
+  examples?: Record<string, ReferenceObject | ExampleObject>;
+}>;
+interface ParameterBaseObject extends Replace<OpenAPIV3_1.ParameterBaseObject, {
+  schema?: SchemaObject | ReferenceObject;
+  examples?: Record<string, ReferenceObject | ExampleObject>;
+  content?: Record<string, MediaTypeObject>;
+}> {}
+interface ParameterObject extends ParameterBaseObject {
+  name: string;
+  in: string;
 }
+type HeaderObject = ParameterBaseObject;
+type RequestBodyObject = Replace<OpenAPIV3_1.RequestBodyObject, {
+  content: Record<string, MediaTypeObject>;
+}>;
+type ResponseObject = Replace<OpenAPIV3_1.ResponseObject, {
+  headers?: Record<string, ReferenceObject | HeaderObject>;
+  content?: Record<string, MediaTypeObject>;
+  links?: Record<string, ReferenceObject | LinkObject>;
+}>;
+type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
+type OperationObject<T extends {} = {}> = Replace<OpenAPIV3_1.OperationObject<T>, {
+  parameters?: (ReferenceObject | ParameterObject)[];
+  requestBody?: ReferenceObject | RequestBodyObject;
+  responses?: ResponsesObject;
+  callbacks?: Record<string, ReferenceObject | CallbackObject>;
+}> & T;
+type PathItemObject<T extends {} = {}> = Replace<OpenAPIV3_1.PathItemObject<T>, {
+  parameters?: (ReferenceObject | ParameterObject)[];
+}> & { [method in HttpMethods]?: OperationObject<T> };
+type PathsObject<T extends {} = {}, TPath extends {} = {}> = Record<string, (PathItemObject<T> & TPath) | undefined>;
+type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+type ComponentsObject = Replace<OpenAPIV3_1.ComponentsObject, {
+  schemas?: Record<string, SchemaObject>;
+  responses?: Record<string, ReferenceObject | ResponseObject>;
+  parameters?: Record<string, ReferenceObject | ParameterObject>;
+  requestBodies?: Record<string, ReferenceObject | RequestBodyObject>;
+  headers?: Record<string, ReferenceObject | HeaderObject>;
+  links?: Record<string, ReferenceObject | LinkObject>;
+  callbacks?: Record<string, ReferenceObject | CallbackObject>;
+  pathItems?: Record<string, ReferenceObject | PathItemObject>;
+}>;
+type Document<T extends {} = {}> = Replace<OpenAPIV3_1.Document<T>, {
+  paths?: PathsObject<T>;
+  components?: ComponentsObject;
+}>;
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/generate.d.ts
 interface GenerateOptions {
   /**
    * The name of the exported router symbol.
@@ -38,16 +106,6 @@ interface GenerateOptions {
   /** Version string for the generated OpenAPI `info` object. */
   version?: string;
 }
-interface OpenAPIDocument {
-  openapi: string;
-  jsonSchemaDialect?: string;
-  info: {
-    title: string;
-    version: string;
-  };
-  paths: Record<string, Record<string, unknown>>;
-  components: Record<string, unknown>;
-}
 /**
  * Analyse the given TypeScript router file using the TypeScript compiler and
  * return an OpenAPI 3.1 document describing all query and mutation procedures.
@@ -56,8 +114,9 @@ interface OpenAPIDocument {
  *   the AppRouter.
  * @param options - Optional generation settings (export name, title, version).
  */
-declare function generateOpenAPIDocument(routerFilePath: string, options?: GenerateOptions): Promise<OpenAPIDocument>;
+declare function generateOpenAPIDocument(routerFilePath: string, options?: GenerateOptions): Promise<Document>;
 //# sourceMappingURL=generate.d.ts.map
+
 //#endregion
-export { GenerateOptions, JsonSchema, OpenAPIDocument, generateOpenAPIDocument };
+export { GenerateOptions, types_d_exports as OpenAPIV3_1, generateOpenAPIDocument };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/generate.ts"],"sourcesContent":[],"mappings":";;AAcA;;AAEyB,UAFR,UAAA,CAEQ;EAAU,IAAzB,CAAA,EAAA,MAAA;EAAM,KAEc,CAAA,EAFpB,MAEoB,CAAA,MAAA,EAFL,UAEK,CAAA;EAAU,IAAzB,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAAM,UAEX,CAAA,EAFK,MAEL,CAAA,MAAA,EAFoB,UAEpB,CAAA;EAAU,QACJ,CAAA,EAAA,MAAA,EAAA;EAAU,KAGhB,CAAA,EAJA,UAIA,GAAA,KAAA;EAAU,WACV,CAAA,EAJM,UAIN,EAAA;EAAU,KACV,CAAA,EAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA;EAAU,IACZ,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,CAAA,EAAA;EAAU,KACO,CAAA,EAJf,UAIe,EAAA;EAAU,KACiB,CAAA,EAJ1C,UAI0C,EAAA;EAAM,KAAA,CAAA,EAHhD,UAGgD,EAAA;EAsBzC,GAAA,CAAA,EAxBT,UAwBS;EAYA,oBAAe,CAAA,EAnCP,UAmCO,GAAA,OAAA;EAAA,aAAA,CAAA,EAAA;IAIR,YAAA,EAAA,MAAA;IAAf,OAAA,CAAA,EAtC2C,MAsC3C,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,CAAA;EACK,MAAA,CAAA,EAAA,MAAA;EAqmCE,WAAA,CAAA,EAAA,MAAA;EAAuB,QAAA,CAAA,EAAA,MAAA;EAAA,QAElC,CAAA,EAAA,MAAA;EAAoB,OACpB,CAAA,EAAA,MAAA;;AAAD,UAznCO,eAAA,CAynCP;;;;;;;;;;;UA7mCO,eAAA;;;;;;;SAIR,eAAe;cACV;;;;;;;;;;iBAqmCQ,uBAAA,mCAEX,kBACR,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/generate.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,6 @@
-import { __toESM, require_objectSpread2 } from "./objectSpread2-UxrN8MPM.mjs";
+import { __toESM } from "./chunk-CJ2cON1m.mjs";
+import { require_objectSpread2 } from "./objectSpread2-Blgb1OZh.mjs";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import * as ts from "typescript";
 import { pathToFileURL } from "node:url";
@@ -42,8 +44,7 @@ const wrapperDefTypes = new Set([
 	"readonly",
 	"pipe",
 	"transform",
-	"promise",
-	"lazy"
+	"promise"
 ]);
 /**
 * Extract the wrapped inner schema from a wrapper def.
@@ -85,13 +86,22 @@ function extractZodDescriptions(schema) {
 	}
 	walkZodShape(schema, "", {
 		registry,
-		map
+		map,
+		seenLazy: /* @__PURE__ */ new Set()
 	});
 	if (map.properties.size > 0) hasAny = true;
 	return hasAny ? map : null;
 }
 function walkZodShape(schema, prefix, ctx) {
 	const unwrapped = unwrapZodSchema(schema);
+	const def = unwrapped._zod.def;
+	if (def.type === "lazy" && "getter" in def) {
+		if (ctx.seenLazy.has(unwrapped)) return;
+		ctx.seenLazy.add(unwrapped);
+		const inner = def.getter();
+		if (isZodSchema(inner)) walkZodShape(inner, prefix, ctx);
+		return;
+	}
 	const element = zodArrayElement(unwrapped);
 	if (element) {
 		var _elemMeta$description;
@@ -192,35 +202,80 @@ function isProcedure(value) {
 * Overlay description strings from a `DescriptionMap` onto an existing
 * JSON schema produced by the TypeScript type checker.  Mutates in place.
 */
-function applyDescriptions(schema, descs) {
+function applyDescriptions(schema, descs, schemas) {
 	if (descs.self) schema.description = descs.self;
-	for (const [propPath, description] of descs.properties) setNestedDescription(schema, propPath.split("."), description);
+	for (const [propPath, description] of descs.properties) setNestedDescription({
+		schema,
+		pathParts: propPath.split("."),
+		description,
+		schemas
+	});
+}
+function resolveSchemaRef(schema, schemas) {
+	var _schemas$refName;
+	const ref = schema.$ref;
+	if (!ref) return schema;
+	if (!schemas || !ref.startsWith("#/components/schemas/")) return null;
+	const refName = ref.slice(21);
+	return refName ? (_schemas$refName = schemas[refName]) !== null && _schemas$refName !== void 0 ? _schemas$refName : null : null;
+}
+function getArrayItemsSchema(schema) {
+	const items = schema.items;
+	if (schema.type !== "array" || items == null || items === false) return null;
+	return items;
 }
-function setNestedDescription(schema, pathParts, description) {
-	var _schema$properties;
+function getPropertySchema(schema, propertyName) {
+	var _schema$properties$pr, _schema$properties;
+	return (_schema$properties$pr = (_schema$properties = schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[propertyName]) !== null && _schema$properties$pr !== void 0 ? _schema$properties$pr : null;
+}
+function setLeafDescription(schema, description) {
+	if (schema.$ref) {
+		var _schema$allOf;
+		const ref = schema.$ref;
+		delete schema.$ref;
+		schema.allOf = [{ $ref: ref }, ...(_schema$allOf = schema.allOf) !== null && _schema$allOf !== void 0 ? _schema$allOf : []];
+	}
+	schema.description = description;
+}
+function setNestedDescription({ schema, pathParts, description, schemas }) {
 	if (pathParts.length === 0) return;
 	const [head, ...rest] = pathParts;
 	if (!head) return;
 	if (head === "[]") {
-		const items = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : null;
+		const items = getArrayItemsSchema(schema);
 		if (!items) return;
-		if (rest.length === 0) items.description = description;
-		else setNestedDescription(items, rest, description);
+		if (rest.length === 0) setLeafDescription(items, description);
+		else {
+			var _resolveSchemaRef;
+			const target = (_resolveSchemaRef = resolveSchemaRef(items, schemas)) !== null && _resolveSchemaRef !== void 0 ? _resolveSchemaRef : items;
+			setNestedDescription({
+				schema: target,
+				pathParts: rest,
+				description,
+				schemas
+			});
+		}
 		return;
 	}
-	const propSchema = (_schema$properties = schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[head];
-	if (!propSchema || typeof propSchema !== "object") return;
-	if (rest.length === 0) propSchema.description = description;
+	const propSchema = getPropertySchema(schema, head);
+	if (!propSchema) return;
+	if (rest.length === 0) setLeafDescription(propSchema, description);
 	else {
-		const target = propSchema.type === "array" && propSchema.items && typeof propSchema.items === "object" ? propSchema.items : propSchema;
-		setNestedDescription(target, rest, description);
+		var _getArrayItemsSchema, _resolveSchemaRef2;
+		const target = (_getArrayItemsSchema = getArrayItemsSchema(propSchema)) !== null && _getArrayItemsSchema !== void 0 ? _getArrayItemsSchema : propSchema;
+		const resolvedTarget = (_resolveSchemaRef2 = resolveSchemaRef(target, schemas)) !== null && _resolveSchemaRef2 !== void 0 ? _resolveSchemaRef2 : target;
+		setNestedDescription({
+			schema: resolvedTarget,
+			pathParts: rest,
+			description,
+			schemas
+		});
 	}
 }
 
 //#endregion
 //#region src/generate.ts
 var import_objectSpread2 = __toESM(require_objectSpread2(), 1);
-const log = console;
 const PRIMITIVE_FLAGS = ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.Boolean | ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral;
 function hasFlag(type, flag) {
 	return (type.getFlags() & flag) !== 0;
@@ -252,6 +307,7 @@ const ANONYMOUS_NAMES = new Set([
 	"Object",
 	""
 ]);
+const INTERNAL_COMPUTED_PROPERTY_SYMBOL = /^__@.*@\d+$/;
 /** Try to determine a meaningful name for a TS type (type alias or interface). */
 function getTypeName(type) {
 	var _type$aliasSymbol, _type$getSymbol;
@@ -261,6 +317,21 @@ function getTypeName(type) {
 	if (symName && !ANONYMOUS_NAMES.has(symName) && !symName.startsWith("__")) return symName;
 	return null;
 }
+function shouldSkipPropertySymbol(prop) {
+	var _prop$declarations$so, _prop$declarations;
+	return (_prop$declarations$so = (_prop$declarations = prop.declarations) === null || _prop$declarations === void 0 ? void 0 : _prop$declarations.some((declaration) => {
+		const declarationName = ts.getNameOfDeclaration(declaration);
+		if (!declarationName || !ts.isComputedPropertyName(declarationName)) return false;
+		return INTERNAL_COMPUTED_PROPERTY_SYMBOL.test(prop.getName());
+	})) !== null && _prop$declarations$so !== void 0 ? _prop$declarations$so : false;
+}
+function getReferencedSchema(schema, schemas) {
+	var _schemas$refName;
+	const ref = schema === null || schema === void 0 ? void 0 : schema.$ref;
+	if (!(ref === null || ref === void 0 ? void 0 : ref.startsWith("#/components/schemas/"))) return schema;
+	const refName = ref.slice(21);
+	return refName ? (_schemas$refName = schemas[refName]) !== null && _schemas$refName !== void 0 ? _schemas$refName : null : schema;
+}
 function ensureUniqueName(name, existing) {
 	if (!(name in existing)) return name;
 	let i = 2;
@@ -270,6 +341,9 @@ function ensureUniqueName(name, existing) {
 function schemaRef(name) {
 	return { $ref: `#/components/schemas/${name}` };
 }
+function isSelfSchemaRef(schema, name) {
+	return schema.$ref === schemaRef(name).$ref;
+}
 function isNonEmptySchema(s) {
 	for (const _ in s) return true;
 	return false;
@@ -278,21 +352,28 @@ function isNonEmptySchema(s) {
 * Convert a TS type to a JSON Schema.  If the type has been pre-registered
 * (or has a meaningful TS name), it is stored in `ctx.schemas` and a `$ref`
 * is returned instead of an inline schema.
+*
+* Named types (type aliases, interfaces) are auto-registered before conversion
+* so that recursive references (including through unions and intersections)
+* resolve to a `$ref` instead of causing infinite recursion.
 */
 function typeToJsonSchema(type, ctx, depth = 0) {
-	if (depth > 20) {
-		log.warn(`[openapi] Schema conversion reached maximum depth (20) for type "${ctx.checker.typeToString(type)}". The resulting schema will be incomplete.`);
-		return {};
-	}
-	const refName = ctx.typeToRef.get(type);
-	if (refName) {
-		if (refName in ctx.schemas) return schemaRef(refName);
-		ctx.schemas[refName] = {};
+	const existingRef = ctx.typeToRef.get(type);
+	if (existingRef) {
+		const storedSchema = ctx.schemas[existingRef];
+		if (storedSchema && (isNonEmptySchema(storedSchema) || ctx.visited.has(type))) return schemaRef(existingRef);
+		ctx.schemas[existingRef] = storedSchema !== null && storedSchema !== void 0 ? storedSchema : {};
 		const schema$1 = convertTypeToSchema(type, ctx, depth);
-		ctx.schemas[refName] = schema$1;
-		return schemaRef(refName);
+		if (!isSelfSchemaRef(schema$1, existingRef)) ctx.schemas[existingRef] = schema$1;
+		return schemaRef(existingRef);
 	}
 	const schema = convertTypeToSchema(type, ctx, depth);
+	const postConvertRef = ctx.typeToRef.get(type);
+	if (postConvertRef) {
+		const stored = ctx.schemas[postConvertRef];
+		if (stored && !isNonEmptySchema(stored) && !isSelfSchemaRef(schema, postConvertRef)) ctx.schemas[postConvertRef] = schema;
+		return schemaRef(postConvertRef);
+	}
 	if (!schema.description && !schema.$ref && type.aliasSymbol) {
 		const aliasJsDoc = getJsDocComment(type.aliasSymbol, ctx.checker);
 		if (aliasJsDoc) schema.description = aliasJsDoc;
@@ -509,6 +590,7 @@ function convertPlainObject(type, ctx, depth) {
 	const properties = {};
 	const required = [];
 	for (const prop of typeProps) {
+		if (shouldSkipPropertySymbol(prop)) continue;
 		const propType = checker.getTypeOfSymbol(prop);
 		const propSchema = typeToJsonSchema(propType, ctx, depth + 1);
 		const jsDoc = getJsDocComment(prop, checker);
@@ -542,8 +624,18 @@ function convertTypeToSchema(type, ctx, depth) {
 	const flags = type.getFlags();
 	const primitive = convertPrimitiveOrLiteral(type, flags, ctx.checker);
 	if (primitive) return primitive;
-	if (type.isUnion()) return convertUnionType(type, ctx, depth);
-	if (type.isIntersection()) return convertIntersectionType(type, ctx, depth);
+	if (type.isUnion()) {
+		ctx.visited.add(type);
+		const result = convertUnionType(type, ctx, depth);
+		ctx.visited.delete(type);
+		return result;
+	}
+	if (type.isIntersection()) {
+		ctx.visited.add(type);
+		const result = convertIntersectionType(type, ctx, depth);
+		ctx.visited.delete(type);
+		return result;
+	}
 	if (isObjectType(type)) return convertObjectType(type, ctx, depth);
 	return {};
 }
@@ -566,7 +658,69 @@ function isVoidLikeInput(inputType) {
 	const isUnionOfVoids = inputType.isUnion() && inputType.types.every((t) => hasFlag(t, ts.TypeFlags.Void | ts.TypeFlags.Undefined));
 	return isUnionOfVoids;
 }
+function shouldIncludeProcedureInOpenAPI(type) {
+	return type !== "subscription";
+}
+function getProcedureInputTypeName(type, path$1) {
+	const directName = getTypeName(type);
+	if (directName) return directName;
+	for (const sym of [type.aliasSymbol, type.getSymbol()].filter((candidate) => !!candidate)) {
+		var _sym$declarations;
+		for (const declaration of (_sym$declarations = sym.declarations) !== null && _sym$declarations !== void 0 ? _sym$declarations : []) {
+			var _ts$getNameOfDeclarat;
+			const declarationName = (_ts$getNameOfDeclarat = ts.getNameOfDeclaration(declaration)) === null || _ts$getNameOfDeclarat === void 0 ? void 0 : _ts$getNameOfDeclarat.getText();
+			if (declarationName && !ANONYMOUS_NAMES.has(declarationName) && !declarationName.startsWith("__")) return declarationName;
+		}
+	}
+	const fallbackName = path$1.split(".").filter(Boolean).map((segment) => segment.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")).join("");
+	return `${fallbackName || "Procedure"}Input`;
+}
+function isUnknownLikeType(type) {
+	return hasFlag(type, ts.TypeFlags.Unknown | ts.TypeFlags.Any);
+}
+function isCollapsedProcedureInputType(type) {
+	return isUnknownLikeType(type) || isObjectType(type) && type.getProperties().length === 0 && !type.getStringIndexType();
+}
+function recoverProcedureInputType(def, checker) {
+	var _def$symbol$declarati;
+	let initializer = null;
+	for (const declaration of (_def$symbol$declarati = def.symbol.declarations) !== null && _def$symbol$declarati !== void 0 ? _def$symbol$declarati : []) {
+		if (ts.isPropertyAssignment(declaration)) {
+			initializer = declaration.initializer;
+			break;
+		}
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+			initializer = declaration.initializer;
+			break;
+		}
+	}
+	if (!initializer) return null;
+	let recovered = null;
+	const visit = (expr) => {
+		if (!ts.isCallExpression(expr)) return;
+		const callee = expr.expression;
+		if (!ts.isPropertyAccessExpression(callee)) return;
+		visit(callee.expression);
+		if (callee.name.text !== "input") return;
+		const [parserExpr] = expr.arguments;
+		if (!parserExpr) return;
+		const parserType = checker.getTypeAtLocation(parserExpr);
+		const standardSym = parserType.getProperty("~standard");
+		if (!standardSym) return;
+		const standardType = checker.getTypeOfSymbolAtLocation(standardSym, parserExpr);
+		const typesSym = standardType.getProperty("types");
+		if (!typesSym) return;
+		const typesType = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(typesSym, parserExpr));
+		const outputSym = typesType.getProperty("output");
+		if (!outputSym) return;
+		const outputType = checker.getTypeOfSymbolAtLocation(outputSym, parserExpr);
+		if (!isUnknownLikeType(outputType)) recovered = outputType;
+	};
+	visit(initializer);
+	return recovered;
+}
 function extractProcedure(def, ctx) {
+	var _recoverProcedureInpu;
 	const { schemaCtx } = ctx;
 	const { checker } = schemaCtx;
 	const $typesSym = def.defType.getProperty("$types");
@@ -576,12 +730,29 @@ function extractProcedure(def, ctx) {
 	const outputSym = $typesType.getProperty("output");
 	const inputType = inputSym ? checker.getTypeOfSymbol(inputSym) : null;
 	const outputType = outputSym ? checker.getTypeOfSymbol(outputSym) : null;
-	const inputSchema = !inputType || isVoidLikeInput(inputType) ? null : typeToJsonSchema(inputType, schemaCtx);
+	const resolvedInputType = inputType && isCollapsedProcedureInputType(inputType) ? (_recoverProcedureInpu = recoverProcedureInputType(def, checker)) !== null && _recoverProcedureInpu !== void 0 ? _recoverProcedureInpu : inputType : inputType;
+	let inputSchema = null;
+	if (!resolvedInputType || isVoidLikeInput(resolvedInputType)) {} else {
+		const ensureRecoveredInputRegistration = (type) => {
+			if (schemaCtx.typeToRef.has(type)) return;
+			const refName = ensureUniqueName(getProcedureInputTypeName(type, def.path), schemaCtx.schemas);
+			schemaCtx.typeToRef.set(type, refName);
+			schemaCtx.schemas[refName] = {};
+		};
+		if (resolvedInputType !== inputType) ensureRecoveredInputRegistration(resolvedInputType);
+		const initialSchema = typeToJsonSchema(resolvedInputType, schemaCtx);
+		if (!isNonEmptySchema(initialSchema) && !schemaCtx.typeToRef.has(resolvedInputType)) {
+			ensureRecoveredInputRegistration(resolvedInputType);
+			inputSchema = typeToJsonSchema(resolvedInputType, schemaCtx);
+		} else inputSchema = initialSchema;
+	}
 	const outputSchema = outputType ? typeToJsonSchema(outputType, schemaCtx) : null;
 	const runtimeDescs = ctx.runtimeDescriptions.get(def.path);
 	if (runtimeDescs) {
-		if (inputSchema && runtimeDescs.input) applyDescriptions(inputSchema, runtimeDescs.input);
-		if (outputSchema && runtimeDescs.output) applyDescriptions(outputSchema, runtimeDescs.output);
+		const resolvedInputSchema = getReferencedSchema(inputSchema, schemaCtx.schemas);
+		const resolvedOutputSchema = getReferencedSchema(outputSchema, schemaCtx.schemas);
+		if (resolvedInputSchema && runtimeDescs.input) applyDescriptions(resolvedInputSchema, runtimeDescs.input, schemaCtx.schemas);
+		if (resolvedOutputSchema && runtimeDescs.output) applyDescriptions(resolvedOutputSchema, runtimeDescs.output, schemaCtx.schemas);
 	}
 	ctx.procedures.push({
 		path: def.path,
@@ -593,13 +764,33 @@ function extractProcedure(def, ctx) {
 }
 /** Extract the JSDoc comment text from a symbol, if any. */
 function getJsDocComment(sym, checker) {
+	var _sym$declarations2;
+	const isWithinPath = (candidate, parent) => {
+		const rel = path.relative(parent, candidate);
+		return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+	};
+	const normalize = (filePath) => filePath.replace(/\\/g, "/");
+	const workspaceRoot = normalize(process.cwd());
+	const declarations = (_sym$declarations2 = sym.declarations) !== null && _sym$declarations2 !== void 0 ? _sym$declarations2 : [];
+	const isExternalNodeModulesDeclaration = declarations.length > 0 && declarations.every((declaration) => {
+		const sourceFile = declaration.getSourceFile();
+		if (!sourceFile.isDeclarationFile) return false;
+		const declarationPath = normalize(sourceFile.fileName);
+		if (!declarationPath.includes("/node_modules/")) return false;
+		try {
+			const realPath = normalize(fs.realpathSync.native(sourceFile.fileName));
+			if (isWithinPath(realPath, workspaceRoot) && !realPath.includes("/node_modules/")) return false;
+		} catch (_unused) {}
+		return true;
+	});
+	if (isExternalNodeModulesDeclaration) return void 0;
 	const parts = sym.getDocumentationComment(checker);
 	if (parts.length === 0) return void 0;
 	const text = parts.map((p) => p.text).join("");
 	return text || void 0;
 }
 function walkType(opts) {
-	const { type, ctx, currentPath, description } = opts;
+	const { type, ctx, currentPath, description, symbol } = opts;
 	if (ctx.seen.has(type)) return;
 	const defSym = type.getProperty("_def");
 	if (!defSym) {
@@ -614,11 +805,14 @@ function walkType(opts) {
 	const defType = checker.getTypeOfSymbol(defSym);
 	const procedureTypeName = getProcedureTypeName(defType, checker);
 	if (procedureTypeName) {
+		var _ref;
+		if (!shouldIncludeProcedureInOpenAPI(procedureTypeName)) return;
 		extractProcedure({
 			defType,
 			typeName: procedureTypeName,
 			path: currentPath,
-			description
+			description,
+			symbol: (_ref = symbol !== null && symbol !== void 0 ? symbol : type.getSymbol()) !== null && _ref !== void 0 ? _ref : defSym
 		}, ctx);
 		return;
 	}
@@ -642,7 +836,8 @@ function walkRecord(recordType, ctx, prefix) {
 			type: propType,
 			ctx,
 			currentPath: fullPath,
-			description
+			description,
+			symbol: prop
 		});
 	}
 }
@@ -720,8 +915,9 @@ function wrapInSuccessEnvelope(outputSchema) {
 	};
 }
 function buildProcedureOperation(proc, method) {
+	const [tag = proc.path] = proc.path.split(".");
 	const operation = (0, import_objectSpread2.default)((0, import_objectSpread2.default)({ operationId: proc.path }, proc.description ? { description: proc.description } : {}), {}, {
-		tags: [proc.path.split(".")[0]],
+		tags: [tag],
 		responses: {
 			"200": {
 				description: "Successful response",
@@ -731,14 +927,14 @@ function buildProcedureOperation(proc, method) {
 		}
 	});
 	if (proc.inputSchema === null) return operation;
-	if (method === "get") operation["parameters"] = [{
+	if (method === "get") operation.parameters = [{
 		name: "input",
 		in: "query",
 		required: true,
 		style: "deepObject",
 		content: { "application/json": { schema: proc.inputSchema } }
 	}];
-	else operation["requestBody"] = {
+	else operation.requestBody = {
 		required: true,
 		content: { "application/json": { schema: proc.inputSchema } }
 	};
@@ -749,7 +945,7 @@ function buildOpenAPIDocument(procedures, options, meta = { errorSchema: null })
 	const paths = {};
 	for (const proc of procedures) {
 		var _paths$opPath;
-		if (proc.type === "subscription") continue;
+		if (!shouldIncludeProcedureInOpenAPI(proc.type)) continue;
 		const opPath = `/${proc.path}`;
 		const method = proc.type === "query" ? "get" : "post";
 		const pathItem = (_paths$opPath = paths[opPath]) !== null && _paths$opPath !== void 0 ? _paths$opPath : {};
@@ -765,7 +961,7 @@ function buildOpenAPIDocument(procedures, options, meta = { errorSchema: null })
 			version: (_options$version = options.version) !== null && _options$version !== void 0 ? _options$version : "0.0.0"
 		},
 		paths,
-		components: (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, hasNamedSchemas ? { schemas: meta.schemas } : {}), {}, { responses: { Error: {
+		components: (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, hasNamedSchemas && meta.schemas ? { schemas: meta.schemas } : {}), {}, { responses: { Error: {
 			description: "Error response",
 			content: { "application/json": { schema: {
 				type: "object",
@@ -831,5 +1027,9 @@ async function generateOpenAPIDocument(routerFilePath, options = {}) {
 }
 
 //#endregion
-export { generateOpenAPIDocument };
+//#region src/types.ts
+var types_exports = {};
+
+//#endregion
+export { types_exports as OpenAPIV3_1, generateOpenAPIDocument };
 //# sourceMappingURL=index.mjs.map