adorn-api 1.0.11 → 1.0.13

package/dist/cli.js

@@ -86,7 +86,7 @@ function analyzeClass(node, sourceFile, checker) {
     produces
   };
 }
-function extractClassConsumes(node, checker) {
+function extractClassConsumes(node, _checker) {
   const decorator = findDecorator(node, "Consumes");
   if (!decorator) return void 0;
   const callExpr = decorator.expression;
@@ -102,7 +102,7 @@ function extractClassConsumes(node, checker) {
   }
   return void 0;
 }
-function extractClassProduces(node, checker) {
+function extractClassProduces(node, _checker) {
   const decorator = findDecorator(node, "Produces");
   if (!decorator) return void 0;
   const callExpr = decorator.expression;
@@ -154,7 +154,7 @@ function analyzeMethod(node, className, checker) {
   }
   const pathParamNames = extractPathParams(path4);
   const pathParamIndices = matchPathParamsToIndices(pathParamNames, parameters);
-  const { bodyParamIndex, queryParamIndices, queryObjectParamIndex, headerObjectParamIndex, cookieObjectParamIndex, paginationParamIndex, bodyContentType } = classifyParameters(parameters, httpMethod, pathParamIndices, checker);
+  const { bodyParamIndex, queryParamIndices, queryObjectParamIndex, headerObjectParamIndex, cookieObjectParamIndex, bodyContentType } = classifyParameters(parameters, httpMethod, pathParamIndices, checker);
   return {
     methodName,
     httpMethod,
@@ -170,7 +170,6 @@ function analyzeMethod(node, className, checker) {
     queryObjectParamIndex,
     headerObjectParamIndex,
     cookieObjectParamIndex,
-    paginationParamIndex,
     bodyContentType
   };
 }
@@ -196,7 +195,6 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
   let queryObjectParamIndex = null;
   let headerObjectParamIndex = null;
   let cookieObjectParamIndex = null;
-  let paginationParamIndex = null;
   const isBodyMethod = ["POST", "PUT", "PATCH"].includes(httpMethod);
   for (let i = 0; i < parameters.length; i++) {
     const param = parameters[i];
@@ -223,11 +221,6 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
       usedIndices.add(i);
       continue;
     }
-    if (typeStr === "PaginationParams") {
-      paginationParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
     if (isBodyMethod && bodyParamIndex === null) {
       bodyParamIndex = i;
       usedIndices.add(i);
@@ -248,19 +241,19 @@ function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
     queryObjectParamIndex,
     headerObjectParamIndex,
     cookieObjectParamIndex,
-    paginationParamIndex,
     bodyContentType: void 0
   };
 }
 function isObjectType(type, checker) {
   const objectFlags = (type.flags & ts2.TypeFlags.Object) !== 0;
-  if (!objectFlags) return false;
+  const intersectionFlags = (type.flags & ts2.TypeFlags.Intersection) !== 0;
+  if (!objectFlags && !intersectionFlags) return false;
   const symbol = type.getSymbol();
   if (symbol?.getName() === "__object") return true;
   const properties = checker.getPropertiesOfType(type);
   if (properties.length > 0) return true;
-  const callSignatures = type.getCallSignatures();
-  if (callSignatures && callSignatures.length > 0) return false;
+  const callSigs = type.getCallSignatures?.();
+  if (callSigs && callSigs.length > 0) return false;
   return true;
 }
 function getTypeName(type) {
@@ -291,7 +284,7 @@ function extractDecoratorStringArg(decorator) {
   }
   return null;
 }
-function unwrapPromise(type, checker) {
+function unwrapPromise(type, _checker) {
   const symbol = type.getSymbol();
   if (symbol?.getName() === "Promise") {
     const typeArgs = type.typeArguments;
@@ -312,12 +305,15 @@ function unwrapPromiseTypeNode(typeNode) {
 }
 
 // src/compiler/schema/openapi.ts
-import ts6 from "typescript";
+import ts9 from "typescript";
 
 // src/compiler/schema/typeToJsonSchema.ts
+import ts7 from "typescript";
+
+// src/compiler/schema/primitives.ts
 import ts3 from "typescript";
-function typeToJsonSchema(type, ctx, typeNode) {
-  const { checker } = ctx;
+function handlePrimitiveType(type, ctx, typeNode) {
+  const { checker, propertyName } = ctx;
   if (type.flags & ts3.TypeFlags.Undefined) {
     return {};
   }
@@ -331,7 +327,7 @@ function typeToJsonSchema(type, ctx, typeNode) {
     return { type: "string" };
   }
   if (type.flags & ts3.TypeFlags.Number) {
-    return { type: "number" };
+    return normalizeNumericType(type, checker, typeNode, propertyName);
   }
   if (type.flags & ts3.TypeFlags.Boolean) {
     return { type: "boolean" };
@@ -355,26 +351,7 @@ function typeToJsonSchema(type, ctx, typeNode) {
     const intrinsic = type.intrinsicName;
     return { type: "boolean", enum: [intrinsic === "true"] };
   }
-  if (type.isUnion()) {
-    return handleUnion(type, ctx, typeNode);
-  }
-  if (type.isIntersection()) {
-    return handleIntersection(type, ctx, typeNode);
-  }
-  if (checker.isArrayType(type)) {
-    const typeArgs = type.typeArguments;
-    const itemType = typeArgs?.[0];
-    const items = itemType ? typeToJsonSchema(itemType, ctx) : {};
-    return {
-      type: "array",
-      items,
-      uniqueItems: isSetType(type, checker) ? true : void 0
-    };
-  }
-  if (type.flags & ts3.TypeFlags.Object) {
-    return handleObjectType(type, ctx, typeNode);
-  }
-  return {};
+  return null;
 }
 function isDateType(type, checker) {
   const symbol = type.getSymbol();
@@ -389,53 +366,51 @@ function isDateType(type, checker) {
   }
   return symbol?.getName() === "Date";
 }
-function isSetType(type, checker) {
-  const symbol = type.getSymbol();
-  if (!symbol) return false;
-  const name = symbol.getName();
-  if (name === "Set") return true;
-  return false;
-}
-function getSchemaName(type, typeNode) {
-  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
-  const aliasName = aliasSymbol?.getName();
-  if (aliasName && aliasName !== "__type") {
-    return aliasName;
+function normalizeNumericType(type, checker, typeNode, propertyName) {
+  const typeName = getExplicitTypeNameFromNode(typeNode) ?? null;
+  const symbol = getEffectiveSymbol(type, checker);
+  const symbolName = symbol?.getName() ?? null;
+  if (shouldBeIntegerType(typeName) || shouldBeIntegerType(symbolName) || shouldBeIntegerType(propertyName ?? null)) {
+    return { type: "integer" };
   }
-  const symbol = type.getSymbol();
-  const symbolName = symbol?.getName?.();
-  if (symbolName && symbolName !== "__type") {
-    return symbolName;
+  return { type: "number" };
+}
+function shouldBeIntegerType(typeName) {
+  if (!typeName) return false;
+  const lower = typeName.toLowerCase();
+  return lower === "id" || lower.endsWith("id") || lower === "primarykey" || lower === "pk" || lower === "page" || lower === "pagesize" || lower === "totalitems" || lower === "limit" || lower === "offset";
+}
+function getExplicitTypeNameFromNode(typeNode) {
+  if (!typeNode) return null;
+  if (ts3.isTypeReferenceNode(typeNode)) {
+    if (ts3.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.text;
+    }
   }
-  const nodeName = getExplicitTypeNameFromNode(typeNode);
-  if (nodeName && nodeName !== "__type") {
-    return nodeName;
+  if (ts3.isTypeAliasDeclaration(typeNode.parent)) {
+    if (ts3.isIdentifier(typeNode.parent.name)) {
+      return typeNode.parent.name.text;
+    }
   }
   return null;
 }
-function buildNamedSchema(type, ctx, typeNode, build) {
-  const name = getSchemaName(type, typeNode);
-  if (!name) {
-    return build();
-  }
-  const { components, typeStack } = ctx;
-  if (components.has(name) || typeStack.has(type)) {
-    return { $ref: `#/components/schemas/${name}` };
-  }
-  typeStack.add(type);
-  const schema = build();
-  typeStack.delete(type);
-  if (!components.has(name)) {
-    components.set(name, schema);
+function getEffectiveSymbol(type, checker) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  if (aliasSymbol && aliasSymbol.flags & ts3.SymbolFlags.Alias) {
+    return checker.getAliasedSymbol(aliasSymbol);
   }
-  return { $ref: `#/components/schemas/${name}` };
+  return type.getSymbol() ?? null;
 }
+
+// src/compiler/schema/unionHandler.ts
+import ts4 from "typescript";
 function handleUnion(type, ctx, typeNode) {
   return buildNamedSchema(type, ctx, typeNode, () => {
     const types = type.types;
-    const nullType = types.find((t) => t.flags & ts3.TypeFlags.Null);
-    const otherTypes = types.filter((t) => !(t.flags & ts3.TypeFlags.Null) && !(t.flags & ts3.TypeFlags.Undefined));
-    const allStringLiterals = otherTypes.every((t) => t.flags & ts3.TypeFlags.StringLiteral);
+    const nullType = types.find((t) => t.flags & ts4.TypeFlags.Null);
+    const undefinedType = types.find((t) => t.flags & ts4.TypeFlags.Undefined);
+    const otherTypes = types.filter((t) => !(t.flags & ts4.TypeFlags.Null) && !(t.flags & ts4.TypeFlags.Undefined));
+    const allStringLiterals = otherTypes.every((t) => t.flags & ts4.TypeFlags.StringLiteral);
     if (allStringLiterals && otherTypes.length > 0) {
       const enumValues = otherTypes.map((t) => t.value);
       const schema = { type: "string", enum: enumValues };
@@ -444,6 +419,14 @@ function handleUnion(type, ctx, typeNode) {
       }
       return schema;
     }
+    const allBooleanLiterals = otherTypes.length > 0 && otherTypes.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
+    if (allBooleanLiterals) {
+      const schema = { type: "boolean" };
+      if (nullType || undefinedType) {
+        schema.type = ["boolean", "null"];
+      }
+      return schema;
+    }
     if (otherTypes.length === 1 && nullType) {
       const innerSchema = typeToJsonSchema(otherTypes[0], ctx);
       if (typeof innerSchema.type === "string") {
@@ -473,49 +456,7 @@ function handleUnion(type, ctx, typeNode) {
     return {};
   });
 }
-function handleIntersection(type, ctx, typeNode) {
-  return buildNamedSchema(type, ctx, typeNode, () => {
-    const types = type.types;
-    const brandCollapsed = tryCollapseBrandedIntersection(types, ctx, typeNode);
-    if (brandCollapsed) {
-      return brandCollapsed;
-    }
-    const allOf = [];
-    for (const t of types) {
-      allOf.push(typeToJsonSchema(t, ctx));
-    }
-    return { allOf };
-  });
-}
-function tryCollapseBrandedIntersection(types, ctx, typeNode) {
-  const { checker } = ctx;
-  const parts = [...types];
-  const prim = parts.find(isPrimitiveLike);
-  if (!prim) return null;
-  const rest = parts.filter((p) => p !== prim);
-  if (rest.every((r) => isBrandObject(checker, r, ctx))) {
-    return typeToJsonSchema(prim, ctx);
-  }
-  return null;
-}
-function isPrimitiveLike(t) {
-  return (t.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.Boolean | ts3.TypeFlags.BigInt)) !== 0 || (t.flags & ts3.TypeFlags.StringLiteral) !== 0 || (t.flags & ts3.TypeFlags.NumberLiteral) !== 0;
-}
-function isBrandObject(checker, t, ctx) {
-  if (!(t.flags & ts3.TypeFlags.Object)) return false;
-  const props = t.getProperties();
-  if (props.length === 0) return false;
-  const allowed = /* @__PURE__ */ new Set(["__brand", "__type", "__tag", "brand"]);
-  for (const p of props) {
-    if (!allowed.has(p.getName())) return false;
-  }
-  const callSigs = t.getCallSignatures?.();
-  if (callSigs && callSigs.length > 0) return false;
-  const constructSigs = t.getConstructSignatures?.();
-  if (constructSigs && constructSigs.length > 0) return false;
-  return true;
-}
-function detectDiscriminatedUnion(types, ctx, branches) {
+function detectDiscriminatedUnion(types, ctx, _branches) {
   if (types.length < 2) return null;
   const candidates = findCommonPropertyNames(ctx.checker, types);
   for (const propName of candidates) {
@@ -546,10 +487,10 @@ function findCommonPropertyNames(checker, types) {
 function isRequiredProperty(checker, type, propName) {
   const sym = checker.getPropertyOfType(type, propName);
   if (!sym) return false;
-  if (sym.flags & ts3.SymbolFlags.Optional) return false;
+  if (sym.flags & ts4.SymbolFlags.Optional) return false;
   const propType = checker.getTypeOfSymbol(sym);
   if (propType.isUnion?.()) {
-    const hasUndefined = propType.types.some((t) => (t.flags & ts3.TypeFlags.Undefined) !== 0);
+    const hasUndefined = propType.types.some((t) => (t.flags & ts4.TypeFlags.Undefined) !== 0);
     if (hasUndefined) return false;
   }
   return true;
@@ -592,11 +533,187 @@ function getBranchSchemaName(type, ctx) {
   }
   return `Anonymous_${ctx.typeNameStack.length}`;
 }
+function buildNamedSchema(type, ctx, typeNode, build) {
+  const name = getSchemaName(type, typeNode);
+  if (!name) {
+    return build();
+  }
+  const { components, typeStack } = ctx;
+  if (components.has(name) || typeStack.has(type)) {
+    return { $ref: `#/components/schemas/${name}` };
+  }
+  typeStack.add(type);
+  const schema = build();
+  typeStack.delete(type);
+  if (!components.has(name)) {
+    components.set(name, schema);
+  }
+  return { $ref: `#/components/schemas/${name}` };
+}
+function getSchemaName(type, typeNode) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  const aliasName = aliasSymbol?.getName();
+  if (aliasName && aliasName !== "__type") {
+    return aliasName;
+  }
+  const symbol = type.getSymbol();
+  const symbolName = symbol?.getName?.();
+  if (symbolName && symbolName !== "__type") {
+    return symbolName;
+  }
+  const nodeName = getExplicitTypeNameFromNode2(typeNode);
+  if (nodeName && nodeName !== "__type") {
+    return nodeName;
+  }
+  return null;
+}
+function getExplicitTypeNameFromNode2(typeNode) {
+  if (!typeNode) return null;
+  if (ts4.isTypeReferenceNode(typeNode)) {
+    if (ts4.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.text;
+    }
+  }
+  if (ts4.isTypeAliasDeclaration(typeNode.parent)) {
+    if (ts4.isIdentifier(typeNode.parent.name)) {
+      return typeNode.parent.name.text;
+    }
+  }
+  return null;
+}
+
+// src/compiler/schema/intersectionHandler.ts
+import ts5 from "typescript";
+function handleIntersection(type, ctx, typeNode) {
+  return buildNamedSchema2(type, ctx, typeNode, () => {
+    const types = type.types;
+    const brandCollapsed = tryCollapseBrandedIntersection(types, ctx, typeNode);
+    if (brandCollapsed) {
+      return brandCollapsed;
+    }
+    const allOf = [];
+    for (const t of types) {
+      const schema = typeToJsonSchema(t, ctx);
+      if (Object.keys(schema).length > 0) {
+        if (isEmptyObjectSchema(schema)) {
+          continue;
+        }
+        allOf.push(schema);
+      }
+    }
+    if (allOf.length === 0) {
+      return {};
+    }
+    if (allOf.length === 1) {
+      return allOf[0];
+    }
+    return { allOf };
+  });
+}
+function tryCollapseBrandedIntersection(types, ctx, _typeNode) {
+  const { checker } = ctx;
+  const parts = [...types];
+  const prim = parts.find(isPrimitiveLike);
+  if (!prim) return null;
+  const rest = parts.filter((p) => p !== prim);
+  if (rest.every((r) => isBrandObject(checker, r, ctx))) {
+    return typeToJsonSchema(prim, ctx);
+  }
+  return null;
+}
+function isPrimitiveLike(t) {
+  return (t.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.BigInt)) !== 0 || (t.flags & ts5.TypeFlags.StringLiteral) !== 0 || (t.flags & ts5.TypeFlags.NumberLiteral) !== 0;
+}
+function isBrandObject(checker, t, _ctx) {
+  if (!(t.flags & ts5.TypeFlags.Object)) return false;
+  const props = t.getProperties();
+  if (props.length === 0) return false;
+  const allowed = /* @__PURE__ */ new Set(["__brand", "__type", "__tag", "brand"]);
+  for (const p of props) {
+    if (!allowed.has(p.getName())) return false;
+  }
+  const callSigs = t.getCallSignatures?.();
+  if (callSigs && callSigs.length > 0) return false;
+  const constructSigs = t.getConstructSignatures?.();
+  if (constructSigs && constructSigs.length > 0) return false;
+  return true;
+}
+function isEmptyObjectSchema(schema) {
+  if (schema.type !== "object") {
+    return false;
+  }
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    if (!schema.additionalProperties) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildNamedSchema2(type, ctx, typeNode, build) {
+  const name = getSchemaName2(type, typeNode);
+  if (!name) {
+    return build();
+  }
+  const { components, typeStack } = ctx;
+  if (components.has(name) || typeStack.has(type)) {
+    return { $ref: `#/components/schemas/${name}` };
+  }
+  typeStack.add(type);
+  const schema = build();
+  typeStack.delete(type);
+  if (!components.has(name)) {
+    components.set(name, schema);
+  }
+  return { $ref: `#/components/schemas/${name}` };
+}
+function getSchemaName2(type, typeNode) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  const aliasName = aliasSymbol?.getName();
+  if (aliasName && aliasName !== "__type") {
+    return aliasName;
+  }
+  const symbol = type.getSymbol();
+  const symbolName = symbol?.getName?.();
+  if (symbolName && symbolName !== "__type") {
+    return symbolName;
+  }
+  const nodeName = getExplicitTypeNameFromNode3(typeNode);
+  if (nodeName && nodeName !== "__type") {
+    return nodeName;
+  }
+  return null;
+}
+function getExplicitTypeNameFromNode3(typeNode) {
+  if (!typeNode) return null;
+  if (ts5.isTypeReferenceNode(typeNode)) {
+    if (ts5.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.text;
+    }
+  }
+  if (ts5.isTypeAliasDeclaration(typeNode.parent)) {
+    if (ts5.isIdentifier(typeNode.parent.name)) {
+      return typeNode.parent.name.text;
+    }
+  }
+  return null;
+}
+
+// src/compiler/schema/objectHandler.ts
+import ts6 from "typescript";
 function handleObjectType(type, ctx, typeNode) {
   const { checker, components, typeStack } = ctx;
   const symbol = type.getSymbol();
   const typeName = symbol?.getName?.() ?? getTypeNameFromNode(typeNode, ctx);
+  if (isMetalOrmWrapperType(type, checker)) {
+    return handleMetalOrmWrapper(type, ctx);
+  }
   if (typeName && typeName !== "__type") {
+    const isMetalOrmGeneric = METAL_ORM_WRAPPER_NAMES.some(
+      (name) => typeName === name || typeName.endsWith("Api")
+    );
+    if (isMetalOrmGeneric) {
+      return {};
+    }
     if (components.has(typeName)) {
       return { $ref: `#/components/schemas/${typeName}` };
     }
@@ -608,7 +725,8 @@ function handleObjectType(type, ctx, typeNode) {
   const schema = buildObjectSchema(type, ctx, typeNode);
   if (typeName && typeName !== "__type") {
     typeStack.delete(type);
-    if (!components.has(typeName)) {
+    const existing = components.get(typeName);
+    if (!existing) {
       components.set(typeName, schema);
     }
     return { $ref: `#/components/schemas/${typeName}` };
@@ -616,36 +734,26 @@ function handleObjectType(type, ctx, typeNode) {
   typeStack.delete(type);
   return schema;
 }
-function getExplicitTypeNameFromNode(typeNode) {
-  if (!typeNode) return null;
-  if (ts3.isTypeReferenceNode(typeNode)) {
-    if (ts3.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.text;
-    }
-  }
-  if (ts3.isTypeAliasDeclaration(typeNode.parent)) {
-    if (ts3.isIdentifier(typeNode.parent.name)) {
-      return typeNode.parent.name.text;
-    }
-  }
-  return null;
-}
-function getTypeNameFromNode(typeNode, ctx) {
-  const explicitName = getExplicitTypeNameFromNode(typeNode);
-  if (explicitName) return explicitName;
-  return `Anonymous_${ctx.typeNameStack.length}`;
-}
-function buildObjectSchema(type, ctx, typeNode) {
-  const { checker } = ctx;
+function buildObjectSchema(type, ctx, _typeNode) {
+  const { checker, mode } = ctx;
   const properties = {};
   const required = [];
   const props = checker.getPropertiesOfType(type);
   for (const prop of props) {
     const propName = prop.getName();
+    if (isIteratorOrSymbolProperty(propName)) {
+      continue;
+    }
     const propType = checker.getTypeOfSymbol(prop);
-    const isOptional = !!(prop.flags & ts3.SymbolFlags.Optional);
-    properties[propName] = typeToJsonSchema(propType, ctx);
-    if (!isOptional) {
+    if (isMethodLike(propType)) {
+      continue;
+    }
+    const isOptional = !!(prop.flags & ts6.SymbolFlags.Optional);
+    const isRelation = isMetalOrmWrapperType(propType, checker);
+    const propCtx = { ...ctx, propertyName: propName };
+    properties[propName] = typeToJsonSchema(propType, propCtx);
+    const shouldRequire = mode === "response" ? !isRelation && !isOptional : !isOptional;
+    if (shouldRequire) {
       required.push(propName);
     }
   }
@@ -664,14 +772,14 @@ function buildObjectSchema(type, ctx, typeNode) {
   }
   return schema;
 }
-function isRecordType(type, checker) {
+function isRecordType(type, _checker) {
   const symbol = type.getSymbol();
   if (!symbol) return false;
   const name = symbol.getName();
   if (name === "Record") return true;
   return false;
 }
-function getRecordValueType(type, checker) {
+function getRecordValueType(type, _checker) {
   const symbol = type.getSymbol();
   if (!symbol) return null;
   const name = symbol.getName();
@@ -684,24 +792,229 @@ function getRecordValueType(type, checker) {
   }
   return null;
 }
+function isMetalOrmWrapperType(type, checker) {
+  return !!findMetalOrmWrapper(type, checker);
+}
+function isMethodLike(type) {
+  const callSigs = type.getCallSignatures?.();
+  return !!(callSigs && callSigs.length > 0);
+}
+function isIteratorOrSymbolProperty(propName) {
+  return propName.startsWith("__@") || propName.startsWith("[") || propName === Symbol.iterator.toString();
+}
+function getTypeNameFromNode(typeNode, _ctx) {
+  const explicitName = getExplicitTypeNameFromNode4(typeNode);
+  if (explicitName) return explicitName;
+  return "Anonymous_${ctx.typeNameStack.length}";
+}
+function getExplicitTypeNameFromNode4(typeNode) {
+  if (!typeNode) return null;
+  if (ts6.isTypeReferenceNode(typeNode)) {
+    if (ts6.isIdentifier(typeNode.typeName)) {
+      return typeNode.typeName.text;
+    }
+  }
+  if (ts6.isTypeAliasDeclaration(typeNode.parent)) {
+    if (ts6.isIdentifier(typeNode.parent.name)) {
+      return typeNode.parent.name.text;
+    }
+  }
+  return null;
+}
+var METAL_ORM_WRAPPER_NAMES = ["HasManyCollection", "ManyToManyCollection", "BelongsToReference", "HasOneReference"];
+function findMetalOrmWrapper(type, checker) {
+  if (type.isIntersection()) {
+    let wrapperInfo = null;
+    let hasReadonlyArray = false;
+    for (const constituent of type.types) {
+      const result = findWrapperInType(constituent, checker);
+      if (result) {
+        wrapperInfo = result;
+      }
+      if (!(constituent.flags & ts6.TypeFlags.Object)) continue;
+      const symbol = constituent.getSymbol();
+      if (symbol?.getName() === "ReadonlyArray") {
+        hasReadonlyArray = true;
+      }
+    }
+    if (wrapperInfo) {
+      return { ...wrapperInfo, isReadonlyArray: hasReadonlyArray };
+    }
+    return null;
+  }
+  return findWrapperInType(type, checker);
+}
+function findWrapperInType(type, checker) {
+  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
+  const symbol = type.getSymbol();
+  const effectiveSymbol = aliasSymbol && aliasSymbol.flags & ts6.SymbolFlags.Alias ? checker.getAliasedSymbol(aliasSymbol) : symbol;
+  if (!effectiveSymbol) return null;
+  const name = effectiveSymbol.getName();
+  if (!METAL_ORM_WRAPPER_NAMES.includes(name)) return null;
+  const typeRef = type;
+  const typeArgs = typeRef.typeArguments || [];
+  return {
+    wrapperName: name,
+    targetTypeArgs: typeArgs,
+    isReadonlyArray: false
+  };
+}
+function getWrapperTypeName(type, _checker) {
+  const symbol = type.getSymbol();
+  if (!symbol) return null;
+  const name = symbol.getName();
+  return METAL_ORM_WRAPPER_NAMES.includes(name) ? name : null;
+}
+function handleMetalOrmWrapper(type, ctx) {
+  const typeRef = type;
+  const typeArgs = typeRef.typeArguments;
+  const targetType = typeArgs?.[0] ?? null;
+  const wrapperName = getWrapperTypeName(type, ctx.checker);
+  if (!wrapperName) return {};
+  const wrapperRel = { wrapper: wrapperName };
+  if (wrapperName === "HasManyCollection" || wrapperName === "ManyToManyCollection") {
+    const items = targetType ? typeToJsonSchema(targetType, ctx) : {};
+    if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
+      wrapperRel.pivot = typeArgs[1];
+    }
+    return {
+      type: "array",
+      items,
+      "x-metal-orm-rel": wrapperRel
+    };
+  }
+  if (!targetType) {
+    return { "x-metal-orm-rel": wrapperRel };
+  }
+  if (wrapperName === "BelongsToReference" || wrapperName === "HasOneReference") {
+    return handleBelongsToReference(targetType, ctx, wrapperRel);
+  }
+  const targetSchema = typeToJsonSchema(targetType, ctx);
+  return {
+    ...targetSchema,
+    "x-metal-orm-rel": wrapperRel
+  };
+}
+function handleBelongsToReference(targetType, ctx, wrapperRel) {
+  const { components } = ctx;
+  const targetSymbol = targetType.getSymbol();
+  const typeName = targetSymbol?.getName();
+  if (!typeName) {
+    return {
+      type: "object",
+      properties: {},
+      "x-metal-orm-rel": wrapperRel
+    };
+  }
+  const refSchemaName = `${typeName}Ref`;
+  if (components.has(refSchemaName)) {
+    return {
+      $ref: `#/components/schemas/${refSchemaName}`,
+      "x-metal-orm-rel": wrapperRel
+    };
+  }
+  const refSchema = buildRefSchema(targetType, ctx);
+  components.set(refSchemaName, refSchema);
+  return {
+    $ref: `#/components/schemas/${refSchemaName}`,
+    "x-metal-orm-rel": wrapperRel
+  };
+}
+function buildRefSchema(type, ctx) {
+  const { checker } = ctx;
+  if (!(type.flags & ts6.TypeFlags.Object)) {
+    return { type: "object", properties: {} };
+  }
+  const objectType = type;
+  const properties = {};
+  const required = [];
+  const props = checker.getPropertiesOfType(objectType);
+  for (const prop of props) {
+    const propName = prop.getName();
+    if (isIteratorOrSymbolProperty(propName)) {
+      continue;
+    }
+    const propType = checker.getTypeOfSymbol(prop);
+    if (isMethodLike(propType)) {
+      continue;
+    }
+    const isOptional = !!(prop.flags & ts6.SymbolFlags.Optional);
+    const isRelation = isMetalOrmWrapperType(propType, checker);
+    if (isRelation) {
+      continue;
+    }
+    const propCtx = { ...ctx, propertyName: propName };
+    properties[propName] = typeToJsonSchema(propType, propCtx);
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+
+// src/compiler/schema/typeToJsonSchema.ts
+function typeToJsonSchema(type, ctx, typeNode) {
+  const primitiveResult = handlePrimitiveType(type, ctx, typeNode);
+  if (primitiveResult) {
+    return primitiveResult;
+  }
+  if (type.isUnion()) {
+    return handleUnion(type, ctx, typeNode);
+  }
+  if (type.isIntersection()) {
+    return handleIntersection(type, ctx, typeNode);
+  }
+  if (ctx.checker.isArrayType(type)) {
+    const typeArgs = type.typeArguments;
+    const itemType = typeArgs?.[0];
+    const items = itemType ? typeToJsonSchema(itemType, ctx) : {};
+    return {
+      type: "array",
+      items,
+      uniqueItems: isSetType(type, ctx.checker) ? true : void 0
+    };
+  }
+  if (type.flags & ts7.TypeFlags.Object) {
+    const objectType = type;
+    if (isMetalOrmWrapperType(type, ctx.checker)) {
+      return handleMetalOrmWrapper(objectType, ctx);
+    }
+    return handleObjectType(objectType, ctx, typeNode);
+  }
+  return {};
+}
+function isSetType(type, _checker) {
+  const symbol = type.getSymbol();
+  if (!symbol) return false;
+  const name = symbol.getName();
+  if (name === "Set") return true;
+  return false;
+}
 
 // src/compiler/schema/extractAnnotations.ts
-import ts4 from "typescript";
+import ts8 from "typescript";
 function extractPropertySchemaFragments(checker, prop) {
-  if (!ts4.canHaveDecorators(prop)) return [];
-  const decs = ts4.getDecorators(prop);
+  if (!ts8.canHaveDecorators(prop)) return [];
+  const decs = ts8.getDecorators(prop);
   if (!decs || decs.length === 0) return [];
   const frags = [];
   for (const d of decs) {
     const expr = d.expression;
     let callee;
     let args;
-    if (ts4.isCallExpression(expr)) {
+    if (ts8.isCallExpression(expr)) {
       callee = expr.expression;
       args = expr.arguments;
     } else {
       callee = expr;
-      args = ts4.factory.createNodeArray([]);
+      args = ts8.factory.createNodeArray([]);
     }
     const sym = checker.getSymbolAtLocation(callee);
     if (!sym) continue;
@@ -710,7 +1023,7 @@ function extractPropertySchemaFragments(checker, prop) {
     const name = resolved.name;
     if (name === "Schema") {
       const obj = args[0];
-      if (obj && ts4.isObjectLiteralExpression(obj)) {
+      if (obj && ts8.isObjectLiteralExpression(obj)) {
         const frag = objectLiteralToJson(obj);
         if (frag) frags.push(frag);
       }
@@ -732,7 +1045,7 @@ function extractPropertySchemaFragments(checker, prop) {
       frags.push({ format: args[0].text });
     } else if (name === "Pattern") {
       const arg = args[0];
-      if (arg && ts4.isRegularExpressionLiteral(arg)) {
+      if (arg && ts8.isRegularExpressionLiteral(arg)) {
         frags.push({ pattern: extractRegexPattern(arg.text) });
       } else if (isStringLiteral(arg)) {
         frags.push({ pattern: arg.text });
@@ -749,11 +1062,11 @@ function extractPropertySchemaFragments(checker, prop) {
       frags.push({ multipleOf: Number(args[0].text) });
     } else if (name === "Example") {
       frags.push({ example: literalToJson(args[0]) });
-    } else if (name === "Examples" && ts4.isArrayLiteralExpression(args[0])) {
+    } else if (name === "Examples" && ts8.isArrayLiteralExpression(args[0])) {
       frags.push({ examples: args[0].elements.map((e) => literalToJson(e)) });
     } else if (name === "Description" && isStringLiteral(args[0])) {
       frags.push({ description: args[0].text });
-    } else if (name === "Enum" && ts4.isArrayLiteralExpression(args[0])) {
+    } else if (name === "Enum" && ts8.isArrayLiteralExpression(args[0])) {
       frags.push({ enum: args[0].elements.map((e) => literalToJson(e)) });
     } else if (name === "Const") {
       frags.push({ const: literalToJson(args[0]) });
@@ -761,9 +1074,9 @@ function extractPropertySchemaFragments(checker, prop) {
       frags.push({ default: literalToJson(args[0]) });
     } else if (name === "AdditionalProperties") {
       const arg = args[0];
-      if (arg && (arg.kind === ts4.SyntaxKind.FalseKeyword || arg.kind === ts4.SyntaxKind.TrueKeyword)) {
-        frags.push({ additionalProperties: arg.kind === ts4.SyntaxKind.TrueKeyword });
-      } else if (arg && ts4.isObjectLiteralExpression(arg)) {
+      if (arg && (arg.kind === ts8.SyntaxKind.FalseKeyword || arg.kind === ts8.SyntaxKind.TrueKeyword)) {
+        frags.push({ additionalProperties: arg.kind === ts8.SyntaxKind.TrueKeyword });
+      } else if (arg && ts8.isObjectLiteralExpression(arg)) {
         const obj = objectLiteralToJson(arg);
         if (obj) frags.push({ additionalProperties: obj });
       }
@@ -776,7 +1089,7 @@ function extractPropertySchemaFragments(checker, prop) {
   return frags;
 }
 function resolveImportedDecorator(checker, sym) {
-  const target = sym.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
+  const target = sym.flags & ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
   const name = target.getName();
   const decl = target.declarations?.[0];
   if (!decl) return null;
@@ -784,111 +1097,320 @@ function resolveImportedDecorator(checker, sym) {
   if (fileName.includes("/node_modules/adorn-api/") || fileName.includes("/src/schema/")) {
     return { module: "adorn-api/schema", name };
   }
-  return null;
-}
-function isNumberLiteral(node) {
-  return !!node && ts4.isNumericLiteral(node);
+  return null;
+}
+function isNumberLiteral(node) {
+  return !!node && ts8.isNumericLiteral(node);
+}
+function isStringLiteral(node) {
+  return !!node && ts8.isStringLiteral(node);
+}
+function extractRegexPattern(text) {
+  const match = text.match(/^\/(.+)\/[gimsuy]*$/);
+  return match ? match[1] : text;
+}
+function objectLiteralToJson(obj) {
+  const out = {};
+  for (const prop of obj.properties) {
+    if (!ts8.isPropertyAssignment(prop)) continue;
+    const name = prop.name;
+    let key;
+    if (ts8.isIdentifier(name)) {
+      key = name.text;
+    } else if (ts8.isStringLiteral(name)) {
+      key = name.text;
+    } else {
+      continue;
+    }
+    out[key] = literalToJson(prop.initializer);
+  }
+  return out;
+}
+function literalToJson(node) {
+  if (ts8.isStringLiteral(node)) return node.text;
+  if (ts8.isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === ts8.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts8.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts8.SyntaxKind.NullKeyword) return null;
+  if (ts8.isObjectLiteralExpression(node)) return objectLiteralToJson(node);
+  if (ts8.isArrayLiteralExpression(node)) return node.elements.map((e) => literalToJson(e));
+  return void 0;
+}
+function mergeFragments(base, ...frags) {
+  const result = { ...base };
+  for (const frag of frags) {
+    Object.assign(result, frag);
+  }
+  return result;
+}
+
+// src/compiler/schema/parameters.ts
+function buildPathParameters(operation, ctx, parameters) {
+  for (const paramIndex of operation.pathParamIndices) {
+    const param = operation.parameters[paramIndex];
+    if (param) {
+      let paramSchema = typeToJsonSchema(param.type, ctx);
+      if (param.paramNode) {
+        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
+        if (frags.length > 0) {
+          paramSchema = mergeFragments(paramSchema, ...frags);
+        }
+      }
+      const schema = paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema;
+      const paramName = param.name.toLowerCase();
+      const isIdParam = paramName === "id" || paramName.endsWith("id");
+      if (!schema.$ref && schema.type === "number" && isIdParam) {
+        schema.type = "integer";
+        if (!schema.minimum) {
+          schema.minimum = 1;
+        }
+      }
+      parameters.push({
+        name: param.name,
+        in: "path",
+        required: !param.isOptional,
+        schema
+      });
+    }
+  }
+}
+function buildQueryParameters(operation, ctx, parameters) {
+  if (operation.queryObjectParamIndex !== null) {
+    const queryParam = operation.parameters[operation.queryObjectParamIndex];
+    if (!queryParam) return;
+    const querySchema = typeToJsonSchema(queryParam.type, ctx);
+    const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps(querySchema, ctx.components);
+    for (const [propName, propSchema] of Object.entries(queryObjProps)) {
+      const isRequired = queryRequired.includes(propName);
+      const isObjectLike = isObjectLikeSchema(propSchema, ctx);
+      const serialization = determineQuerySerialization(propSchema.type);
+      const exampleValue = generateExampleValue(propSchema, propName);
+      if (isObjectLike) {
+        const schemaRef = propSchema.$ref || "#/components/schemas/InlineQueryParam";
+        parameters.push({
+          name: propName,
+          in: "query",
+          required: isRequired,
+          schema: { type: "string" },
+          description: `JSON-encoded object. ${exampleValue}`,
+          examples: {
+            default: { value: parseExampleValue(exampleValue) }
+          },
+          "x-adorn-jsonSchemaRef": schemaRef
+        });
+      } else {
+        const paramDef = {
+          name: propName,
+          in: "query",
+          required: isRequired,
+          schema: propSchema.$ref ? { $ref: propSchema.$ref } : propSchema
+        };
+        if (propName === "page") {
+          paramDef.schema = { type: "integer", default: 1, minimum: 1 };
+        } else if (propName === "pageSize") {
+          paramDef.schema = { type: "integer", default: 10, minimum: 1 };
+        } else if (propName === "totalItems") {
+          paramDef.schema = { type: "integer", minimum: 0 };
+        } else if (propName === "sort") {
+          paramDef.schema = {
+            oneOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          };
+        } else if (propName === "q") {
+          paramDef.schema = { type: "string" };
+        } else if (propName === "hasComments") {
+          paramDef.schema = { type: "boolean" };
+        }
+        if (Object.keys(serialization).length > 0) {
+          Object.assign(paramDef, serialization);
+        }
+        parameters.push(paramDef);
+      }
+    }
+  }
+  for (const paramIndex of operation.queryParamIndices) {
+    const param = operation.parameters[paramIndex];
+    if (param) {
+      let paramSchema = typeToJsonSchema(param.type, ctx);
+      if (param.paramNode) {
+        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
+        if (frags.length > 0) {
+          paramSchema = mergeFragments(paramSchema, ...frags);
+        }
+      }
+      const isObjectLike = isObjectLikeSchema(paramSchema, ctx);
+      if (isObjectLike) {
+        const schemaRef = paramSchema.$ref || "#/components/schemas/InlineQueryParam";
+        const exampleValue = generateExampleValue(paramSchema, param.name);
+        parameters.push({
+          name: param.name,
+          in: "query",
+          required: !param.isOptional,
+          schema: { type: "string" },
+          description: `JSON-encoded object. ${exampleValue}`,
+          examples: {
+            default: { value: parseExampleValue(exampleValue) }
+          },
+          "x-adorn-jsonSchemaRef": schemaRef
+        });
+      } else {
+        const serialization = determineQuerySerialization(paramSchema.type);
+        parameters.push({
+          name: param.name,
+          in: "query",
+          required: !param.isOptional,
+          schema: paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema,
+          ...Object.keys(serialization).length > 0 ? serialization : {}
+        });
+      }
+    }
+  }
+}
+function buildHeaderParameters(operation, ctx, parameters) {
+  if (operation.headerObjectParamIndex === null) return;
+  const headerParam = operation.parameters[operation.headerObjectParamIndex];
+  if (!headerParam) return;
+  const headerSchema = typeToJsonSchema(headerParam.type, ctx);
+  if (!headerSchema.properties) return;
+  const headerObjProps = headerSchema.properties;
+  for (const [propName, propSchema] of Object.entries(headerObjProps)) {
+    const isRequired = headerSchema.required?.includes(propName) ?? false;
+    parameters.push({
+      name: propName,
+      in: "header",
+      required: isRequired,
+      schema: propSchema
+    });
+  }
 }
-function isStringLiteral(node) {
-  return !!node && ts4.isStringLiteral(node);
+function buildCookieParameters(operation, ctx, parameters) {
+  if (operation.cookieObjectParamIndex === null) return;
+  const cookieParam = operation.parameters[operation.cookieObjectParamIndex];
+  if (!cookieParam) return;
+  const cookieSchema = typeToJsonSchema(cookieParam.type, ctx);
+  if (!cookieSchema.properties) return;
+  const cookieObjProps = cookieSchema.properties;
+  for (const [propName, propSchema] of Object.entries(cookieObjProps)) {
+    const isRequired = cookieSchema.required?.includes(propName) ?? false;
+    parameters.push({
+      name: propName,
+      in: "cookie",
+      required: isRequired,
+      schema: propSchema,
+      style: "form",
+      explode: true
+    });
+  }
 }
-function extractRegexPattern(text) {
-  const match = text.match(/^\/(.+)\/[gimsuy]*$/);
-  return match ? match[1] : text;
+function determineQuerySerialization(schemaType) {
+  const typeArray = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
+  const isArray = typeArray.includes("array");
+  if (isArray) {
+    return { style: "form", explode: true };
+  }
+  return {};
 }
-function objectLiteralToJson(obj) {
-  const out = {};
-  for (const prop of obj.properties) {
-    if (!ts4.isPropertyAssignment(prop)) continue;
-    const name = prop.name;
-    let key;
-    if (ts4.isIdentifier(name)) {
-      key = name.text;
-    } else if (ts4.isStringLiteral(name)) {
-      key = name.text;
-    } else {
-      continue;
+function generateExampleValue(schema, propName) {
+  const resolved = resolveSchemaRef(schema, /* @__PURE__ */ new Map());
+  if (resolved.type === "object" && resolved.properties) {
+    const example = {};
+    for (const [key, prop] of Object.entries(resolved.properties)) {
+      const propResolved = resolveSchemaRef(prop, /* @__PURE__ */ new Map());
+      if (propResolved.type === "string") {
+        example[key] = "value";
+      } else if (propResolved.type === "number" || propResolved.type === "integer") {
+        example[key] = 1;
+      } else if (propResolved.type === "boolean") {
+        example[key] = true;
+      } else if (Array.isArray(propResolved.type) && propResolved.type.includes("null")) {
+        example[key] = null;
+      } else if (propResolved.enum) {
+        example[key] = propResolved.enum[0];
+      } else {
+        example[key] = "value";
+      }
     }
-    out[key] = literalToJson(prop.initializer);
+    return `Example: ${propName}=${JSON.stringify(example)}`;
   }
-  return out;
-}
-function literalToJson(node) {
-  if (ts4.isStringLiteral(node)) return node.text;
-  if (ts4.isNumericLiteral(node)) return Number(node.text);
-  if (node.kind === ts4.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === ts4.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === ts4.SyntaxKind.NullKeyword) return null;
-  if (ts4.isObjectLiteralExpression(node)) return objectLiteralToJson(node);
-  if (ts4.isArrayLiteralExpression(node)) return node.elements.map((e) => literalToJson(e));
-  return void 0;
+  return `Example: ${propName}=${JSON.stringify({ key: "value" })}`;
 }
-function mergeFragments(base, ...frags) {
-  const result = { ...base };
-  for (const frag of frags) {
-    Object.assign(result, frag);
+function parseExampleValue(description) {
+  const match = description.match(/Example:\s*\w+=(\{[^}]+\})/);
+  if (match) {
+    return match[1];
   }
-  return result;
+  return JSON.stringify({ key: "value" });
 }
-
-// src/compiler/analyze/extractQueryStyle.ts
-import ts5 from "typescript";
-function extractQueryStyleOptions(checker, method) {
-  if (!ts5.canHaveDecorators(method)) return null;
-  const decorators = ts5.getDecorators(method);
-  if (!decorators || decorators.length === 0) return null;
-  for (const decorator of decorators) {
-    const expr = decorator.expression;
-    const isCall = ts5.isCallExpression(expr);
-    const callee = isCall ? expr.expression : expr;
-    const args = isCall ? expr.arguments : ts5.factory.createNodeArray([]);
-    const sym = checker.getSymbolAtLocation(callee);
-    if (!sym) continue;
-    const resolved = sym.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
-    const name = resolved.getName();
-    if (name !== "QueryStyle") continue;
-    const optsNode = args[0];
-    if (!optsNode || !ts5.isObjectLiteralExpression(optsNode)) {
-      return {};
+function isObjectLikeSchema(schema, ctx) {
+  const resolved = resolveSchemaRef(schema, ctx.components);
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isObjectLikeSchema(branch, ctx)) {
+        return true;
+      }
     }
-    return parseQueryStyleOptions(optsNode);
   }
-  return null;
+  if (resolved.type === "array" && resolved.items) {
+    const itemsSchema = resolveSchemaRef(resolved.items, ctx.components);
+    return isObjectLikeSchema(itemsSchema, ctx);
+  }
+  return false;
 }
-function parseQueryStyleOptions(node) {
-  const opts = {};
-  for (const prop of node.properties) {
-    if (!ts5.isPropertyAssignment(prop)) continue;
-    const name = getPropName(prop.name);
-    if (!name) continue;
-    if (name === "style" && ts5.isStringLiteral(prop.initializer)) {
-      const style = prop.initializer.text;
-      opts.style = style;
-    } else if (name === "explode" && isBooleanLiteral(prop.initializer)) {
-      opts.explode = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
-    } else if (name === "allowReserved" && isBooleanLiteral(prop.initializer)) {
-      opts.allowReserved = prop.initializer.kind === ts5.SyntaxKind.TrueKeyword;
-    }
-  }
-  return opts;
-}
-function getPropName(name) {
-  if (ts5.isIdentifier(name)) return name.text;
-  if (ts5.isStringLiteral(name)) return name.text;
-  return null;
+function resolveSchemaRef(schema, components) {
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/components/schemas/")) {
+    return schema;
+  }
+  const name = ref.replace("#/components/schemas/", "");
+  const next = components.get(name);
+  if (!next) return schema;
+  return resolveSchemaRef(next, components);
 }
-function isBooleanLiteral(node) {
-  return node.kind === ts5.SyntaxKind.TrueKeyword || node.kind === ts5.SyntaxKind.FalseKeyword;
+function resolveAndCollectObjectProps(schema, components) {
+  const resolved = resolveSchemaRef(schema, components);
+  const properties = {};
+  const required = [];
+  const processSchema = (s) => {
+    const current = resolveSchemaRef(s, components);
+    if (current.properties) {
+      for (const [key, val] of Object.entries(current.properties)) {
+        if (!properties[key]) {
+          properties[key] = val;
+        }
+      }
+    }
+    if (current.required) {
+      for (const req of current.required) {
+        if (!required.includes(req)) {
+          required.push(req);
+        }
+      }
+    }
+    if (current.allOf) {
+      for (const branch of current.allOf) {
+        processSchema(branch);
+      }
+    }
+  };
+  processSchema(resolved);
+  return { properties, required };
 }
 
 // src/compiler/schema/openapi.ts
+var METAL_ORM_WRAPPER_NAMES2 = ["BelongsToReference", "HasOneReference", "HasManyCollection", "ManyToManyCollection"];
 function generateOpenAPI(controllers, checker, options = {}) {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
     checker,
     components,
     typeStack: /* @__PURE__ */ new Set(),
-    typeNameStack: []
+    typeNameStack: [],
+    mode: "response"
   };
   const paths = {};
   for (const controller of controllers) {
@@ -901,6 +1423,8 @@ function generateOpenAPI(controllers, checker, options = {}) {
       paths[fullPath][method] = buildOperation(operation, ctx, controller.consumes);
     }
   }
+  const schemas = Object.fromEntries(components);
+  cleanupMetalOrmWrappers(schemas, paths);
   return {
     openapi: "3.1.0",
     info: {
@@ -908,15 +1432,120 @@ function generateOpenAPI(controllers, checker, options = {}) {
       version: options.version ?? "1.0.0"
     },
     components: {
-      schemas: Object.fromEntries(components)
+      schemas
     },
     paths
   };
 }
+function cleanupMetalOrmWrappers(schemas, paths) {
+  const schemasToDelete = /* @__PURE__ */ new Set();
+  for (const wrapperName of METAL_ORM_WRAPPER_NAMES2) {
+    if (schemas[wrapperName]) {
+      schemasToDelete.add(wrapperName);
+    }
+    if (schemas[`${wrapperName}Api`]) {
+      schemasToDelete.add(`${wrapperName}Api`);
+    }
+  }
+  for (const schema of Object.values(schemas)) {
+    cleanupSchemaRefs(schema, schemasToDelete);
+  }
+  for (const pathItem of Object.values(paths)) {
+    cleanupPathItemRefs(pathItem, schemasToDelete);
+  }
+  for (const schemaName of schemasToDelete) {
+    delete schemas[schemaName];
+  }
+}
+function cleanupSchemaRefs(schema, schemasToDelete) {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  if (schema.properties) {
+    for (const propName of Object.keys(schema.properties)) {
+      const propSchema = schema.properties[propName];
+      if (propSchema.$ref && typeof propSchema.$ref === "string") {
+        const refName = propSchema.$ref.replace("#/components/schemas/", "");
+        if (schemasToDelete.has(refName)) {
+          delete schema.properties[propName];
+          if (schema.required && Array.isArray(schema.required)) {
+            schema.required = schema.required.filter((r) => r !== propName);
+          }
+        }
+      } else {
+        cleanupSchemaRefs(propSchema, schemasToDelete);
+      }
+    }
+  }
+  if (schema.items) {
+    cleanupSchemaRefs(schema.items, schemasToDelete);
+  }
+  if (schema.allOf) {
+    for (const item of schema.allOf) {
+      cleanupSchemaRefs(item, schemasToDelete);
+    }
+  }
+}
+function cleanupPathItemRefs(pathItem, schemasToDelete) {
+  if (typeof pathItem !== "object" || pathItem === null) {
+    return;
+  }
+  for (const method of Object.keys(pathItem)) {
+    const operation = pathItem[method];
+    if (typeof operation !== "object" || operation === null) continue;
+    if (operation.requestBody) {
+      cleanupRequestBodyRefs(operation.requestBody, schemasToDelete);
+    }
+    if (operation.responses) {
+      const responses = Object.values(operation.responses);
+      for (const response of responses) {
+        if (response.content) {
+          const contentTypes = Object.values(response.content);
+          for (const contentType of contentTypes) {
+            if (contentType.schema) {
+              cleanupSchemaRefs(contentType.schema, schemasToDelete);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function cleanupRequestBodyRefs(requestBody, schemasToDelete) {
+  if (typeof requestBody !== "object" || requestBody === null) return;
+  if (requestBody.content) {
+    const contentTypes = Object.values(requestBody.content);
+    for (const contentType of contentTypes) {
+      if (contentType.schema) {
+        cleanupSchemaRefs(contentType.schema, schemasToDelete);
+      }
+    }
+  }
+  if (requestBody.properties) {
+    for (const propName of Object.keys(requestBody.properties)) {
+      const propSchema = requestBody.properties[propName];
+      if (propSchema.$ref && typeof propSchema.$ref === "string") {
+        const refName = propSchema.$ref.replace("#/components/schemas/", "");
+        if (schemasToDelete.has(refName)) {
+          delete requestBody.properties[propName];
+          if (requestBody.required && Array.isArray(requestBody.required)) {
+            requestBody.required = requestBody.required.filter((r) => r !== propName);
+          }
+        }
+      } else {
+        cleanupSchemaRefs(propSchema, schemasToDelete);
+      }
+    }
+  }
+}
 function convertToOpenApiPath(basePath, path4) {
   const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
   const converted = path4.replace(/:([^/]+)/g, "{$1}");
-  return base + converted || "/";
+  let fullPath = base + converted || "/";
+  if (fullPath.endsWith("/") && fullPath !== "/") {
+    fullPath = fullPath.slice(0, -1);
+  }
+  return fullPath;
 }
 function buildOperation(operation, ctx, controllerConsumes) {
   const op = {
@@ -931,7 +1560,8 @@ function buildOperation(operation, ctx, controllerConsumes) {
   if (parameters.length > 0) {
     op.parameters = parameters;
   }
-  const responseSchema = typeToJsonSchema(operation.returnType, ctx, operation.returnTypeNode);
+  const responseCtx = { ...ctx, mode: "response" };
+  const responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
   const status = operation.httpMethod === "POST" ? 201 : 200;
   op.responses[status] = {
     description: status === 201 ? "Created" : "OK",
@@ -944,8 +1574,9 @@ function buildOperation(operation, ctx, controllerConsumes) {
   if (["POST", "PUT", "PATCH"].includes(operation.httpMethod) && operation.bodyParamIndex !== null) {
     const bodyParam = operation.parameters[operation.bodyParamIndex];
     if (bodyParam) {
-      let bodySchema = typeToJsonSchema(bodyParam.type, ctx);
-      bodySchema = mergeBodySchemaAnnotations(bodyParam, ctx, bodySchema);
+      const requestCtx = { ...ctx, mode: "request" };
+      let bodySchema = typeToJsonSchema(bodyParam.type, requestCtx);
+      bodySchema = mergeBodySchemaAnnotations(bodyParam, requestCtx, bodySchema);
       const contentType = operation.bodyContentType ?? controllerConsumes?.[0] ?? "application/json";
       const requestBody = {
         required: !bodyParam.isOptional,
@@ -972,12 +1603,12 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   const declarations = typeSymbol.getDeclarations();
   if (!declarations || declarations.length === 0) return schema;
   const classDecl = declarations[0];
-  if (!ts6.isClassDeclaration(classDecl)) return schema;
+  if (!ts9.isClassDeclaration(classDecl)) return schema;
   const result = { ...schema };
   const props = { ...result.properties };
   for (const member of classDecl.members) {
-    if (!ts6.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = ts6.isIdentifier(member.name) ? member.name.text : null;
+    if (!ts9.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = ts9.isIdentifier(member.name) ? member.name.text : null;
     if (!propName) continue;
     if (!props[propName]) continue;
     const frags = extractPropertySchemaFragments(ctx.checker, member);
@@ -988,137 +1619,17 @@ function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
   result.properties = props;
   return result;
 }
-function buildPathParameters(operation, ctx, parameters) {
-  for (const paramIndex of operation.pathParamIndices) {
-    const param = operation.parameters[paramIndex];
-    if (param) {
-      let paramSchema = typeToJsonSchema(param.type, ctx);
-      if (param.paramNode) {
-        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
-        if (frags.length > 0) {
-          paramSchema = mergeFragments(paramSchema, ...frags);
-        }
-      }
-      parameters.push({
-        name: param.name,
-        in: "path",
-        required: !param.isOptional,
-        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema
-      });
-    }
-  }
-}
-function buildQueryParameters(operation, ctx, parameters) {
-  if (operation.queryObjectParamIndex !== null) {
-    const queryParam = operation.parameters[operation.queryObjectParamIndex];
-    if (!queryParam) return;
-    const queryStyle = extractQueryStyleOptions(ctx.checker, operation.methodDeclaration);
-    const querySchema = typeToJsonSchema(queryParam.type, ctx);
-    if (queryStyle?.style === "deepObject") {
-      const explode = queryStyle.explode ?? true;
-      const deepParam = {
-        name: queryParam.name,
-        in: "query",
-        required: !queryParam.isOptional,
-        schema: querySchema.$ref ? { $ref: querySchema.$ref } : querySchema,
-        style: "deepObject",
-        explode
-      };
-      if (queryStyle.allowReserved !== void 0) {
-        deepParam.allowReserved = queryStyle.allowReserved;
-      }
-      parameters.push(deepParam);
-    } else {
-      if (!querySchema.properties) return;
-      const queryObjProps = querySchema.properties;
-      for (const [propName, propSchema] of Object.entries(queryObjProps)) {
-        const isRequired = querySchema.required?.includes(propName) ?? false;
-        const serialization = determineQuerySerialization(propSchema.type);
-        parameters.push({
-          name: propName,
-          in: "query",
-          required: isRequired,
-          schema: propSchema,
-          ...Object.keys(serialization).length > 0 ? serialization : {}
-        });
-      }
-    }
-  }
-  for (const paramIndex of operation.queryParamIndices) {
-    const param = operation.parameters[paramIndex];
-    if (param) {
-      let paramSchema = typeToJsonSchema(param.type, ctx);
-      if (param.paramNode) {
-        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
-        if (frags.length > 0) {
-          paramSchema = mergeFragments(paramSchema, ...frags);
-        }
-      }
-      const serialization = determineQuerySerialization(paramSchema.type);
-      parameters.push({
-        name: param.name,
-        in: "query",
-        required: !param.isOptional,
-        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema,
-        ...Object.keys(serialization).length > 0 ? serialization : {}
-      });
-    }
-  }
-}
-function determineQuerySerialization(schemaType) {
-  const typeArray = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
-  const isArray = typeArray.includes("array");
-  if (isArray) {
-    return { style: "form", explode: true };
-  }
-  return {};
-}
-function buildHeaderParameters(operation, ctx, parameters) {
-  if (operation.headerObjectParamIndex === null) return;
-  const headerParam = operation.parameters[operation.headerObjectParamIndex];
-  if (!headerParam) return;
-  const headerSchema = typeToJsonSchema(headerParam.type, ctx);
-  if (!headerSchema.properties) return;
-  const headerObjProps = headerSchema.properties;
-  for (const [propName, propSchema] of Object.entries(headerObjProps)) {
-    const isRequired = headerSchema.required?.includes(propName) ?? false;
-    parameters.push({
-      name: propName,
-      in: "header",
-      required: isRequired,
-      schema: propSchema
-    });
-  }
-}
-function buildCookieParameters(operation, ctx, parameters) {
-  if (operation.cookieObjectParamIndex === null) return;
-  const cookieParam = operation.parameters[operation.cookieObjectParamIndex];
-  if (!cookieParam) return;
-  const cookieSchema = typeToJsonSchema(cookieParam.type, ctx);
-  if (!cookieSchema.properties) return;
-  const cookieObjProps = cookieSchema.properties;
-  for (const [propName, propSchema] of Object.entries(cookieObjProps)) {
-    const isRequired = cookieSchema.required?.includes(propName) ?? false;
-    parameters.push({
-      name: propName,
-      in: "cookie",
-      required: isRequired,
-      schema: propSchema,
-      style: "form",
-      explode: true
-    });
-  }
-}
 
 // src/compiler/manifest/emit.ts
-import ts7 from "typescript";
+import ts10 from "typescript";
 function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
     checker,
     components,
     typeStack: /* @__PURE__ */ new Set(),
-    typeNameStack: []
+    typeNameStack: [],
+    mode: "request"
   };
   const controllerEntries = controllers.map((ctrl) => ({
     controllerId: ctrl.className,
@@ -1132,7 +1643,7 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     generator: {
       name: "adorn-api",
       version,
-      typescript: ts7.version
+      typescript: ts10.version
     },
     schemas: {
       kind: "openapi-3.1",
@@ -1143,14 +1654,70 @@ function generateManifest(controllers, checker, version, validationMode = "ajv-r
     controllers: controllerEntries
   };
 }
+function resolveSchemaRef2(schema, components) {
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/components/schemas/")) {
+    return schema;
+  }
+  const name = ref.replace("#/components/schemas/", "");
+  const next = components.get(name);
+  if (!next) return schema;
+  return resolveSchemaRef2(next, components);
+}
+function resolveAndCollectObjectProps2(schema, components) {
+  const resolved = resolveSchemaRef2(schema, components);
+  const properties = {};
+  const required = [];
+  const processSchema = (s) => {
+    const current = resolveSchemaRef2(s, components);
+    if (current.properties) {
+      for (const [key, val] of Object.entries(current.properties)) {
+        if (!properties[key]) {
+          properties[key] = val;
+        }
+      }
+    }
+    if (current.required) {
+      for (const req of current.required) {
+        if (!required.includes(req)) {
+          required.push(req);
+        }
+      }
+    }
+    if (current.allOf) {
+      for (const branch of current.allOf) {
+        processSchema(branch);
+      }
+    }
+  };
+  processSchema(resolved);
+  return { properties, required };
+}
+function isObjectLikeSchema2(schema, components) {
+  const resolved = resolveSchemaRef2(schema, components);
+  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
+    return true;
+  }
+  if (resolved.allOf) {
+    for (const branch of resolved.allOf) {
+      if (isObjectLikeSchema2(branch, components)) {
+        return true;
+      }
+    }
+  }
+  if (resolved.type === "array" && resolved.items) {
+    const itemsSchema = resolveSchemaRef2(resolved.items, components);
+    return isObjectLikeSchema2(itemsSchema, components);
+  }
+  return false;
+}
 function buildOperationEntry(op, ctx) {
   const args = {
     body: null,
     path: [],
     query: [],
     headers: [],
-    cookies: [],
-    paginationParamIndex: op.paginationParamIndex
+    cookies: []
   };
   buildPathArgs(op, ctx, args);
   buildQueryArgs(op, ctx, args);
@@ -1217,53 +1784,39 @@ function buildPathArgs(op, ctx, args) {
 function buildQueryArgs(op, ctx, args) {
   if (op.queryObjectParamIndex !== null) {
     const queryParam = op.parameters[op.queryObjectParamIndex];
-    if (queryParam) {
-      const queryStyle = extractQueryStyleOptions(ctx.checker, op.methodDeclaration);
-      const querySchema = typeToJsonSchema(queryParam.type, ctx);
-      if (queryStyle?.style === "deepObject") {
-        const schemaRef = querySchema.$ref ?? "#/components/schemas/InlineQueryParam";
-        args.query.push({
-          name: queryParam.name,
-          index: queryParam.index,
-          required: !queryParam.isOptional,
-          schemaRef,
-          schemaType: querySchema.type,
-          serialization: {
-            style: "deepObject",
-            explode: queryStyle.explode ?? true,
-            allowReserved: queryStyle.allowReserved
-          }
-        });
-      } else {
-        if (!querySchema.properties) return;
-        for (const [propName, propSchema] of Object.entries(querySchema.properties)) {
-          const isRequired = querySchema.required?.includes(propName) ?? false;
-          let schemaRef = propSchema.$ref;
-          if (!schemaRef) {
-            schemaRef = "#/components/schemas/InlineQueryParam";
-          }
-          args.query.push({
-            name: propName,
-            index: queryParam.index,
-            required: !isRequired,
-            schemaRef,
-            schemaType: propSchema.type
-          });
-        }
+    if (!queryParam) return;
+    const querySchema = typeToJsonSchema(queryParam.type, ctx);
+    const { properties: queryObjProps, required: queryRequired } = resolveAndCollectObjectProps2(querySchema, ctx.components);
+    for (const [propName, propSchema] of Object.entries(queryObjProps)) {
+      const isRequired = queryRequired.includes(propName) ?? false;
+      const isObjectLike = isObjectLikeSchema2(propSchema, ctx.components);
+      let schemaRef = propSchema.$ref;
+      if (!schemaRef) {
+        schemaRef = "#/components/schemas/InlineQueryParam";
       }
+      args.query.push({
+        name: propName,
+        index: queryParam.index,
+        required: isRequired,
+        schemaRef,
+        schemaType: propSchema.type,
+        content: isObjectLike ? "application/json" : void 0
+      });
     }
   }
   for (const paramIndex of op.queryParamIndices) {
     const param = op.parameters[paramIndex];
     if (param) {
       const paramSchema = typeToJsonSchema(param.type, ctx);
+      const isObjectLike = isObjectLikeSchema2(paramSchema, ctx.components);
       const schemaRef = paramSchema.$ref ?? "#/components/schemas/InlineQueryParam";
       args.query.push({
         name: param.name,
         index: param.index,
         required: !param.isOptional,
         schemaRef,
-        schemaType: paramSchema.type
+        schemaType: paramSchema.type,
+        content: isObjectLike ? "application/json" : void 0
       });
     }
   }
@@ -1283,7 +1836,7 @@ function buildHeaderArgs(op, ctx, args) {
     args.headers.push({
       name: propName,
       index: headerParam.index,
-      required: !isRequired,
+      required: isRequired,
       schemaRef,
       schemaType: propSchema.type
     });
@@ -1304,7 +1857,7 @@ function buildCookieArgs(op, ctx, args) {
     args.cookies.push({
       name: propName,
       index: cookieParam.index,
-      required: !isRequired,
+      required: isRequired,
       schemaRef,
       schemaType: propSchema.type,
       serialization: { style: "form", explode: true }
@@ -1320,7 +1873,7 @@ import Ajv from "ajv";
 import addFormats from "ajv-formats";
 var OAS_SCHEMA_ONLY = /* @__PURE__ */ new Set(["discriminator", "xml", "externalDocs", "example"]);
 function sanitizeSchemaForAjv(schema) {
-  if (schema == null || typeof schema !== "object") return schema;
+  if (schema === null || typeof schema !== "object") return schema;
   if (Array.isArray(schema)) return schema.map(sanitizeSchemaForAjv);
   const out = {};
   for (const [k, v] of Object.entries(schema)) {
@@ -1331,7 +1884,7 @@ function sanitizeSchemaForAjv(schema) {
   return out;
 }
 function rewriteComponentRefs(schema) {
-  if (schema == null || typeof schema !== "object") return schema;
+  if (schema === null || typeof schema !== "object") return schema;
   if (Array.isArray(schema)) return schema.map(rewriteComponentRefs);
   if (typeof schema.$ref === "string") {
     const ref = schema.$ref;
@@ -1408,16 +1961,13 @@ async function emitPrecompiledValidators(opts) {
 `;
     cjs += `    body: ${v.body ? `exports[${JSON.stringify(v.body)}]` : "undefined"},
 `;
-    cjs += `    response: {
-`;
+    cjs += "    response: {\n";
     for (const [key, id] of Object.entries(v.response)) {
       cjs += `      ${JSON.stringify(key)}: exports[${JSON.stringify(id)}],
 `;
     }
-    cjs += `    }
-`;
-    cjs += `  },
-`;
+    cjs += "    }\n";
+    cjs += "  },\n";
   }
   cjs += "};\n";
   fs.writeFileSync(cjsPath, cjs, "utf8");
@@ -1452,7 +2002,6 @@ export function validateResponse(operationId, status, contentType, data) {
 // src/compiler/cache/isStale.ts
 import fs2 from "fs";
 import path2 from "path";
-import "typescript";
 function readJson(p) {
   try {
     return JSON.parse(fs2.readFileSync(p, "utf8"));
@@ -1509,7 +2058,7 @@ function findLockfile(startDir) {
     for (const n of names) {
       const p = path2.join(dir, n);
       const mt = statMtimeMs(p);
-      if (mt != null) return { path: p, mtimeMs: mt };
+      if (mt !== null) return { path: p, mtimeMs: mt };
     }
     const parent = path2.dirname(dir);
     if (parent === dir) break;
@@ -1534,22 +2083,22 @@ async function isStale(params) {
   const chain = collectTsconfigChain(tsconfigAbs);
   for (const cfg of chain) {
     const mt = statMtimeMs(cfg);
-    if (mt == null) return { stale: true, reason: "config-missing", detail: cfg };
+    if (mt === null) return { stale: true, reason: "config-missing", detail: cfg };
     const cachedMt = cache.project.configFiles[cfg];
-    if (cachedMt == null || Math.abs(cachedMt - mt) > 1e-4) {
+    if (cachedMt === null || Math.abs(cachedMt - mt) > 1e-4) {
       return { stale: true, reason: "config-updated", detail: cfg };
     }
   }
   if (cache.project.lockfile?.path) {
     const mt = statMtimeMs(cache.project.lockfile.path);
-    if (mt == null) return { stale: true, reason: "lockfile-missing", detail: cache.project.lockfile.path };
+    if (mt === null) return { stale: true, reason: "lockfile-missing", detail: cache.project.lockfile.path };
     if (Math.abs(cache.project.lockfile.mtimeMs - mt) > 1e-4) {
       return { stale: true, reason: "lockfile-updated", detail: cache.project.lockfile.path };
     }
   }
   for (const [file, cachedMt] of Object.entries(cache.inputs)) {
     const mt = statMtimeMs(file);
-    if (mt == null) return { stale: true, reason: "input-missing", detail: file };
+    if (mt === null) return { stale: true, reason: "input-missing", detail: file };
     if (Math.abs(cachedMt - mt) > 1e-4) return { stale: true, reason: "input-updated", detail: file };
   }
   return { stale: false, reason: "up-to-date" };
@@ -1558,7 +2107,7 @@ async function isStale(params) {
 // src/compiler/cache/writeCache.ts
 import fs3 from "fs";
 import path3 from "path";
-import ts9 from "typescript";
+import ts11 from "typescript";
 function statMtimeMs2(p) {
   return fs3.statSync(p).mtimeMs;
 }
@@ -1591,7 +2140,7 @@ function writeCache(params) {
     generator: {
       name: "adorn-api",
       version: params.adornVersion,
-      typescript: ts9.version
+      typescript: ts11.version
     },
     project: {
       tsconfigPath: params.tsconfigAbs,
@@ -1604,7 +2153,7 @@ function writeCache(params) {
 }
 
 // src/cli.ts
-import ts10 from "typescript";
+import ts12 from "typescript";
 import process from "process";
 var ADORN_VERSION = "0.1.0";
 function log(msg) {
@@ -1615,6 +2164,26 @@ function debug(...args) {
     console.error("[adorn-api]", ...args);
   }
 }
+function sanitizeForJson(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sanitizeForJson(item));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("__@") || key.startsWith("[")) continue;
+    if (typeof value === "function") continue;
+    if (value !== null && typeof value === "object") {
+      const typeName = value.constructor?.name;
+      if (typeName && !["Object", "Array", "String", "Number", "Boolean", "Date", "RegExp"].includes(typeName)) {
+        continue;
+      }
+    }
+    result[key] = sanitizeForJson(value);
+  }
+  return result;
+}
 async function buildCommand(args) {
   const projectIndex = args.indexOf("-p");
   const projectPath = projectIndex !== -1 ? args[projectIndex + 1] : "./tsconfig.json";
@@ -1632,7 +2201,7 @@ async function buildCommand(args) {
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts10.version
+      typescriptVersion: ts12.version
     });
     if (!stale.stale) {
       log("adorn-api: artifacts up-to-date");
@@ -1653,7 +2222,7 @@ async function buildCommand(args) {
   const openapi = generateOpenAPI(controllers, checker, { title: "API", version: "1.0.0" });
   const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
   mkdirSync(outputPath, { recursive: true });
-  writeFileSync(resolve2(outputPath, "openapi.json"), JSON.stringify(openapi, null, 2));
+  writeFileSync(resolve2(outputPath, "openapi.json"), JSON.stringify(sanitizeForJson(openapi), null, 2));
   writeFileSync(resolve2(outputPath, "manifest.json"), JSON.stringify(manifest, null, 2));
   if (validationMode === "precompiled") {
     log("Generating precompiled validators...");