adorn-api 1.0.4 → 1.0.6

package/dist/cli.cjs

@@ -0,0 +1,1571 @@
+#!/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_fs5 = require("fs");
+var import_node_path5 = require("path");
+
+// 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 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,
+    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 typeStr = param.type.getSymbol()?.getName() ?? "";
+    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(param.type, 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;
+  if (!objectFlags) return false;
+  const symbol = type.getSymbol();
+  if (symbol?.getName() === "__object") return true;
+  const properties = checker.getPropertiesOfType(type);
+  if (properties.length > 0) return true;
+  const callSignatures = type.getCallSignatures();
+  if (callSignatures && callSignatures.length > 0) return false;
+  return true;
+}
+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;
+}
+
+// src/compiler/schema/openapi.ts
+var import_typescript5 = __toESM(require("typescript"), 1);
+
+// src/compiler/schema/typeToJsonSchema.ts
+var import_typescript3 = __toESM(require("typescript"), 1);
+function typeToJsonSchema(type, ctx, typeNode) {
+  const { checker } = ctx;
+  if (type.flags & import_typescript3.default.TypeFlags.Undefined) {
+    return {};
+  }
+  if (type.flags & import_typescript3.default.TypeFlags.Null) {
+    return { type: "null" };
+  }
+  if (type.flags & import_typescript3.default.TypeFlags.String) {
+    return { type: "string" };
+  }
+  if (type.flags & import_typescript3.default.TypeFlags.Number) {
+    return { type: "number" };
+  }
+  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"] };
+  }
+  if (type.isUnion()) {
+    return handleUnion(type.types, ctx, typeNode);
+  }
+  if (type.isIntersection()) {
+    return handleIntersection(type.types, ctx, typeNode);
+  }
+  if (checker.isArrayType(type)) {
+    const typeArgs = type.typeArguments;
+    const itemType = typeArgs?.[0];
+    const items = itemType ? typeToJsonSchema(itemType, ctx) : {};
+    return {
+      type: "array",
+      items,
+      uniqueItems: isSetType(type, checker) ? true : void 0
+    };
+  }
+  if (type.flags & import_typescript3.default.TypeFlags.Object) {
+    return handleObjectType(type, 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;
+}
+function handleUnion(types, ctx, typeNode) {
+  const nullType = types.find((t) => t.flags & import_typescript3.default.TypeFlags.Null);
+  const otherTypes = types.filter((t) => !(t.flags & import_typescript3.default.TypeFlags.Null) && !(t.flags & import_typescript3.default.TypeFlags.Undefined));
+  const allStringLiterals = otherTypes.every((t) => t.flags & import_typescript3.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;
+  }
+  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 handleIntersection(types, ctx, typeNode) {
+  const brandCollapsed = tryCollapseBrandedIntersection(types, ctx, typeNode);
+  if (brandCollapsed) {
+    return brandCollapsed;
+  }
+  const allOf = [];
+  for (const t of types) {
+    allOf.push(typeToJsonSchema(t, ctx));
+  }
+  return { allOf };
+}
+function tryCollapseBrandedIntersection(types, ctx, typeNode) {
+  const { checker } = ctx;
+  const parts = [...types];
+  const prim = parts.find(isPrimitiveLike);
+  if (!prim) return null;
+  const rest = parts.filter((p) => p !== prim);
+  if (rest.every((r) => isBrandObject(checker, r, ctx))) {
+    return typeToJsonSchema(prim, ctx);
+  }
+  return null;
+}
+function isPrimitiveLike(t) {
+  return (t.flags & (import_typescript3.default.TypeFlags.String | import_typescript3.default.TypeFlags.Number | import_typescript3.default.TypeFlags.Boolean | import_typescript3.default.TypeFlags.BigInt)) !== 0 || (t.flags & import_typescript3.default.TypeFlags.StringLiteral) !== 0 || (t.flags & import_typescript3.default.TypeFlags.NumberLiteral) !== 0;
+}
+function isBrandObject(checker, t, ctx) {
+  if (!(t.flags & import_typescript3.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 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_typescript3.default.SymbolFlags.Optional) return false;
+  const propType = checker.getTypeOfSymbol(sym);
+  if (propType.isUnion?.()) {
+    const hasUndefined = propType.types.some((t) => (t.flags & import_typescript3.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 handleObjectType(type, ctx, typeNode) {
+  const { checker, components, typeStack } = ctx;
+  const symbol = type.getSymbol();
+  const typeName = symbol?.getName?.() ?? getTypeNameFromNode(typeNode, ctx);
+  if (typeName && typeName !== "__type") {
+    if (components.has(typeName)) {
+      return { $ref: `#/components/schemas/${typeName}` };
+    }
+    if (typeStack.has(type)) {
+      return { $ref: `#/components/schemas/${typeName}` };
+    }
+    typeStack.add(type);
+  }
+  const schema = buildObjectSchema(type, ctx, typeNode);
+  if (typeName && typeName !== "__type") {
+    typeStack.delete(type);
+    if (!components.has(typeName)) {
+      components.set(typeName, schema);
+    }
+    return { $ref: `#/components/schemas/${typeName}` };
+  }
+  typeStack.delete(type);
+  return schema;
+}
+function getTypeNameFromNode(typeNode, ctx) {
+  if (!typeNode) return `Anonymous_${ctx.typeNameStack.length}`;
+  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 `Anonymous_${ctx.typeNameStack.length}`;
+}
+function buildObjectSchema(type, ctx, typeNode) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = checker.getPropertiesOfType(type);
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & import_typescript3.default.SymbolFlags.Optional);
+    properties[propName] = typeToJsonSchema(propType, ctx);
+    if (!isOptional) {
+      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) {
+      schema.additionalProperties = typeToJsonSchema(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;
+}
+
+// src/compiler/schema/extractAnnotations.ts
+var import_typescript4 = __toESM(require("typescript"), 1);
+function extractPropertySchemaFragments(checker, prop) {
+  if (!import_typescript4.default.canHaveDecorators(prop)) return [];
+  const decs = import_typescript4.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_typescript4.default.isCallExpression(expr)) {
+      callee = expr.expression;
+      args = expr.arguments;
+    } else {
+      callee = expr;
+      args = import_typescript4.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_typescript4.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_typescript4.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_typescript4.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_typescript4.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_typescript4.default.SyntaxKind.FalseKeyword || arg.kind === import_typescript4.default.SyntaxKind.TrueKeyword)) {
+        frags.push({ additionalProperties: arg.kind === import_typescript4.default.SyntaxKind.TrueKeyword });
+      } else if (arg && import_typescript4.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_typescript4.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_typescript4.default.isNumericLiteral(node);
+}
+function isStringLiteral(node) {
+  return !!node && import_typescript4.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_typescript4.default.isPropertyAssignment(prop)) continue;
+    const name = prop.name;
+    let key;
+    if (import_typescript4.default.isIdentifier(name)) {
+      key = name.text;
+    } else if (import_typescript4.default.isStringLiteral(name)) {
+      key = name.text;
+    } else {
+      continue;
+    }
+    out[key] = literalToJson(prop.initializer);
+  }
+  return out;
+}
+function literalToJson(node) {
+  if (import_typescript4.default.isStringLiteral(node)) return node.text;
+  if (import_typescript4.default.isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === import_typescript4.default.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === import_typescript4.default.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === import_typescript4.default.SyntaxKind.NullKeyword) return null;
+  if (import_typescript4.default.isObjectLiteralExpression(node)) return objectLiteralToJson(node);
+  if (import_typescript4.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/openapi.ts
+function generateOpenAPI(controllers, checker, options = {}) {
+  const components = /* @__PURE__ */ new Map();
+  const ctx = {
+    checker,
+    components,
+    typeStack: /* @__PURE__ */ new Set(),
+    typeNameStack: []
+  };
+  const paths = {};
+  for (const controller of controllers) {
+    for (const operation of controller.operations) {
+      const fullPath = convertToOpenApiPath(controller.basePath, operation.path);
+      if (!paths[fullPath]) {
+        paths[fullPath] = {};
+      }
+      const method = operation.httpMethod.toLowerCase();
+      paths[fullPath][method] = buildOperation(operation, ctx, controller.consumes);
+    }
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: options.title ?? "API",
+      version: options.version ?? "1.0.0"
+    },
+    components: {
+      schemas: Object.fromEntries(components)
+    },
+    paths
+  };
+}
+function convertToOpenApiPath(basePath, path4) {
+  const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  const converted = path4.replace(/:([^/]+)/g, "{$1}");
+  return base + converted || "/";
+}
+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 responseSchema = typeToJsonSchema(operation.returnType, ctx);
+  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) {
+      let bodySchema = typeToJsonSchema(bodyParam.type, ctx);
+      bodySchema = mergeBodySchemaAnnotations(bodyParam, ctx, 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_typescript5.default.isClassDeclaration(classDecl)) return schema;
+  const result = { ...schema };
+  const props = { ...result.properties };
+  for (const member of classDecl.members) {
+    if (!import_typescript5.default.isPropertyDeclaration(member) || !member.name) continue;
+    const propName = import_typescript5.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;
+}
+function buildPathParameters(operation, ctx, parameters) {
+  for (const paramIndex of operation.pathParamIndices) {
+    const param = operation.parameters[paramIndex];
+    if (param) {
+      let paramSchema = typeToJsonSchema(param.type, ctx);
+      if (param.paramNode) {
+        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
+        if (frags.length > 0) {
+          paramSchema = mergeFragments(paramSchema, ...frags);
+        }
+      }
+      parameters.push({
+        name: param.name,
+        in: "path",
+        required: !param.isOptional,
+        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema
+      });
+    }
+  }
+}
+function buildQueryParameters(operation, ctx, parameters) {
+  if (operation.queryObjectParamIndex !== null) {
+    const queryParam = operation.parameters[operation.queryObjectParamIndex];
+    if (!queryParam) return;
+    const querySchema = typeToJsonSchema(queryParam.type, ctx);
+    if (!querySchema.properties) return;
+    const queryObjProps = querySchema.properties;
+    for (const [propName, propSchema] of Object.entries(queryObjProps)) {
+      const isRequired = querySchema.required?.includes(propName) ?? false;
+      const serialization = determineQuerySerialization(propSchema.type);
+      parameters.push({
+        name: propName,
+        in: "query",
+        required: isRequired,
+        schema: propSchema,
+        ...Object.keys(serialization).length > 0 ? serialization : {}
+      });
+    }
+  }
+  for (const paramIndex of operation.queryParamIndices) {
+    const param = operation.parameters[paramIndex];
+    if (param) {
+      let paramSchema = typeToJsonSchema(param.type, ctx);
+      if (param.paramNode) {
+        const frags = extractPropertySchemaFragments(ctx.checker, param.paramNode);
+        if (frags.length > 0) {
+          paramSchema = mergeFragments(paramSchema, ...frags);
+        }
+      }
+      const serialization = determineQuerySerialization(paramSchema.type);
+      parameters.push({
+        name: param.name,
+        in: "query",
+        required: !param.isOptional,
+        schema: paramSchema.$ref ? { type: "string", $ref: paramSchema.$ref } : paramSchema,
+        ...Object.keys(serialization).length > 0 ? serialization : {}
+      });
+    }
+  }
+}
+function determineQuerySerialization(schemaType) {
+  const typeArray = Array.isArray(schemaType) ? schemaType : schemaType ? [schemaType] : [];
+  const isArray = typeArray.includes("array");
+  if (isArray) {
+    return { style: "form", explode: true };
+  }
+  return {};
+}
+function buildHeaderParameters(operation, ctx, parameters) {
+  if (operation.headerObjectParamIndex === null) return;
+  const headerParam = operation.parameters[operation.headerObjectParamIndex];
+  if (!headerParam) return;
+  const headerSchema = typeToJsonSchema(headerParam.type, ctx);
+  if (!headerSchema.properties) return;
+  const headerObjProps = headerSchema.properties;
+  for (const [propName, propSchema] of Object.entries(headerObjProps)) {
+    const isRequired = headerSchema.required?.includes(propName) ?? false;
+    parameters.push({
+      name: propName,
+      in: "header",
+      required: isRequired,
+      schema: propSchema
+    });
+  }
+}
+function buildCookieParameters(operation, ctx, parameters) {
+  if (operation.cookieObjectParamIndex === null) return;
+  const cookieParam = operation.parameters[operation.cookieObjectParamIndex];
+  if (!cookieParam) return;
+  const cookieSchema = typeToJsonSchema(cookieParam.type, ctx);
+  if (!cookieSchema.properties) return;
+  const cookieObjProps = cookieSchema.properties;
+  for (const [propName, propSchema] of Object.entries(cookieObjProps)) {
+    const isRequired = cookieSchema.required?.includes(propName) ?? false;
+    parameters.push({
+      name: propName,
+      in: "cookie",
+      required: isRequired,
+      schema: propSchema,
+      style: "form",
+      explode: true
+    });
+  }
+}
+
+// src/compiler/manifest/emit.ts
+var import_typescript6 = __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: []
+  };
+  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_typescript6.default.version
+    },
+    schemas: {
+      kind: "openapi-3.1",
+      file: "./openapi.json",
+      componentsSchemasPointer: "/components/schemas"
+    },
+    validation: validationConfig,
+    controllers: controllerEntries
+  };
+}
+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);
+  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) {
+      const querySchema = typeToJsonSchema(queryParam.type, ctx);
+      if (!querySchema.properties) return;
+      for (const [propName, propSchema] of Object.entries(querySchema.properties)) {
+        const isRequired = querySchema.required?.includes(propName) ?? false;
+        let schemaRef = propSchema.$ref;
+        if (!schemaRef) {
+          schemaRef = "#/components/schemas/InlineQueryParam";
+        }
+        args.query.push({
+          name: propName,
+          index: queryParam.index,
+          required: !isRequired,
+          schemaRef,
+          schemaType: propSchema.type
+        });
+      }
+    }
+  }
+  for (const paramIndex of op.queryParamIndices) {
+    const param = op.parameters[paramIndex];
+    if (param) {
+      const paramSchema = typeToJsonSchema(param.type, ctx);
+      const schemaRef = paramSchema.$ref ?? "#/components/schemas/InlineQueryParam";
+      args.query.push({
+        name: param.name,
+        index: param.index,
+        required: !param.isOptional,
+        schemaRef,
+        schemaType: paramSchema.type
+      });
+    }
+  }
+}
+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: {
+`;
+    for (const [key, id] of Object.entries(v.response)) {
+      cjs += `      ${JSON.stringify(key)}: exports[${JSON.stringify(id)}],
+`;
+    }
+    cjs += `    }
+`;
+    cjs += `  },
+`;
+  }
+  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_typescript7 = require("typescript");
+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_typescript8 = __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_typescript8.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.ts
+var import_typescript9 = __toESM(require("typescript"), 1);
+var import_node_process = __toESM(require("process"), 1);
+var ADORN_VERSION = "0.1.0";
+function log(msg) {
+  import_node_process.default.stdout.write(msg + "\n");
+}
+function debug(...args) {
+  if (import_node_process.default.env.ADORN_DEBUG) {
+    console.error("[adorn-api]", ...args);
+  }
+}
+async function buildCommand(args) {
+  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";
+  if (validationMode !== "none" && validationMode !== "ajv-runtime" && validationMode !== "precompiled") {
+    console.error(`Invalid validation mode: ${validationMode}. Valid values: none, ajv-runtime, precompiled`);
+    import_node_process.default.exit(1);
+  }
+  const outputPath = (0, import_node_path5.resolve)(outputDir);
+  if (ifStale) {
+    const stale = await isStale({
+      outDir: outputDir,
+      project: projectPath,
+      adornVersion: ADORN_VERSION,
+      typescriptVersion: import_typescript9.default.version
+    });
+    if (!stale.stale) {
+      log("adorn-api: artifacts up-to-date");
+      return;
+    }
+    log(`adorn-api: building artifacts (reason: ${stale.reason}${stale.detail ? `: ${stale.detail}` : ""})`);
+    debug("Stale detail:", stale.detail);
+  } else {
+    log("adorn-api: building artifacts (reason: forced-build)");
+  }
+  const { program, checker, sourceFiles } = createProgramFromConfig(projectPath);
+  const controllers = scanControllers(sourceFiles, checker);
+  if (controllers.length === 0) {
+    console.warn("No controllers found!");
+    import_node_process.default.exit(1);
+  }
+  log(`Found ${controllers.length} controller(s)`);
+  const openapi = generateOpenAPI(controllers, checker, { title: "API", version: "1.0.0" });
+  const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
+  (0, import_node_fs5.mkdirSync)(outputPath, { recursive: true });
+  (0, import_node_fs5.writeFileSync)((0, import_node_path5.resolve)(outputPath, "openapi.json"), JSON.stringify(openapi, null, 2));
+  (0, import_node_fs5.writeFileSync)((0, import_node_path5.resolve)(outputPath, "manifest.json"), JSON.stringify(manifest, null, 2));
+  if (validationMode === "precompiled") {
+    log("Generating precompiled validators...");
+    const manifestObj = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path5.resolve)(outputPath, "manifest.json"), "utf-8"));
+    await emitPrecompiledValidators({
+      outDir: outputPath,
+      openapi,
+      manifest: manifestObj,
+      strict: "off",
+      formatsMode: "full"
+    });
+    manifestObj.validation = {
+      mode: "precompiled",
+      precompiledModule: "./validators.mjs"
+    };
+    (0, import_node_fs5.writeFileSync)((0, import_node_path5.resolve)(outputPath, "manifest.json"), JSON.stringify(manifestObj, null, 2));
+    log("  - validators.cjs");
+    log("  - validators.mjs");
+    log("  - validators.meta.json");
+  }
+  writeCache({
+    outDir: outputDir,
+    tsconfigAbs: (0, import_node_path5.resolve)(projectPath),
+    program,
+    adornVersion: ADORN_VERSION
+  });
+  log(`Written to ${outputPath}/`);
+  log("  - openapi.json");
+  log("  - manifest.json");
+  log("  - cache.json");
+}
+function cleanCommand(args) {
+  const outputDir = args.includes("--output") ? args[args.indexOf("--output") + 1] : ".adorn";
+  const outputPath = (0, import_node_path5.resolve)(outputDir);
+  if ((0, import_node_fs5.existsSync)(outputPath)) {
+    (0, import_node_fs5.rmSync)(outputPath, { recursive: true, force: true });
+  }
+  log(`adorn-api: cleaned ${outputDir}`);
+}
+var command = import_node_process.default.argv[2];
+if (command === "build") {
+  buildCommand(import_node_process.default.argv.slice(3)).catch((err) => {
+    console.error(err);
+    import_node_process.default.exit(1);
+  });
+} else if (command === "clean") {
+  cleanCommand(import_node_process.default.argv.slice(3));
+} else {
+  console.log(`
+adorn-api CLI
+
+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)
+
+Examples:
+  adorn-api build -p ./tsconfig.json --output .adorn
+  adorn-api build --if-stale
+  adorn-api build --validation-mode precompiled
+  adorn-api clean
+  `);
+}
+//# sourceMappingURL=cli.cjs.map