@contractkit/plugin-typescript 0.28.0 → 0.28.2

package/dist/index.js

@@ -2,12 +2,166 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-import { resolve as resolve2, join as join2, relative as relative6, dirname as dirname6, basename as basename3 } from "path";
+import { resolve as resolve2, join as join2, relative as relative7, dirname as dirname7, basename as basename4 } from "path";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, rmdirSync } from "fs";
 
 // src/codegen-contract.ts
 import { relative, dirname } from "path";
 import { collectTypeRefs, computeModelsWithOutput as ckComputeModelsWithOutput, collectExternalOutputRefs as ckCollectExternalOutputRefs } from "@contractkit/core";
+
+// src/ts-render.ts
+var JSON_VALUE_TYPE_DECL = "export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };";
+function quoteKey(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
+}
+__name(quoteKey, "quoteKey");
+function escapeJsDocLines(text) {
+  return text.replace(/\*\//g, "*\\/").split("\n");
+}
+__name(escapeJsDocLines, "escapeJsDocLines");
+function escapeSingleQuoted(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+__name(escapeSingleQuoted, "escapeSingleQuoted");
+function headerNameToProperty(name) {
+  const parts = name.split(/[-_]/).filter(Boolean);
+  return parts.map((p, i) => {
+    const lower = p.toLowerCase();
+    return i === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+}
+__name(headerNameToProperty, "headerNameToProperty");
+function renderTsType(type) {
+  switch (type.kind) {
+    case "scalar":
+      return renderTsScalar(type.name);
+    case "array": {
+      const inner = renderTsType(type.item);
+      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
+      return needsParens ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "tuple":
+      return `[${type.items.map(renderTsType).join(", ")}]`;
+    case "record":
+      return `Record<${renderTsType(type.key)}, ${renderTsType(type.value)}>`;
+    case "enum":
+      return type.values.map((v) => `'${escapeSingleQuoted(v)}'`).join(" | ");
+    case "literal":
+      return typeof type.value === "string" ? `'${escapeSingleQuoted(type.value)}'` : String(type.value);
+    case "union":
+      return type.members.map(renderTsType).join(" | ");
+    case "discriminatedUnion":
+      return type.members.map(renderTsType).join(" | ");
+    case "intersection":
+      return type.members.map(renderTsType).join(" & ");
+    case "ref":
+      return type.name;
+    case "lazy":
+      return renderTsType(type.inner);
+    case "inlineObject":
+      return renderTsInlineObject(type.fields);
+    default:
+      return "unknown";
+  }
+}
+__name(renderTsType, "renderTsType");
+function renderTsScalar(name) {
+  switch (name) {
+    case "string":
+    case "email":
+    case "url":
+    case "uuid":
+      return "string";
+    case "number":
+    case "int":
+      return "number";
+    case "bigint":
+      return "bigint";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "time":
+    case "datetime":
+    case "duration":
+    case "interval":
+      return "string";
+    case "null":
+      return "null";
+    case "unknown":
+      return "unknown";
+    case "object":
+      return "Record<string, unknown>";
+    case "binary":
+      return "Blob";
+    case "json":
+      return "JsonValue";
+    default: {
+      const _exhaustive = name;
+      throw new Error(`plugin-typescript: unmapped scalar '${String(_exhaustive)}' \u2014 add a case`);
+    }
+  }
+}
+__name(renderTsScalar, "renderTsScalar");
+function renderTsInlineObject(fields) {
+  const entries = fields.map((f) => {
+    const opt = f.optional ? "?" : "";
+    return `${quoteKey(f.name)}${opt}: ${renderTsType(f.type)}`;
+  });
+  return `{ ${entries.join("; ")} }`;
+}
+__name(renderTsInlineObject, "renderTsInlineObject");
+function renderInputTsType(type, modelsWithInput) {
+  if (!modelsWithInput || modelsWithInput.size === 0) return renderTsType(type);
+  switch (type.kind) {
+    case "ref":
+      return modelsWithInput.has(type.name) ? `${type.name}Input` : type.name;
+    case "array": {
+      const inner = renderInputTsType(type.item, modelsWithInput);
+      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
+      return needsParens ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "intersection":
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" & ");
+    case "union":
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
+    case "discriminatedUnion":
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
+    case "inlineObject":
+      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderInputTsType(f.type, modelsWithInput)}`).join("; ")} }`;
+    case "lazy":
+      return renderInputTsType(type.inner, modelsWithInput);
+    default:
+      return renderTsType(type);
+  }
+}
+__name(renderInputTsType, "renderInputTsType");
+function renderOutputTsType(type, modelsWithOutput) {
+  if (!modelsWithOutput || modelsWithOutput.size === 0) return renderTsType(type);
+  switch (type.kind) {
+    case "ref":
+      return modelsWithOutput.has(type.name) ? `${type.name}Output` : type.name;
+    case "array": {
+      const inner = renderOutputTsType(type.item, modelsWithOutput);
+      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
+      return needsParens ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "intersection":
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" & ");
+    case "union":
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
+    case "discriminatedUnion":
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
+    case "inlineObject":
+      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderOutputTsType(f.type, modelsWithOutput)}`).join("; ")} }`;
+    case "lazy":
+      return renderOutputTsType(type.inner, modelsWithOutput);
+    default:
+      return renderTsType(type);
+  }
+}
+__name(renderOutputTsType, "renderOutputTsType");
+
+// src/codegen-contract.ts
 function modeToWrapper(mode) {
   switch (mode) {
     case "strict":
@@ -56,7 +210,7 @@ function generateComments(model, outPath) {
     lines.push(` * @deprecated`);
   }
   if (model.description) {
-    lines.push(` * ${model.description}`);
+    for (const l of escapeJsDocLines(model.description)) lines.push(` * ${l}`);
   }
   const relPath = outPath ? relative(dirname(outPath), model.loc.file) : model.loc.file;
   lines.push(` * generated from [${model.name}](file://./${relPath}#L${model.loc.line})`);
@@ -199,9 +353,9 @@ function generateSimpleModel(model, outPath) {
       const outputKey = applyCase(field.name, outputCase);
       if (field.optional) {
         const guard = hasInputTransform ? `data.${inputKey} != null` : `data.${inputKey} !== undefined`;
-        lines.push(`    ...(${guard} ? { ${quoteKey(outputKey)}: data.${inputKey} } : {}),`);
+        lines.push(`    ...(${guard} ? { ${quoteKey2(outputKey)}: data.${inputKey} } : {}),`);
       } else {
-        lines.push(`    ${quoteKey(outputKey)}: data.${inputKey},`);
+        lines.push(`    ${quoteKey2(outputKey)}: data.${inputKey},`);
       }
     }
     lines.push(`}));`);
@@ -298,7 +452,7 @@ function generateThreeSchemaModel(model, outPath, modelsWithInput, modelsWithWri
   }
   const omitClause = fieldsToOmit.size > 0 ? `.omit({ ${[
     ...fieldsToOmit
-  ].map((f) => `${quoteKey(f)}: true`).join(", ")} })` : "";
+  ].map((f) => `${quoteKey2(f)}: true`).join(", ")} })` : "";
   if (bases.length > 0) {
     const { head, tail } = buildExtendChain(bases, (b) => modelsWithInput?.has(b) ? `${b}Input` : b);
     lines.push(`export const ${name}Input = ${head}${tail}${omitClause}.extend({`);
@@ -343,7 +497,7 @@ function renderFieldsAsPascalCase(fields, defaultMode) {
       expr += ".nullable()";
     }
     if (f.description) expr += `.describe("${escapeString(f.description)}")`;
-    return `${quoteKey(pascalKey)}: ${expr},`;
+    return `${quoteKey2(pascalKey)}: ${expr},`;
   });
 }
 __name(renderFieldsAsPascalCase, "renderFieldsAsPascalCase");
@@ -361,7 +515,7 @@ function renderFieldsAsSnakeCase(fields, defaultMode) {
       expr += ".nullable()";
     }
     if (f.description) expr += `.describe("${escapeString(f.description)}")`;
-    return `${quoteKey(snakeKey)}: ${expr},`;
+    return `${quoteKey2(snakeKey)}: ${expr},`;
   });
 }
 __name(renderFieldsAsSnakeCase, "renderFieldsAsSnakeCase");
@@ -377,7 +531,7 @@ function renderField(field, defaultMode) {
     expr += ".optional()";
   }
   if (field.description) expr += `.describe("${escapeString(field.description)}")`;
-  lines.push(`${quoteKey(field.name)}: ${expr},`);
+  lines.push(`${quoteKey2(field.name)}: ${expr},`);
   return lines;
 }
 __name(renderField, "renderField");
@@ -502,8 +656,10 @@ function renderScalar(s) {
       return "_ZodBinary";
     case "json":
       return "_ZodJson";
-    default:
-      return "z.unknown()";
+    default: {
+      const _exhaustive = s.name;
+      throw new Error(`plugin-typescript: unmapped scalar '${String(_exhaustive)}' \u2014 add a case`);
+    }
   }
 }
 __name(renderScalar, "renderScalar");
@@ -523,7 +679,7 @@ function renderRecord(r) {
 }
 __name(renderRecord, "renderRecord");
 function renderEnum(e) {
-  const vals = e.values.map((v) => `"${v}"`).join(", ");
+  const vals = e.values.map((v) => `"${escapeString(v)}"`).join(", ");
   return `z.enum([${vals}])`;
 }
 __name(renderEnum, "renderEnum");
@@ -572,9 +728,9 @@ function renderInlineObject(o, parseCaseTransform, defaultMode) {
     const transformEntries = o.fields.map((f) => {
       const snakeKey = camelToSnake(f.name);
       if (f.optional) {
-        return `    ...(data.${snakeKey} != null ? { ${quoteKey(f.name)}: data.${snakeKey} } : {}),`;
+        return `    ...(data.${snakeKey} != null ? { ${quoteKey2(f.name)}: data.${snakeKey} } : {}),`;
       }
-      return `    ${quoteKey(f.name)}: data.${snakeKey},`;
+      return `    ${quoteKey2(f.name)}: data.${snakeKey},`;
     }).join("\n");
     return `${wrapper}({
 ${joined}
@@ -588,9 +744,9 @@ ${transformEntries}
     const transformEntries = o.fields.map((f) => {
       const pascalKey = camelToPascal(f.name);
       if (f.optional) {
-        return `    ...(data.${pascalKey} != null ? { ${quoteKey(f.name)}: data.${pascalKey} } : {}),`;
+        return `    ...(data.${pascalKey} != null ? { ${quoteKey2(f.name)}: data.${pascalKey} } : {}),`;
       }
-      return `    ${quoteKey(f.name)}: data.${pascalKey},`;
+      return `    ${quoteKey2(f.name)}: data.${pascalKey},`;
     }).join("\n");
     return `${wrapper}({
 ${joined}
@@ -676,7 +832,7 @@ function renderInputField(field, modelsWithInput, defaultMode) {
     expr += ".optional()";
   }
   if (field.description) expr += `.describe("${escapeString(field.description)}")`;
-  lines.push(`${quoteKey(field.name)}: ${expr},`);
+  lines.push(`${quoteKey2(field.name)}: ${expr},`);
   return lines;
 }
 __name(renderInputField, "renderInputField");
@@ -736,17 +892,17 @@ function renderQueryField(field, modelsWithInput, defaultMode) {
     expr += ".optional()";
   }
   if (field.description) expr += `.describe("${escapeString(field.description)}")`;
-  return `${quoteKey(field.name)}: ${expr},`;
+  return `${quoteKey2(field.name)}: ${expr},`;
 }
 __name(renderQueryField, "renderQueryField");
 function isValidIdentifier(name) {
   return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 __name(isValidIdentifier, "isValidIdentifier");
-function quoteKey(name) {
+function quoteKey2(name) {
   return isValidIdentifier(name) ? name : `'${name}'`;
 }
-__name(quoteKey, "quoteKey");
+__name(quoteKey2, "quoteKey");
 function escapeString(s) {
   return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 }
@@ -950,149 +1106,6 @@ __name(pascalToDotCase, "pascalToDotCase");
 
 // src/codegen-operation.ts
 import { resolveModifiers, resolveSecurity, SECURITY_NONE, classifyContentType } from "@contractkit/core";
-
-// src/ts-render.ts
-var JSON_VALUE_TYPE_DECL = "export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };";
-function quoteKey2(name) {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
-}
-__name(quoteKey2, "quoteKey");
-function headerNameToProperty(name) {
-  const parts = name.split(/[-_]/).filter(Boolean);
-  return parts.map((p, i) => {
-    const lower = p.toLowerCase();
-    return i === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
-  }).join("");
-}
-__name(headerNameToProperty, "headerNameToProperty");
-function renderTsType(type) {
-  switch (type.kind) {
-    case "scalar":
-      return renderTsScalar(type.name);
-    case "array": {
-      const inner = renderTsType(type.item);
-      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
-      return needsParens ? `(${inner})[]` : `${inner}[]`;
-    }
-    case "tuple":
-      return `[${type.items.map(renderTsType).join(", ")}]`;
-    case "record":
-      return `Record<${renderTsType(type.key)}, ${renderTsType(type.value)}>`;
-    case "enum":
-      return type.values.map((v) => `'${v}'`).join(" | ");
-    case "literal":
-      return typeof type.value === "string" ? `'${type.value}'` : String(type.value);
-    case "union":
-      return type.members.map(renderTsType).join(" | ");
-    case "discriminatedUnion":
-      return type.members.map(renderTsType).join(" | ");
-    case "intersection":
-      return type.members.map(renderTsType).join(" & ");
-    case "ref":
-      return type.name;
-    case "lazy":
-      return renderTsType(type.inner);
-    case "inlineObject":
-      return renderTsInlineObject(type.fields);
-    default:
-      return "unknown";
-  }
-}
-__name(renderTsType, "renderTsType");
-function renderTsScalar(name) {
-  switch (name) {
-    case "string":
-    case "email":
-    case "url":
-    case "uuid":
-      return "string";
-    case "number":
-    case "int":
-      return "number";
-    case "bigint":
-      return "bigint";
-    case "boolean":
-      return "boolean";
-    case "date":
-    case "datetime":
-    case "duration":
-    case "interval":
-      return "string";
-    case "null":
-      return "null";
-    case "unknown":
-      return "unknown";
-    case "object":
-      return "Record<string, unknown>";
-    case "binary":
-      return "Blob";
-    case "json":
-      return "JsonValue";
-    default:
-      return "unknown";
-  }
-}
-__name(renderTsScalar, "renderTsScalar");
-function renderTsInlineObject(fields) {
-  const entries = fields.map((f) => {
-    const opt = f.optional ? "?" : "";
-    return `${quoteKey2(f.name)}${opt}: ${renderTsType(f.type)}`;
-  });
-  return `{ ${entries.join("; ")} }`;
-}
-__name(renderTsInlineObject, "renderTsInlineObject");
-function renderInputTsType(type, modelsWithInput) {
-  if (!modelsWithInput || modelsWithInput.size === 0) return renderTsType(type);
-  switch (type.kind) {
-    case "ref":
-      return modelsWithInput.has(type.name) ? `${type.name}Input` : type.name;
-    case "array": {
-      const inner = renderInputTsType(type.item, modelsWithInput);
-      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
-      return needsParens ? `(${inner})[]` : `${inner}[]`;
-    }
-    case "intersection":
-      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" & ");
-    case "union":
-      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
-    case "discriminatedUnion":
-      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
-    case "inlineObject":
-      return `{ ${type.fields.map((f) => `${quoteKey2(f.name)}${f.optional ? "?" : ""}: ${renderInputTsType(f.type, modelsWithInput)}`).join("; ")} }`;
-    case "lazy":
-      return renderInputTsType(type.inner, modelsWithInput);
-    default:
-      return renderTsType(type);
-  }
-}
-__name(renderInputTsType, "renderInputTsType");
-function renderOutputTsType(type, modelsWithOutput) {
-  if (!modelsWithOutput || modelsWithOutput.size === 0) return renderTsType(type);
-  switch (type.kind) {
-    case "ref":
-      return modelsWithOutput.has(type.name) ? `${type.name}Output` : type.name;
-    case "array": {
-      const inner = renderOutputTsType(type.item, modelsWithOutput);
-      const needsParens = type.item.kind === "union" || type.item.kind === "discriminatedUnion" || type.item.kind === "intersection" || type.item.kind === "enum";
-      return needsParens ? `(${inner})[]` : `${inner}[]`;
-    }
-    case "intersection":
-      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" & ");
-    case "union":
-      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
-    case "discriminatedUnion":
-      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
-    case "inlineObject":
-      return `{ ${type.fields.map((f) => `${quoteKey2(f.name)}${f.optional ? "?" : ""}: ${renderOutputTsType(f.type, modelsWithOutput)}`).join("; ")} }`;
-    case "lazy":
-      return renderOutputTsType(type.inner, modelsWithOutput);
-    default:
-      return renderTsType(type);
-  }
-}
-__name(renderOutputTsType, "renderOutputTsType");
-
-// src/codegen-operation.ts
 import { basename, dirname as dirname2, relative as relative2 } from "path";
 function bodyParserToken(contentType) {
   switch (classifyContentType(contentType)) {
@@ -1244,7 +1257,7 @@ function generateHandler(route, op, root, options) {
   lines.push("/**");
   const desc = op.description ?? route.description;
   if (desc) {
-    lines.push(` * ${desc}`);
+    for (const l of escapeJsDocLines(desc)) lines.push(` * ${l}`);
   }
   const relFile = outPath ? relative2(dirname2(outPath), file) : file;
   lines.push(` * from [${basename(file)}](file://./${relFile}#L${op.loc.line})`);
@@ -1273,11 +1286,11 @@ function generateHandler(route, op, root, options) {
     middlewares.push(`bodyParserMiddleware([${tokensExpr}])`);
   }
   if (op.signature) {
-    const sigArgs = op.signaturePolicy ? `'${op.signature}', { policy: '${op.signaturePolicy}' }` : `'${op.signature}'`;
+    const sigArgs = op.signaturePolicy ? `'${escapeSingleQuoted(op.signature)}', { policy: '${escapeSingleQuoted(op.signaturePolicy)}' }` : `'${escapeSingleQuoted(op.signature)}'`;
     middlewares.push(`requireSignature(${sigArgs})`);
   }
   const middlewareStr = middlewares.length > 0 ? `, ${middlewares.join(", ")},` : ",";
-  lines.push(`${deriveRouterName(file)}.${method}('${path}'${middlewareStr} async (ctx, next) => {`);
+  lines.push(`${deriveRouterName(file)}.${method}('${path}'${middlewareStr} async ctx => {`);
   lines.push(...generateParamValidation(route.params, "ctx.params", "params", route.paramsMode ?? "strict", "", modelsWithInput));
   lines.push(...generateParamValidation(op.query, "ctx.query", "query", op.queryMode ?? "strict", "", modelsWithInput));
   lines.push(...generateParamValidation(op.headers, "ctx.headers", "headers", op.headersMode ?? "strip", "", modelsWithInput));
@@ -1308,13 +1321,13 @@ function generateHandler(route, op, root, options) {
       lines.push("");
     }
   }
-  const primaryResponse = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+  const primaryResponse2 = op.responses.find((r) => r.bodyType) ?? op.responses[0];
   const serviceParts = inferService(op, route, file);
-  const respHeaders = primaryResponse?.headers ?? [];
+  const respHeaders = primaryResponse2?.headers ?? [];
   const hasRespHeaders = respHeaders.length > 0;
-  const headersAnnotation = hasRespHeaders ? `{ ${respHeaders.map((h) => `${quoteKey2(headerNameToProperty(h.name))}${h.optional ? "?" : ""}: ${renderOutputTsType(h.type, options.modelsWithOutput)}`).join("; ")} }` : "";
-  if (primaryResponse?.bodyType) {
-    const { annotation, prelude } = formatTypeAnnotation(primaryResponse.bodyType, options.modelsWithOutput);
+  const headersAnnotation = hasRespHeaders ? `{ ${respHeaders.map((h) => `${quoteKey(headerNameToProperty(h.name))}${h.optional ? "?" : ""}: ${renderOutputTsType(h.type, options.modelsWithOutput)}`).join("; ")} }` : "";
+  if (primaryResponse2?.bodyType) {
+    const { annotation, prelude } = formatTypeAnnotation(primaryResponse2.bodyType, options.modelsWithOutput);
     if (prelude) {
       lines.push(`    ${prelude}`);
     }
@@ -1333,7 +1346,7 @@ function generateHandler(route, op, root, options) {
     }
   }
   lines.push("");
-  lines.push(`    ctx.status = ${primaryResponse?.statusCode ?? 200};`);
+  lines.push(`    ctx.status = ${primaryResponse2?.statusCode ?? 200};`);
   if (hasRespHeaders) {
     for (const h of respHeaders) {
       const accessor = `result.headers[${JSON.stringify(headerNameToProperty(h.name))}]`;
@@ -1344,8 +1357,8 @@ function generateHandler(route, op, root, options) {
       }
     }
   }
-  if (primaryResponse?.bodyType && primaryResponse.contentType) {
-    lines.push(`    ctx.type = '${primaryResponse.contentType}';`);
+  if (primaryResponse2?.bodyType && primaryResponse2.contentType) {
+    lines.push(`    ctx.type = '${primaryResponse2.contentType}';`);
     lines.push(`    ctx.body = ${hasRespHeaders ? "result.body" : "result"};`);
   }
   lines.push(`});`);
@@ -1947,24 +1960,25 @@ function generateMethod(route, op, file, options) {
   const { modelsWithInput, modelsWithOutput } = options;
   const params = buildMethodParams(route, op, modelsWithInput);
   const paramStr = params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ");
-  const primaryResponse = op.responses.find((r) => r.bodyType) ?? op.responses[0];
-  const isVoid = !primaryResponse?.bodyType;
-  const respCategory = primaryResponse?.contentType ? classifyContentType2(primaryResponse.contentType) : "json";
-  const dataType = isVoid ? "void" : respCategory === "text" ? "string" : respCategory === "binary" ? "Blob" : renderOutputTsType(primaryResponse.bodyType, modelsWithOutput);
-  const respHeaders = primaryResponse?.headers ?? [];
+  const primaryResponse2 = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+  const isVoid = !primaryResponse2?.bodyType;
+  const respCategory = primaryResponse2?.contentType ? classifyContentType2(primaryResponse2.contentType) : "json";
+  const dataType = isVoid ? "void" : respCategory === "text" ? "string" : respCategory === "binary" ? "Blob" : renderOutputTsType(primaryResponse2.bodyType, modelsWithOutput);
+  const respHeaders = primaryResponse2?.headers ?? [];
   const hasRespHeaders = respHeaders.length > 0;
-  const headersShape = hasRespHeaders ? `{ ${respHeaders.map((h) => `${quoteKey2(headerNameToProperty(h.name))}${h.optional ? "?" : ""}: ${renderOutputTsType(h.type, modelsWithOutput)}`).join("; ")} }` : "";
+  const headersShape = hasRespHeaders ? `{ ${respHeaders.map((h) => `${quoteKey(headerNameToProperty(h.name))}${h.optional ? "?" : ""}: ${renderOutputTsType(h.type, modelsWithOutput)}`).join("; ")} }` : "";
   const returnType = hasRespHeaders ? isVoid ? `{ headers: ${headersShape} }` : `{ data: ${dataType}; headers: ${headersShape} }` : dataType;
   const desc = op.description ?? route.description;
   if (op.name || desc) {
     const tags = [];
     if (op.name) tags.push(`@name ${op.name}`);
     if (desc) tags.push(`@description ${desc}`);
-    if (tags.length === 1) {
-      lines.push(`    /** ${tags[0]} */`);
+    const contentLines = tags.flatMap((t) => escapeJsDocLines(t));
+    if (contentLines.length === 1) {
+      lines.push(`    /** ${contentLines[0]} */`);
     } else {
       lines.push(`    /**`);
-      for (const tag of tags) lines.push(`     * ${tag}`);
+      for (const l of contentLines) lines.push(`     * ${l}`);
       lines.push(`     */`);
     }
   }
@@ -2040,7 +2054,7 @@ function generateMethod(route, op, file, options) {
   }
   const readBodyExpr = respCategory === "text" ? `await result.text()` : respCategory === "binary" ? `await result.blob()` : `await parseJson<${dataType}>(result)`;
   if (hasRespHeaders) {
-    const headerEntries = respHeaders.map((h) => `${quoteKey2(headerNameToProperty(h.name))}: result.headers.get('${h.name}') ?? undefined`).join(", ");
+    const headerEntries = respHeaders.map((h) => `${quoteKey(headerNameToProperty(h.name))}: result.headers.get('${h.name}') ?? undefined`).join(", ");
     if (isVoid) {
       lines.push(`        return { headers: { ${headerEntries} } };`);
     } else {
@@ -2152,7 +2166,7 @@ function buildMethodParams(route, op, modelsWithInput) {
   }
   if (op.query) {
     if (op.query.kind === "params") {
-      const fields = op.query.nodes.map((p) => `${quoteKey2(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
+      const fields = op.query.nodes.map((p) => `${quoteKey(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
       params.push({
         name: "query",
         type: `{ ${fields} }`,
@@ -2175,7 +2189,7 @@ function buildMethodParams(route, op, modelsWithInput) {
   }
   if (op.headers) {
     if (op.headers.kind === "params") {
-      const fields = op.headers.nodes.map((p) => `${quoteKey2(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
+      const fields = op.headers.nodes.map((p) => `${quoteKey(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
       params.push({
         name: "customHeaders",
         type: `{ ${fields} }`,
@@ -2877,7 +2891,7 @@ function generateComments2(model, outPath) {
     lines.push(` * @deprecated`);
   }
   if (model.description) {
-    lines.push(` * ${model.description}`);
+    for (const l of escapeJsDocLines(model.description)) lines.push(` * ${l}`);
   }
   const relPath = outPath ? relative4(dirname4(outPath), model.loc.file) : model.loc.file;
   lines.push(` * generated from [${model.name}](file://./${relPath}#L${model.loc.line})`);
@@ -2941,34 +2955,40 @@ function generateVisibilityModel(model, outPath, modelsWithInput, modelMap) {
   return lines;
 }
 __name(generateVisibilityModel, "generateVisibilityModel");
+function withFieldJsDoc(jsdocParts, line) {
+  if (jsdocParts.length === 0) return line;
+  const contentLines = escapeJsDocLines(jsdocParts.join(" "));
+  if (contentLines.length === 1) {
+    return `/** ${contentLines[0]} */
+    ${line}`;
+  }
+  const body = contentLines.map((l) => `     * ${l}`).join("\n");
+  return `/**
+${body}
+     */
+    ${line}`;
+}
+__name(withFieldJsDoc, "withFieldJsDoc");
 function renderField2(field) {
   const opt = field.optional || field.default !== void 0 ? "?" : "";
   let typeStr = renderTsType(field.type);
   if (field.nullable) typeStr += " | null";
-  const line = `${quoteKey2(field.name)}${opt}: ${typeStr};`;
+  const line = `${quoteKey(field.name)}${opt}: ${typeStr};`;
   const jsdocParts = [];
   if (field.deprecated) jsdocParts.push("@deprecated");
   if (field.description) jsdocParts.push(field.description);
-  if (jsdocParts.length > 0) {
-    return `/** ${jsdocParts.join(" ")} */
-    ${line}`;
-  }
-  return line;
+  return withFieldJsDoc(jsdocParts, line);
 }
 __name(renderField2, "renderField");
 function renderInputField2(field, modelsWithInput) {
   const opt = field.optional || field.default !== void 0 ? "?" : "";
   let typeStr = renderInputTsType(field.type, modelsWithInput);
   if (field.nullable) typeStr += " | null";
-  const line = `${quoteKey2(field.name)}${opt}: ${typeStr};`;
+  const line = `${quoteKey(field.name)}${opt}: ${typeStr};`;
   const jsdocParts = [];
   if (field.deprecated) jsdocParts.push("@deprecated");
   if (field.description) jsdocParts.push(field.description);
-  if (jsdocParts.length > 0) {
-    return `/** ${jsdocParts.join(" ")} */
-    ${line}`;
-  }
-  return line;
+  return withFieldJsDoc(jsdocParts, line);
 }
 __name(renderInputField2, "renderInputField");
 function camelToSnake2(s) {
@@ -3011,22 +3031,457 @@ function renderOutputField(field, outputCase, modelsWithOutput) {
   const key = applyOutputCase(field.name, outputCase);
   let typeStr = renderOutputTsType(field.type, modelsWithOutput);
   if (field.nullable) typeStr += " | null";
-  const line = `${quoteKey2(key)}${opt}: ${typeStr};`;
+  const line = `${quoteKey(key)}${opt}: ${typeStr};`;
   const jsdocParts = [];
   if (field.deprecated) jsdocParts.push("@deprecated");
   if (field.description) jsdocParts.push(field.description);
-  if (jsdocParts.length > 0) {
-    return `/** ${jsdocParts.join(" ")} */
-    ${line}`;
-  }
-  return line;
+  return withFieldJsDoc(jsdocParts, line);
 }
 __name(renderOutputField, "renderOutputField");
 
+// src/codegen-mcp.ts
+import { resolveModifiers as resolveModifiers3 } from "@contractkit/core";
+import { basename as basename3, dirname as dirname5, relative as relative5 } from "path";
+function mcpConfig(op) {
+  return op.mcp && typeof op.mcp === "object" ? op.mcp : void 0;
+}
+__name(mcpConfig, "mcpConfig");
+function hasMcpOperations(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!op.mcp) continue;
+      if (!includeInternal && resolveModifiers3(route, op).includes("internal")) continue;
+      return true;
+    }
+  }
+  return false;
+}
+__name(hasMcpOperations, "hasMcpOperations");
+function toSnake(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-.]+/g, "_").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+__name(toSnake, "toSnake");
+function toPascal(s) {
+  return s.split("_").filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+__name(toPascal, "toPascal");
+function inferToolName(method, path) {
+  const parts = [
+    method.toLowerCase()
+  ];
+  for (const seg of path.split("/").filter(Boolean)) {
+    if (seg.startsWith("{")) {
+      parts.push("by", toSnake(seg.slice(1, -1)));
+    } else {
+      parts.push(toSnake(seg));
+    }
+  }
+  return parts.filter(Boolean).join("_");
+}
+__name(inferToolName, "inferToolName");
+function deriveToolName(op, route) {
+  const cfg = mcpConfig(op);
+  if (cfg?.name) return cfg.name;
+  if (op.sdk) return toSnake(op.sdk);
+  if (op.name) return toSnake(op.name);
+  return inferToolName(op.method, route.path);
+}
+__name(deriveToolName, "deriveToolName");
+function deriveToolClassName(toolName) {
+  return `${toPascal(toolName)}McpTool`;
+}
+__name(deriveToolClassName, "deriveToolClassName");
+function buildArgsProps(route, op, modelsWithInput) {
+  const props = [];
+  if (route.params) {
+    if (route.params.kind === "params") {
+      for (const node of route.params.nodes) {
+        props.push({
+          key: node.name,
+          expr: renderInputType(node.type, modelsWithInput),
+          optional: false
+        });
+      }
+    } else if (route.params.kind === "ref") {
+      props.push({
+        key: "params",
+        expr: refSchema(route.params.name, modelsWithInput),
+        optional: false
+      });
+    } else {
+      props.push({
+        key: "params",
+        expr: renderInputType(route.params.node, modelsWithInput),
+        optional: false
+      });
+    }
+  }
+  const bodies = op.request?.bodies ?? [];
+  if (bodies.length === 1 && bodies[0].contentType === "multipart/form-data") {
+    props.push({
+      key: "multipartBody",
+      expr: "z.unknown()",
+      optional: false
+    });
+  } else if (bodies.length === 1) {
+    props.push({
+      key: "body",
+      expr: renderInputType(bodies[0].bodyType, modelsWithInput),
+      optional: false
+    });
+  } else if (bodies.length > 1) {
+    props.push({
+      key: "body",
+      expr: "z.unknown()",
+      optional: false
+    });
+  }
+  if (op.query) props.push({
+    key: "query",
+    expr: paramSourceSchema(op.query, modelsWithInput),
+    optional: true
+  });
+  if (op.headers) props.push({
+    key: "headers",
+    expr: paramSourceSchema(op.headers, modelsWithInput),
+    optional: true
+  });
+  return props;
+}
+__name(buildArgsProps, "buildArgsProps");
+function refSchema(name, modelsWithInput) {
+  return modelsWithInput?.has(name) ? `${name}Input` : name;
+}
+__name(refSchema, "refSchema");
+function paramSourceSchema(src, modelsWithInput) {
+  if (src.kind === "ref") return refSchema(src.name, modelsWithInput);
+  if (src.kind === "type") return renderInputType(src.node, modelsWithInput);
+  const fields = src.nodes.map((n) => `${quoteKey(n.name)}: ${renderInputType(n.type, modelsWithInput)}`).join(", ");
+  return `z.object({ ${fields} })`;
+}
+__name(paramSourceSchema, "paramSourceSchema");
+function argsSchemaExpr(props) {
+  if (props.length === 0) return "z.object({})";
+  const fields = props.map((p) => `${quoteKey(p.key)}: ${p.expr}${p.optional ? ".optional()" : ""}`).join(", ");
+  return `z.object({ ${fields} })`;
+}
+__name(argsSchemaExpr, "argsSchemaExpr");
+function primaryResponse(op) {
+  return op.responses.find((r) => r.bodyType) ?? op.responses[0];
+}
+__name(primaryResponse, "primaryResponse");
+function outputSchemaExpr(op) {
+  const body = primaryResponse(op)?.bodyType;
+  if (!body) return void 0;
+  if (body.kind === "ref") return body.name;
+  if (body.kind === "inlineObject") return renderType(body);
+  return void 0;
+}
+__name(outputSchemaExpr, "outputSchemaExpr");
+var HINT_KEYS = [
+  "readOnlyHint",
+  "destructiveHint",
+  "idempotentHint",
+  "openWorldHint"
+];
+function annotationsExpr(cfg) {
+  if (!cfg) return void 0;
+  const parts = [];
+  for (const key of HINT_KEYS) {
+    const val = cfg[key];
+    if (val !== void 0) parts.push(`${key}: ${val}`);
+  }
+  return parts.length > 0 ? `{ ${parts.join(", ")} }` : void 0;
+}
+__name(annotationsExpr, "annotationsExpr");
+function walkTypeRefs(type, ids, variant, modelsWithInput) {
+  switch (type.kind) {
+    case "ref":
+      ids.add(variant === "input" ? refSchema(type.name, modelsWithInput) : type.name);
+      break;
+    case "array":
+      walkTypeRefs(type.item, ids, variant, modelsWithInput);
+      break;
+    case "tuple":
+      type.items.forEach((t) => walkTypeRefs(t, ids, variant, modelsWithInput));
+      break;
+    case "record":
+      walkTypeRefs(type.key, ids, variant, modelsWithInput);
+      walkTypeRefs(type.value, ids, variant, modelsWithInput);
+      break;
+    case "union":
+    case "discriminatedUnion":
+    case "intersection":
+      type.members.forEach((t) => walkTypeRefs(t, ids, variant, modelsWithInput));
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => walkTypeRefs(f.type, ids, variant, modelsWithInput));
+      break;
+    case "lazy":
+      walkTypeRefs(type.inner, ids, variant, modelsWithInput);
+      break;
+  }
+}
+__name(walkTypeRefs, "walkTypeRefs");
+function walkSourceRefs(src, ids, modelsWithInput) {
+  if (!src) return;
+  if (src.kind === "ref") ids.add(refSchema(src.name, modelsWithInput));
+  else if (src.kind === "params") src.nodes.forEach((n) => walkTypeRefs(n.type, ids, "input", modelsWithInput));
+  else walkTypeRefs(src.node, ids, "input", modelsWithInput);
+}
+__name(walkSourceRefs, "walkSourceRefs");
+function collectSchemaIds(ops, modelsWithInput) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const { route, op } of ops) {
+    walkSourceRefs(route.params, ids, modelsWithInput);
+    const bodies = op.request?.bodies ?? [];
+    if (bodies.length === 1 && bodies[0].contentType !== "multipart/form-data") {
+      walkTypeRefs(bodies[0].bodyType, ids, "input", modelsWithInput);
+    }
+    walkSourceRefs(op.query, ids, modelsWithInput);
+    walkSourceRefs(op.headers, ids, modelsWithInput);
+    const body = primaryResponse(op)?.bodyType;
+    if (body && (body.kind === "ref" || body.kind === "inlineObject")) walkTypeRefs(body, ids, "read");
+  }
+  return ids;
+}
+__name(collectSchemaIds, "collectSchemaIds");
+function schemaImportLines(ids, options) {
+  const lines = [];
+  const { modelOutPaths, outPath } = options;
+  if (ids.size === 0) return lines;
+  if (modelOutPaths && outPath) {
+    const byFile = /* @__PURE__ */ new Map();
+    const unresolved = [];
+    for (const id of ids) {
+      const p = modelOutPaths.get(id);
+      if (p) {
+        const group = byFile.get(p) ?? [];
+        group.push(id);
+        byFile.set(p, group);
+      } else {
+        unresolved.push(id);
+      }
+    }
+    const fromDir = dirname5(outPath);
+    for (const [file, names] of byFile) {
+      let rel = relative5(fromDir, file).replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      lines.push(`import { ${names.sort().join(", ")} } from '${rel}';`);
+    }
+    for (const id of unresolved.sort()) lines.push(`import { ${id} } from './${pascalToDotCase(id)}.js';`);
+  } else {
+    for (const id of [
+      ...ids
+    ].sort()) lines.push(`import { ${id} } from './${pascalToDotCase(id)}.js';`);
+  }
+  return lines;
+}
+__name(schemaImportLines, "schemaImportLines");
+function scalarHelperLines(body) {
+  const lines = [];
+  if (body.includes("_ZodBinary")) {
+    lines.push(`const _ZodBinary = z.custom<Buffer>((val) => Buffer.isBuffer(val), { error: 'Must be binary data' });`);
+  }
+  if (body.includes("_ZodDatetime")) {
+    lines.push(`const _ZodDatetime = z.preprocess((val) => typeof val === 'string' ? DateTime.fromISO(val) : val, z.custom<DateTime>((val) => val instanceof DateTime && val.isValid, { message: 'Must be in ISO 8601 format' }));`);
+  }
+  if (body.includes("_ZodInterval")) {
+    lines.push(`const _ZodInterval = z.preprocess((val) => typeof val === 'string' ? Interval.fromISO(val) : val, z.custom<Interval>((val) => val instanceof Interval && val.isValid, { message: 'Must be an ISO 8601 interval' })).transform(val => val.toISO()!);`);
+  }
+  if (body.includes("_ZodJson")) {
+    lines.push(`type _JsonValue = string | number | boolean | null | _JsonValue[] | { [key: string]: _JsonValue };`);
+    lines.push(`const _ZodJson: z.ZodType<_JsonValue> = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(_ZodJson), z.record(z.string(), _ZodJson)]));`);
+  }
+  return lines;
+}
+__name(scalarHelperLines, "scalarHelperLines");
+function planTools(root, includeInternal) {
+  const plans = [];
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!op.mcp) continue;
+      if (!includeInternal && resolveModifiers3(route, op).includes("internal")) continue;
+      const toolName = deriveToolName(op, route);
+      const className = deriveToolClassName(toolName);
+      plans.push({
+        route,
+        op,
+        toolName,
+        className,
+        argsConstName: `${toPascal(toolName)}Args`
+      });
+    }
+  }
+  return plans;
+}
+__name(planTools, "planTools");
+function renderToolClass(plan, file, options) {
+  const { route, op, toolName, className, argsConstName } = plan;
+  const cfg = mcpConfig(op);
+  const lines = [];
+  const relFile = options.outPath ? relative5(dirname5(options.outPath), file) : file;
+  lines.push("/**");
+  lines.push(` * from [${basename3(file)}](file://./${relFile}#L${op.loc.line})`);
+  lines.push(" */");
+  lines.push("@Injectable()");
+  lines.push(`export class ${className} implements McpToolHandler {`);
+  lines.push("    readonly definition: Tool = {");
+  lines.push(`        name: '${escapeSingleQuoted(toolName)}',`);
+  if (cfg?.title) lines.push(`        title: '${escapeSingleQuoted(cfg.title)}',`);
+  const desc = cfg?.description ?? op.description ?? route.description;
+  if (desc) lines.push(`        description: '${escapeSingleQuoted(desc)}',`);
+  lines.push(`        inputSchema: z.toJSONSchema(${argsConstName}, { unrepresentable: 'any' }) as Tool['inputSchema'],`);
+  const outExpr = outputSchemaExpr(op);
+  if (outExpr) lines.push(`        outputSchema: z.toJSONSchema(${outExpr}, { unrepresentable: 'any' }) as Tool['outputSchema'],`);
+  const annotations = annotationsExpr(cfg);
+  if (annotations) lines.push(`        annotations: ${annotations},`);
+  lines.push("    };");
+  lines.push("");
+  const service = inferService(op, route, file);
+  lines.push(`    constructor(private readonly service: ${service.className}) {}`);
+  lines.push("");
+  const props = buildArgsProps(route, op, options.modelsWithInput);
+  const destructure = props.map((p) => p.key);
+  const callArgs = buildArgs(route, op);
+  const isVoid = !primaryResponse(op)?.bodyType;
+  const structured = !!outExpr;
+  lines.push("    async handle(args: Record<string, unknown>, _context: McpToolContext): Promise<CallToolResult> {");
+  if (destructure.length > 0) {
+    lines.push(`        const { ${destructure.join(", ")} } = await parseAndValidate(args, ${argsConstName});`);
+  }
+  if (isVoid) {
+    lines.push(`        await this.service.${service.methodName}(${callArgs});`);
+    lines.push(`        return { content: [{ type: 'text', text: 'OK' }] };`);
+  } else {
+    lines.push(`        const result = await this.service.${service.methodName}(${callArgs});`);
+    if (structured) {
+      lines.push(`        return { content: [{ type: 'text', text: JSON.stringify(result) }], structuredContent: result };`);
+    } else {
+      lines.push(`        return { content: [{ type: 'text', text: JSON.stringify(result) }] };`);
+    }
+  }
+  lines.push("    }");
+  lines.push("}");
+  return lines;
+}
+__name(renderToolClass, "renderToolClass");
+function deriveMcpRegisterFnName(file) {
+  return `register${deriveBaseName(file)}McpTools`;
+}
+__name(deriveMcpRegisterFnName, "deriveMcpRegisterFnName");
+function generateMcpFile(root, options = {}) {
+  const includeInternal = options.includeInternal ?? false;
+  const plans = planTools(root, includeInternal);
+  const argsConsts = plans.map((p) => `const ${p.argsConstName} = ${argsSchemaExpr(buildArgsProps(p.route, p.op, options.modelsWithInput))};`);
+  const classes = plans.map((p) => renderToolClass(p, root.file, options).join("\n"));
+  const registerFn = [];
+  registerFn.push(`/** Add this file's tools to the shared catalog. */`);
+  registerFn.push(`export function ${deriveMcpRegisterFnName(root.file)}(map: McpToolHandlerMap, container: Container): void {`);
+  for (const p of plans) registerFn.push(`    map.set('${escapeSingleQuoted(p.toolName)}', container.get(${p.className}));`);
+  registerFn.push("}");
+  const bodyCore = [
+    argsConsts.join("\n"),
+    classes.join("\n\n"),
+    registerFn.join("\n")
+  ].filter(Boolean).join("\n\n");
+  const helperConsts = scalarHelperLines(bodyCore);
+  const bodyWithHelpers = [
+    helperConsts.join("\n"),
+    bodyCore
+  ].filter(Boolean).join("\n\n");
+  const needsParseAndValidate = plans.some((p) => buildArgsProps(p.route, p.op, options.modelsWithInput).length > 0);
+  const imports = [];
+  imports.push(`import { Injectable, type Container } from 'injectkit';`);
+  imports.push(`import { z } from 'zod';`);
+  const luxon = [];
+  if (/\bDateTime\b/.test(bodyWithHelpers)) luxon.push("DateTime");
+  if (/\bInterval\b/.test(bodyWithHelpers)) luxon.push("Interval");
+  if (/\bDuration\b/.test(bodyWithHelpers)) luxon.push("Duration");
+  if (luxon.length > 0) imports.push(`import { ${luxon.join(", ")} } from 'luxon';`);
+  imports.push(`import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';`);
+  imports.push(`import type { McpToolHandler, McpToolHandlerMap, McpToolContext } from '@maroonedsoftware/mcp';`);
+  if (needsParseAndValidate) imports.push(`import { parseAndValidate } from '@maroonedsoftware/zod';`);
+  const serviceModules = /* @__PURE__ */ new Map();
+  for (const p of plans) {
+    const svc = inferService(p.op, p.route, root.file).className;
+    if (!serviceModules.has(svc)) {
+      serviceModules.set(svc, root.services?.[svc] ?? root.meta[svc] ?? deriveModulePath(svc, options.servicePathTemplate));
+    }
+  }
+  for (const [svc, mod] of [
+    ...serviceModules.entries()
+  ].sort(([a], [b]) => a.localeCompare(b))) {
+    imports.push(`import { ${svc} } from '${mod}';`);
+  }
+  imports.push(...schemaImportLines(collectSchemaIds(plans, options.modelsWithInput), options));
+  const relFile = options.outPath ? relative5(dirname5(options.outPath), root.file) : root.file;
+  const header = `// Auto-generated MCP tools
+// generated from [${basename3(root.file)}](file://./${relFile})`;
+  return `${header}
+${imports.join("\n")}
+
+${bodyWithHelpers}
+`;
+}
+__name(generateMcpFile, "generateMcpFile");
+function generateMcpAggregator(entries) {
+  const sorted = [
+    ...entries
+  ].sort((a, b) => a.registerFn.localeCompare(b.registerFn));
+  const lines = [];
+  lines.push(`import { type Container } from 'injectkit';`);
+  lines.push(`import { McpToolHandlerMap } from '@maroonedsoftware/mcp';`);
+  for (const e of sorted) lines.push(`import { ${e.registerFn} } from '${e.importPath}';`);
+  lines.push("");
+  lines.push("/** Build + register the MCP tool catalog. Call once at startup. */");
+  lines.push("export function registerMcpTools(container: Container): McpToolHandlerMap {");
+  lines.push("    const map = new McpToolHandlerMap();");
+  for (const e of sorted) lines.push(`    ${e.registerFn}(map, container);`);
+  lines.push("    container.register(McpToolHandlerMap, { useValue: map });");
+  lines.push("    return map;");
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+__name(generateMcpAggregator, "generateMcpAggregator");
+function generateMcpRouter(options = {}) {
+  const path = options.path ?? "/mcp";
+  return `import { ServerKitRouter, requireSignature } from '@maroonedsoftware/koa';
+import { McpDispatcher, createMcpRequestContext, MCP_AUTH_POLICY } from '@maroonedsoftware/mcp';
+
+/** Mount the MCP endpoint onto a ServerKit router. Call \`registerMcpTools(container)\` at startup. */
+export function mountMcp(router: ReturnType<typeof ServerKitRouter>): void {
+    router.post('${path}', requireSignature('mcp', { policy: MCP_AUTH_POLICY }), async (ctx) => {
+        const dispatcher = ctx.container.get(McpDispatcher);
+        const context = createMcpRequestContext({ requestId: ctx.requestId, logger: ctx.logger });
+        if (dispatcher.sessionMode === 'stateful') {
+            ctx.respond = false;
+            await dispatcher.dispatchStateful(
+                { req: ctx.req, res: ctx.res, body: ctx.request.body, sessionId: ctx.get('mcp-session-id') },
+                context,
+            );
+        } else {
+            const response = await dispatcher.dispatch(JSON.parse(ctx.rawBody), context);
+            if (response) ctx.body = response;
+        }
+    });
+}
+`;
+}
+__name(generateMcpRouter, "generateMcpRouter");
+
 // src/path-utils.ts
-import { resolve, join, relative as relative5, dirname as dirname5 } from "path";
+import { resolve, join, relative as relative6, dirname as dirname6, isAbsolute } from "path";
 import { collectTypeRefs as collectTypeRefs2, collectPublicTypeNames } from "@contractkit/core";
 var TEMPLATE_VAR_RE = /\{\w+\}/;
+function assertWithinBase(baseOutDir, outPath) {
+  const rel = relative6(resolve(baseOutDir), resolve(outPath));
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`Refusing to emit outside output directory: resolved path "${outPath}" escapes "${baseOutDir}" (check options { keys } values used in output path templates)`);
+  }
+  return outPath;
+}
+__name(assertWithinBase, "assertWithinBase");
 function resolveTemplate(template, vars) {
   return template.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? `{${key}}`);
 }
@@ -3038,7 +3493,7 @@ function includesFilename(p) {
 __name(includesFilename, "includesFilename");
 function commonDir(files, rootDir) {
   if (files.length === 0) return resolve(rootDir);
-  const parts = files.map((f) => dirname5(f).split("/"));
+  const parts = files.map((f) => dirname6(f).split("/"));
   const first = parts[0];
   let depth = first.length;
   for (const p of parts) {
@@ -3054,7 +3509,7 @@ function commonDir(files, rootDir) {
 __name(commonDir, "commonDir");
 function computeOpOutPath(filePath, baseDir, output, defaultSuffix, commonRoot, meta = {}) {
   const baseName = filePath.split("/").pop();
-  const relDir = relative5(commonRoot, dirname5(filePath));
+  const relDir = relative6(commonRoot, dirname6(filePath));
   const filename = baseName.replace(/\.ck$/, "");
   const defaultName = `${filename}${defaultSuffix}`;
   const baseOutDir = resolve(baseDir);
@@ -3065,14 +3520,14 @@ function computeOpOutPath(filePath, baseDir, output, defaultSuffix, commonRoot,
       ext: "ck",
       ...meta
     });
-    if (includesFilename(resolved)) return join(baseOutDir, resolved);
-    return join(baseOutDir, resolved, defaultName);
+    if (includesFilename(resolved)) return assertWithinBase(baseOutDir, join(baseOutDir, resolved));
+    return assertWithinBase(baseOutDir, join(baseOutDir, resolved, defaultName));
   }
   if (output) {
-    if (includesFilename(output)) return join(baseOutDir, output);
-    return join(baseOutDir, output, relDir, defaultName);
+    if (includesFilename(output)) return assertWithinBase(baseOutDir, join(baseOutDir, output));
+    return assertWithinBase(baseOutDir, join(baseOutDir, output, relDir, defaultName));
   }
-  return join(baseOutDir, relDir, defaultName);
+  return assertWithinBase(baseOutDir, join(baseOutDir, relDir, defaultName));
 }
 __name(computeOpOutPath, "computeOpOutPath");
 function computeContractOutPath(filePath, baseDir, output, defaultSuffix, commonRoot, meta = {}) {
@@ -3084,7 +3539,7 @@ function computeSdkOutPath(filePath, rootDir, clientOutput, commonRoot, meta = {
   const baseName = filePath.split("/").pop();
   const defaultOutName = baseName.replace(/\.ck$/, ".client.ts");
   const baseOutDir = resolve(rootDir);
-  const relDir = relative5(commonRoot, dirname5(filePath));
+  const relDir = relative6(commonRoot, dirname6(filePath));
   const filename = baseName.replace(/\.ck$/, "");
   if (clientOutput && TEMPLATE_VAR_RE.test(clientOutput)) {
     const resolved = resolveTemplate(clientOutput, {
@@ -3093,14 +3548,14 @@ function computeSdkOutPath(filePath, rootDir, clientOutput, commonRoot, meta = {
       ext: "ck",
       ...meta
     });
-    if (includesFilename(resolved)) return join(baseOutDir, resolved);
-    return join(baseOutDir, resolved, defaultOutName);
+    if (includesFilename(resolved)) return assertWithinBase(baseOutDir, join(baseOutDir, resolved));
+    return assertWithinBase(baseOutDir, join(baseOutDir, resolved, defaultOutName));
   }
   if (clientOutput) {
-    if (includesFilename(clientOutput)) return join(baseOutDir, clientOutput);
-    return join(baseOutDir, clientOutput, relDir, defaultOutName);
+    if (includesFilename(clientOutput)) return assertWithinBase(baseOutDir, join(baseOutDir, clientOutput));
+    return assertWithinBase(baseOutDir, join(baseOutDir, clientOutput, relDir, defaultOutName));
   }
-  return join(baseOutDir, relDir, defaultOutName);
+  return assertWithinBase(baseOutDir, join(baseOutDir, relDir, defaultOutName));
 }
 __name(computeSdkOutPath, "computeSdkOutPath");
 function computeSdkAreaClientOutPath(area, rootDir, clientOutput) {
@@ -3121,14 +3576,14 @@ function computeSdkAreaClientOutPath(area, rootDir, clientOutput) {
       subarea: ""
     });
     const cleaned = fixHiddenSegment(resolved.replace(/\/+/g, "/").replace(/^\//, ""));
-    if (includesFilename(cleaned)) return join(baseOutDir, cleaned);
-    return join(baseOutDir, cleaned, `${filename}.client.ts`);
+    if (includesFilename(cleaned)) return assertWithinBase(baseOutDir, join(baseOutDir, cleaned));
+    return assertWithinBase(baseOutDir, join(baseOutDir, cleaned, `${filename}.client.ts`));
   }
   if (clientOutput) {
-    if (includesFilename(clientOutput)) return join(baseOutDir, clientOutput);
-    return join(baseOutDir, clientOutput, `${filename}.client.ts`);
+    if (includesFilename(clientOutput)) return assertWithinBase(baseOutDir, join(baseOutDir, clientOutput));
+    return assertWithinBase(baseOutDir, join(baseOutDir, clientOutput, `${filename}.client.ts`));
   }
-  return join(baseOutDir, `${filename}.client.ts`);
+  return assertWithinBase(baseOutDir, join(baseOutDir, `${filename}.client.ts`));
 }
 __name(computeSdkAreaClientOutPath, "computeSdkAreaClientOutPath");
 function computeSdkTypeOutPath(filePath, rootDir, typeOutput, commonRoot, meta = {}) {
@@ -3136,7 +3591,7 @@ function computeSdkTypeOutPath(filePath, rootDir, typeOutput, commonRoot, meta =
   const baseName = filePath.split("/").pop();
   const defaultOutName = baseName.replace(/\.ck$/, ".ts");
   const baseOutDir = resolve(rootDir);
-  const relDir = relative5(commonRoot, dirname5(filePath));
+  const relDir = relative6(commonRoot, dirname6(filePath));
   const filename = baseName.replace(/\.ck$/, "");
   if (TEMPLATE_VAR_RE.test(typeOutput)) {
     const resolved = resolveTemplate(typeOutput, {
@@ -3145,17 +3600,17 @@ function computeSdkTypeOutPath(filePath, rootDir, typeOutput, commonRoot, meta =
       ext: "ck",
       ...meta
     });
-    if (includesFilename(resolved)) return join(baseOutDir, resolved);
-    return join(baseOutDir, resolved, defaultOutName);
+    if (includesFilename(resolved)) return assertWithinBase(baseOutDir, join(baseOutDir, resolved));
+    return assertWithinBase(baseOutDir, join(baseOutDir, resolved, defaultOutName));
   }
-  if (includesFilename(typeOutput)) return join(baseOutDir, typeOutput);
-  return join(baseOutDir, typeOutput, relDir, defaultOutName);
+  if (includesFilename(typeOutput)) return assertWithinBase(baseOutDir, join(baseOutDir, typeOutput));
+  return assertWithinBase(baseOutDir, join(baseOutDir, typeOutput, relDir, defaultOutName));
 }
 __name(computeSdkTypeOutPath, "computeSdkTypeOutPath");
 function generateBarrelFiles(contractPaths) {
   const byDir = /* @__PURE__ */ new Map();
   for (const outPath of contractPaths) {
-    const dir = dirname5(outPath);
+    const dir = dirname6(outPath);
     const group = byDir.get(dir) ?? [];
     group.push(outPath);
     byDir.set(dir, group);
@@ -3249,6 +3704,7 @@ async function runTypescriptCodegen(inputs, ctx, config, rootDir) {
   if (config.sdk) collectSdkOutput(config.sdk, rootDir, inputs, units, globalFiles);
   if (config.zod) collectZodOutput(config.zod, rootDir, inputs, units);
   if (config.types) collectTypesOutput(config.types, rootDir, inputs, units);
+  if (config.mcp) collectMcpOutput(config.mcp, config, rootDir, inputs, units, globalFiles);
   const result = runIncrementalCodegen({
     codegenVersion: TYPESCRIPT_CODEGEN_VERSION,
     prevManifest,
@@ -3455,7 +3911,7 @@ function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
   const sdkEntryPath = sdkOutput ? join2(sdkBase, TEMPLATE_VAR_RE.test(sdkOutput) ? resolveTemplate(sdkOutput, {
     name: sdkName ?? "sdk"
   }) : sdkOutput) : join2(sdkBase, "sdk.ts");
-  const sdkOptionsPath = join2(dirname6(sdkEntryPath), "sdk-options.ts");
+  const sdkOptionsPath = join2(dirname7(sdkEntryPath), "sdk-options.ts");
   const subConfigKey = stableSubConfig(config);
   const modelsWithInput = inputs.modelsWithInput;
   const modelsWithOutput = inputs.modelsWithOutput;
@@ -3514,7 +3970,7 @@ function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
             modelsWithOutput
           });
         } else {
-          let rel = relative6(dirname6(typeOutPath), sdkOptionsPath).replace(/\.ts$/, ".js");
+          let rel = relative7(dirname7(typeOutPath), sdkOptionsPath).replace(/\.ts$/, ".js");
           if (!rel.startsWith(".")) rel = "./" + rel;
           content = generatePlainTypes(ast, {
             modelOutPaths: sdkModelOutPaths,
@@ -3655,12 +4111,12 @@ function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
   const hasAnything = sdkClientInfos.length > 0 || areaBuckets.size > 0;
   const areaClientOutPaths = /* @__PURE__ */ new Map();
   if (hasAnything) {
-    const sdkEntryDir = dirname6(sdkEntryPath);
-    const sdkOptionsRel = relative6(sdkEntryDir, sdkOptionsPath).replace(/\.ts$/, ".js");
+    const sdkEntryDir = dirname7(sdkEntryPath);
+    const sdkOptionsRel = relative7(sdkEntryDir, sdkOptionsPath).replace(/\.ts$/, ".js");
     const sdkOptionsImportPath = sdkOptionsRel.startsWith(".") ? sdkOptionsRel : "./" + sdkOptionsRel;
     const sdkClassName = sdkName ? sdkName.split(/[-._\s]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Sdk" : "Sdk";
     const toClientImport = /* @__PURE__ */ __name((sourceDir, info) => {
-      let rel = relative6(sourceDir, info.outPath).replace(/\.ts$/, ".js");
+      let rel = relative7(sourceDir, info.outPath).replace(/\.ts$/, ".js");
       if (!rel.startsWith(".")) rel = "./" + rel;
       return {
         className: info.className,
@@ -3689,7 +4145,7 @@ function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
       });
       const subareaClients = bucket.leaves.sort((a, b) => a.subarea.localeCompare(b.subarea)).map((l) => ({
         propertyName: deriveSubareaPropertyName(l.subarea),
-        client: toClientImport(dirname6(areaClientOutPath), {
+        client: toClientImport(dirname7(areaClientOutPath), {
           outPath: l.outPath,
           className: deriveSubareaClientClassName(area, l.subarea),
           propertyName: deriveSubareaPropertyName(l.subarea)
@@ -3760,23 +4216,23 @@ function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
       })
     });
   }
-  const sdkSrcDir = dirname6(sdkEntryPath);
+  const sdkSrcDir = dirname7(sdkEntryPath);
   const sdkTypeBarrels = generateBarrelFiles(sdkTypePaths);
   for (const barrel of sdkTypeBarrels) globalFiles.push({
     relativePath: barrel.outPath,
     content: barrel.content
   });
   const rootExports = [
-    `export * from './${basename3(sdkOptionsPath).replace(/\.ts$/, ".js")}';`
+    `export * from './${basename4(sdkOptionsPath).replace(/\.ts$/, ".js")}';`
   ];
-  if (hasAnything) rootExports.push(`export * from './${basename3(sdkEntryPath).replace(/\.ts$/, ".js")}';`);
+  if (hasAnything) rootExports.push(`export * from './${basename4(sdkEntryPath).replace(/\.ts$/, ".js")}';`);
   for (const c of sdkClientInfos) {
-    let rel = relative6(sdkSrcDir, c.outPath).replace(/\.ts$/, ".js");
+    let rel = relative7(sdkSrcDir, c.outPath).replace(/\.ts$/, ".js");
     if (!rel.startsWith(".")) rel = "./" + rel;
     rootExports.push(`export * from '${rel}';`);
   }
   for (const barrel of sdkTypeBarrels) {
-    let rel = relative6(sdkSrcDir, barrel.outPath).replace(/\.ts$/, ".js");
+    let rel = relative7(sdkSrcDir, barrel.outPath).replace(/\.ts$/, ".js");
     if (!rel.startsWith(".")) rel = "./" + rel;
     rootExports.push(`export * from '${rel}';`);
   }
@@ -3920,6 +4376,114 @@ function collectTypesOutput(config, rootDir, inputs, units) {
   }
 }
 __name(collectTypesOutput, "collectTypesOutput");
+function resolveMcpModelOutPaths(config, rootDir, contractRoots, commonRoot, modelsWithInput, modelsWithOutput) {
+  const map = /* @__PURE__ */ new Map();
+  let base;
+  let template;
+  let suffix;
+  if (config.mcp?.output?.types) {
+    base = resolve2(rootDir, config.mcp.baseDir ?? ".");
+    template = config.mcp.output.types;
+    suffix = ".ts";
+  } else if (config.server?.zod && config.server.output?.types) {
+    base = resolve2(rootDir, config.server.baseDir ?? ".");
+    template = config.server.output.types;
+    suffix = ".ts";
+  } else if (config.zod) {
+    base = resolve2(rootDir, config.zod.baseDir ?? ".");
+    template = config.zod.output;
+    suffix = ".schema.ts";
+  } else {
+    return map;
+  }
+  for (const ast of contractRoots) {
+    const outPath = computeContractOutPath(ast.file, base, template, suffix, commonRoot, ast.meta);
+    for (const model of ast.models) {
+      map.set(model.name, outPath);
+      if (modelsWithInput.has(model.name)) map.set(`${model.name}Input`, outPath);
+      if (modelsWithOutput.has(model.name)) map.set(`${model.name}Output`, outPath);
+    }
+  }
+  return map;
+}
+__name(resolveMcpModelOutPaths, "resolveMcpModelOutPaths");
+function collectMcpOutput(config, fullConfig, rootDir, inputs, units, globalFiles) {
+  const mcpBase = resolve2(rootDir, config.baseDir ?? ".");
+  const modelsWithInput = inputs.modelsWithInput;
+  const modelsWithOutput = inputs.modelsWithOutput;
+  const modelMap = buildModelMap(inputs.contractRoots);
+  const allFiles = [
+    ...inputs.contractRoots.map((r) => r.file),
+    ...inputs.opRoots.map((r) => r.file)
+  ];
+  const commonRoot = commonDir(allFiles, rootDir);
+  const subConfigKey = stableSubConfig(config);
+  const includeInternal = config.includeInternal ?? false;
+  const modelOutPaths = resolveMcpModelOutPaths(fullConfig, rootDir, inputs.contractRoots, commonRoot, modelsWithInput, modelsWithOutput);
+  const entries = [];
+  for (const ast of inputs.opRoots) {
+    if (!hasMcpOperations(ast, includeInternal)) continue;
+    const outPath = computeOpOutPath(ast.file, mcpBase, config.output?.tools, ".mcp.ts", commonRoot, ast.meta);
+    const refs = collectOpRootRefs(ast, modelMap);
+    const fingerprint = hashFingerprint({
+      kind: "mcp-tools",
+      v: TYPESCRIPT_CODEGEN_VERSION,
+      outPath,
+      root: ast,
+      outPathSlice: sliceOutPathMap(refs, modelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithOutput),
+      servicePathTemplate: config.servicePathTemplate ?? null,
+      includeInternal,
+      sub: subConfigKey
+    });
+    units.push({
+      key: `mcp-tools::${outPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: outPath,
+          content: generateMcpFile(ast, {
+            outPath,
+            modelOutPaths,
+            modelsWithInput,
+            modelsWithOutput,
+            servicePathTemplate: config.servicePathTemplate,
+            includeInternal
+          })
+        }
+      ], "render")
+    });
+    entries.push({
+      outPath,
+      registerFn: deriveMcpRegisterFnName(ast.file)
+    });
+  }
+  if (entries.length === 0) return;
+  const indexPath = join2(mcpBase, config.output?.index ?? "mcp.tools.ts");
+  const aggregatorEntries = entries.map((e) => {
+    let rel = relative7(dirname7(indexPath), e.outPath).replace(/\.ts$/, ".js");
+    if (!rel.startsWith(".")) rel = "./" + rel;
+    return {
+      registerFn: e.registerFn,
+      importPath: rel
+    };
+  }).sort((a, b) => a.registerFn.localeCompare(b.registerFn));
+  globalFiles.push({
+    relativePath: indexPath,
+    content: generateMcpAggregator(aggregatorEntries)
+  });
+  if (config.emitRouter !== false) {
+    const routerPath = join2(mcpBase, config.output?.router ?? "mcp.router.ts");
+    globalFiles.push({
+      relativePath: routerPath,
+      content: generateMcpRouter({
+        path: config.path
+      })
+    });
+  }
+}
+__name(collectMcpOutput, "collectMcpOutput");
 function readManifest(manifestPath) {
   if (!existsSync(manifestPath)) return emptyIncrementalManifest(TYPESCRIPT_CODEGEN_VERSION);
   try {
@@ -3931,7 +4495,7 @@ function readManifest(manifestPath) {
 __name(readManifest, "readManifest");
 function writeManifest(manifestPath, manifest) {
   try {
-    mkdirSync(dirname6(manifestPath), {
+    mkdirSync(dirname7(manifestPath), {
       recursive: true
     });
     writeFileSync(manifestPath, serializeIncrementalManifest(manifest), "utf-8");
@@ -3947,7 +4511,7 @@ function deleteStalePaths(absPaths) {
       rmSync(abs, {
         force: true
       });
-      removedDirs.add(dirname6(abs));
+      removedDirs.add(dirname7(abs));
     }
   }
   for (const dir of removedDirs) {
@@ -3956,7 +4520,7 @@ function deleteStalePaths(absPaths) {
       try {
         if (readdirSync(current).length === 0) {
           rmdirSync(current);
-          current = dirname6(current);
+          current = dirname7(current);
         } else {
           break;
         }