@contractkit/plugin-typescript 0.28.1 → 0.29.0

package/dist/index.js

@@ -2,7 +2,7 @@ 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
@@ -31,41 +31,41 @@ function headerNameToProperty(name) {
   }).join("");
 }
 __name(headerNameToProperty, "headerNameToProperty");
-function renderTsType(type) {
+function renderTsType(type, target = "client") {
   switch (type.kind) {
     case "scalar":
-      return renderTsScalar(type.name);
+      return renderTsScalar(type.name, target);
     case "array": {
-      const inner = renderTsType(type.item);
+      const inner = renderTsType(type.item, target);
       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(", ")}]`;
+      return `[${type.items.map((i) => renderTsType(i, target)).join(", ")}]`;
     case "record":
-      return `Record<${renderTsType(type.key)}, ${renderTsType(type.value)}>`;
+      return `Record<${renderTsType(type.key, target)}, ${renderTsType(type.value, target)}>`;
     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(" | ");
+      return type.members.map((m) => renderTsType(m, target)).join(" | ");
     case "discriminatedUnion":
-      return type.members.map(renderTsType).join(" | ");
+      return type.members.map((m) => renderTsType(m, target)).join(" | ");
     case "intersection":
-      return type.members.map(renderTsType).join(" & ");
+      return type.members.map((m) => renderTsType(m, target)).join(" & ");
     case "ref":
       return type.name;
     case "lazy":
-      return renderTsType(type.inner);
+      return renderTsType(type.inner, target);
     case "inlineObject":
-      return renderTsInlineObject(type.fields);
+      return renderTsInlineObject(type.fields, target);
     default:
       return "unknown";
   }
 }
 __name(renderTsType, "renderTsType");
-function renderTsScalar(name) {
+function renderTsScalar(name, target) {
   switch (name) {
     case "string":
     case "email":
@@ -92,7 +92,7 @@ function renderTsScalar(name) {
     case "object":
       return "Record<string, unknown>";
     case "binary":
-      return "Blob";
+      return target === "server" ? "Buffer" : "Blob";
     case "json":
       return "JsonValue";
     default: {
@@ -102,61 +102,61 @@ function renderTsScalar(name) {
   }
 }
 __name(renderTsScalar, "renderTsScalar");
-function renderTsInlineObject(fields) {
+function renderTsInlineObject(fields, target) {
   const entries = fields.map((f) => {
     const opt = f.optional ? "?" : "";
-    return `${quoteKey(f.name)}${opt}: ${renderTsType(f.type)}`;
+    return `${quoteKey(f.name)}${opt}: ${renderTsType(f.type, target)}`;
   });
   return `{ ${entries.join("; ")} }`;
 }
 __name(renderTsInlineObject, "renderTsInlineObject");
-function renderInputTsType(type, modelsWithInput) {
-  if (!modelsWithInput || modelsWithInput.size === 0) return renderTsType(type);
+function renderInputTsType(type, modelsWithInput, target = "client") {
+  if (!modelsWithInput || modelsWithInput.size === 0) return renderTsType(type, target);
   switch (type.kind) {
     case "ref":
       return modelsWithInput.has(type.name) ? `${type.name}Input` : type.name;
     case "array": {
-      const inner = renderInputTsType(type.item, modelsWithInput);
+      const inner = renderInputTsType(type.item, modelsWithInput, target);
       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(" & ");
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput, target)).join(" & ");
     case "union":
-      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput, target)).join(" | ");
     case "discriminatedUnion":
-      return type.members.map((m) => renderInputTsType(m, modelsWithInput)).join(" | ");
+      return type.members.map((m) => renderInputTsType(m, modelsWithInput, target)).join(" | ");
     case "inlineObject":
-      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderInputTsType(f.type, modelsWithInput)}`).join("; ")} }`;
+      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderInputTsType(f.type, modelsWithInput, target)}`).join("; ")} }`;
     case "lazy":
-      return renderInputTsType(type.inner, modelsWithInput);
+      return renderInputTsType(type.inner, modelsWithInput, target);
     default:
-      return renderTsType(type);
+      return renderTsType(type, target);
   }
 }
 __name(renderInputTsType, "renderInputTsType");
-function renderOutputTsType(type, modelsWithOutput) {
-  if (!modelsWithOutput || modelsWithOutput.size === 0) return renderTsType(type);
+function renderOutputTsType(type, modelsWithOutput, target = "client") {
+  if (!modelsWithOutput || modelsWithOutput.size === 0) return renderTsType(type, target);
   switch (type.kind) {
     case "ref":
       return modelsWithOutput.has(type.name) ? `${type.name}Output` : type.name;
     case "array": {
-      const inner = renderOutputTsType(type.item, modelsWithOutput);
+      const inner = renderOutputTsType(type.item, modelsWithOutput, target);
       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(" & ");
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput, target)).join(" & ");
     case "union":
-      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput, target)).join(" | ");
     case "discriminatedUnion":
-      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput)).join(" | ");
+      return type.members.map((m) => renderOutputTsType(m, modelsWithOutput, target)).join(" | ");
     case "inlineObject":
-      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderOutputTsType(f.type, modelsWithOutput)}`).join("; ")} }`;
+      return `{ ${type.fields.map((f) => `${quoteKey(f.name)}${f.optional ? "?" : ""}: ${renderOutputTsType(f.type, modelsWithOutput, target)}`).join("; ")} }`;
     case "lazy":
-      return renderOutputTsType(type.inner, modelsWithOutput);
+      return renderOutputTsType(type.inner, modelsWithOutput, target);
     default:
-      return renderTsType(type);
+      return renderTsType(type, target);
   }
 }
 __name(renderOutputTsType, "renderOutputTsType");
@@ -1200,8 +1200,12 @@ function generateOp(root, options = {}) {
   if (types.length > 0) {
     body.push(...generateTypeImports(types, root.file, options));
   }
-  if (opNeedsDateTime(root)) {
-    body.push(`import { DateTime } from 'luxon';`);
+  const luxonImports = [];
+  if (opNeedsDateTime(root)) luxonImports.push("DateTime");
+  if (opNeedsScalar(root, "duration")) luxonImports.push("Duration");
+  if (opNeedsScalar(root, "interval")) luxonImports.push("Interval");
+  if (luxonImports.length > 0) {
+    body.push(`import { ${luxonImports.join(", ")} } from 'luxon';`);
   }
   if (needsParseAndValidate) {
     body.push(`import { parseAndValidate } from '@maroonedsoftware/zod';`);
@@ -1216,6 +1220,9 @@ function generateOp(root, options = {}) {
   if (opNeedsScalar(root, "datetime")) {
     helpers.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 (opNeedsScalar(root, "interval")) {
+    helpers.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 (opNeedsScalar(root, "json")) {
     helpers.push(`type _JsonValue = string | number | boolean | null | _JsonValue[] | { [key: string]: _JsonValue };`);
     helpers.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)]));`);
@@ -1290,7 +1297,7 @@ function generateHandler(route, op, root, options) {
     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));
@@ -1321,13 +1328,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) => `${quoteKey(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, "server")}`).join("; ")} }` : "";
+  if (primaryResponse2?.bodyType) {
+    const { annotation, prelude } = formatTypeAnnotation(primaryResponse2.bodyType, options.modelsWithOutput);
     if (prelude) {
       lines.push(`    ${prelude}`);
     }
@@ -1346,7 +1353,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))}]`;
@@ -1357,8 +1364,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(`});`);
@@ -1419,6 +1426,45 @@ function buildArgs(route, op) {
   return args.join(", ");
 }
 __name(buildArgs, "buildArgs");
+function serverTsScalar(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":
+      return "DateTime";
+    case "duration":
+      return "Duration";
+    case "interval":
+      return "string";
+    case "binary":
+      return "Buffer";
+    case "json":
+      return "_JsonValue";
+    case "object":
+      return "Record<string, unknown>";
+    case "null":
+      return "null";
+    case "unknown":
+      return "unknown";
+    default: {
+      const _exhaustive = name;
+      throw new Error(`plugin-typescript: unmapped scalar '${String(_exhaustive)}' \u2014 add a case`);
+    }
+  }
+}
+__name(serverTsScalar, "serverTsScalar");
 function formatTypeAnnotation(bodyType, modelsWithOutput) {
   if (bodyType.kind === "array") {
     const inner = formatTypeAnnotation(bodyType.item, modelsWithOutput);
@@ -1434,7 +1480,7 @@ function formatTypeAnnotation(bodyType, modelsWithOutput) {
     };
   }
   if (bodyType.kind === "scalar") return {
-    annotation: bodyType.name
+    annotation: serverTsScalar(bodyType.name)
   };
   const schema = renderType(bodyType);
   return {
@@ -1960,11 +2006,11 @@ 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) => `${quoteKey(headerNameToProperty(h.name))}${h.optional ? "?" : ""}: ${renderOutputTsType(h.type, modelsWithOutput)}`).join("; ")} }` : "";
   const returnType = hasRespHeaders ? isVoid ? `{ headers: ${headersShape} }` : `{ data: ${dataType}; headers: ${headersShape} }` : dataType;
@@ -2807,6 +2853,7 @@ __name(generateSdkAggregator, "generateSdkAggregator");
 import { relative as relative4, dirname as dirname4 } from "path";
 import { computeModelsWithOutput, collectExternalOutputRefs } from "@contractkit/core";
 function generatePlainTypes(root, context) {
+  const target = context?.target ?? "client";
   const externalRefs = collectExternalRefs(root);
   const lines = [];
   const externalModelsWithInput = context?.modelsWithInput ?? /* @__PURE__ */ new Set();
@@ -2848,21 +2895,21 @@ function generatePlainTypes(root, context) {
     m
   ]));
   for (const model of topoSortModels(root.models)) {
-    lines.push(...generateModel2(model, context?.currentOutPath, allModelsWithInput, allModelsWithOutput, modelMap));
+    lines.push(...generateModel2(model, target, context?.currentOutPath, allModelsWithInput, allModelsWithOutput, modelMap));
     lines.push("");
   }
   return lines.join("\n");
 }
 __name(generatePlainTypes, "generatePlainTypes");
-function generateModel2(model, outPath, modelsWithInput, modelsWithOutput, modelMap) {
+function generateModel2(model, target, outPath, modelsWithInput, modelsWithOutput, modelMap) {
   if (model.type) {
-    return generateTypeAlias2(model, outPath, modelsWithInput, modelsWithOutput);
+    return generateTypeAlias2(model, target, outPath, modelsWithInput, modelsWithOutput);
   }
   const needsInputSplit = model.fields.some((f) => f.visibility !== "normal") || (modelsWithInput?.has(model.name) ?? false);
-  const lines = needsInputSplit ? generateVisibilityModel(model, outPath, modelsWithInput, modelMap) : generateSimpleModel2(model, outPath, modelMap);
+  const lines = needsInputSplit ? generateVisibilityModel(model, target, outPath, modelsWithInput, modelMap) : generateSimpleModel2(model, target, outPath, modelMap);
   if (modelsWithOutput?.has(model.name)) {
     lines.push("");
-    lines.push(...generateOutputModel(model, modelsWithOutput));
+    lines.push(...generateOutputModel(model, target, modelsWithOutput));
   }
   return lines;
 }
@@ -2899,15 +2946,15 @@ function generateComments2(model, outPath) {
   return lines;
 }
 __name(generateComments2, "generateComments");
-function generateTypeAlias2(model, outPath, modelsWithInput, modelsWithOutput) {
+function generateTypeAlias2(model, target, outPath, modelsWithInput, modelsWithOutput) {
   const lines = [];
   lines.push(...generateComments2(model, outPath));
-  lines.push(`export type ${model.name} = ${renderTsType(model.type)};`);
+  lines.push(`export type ${model.name} = ${renderTsType(model.type, target)};`);
   if (modelsWithInput?.has(model.name)) {
-    lines.push(`export type ${model.name}Input = ${renderInputTsType(model.type, modelsWithInput)};`);
+    lines.push(`export type ${model.name}Input = ${renderInputTsType(model.type, modelsWithInput, target)};`);
   }
   if (modelsWithOutput?.has(model.name)) {
-    lines.push(`export type ${model.name}Output = ${renderOutputTsType(model.type, modelsWithOutput)};`);
+    lines.push(`export type ${model.name}Output = ${renderOutputTsType(model.type, modelsWithOutput, target)};`);
   }
   return lines;
 }
@@ -2920,20 +2967,20 @@ function buildExtendsClause(bases, overrideNames, baseNameResolver) {
   return ` extends ${wrapped.join(", ")}`;
 }
 __name(buildExtendsClause, "buildExtendsClause");
-function generateSimpleModel2(model, outPath, modelMap) {
+function generateSimpleModel2(model, target, outPath, modelMap) {
   const lines = [];
   lines.push(...generateComments2(model, outPath));
   const bases = model.bases ?? [];
   const overrideNames = computeOverrideNames(model, modelMap);
   lines.push(`export interface ${model.name}${buildExtendsClause(bases, overrideNames, (b) => b)} {`);
   for (const field of model.fields) {
-    lines.push(`    ${renderField2(field)}`);
+    lines.push(`    ${renderField2(field, target)}`);
   }
   lines.push("}");
   return lines;
 }
 __name(generateSimpleModel2, "generateSimpleModel");
-function generateVisibilityModel(model, outPath, modelsWithInput, modelMap) {
+function generateVisibilityModel(model, target, outPath, modelsWithInput, modelMap) {
   const lines = [];
   lines.push(...generateComments2(model, outPath));
   const bases = model.bases ?? [];
@@ -2941,7 +2988,7 @@ function generateVisibilityModel(model, outPath, modelsWithInput, modelMap) {
   const readFields = model.fields.filter((f) => f.visibility !== "writeonly");
   lines.push(`export interface ${model.name}${buildExtendsClause(bases, overrideNames, (b) => b)} {`);
   for (const field of readFields) {
-    lines.push(`    ${renderField2(field)}`);
+    lines.push(`    ${renderField2(field, target)}`);
   }
   lines.push("}");
   lines.push("");
@@ -2949,7 +2996,7 @@ function generateVisibilityModel(model, outPath, modelsWithInput, modelMap) {
   const inputResolver = /* @__PURE__ */ __name((b) => modelsWithInput?.has(b) ? `${b}Input` : b, "inputResolver");
   lines.push(`export interface ${model.name}Input${buildExtendsClause(bases, overrideNames, inputResolver)} {`);
   for (const field of writeFields) {
-    lines.push(`    ${modelsWithInput ? renderInputField2(field, modelsWithInput) : renderField2(field)}`);
+    lines.push(`    ${modelsWithInput ? renderInputField2(field, modelsWithInput, target) : renderField2(field, target)}`);
   }
   lines.push("}");
   return lines;
@@ -2969,9 +3016,9 @@ ${body}
     ${line}`;
 }
 __name(withFieldJsDoc, "withFieldJsDoc");
-function renderField2(field) {
+function renderField2(field, target) {
   const opt = field.optional || field.default !== void 0 ? "?" : "";
-  let typeStr = renderTsType(field.type);
+  let typeStr = renderTsType(field.type, target);
   if (field.nullable) typeStr += " | null";
   const line = `${quoteKey(field.name)}${opt}: ${typeStr};`;
   const jsdocParts = [];
@@ -2980,9 +3027,9 @@ function renderField2(field) {
   return withFieldJsDoc(jsdocParts, line);
 }
 __name(renderField2, "renderField");
-function renderInputField2(field, modelsWithInput) {
+function renderInputField2(field, modelsWithInput, target) {
   const opt = field.optional || field.default !== void 0 ? "?" : "";
-  let typeStr = renderInputTsType(field.type, modelsWithInput);
+  let typeStr = renderInputTsType(field.type, modelsWithInput, target);
   if (field.nullable) typeStr += " | null";
   const line = `${quoteKey(field.name)}${opt}: ${typeStr};`;
   const jsdocParts = [];
@@ -3005,7 +3052,7 @@ function applyOutputCase(name, c) {
   return camelToPascal2(name);
 }
 __name(applyOutputCase, "applyOutputCase");
-function generateOutputModel(model, modelsWithOutput) {
+function generateOutputModel(model, target, modelsWithOutput) {
   const lines = [];
   const outputCase = model.outputCase && model.outputCase !== "camel" ? model.outputCase : void 0;
   const readFields = model.fields.filter((f) => f.visibility !== "writeonly");
@@ -3013,23 +3060,23 @@ function generateOutputModel(model, modelsWithOutput) {
     const baseExt = model.bases?.[0] && modelsWithOutput.has(model.bases?.[0]) ? ` extends ${model.bases?.[0]}Output` : model.bases?.[0] ? ` extends ${model.bases?.[0]}` : "";
     lines.push(`export interface ${model.name}Output${baseExt} {`);
     for (const field of readFields) {
-      lines.push(`    ${renderOutputField(field, model.outputCase, modelsWithOutput)}`);
+      lines.push(`    ${renderOutputField(field, model.outputCase, modelsWithOutput, target)}`);
     }
     lines.push("}");
     return lines;
   }
   lines.push(`export interface ${model.name}Output {`);
   for (const field of readFields) {
-    lines.push(`    ${renderOutputField(field, outputCase, modelsWithOutput)}`);
+    lines.push(`    ${renderOutputField(field, outputCase, modelsWithOutput, target)}`);
   }
   lines.push("}");
   return lines;
 }
 __name(generateOutputModel, "generateOutputModel");
-function renderOutputField(field, outputCase, modelsWithOutput) {
+function renderOutputField(field, outputCase, modelsWithOutput, target) {
   const opt = field.optional || field.default !== void 0 ? "?" : "";
   const key = applyOutputCase(field.name, outputCase);
-  let typeStr = renderOutputTsType(field.type, modelsWithOutput);
+  let typeStr = renderOutputTsType(field.type, modelsWithOutput, target);
   if (field.nullable) typeStr += " | null";
   const line = `${quoteKey(key)}${opt}: ${typeStr};`;
   const jsdocParts = [];
@@ -3039,12 +3086,443 @@ function renderOutputField(field, outputCase, modelsWithOutput) {
 }
 __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, isAbsolute } 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 = relative5(resolve(baseOutDir), resolve(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)`);
   }
@@ -3062,7 +3540,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) {
@@ -3078,7 +3556,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);
@@ -3108,7 +3586,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, {
@@ -3160,7 +3638,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, {
@@ -3179,7 +3657,7 @@ __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);
@@ -3273,6 +3751,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,
@@ -3424,7 +3903,9 @@ function collectServerOutput(config, rootDir, inputs, units) {
           modelOutPaths: serverModelOutPaths,
           currentOutPath: typeOutPath,
           modelsWithInput,
-          modelsWithOutput
+          modelsWithOutput,
+          // These types are consumed by Koa handlers, so `binary` is a Buffer, not a Blob.
+          target: "server"
         };
         const content = config.zod ? generateContract(ast, renderCtx) : generatePlainTypes(ast, renderCtx);
         return [
@@ -3479,7 +3960,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;
@@ -3538,7 +4019,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,
@@ -3679,12 +4160,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,
@@ -3713,7 +4194,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)
@@ -3784,23 +4265,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}';`);
   }
@@ -3936,7 +4417,8 @@ function collectTypesOutput(config, rootDir, inputs, units) {
             modelOutPaths,
             currentOutPath: outPath,
             modelsWithInput,
-            modelsWithOutput
+            modelsWithOutput,
+            target: config.target
           })
         }
       ], "render")
@@ -3944,6 +4426,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 {
@@ -3955,7 +4545,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");
@@ -3971,7 +4561,7 @@ function deleteStalePaths(absPaths) {
       rmSync(abs, {
         force: true
       });
-      removedDirs.add(dirname6(abs));
+      removedDirs.add(dirname7(abs));
     }
   }
   for (const dir of removedDirs) {
@@ -3980,7 +4570,7 @@ function deleteStalePaths(absPaths) {
       try {
         if (readdirSync(current).length === 0) {
           rmdirSync(current);
-          current = dirname6(current);
+          current = dirname7(current);
         } else {
           break;
         }