adorn-api 1.0.23 → 1.0.24

package/dist/cli.cjs

@@ -1,4622 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
-var import_node_url = require("url");
-
-// src/compiler/runner/createProgram.ts
-var import_typescript = __toESM(require("typescript"), 1);
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-function createProgramFromConfig(tsconfigPath) {
-  const absolutePath = (0, import_node_path.resolve)(tsconfigPath);
-  const configDir = (0, import_node_path.dirname)(absolutePath);
-  const configFile = import_typescript.default.readConfigFile(absolutePath, (path4) => (0, import_node_fs.readFileSync)(path4, "utf-8"));
-  if (configFile.error) {
-    throw new Error(`Failed to read tsconfig: ${import_typescript.default.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
-  }
-  const parsed = import_typescript.default.parseJsonConfigFileContent(configFile.config, import_typescript.default.sys, configDir);
-  if (parsed.errors.length > 0) {
-    const messages = parsed.errors.map((e) => import_typescript.default.flattenDiagnosticMessageText(e.messageText, "\n"));
-    throw new Error(`Failed to parse tsconfig:
-${messages.join("\n")}`);
-  }
-  const program = import_typescript.default.createProgram(parsed.fileNames, parsed.options);
-  const checker = program.getTypeChecker();
-  const sourceFiles = program.getSourceFiles().filter(
-    (sf) => !sf.isDeclarationFile && !sf.fileName.includes("node_modules")
-  );
-  return { program, checker, sourceFiles };
-}
-
-// src/compiler/analyze/scanControllers.ts
-var import_typescript2 = __toESM(require("typescript"), 1);
-
-// src/utils/operationId.ts
-function defaultOperationId(controllerName, methodName) {
-  return `${controllerName}_${methodName}`;
-}
-
-// src/compiler/analyze/scanControllers.ts
-function scanControllers(sourceFiles, checker) {
-  const controllers = [];
-  for (const sourceFile of sourceFiles) {
-    import_typescript2.default.forEachChild(sourceFile, (node) => {
-      if (import_typescript2.default.isClassDeclaration(node) && node.name) {
-        const controller = analyzeClass(node, sourceFile, checker);
-        if (controller) {
-          controllers.push(controller);
-        }
-      }
-    });
-  }
-  return controllers;
-}
-function analyzeClass(node, sourceFile, checker) {
-  if (!node.name) return null;
-  const controllerDecorator = findDecorator(node, "Controller");
-  if (!controllerDecorator) return null;
-  const basePath = extractDecoratorStringArg(controllerDecorator) ?? "/";
-  const className = node.name.text;
-  const consumes = extractClassConsumes(node, checker);
-  const produces = extractClassProduces(node, checker);
-  const operations = [];
-  for (const member of node.members) {
-    if (import_typescript2.default.isMethodDeclaration(member) && member.name) {
-      const operation = analyzeMethod(member, className, checker);
-      if (operation) {
-        operations.push(operation);
-      }
-    }
-  }
-  if (operations.length === 0) return null;
-  return {
-    className,
-    basePath,
-    sourceFile,
-    classDeclaration: node,
-    operations,
-    consumes,
-    produces
-  };
-}
-function extractClassConsumes(node, _checker) {
-  const decorator = findDecorator(node, "Consumes");
-  if (!decorator) return void 0;
-  const callExpr = decorator.expression;
-  if (!import_typescript2.default.isCallExpression(callExpr)) return void 0;
-  const args = callExpr.arguments;
-  if (args.length === 0) return void 0;
-  const firstArg = args[0];
-  if (import_typescript2.default.isStringLiteral(firstArg)) {
-    return [firstArg.text];
-  }
-  if (import_typescript2.default.isArrayLiteralExpression(firstArg)) {
-    return firstArg.elements.filter(import_typescript2.default.isStringLiteral).map((e) => e.text);
-  }
-  return void 0;
-}
-function extractClassProduces(node, _checker) {
-  const decorator = findDecorator(node, "Produces");
-  if (!decorator) return void 0;
-  const callExpr = decorator.expression;
-  if (!import_typescript2.default.isCallExpression(callExpr)) return void 0;
-  const args = callExpr.arguments;
-  if (args.length === 0) return void 0;
-  const firstArg = args[0];
-  if (import_typescript2.default.isStringLiteral(firstArg)) {
-    return [firstArg.text];
-  }
-  if (import_typescript2.default.isArrayLiteralExpression(firstArg)) {
-    return firstArg.elements.filter(import_typescript2.default.isStringLiteral).map((e) => e.text);
-  }
-  return void 0;
-}
-function analyzeMethod(node, className, checker) {
-  const methodName = import_typescript2.default.isIdentifier(node.name) ? node.name.text : null;
-  if (!methodName) return null;
-  const httpMethods = ["Get", "Post", "Put", "Patch", "Delete"];
-  let httpMethod = null;
-  let path4 = "/";
-  for (const method of httpMethods) {
-    const decorator = findDecorator(node, method);
-    if (decorator) {
-      httpMethod = method.toUpperCase();
-      path4 = extractDecoratorStringArg(decorator) ?? "/";
-      break;
-    }
-  }
-  if (!httpMethod) return null;
-  const signature = checker.getSignatureFromDeclaration(node);
-  if (!signature) return null;
-  let returnType = checker.getReturnTypeOfSignature(signature);
-  returnType = unwrapPromise(returnType, checker);
-  const returnTypeNode = unwrapPromiseTypeNode(node.type);
-  const parameters = [];
-  for (let i = 0; i < node.parameters.length; i++) {
-    const param = node.parameters[i];
-    const paramName = import_typescript2.default.isIdentifier(param.name) ? param.name.text : `arg${i}`;
-    const paramType = checker.getTypeAtLocation(param);
-    const isOptional = !!param.questionToken || !!param.initializer;
-    parameters.push({
-      name: paramName,
-      index: i,
-      type: paramType,
-      isOptional,
-      paramNode: param
-    });
-  }
-  const pathParamNames = extractPathParams(path4);
-  const pathParamIndices = matchPathParamsToIndices(pathParamNames, parameters);
-  const { bodyParamIndex, queryParamIndices, queryObjectParamIndex, headerObjectParamIndex, cookieObjectParamIndex, bodyContentType } = classifyParameters(parameters, httpMethod, pathParamIndices, checker);
-  return {
-    methodName,
-    httpMethod,
-    path: path4,
-    operationId: defaultOperationId(className, methodName),
-    methodDeclaration: node,
-    returnType,
-    returnTypeNode,
-    parameters,
-    pathParamIndices,
-    bodyParamIndex,
-    queryParamIndices,
-    queryObjectParamIndex,
-    headerObjectParamIndex,
-    cookieObjectParamIndex,
-    bodyContentType
-  };
-}
-function extractPathParams(path4) {
-  const matches = path4.match(/:([^/]+)/g);
-  if (!matches) return [];
-  return matches.map((m) => m.slice(1));
-}
-function matchPathParamsToIndices(pathParamNames, parameters) {
-  const indices = [];
-  for (const name of pathParamNames) {
-    const param = parameters.find((p) => p.name === name);
-    if (param) {
-      indices.push(param.index);
-    }
-  }
-  return indices;
-}
-function classifyParameters(parameters, httpMethod, pathParamIndices, checker) {
-  const usedIndices = new Set(pathParamIndices);
-  const queryParamIndices = [];
-  let bodyParamIndex = null;
-  let queryObjectParamIndex = null;
-  let headerObjectParamIndex = null;
-  let cookieObjectParamIndex = null;
-  const isBodyMethod = ["POST", "PUT", "PATCH"].includes(httpMethod);
-  for (let i = 0; i < parameters.length; i++) {
-    const param = parameters[i];
-    if (usedIndices.has(i)) continue;
-    const nonNullableType = checker.getNonNullableType(param.type);
-    const typeStr = getTypeName(param.type) || getTypeName(nonNullableType);
-    if (typeStr === "Body") {
-      bodyParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    if (typeStr === "Query") {
-      queryObjectParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    if (typeStr === "Headers") {
-      headerObjectParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    if (typeStr === "Cookies") {
-      cookieObjectParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    if (isBodyMethod && bodyParamIndex === null) {
-      bodyParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    const isObj = isObjectType(nonNullableType, checker);
-    if (isObj && queryObjectParamIndex === null && !isBodyMethod) {
-      queryObjectParamIndex = i;
-      usedIndices.add(i);
-      continue;
-    }
-    queryParamIndices.push(i);
-    usedIndices.add(i);
-  }
-  return {
-    bodyParamIndex,
-    queryParamIndices,
-    queryObjectParamIndex,
-    headerObjectParamIndex,
-    cookieObjectParamIndex,
-    bodyContentType: void 0
-  };
-}
-function isObjectType(type, checker) {
-  const objectFlags = (type.flags & import_typescript2.default.TypeFlags.Object) !== 0;
-  const intersectionFlags = (type.flags & import_typescript2.default.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 callSigs = type.getCallSignatures?.();
-  if (callSigs && callSigs.length > 0) return false;
-  return true;
-}
-function getTypeName(type) {
-  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
-  if (aliasSymbol) return aliasSymbol.getName();
-  const symbol = type.getSymbol();
-  return symbol?.getName() ?? "";
-}
-function findDecorator(node, name) {
-  const decorators = import_typescript2.default.getDecorators(node);
-  if (!decorators) return null;
-  for (const decorator of decorators) {
-    if (import_typescript2.default.isCallExpression(decorator.expression)) {
-      const expr = decorator.expression.expression;
-      if (import_typescript2.default.isIdentifier(expr) && expr.text === name) {
-        return decorator;
-      }
-    }
-  }
-  return null;
-}
-function extractDecoratorStringArg(decorator) {
-  if (import_typescript2.default.isCallExpression(decorator.expression)) {
-    const arg = decorator.expression.arguments[0];
-    if (arg && import_typescript2.default.isStringLiteral(arg)) {
-      return arg.text;
-    }
-  }
-  return null;
-}
-function unwrapPromise(type, _checker) {
-  const symbol = type.getSymbol();
-  if (symbol?.getName() === "Promise") {
-    const typeArgs = type.typeArguments;
-    if (typeArgs && typeArgs.length > 0) {
-      return typeArgs[0];
-    }
-  }
-  return type;
-}
-function unwrapPromiseTypeNode(typeNode) {
-  if (!typeNode) return void 0;
-  if (import_typescript2.default.isTypeReferenceNode(typeNode)) {
-    if (import_typescript2.default.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise") {
-      return typeNode.typeArguments?.[0] ?? typeNode;
-    }
-  }
-  return typeNode;
-}
-
-// src/compiler/schema/openapi.ts
-var import_typescript12 = __toESM(require("typescript"), 1);
-
-// src/compiler/schema/typeToJsonSchema.ts
-var import_typescript7 = __toESM(require("typescript"), 1);
-
-// src/compiler/schema/primitives.ts
-var import_typescript3 = __toESM(require("typescript"), 1);
-function handlePrimitiveType(type, ctx, typeNode) {
-  const { checker, propertyName } = ctx;
-  if (type.flags & import_typescript3.default.TypeFlags.Undefined) {
-    return {};
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.Null) {
-    return { type: "null" };
-  }
-  if (isDateType(type, checker)) {
-    return { type: "string", format: "date-time" };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.String) {
-    return { type: "string" };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.Number) {
-    return normalizeNumericType(type, checker, typeNode, propertyName);
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.Boolean) {
-    return { type: "boolean" };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.BigInt) {
-    return {
-      type: "string",
-      format: "int64",
-      pattern: "^-?\\d+$"
-    };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.StringLiteral) {
-    const value = type.value;
-    return { type: "string", enum: [value] };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.NumberLiteral) {
-    const value = type.value;
-    return { type: "number", enum: [value] };
-  }
-  if (type.flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
-    const intrinsic = type.intrinsicName;
-    return { type: "boolean", enum: [intrinsic === "true"] };
-  }
-  return null;
-}
-function isDateType(type, checker) {
-  const symbol = type.getSymbol();
-  const aliasSymbol = type.aliasSymbol;
-  if (aliasSymbol && aliasSymbol.flags & import_typescript3.default.SymbolFlags.Alias) {
-    const aliased = checker.getAliasedSymbol(aliasSymbol);
-    return aliased?.getName() === "Date";
-  }
-  if (symbol && symbol.flags & import_typescript3.default.SymbolFlags.Alias) {
-    const aliased = checker.getAliasedSymbol(symbol);
-    return aliased?.getName() === "Date";
-  }
-  return symbol?.getName() === "Date";
-}
-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" };
-  }
-  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 (import_typescript3.default.isTypeReferenceNode(typeNode)) {
-    if (import_typescript3.default.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.text;
-    }
-  }
-  if (import_typescript3.default.isTypeAliasDeclaration(typeNode.parent)) {
-    if (import_typescript3.default.isIdentifier(typeNode.parent.name)) {
-      return typeNode.parent.name.text;
-    }
-  }
-  return null;
-}
-function getEffectiveSymbol(type, checker) {
-  const aliasSymbol = type.aliasSymbol ?? type.aliasSymbol;
-  if (aliasSymbol && aliasSymbol.flags & import_typescript3.default.SymbolFlags.Alias) {
-    return checker.getAliasedSymbol(aliasSymbol);
-  }
-  return type.getSymbol() ?? null;
-}
-
-// src/compiler/schema/unionHandler.ts
-var import_typescript4 = __toESM(require("typescript"), 1);
-function handleUnion(type, ctx, typeNode) {
-  return buildNamedSchema(type, ctx, typeNode, () => {
-    const types = type.types;
-    const nullType = types.find((t) => t.flags & import_typescript4.default.TypeFlags.Null);
-    const undefinedType = types.find((t) => t.flags & import_typescript4.default.TypeFlags.Undefined);
-    const otherTypes = types.filter((t) => !(t.flags & import_typescript4.default.TypeFlags.Null) && !(t.flags & import_typescript4.default.TypeFlags.Undefined));
-    const allStringLiterals = otherTypes.every((t) => t.flags & import_typescript4.default.TypeFlags.StringLiteral);
-    if (allStringLiterals && otherTypes.length > 0) {
-      const enumValues = otherTypes.map((t) => t.value);
-      const schema = { type: "string", enum: enumValues };
-      if (nullType) {
-        schema.type = ["string", "null"];
-      }
-      return schema;
-    }
-    const allBooleanLiterals = otherTypes.length > 0 && otherTypes.every((t) => t.flags & import_typescript4.default.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") {
-        innerSchema.type = [innerSchema.type, "null"];
-      }
-      return innerSchema;
-    }
-    if (otherTypes.length > 1) {
-      const branches = otherTypes.map((t) => typeToJsonSchema(t, ctx));
-      const hasNull = !!nullType;
-      const result = {};
-      if (hasNull) {
-        result.anyOf = [...branches, { type: "null" }];
-      } else {
-        result.anyOf = branches;
-      }
-      const discriminatorResult = detectDiscriminatedUnion(otherTypes, ctx, branches);
-      if (discriminatorResult) {
-        result.oneOf = branches;
-        result.discriminator = discriminatorResult;
-      }
-      return result;
-    }
-    if (otherTypes.length === 1) {
-      return typeToJsonSchema(otherTypes[0], ctx);
-    }
-    return {};
-  });
-}
-function detectDiscriminatedUnion(types, ctx, _branches) {
-  if (types.length < 2) return null;
-  const candidates = findCommonPropertyNames(ctx.checker, types);
-  for (const propName of candidates) {
-    const requiredInAll = types.every((t) => isRequiredProperty(ctx.checker, t, propName));
-    if (!requiredInAll) continue;
-    const literalSets = types.map((t) => getPropertyLiteralValues(ctx.checker, t, propName));
-    if (literalSets.some((s) => s === null)) continue;
-    const allSets = literalSets;
-    if (!areSetsDisjoint(allSets)) continue;
-    const mapping = {};
-    for (let i = 0; i < types.length; i++) {
-      const branchName = getBranchSchemaName(types[i], ctx);
-      for (const val of allSets[i]) {
-        mapping[val] = `#/components/schemas/${branchName}`;
-      }
-    }
-    return { propertyName: propName, mapping };
-  }
-  return null;
-}
-function findCommonPropertyNames(checker, types) {
-  if (types.length === 0) return [];
-  const firstProps = types[0].getProperties().map((s) => s.getName());
-  return firstProps.filter(
-    (name) => types.every((m) => !!checker.getPropertyOfType(m, name))
-  );
-}
-function isRequiredProperty(checker, type, propName) {
-  const sym = checker.getPropertyOfType(type, propName);
-  if (!sym) return false;
-  if (sym.flags & import_typescript4.default.SymbolFlags.Optional) return false;
-  const propType = checker.getTypeOfSymbol(sym);
-  if (propType.isUnion?.()) {
-    const hasUndefined = propType.types.some((t) => (t.flags & import_typescript4.default.TypeFlags.Undefined) !== 0);
-    if (hasUndefined) return false;
-  }
-  return true;
-}
-function getPropertyLiteralValues(checker, type, propName) {
-  const sym = checker.getPropertyOfType(type, propName);
-  if (!sym) return null;
-  const propType = checker.getTypeOfSymbol(sym);
-  if (propType.isStringLiteral?.()) {
-    return /* @__PURE__ */ new Set([propType.value]);
-  }
-  if (propType.isUnion?.()) {
-    const values = /* @__PURE__ */ new Set();
-    for (const m of propType.types) {
-      if (!m.isStringLiteral?.()) return null;
-      values.add(m.value);
-    }
-    return values;
-  }
-  return null;
-}
-function areSetsDisjoint(sets) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const s of sets) {
-    for (const v of s) {
-      if (seen.has(v)) return false;
-      seen.add(v);
-    }
-  }
-  return true;
-}
-function getBranchSchemaName(type, ctx) {
-  const symbol = type.getSymbol();
-  if (symbol) {
-    return symbol.getName();
-  }
-  const aliasSymbol = type.aliasSymbol;
-  if (aliasSymbol) {
-    return aliasSymbol.getName();
-  }
-  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 (import_typescript4.default.isTypeReferenceNode(typeNode)) {
-    if (import_typescript4.default.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.text;
-    }
-  }
-  if (import_typescript4.default.isTypeAliasDeclaration(typeNode.parent)) {
-    if (import_typescript4.default.isIdentifier(typeNode.parent.name)) {
-      return typeNode.parent.name.text;
-    }
-  }
-  return null;
-}
-
-// src/compiler/schema/intersectionHandler.ts
-var import_typescript5 = __toESM(require("typescript"), 1);
-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 & (import_typescript5.default.TypeFlags.String | import_typescript5.default.TypeFlags.Number | import_typescript5.default.TypeFlags.Boolean | import_typescript5.default.TypeFlags.BigInt)) !== 0 || (t.flags & import_typescript5.default.TypeFlags.StringLiteral) !== 0 || (t.flags & import_typescript5.default.TypeFlags.NumberLiteral) !== 0;
-}
-function isBrandObject(checker, t, _ctx) {
-  if (!(t.flags & import_typescript5.default.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 (import_typescript5.default.isTypeReferenceNode(typeNode)) {
-    if (import_typescript5.default.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.text;
-    }
-  }
-  if (import_typescript5.default.isTypeAliasDeclaration(typeNode.parent)) {
-    if (import_typescript5.default.isIdentifier(typeNode.parent.name)) {
-      return typeNode.parent.name.text;
-    }
-  }
-  return null;
-}
-
-// src/compiler/schema/objectHandler.ts
-var import_typescript6 = __toESM(require("typescript"), 1);
-function getTypeParameterName(type) {
-  if (type.flags & import_typescript6.default.TypeFlags.TypeParameter) {
-    const typeParam = type;
-    return typeParam.symbol?.getName() ?? null;
-  }
-  return null;
-}
-function getTypeArguments(type) {
-  const typeRef = type;
-  const args = typeRef.typeArguments;
-  if (!args) return void 0;
-  return Array.from(args);
-}
-function createTypeParameterSubstitutions(type, typeNode, checker) {
-  const typeArgs = getTypeArguments(type);
-  if (!typeArgs || typeArgs.length === 0) {
-    return void 0;
-  }
-  if (!typeNode || !import_typescript6.default.isTypeReferenceNode(typeNode)) {
-    return void 0;
-  }
-  const typeParams = typeNode.typeArguments;
-  if (!typeParams || typeParams.length !== typeArgs.length) {
-    return void 0;
-  }
-  const substitutions = /* @__PURE__ */ new Map();
-  for (let i = 0; i < typeParams.length; i++) {
-    const typeParamNode = typeParams[i];
-    const typeArg = typeArgs[i];
-    if (import_typescript6.default.isIdentifier(typeParamNode)) {
-      substitutions.set(typeParamNode.text, typeArg);
-    }
-  }
-  return substitutions.size > 0 ? substitutions : void 0;
-}
-function resolveTypeParameter(type, substitutions, _checker) {
-  if (!substitutions) return null;
-  const paramName = getTypeParameterName(type);
-  if (!paramName) return null;
-  const resolved = substitutions.get(paramName);
-  return resolved ?? null;
-}
-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 (typeStack.has(type)) {
-      return { $ref: `#/components/schemas/${typeName}` };
-    }
-    typeStack.add(type);
-  }
-  const typeParamSubstitutions = createTypeParameterSubstitutions(type, typeNode, checker);
-  const buildCtx = typeParamSubstitutions ? { ...ctx, typeParameterSubstitutions: typeParamSubstitutions } : ctx;
-  const schema = buildObjectSchema(type, buildCtx, typeNode);
-  if (typeName && typeName !== "__type") {
-    typeStack.delete(type);
-    const existing = components.get(typeName);
-    if (!existing) {
-      components.set(typeName, schema);
-    } else {
-      const merged = mergeSchemasIfNeeded(existing, schema);
-      if (merged !== existing) {
-        components.set(typeName, merged);
-      }
-    }
-    return { $ref: `#/components/schemas/${typeName}` };
-  }
-  typeStack.delete(type);
-  return schema;
-}
-function buildObjectSchema(type, ctx, _typeNode) {
-  const { checker, mode, typeParameterSubstitutions } = ctx;
-  const properties = {};
-  const required = [];
-  const props = checker.getPropertiesOfType(type);
-  for (const prop of props) {
-    const propName = prop.getName();
-    if (isIteratorOrSymbolProperty(propName)) {
-      continue;
-    }
-    let propType = checker.getTypeOfSymbol(prop);
-    if (isMethodLike(propType)) {
-      continue;
-    }
-    const resolvedType = resolveTypeParameter(propType, typeParameterSubstitutions, checker);
-    if (resolvedType) {
-      propType = resolvedType;
-    }
-    const isOptional = !!(prop.flags & import_typescript6.default.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);
-    }
-  }
-  const schema = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    schema.required = required;
-  }
-  if (isRecordType(type, checker)) {
-    const valueType = getRecordValueType(type, checker);
-    if (valueType) {
-      const resolvedValueType = resolveTypeParameter(valueType, typeParameterSubstitutions, checker);
-      schema.additionalProperties = typeToJsonSchema(resolvedValueType ?? valueType, ctx);
-    }
-  }
-  return schema;
-}
-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) {
-  const symbol = type.getSymbol();
-  if (!symbol) return null;
-  const name = symbol.getName();
-  if (name === "Record") {
-    const typeRef = type;
-    const typeArgs = typeRef.typeArguments;
-    if (typeArgs && typeArgs.length >= 2) {
-      return typeArgs[1];
-    }
-  }
-  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 (import_typescript6.default.isTypeReferenceNode(typeNode)) {
-    if (import_typescript6.default.isIdentifier(typeNode.typeName)) {
-      return typeNode.typeName.text;
-    }
-  }
-  if (import_typescript6.default.isTypeAliasDeclaration(typeNode.parent)) {
-    if (import_typescript6.default.isIdentifier(typeNode.parent.name)) {
-      return typeNode.parent.name.text;
-    }
-  }
-  return null;
-}
-function mergeSchemasIfNeeded(existing, newSchema) {
-  if (existing.type === "array" && newSchema.type === "array") {
-    return mergeArraySchemas(existing, newSchema);
-  }
-  const result = { ...existing };
-  for (const [key, newValue] of Object.entries(newSchema)) {
-    if (key === "properties" && newValue) {
-      result.properties = mergePropertiesIfNeeded(existing.properties || {}, newValue);
-    } else if (key === "required" && newValue) {
-      result.required = mergeRequiredFields(existing.required || [], newValue);
-    } else if (!deepEqual(existing[key], newValue)) {
-      result[key] = newValue;
-    }
-  }
-  return result;
-}
-function mergePropertiesIfNeeded(existing, newProps) {
-  const result = { ...existing };
-  for (const [propName, newPropSchema] of Object.entries(newProps)) {
-    const existingProp = existing[propName];
-    if (!existingProp) {
-      result[propName] = newPropSchema;
-    } else if (deepEqual(existingProp, newPropSchema)) {
-      continue;
-    } else {
-      result[propName] = mergePropertySchemas(existingProp, newPropSchema);
-    }
-  }
-  return result;
-}
-function mergePropertySchemas(schema1, schema2) {
-  if (deepEqual(schema1, schema2)) {
-    return schema1;
-  }
-  if (schema1.type === "array" && schema2.type === "array") {
-    return mergeArraySchemas(schema1, schema2);
-  }
-  const existingOneOf = schema1.oneOf || schema1.anyOf;
-  const newOneOf = schema2.oneOf || schema2.anyOf;
-  if (existingOneOf) {
-    const mergedOneOf = [...existingOneOf];
-    if (newOneOf) {
-      for (const newItem of newOneOf) {
-        if (!mergedOneOf.some((item) => deepEqual(item, newItem))) {
-          mergedOneOf.push(newItem);
-        }
-      }
-    } else if (!mergedOneOf.some((item) => deepEqual(item, schema2))) {
-      mergedOneOf.push(schema2);
-    }
-    return { ...schema1, oneOf: mergedOneOf };
-  }
-  return {
-    oneOf: [schema1, schema2]
-  };
-}
-function mergeArraySchemas(schema1, schema2) {
-  const result = { type: "array" };
-  if (schema1.uniqueItems || schema2.uniqueItems) {
-    result.uniqueItems = true;
-  }
-  if (schema1.items && schema2.items) {
-    result.items = mergePropertySchemas(schema1.items, schema2.items);
-  } else if (schema1.items) {
-    result.items = schema1.items;
-  } else if (schema2.items) {
-    result.items = schema2.items;
-  }
-  return result;
-}
-function mergeRequiredFields(existing, newFields) {
-  const merged = /* @__PURE__ */ new Set([...existing, ...newFields]);
-  return Array.from(merged);
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === "object") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) return false;
-    for (const key of aKeys) {
-      if (!bKeys.includes(key)) return false;
-      if (!deepEqual(a[key], b[key])) return false;
-    }
-    return true;
-  }
-  return false;
-}
-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 & import_typescript6.default.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 & import_typescript6.default.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 (!targetType) {
-    return { "x-metal-orm-rel": wrapperRel };
-  }
-  if (wrapperName === "HasManyCollection" || wrapperName === "ManyToManyCollection") {
-    if (ctx.typeStack.has(targetType)) {
-      const items2 = {
-        type: "object",
-        properties: {
-          id: { type: "integer" }
-        },
-        required: ["id"]
-      };
-      if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
-        wrapperRel.pivot = ctx.checker.typeToString(typeArgs[1]);
-      }
-      return {
-        type: "array",
-        items: items2,
-        "x-metal-orm-rel": wrapperRel
-      };
-    }
-    const items = targetType ? typeToJsonSchema(targetType, ctx) : {};
-    if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
-      wrapperRel.pivot = ctx.checker.typeToString(typeArgs[1]);
-    }
-    return {
-      type: "array",
-      items,
-      "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, typeStack } = 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
-    };
-  }
-  if (typeStack.has(targetType)) {
-    const circularRefSchema = {
-      type: "object",
-      properties: {
-        id: { type: "integer" }
-      },
-      required: ["id"]
-    };
-    components.set(refSchemaName, circularRefSchema);
-    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 & import_typescript6.default.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 & import_typescript6.default.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 & import_typescript7.default.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
-var import_typescript8 = __toESM(require("typescript"), 1);
-function extractPropertySchemaFragments(checker, prop) {
-  if (!import_typescript8.default.canHaveDecorators(prop)) return [];
-  const decs = import_typescript8.default.getDecorators(prop);
-  if (!decs || decs.length === 0) return [];
-  const frags = [];
-  for (const d of decs) {
-    const expr = d.expression;
-    let callee;
-    let args;
-    if (import_typescript8.default.isCallExpression(expr)) {
-      callee = expr.expression;
-      args = expr.arguments;
-    } else {
-      callee = expr;
-      args = import_typescript8.default.factory.createNodeArray([]);
-    }
-    const sym = checker.getSymbolAtLocation(callee);
-    if (!sym) continue;
-    const resolved = resolveImportedDecorator(checker, sym);
-    if (!resolved || resolved.module !== "adorn-api/schema") continue;
-    const name = resolved.name;
-    if (name === "Schema") {
-      const obj = args[0];
-      if (obj && import_typescript8.default.isObjectLiteralExpression(obj)) {
-        const frag = objectLiteralToJson(obj);
-        if (frag) frags.push(frag);
-      }
-      continue;
-    }
-    if (name === "Min" && isNumberLiteral(args[0])) {
-      frags.push({ minimum: Number(args[0].text) });
-    } else if (name === "Max" && isNumberLiteral(args[0])) {
-      frags.push({ maximum: Number(args[0].text) });
-    } else if (name === "ExclusiveMin" && isNumberLiteral(args[0])) {
-      frags.push({ exclusiveMinimum: Number(args[0].text) });
-    } else if (name === "ExclusiveMax" && isNumberLiteral(args[0])) {
-      frags.push({ exclusiveMaximum: Number(args[0].text) });
-    } else if (name === "MinLength" && isNumberLiteral(args[0])) {
-      frags.push({ minLength: Number(args[0].text) });
-    } else if (name === "MaxLength" && isNumberLiteral(args[0])) {
-      frags.push({ maxLength: Number(args[0].text) });
-    } else if (name === "Format" && isStringLiteral(args[0])) {
-      frags.push({ format: args[0].text });
-    } else if (name === "Pattern") {
-      const arg = args[0];
-      if (arg && import_typescript8.default.isRegularExpressionLiteral(arg)) {
-        frags.push({ pattern: extractRegexPattern(arg.text) });
-      } else if (isStringLiteral(arg)) {
-        frags.push({ pattern: arg.text });
-      }
-    } else if (name === "MinItems" && isNumberLiteral(args[0])) {
-      frags.push({ minItems: Number(args[0].text) });
-    } else if (name === "MaxItems" && isNumberLiteral(args[0])) {
-      frags.push({ maxItems: Number(args[0].text) });
-    } else if (name === "MinProperties" && isNumberLiteral(args[0])) {
-      frags.push({ minProperties: Number(args[0].text) });
-    } else if (name === "MaxProperties" && isNumberLiteral(args[0])) {
-      frags.push({ maxProperties: Number(args[0].text) });
-    } else if (name === "MultipleOf" && isNumberLiteral(args[0])) {
-      frags.push({ multipleOf: Number(args[0].text) });
-    } else if (name === "Example") {
-      frags.push({ example: literalToJson(args[0]) });
-    } else if (name === "Examples" && import_typescript8.default.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" && import_typescript8.default.isArrayLiteralExpression(args[0])) {
-      frags.push({ enum: args[0].elements.map((e) => literalToJson(e)) });
-    } else if (name === "Const") {
-      frags.push({ const: literalToJson(args[0]) });
-    } else if (name === "Default") {
-      frags.push({ default: literalToJson(args[0]) });
-    } else if (name === "AdditionalProperties") {
-      const arg = args[0];
-      if (arg && (arg.kind === import_typescript8.default.SyntaxKind.FalseKeyword || arg.kind === import_typescript8.default.SyntaxKind.TrueKeyword)) {
-        frags.push({ additionalProperties: arg.kind === import_typescript8.default.SyntaxKind.TrueKeyword });
-      } else if (arg && import_typescript8.default.isObjectLiteralExpression(arg)) {
-        const obj = objectLiteralToJson(arg);
-        if (obj) frags.push({ additionalProperties: obj });
-      }
-    } else if (name === "Closed") {
-      frags.push({ additionalProperties: false });
-    } else if (name === "ClosedUnevaluated") {
-      frags.push({ unevaluatedProperties: false });
-    }
-  }
-  return frags;
-}
-function resolveImportedDecorator(checker, sym) {
-  const target = sym.flags & import_typescript8.default.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
-  const name = target.getName();
-  const decl = target.declarations?.[0];
-  if (!decl) return null;
-  const fileName = decl.getSourceFile().fileName.replace(/\\/g, "/");
-  if (fileName.includes("/node_modules/adorn-api/") || fileName.includes("/src/schema/")) {
-    return { module: "adorn-api/schema", name };
-  }
-  return null;
-}
-function isNumberLiteral(node) {
-  return !!node && import_typescript8.default.isNumericLiteral(node);
-}
-function isStringLiteral(node) {
-  return !!node && import_typescript8.default.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 (!import_typescript8.default.isPropertyAssignment(prop)) continue;
-    const name = prop.name;
-    let key;
-    if (import_typescript8.default.isIdentifier(name)) {
-      key = name.text;
-    } else if (import_typescript8.default.isStringLiteral(name)) {
-      key = name.text;
-    } else {
-      continue;
-    }
-    out[key] = literalToJson(prop.initializer);
-  }
-  return out;
-}
-function literalToJson(node) {
-  if (import_typescript8.default.isStringLiteral(node)) return node.text;
-  if (import_typescript8.default.isNumericLiteral(node)) return Number(node.text);
-  if (node.kind === import_typescript8.default.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === import_typescript8.default.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === import_typescript8.default.SyntaxKind.NullKeyword) return null;
-  if (import_typescript8.default.isObjectLiteralExpression(node)) return objectLiteralToJson(node);
-  if (import_typescript8.default.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 isDeepObject = isDeepObjectSchema(propSchema, ctx);
-      const isObjectLike = isObjectLikeSchema(propSchema, ctx);
-      const serialization = determineQuerySerialization(propSchema.type);
-      const exampleValue = generateExampleValue(propSchema, propName);
-      if (isDeepObject) {
-        parameters.push({
-          name: propName,
-          in: "query",
-          required: isRequired,
-          style: "deepObject",
-          explode: true,
-          schema: propSchema.$ref ? { $ref: propSchema.$ref } : propSchema
-        });
-      } else 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 isDeepObject = isDeepObjectSchema(paramSchema, ctx);
-      const isObjectLike = isObjectLikeSchema(paramSchema, ctx);
-      if (isDeepObject) {
-        parameters.push({
-          name: param.name,
-          in: "query",
-          required: !param.isOptional,
-          style: "deepObject",
-          explode: true,
-          schema: paramSchema.$ref ? { $ref: paramSchema.$ref } : paramSchema
-        });
-      } else 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 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 determineQuerySerialization(schemaType) {
-  const typeArray = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
-  const isArray = typeArray.includes("array");
-  if (isArray) {
-    return { style: "form", explode: true };
-  }
-  return {};
-}
-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";
-      }
-    }
-    return `Example: ${propName}=${JSON.stringify(example)}`;
-  }
-  return `Example: ${propName}=${JSON.stringify({ key: "value" })}`;
-}
-function parseExampleValue(description) {
-  const match = description.match(/Example:\s*\w+=(\{[^}]+\})/);
-  if (match) {
-    return match[1];
-  }
-  return JSON.stringify({ key: "value" });
-}
-function isDeepObjectSchema(schema, ctx) {
-  const resolved = resolveSchemaRef(schema, ctx.components);
-  if (resolved.type === "array") {
-    return false;
-  }
-  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
-    return true;
-  }
-  if (resolved.allOf) {
-    for (const branch of resolved.allOf) {
-      if (isDeepObjectSchema(branch, ctx)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-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;
-      }
-    }
-  }
-  if (resolved.type === "array" && resolved.items) {
-    const itemsSchema = resolveSchemaRef(resolved.items, ctx.components);
-    return isObjectLikeSchema(itemsSchema, ctx);
-  }
-  return false;
-}
-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 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/queryBuilderAnalyzer.ts
-var import_typescript10 = __toESM(require("typescript"), 1);
-
-// src/compiler/schema/serviceCallAnalyzer.ts
-var import_typescript9 = __toESM(require("typescript"), 1);
-var ServiceCallAnalyzer = class {
-  checker;
-  program;
-  cache = /* @__PURE__ */ new Map();
-  analyzedMethods = /* @__PURE__ */ new Set();
-  constructor(checker, program) {
-    this.checker = checker;
-    this.program = program;
-  }
-  /**
-   * Analyzes a controller method for query builder patterns, following service calls
-   */
-  analyzeControllerMethod(methodDeclaration, options = {}) {
-    const cacheKey = this.getMethodCacheKey(methodDeclaration);
-    if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey) ?? null;
-    }
-    const maxDepth = options.maxDepth ?? 3;
-    const schema = this.analyzeMethodWithServiceCalls(methodDeclaration, 0, maxDepth, options);
-    this.cache.set(cacheKey, schema);
-    return schema;
-  }
-  /**
-   * Recursively analyzes method with service call traversal
-   */
-  analyzeMethodWithServiceCalls(methodDeclaration, currentDepth, maxDepth, options) {
-    if (currentDepth >= maxDepth) {
-      return null;
-    }
-    const methodKey = this.getMethodCacheKey(methodDeclaration);
-    if (this.analyzedMethods.has(methodKey)) {
-      return null;
-    }
-    this.analyzedMethods.add(methodKey);
-    const directSchema = analyzeQueryBuilderForSchema(methodDeclaration, this.checker);
-    if (directSchema) {
-      return directSchema;
-    }
-    const serviceCalls = this.findServiceCalls(methodDeclaration);
-    for (const serviceCall of serviceCalls) {
-      const serviceSchema = this.analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options);
-      if (serviceSchema) {
-        return serviceSchema;
-      }
-    }
-    return null;
-  }
-  /**
-   * Analyzes a service method for query builder patterns
-   */
-  analyzeServiceMethod(serviceCall, currentDepth, maxDepth, options) {
-    const directSchema = analyzeQueryBuilderForSchema(serviceCall.methodDeclaration, this.checker);
-    if (directSchema) {
-      return directSchema;
-    }
-    if (options.analyzeHelpers) {
-      return this.analyzeMethodWithServiceCalls(
-        serviceCall.methodDeclaration,
-        currentDepth + 1,
-        maxDepth,
-        options
-      );
-    }
-    return null;
-  }
-  /**
-   * Finds service calls in a method body
-   */
-  findServiceCalls(methodDeclaration) {
-    const serviceCalls = [];
-    const body = methodDeclaration.body;
-    if (!body) {
-      return serviceCalls;
-    }
-    const visitor = (node) => {
-      if (import_typescript9.default.isCallExpression(node)) {
-        const serviceCall = this.resolveServiceCall(node);
-        if (serviceCall) {
-          serviceCalls.push(serviceCall);
-        }
-      }
-      import_typescript9.default.forEachChild(node, visitor);
-    };
-    import_typescript9.default.forEachChild(body, visitor);
-    return serviceCalls;
-  }
-  /**
-   * Resolves a call expression to a service method
-   */
-  resolveServiceCall(callExpression) {
-    if (import_typescript9.default.isPropertyAccessExpression(callExpression.expression)) {
-      const propAccess = callExpression.expression;
-      const methodName = propAccess.name.text;
-      const objectType = this.checker.getTypeAtLocation(propAccess.expression);
-      const objectSymbol = objectType.getSymbol();
-      if (objectSymbol) {
-        const classDeclaration = this.findClassDeclaration(objectSymbol);
-        if (classDeclaration) {
-          const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
-          if (methodDeclaration) {
-            return {
-              serviceName: classDeclaration.name?.text || "Unknown",
-              methodName,
-              filePath: classDeclaration.getSourceFile().fileName,
-              classDeclaration,
-              methodDeclaration
-            };
-          }
-        }
-      }
-    }
-    if (import_typescript9.default.isPropertyAccessExpression(callExpression.expression)) {
-      const propAccess = callExpression.expression;
-      const methodName = propAccess.name.text;
-      if (import_typescript9.default.isIdentifier(propAccess.expression)) {
-        const className = propAccess.expression.text;
-        const classSymbol = this.checker.getSymbolAtLocation(propAccess.expression);
-        if (classSymbol) {
-          const classDeclaration = this.findClassDeclaration(classSymbol);
-          if (classDeclaration && classDeclaration.name?.text === className) {
-            const methodDeclaration = this.findMethodDeclaration(classDeclaration, methodName);
-            if (methodDeclaration) {
-              return {
-                serviceName: className,
-                methodName,
-                filePath: classDeclaration.getSourceFile().fileName,
-                classDeclaration,
-                methodDeclaration
-              };
-            }
-          }
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Finds class declaration from a symbol
-   */
-  findClassDeclaration(symbol) {
-    const declarations = symbol.getDeclarations();
-    if (!declarations) return null;
-    for (const declaration of declarations) {
-      if (import_typescript9.default.isClassDeclaration(declaration)) {
-        return declaration;
-      }
-    }
-    return null;
-  }
-  /**
-   * Finds method declaration in a class
-   */
-  findMethodDeclaration(classDeclaration, methodName) {
-    for (const member of classDeclaration.members) {
-      if (import_typescript9.default.isMethodDeclaration(member) && member.name) {
-        if (import_typescript9.default.isIdentifier(member.name) && member.name.text === methodName) {
-          return member;
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Generates cache key for a method
-   */
-  getMethodCacheKey(methodDeclaration) {
-    const sourceFile = methodDeclaration.getSourceFile();
-    const className = this.getClassName(methodDeclaration);
-    const methodName = methodDeclaration.name?.getText() || "unknown";
-    const line = sourceFile.getLineAndCharacterOfPosition(methodDeclaration.getStart()).line;
-    return `${sourceFile.fileName}:${className}:${methodName}:${line}`;
-  }
-  /**
-   * Gets class name from method declaration
-   */
-  getClassName(methodDeclaration) {
-    let node = methodDeclaration;
-    while (node) {
-      if (import_typescript9.default.isClassDeclaration(node)) {
-        return node.name?.text || "Unknown";
-      }
-      node = node.parent;
-    }
-    return "Unknown";
-  }
-  /**
-   * Clears the analysis cache
-   */
-  clearCache() {
-    this.cache.clear();
-    this.analyzedMethods.clear();
-  }
-  /**
-   * Gets cache statistics
-   */
-  getCacheStats() {
-    return {
-      cached: this.cache.size,
-      analyzed: this.analyzedMethods.size
-    };
-  }
-};
-function analyzeControllerWithServiceCalls(methodDeclaration, checker, program, options = {}) {
-  if (!program) {
-    return null;
-  }
-  const analyzer = new ServiceCallAnalyzer(checker, program);
-  return analyzer.analyzeControllerMethod(methodDeclaration, options);
-}
-
-// src/compiler/schema/queryBuilderAnalyzer.ts
-function analyzeQueryBuilderForSchema(methodDeclaration, checker, options = {}) {
-  const body = methodDeclaration.body;
-  if (!body) {
-    return null;
-  }
-  const trackedSchema = analyzeWithVariableTracking(body, checker, options);
-  if (trackedSchema) {
-    return trackedSchema;
-  }
-  const returnStatement = findReturnStatement(body);
-  if (!returnStatement) {
-    return null;
-  }
-  const callChain = analyzeReturnExpression(returnStatement.expression);
-  if (!callChain) {
-    return null;
-  }
-  return parseQueryBuilderChain(callChain, checker, options);
-}
-function analyzeQueryBuilderWithServiceCalls(methodDeclaration, checker, program, options = {}, operationInfo) {
-  let schema = analyzeQueryBuilderForSchema(methodDeclaration, checker, options);
-  if (!schema && program) {
-    try {
-      schema = analyzeControllerWithServiceCalls(methodDeclaration, checker, program, {
-        maxDepth: options.maxDepth,
-        analyzeHelpers: options.analyzeHelpers
-      });
-    } catch (error) {
-      console.warn("Service call analysis failed:", error);
-    }
-  }
-  return {
-    detected: schema !== null,
-    schema,
-    ...operationInfo
-  };
-}
-function analyzeWithVariableTracking(body, checker, options) {
-  let queryBuilderVar = null;
-  let entityName = null;
-  const selectedFields = /* @__PURE__ */ new Set();
-  const includes = {};
-  let isPaged = false;
-  let hasReturn = false;
-  for (const statement of body.statements) {
-    if (import_typescript10.default.isReturnStatement(statement)) {
-      hasReturn = true;
-      const returnExpr = statement.expression;
-      if (returnExpr && import_typescript10.default.isCallExpression(returnExpr)) {
-        const callExpr = returnExpr;
-        if (import_typescript10.default.isIdentifier(callExpr.expression) && queryBuilderVar) {
-          const varName = callExpr.expression.text;
-          if (varName === queryBuilderVar) {
-            const methodName = callExpr.expression.text;
-            if (methodName === "executePaged") {
-              isPaged = true;
-            }
-          }
-        }
-        if (import_typescript10.default.isPropertyAccessExpression(callExpr.expression) && queryBuilderVar) {
-          const propAccess = callExpr.expression;
-          if (import_typescript10.default.isIdentifier(propAccess.expression) && propAccess.expression.text === queryBuilderVar) {
-            const methodName = propAccess.name.text;
-            if (methodName === "executePaged") {
-              isPaged = true;
-            }
-          }
-        }
-      }
-      continue;
-    }
-    if (!import_typescript10.default.isExpressionStatement(statement)) {
-      if (import_typescript10.default.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-          if (!import_typescript10.default.isIdentifier(declaration.name)) continue;
-          const varName = declaration.name.text;
-          const initializer = declaration.initializer;
-          if (!initializer || !import_typescript10.default.isCallExpression(initializer)) continue;
-          const opInfo = extractChainedOperation(initializer);
-          if (opInfo && (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom")) {
-            queryBuilderVar = varName;
-            if (opInfo.entityName) {
-              entityName = opInfo.entityName;
-            }
-          }
-        }
-      }
-      continue;
-    }
-    const expr = statement.expression;
-    if (import_typescript10.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript10.default.SyntaxKind.EqualsToken) {
-      if (!import_typescript10.default.isIdentifier(expr.left)) {
-        continue;
-      }
-      const varName = expr.left.text;
-      const rightSide = expr.right;
-      if (import_typescript10.default.isCallExpression(rightSide)) {
-        const opInfo = extractChainedOperation(rightSide);
-        if (opInfo) {
-          if (opInfo.operation === "selectFromEntity" || opInfo.operation === "selectFrom") {
-            queryBuilderVar = varName;
-            if (opInfo.entityName) {
-              entityName = opInfo.entityName;
-            }
-          }
-          if ((opInfo.operation === "select" || opInfo.operation === "include") && queryBuilderVar === varName) {
-            if (opInfo.operation === "select") {
-              for (const field of opInfo.fields || []) {
-                selectedFields.add(field);
-              }
-            } else if (opInfo.operation === "include" && opInfo.includeArg) {
-              const parsedIncludes = parseIncludeObjectLiteral(opInfo.includeArg);
-              if (parsedIncludes) {
-                for (const [relName, relSchema] of Object.entries(parsedIncludes)) {
-                  includes[relName] = relSchema;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  if (!hasReturn || !queryBuilderVar || !entityName) {
-    return null;
-  }
-  return {
-    entityName,
-    selectedFields: Array.from(selectedFields),
-    includes,
-    isPaged
-  };
-}
-function extractChainedOperation(callExpr) {
-  if (import_typescript10.default.isIdentifier(callExpr.expression)) {
-    const methodName2 = callExpr.expression.text;
-    if (methodName2 === "selectFromEntity" || methodName2 === "selectFrom") {
-      const entityArg = callExpr.arguments[0];
-      let entityName = null;
-      if (import_typescript10.default.isIdentifier(entityArg)) {
-        entityName = entityArg.text;
-      } else if (import_typescript10.default.isPropertyAccessExpression(entityArg)) {
-        entityName = entityArg.name.text;
-      }
-      return {
-        operation: methodName2 === "selectFromEntity" ? "selectFromEntity" : "selectFrom",
-        fields: null,
-        includeArg: null,
-        entityName
-      };
-    }
-  }
-  if (!import_typescript10.default.isPropertyAccessExpression(callExpr.expression)) {
-    return null;
-  }
-  const propAccess = callExpr.expression;
-  const methodName = propAccess.name.text;
-  if (methodName === "select") {
-    const fields = [];
-    for (const arg of callExpr.arguments) {
-      if (import_typescript10.default.isStringLiteral(arg)) {
-        fields.push(arg.text);
-      }
-    }
-    return {
-      operation: "select",
-      fields,
-      includeArg: null,
-      entityName: null
-    };
-  }
-  if (methodName === "include") {
-    return {
-      operation: "include",
-      fields: null,
-      includeArg: callExpr.arguments[0] || null,
-      entityName: null
-    };
-  }
-  return null;
-}
-function parseIncludeObjectLiteral(arg) {
-  if (!import_typescript10.default.isObjectLiteralExpression(arg)) {
-    return null;
-  }
-  const includes = {};
-  for (const prop of arg.properties) {
-    if (!import_typescript10.default.isPropertyAssignment(prop) || !import_typescript10.default.isIdentifier(prop.name)) {
-      continue;
-    }
-    const relationName = prop.name.text;
-    const value = prop.initializer;
-    if (value.kind === import_typescript10.default.SyntaxKind.TrueKeyword) {
-      includes[relationName] = true;
-    } else if (import_typescript10.default.isObjectLiteralExpression(value)) {
-      const nestedSchema = parseNestedInclude(value, 0);
-      if (nestedSchema) {
-        includes[relationName] = nestedSchema;
-      }
-    }
-  }
-  return includes;
-}
-function parseNestedInclude(obj, depth) {
-  const selectedFields = [];
-  const includes = {};
-  for (const prop of obj.properties) {
-    if (!import_typescript10.default.isPropertyAssignment(prop) || !import_typescript10.default.isIdentifier(prop.name)) {
-      continue;
-    }
-    const propName = prop.name.text;
-    const value = prop.initializer;
-    if (propName === "select" && import_typescript10.default.isArrayLiteralExpression(value)) {
-      for (const element of value.elements) {
-        if (import_typescript10.default.isStringLiteral(element)) {
-          selectedFields.push(element.text);
-        }
-      }
-    } else if (propName === "include" && import_typescript10.default.isObjectLiteralExpression(value)) {
-      const nestedIncludes = parseIncludeObjectLiteral(value);
-      if (nestedIncludes) {
-        for (const [relName, relSchema] of Object.entries(nestedIncludes)) {
-          includes[relName] = relSchema;
-        }
-      }
-    }
-  }
-  return {
-    entityName: "",
-    selectedFields,
-    includes,
-    isPaged: false
-  };
-}
-function getMethodName(expression) {
-  if (import_typescript10.default.isIdentifier(expression)) {
-    return expression.text;
-  }
-  if (import_typescript10.default.isPropertyAccessExpression(expression)) {
-    return expression.name.text;
-  }
-  return null;
-}
-function findReturnStatement(body) {
-  let returnStatement = null;
-  for (const statement of body.statements) {
-    if (import_typescript10.default.isReturnStatement(statement)) {
-      if (returnStatement !== null) {
-        return null;
-      }
-      returnStatement = statement;
-    }
-  }
-  return returnStatement;
-}
-function analyzeReturnExpression(expression) {
-  if (!expression) {
-    return null;
-  }
-  if (import_typescript10.default.isCallExpression(expression)) {
-    return buildCallChain(expression, null);
-  }
-  return null;
-}
-function buildCallChain(node, parent) {
-  if (import_typescript10.default.isCallExpression(node)) {
-    const callNode = {
-      expression: node.expression,
-      methodName: getMethodName(node.expression),
-      arguments: node.arguments,
-      parent
-    };
-    if (import_typescript10.default.isPropertyAccessExpression(node.expression)) {
-      return buildCallChain(node.expression.expression, callNode);
-    }
-    return callNode;
-  }
-  return parent;
-}
-function parseQueryBuilderChain(chain, checker, options) {
-  if (!chain) {
-    return null;
-  }
-  const rootNode = findSelectFromEntityCall(chain);
-  if (!rootNode) {
-    return null;
-  }
-  const entityName = extractEntityName(rootNode, checker);
-  if (!entityName) {
-    return null;
-  }
-  const selectedFields = /* @__PURE__ */ new Set();
-  const includes = {};
-  let isPaged = false;
-  let currentNode = chain;
-  while (currentNode) {
-    const methodName = currentNode.methodName;
-    if (methodName === "select") {
-      for (const arg of currentNode.arguments) {
-        if (import_typescript10.default.isStringLiteral(arg)) {
-          selectedFields.add(arg.text);
-        }
-      }
-    } else if (methodName === "include") {
-      parseIncludeArgument(currentNode.arguments[0], includes, checker, options, 0);
-    } else if (methodName === "executePaged") {
-      isPaged = true;
-    }
-    currentNode = currentNode.parent;
-  }
-  return {
-    entityName,
-    selectedFields: Array.from(selectedFields),
-    includes,
-    isPaged
-  };
-}
-function findSelectFromEntityCall(chain) {
-  let currentNode = chain;
-  let lastNode = null;
-  while (currentNode) {
-    if (currentNode.methodName === "selectFromEntity" || currentNode.methodName === "selectFrom") {
-      return currentNode;
-    }
-    lastNode = currentNode;
-    currentNode = currentNode.parent;
-  }
-  return lastNode;
-}
-function extractEntityName(callNode, checker) {
-  if (callNode.arguments.length === 0) {
-    return null;
-  }
-  const entityArg = callNode.arguments[0];
-  if (import_typescript10.default.isIdentifier(entityArg)) {
-    return entityArg.text;
-  }
-  if (import_typescript10.default.isPropertyAccessExpression(entityArg)) {
-    return entityArg.name.text;
-  }
-  return null;
-}
-function parseIncludeArgument(arg, includes, checker, options, depth) {
-  if (!arg) {
-    return;
-  }
-  if (import_typescript10.default.isObjectLiteralExpression(arg)) {
-    for (const prop of arg.properties) {
-      if (!import_typescript10.default.isPropertyAssignment(prop) || !import_typescript10.default.isIdentifier(prop.name)) {
-        continue;
-      }
-      const relationName = prop.name.text;
-      const value = prop.initializer;
-      if (value.kind === import_typescript10.default.SyntaxKind.TrueKeyword) {
-        includes[relationName] = true;
-      } else if (import_typescript10.default.isObjectLiteralExpression(value)) {
-        const maxDepth = options.maxDepth ?? 5;
-        if (depth < maxDepth) {
-          const nestedSchema = parseNestedInclude(value, depth + 1);
-          if (nestedSchema) {
-            includes[relationName] = nestedSchema;
-          }
-        }
-      }
-    }
-  }
-}
-
-// src/compiler/schema/queryBuilderSchemaBuilder.ts
-var import_typescript11 = require("typescript");
-function wrapInPaginatedResult(schema) {
-  return {
-    type: "object",
-    properties: {
-      items: {
-        type: "array",
-        items: schema
-      },
-      page: { type: "integer" },
-      pageSize: { type: "integer" },
-      totalItems: { type: "integer" }
-    },
-    required: ["items", "page", "pageSize", "totalItems"]
-  };
-}
-
-// 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: [],
-    mode: "response"
-  };
-  const paths = {};
-  const { onProgress, onQueryBuilderProgress } = options;
-  let totalOperations = 0;
-  for (const controller of controllers) {
-    totalOperations += controller.operations.length;
-  }
-  let currentOperation = 0;
-  for (let i = 0; i < controllers.length; i++) {
-    const controller = controllers[i];
-    if (onProgress) {
-      onProgress(`Processing controller ${controller.className}`, i + 1, controllers.length);
-    }
-    for (const operation of controller.operations) {
-      const fullPath = convertToOpenApiPath(controller.basePath, operation.path);
-      if (!paths[fullPath]) {
-        paths[fullPath] = {};
-      }
-      const method = operation.httpMethod.toLowerCase();
-      const analysisResult = analyzeQueryBuilderWithServiceCalls(
-        operation.methodDeclaration,
-        checker,
-        null,
-        // TODO: Pass program when available
-        {},
-        {
-          methodName: operation.operationId,
-          httpMethod: operation.httpMethod,
-          path: operation.path,
-          operationId: operation.operationId
-        }
-      );
-      if (onQueryBuilderProgress) {
-        currentOperation++;
-        onQueryBuilderProgress({
-          controller: controller.className,
-          operation: operation.operationId,
-          method: operation.httpMethod,
-          path: operation.path,
-          queryBuilderDetected: analysisResult.detected,
-          entityName: analysisResult.schema?.entityName,
-          selectedFields: analysisResult.schema?.selectedFields,
-          isPaged: analysisResult.schema?.isPaged,
-          current: currentOperation,
-          total: totalOperations
-        });
-      }
-      paths[fullPath][method] = buildOperation(operation, ctx, controller.consumes);
-    }
-  }
-  const schemas = Object.fromEntries(components);
-  if (onProgress) {
-    onProgress("Generating and cleaning schemas", controllers.length, controllers.length);
-  }
-  cleanupMetalOrmWrappers(schemas, paths);
-  return {
-    openapi: "3.1.0",
-    info: {
-      title: options.title ?? "API",
-      version: options.version ?? "1.0.0"
-    },
-    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}");
-  let fullPath = base + converted || "/";
-  if (fullPath.endsWith("/") && fullPath !== "/") {
-    fullPath = fullPath.slice(0, -1);
-  }
-  return fullPath;
-}
-function tryInferQueryBuilderSchema(operation, checker) {
-  return analyzeQueryBuilderForSchema(operation.methodDeclaration, checker) ?? null;
-}
-function getEntityTypeFromReturnType(operation, checker) {
-  const returnType = operation.returnType;
-  const unwrapPromise2 = (type) => {
-    const symbol2 = type.getSymbol();
-    if (symbol2?.getName() === "Promise") {
-      const typeArgs = type.typeArguments;
-      if (typeArgs && typeArgs.length > 0) {
-        return typeArgs[0];
-      }
-    }
-    return type;
-  };
-  const innerType = unwrapPromise2(returnType);
-  const symbol = innerType.getSymbol();
-  if (symbol?.getName() === "PaginatedResult") {
-    const typeArgs = innerType.typeArguments;
-    if (typeArgs && typeArgs.length > 0) {
-      return typeArgs[0];
-    }
-  }
-  return null;
-}
-function filterSchemaByQueryBuilder(querySchema, operation, ctx) {
-  const entityType = getEntityTypeFromReturnType(operation, ctx.checker);
-  if (!entityType) {
-    return {};
-  }
-  const entitySchema = typeToJsonSchema(entityType, ctx);
-  let baseSchema = entitySchema;
-  if (entitySchema.$ref && entitySchema.$ref.startsWith("#/components/schemas/")) {
-    const schemaName = entitySchema.$ref.replace("#/components/schemas/", "");
-    const componentSchema = ctx.components.get(schemaName);
-    if (componentSchema) {
-      baseSchema = componentSchema;
-    }
-  }
-  if (!baseSchema.properties || Object.keys(baseSchema.properties).length === 0) {
-    return {};
-  }
-  const filteredSchema = buildFilteredSchema(querySchema, baseSchema);
-  if (querySchema.isPaged) {
-    return wrapInPaginatedResult(filteredSchema);
-  }
-  return filteredSchema;
-}
-function buildFilteredSchema(querySchema, entitySchema) {
-  const properties = {};
-  const required = [];
-  for (const field of querySchema.selectedFields) {
-    if (entitySchema.properties?.[field]) {
-      properties[field] = entitySchema.properties[field];
-      if (entitySchema.required && entitySchema.required.includes(field)) {
-        required.push(field);
-      }
-    }
-  }
-  for (const [relationName, includeSpec] of Object.entries(querySchema.includes)) {
-    if (entitySchema.properties?.[relationName]) {
-      properties[relationName] = {
-        type: "object",
-        properties: {
-          id: { type: "integer" }
-        },
-        required: ["id"]
-      };
-      if (entitySchema.required && entitySchema.required.includes(relationName)) {
-        required.push(relationName);
-      }
-    }
-  }
-  const schema = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    schema.required = required;
-  }
-  return schema;
-}
-function buildOperation(operation, ctx, controllerConsumes) {
-  const op = {
-    operationId: operation.operationId,
-    responses: {}
-  };
-  const parameters = [];
-  buildPathParameters(operation, ctx, parameters);
-  buildQueryParameters(operation, ctx, parameters);
-  buildHeaderParameters(operation, ctx, parameters);
-  buildCookieParameters(operation, ctx, parameters);
-  if (parameters.length > 0) {
-    op.parameters = parameters;
-  }
-  const responseCtx = { ...ctx, mode: "response" };
-  let responseSchema;
-  const querySchema = tryInferQueryBuilderSchema(operation, ctx.checker);
-  if (querySchema) {
-    const entityType = getEntityTypeFromReturnType(operation, ctx.checker);
-    if (entityType) {
-      responseSchema = filterSchemaByQueryBuilder(querySchema, operation, responseCtx);
-    } else {
-      responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
-    }
-  } else {
-    responseSchema = typeToJsonSchema(operation.returnType, responseCtx, operation.returnTypeNode);
-  }
-  const status = operation.httpMethod === "POST" ? 201 : 200;
-  op.responses[status] = {
-    description: status === 201 ? "Created" : "OK",
-    content: {
-      "application/json": {
-        schema: responseSchema
-      }
-    }
-  };
-  if (["POST", "PUT", "PATCH"].includes(operation.httpMethod) && operation.bodyParamIndex !== null) {
-    const bodyParam = operation.parameters[operation.bodyParamIndex];
-    if (bodyParam) {
-      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,
-        content: {}
-      };
-      if (contentType === "multipart/form-data") {
-        requestBody.content["multipart/form-data"] = {
-          schema: bodySchema
-        };
-      } else {
-        requestBody.content[contentType] = {
-          schema: bodySchema
-        };
-      }
-      op.requestBody = requestBody;
-    }
-  }
-  return op;
-}
-function mergeBodySchemaAnnotations(bodyParam, ctx, schema) {
-  if (!schema.properties) return schema;
-  const typeSymbol = bodyParam.type.getSymbol();
-  if (!typeSymbol) return schema;
-  const declarations = typeSymbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return schema;
-  const classDecl = declarations[0];
-  if (!import_typescript12.default.isClassDeclaration(classDecl)) return schema;
-  const result = { ...schema };
-  const props = { ...result.properties };
-  for (const member of classDecl.members) {
-    if (!import_typescript12.default.isPropertyDeclaration(member) || !member.name) continue;
-    const propName = import_typescript12.default.isIdentifier(member.name) ? member.name.text : null;
-    if (!propName) continue;
-    if (!props[propName]) continue;
-    const frags = extractPropertySchemaFragments(ctx.checker, member);
-    if (frags.length > 0) {
-      props[propName] = mergeFragments(props[propName], ...frags);
-    }
-  }
-  result.properties = props;
-  return result;
-}
-
-// src/compiler/manifest/emit.ts
-var import_typescript13 = __toESM(require("typescript"), 1);
-function generateManifest(controllers, checker, version, validationMode = "ajv-runtime") {
-  const components = /* @__PURE__ */ new Map();
-  const ctx = {
-    checker,
-    components,
-    typeStack: /* @__PURE__ */ new Set(),
-    typeNameStack: [],
-    mode: "request"
-  };
-  const controllerEntries = controllers.map((ctrl) => ({
-    controllerId: ctrl.className,
-    basePath: ctrl.basePath,
-    operations: ctrl.operations.map((op) => buildOperationEntry(op, ctx))
-  }));
-  const validationConfig = validationMode === "precompiled" ? { mode: "precompiled", precompiledModule: null } : validationMode === "none" ? { mode: "none", precompiledModule: null } : { mode: "ajv-runtime", precompiledModule: null };
-  return {
-    manifestVersion: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    generator: {
-      name: "adorn-api",
-      version,
-      typescript: import_typescript13.default.version
-    },
-    schemas: {
-      kind: "openapi-3.1",
-      file: "./openapi.json",
-      componentsSchemasPointer: "/components/schemas"
-    },
-    validation: validationConfig,
-    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 isDeepObjectSchema2(schema, components) {
-  const resolved = resolveSchemaRef2(schema, components);
-  if (resolved.type === "array") {
-    return false;
-  }
-  if (resolved.type === "object" || resolved.properties || resolved.additionalProperties) {
-    return true;
-  }
-  if (resolved.allOf) {
-    for (const branch of resolved.allOf) {
-      if (isDeepObjectSchema2(branch, components)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-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: []
-  };
-  buildPathArgs(op, ctx, args);
-  buildQueryArgs(op, ctx, args);
-  buildHeaderArgs(op, ctx, args);
-  buildCookieArgs(op, ctx, args);
-  if (op.bodyParamIndex !== null) {
-    const bodyParam = op.parameters[op.bodyParamIndex];
-    if (bodyParam) {
-      const bodySchema = typeToJsonSchema(bodyParam.type, ctx);
-      const schemaRef2 = bodySchema.$ref ?? "#/components/schemas/InlineBody";
-      args.body = {
-        index: bodyParam.index,
-        required: !bodyParam.isOptional,
-        contentType: op.bodyContentType ?? "application/json",
-        schemaRef: schemaRef2
-      };
-    }
-  }
-  const responseSchema = typeToJsonSchema(op.returnType, ctx, op.returnTypeNode);
-  const status = op.httpMethod === "POST" ? 201 : 200;
-  let schemaRef = responseSchema.$ref;
-  let isArray = false;
-  if (!schemaRef && responseSchema.type === "array" && responseSchema.items?.$ref) {
-    schemaRef = responseSchema.items.$ref;
-    isArray = true;
-  } else if (!schemaRef) {
-    schemaRef = "#/components/schemas/InlineResponse";
-  }
-  return {
-    operationId: op.operationId,
-    http: {
-      method: op.httpMethod,
-      path: op.path
-    },
-    handler: {
-      methodName: op.methodName
-    },
-    args,
-    responses: [
-      {
-        status,
-        contentType: "application/json",
-        schemaRef,
-        isArray
-      }
-    ]
-  };
-}
-function buildPathArgs(op, ctx, args) {
-  for (const paramIndex of op.pathParamIndices) {
-    const param = op.parameters[paramIndex];
-    if (param) {
-      const paramSchema = typeToJsonSchema(param.type, ctx);
-      args.path.push({
-        name: param.name,
-        index: param.index,
-        required: !param.isOptional,
-        schemaRef: paramSchema.$ref ?? "#/components/schemas/InlinePathParam",
-        schemaType: paramSchema.type
-      });
-    }
-  }
-}
-function buildQueryArgs(op, ctx, args) {
-  if (op.queryObjectParamIndex !== null) {
-    const queryParam = op.parameters[op.queryObjectParamIndex];
-    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 isDeepObject = isDeepObjectSchema2(propSchema, ctx.components);
-      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,
-        serialization: isDeepObject ? { style: "deepObject", explode: true } : void 0,
-        content: !isDeepObject && 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 isDeepObject = isDeepObjectSchema2(paramSchema, ctx.components);
-      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,
-        serialization: isDeepObject ? { style: "deepObject", explode: true } : void 0,
-        content: !isDeepObject && isObjectLike ? "application/json" : void 0
-      });
-    }
-  }
-}
-function buildHeaderArgs(op, ctx, args) {
-  if (op.headerObjectParamIndex === null) return;
-  const headerParam = op.parameters[op.headerObjectParamIndex];
-  if (!headerParam) return;
-  const headerSchema = typeToJsonSchema(headerParam.type, ctx);
-  if (!headerSchema.properties) return;
-  for (const [propName, propSchema] of Object.entries(headerSchema.properties)) {
-    const isRequired = headerSchema.required?.includes(propName) ?? false;
-    let schemaRef = propSchema.$ref;
-    if (!schemaRef) {
-      schemaRef = "#/components/schemas/InlineHeaderParam";
-    }
-    args.headers.push({
-      name: propName,
-      index: headerParam.index,
-      required: isRequired,
-      schemaRef,
-      schemaType: propSchema.type
-    });
-  }
-}
-function buildCookieArgs(op, ctx, args) {
-  if (op.cookieObjectParamIndex === null) return;
-  const cookieParam = op.parameters[op.cookieObjectParamIndex];
-  if (!cookieParam) return;
-  const cookieSchema = typeToJsonSchema(cookieParam.type, ctx);
-  if (!cookieSchema.properties) return;
-  for (const [propName, propSchema] of Object.entries(cookieSchema.properties)) {
-    const isRequired = cookieSchema.required?.includes(propName) ?? false;
-    let schemaRef = propSchema.$ref;
-    if (!schemaRef) {
-      schemaRef = "#/components/schemas/InlineCookieParam";
-    }
-    args.cookies.push({
-      name: propName,
-      index: cookieParam.index,
-      required: isRequired,
-      schemaRef,
-      schemaType: propSchema.type,
-      serialization: { style: "form", explode: true }
-    });
-  }
-}
-
-// src/compiler/validation/emitPrecompiledValidators.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_crypto = __toESM(require("crypto"), 1);
-var import_ajv = __toESM(require("ajv"), 1);
-var import_ajv_formats = __toESM(require("ajv-formats"), 1);
-var OAS_SCHEMA_ONLY = /* @__PURE__ */ new Set(["discriminator", "xml", "externalDocs", "example"]);
-function sanitizeSchemaForAjv(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)) {
-    if (OAS_SCHEMA_ONLY.has(k)) continue;
-    if (k.startsWith("x-")) continue;
-    out[k] = sanitizeSchemaForAjv(v);
-  }
-  return out;
-}
-function rewriteComponentRefs(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;
-    const m = ref.match(/^#\/components\/schemas\/(.+)$/);
-    if (m) {
-      return { ...schema, $ref: m[1] };
-    }
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(schema)) {
-    out[k] = rewriteComponentRefs(v);
-  }
-  return out;
-}
-function safeId(s) {
-  return s.replace(/[^A-Za-z0-9_]/g, "_").replace(/^[^A-Za-z_]/, "_$&");
-}
-function schemaNameFromRef(schemaRef) {
-  return schemaRef.replace(/^#\/components\/schemas\//, "");
-}
-async function emitPrecompiledValidators(opts) {
-  const outDir = opts.outDir;
-  const cjsPath = import_node_path2.default.join(outDir, "validators.cjs");
-  const esmPath = import_node_path2.default.join(outDir, "validators.mjs");
-  const metaPath = import_node_path2.default.join(outDir, "validators.meta.json");
-  import_node_fs2.default.mkdirSync(outDir, { recursive: true });
-  const schemas = [];
-  for (const [name, sch] of Object.entries(opts.openapi.components?.schemas ?? {})) {
-    const clean = rewriteComponentRefs(sanitizeSchemaForAjv(sch));
-    schemas.push({ ...clean, $id: name });
-  }
-  const opIndex = {};
-  for (const ctrl of opts.manifest.controllers ?? []) {
-    for (const op of ctrl.operations ?? []) {
-      const entry = { response: {} };
-      opIndex[op.operationId] = entry;
-      if (op.args.body?.schemaRef) {
-        const typeName = schemaNameFromRef(op.args.body.schemaRef);
-        const id = safeId(`op_${op.operationId}_body`);
-        schemas.push({ $id: id, $ref: typeName });
-        entry.body = id;
-      }
-      for (const r of op.responses ?? []) {
-        if (!r.schemaRef) continue;
-        const typeName = schemaNameFromRef(r.schemaRef);
-        const key = `${r.status}|${r.contentType}`;
-        const id = safeId(`op_${op.operationId}_res_${r.status}_${r.contentType}`);
-        schemas.push({ $id: id, $ref: typeName });
-        entry.response[key] = id;
-      }
-    }
-  }
-  const strictOpt = opts.strict === "off" ? false : opts.strict === "log" ? "log" : true;
-  const ajv = new import_ajv.default.default({
-    schemas,
-    allErrors: true,
-    strict: strictOpt,
-    code: { source: true }
-  });
-  import_ajv_formats.default.default(ajv, { mode: opts.formatsMode ?? "full" });
-  let cjs;
-  const standaloneModule = require("ajv/dist/standalone");
-  if (typeof standaloneModule === "function") {
-    cjs = standaloneModule(ajv);
-  } else if (standaloneModule && typeof standaloneModule.default === "function") {
-    cjs = standaloneModule.default(ajv);
-  } else {
-    throw new Error("Unable to find standalone code generator in ajv/dist/standalone");
-  }
-  cjs += "\n\n// --- adorn-api operation lookup (generated) ---\n";
-  cjs += "exports.validators = {\n";
-  for (const [operationId, v] of Object.entries(opIndex)) {
-    cjs += `  ${JSON.stringify(operationId)}: {
-`;
-    cjs += `    body: ${v.body ? `exports[${JSON.stringify(v.body)}]` : "undefined"},
-`;
-    cjs += "    response: {\n";
-    for (const [key, id] of Object.entries(v.response)) {
-      cjs += `      ${JSON.stringify(key)}: exports[${JSON.stringify(id)}],
-`;
-    }
-    cjs += "    }\n";
-    cjs += "  },\n";
-  }
-  cjs += "};\n";
-  import_node_fs2.default.writeFileSync(cjsPath, cjs, "utf8");
-  const esm = `// .adorn/validators.mjs (generated)
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const cjs = require("./validators.cjs");
-
-export const validators = cjs.validators;
-
-export function validateBody(operationId, data) {
-  const v = validators?.[operationId]?.body;
-  if (!v) return { ok: true, errors: null };
-  const ok = v(data);
-  return { ok, errors: ok ? null : v.errors };
-}
-
-export function validateResponse(operationId, status, contentType, data) {
-  const key = String(status) + "|" + String(contentType);
-  const v = validators?.[operationId]?.response?.[key];
-  if (!v) return { ok: true, errors: null };
-  const ok = v(data);
-  return { ok, errors: ok ? null : v.errors };
-}
-`;
-  import_node_fs2.default.writeFileSync(esmPath, esm, "utf8");
-  const hash = import_node_crypto.default.createHash("sha256").update(cjs).digest("hex");
-  import_node_fs2.default.writeFileSync(metaPath, JSON.stringify({ hash }, null, 2), "utf8");
-  return { validatorsCjsPath: cjsPath, validatorsEsmPath: esmPath, hash };
-}
-
-// src/compiler/cache/isStale.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_meta = {};
-function readJson(p) {
-  try {
-    return JSON.parse(import_node_fs3.default.readFileSync(p, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function statMtimeMs(p) {
-  try {
-    return import_node_fs3.default.statSync(p).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-function ensureAbs(p) {
-  return import_node_path3.default.isAbsolute(p) ? p : import_node_path3.default.resolve(p);
-}
-function collectTsconfigChain(tsconfigPathAbs) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  function visit(pAbs) {
-    if (seen.has(pAbs)) return;
-    seen.add(pAbs);
-    out.push(pAbs);
-    const raw = readJson(pAbs);
-    const ext = raw?.extends;
-    if (!ext) return;
-    let resolved = null;
-    if (ext.startsWith(".") || ext.startsWith("/") || /^[A-Za-z]:\\/.test(ext)) {
-      resolved = ensureAbs(import_node_path3.default.resolve(import_node_path3.default.dirname(pAbs), ext));
-      if (!resolved.endsWith(".json")) resolved += ".json";
-    } else {
-      try {
-        const req = module.createRequire?.(import_meta.url) ?? require;
-        resolved = req.resolve(ext);
-      } catch {
-        try {
-          const req = module.createRequire?.(import_meta.url) ?? require;
-          resolved = req.resolve(ext.endsWith(".json") ? ext : `${ext}.json`);
-        } catch {
-          resolved = null;
-        }
-      }
-    }
-    if (resolved) visit(resolved);
-  }
-  visit(tsconfigPathAbs);
-  return out;
-}
-function findLockfile(startDir) {
-  const names = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"];
-  let dir = startDir;
-  for (let i = 0; i < 20; i++) {
-    for (const n of names) {
-      const p = import_node_path3.default.join(dir, n);
-      const mt = statMtimeMs(p);
-      if (mt !== null) return { path: p, mtimeMs: mt };
-    }
-    const parent = import_node_path3.default.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-async function isStale(params) {
-  const outDirAbs = ensureAbs(params.outDir);
-  const tsconfigAbs = ensureAbs(params.project);
-  const manifestPath = import_node_path3.default.join(outDirAbs, "manifest.json");
-  const cachePath = import_node_path3.default.join(outDirAbs, "cache.json");
-  if (!import_node_fs3.default.existsSync(manifestPath)) return { stale: true, reason: "missing-manifest" };
-  const cache = readJson(cachePath);
-  if (!cache) return { stale: true, reason: "missing-cache" };
-  if (cache.generator.version !== params.adornVersion) {
-    return { stale: true, reason: "generator-version-changed", detail: `${cache.generator.version} -> ${params.adornVersion}` };
-  }
-  if (ensureAbs(cache.project.tsconfigPath) !== tsconfigAbs) {
-    return { stale: true, reason: "tsconfig-changed", detail: "different project path" };
-  }
-  const chain = collectTsconfigChain(tsconfigAbs);
-  for (const cfg of chain) {
-    const mt = statMtimeMs(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) {
-      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 (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 (Math.abs(cachedMt - mt) > 1e-4) return { stale: true, reason: "input-updated", detail: file };
-  }
-  return { stale: false, reason: "up-to-date" };
-}
-
-// src/compiler/cache/writeCache.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-var import_typescript14 = __toESM(require("typescript"), 1);
-function statMtimeMs2(p) {
-  return import_node_fs4.default.statSync(p).mtimeMs;
-}
-function ensureDir(p) {
-  import_node_fs4.default.mkdirSync(p, { recursive: true });
-}
-function isProjectSourceFile(f) {
-  if (f.includes(`${import_node_path4.default.sep}node_modules${import_node_path4.default.sep}`)) return false;
-  if (f.includes(`${import_node_path4.default.sep}typescript${import_node_path4.default.sep}lib${import_node_path4.default.sep}`)) return false;
-  return /\.(ts|tsx|mts|cts)$/.test(f);
-}
-function writeCache(params) {
-  const outDirAbs = import_node_path4.default.isAbsolute(params.outDir) ? params.outDir : import_node_path4.default.resolve(params.outDir);
-  ensureDir(outDirAbs);
-  const configFiles = collectTsconfigChain(params.tsconfigAbs);
-  const configMtimes = {};
-  for (const cfg of configFiles) configMtimes[cfg] = statMtimeMs2(cfg);
-  const lock = findLockfile(import_node_path4.default.dirname(params.tsconfigAbs));
-  const inputs = {};
-  for (const sf of params.program.getSourceFiles()) {
-    const f = sf.fileName;
-    if (!isProjectSourceFile(f)) continue;
-    try {
-      inputs[f] = statMtimeMs2(f);
-    } catch {
-    }
-  }
-  const cache = {
-    cacheVersion: 1,
-    generator: {
-      name: "adorn-api",
-      version: params.adornVersion,
-      typescript: import_typescript14.default.version
-    },
-    project: {
-      tsconfigPath: params.tsconfigAbs,
-      configFiles: configMtimes,
-      lockfile: lock ?? null
-    },
-    inputs
-  };
-  import_node_fs4.default.writeFileSync(import_node_path4.default.join(outDirAbs, "cache.json"), JSON.stringify(cache, null, 2), "utf8");
-}
-
-// src/cli/progress.ts
-var import_node_process = __toESM(require("process"), 1);
-var ProgressTracker = class {
-  phases = /* @__PURE__ */ new Map();
-  startTime;
-  verbose = false;
-  quiet = false;
-  indentLevel = 0;
-  constructor(options = {}) {
-    this.verbose = options.verbose ?? false;
-    this.quiet = options.quiet ?? false;
-    this.startTime = performance.now();
-  }
-  /**
-   * Start a new phase.
-   */
-  startPhase(name, message) {
-    this.phases.set(name, {
-      name,
-      startTime: performance.now(),
-      status: "running",
-      message
-    });
-    if (!this.quiet) {
-      this.log(`\u25CF ${message || name}`);
-    }
-  }
-  /**
-   * Complete a phase successfully.
-   */
-  completePhase(name, message) {
-    const phase = this.phases.get(name);
-    if (phase) {
-      phase.endTime = performance.now();
-      phase.status = "completed";
-      phase.message = message;
-    }
-    if (!this.quiet) {
-      const elapsed = phase ? this.formatElapsed(phase.startTime, phase.endTime) : "";
-      const status = this.verbose ? `\u2713 ${message || name} ${elapsed}` : `\u2713 ${message || name} ${elapsed}`;
-      this.log(status);
-    }
-  }
-  /**
-   * Mark a phase as failed.
-   */
-  failPhase(name, message) {
-    const phase = this.phases.get(name);
-    if (phase) {
-      phase.endTime = performance.now();
-      phase.status = "failed";
-      phase.message = message;
-    }
-    if (!this.quiet) {
-      this.log(`\u2717 ${message || name}`);
-    }
-  }
-  /**
-   * Log a verbose message.
-   */
-  verboseLog(message) {
-    if (this.verbose && !this.quiet) {
-      const elapsed = this.formatElapsed(this.startTime);
-      this.log(`[${elapsed}] ${message}`);
-    }
-  }
-  /**
-   * Log a regular message.
-   */
-  log(message) {
-    const indent = "  ".repeat(this.indentLevel);
-    import_node_process.default.stdout.write(indent + message + "\n");
-  }
-  /**
-   * Log a sub-message (indented).
-   */
-  logSub(message) {
-    this.indentLevel++;
-    this.log(message);
-    this.indentLevel--;
-  }
-  /**
-   * Get the total elapsed time in milliseconds.
-   */
-  getTotalElapsed() {
-    return performance.now() - this.startTime;
-  }
-  /**
-   * Format elapsed time as a human-readable string.
-   */
-  formatElapsed(startTime, endTime) {
-    const elapsed = (endTime ?? performance.now()) - (startTime ?? this.startTime);
-    if (elapsed < 1) {
-      return `${(elapsed * 1e3).toFixed(0)}ms`;
-    } else if (elapsed < 1e3) {
-      return `${elapsed.toFixed(0)}ms`;
-    } else {
-      return `${(elapsed / 1e3).toFixed(2)}s`;
-    }
-  }
-  /**
-   * Get all completed phases with their timings.
-   */
-  getPhases() {
-    return Array.from(this.phases.values());
-  }
-  /**
-   * Print a build summary.
-   */
-  printSummary(stats) {
-    if (this.quiet) return;
-    this.log("");
-    this.log("Build Summary:");
-    this.log(`  Controllers:     ${stats.controllers}`);
-    this.log(`  Operations:      ${stats.operations}`);
-    this.log(`  Schemas:         ${stats.schemas}`);
-    this.log(`  Source files:    ${stats.sourceFiles}`);
-    this.log(`  Output dir:      ${stats.artifactsWritten[0]?.split("/").slice(0, -1).join("/") || ".adorn"}`);
-    this.log("");
-    this.log("Timings:");
-    for (const phase of this.phases.values()) {
-      if (phase.status === "completed" && phase.endTime) {
-        const elapsed = phase.endTime - phase.startTime;
-        const timeStr = elapsed < 1 ? `${(elapsed * 1e3).toFixed(0)}ms` : elapsed < 1e3 ? `${elapsed.toFixed(0)}ms` : `${(elapsed / 1e3).toFixed(2)}s`;
-        this.log(`  ${phase.name.padEnd(20)} ${timeStr}`);
-      }
-    }
-    this.log(`  ${"\u2500".repeat(21)}`);
-    this.log(`  Total time:      ${this.formatElapsed()}`);
-    this.log("");
-  }
-  /**
-   * Print artifact list.
-   */
-  printArtifacts(artifacts) {
-    if (this.quiet) return;
-    this.log("Written artifacts:");
-    for (const artifact of artifacts) {
-      const sizeStr = artifact.size ? ` (${artifact.size >= 1024 ? `${(artifact.size / 1024).toFixed(1)} KB` : `${artifact.size} B`})` : "";
-      this.log(`  \u251C\u2500\u2500 ${artifact.name}${sizeStr}`);
-    }
-  }
-};
-var Spinner = class {
-  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u28B0", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  interval;
-  message;
-  current = 0;
-  total = 0;
-  customStatus;
-  frameIndex = 0;
-  lastLineLength = 0;
-  constructor(message = "") {
-    this.message = message;
-  }
-  /**
-   * Start the spinner.
-   */
-  start() {
-    this.interval = setInterval(() => {
-      const frame = this.frames[this.frameIndex];
-      let output;
-      if (this.customStatus) {
-        output = `\r${frame} ${this.customStatus}`;
-      } else if (this.total > 0) {
-        output = `\r${frame} ${this.message} (${this.current}/${this.total})`;
-      } else {
-        output = `\r${frame} ${this.message}`;
-      }
-      this.lastLineLength = output.length - 1;
-      import_node_process.default.stdout.write(output);
-      if (import_node_process.default.stdout.writable) {
-        import_node_process.default.stdout.write("");
-      }
-      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-    }, 80);
-  }
-  /**
-   * Set progress counters.
-   */
-  setProgress(current, total) {
-    this.current = current;
-    this.total = total;
-  }
-  /**
-   * Set a custom status message (overrides counters).
-   */
-  setStatus(status) {
-    this.customStatus = status;
-    const frame = this.frames[this.frameIndex];
-    const output = `\r${frame} ${status}`;
-    const clearLength = Math.max(this.lastLineLength, output.length - 1);
-    import_node_process.default.stdout.write("\r" + " ".repeat(clearLength) + "\r");
-    this.lastLineLength = output.length - 1;
-    import_node_process.default.stdout.write(output);
-    if (import_node_process.default.stdout.writable) {
-      import_node_process.default.stdout.write("");
-    }
-  }
-  /**
-   * Clear the custom status message.
-   */
-  clearStatus() {
-    this.customStatus = void 0;
-  }
-  /**
-   * Stop the spinner with a completion message.
-   */
-  stop(completedMessage) {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = void 0;
-    }
-    import_node_process.default.stdout.write("\r" + " ".repeat(this.lastLineLength) + "\r");
-    if (completedMessage) {
-      import_node_process.default.stdout.write(completedMessage + "\n");
-    }
-    if (import_node_process.default.stdout.writable) {
-      import_node_process.default.stdout.write("");
-    }
-  }
-  /**
-   * Stop the spinner with a failure message.
-   */
-  fail(failedMessage) {
-    this.stop();
-    if (failedMessage) {
-      import_node_process.default.stdout.write(`\u2717 ${failedMessage}
-`);
-    }
-  }
-};
-
-// src/compiler/schema/partitioner.ts
-var DEFAULT_CONFIG = {
-  strategy: "auto",
-  threshold: 50,
-  maxGroupSize: 50,
-  complexityThreshold: 10,
-  verbose: false
-};
-function calculateSchemaComplexity(schema) {
-  let propertyCount = 0;
-  let nestedDepth = 0;
-  let refCount = 0;
-  let hasUnion = false;
-  let hasIntersection = false;
-  let hasEnum = false;
-  const jsonSize = JSON.stringify(schema).length;
-  const analyze = (s, depth) => {
-    if (!s || typeof s !== "object") return;
-    nestedDepth = Math.max(nestedDepth, depth);
-    if (s.type === "object" && s.properties) {
-      propertyCount += Object.keys(s.properties).length;
-      for (const prop of Object.values(s.properties)) {
-        analyze(prop, depth + 1);
-      }
-    }
-    if (s.$ref) refCount++;
-    if (s.anyOf || s.oneOf) hasUnion = true;
-    if (s.allOf) hasIntersection = true;
-    if (s.enum) hasEnum = true;
-    if (s.items) {
-      analyze(s.items, depth + 1);
-    }
-  };
-  analyze(schema, 0);
-  const complexity = propertyCount * 1 + nestedDepth * 2 + refCount * 0.5 + (hasUnion ? 5 : 0) + (hasIntersection ? 5 : 0) + (hasEnum ? 1 : 0);
-  return {
-    propertyCount,
-    nestedDepth,
-    refCount,
-    hasUnion,
-    hasIntersection,
-    hasEnum,
-    jsonSize
-  };
-}
-function countExternalRefs(schema, allSchemas) {
-  let count = 0;
-  const analyze = (s) => {
-    if (!s || typeof s !== "object") return;
-    if (s.$ref && typeof s.$ref === "string") {
-      const refName = s.$ref.replace("#/components/schemas/", "");
-      if (refName && allSchemas.has(refName)) {
-        count++;
-      }
-    }
-    if (s.properties) {
-      for (const prop of Object.values(s.properties)) {
-        analyze(prop);
-      }
-    }
-    if (s.items) analyze(s.items);
-    if (s.anyOf) s.anyOf.forEach(analyze);
-    if (s.oneOf) s.oneOf.forEach(analyze);
-    if (s.allOf) s.allOf.forEach(analyze);
-  };
-  analyze(schema);
-  return count;
-}
-function analyzeDependencyDensity(schemas) {
-  let totalDeps = 0;
-  let maxDeps = 0;
-  for (const schema of schemas.values()) {
-    const deps = countExternalRefs(schema, schemas);
-    totalDeps += deps;
-    maxDeps = Math.max(maxDeps, deps);
-  }
-  return {
-    avgDeps: schemas.size > 0 ? totalDeps / schemas.size : 0,
-    maxDeps
-  };
-}
-function partitionByController(schemas, graph, config) {
-  const groups = /* @__PURE__ */ new Map();
-  const sharedSchemas = /* @__PURE__ */ new Map();
-  groups.set("_shared", sharedSchemas);
-  const schemaUsage = /* @__PURE__ */ new Map();
-  for (const [nodeId, node] of graph.nodes.entries()) {
-    if (node.kind === "Operation") {
-      const opNode = node;
-      const returnType = opNode.operation?.returnType;
-      if (returnType && schemas.has(returnType)) {
-        if (!schemaUsage.has(returnType)) {
-          schemaUsage.set(returnType, /* @__PURE__ */ new Set());
-        }
-        schemaUsage.get(returnType).add(node.metadata.name);
-      }
-    }
-  }
-  for (const [schemaName, schema] of schemas.entries()) {
-    const usage = schemaUsage.get(schemaName);
-    if (!usage || usage.size === 0) {
-      sharedSchemas.set(schemaName, schema);
-    } else if (usage.size === 1) {
-      const controllerName = Array.from(usage)[0].split(":")[0] || "default";
-      const groupName = controllerName.toLowerCase();
-      if (!groups.has(groupName)) {
-        groups.set(groupName, /* @__PURE__ */ new Map());
-      }
-      groups.get(groupName).set(schemaName, schema);
-    } else {
-      sharedSchemas.set(schemaName, schema);
-    }
-  }
-  return Array.from(groups.entries()).map(([name, schemaMap]) => {
-    let totalComplexity = 0;
-    const dependencies = [];
-    for (const [schemaName, schema] of schemaMap.entries()) {
-      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
-      const deps = countExternalRefs(schema, schemas);
-      for (let i = 0; i < deps; i++) {
-        dependencies.push(schemaName);
-      }
-    }
-    return {
-      name,
-      schemas: schemaMap,
-      complexity: totalComplexity,
-      dependencies
-    };
-  });
-}
-function partitionByDependency(schemas, schemaGraph, config) {
-  const groups = /* @__PURE__ */ new Map();
-  const sccs = schemaGraph.findStronglyConnectedComponents();
-  const processed = /* @__PURE__ */ new Set();
-  for (const scc of sccs) {
-    if (scc.length === 1 && processed.has(scc[0])) continue;
-    const groupSchemas = /* @__PURE__ */ new Map();
-    const groupName = `dependent-${groups.size + 1}`;
-    for (const nodeId of scc) {
-      const node = schemaGraph.getGraph().nodes.get(nodeId);
-      if (node && node.kind === "TypeDefinition") {
-        const schemaName = node.metadata.name;
-        if (schemas.has(schemaName)) {
-          groupSchemas.set(schemaName, schemas.get(schemaName));
-          processed.add(nodeId);
-        }
-      }
-    }
-    if (groupSchemas.size > 0) {
-      groups.set(groupName, groupSchemas);
-    }
-  }
-  for (const [nodeId, node] of schemaGraph.getGraph().nodes.entries()) {
-    if (processed.has(nodeId)) continue;
-    if (node.kind !== "TypeDefinition") continue;
-    const schemaName = node.metadata.name;
-    if (!schemas.has(schemaName)) continue;
-    const groupSchemas = /* @__PURE__ */ new Map();
-    groupSchemas.set(schemaName, schemas.get(schemaName));
-    groups.set(`standalone-${groups.size + 1}`, groupSchemas);
-    processed.add(nodeId);
-  }
-  return Array.from(groups.entries()).map(([name, schemaMap]) => {
-    let totalComplexity = 0;
-    const dependencies = [];
-    for (const [schemaName, schema] of schemaMap.entries()) {
-      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
-      const deps = countExternalRefs(schema, schemas);
-      for (let i = 0; i < deps; i++) {
-        dependencies.push(schemaName);
-      }
-    }
-    return {
-      name,
-      schemas: schemaMap,
-      complexity: totalComplexity,
-      dependencies
-    };
-  });
-}
-function partitionBySize(schemas, config) {
-  const sortedSchemas = Array.from(schemas.entries()).sort((a, b) => {
-    const complexityA = calculateSchemaComplexity(a[1]).propertyCount;
-    const complexityB = calculateSchemaComplexity(b[1]).propertyCount;
-    return complexityB - complexityA;
-  });
-  const groups = /* @__PURE__ */ new Map();
-  let currentGroup = /* @__PURE__ */ new Map();
-  let currentCount = 0;
-  let groupIndex = 1;
-  for (const [schemaName, schema] of sortedSchemas) {
-    if (currentCount >= config.maxGroupSize) {
-      groups.set(`group-${groupIndex}`, currentGroup);
-      currentGroup = /* @__PURE__ */ new Map();
-      currentCount = 0;
-      groupIndex++;
-    }
-    currentGroup.set(schemaName, schema);
-    currentCount++;
-  }
-  if (currentCount > 0) {
-    groups.set(`group-${groupIndex}`, currentGroup);
-  }
-  return Array.from(groups.entries()).map(([name, schemaMap]) => {
-    let totalComplexity = 0;
-    const dependencies = [];
-    for (const [schemaName, schema] of schemaMap.entries()) {
-      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
-      const deps = countExternalRefs(schema, schemas);
-      for (let i = 0; i < deps; i++) {
-        dependencies.push(schemaName);
-      }
-    }
-    return {
-      name,
-      schemas: schemaMap,
-      complexity: totalComplexity,
-      dependencies
-    };
-  });
-}
-function determineBestStrategy(schemas, graph, schemaGraph, config) {
-  const schemaCount = schemas.size;
-  const { avgDeps } = analyzeDependencyDensity(schemas);
-  let controllerGroups = 0;
-  for (const node of graph.nodes.values()) {
-    if (node.kind === "Controller") {
-      controllerGroups++;
-    }
-  }
-  if (schemaCount < config.threshold) {
-    return "none";
-  }
-  if (avgDeps > 3) {
-    return "dependency";
-  }
-  if (controllerGroups > 1 && avgDeps < 2) {
-    return "controller";
-  }
-  return "size";
-}
-function partitionSchemas(schemas, graph, schemaGraph, config = {}) {
-  const finalConfig = { ...DEFAULT_CONFIG, ...config };
-  const schemaCount = schemas.size;
-  let totalComplexity = 0;
-  let totalSchemas = 0;
-  const { avgDeps } = analyzeDependencyDensity(schemas);
-  let controllerGroups = 0;
-  for (const node of graph.nodes.values()) {
-    if (node.kind === "Controller") {
-      controllerGroups++;
-    }
-  }
-  for (const schema of schemas.values()) {
-    totalComplexity += calculateSchemaComplexity(schema).propertyCount;
-    totalSchemas++;
-  }
-  const avgComplexity = totalSchemas > 0 ? totalComplexity / totalSchemas : 0;
-  let strategy = finalConfig.strategy;
-  let recommendation = "";
-  if (strategy === "auto") {
-    strategy = determineBestStrategy(schemas, graph, schemaGraph, finalConfig);
-    if (schemaCount < finalConfig.threshold) {
-      recommendation = `Schema count (${schemaCount}) below threshold (${finalConfig.threshold}), single file optimal`;
-    } else if (strategy === "dependency") {
-      recommendation = `High dependency density (${avgDeps.toFixed(2)} avg refs/schema), using dependency-based partitioning`;
-    } else if (strategy === "controller") {
-      recommendation = `Found ${controllerGroups} controller groups with low coupling, using controller-based partitioning`;
-    } else {
-      recommendation = `Using size-based partitioning with max ${finalConfig.maxGroupSize} schemas per group`;
-    }
-  }
-  let groups = [];
-  if (strategy === "none") {
-    groups = [{
-      name: "all",
-      schemas: new Map(schemas),
-      complexity: totalComplexity,
-      dependencies: []
-    }];
-    recommendation = recommendation || "Single file mode (--split not specified)";
-  } else if (strategy === "controller") {
-    groups = partitionByController(schemas, graph, finalConfig);
-  } else if (strategy === "dependency") {
-    groups = partitionByDependency(schemas, schemaGraph, finalConfig);
-  } else {
-    groups = partitionBySize(schemas, finalConfig);
-  }
-  const shouldSplit = strategy !== "none" && schemaCount >= finalConfig.threshold;
-  return {
-    shouldSplit,
-    strategy,
-    groups,
-    recommendation,
-    metrics: {
-      totalSchemas: schemaCount,
-      averageComplexity: avgComplexity,
-      avgDependencyDensity: avgDeps,
-      controllerGroups
-    }
-  };
-}
-
-// src/compiler/schema/splitOpenapi.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
-function sanitizeFilename(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function getSchemaFilename(group) {
-  const name = sanitizeFilename(group.name);
-  return `schemas/${name}.json`;
-}
-function collectAllSchemas(groups) {
-  const result = /* @__PURE__ */ new Map();
-  for (const group of groups) {
-    for (const [schemaName, schema] of group.schemas.entries()) {
-      result.set(schemaName, { schema, group: group.name });
-    }
-  }
-  return result;
-}
-function convertToExternalRef(schema, schemaMap) {
-  if (!schema || typeof schema !== "object") return schema;
-  const result = { ...schema };
-  if (schema.$ref && typeof schema.$ref === "string") {
-    const refName = schema.$ref.replace("#/components/schemas/", "");
-    if (refName && schemaMap.has(refName)) {
-      const target = schemaMap.get(refName);
-      const filename = sanitizeFilename(target.group);
-      result.$ref = `schemas/${filename}.json#/components/schemas/${refName}`;
-    }
-  }
-  const nestedProps = ["properties", "items", "additionalProperties"];
-  for (const prop of nestedProps) {
-    if (prop in result) {
-      const value = result[prop];
-      if (Array.isArray(value)) {
-        result[prop] = value.map(
-          (item) => typeof item === "object" ? convertToExternalRef(item, schemaMap) : item
-        );
-      } else if (typeof value === "object" && value !== null) {
-        result[prop] = convertToExternalRef(value, schemaMap);
-      }
-    }
-  }
-  const arrayProps = ["anyOf", "oneOf", "allOf"];
-  for (const prop of arrayProps) {
-    if (prop in result && Array.isArray(result[prop])) {
-      result[prop] = result[prop].map(
-        (item) => typeof item === "object" ? convertToExternalRef(item, schemaMap) : item
-      );
-    }
-  }
-  return result;
-}
-function generateSchemaFileContent(group, schemaMap) {
-  const content = {};
-  for (const [schemaName, schema] of group.schemas.entries()) {
-    content[schemaName] = convertToExternalRef(schema, schemaMap);
-  }
-  return content;
-}
-function generateSchemaIndex(groups, schemaMap) {
-  const index = {
-    schemas: {}
-  };
-  for (const [schemaName, { group }] of schemaMap.entries()) {
-    const filename = sanitizeFilename(group);
-    index.schemas[schemaName] = {
-      $ref: `schemas/${filename}.json#/components/schemas/${schemaName}`
-    };
-  }
-  return index;
-}
-function generateModularOpenAPI(openapi, partitioning, config) {
-  const {
-    outputDir,
-    schemasDir = "schemas",
-    createIndexFile = true,
-    prettyPrint = true,
-    onProgress
-  } = config;
-  const indent = prettyPrint ? 2 : 0;
-  let totalSize = 0;
-  const schemaFiles = [];
-  (0, import_node_fs5.mkdirSync)(outputDir, { recursive: true });
-  if (!partitioning.shouldSplit || partitioning.groups.length === 1) {
-    if (onProgress) {
-      onProgress("Writing single OpenAPI file", 1, 1);
-    }
-    const mainPath2 = (0, import_node_path5.resolve)(outputDir, "openapi.json");
-    (0, import_node_fs5.writeFileSync)(mainPath2, JSON.stringify(openapi, null, indent));
-    totalSize = Buffer.byteLength(JSON.stringify(openapi));
-    return {
-      mainSpec: mainPath2,
-      schemaFiles: [],
-      totalSize,
-      splitEnabled: false
-    };
-  }
-  const schemasPath = (0, import_node_path5.resolve)(outputDir, schemasDir);
-  (0, import_node_fs5.mkdirSync)(schemasPath, { recursive: true });
-  if (onProgress) {
-    onProgress("Creating schemas directory", 0, partitioning.groups.length + 2);
-  }
-  const schemaMap = collectAllSchemas(partitioning.groups);
-  const schemaToFile = /* @__PURE__ */ new Map();
-  for (let i = 0; i < partitioning.groups.length; i++) {
-    const group = partitioning.groups[i];
-    if (onProgress) {
-      onProgress(`Writing schema group ${group.name} (${group.schemas.size} schemas)`, i + 1, partitioning.groups.length + 2);
-    }
-    const filename = getSchemaFilename(group);
-    const filePath = (0, import_node_path5.resolve)(outputDir, filename);
-    const content = generateSchemaFileContent(group, schemaMap);
-    (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(content, null, indent));
-    for (const schemaName of group.schemas.keys()) {
-      schemaToFile.set(schemaName, filename);
-    }
-    schemaFiles.push(filePath);
-    totalSize += Buffer.byteLength(JSON.stringify(content));
-  }
-  let indexFile;
-  if (createIndexFile) {
-    if (onProgress) {
-      onProgress("Generating index file", partitioning.groups.length + 1, partitioning.groups.length + 2);
-    }
-    const indexPath = (0, import_node_path5.resolve)(outputDir, "schemas/index.json");
-    const indexContent = generateSchemaIndex(partitioning.groups, schemaMap);
-    (0, import_node_fs5.writeFileSync)(indexPath, JSON.stringify(indexContent, null, indent));
-    totalSize += Buffer.byteLength(JSON.stringify(indexContent));
-    indexFile = indexPath;
-  }
-  if (onProgress) {
-    onProgress("Generating main OpenAPI spec", partitioning.groups.length + 2, partitioning.groups.length + 2);
-  }
-  const mainSpec = generateMainSpec(openapi, schemaMap, schemaToFile);
-  const mainPath = (0, import_node_path5.resolve)(outputDir, "openapi.json");
-  (0, import_node_fs5.writeFileSync)(mainPath, JSON.stringify(mainSpec, null, indent));
-  totalSize += Buffer.byteLength(JSON.stringify(mainSpec));
-  return {
-    mainSpec: mainPath,
-    schemaFiles,
-    indexFile,
-    totalSize,
-    splitEnabled: true
-  };
-}
-function generateMainSpec(original, schemaMap, schemaToFile) {
-  const schemas = {};
-  for (const [schemaName, { group }] of schemaMap.entries()) {
-    const filename = sanitizeFilename(group);
-    schemas[schemaName] = {
-      $ref: `schemas/${filename}.json#/components/schemas/${schemaName}`
-    };
-  }
-  return {
-    ...original,
-    components: {
-      ...original.components,
-      schemas
-    },
-    "x-original-schemas": Object.keys(schemaMap).length,
-    "x-split-enabled": true,
-    "x-schema-files": Array.from(new Set(schemaToFile.values()))
-  };
-}
-
-// src/compiler/graph/types.ts
-function createGraph(tsVersion) {
-  return {
-    nodes: /* @__PURE__ */ new Map(),
-    roots: /* @__PURE__ */ new Set(),
-    version: "1.0.0",
-    metadata: {
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      generatedBy: "adorn-api-gems",
-      tsVersion
-    }
-  };
-}
-function addNode(graph, node) {
-  graph.nodes.set(node.id, node);
-}
-function addEdge(graph, sourceId, targetId, relation, properties) {
-  const sourceNode = graph.nodes.get(sourceId);
-  if (!sourceNode) {
-    throw new Error(`Source node ${sourceId} not found`);
-  }
-  const targetExists = graph.nodes.has(targetId);
-  if (!targetExists) {
-    throw new Error(`Target node ${targetId} not found`);
-  }
-  sourceNode.edges.push({
-    targetId,
-    relation,
-    properties
-  });
-}
-function getEdgesByRelation(graph, relation) {
-  const edges = [];
-  for (const [id, node] of graph.nodes.entries()) {
-    for (const edge of node.edges) {
-      if (edge.relation === relation) {
-        edges.push({ sourceId: id, edge });
-      }
-    }
-  }
-  return edges;
-}
-
-// src/compiler/graph/builder.ts
-var import_typescript15 = __toESM(require("typescript"), 1);
-
-// src/compiler/graph/schemaGraph.ts
-var SchemaGraph = class {
-  graph;
-  adjacency = /* @__PURE__ */ new Map();
-  reverseAdjacency = /* @__PURE__ */ new Map();
-  constructor(graph) {
-    this.graph = graph;
-    this.buildAdjacencyLists();
-  }
-  /**
-   * Build adjacency lists for faster traversal
-   */
-  buildAdjacencyLists() {
-    for (const [id, node] of this.graph.nodes.entries()) {
-      this.adjacency.set(id, /* @__PURE__ */ new Set());
-      this.reverseAdjacency.set(id, /* @__PURE__ */ new Set());
-    }
-    for (const [sourceId, node] of this.graph.nodes.entries()) {
-      for (const edge of node.edges) {
-        this.adjacency.get(sourceId)?.add(edge.targetId);
-        this.reverseAdjacency.get(edge.targetId)?.add(sourceId);
-      }
-    }
-  }
-  /**
-   * Find all nodes that use a given type
-   */
-  findTypeUsages(typeId) {
-    const usages = [];
-    const usesEdges = getEdgesByRelation(this.graph, "uses");
-    for (const { sourceId, edge } of usesEdges) {
-      if (edge.targetId === typeId) {
-        usages.push(sourceId);
-      }
-    }
-    return usages;
-  }
-  /**
-   * Detect cycles in the dependency graph
-   */
-  detectCycles() {
-    const visited = /* @__PURE__ */ new Set();
-    const recursionStack = /* @__PURE__ */ new Set();
-    const cycles = [];
-    for (const nodeId of this.graph.nodes.keys()) {
-      if (!visited.has(nodeId)) {
-        this.detectCyclesDFS(nodeId, visited, recursionStack, [], cycles);
-      }
-    }
-    return {
-      hasCycles: cycles.length > 0,
-      cycles,
-      cycleCount: cycles.length
-    };
-  }
-  /**
-   * Depth-first search for cycle detection
-   */
-  detectCyclesDFS(nodeId, visited, recursionStack, path4, cycles) {
-    visited.add(nodeId);
-    recursionStack.add(nodeId);
-    path4.push(nodeId);
-    const neighbors = this.adjacency.get(nodeId) || /* @__PURE__ */ new Set();
-    for (const neighbor of neighbors) {
-      if (!visited.has(neighbor)) {
-        this.detectCyclesDFS(neighbor, visited, recursionStack, path4, cycles);
-      } else if (recursionStack.has(neighbor)) {
-        const cycleStart = path4.indexOf(neighbor);
-        cycles.push([...path4.slice(cycleStart), neighbor]);
-      }
-    }
-    recursionStack.delete(nodeId);
-    path4.pop();
-  }
-  /**
-   * Find strongly connected components using Tarjan's algorithm
-   */
-  findStronglyConnectedComponents() {
-    let index = 0;
-    const stack = [];
-    const indices = /* @__PURE__ */ new Map();
-    const lowlinks = /* @__PURE__ */ new Map();
-    const onStack = /* @__PURE__ */ new Set();
-    const sccs = [];
-    const strongConnect = (v) => {
-      indices.set(v, index);
-      lowlinks.set(v, index);
-      index++;
-      stack.push(v);
-      onStack.add(v);
-      const neighbors = this.adjacency.get(v) || /* @__PURE__ */ new Set();
-      for (const w of neighbors) {
-        if (!indices.has(w)) {
-          strongConnect(w);
-          lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
-        } else if (onStack.has(w)) {
-          lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
-        }
-      }
-      if (lowlinks.get(v) === indices.get(v)) {
-        const scc = [];
-        let w;
-        do {
-          w = stack.pop();
-          onStack.delete(w);
-          scc.push(w);
-        } while (w !== v);
-        sccs.push(scc);
-      }
-    };
-    for (const nodeId of this.graph.nodes.keys()) {
-      if (!indices.has(nodeId)) {
-        strongConnect(nodeId);
-      }
-    }
-    return sccs;
-  }
-  /**
-   * Topological sort of the graph
-   */
-  topologicalSort() {
-    const inDegree = /* @__PURE__ */ new Map();
-    for (const nodeId of this.graph.nodes.keys()) {
-      inDegree.set(nodeId, 0);
-    }
-    for (const [sourceId, node] of this.graph.nodes.entries()) {
-      for (const edge of node.edges) {
-        inDegree.set(
-          edge.targetId,
-          (inDegree.get(edge.targetId) || 0) + 1
-        );
-      }
-    }
-    const queue = [];
-    for (const [nodeId, degree] of inDegree.entries()) {
-      if (degree === 0) {
-        queue.push(nodeId);
-      }
-    }
-    const sorted = [];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      sorted.push(current);
-      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
-      for (const neighbor of neighbors) {
-        inDegree.set(neighbor, inDegree.get(neighbor) - 1);
-        if (inDegree.get(neighbor) === 0) {
-          queue.push(neighbor);
-        }
-      }
-    }
-    return sorted;
-  }
-  /**
-   * Find nodes reachable from a given start node
-   */
-  findReachable(startNodeId) {
-    const reachable = /* @__PURE__ */ new Set();
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [startNodeId];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (visited.has(current)) continue;
-      visited.add(current);
-      reachable.add(current);
-      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
-      for (const neighbor of neighbors) {
-        if (!visited.has(neighbor)) {
-          queue.push(neighbor);
-        }
-      }
-    }
-    return reachable;
-  }
-  /**
-   * Find shortest path between two nodes (BFS)
-   */
-  findShortestPath(fromId, toId) {
-    const visited = /* @__PURE__ */ new Set();
-    const previous = /* @__PURE__ */ new Map();
-    const queue = [fromId];
-    visited.add(fromId);
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current === toId) {
-        return this.reconstructPath(previous, toId);
-      }
-      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
-      for (const neighbor of neighbors) {
-        if (!visited.has(neighbor)) {
-          visited.add(neighbor);
-          previous.set(neighbor, current);
-          queue.push(neighbor);
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Reconstruct path from previous map
-   */
-  reconstructPath(previous, toId) {
-    const path4 = [toId];
-    let current = toId;
-    while (current !== void 0) {
-      current = previous.get(current);
-      if (current !== void 0) {
-        path4.unshift(current);
-      }
-    }
-    return path4;
-  }
-  /**
-   * Get nodes grouped by their depth from roots
-   */
-  getDepthGroups() {
-    const depths = /* @__PURE__ */ new Map();
-    const groups = /* @__PURE__ */ new Map();
-    for (const rootId of this.graph.roots) {
-      const queue = [rootId];
-      depths.set(rootId, 0);
-      while (queue.length > 0) {
-        const current = queue.shift();
-        const currentDepth = depths.get(current);
-        for (const neighbor of this.adjacency.get(current) || /* @__PURE__ */ new Set()) {
-          const newDepth = currentDepth + 1;
-          if (!depths.has(neighbor) || depths.get(neighbor) > newDepth) {
-            depths.set(neighbor, newDepth);
-            queue.push(neighbor);
-          }
-        }
-      }
-    }
-    for (const [nodeId, depth] of depths.entries()) {
-      if (!groups.has(depth)) {
-        groups.set(depth, []);
-      }
-      groups.get(depth).push(nodeId);
-    }
-    return groups;
-  }
-  /**
-   * Get the underlying graph
-   */
-  getGraph() {
-    return this.graph;
-  }
-};
-
-// src/cli.ts
-var import_typescript16 = __toESM(require("typescript"), 1);
-var import_node_process2 = __toESM(require("process"), 1);
-var import_meta2 = {};
-var ADORN_VERSION = (() => {
-  const tryReadPackageJson = (filePath) => {
-    try {
-      const pkg = JSON.parse((0, import_node_fs6.readFileSync)(filePath, "utf-8"));
-      return pkg.version ?? null;
-    } catch {
-      return null;
-    }
-  };
-  const potentialPaths = [];
-  try {
-    const importMetaUrl = import_meta2?.url;
-    if (importMetaUrl && typeof importMetaUrl === "string" && importMetaUrl.length > 0) {
-      const cliDir = (0, import_node_path6.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
-      potentialPaths.push(
-        (0, import_node_path6.resolve)(cliDir, "..", "package.json"),
-        (0, import_node_path6.resolve)(cliDir, "package.json")
-      );
-    }
-  } catch {
-  }
-  const cwd = import_node_process2.default.cwd();
-  potentialPaths.push(
-    (0, import_node_path6.resolve)(cwd, "package.json"),
-    (0, import_node_path6.resolve)(cwd, "node_modules", "adorn-api", "package.json"),
-    (0, import_node_path6.resolve)(cwd, "..", "package.json"),
-    (0, import_node_path6.resolve)(cwd, "..", "..", "package.json")
-  );
-  for (const pkgPath of potentialPaths) {
-    const version = tryReadPackageJson(pkgPath);
-    if (version) {
-      return version;
-    }
-  }
-  return "0.0.0";
-})();
-function log(msg, options) {
-  if (options?.indent) {
-    import_node_process2.default.stdout.write("  " + msg + "\n");
-  } else {
-    import_node_process2.default.stdout.write(msg + "\n");
-  }
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function getFileSize(path4) {
-  try {
-    return (0, import_node_fs6.statSync)(path4).size;
-  } catch {
-    return void 0;
-  }
-}
-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;
-}
-function buildControllerGraph(controllers) {
-  const graph = createGraph(import_typescript16.default.version);
-  const nodeMap = /* @__PURE__ */ new Map();
-  for (const ctrl of controllers) {
-    const nodeId = `Controller:${ctrl.className}`;
-    const node = {
-      id: nodeId,
-      kind: "Controller",
-      metadata: {
-        name: ctrl.className,
-        sourceLocation: { filePath: "", line: 0, column: 0 },
-        tags: /* @__PURE__ */ new Set(),
-        annotations: /* @__PURE__ */ new Map()
-      },
-      edges: [],
-      controller: {
-        basePath: ctrl.basePath
-      }
-    };
-    addNode(graph, node);
-    nodeMap.set(nodeId, node);
-  }
-  let opIndex = 0;
-  for (const ctrl of controllers) {
-    for (const op of ctrl.operations) {
-      const nodeId = `Operation:${op.operationId}`;
-      const node = {
-        id: nodeId,
-        kind: "Operation",
-        metadata: {
-          name: op.operationId,
-          sourceLocation: { filePath: "", line: 0, column: 0 },
-          tags: /* @__PURE__ */ new Set(),
-          annotations: /* @__PURE__ */ new Map()
-        },
-        edges: [],
-        operation: {
-          httpMethod: op.httpMethod,
-          path: op.path,
-          operationId: op.operationId,
-          returnType: op.returnType || ""
-        }
-      };
-      addNode(graph, node);
-      nodeMap.set(nodeId, node);
-      const ctrlNode = nodeMap.get(`Controller:${ctrl.className}`);
-      if (ctrlNode) {
-        addEdge(graph, ctrlNode.id, node.id, "contains");
-      }
-      opIndex++;
-    }
-  }
-  for (const ctrl of controllers) {
-    for (const op of ctrl.operations) {
-      if (op.returnType && !nodeMap.has(op.returnType)) {
-        const node = {
-          id: op.returnType,
-          kind: "TypeDefinition",
-          metadata: {
-            name: op.returnType,
-            sourceLocation: { filePath: "", line: 0, column: 0 },
-            tags: /* @__PURE__ */ new Set(),
-            annotations: /* @__PURE__ */ new Map()
-          },
-          edges: [],
-          typeDef: {
-            isGeneric: false,
-            properties: /* @__PURE__ */ new Map()
-          }
-        };
-        addNode(graph, node);
-        nodeMap.set(op.returnType, node);
-        const opNodeId = `Operation:${op.operationId}`;
-        const opNode = nodeMap.get(opNodeId);
-        if (opNode) {
-          addEdge(graph, opNode.id, node.id, "uses");
-        }
-      }
-    }
-  }
-  return graph;
-}
-async function buildCommand(args) {
-  const progress = new ProgressTracker({ verbose: args.includes("--verbose"), quiet: args.includes("--quiet") });
-  const projectIndex = args.indexOf("-p");
-  const projectPath = projectIndex !== -1 ? args[projectIndex + 1] : "./tsconfig.json";
-  const outputDir = args.includes("--output") ? args[args.indexOf("--output") + 1] : ".adorn";
-  const ifStale = args.includes("--if-stale");
-  const validationModeIndex = args.indexOf("--validation-mode");
-  const validationMode = validationModeIndex !== -1 ? args[validationModeIndex + 1] : "ajv-runtime";
-  const verbose = args.includes("--verbose");
-  const quiet = args.includes("--quiet");
-  const split = args.includes("--split");
-  const showQueryBuilder = args.includes("--show-query-builder");
-  const splitStrategyIndex = args.indexOf("--split-strategy");
-  const splitStrategy = splitStrategyIndex !== -1 ? args[splitStrategyIndex + 1] : void 0;
-  const splitThresholdIndex = args.indexOf("--split-threshold");
-  const splitThreshold = splitThresholdIndex !== -1 ? parseInt(args[splitThresholdIndex + 1], 10) : 50;
-  if (validationMode !== "none" && validationMode !== "ajv-runtime" && validationMode !== "precompiled") {
-    console.error(`Invalid validation mode: ${validationMode}. Valid values: none, ajv-runtime, precompiled`);
-    import_node_process2.default.exit(1);
-  }
-  const outputPath = (0, import_node_path6.resolve)(outputDir);
-  if (!quiet) {
-    log(`adorn-api v${ADORN_VERSION} - Building API artifacts`);
-    log("");
-  }
-  if (ifStale) {
-    progress.startPhase("staleness-check", "Checking for stale artifacts");
-    const stale = await isStale({
-      outDir: outputDir,
-      project: projectPath,
-      adornVersion: ADORN_VERSION,
-      typescriptVersion: import_typescript16.default.version
-    });
-    if (!stale.stale) {
-      progress.completePhase("staleness-check");
-      if (!quiet) {
-        log("adorn-api: artifacts up-to-date");
-      }
-      return;
-    }
-    progress.completePhase("staleness-check", `Artifacts stale (${stale.reason})`);
-    if (verbose) {
-      progress.verboseLog(`Stale reason: ${stale.detail || stale.reason}`);
-    }
-  } else {
-    progress.startPhase("configuration", "Initializing build");
-    progress.completePhase("configuration", "Build forced (--if-stale not used)");
-  }
-  progress.startPhase("program", "Loading TypeScript configuration");
-  if (verbose) {
-    progress.verboseLog(`Loading ${projectPath}`);
-  }
-  const { program, checker, sourceFiles } = createProgramFromConfig(projectPath);
-  const projectSourceFiles = sourceFiles.filter((sf) => !sf.fileName.includes("node_modules"));
-  progress.completePhase("program");
-  if (verbose) {
-    progress.verboseLog(`Found ${projectSourceFiles.length} source files`);
-  }
-  progress.startPhase("scan", "Scanning for controllers");
-  const controllers = scanControllers(sourceFiles, checker);
-  if (controllers.length === 0) {
-    console.warn("No controllers found!");
-    import_node_process2.default.exit(1);
-  }
-  const totalOperations = controllers.reduce((sum, ctrl) => sum + ctrl.operations.length, 0);
-  progress.completePhase("scan", `Found ${controllers.length} controller(s) with ${totalOperations} operation(s)`);
-  if (verbose) {
-    for (const ctrl of controllers) {
-      progress.verboseLog(`Controller: ${ctrl.className} (${ctrl.basePath}) - ${ctrl.operations.length} operations`);
-    }
-  }
-  progress.startPhase("openapi", "Generating OpenAPI schema");
-  const queryBuilderStats = {
-    totalOperations,
-    detected: 0,
-    fallback: 0,
-    operations: []
-  };
-  const openapiSpinner = new Spinner("Processing schemas");
-  if (!quiet) openapiSpinner.start();
-  const openapi = generateOpenAPI(controllers, checker, {
-    title: "API",
-    version: "1.0.0",
-    onProgress: (message, current, total) => {
-      if (!quiet) {
-        openapiSpinner.setStatus(`${message} (${current}/${total})`);
-      }
-    },
-    onQueryBuilderProgress: (info) => {
-      if (info.queryBuilderDetected) {
-        queryBuilderStats.detected++;
-      } else {
-        queryBuilderStats.fallback++;
-      }
-      queryBuilderStats.operations.push({
-        operationId: info.operation,
-        method: info.method,
-        path: info.path,
-        detected: info.queryBuilderDetected,
-        entityName: info.entityName,
-        selectedFields: info.selectedFields,
-        isPaged: info.isPaged
-      });
-      if (showQueryBuilder || verbose) {
-        if (info.queryBuilderDetected) {
-          const fieldsStr = info.selectedFields && info.selectedFields.length > 0 ? ` [select: ${info.selectedFields.join(",")}]` : "";
-          const pagedStr = info.isPaged ? " (paged)" : "";
-          progress.verboseLog(`  \u2713 Query builder: ${info.method} ${info.path} \u2192 ${info.entityName}${fieldsStr}${pagedStr}`);
-        } else {
-          progress.verboseLog(`  \u25CB No query builder: ${info.method} ${info.path} \u2192 using full entity schema`);
-        }
-      }
-    }
-  });
-  if (!quiet) {
-    openapiSpinner.setStatus(`Processed ${controllers.length} controllers, ${totalOperations} operations`);
-  }
-  if (!quiet) openapiSpinner.stop();
-  const schemaCount = Object.keys(openapi.components?.schemas || {}).length;
-  let splitEnabled = false;
-  if (split && schemaCount >= splitThreshold) {
-    progress.verboseLog(`Schema count (${schemaCount}) >= threshold (${splitThreshold}), analyzing for auto-split...`);
-    const graph = buildControllerGraph(controllers);
-    const schemaGraph = new SchemaGraph(graph);
-    const schemasMap = new Map(Object.entries(openapi.components?.schemas || {}));
-    const strategy = splitStrategy || "auto";
-    const partitioning = partitionSchemas(schemasMap, graph, schemaGraph, {
-      strategy,
-      threshold: splitThreshold,
-      verbose
-    });
-    splitEnabled = partitioning.shouldSplit;
-    if (splitEnabled) {
-      progress.verboseLog(`Partitioning result: ${partitioning.strategy} strategy`);
-      progress.verboseLog(`Recommendation: ${partitioning.recommendation}`);
-      if (!quiet) {
-        log(`  Auto-split enabled: ${partitioning.strategy} strategy`);
-      }
-      const splitSpinner = new Spinner("Writing split schema files");
-      if (!quiet) splitSpinner.start();
-      generateModularOpenAPI(openapi, partitioning, {
-        outputDir: outputPath,
-        schemasDir: "schemas",
-        createIndexFile: true,
-        prettyPrint: true,
-        onProgress: (step, index, total) => {
-          if (!quiet) {
-            progress.logSub(`${step} (${index}/${total})`);
-          }
-        }
-      });
-      if (!quiet) splitSpinner.stop();
-      if (!quiet) {
-        log(`  Schema groups: ${partitioning.groups.length}`);
-      }
-    } else {
-      if (!quiet) {
-        log(`  Auto-split not needed: ${partitioning.recommendation}`);
-      }
-    }
-  } else if (!split) {
-    if (!quiet) {
-      log(`  Splitting disabled (--split not specified)`);
-    }
-  } else {
-    if (!quiet) {
-      log(`  Schema count (${schemaCount}) below threshold (${splitThreshold}), single file mode`);
-    }
-  }
-  progress.completePhase("openapi", `Generated ${schemaCount} schema(s)${splitEnabled ? " (split into groups)" : ""}`);
-  if (showQueryBuilder && totalOperations > 0) {
-    log("");
-    log("Query Builder Analysis:");
-    log(`  Operations analyzed:    ${totalOperations}`);
-    log(`  Patterns detected:      ${queryBuilderStats.detected} (${Math.round(queryBuilderStats.detected / totalOperations * 100)}%)`);
-    log(`  Full schemas used:      ${queryBuilderStats.fallback} (${Math.round(queryBuilderStats.fallback / totalOperations * 100)}%)`);
-    if (queryBuilderStats.detected > 0) {
-      const totalFields = queryBuilderStats.operations.filter((op) => op.detected && op.selectedFields).reduce((sum, op) => sum + (op.selectedFields?.length || 0), 0);
-      log(`  Fields selected:        ${totalFields} total (avg ${Math.round(totalFields / queryBuilderStats.detected)} per query)`);
-    }
-  }
-  progress.startPhase("manifest", "Generating manifest");
-  const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
-  progress.completePhase("manifest");
-  progress.startPhase("write", "Writing artifacts");
-  (0, import_node_fs6.mkdirSync)(outputPath, { recursive: true });
-  const openapiPath = (0, import_node_path6.resolve)(outputPath, "openapi.json");
-  const manifestPath = (0, import_node_path6.resolve)(outputPath, "manifest.json");
-  if (!splitEnabled) {
-    (0, import_node_fs6.writeFileSync)(openapiPath, JSON.stringify(sanitizeForJson(openapi), null, 2));
-  }
-  (0, import_node_fs6.writeFileSync)(manifestPath, JSON.stringify(manifest, null, 2));
-  const artifacts = [
-    { name: "openapi.json", size: getFileSize(openapiPath) },
-    { name: "manifest.json", size: getFileSize(manifestPath) }
-  ];
-  if (splitEnabled) {
-    const schemasDir = (0, import_node_path6.resolve)(outputPath, "schemas");
-    if ((0, import_node_fs6.existsSync)(schemasDir)) {
-      const fs4 = await import("fs");
-      const files = fs4.readdirSync(schemasDir);
-      for (const file of files) {
-        const filePath = (0, import_node_path6.resolve)(schemasDir, file);
-        artifacts.push({ name: `schemas/${file}`, size: getFileSize(filePath) });
-      }
-    }
-  }
-  if (verbose) {
-    for (const artifact of artifacts) {
-      progress.verboseLog(`Written: ${artifact.name} (${formatBytes(artifact.size || 0)})`);
-    }
-  }
-  if (validationMode === "precompiled") {
-    progress.startPhase("validators", "Generating precompiled validators");
-    const manifestObj = JSON.parse((0, import_node_fs6.readFileSync)(manifestPath, "utf-8"));
-    const spinner = new Spinner("Generating validators...");
-    if (!quiet) spinner.start();
-    await emitPrecompiledValidators({
-      outDir: outputPath,
-      openapi,
-      manifest: manifestObj,
-      strict: "off",
-      formatsMode: "full"
-    });
-    if (!quiet) spinner.stop();
-    manifestObj.validation = {
-      mode: "precompiled",
-      precompiledModule: "./validators.mjs"
-    };
-    (0, import_node_fs6.writeFileSync)(manifestPath, JSON.stringify(manifestObj, null, 2));
-    const validatorsCjsPath = (0, import_node_path6.resolve)(outputPath, "validators.cjs");
-    const validatorsMjsPath = (0, import_node_path6.resolve)(outputPath, "validators.mjs");
-    const validatorsMetaPath = (0, import_node_path6.resolve)(outputPath, "validators.meta.json");
-    artifacts.push(
-      { name: "validators.cjs", size: getFileSize(validatorsCjsPath) },
-      { name: "validators.mjs", size: getFileSize(validatorsMjsPath) },
-      { name: "validators.meta.json", size: getFileSize(validatorsMetaPath) }
-    );
-    progress.completePhase("validators");
-    if (verbose) {
-      progress.verboseLog("Precompiled validators generated successfully");
-    }
-  }
-  progress.startPhase("cache", "Writing cache");
-  writeCache({
-    outDir: outputDir,
-    tsconfigAbs: (0, import_node_path6.resolve)(projectPath),
-    program,
-    adornVersion: ADORN_VERSION
-  });
-  const cachePath = (0, import_node_path6.resolve)(outputPath, "cache.json");
-  artifacts.push({ name: "cache.json", size: getFileSize(cachePath) });
-  progress.completePhase("cache");
-  if (verbose) {
-    progress.verboseLog(`Written: cache.json (${formatBytes(getFileSize(cachePath) || 0)})`);
-  }
-  const stats = {
-    controllers: controllers.length,
-    operations: totalOperations,
-    schemas: schemaCount,
-    sourceFiles: projectSourceFiles.length,
-    artifactsWritten: artifacts.map((a) => a.name),
-    splitEnabled,
-    queryBuilder: {
-      detected: queryBuilderStats.detected,
-      fallback: queryBuilderStats.fallback,
-      total: totalOperations
-    }
-  };
-  progress.printSummary(stats);
-  progress.printArtifacts(artifacts);
-}
-function cleanCommand(args) {
-  const quiet = args.includes("--quiet");
-  const outputDir = args.includes("--output") ? args[args.indexOf("--output") + 1] : ".adorn";
-  const outputPath = (0, import_node_path6.resolve)(outputDir);
-  if ((0, import_node_fs6.existsSync)(outputPath)) {
-    (0, import_node_fs6.rmSync)(outputPath, { recursive: true, force: true });
-  }
-  if (!quiet) {
-    log(`adorn-api: cleaned ${outputDir}`);
-  }
-}
-var command = import_node_process2.default.argv[2];
-if (command === "build") {
-  buildCommand(import_node_process2.default.argv.slice(3)).catch((err) => {
-    console.error(err);
-    import_node_process2.default.exit(1);
-  });
-} else if (command === "clean") {
-  cleanCommand(import_node_process2.default.argv.slice(3));
-} else {
-  console.log(`
-adorn-api CLI v${ADORN_VERSION}
-
- Commands:
-   build     Generate OpenAPI and manifest from TypeScript source
-   clean     Remove generated artifacts
-
-  Options:
-   -p <path>                Path to tsconfig.json (default: ./tsconfig.json)
-   --output <dir>           Output directory (default: .adorn)
-   --if-stale               Only rebuild if artifacts are stale
-   --validation-mode <mode> Validation mode: none, ajv-runtime, precompiled (default: ajv-runtime)
-   --split                  Enable automatic schema splitting (default: disabled)
-   --split-strategy <mode>  Override splitting strategy: controller, dependency, size, auto (default: auto)
-   --split-threshold <num>  Schema count threshold for auto-split (default: 50)
-   --verbose                Show detailed progress information
-   --quiet                  Suppress non-essential output
-   --show-query-builder     Show query builder inspection details and statistics
-
- Examples:
-   adorn-api build -p ./tsconfig.json --output .adorn
-   adorn-api build --if-stale
-   adorn-api build --validation-mode precompiled
-   adorn-api build --verbose
-   adorn-api build --show-query-builder  # Show query builder analysis details
-   adorn-api build --split                 # Enable split mode
-   adorn-api build --split-strategy controller  # Force controller-based splitting
-   adorn-api build --split-threshold 100   # Increase threshold to 100
-   adorn-api clean
-   `);
-}
-//# sourceMappingURL=cli.cjs.map