@contractkit/plugin-typescript 0.16.1

package/dist/index.js

@@ -0,0 +1,3162 @@
+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";
+
+// src/codegen-contract.ts
+import { relative, dirname } from "path";
+import { collectTypeRefs, computeModelsWithOutput as ckComputeModelsWithOutput, collectExternalOutputRefs as ckCollectExternalOutputRefs } from "@contractkit/core";
+function modeToWrapper(mode) {
+  switch (mode) {
+    case "strict":
+      return "z.strictObject";
+    case "strip":
+      return "z.object";
+    case "loose":
+      return "z.looseObject";
+  }
+}
+__name(modeToWrapper, "modeToWrapper");
+function computeModelsWithInput(models, externalModelsWithInput = /* @__PURE__ */ new Set()) {
+  const result = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    if (model.fields.some((f) => f.visibility !== "normal")) {
+      result.add(model.name);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const model of models) {
+      if (result.has(model.name)) continue;
+      const refs = /* @__PURE__ */ new Set();
+      for (const field of model.fields) {
+        collectTypeRefs(field.type, refs);
+      }
+      if (model.bases) for (const b of model.bases) refs.add(b);
+      if (model.type) collectTypeRefs(model.type, refs);
+      for (const ref of refs) {
+        if (result.has(ref) || externalModelsWithInput.has(ref)) {
+          result.add(model.name);
+          changed = true;
+          break;
+        }
+      }
+    }
+  }
+  return result;
+}
+__name(computeModelsWithInput, "computeModelsWithInput");
+function generateComments(model, outPath) {
+  const lines = [];
+  lines.push("/**");
+  if (model.deprecated) {
+    lines.push(` * @deprecated`);
+  }
+  if (model.description) {
+    lines.push(` * ${model.description}`);
+  }
+  const relPath = outPath ? relative(dirname(outPath), model.loc.file) : model.loc.file;
+  lines.push(` * generated from [${model.name}](file://./${relPath}#L${model.loc.line})`);
+  lines.push("*/");
+  return lines;
+}
+__name(generateComments, "generateComments");
+function generateContract(root, context) {
+  const needsDateTime = rootNeedsDateTime(root);
+  const needsDuration = rootNeedsScalar(root, "duration");
+  const needsInterval = rootNeedsScalar(root, "interval");
+  const needsBinary = rootNeedsScalar(root, "binary");
+  const needsDatetime = rootNeedsScalar(root, "datetime");
+  const needsJson = rootNeedsScalar(root, "json");
+  const externalRefs = collectExternalRefs(root);
+  const lines = [];
+  const externalModelsWithInput = context?.modelsWithInput ?? /* @__PURE__ */ new Set();
+  const localModelsWithInput = computeModelsWithInput(root.models, externalModelsWithInput);
+  const allModelsWithInput = /* @__PURE__ */ new Set([
+    ...localModelsWithInput,
+    ...externalModelsWithInput
+  ]);
+  const externalModelsWithOutput = context?.modelsWithOutput ?? /* @__PURE__ */ new Set();
+  const localModelsWithOutput = ckComputeModelsWithOutput(root.models, externalModelsWithOutput);
+  const allModelsWithOutput = /* @__PURE__ */ new Set([
+    ...localModelsWithOutput,
+    ...externalModelsWithOutput
+  ]);
+  const externalInputRefs = allModelsWithInput.size > 0 ? collectExternalInputRefs(root, allModelsWithInput) : [];
+  const externalOutputRefs = allModelsWithOutput.size > 0 ? ckCollectExternalOutputRefs(root, allModelsWithOutput) : [];
+  const allExternalRefs = [
+    .../* @__PURE__ */ new Set([
+      ...externalRefs,
+      ...externalInputRefs,
+      ...externalOutputRefs
+    ])
+  ].sort();
+  lines.push(`import { z } from 'zod';`);
+  const luxonImports = [];
+  if (needsDateTime) luxonImports.push("DateTime");
+  if (needsDuration) luxonImports.push("Duration");
+  if (needsInterval) luxonImports.push("Interval");
+  if (luxonImports.length > 0) lines.push(`import { ${luxonImports.join(", ")} } from 'luxon';`);
+  for (const ref of allExternalRefs) {
+    const importPath = resolveImportPath(ref, context);
+    lines.push(`import { ${ref} } from '${importPath}';`);
+  }
+  lines.push("");
+  if (needsBinary) {
+    lines.push(`const _ZodBinary = z.custom<Buffer>((val) => Buffer.isBuffer(val), { error: 'Must be binary data' });`);
+  }
+  if (needsDatetime) {
+    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 (needsInterval) {
+    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 (needsJson) {
+    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)]));`);
+  }
+  if (needsBinary || needsDatetime || needsInterval || needsJson) lines.push("");
+  const modelsWithWriteonly = new Set(root.models.filter((m) => m.fields.some((f) => f.visibility === "writeonly")).map((m) => m.name));
+  const modelMap = new Map(root.models.map((m) => [
+    m.name,
+    m
+  ]));
+  for (const model of topoSortModels(root.models)) {
+    lines.push(...generateModel(model, context?.currentOutPath, allModelsWithInput, modelsWithWriteonly, modelMap, allModelsWithOutput));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+__name(generateContract, "generateContract");
+function flattenFormatChain(model, modelMap) {
+  if (!model.bases || model.bases.length === 0) return model;
+  const firstBase = model.bases[0];
+  const parent = modelMap.get(firstBase);
+  if (!parent) return model;
+  const flatParent = flattenFormatChain(parent, modelMap);
+  const parentHasFormat = flatParent.inputCase !== void 0 && flatParent.inputCase !== "camel" || flatParent.outputCase !== void 0 && flatParent.outputCase !== "camel";
+  if (!parentHasFormat) return model;
+  const merged = /* @__PURE__ */ new Map();
+  for (const f of flatParent.fields) merged.set(f.name, f);
+  for (const f of model.fields) merged.set(f.name, f);
+  return {
+    ...model,
+    bases: void 0,
+    fields: [
+      ...merged.values()
+    ],
+    inputCase: model.inputCase ?? flatParent.inputCase,
+    outputCase: model.outputCase ?? flatParent.outputCase,
+    mode: model.mode ?? flatParent.mode
+  };
+}
+__name(flattenFormatChain, "flattenFormatChain");
+function generateModel(model, outPath, modelsWithInput, modelsWithWriteonly, modelMap, modelsWithOutput) {
+  if (model.type) {
+    return generateTypeAlias(model, outPath, modelsWithInput, modelsWithOutput);
+  }
+  const effective = modelMap ? flattenFormatChain(model, modelMap) : model;
+  const needsInputSplit = effective.fields.some((f) => f.visibility !== "normal") || (modelsWithInput?.has(effective.name) ?? false);
+  const lines = needsInputSplit ? generateThreeSchemaModel(effective, outPath, modelsWithInput, modelsWithWriteonly) : generateSimpleModel(effective, outPath);
+  if (modelsWithOutput?.has(effective.name)) {
+    lines.push(`export type ${effective.name}Output = z.output<typeof ${effective.name}>;`);
+  }
+  return lines;
+}
+__name(generateModel, "generateModel");
+function generateTypeAlias(model, outPath, modelsWithInput, modelsWithOutput) {
+  const lines = [];
+  lines.push(...generateComments(model, outPath));
+  lines.push(`export const ${model.name} = ${renderType(model.type)};`);
+  lines.push(`export type ${model.name} = z.infer<typeof ${model.name}>;`);
+  if (modelsWithInput?.has(model.name)) {
+    lines.push(`export const ${model.name}Input = ${renderInputType(model.type, modelsWithInput)};`);
+    lines.push(`export type ${model.name}Input = z.infer<typeof ${model.name}Input>;`);
+  }
+  if (modelsWithOutput?.has(model.name)) {
+    lines.push(`export type ${model.name}Output = z.output<typeof ${model.name}>;`);
+  }
+  return lines;
+}
+__name(generateTypeAlias, "generateTypeAlias");
+function generateSimpleModel(model, outPath) {
+  const lines = [];
+  lines.push(...generateComments(model, outPath));
+  const wrapper = modeToWrapper(model.mode ?? "strict");
+  const { inputCase, outputCase } = model;
+  const hasInputTransform = !!inputCase && inputCase !== "camel";
+  const hasOutputTransform = !!outputCase && outputCase !== "camel";
+  if (hasInputTransform || hasOutputTransform) {
+    const inputBody = inputCase === "snake" ? renderFieldsAsSnakeCase(model.fields, model.mode) : inputCase === "pascal" ? renderFieldsAsPascalCase(model.fields, model.mode) : renderFields(model.fields, model.mode);
+    lines.push(`export const ${model.name} = ${wrapper}({`);
+    lines.push(...inputBody.map((l) => `    ${l}`));
+    lines.push(`}).transform(data => ({`);
+    for (const field of model.fields) {
+      const inputKey = applyCase(field.name, inputCase);
+      const outputKey = applyCase(field.name, outputCase);
+      lines.push(`    ${quoteKey(outputKey)}: data.${inputKey},`);
+    }
+    lines.push(`}));`);
+    const typeSource = hasOutputTransform && !hasInputTransform ? "input" : "output";
+    lines.push(`export type ${model.name} = z.${typeSource}<typeof ${model.name}>;`);
+    return lines;
+  }
+  const body = renderFields(model.fields, model.mode);
+  const bases = model.bases ?? [];
+  if (bases.length > 0) {
+    const head = bases[0];
+    const tail = bases.slice(1).map((b) => `.extend(${b}.shape)`).join("");
+    lines.push(`export const ${model.name} = ${head}${tail}.extend({`);
+    lines.push(...body.map((l) => `    ${l}`));
+    lines.push(`});`);
+  } else {
+    lines.push(`export const ${model.name} = ${wrapper}({`);
+    lines.push(...body.map((l) => `    ${l}`));
+    lines.push(`});`);
+  }
+  lines.push(`export type ${model.name} = z.infer<typeof ${model.name}>;`);
+  return lines;
+}
+__name(generateSimpleModel, "generateSimpleModel");
+function buildExtendChain(bases, resolveName) {
+  const head = resolveName(bases[0]);
+  const tail = bases.slice(1).map((b) => `.extend(${resolveName(b)}.shape)`).join("");
+  return {
+    head,
+    tail
+  };
+}
+__name(buildExtendChain, "buildExtendChain");
+function generateThreeSchemaModel(model, outPath, modelsWithInput, modelsWithWriteonly) {
+  const lines = [];
+  const name = model.name;
+  lines.push(...generateComments(model, outPath));
+  const wrapper = modeToWrapper(model.mode ?? "strict");
+  const allFields = model.fields;
+  const hasWriteonly = allFields.some((f) => f.visibility === "writeonly");
+  const bases = model.bases ?? [];
+  if (hasWriteonly) {
+    const baseBody = renderFields(allFields, model.mode);
+    if (bases.length > 0) {
+      const { head, tail } = buildExtendChain(bases, (b) => modelsWithWriteonly?.has(b) ? `${b}Base` : b);
+      lines.push(`const ${name}Base = ${head}${tail}.extend({`);
+    } else {
+      lines.push(`const ${name}Base = ${wrapper}({`);
+    }
+    lines.push(...baseBody.map((l) => `    ${l}`));
+    lines.push(`});`);
+    lines.push("");
+  }
+  const readFields = allFields.filter((f) => f.visibility !== "writeonly");
+  const readBody = renderFields(readFields, model.mode);
+  if (bases.length > 0) {
+    const { head, tail } = buildExtendChain(bases, (b) => b);
+    lines.push(`export const ${name} = ${head}${tail}.extend({`);
+  } else {
+    lines.push(`export const ${name} = ${wrapper}({`);
+  }
+  lines.push(...readBody.map((l) => `    ${l}`));
+  lines.push(`});`);
+  lines.push(`export type ${name} = z.infer<typeof ${name}>;`);
+  lines.push("");
+  const writeFields = allFields.filter((f) => f.visibility !== "readonly");
+  const writeBody = modelsWithInput ? renderInputFields(writeFields, modelsWithInput, model.mode) : renderFields(writeFields, model.mode);
+  if (bases.length > 0) {
+    const { head, tail } = buildExtendChain(bases, (b) => modelsWithInput?.has(b) ? `${b}Input` : b);
+    lines.push(`export const ${name}Input = ${head}${tail}.extend({`);
+  } else {
+    lines.push(`export const ${name}Input = ${wrapper}({`);
+  }
+  lines.push(...writeBody.map((l) => `    ${l}`));
+  lines.push(`});`);
+  lines.push(`export type ${name}Input = z.infer<typeof ${name}Input>;`);
+  return lines;
+}
+__name(generateThreeSchemaModel, "generateThreeSchemaModel");
+function camelToSnake(s) {
+  return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+__name(camelToSnake, "camelToSnake");
+function camelToPascal(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+__name(camelToPascal, "camelToPascal");
+function applyCase(name, caseTransform) {
+  if (!caseTransform || caseTransform === "camel") return name;
+  if (caseTransform === "snake") return camelToSnake(name);
+  return camelToPascal(name);
+}
+__name(applyCase, "applyCase");
+function renderFields(fields, defaultMode) {
+  return fields.flatMap((f) => renderField(f, defaultMode));
+}
+__name(renderFields, "renderFields");
+function renderFieldsAsPascalCase(fields, defaultMode) {
+  return fields.map((f) => {
+    const pascalKey = camelToPascal(f.name);
+    let expr = renderType(f.type, "pascal", defaultMode);
+    if (f.default !== void 0) {
+      if (f.nullable) expr += ".nullable()";
+      const dv = typeof f.default === "string" ? `"${escapeString(f.default)}"` : String(f.default);
+      expr += `.default(${dv})`;
+    } else if (f.optional) {
+      expr += ".nullish()";
+    } else if (f.nullable) {
+      expr += ".nullable()";
+    }
+    if (f.description) expr += `.describe("${escapeString(f.description)}")`;
+    return `${quoteKey(pascalKey)}: ${expr},`;
+  });
+}
+__name(renderFieldsAsPascalCase, "renderFieldsAsPascalCase");
+function renderFieldsAsSnakeCase(fields, defaultMode) {
+  return fields.map((f) => {
+    const snakeKey = camelToSnake(f.name);
+    let expr = renderType(f.type, "snake", defaultMode);
+    if (f.default !== void 0) {
+      if (f.nullable) expr += ".nullable()";
+      const dv = typeof f.default === "string" ? `"${escapeString(f.default)}"` : String(f.default);
+      expr += `.default(${dv})`;
+    } else if (f.optional) {
+      expr += ".nullish()";
+    } else if (f.nullable) {
+      expr += ".nullable()";
+    }
+    if (f.description) expr += `.describe("${escapeString(f.description)}")`;
+    return `${quoteKey(snakeKey)}: ${expr},`;
+  });
+}
+__name(renderFieldsAsSnakeCase, "renderFieldsAsSnakeCase");
+function renderField(field, defaultMode) {
+  const lines = [];
+  if (field.deprecated) lines.push("/** @deprecated */");
+  let expr = renderType(field.type, void 0, defaultMode);
+  if (field.nullable) expr += ".nullable()";
+  if (field.default !== void 0) {
+    const dv = typeof field.default === "string" ? `"${escapeString(field.default)}"` : String(field.default);
+    expr += `.default(${dv})`;
+  } else if (field.optional) {
+    expr += ".optional()";
+  }
+  if (field.description) expr += `.describe("${escapeString(field.description)}")`;
+  lines.push(`${quoteKey(field.name)}: ${expr},`);
+  return lines;
+}
+__name(renderField, "renderField");
+function renderType(type, parseCaseTransform, defaultMode) {
+  switch (type.kind) {
+    case "scalar":
+      return renderScalar(type);
+    case "array":
+      return renderArray(type, parseCaseTransform, defaultMode);
+    case "tuple":
+      return renderTuple(type);
+    case "record":
+      return renderRecord(type);
+    case "enum":
+      return renderEnum(type);
+    case "literal":
+      return renderLiteral(type);
+    case "union":
+      return renderUnion(type, parseCaseTransform, defaultMode);
+    case "discriminatedUnion":
+      return renderDiscriminatedUnion(type, parseCaseTransform, defaultMode);
+    case "intersection":
+      return renderIntersection(type, parseCaseTransform, defaultMode);
+    case "ref":
+      return type.name;
+    case "lazy":
+      return `z.lazy(() => ${renderType(type.inner, parseCaseTransform, defaultMode)})`;
+    case "inlineObject":
+      return renderInlineObject(type, parseCaseTransform, defaultMode);
+    default:
+      return "z.unknown()";
+  }
+}
+__name(renderType, "renderType");
+function renderRegexLiteral(source) {
+  const body = source.replace(/\//g, "\\/");
+  if (regexHasAnchor(source)) return `/${body}/`;
+  return `/^${body}$/`;
+}
+__name(renderRegexLiteral, "renderRegexLiteral");
+function regexHasAnchor(source) {
+  if (source.startsWith("^")) return true;
+  if (!source.endsWith("$")) return false;
+  let i = source.length - 2;
+  let backslashes = 0;
+  while (i >= 0 && source[i] === "\\") {
+    backslashes++;
+    i--;
+  }
+  return backslashes % 2 === 0;
+}
+__name(regexHasAnchor, "regexHasAnchor");
+function renderScalar(s) {
+  switch (s.name) {
+    case "string": {
+      let e = "z.string()";
+      if (s.min !== void 0 && s.max !== void 0) e += `.min(${s.min}).max(${s.max})`;
+      else if (s.min !== void 0) e += `.min(${s.min})`;
+      else if (s.max !== void 0) e += `.max(${s.max})`;
+      if (s.len !== void 0) e += `.length(${s.len})`;
+      if (s.regex) e += `.regex(${renderRegexLiteral(s.regex)})`;
+      return e;
+    }
+    case "number": {
+      let e = "z.coerce.number()";
+      if (s.min !== void 0) e += `.min(${s.min})`;
+      if (s.max !== void 0) e += `.max(${s.max})`;
+      return e;
+    }
+    case "int": {
+      let e = "z.coerce.number().int()";
+      if (s.min !== void 0) e += `.min(${s.min})`;
+      if (s.max !== void 0) e += `.max(${s.max})`;
+      return e;
+    }
+    case "bigint": {
+      let inner = "z.bigint()";
+      if (s.min !== void 0) inner += `.min(${s.min}n)`;
+      if (s.max !== void 0) inner += `.max(${s.max}n)`;
+      return `z.preprocess((val) => typeof val === 'string' ? BigInt(val.replace(/n$/, '')) : val, ${inner})`;
+    }
+    case "boolean":
+      return `z.preprocess((v) => v === 'true' ? true : v === 'false' ? false : v, z.boolean())`;
+    case "date": {
+      const fmt = s.format ?? "yyyy-MM-dd";
+      return `z.preprocess((val) => typeof val === 'string' ? DateTime.fromFormat(val, '${escapeString(fmt)}') : val, z.custom<DateTime>((val) => val instanceof DateTime && val.isValid, { message: 'Must be a date in format ${escapeString(fmt)}' }))`;
+    }
+    case "time": {
+      const fmt = s.format ?? "HH:mm:ss";
+      return `z.preprocess((val) => typeof val === 'string' ? DateTime.fromFormat(val, '${escapeString(fmt)}') : val, z.custom<DateTime>((val) => val instanceof DateTime && val.isValid, { message: 'Must be a time in format ${escapeString(fmt)}' }))`;
+    }
+    case "datetime":
+      return "_ZodDatetime";
+    case "interval":
+      return "_ZodInterval";
+    case "duration": {
+      const validParts = [
+        `val instanceof Duration && val.isValid`
+      ];
+      if (s.min !== void 0) validParts.push(`val.toMillis() >= Duration.fromISO('${s.min}').toMillis()`);
+      if (s.max !== void 0) validParts.push(`val.toMillis() <= Duration.fromISO('${s.max}').toMillis()`);
+      const validation = validParts.join(" && ");
+      let message = "Must be an ISO 8601 duration";
+      if (s.min !== void 0 && s.max !== void 0) message += ` between ${s.min} and ${s.max}`;
+      else if (s.min !== void 0) message += ` of at least ${s.min}`;
+      else if (s.max !== void 0) message += ` of at most ${s.max}`;
+      return `z.preprocess((val) => typeof val === 'string' ? Duration.fromISO(val) : val, z.custom<Duration>((val) => ${validation}, { message: '${message}' }))`;
+    }
+    case "email":
+      return "z.email()";
+    case "url":
+      return "z.url()";
+    case "uuid":
+      return "z.uuid()";
+    case "unknown":
+      return "z.unknown()";
+    case "null":
+      return "z.null()";
+    case "object":
+      return "z.record(z.string(), z.unknown())";
+    case "binary":
+      return "_ZodBinary";
+    case "json":
+      return "_ZodJson";
+    default:
+      return "z.unknown()";
+  }
+}
+__name(renderScalar, "renderScalar");
+function renderArray(a, parseCaseTransform, defaultMode) {
+  let e = `z.array(${renderType(a.item, parseCaseTransform, defaultMode)})`;
+  if (a.min !== void 0) e += `.min(${a.min})`;
+  if (a.max !== void 0) e += `.max(${a.max})`;
+  return e;
+}
+__name(renderArray, "renderArray");
+function renderTuple(t) {
+  return `z.tuple([${t.items.map((i) => renderType(i)).join(", ")}])`;
+}
+__name(renderTuple, "renderTuple");
+function renderRecord(r) {
+  return `z.record(${renderType(r.key)}, ${renderType(r.value)})`;
+}
+__name(renderRecord, "renderRecord");
+function renderEnum(e) {
+  const vals = e.values.map((v) => `"${v}"`).join(", ");
+  return `z.enum([${vals}])`;
+}
+__name(renderEnum, "renderEnum");
+function renderLiteral(l) {
+  if (typeof l.value === "string") return `z.literal("${escapeString(l.value)}")`;
+  return `z.literal(${l.value})`;
+}
+__name(renderLiteral, "renderLiteral");
+function renderUnion(u, parseCaseTransform, defaultMode) {
+  return `z.union([${u.members.map((m) => renderType(m, parseCaseTransform, defaultMode)).join(", ")}])`;
+}
+__name(renderUnion, "renderUnion");
+function renderDiscriminatedUnion(u, parseCaseTransform, defaultMode) {
+  return `z.discriminatedUnion("${escapeString(u.discriminator)}", [${u.members.map((m) => renderType(m, parseCaseTransform, defaultMode)).join(", ")}])`;
+}
+__name(renderDiscriminatedUnion, "renderDiscriminatedUnion");
+function renderIntersection(i, parseCaseTransform, defaultMode) {
+  const [first, ...rest] = i.members;
+  if (first && first.kind === "ref" && rest.length > 0 && rest.every((m) => m.kind === "inlineObject")) {
+    const allFields = rest.flatMap((m) => m.fields);
+    const fieldLines = parseCaseTransform === "snake" ? renderFieldsAsSnakeCase(allFields, defaultMode).map((l) => `    ${l}`).join("\n") : parseCaseTransform === "pascal" ? renderFieldsAsPascalCase(allFields, defaultMode).map((l) => `    ${l}`).join("\n") : allFields.flatMap((f) => renderField(f, defaultMode)).map((l) => `    ${l}`).join("\n");
+    return `${first.name}.extend({
+${fieldLines}
+})`;
+  }
+  let expr = renderType(first, parseCaseTransform, defaultMode);
+  for (const member of rest) {
+    expr += `.and(${renderType(member, parseCaseTransform, defaultMode)})`;
+  }
+  return expr;
+}
+__name(renderIntersection, "renderIntersection");
+function renderInlineObject(o, parseCaseTransform, defaultMode) {
+  const wrapper = modeToWrapper(o.mode ?? defaultMode ?? "strict");
+  if (parseCaseTransform === "snake") {
+    const snakeLines = renderFieldsAsSnakeCase(o.fields, defaultMode);
+    const joined = snakeLines.map((l) => `    ${l}`).join("\n");
+    const transformEntries = o.fields.map((f) => {
+      const snakeKey = camelToSnake(f.name);
+      const val = f.optional ? `data.${snakeKey} ?? undefined` : `data.${snakeKey}`;
+      return `    ${quoteKey(f.name)}: ${val},`;
+    }).join("\n");
+    return `${wrapper}({
+${joined}
+}).transform(data => ({
+${transformEntries}
+}))`;
+  }
+  if (parseCaseTransform === "pascal") {
+    const pascalLines = renderFieldsAsPascalCase(o.fields, defaultMode);
+    const joined = pascalLines.map((l) => `    ${l}`).join("\n");
+    const transformEntries = o.fields.map((f) => {
+      const pascalKey = camelToPascal(f.name);
+      const val = f.optional ? `data.${pascalKey} ?? undefined` : `data.${pascalKey}`;
+      return `    ${quoteKey(f.name)}: ${val},`;
+    }).join("\n");
+    return `${wrapper}({
+${joined}
+}).transform(data => ({
+${transformEntries}
+}))`;
+  }
+  const fields = o.fields.flatMap((f) => renderField(f, defaultMode)).map((l) => `    ${l}`).join("\n");
+  return `${wrapper}({
+${fields}
+})`;
+}
+__name(renderInlineObject, "renderInlineObject");
+function renderInputScalar(s) {
+  return renderScalar(s);
+}
+__name(renderInputScalar, "renderInputScalar");
+function renderInputType(type, modelsWithInput, defaultMode) {
+  switch (type.kind) {
+    case "scalar":
+      return renderInputScalar(type);
+    case "ref":
+      return modelsWithInput?.has(type.name) ? `${type.name}Input` : type.name;
+    case "array": {
+      let e = `z.array(${renderInputType(type.item, modelsWithInput, defaultMode)})`;
+      if (type.min !== void 0) e += `.min(${type.min})`;
+      if (type.max !== void 0) e += `.max(${type.max})`;
+      return e;
+    }
+    case "tuple":
+      return `z.tuple([${type.items.map((i) => renderInputType(i, modelsWithInput, defaultMode)).join(", ")}])`;
+    case "record":
+      return `z.record(${renderInputType(type.key, modelsWithInput, defaultMode)}, ${renderInputType(type.value, modelsWithInput, defaultMode)})`;
+    case "union":
+      return `z.union([${type.members.map((m) => renderInputType(m, modelsWithInput, defaultMode)).join(", ")}])`;
+    case "discriminatedUnion":
+      return `z.discriminatedUnion("${escapeString(type.discriminator)}", [${type.members.map((m) => renderInputType(m, modelsWithInput, defaultMode)).join(", ")}])`;
+    case "intersection": {
+      const [first, ...rest] = type.members;
+      if (first && first.kind === "ref" && rest.length > 0 && rest.every((m) => m.kind === "inlineObject")) {
+        const base = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
+        const allFields = rest.flatMap((m) => m.fields);
+        const fieldLines = allFields.map((f) => `    ${renderInputField(f, modelsWithInput ?? /* @__PURE__ */ new Set(), defaultMode)}`).join("\n");
+        return `${base}.extend({
+${fieldLines}
+})`;
+      }
+      let expr = renderInputType(first, modelsWithInput, defaultMode);
+      for (const member of rest) {
+        expr += `.and(${renderInputType(member, modelsWithInput, defaultMode)})`;
+      }
+      return expr;
+    }
+    case "lazy":
+      return `z.lazy(() => ${renderInputType(type.inner, modelsWithInput, defaultMode)})`;
+    case "inlineObject": {
+      const fields = type.fields.flatMap((f) => renderInputField(f, modelsWithInput ?? /* @__PURE__ */ new Set(), defaultMode)).map((l) => `    ${l}`).join("\n");
+      return `${modeToWrapper(type.mode ?? defaultMode ?? "strict")}({
+${fields}
+})`;
+    }
+    default:
+      return renderType(type, void 0, defaultMode);
+  }
+}
+__name(renderInputType, "renderInputType");
+function renderInputField(field, modelsWithInput, defaultMode) {
+  const lines = [];
+  if (field.deprecated) lines.push("/** @deprecated */");
+  let expr = renderInputType(field.type, modelsWithInput, defaultMode);
+  if (field.nullable) expr += ".nullable()";
+  if (field.default !== void 0) {
+    const dv = typeof field.default === "string" ? `"${escapeString(field.default)}"` : String(field.default);
+    expr += `.default(${dv})`;
+  } else if (field.optional) {
+    expr += ".optional()";
+  }
+  if (field.description) expr += `.describe("${escapeString(field.description)}")`;
+  lines.push(`${quoteKey(field.name)}: ${expr},`);
+  return lines;
+}
+__name(renderInputField, "renderInputField");
+function renderInputFields(fields, modelsWithInput, defaultMode) {
+  return fields.flatMap((f) => renderInputField(f, modelsWithInput, defaultMode));
+}
+__name(renderInputFields, "renderInputFields");
+function renderQueryType(type, modelsWithInput, defaultMode) {
+  switch (type.kind) {
+    case "array": {
+      const inner = modelsWithInput ? renderInputType(type, modelsWithInput, defaultMode) : renderType(type, void 0, defaultMode);
+      return `z.preprocess((v) => typeof v === 'string' ? v.split(',') : v, ${inner})`;
+    }
+    case "inlineObject": {
+      const fields = type.fields.map((f) => `    ${renderQueryField(f, modelsWithInput, defaultMode)}`).join("\n");
+      return `${modeToWrapper(type.mode ?? defaultMode ?? "strict")}({
+${fields}
+})`;
+    }
+    case "intersection": {
+      const [first, ...rest] = type.members;
+      if (first && first.kind === "ref" && rest.length > 0 && rest.every((m) => m.kind === "inlineObject")) {
+        const base = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
+        const allFields = rest.flatMap((m) => m.fields);
+        const fieldLines = allFields.map((f) => `    ${renderQueryField(f, modelsWithInput, defaultMode)}`).join("\n");
+        return `${base}.extend({
+${fieldLines}
+})`;
+      }
+      let expr = renderQueryType(first, modelsWithInput, defaultMode);
+      for (const member of rest) {
+        expr += `.and(${renderQueryType(member, modelsWithInput, defaultMode)})`;
+      }
+      return expr;
+    }
+    case "ref":
+      return modelsWithInput?.has(type.name) ? `${type.name}Input` : type.name;
+    default:
+      return modelsWithInput ? renderInputType(type, modelsWithInput, defaultMode) : renderType(type, void 0, defaultMode);
+  }
+}
+__name(renderQueryType, "renderQueryType");
+function renderQueryField(field, modelsWithInput, defaultMode) {
+  let expr = field.type.kind === "array" ? renderQueryType(field.type, modelsWithInput, defaultMode) : modelsWithInput ? renderInputType(field.type, modelsWithInput, defaultMode) : renderType(field.type, void 0, defaultMode);
+  if (field.nullable) expr += ".nullable()";
+  if (field.default !== void 0) {
+    const dv = typeof field.default === "string" ? `"${escapeString(field.default)}"` : String(field.default);
+    expr += `.default(${dv})`;
+  } else if (field.optional) {
+    expr += ".optional()";
+  }
+  if (field.description) expr += `.describe("${escapeString(field.description)}")`;
+  return `${quoteKey(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) {
+  return isValidIdentifier(name) ? name : `'${name}'`;
+}
+__name(quoteKey, "quoteKey");
+function escapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+__name(escapeString, "escapeString");
+function rootNeedsDateTime(root) {
+  return root.models.some((m) => m.type && typeNeedsDateTime(m.type) || m.fields.some((f) => typeNeedsDateTime(f.type)));
+}
+__name(rootNeedsDateTime, "rootNeedsDateTime");
+function typeNeedsScalar(type, name) {
+  switch (type.kind) {
+    case "scalar":
+      return type.name === name;
+    case "array":
+      return typeNeedsScalar(type.item, name);
+    case "tuple":
+      return type.items.some((i) => typeNeedsScalar(i, name));
+    case "record":
+      return typeNeedsScalar(type.key, name) || typeNeedsScalar(type.value, name);
+    case "union":
+      return type.members.some((m) => typeNeedsScalar(m, name));
+    case "discriminatedUnion":
+      return type.members.some((m) => typeNeedsScalar(m, name));
+    case "intersection":
+      return type.members.some((m) => typeNeedsScalar(m, name));
+    case "lazy":
+      return typeNeedsScalar(type.inner, name);
+    case "inlineObject":
+      return type.fields.some((f) => typeNeedsScalar(f.type, name));
+    default:
+      return false;
+  }
+}
+__name(typeNeedsScalar, "typeNeedsScalar");
+function rootNeedsScalar(root, name) {
+  return root.models.some((m) => m.type && typeNeedsScalar(m.type, name) || m.fields.some((f) => typeNeedsScalar(f.type, name)));
+}
+__name(rootNeedsScalar, "rootNeedsScalar");
+function typeNeedsDateTime(type) {
+  switch (type.kind) {
+    case "scalar":
+      return type.name === "date" || type.name === "time" || type.name === "datetime";
+    case "array":
+      return typeNeedsDateTime(type.item);
+    case "union":
+      return type.members.some(typeNeedsDateTime);
+    case "discriminatedUnion":
+      return type.members.some(typeNeedsDateTime);
+    case "intersection":
+      return type.members.some(typeNeedsDateTime);
+    case "inlineObject":
+      return type.fields.some((f) => typeNeedsDateTime(f.type));
+    default:
+      return false;
+  }
+}
+__name(typeNeedsDateTime, "typeNeedsDateTime");
+function collectExternalRefs(root) {
+  const localNames = new Set(root.models.map((m) => m.name));
+  const refs = /* @__PURE__ */ new Set();
+  for (const model of root.models) {
+    if (model.bases?.[0] && !localNames.has(model.bases?.[0])) refs.add(model.bases?.[0]);
+    if (model.type) collectTypeRefs(model.type, refs);
+    for (const field of model.fields) {
+      collectTypeRefs(field.type, refs);
+    }
+  }
+  for (const name of localNames) refs.delete(name);
+  return [
+    ...refs
+  ].sort();
+}
+__name(collectExternalRefs, "collectExternalRefs");
+function collectExternalInputRefs(root, modelsWithInput) {
+  const localNames = new Set(root.models.map((m) => m.name));
+  const refs = /* @__PURE__ */ new Set();
+  for (const model of root.models) {
+    if (!modelsWithInput.has(model.name)) continue;
+    if (model.type) {
+      collectInputTypeRefs(model.type, refs, modelsWithInput);
+      continue;
+    }
+    if (model.bases?.[0] && modelsWithInput.has(model.bases?.[0]) && !localNames.has(model.bases?.[0])) {
+      refs.add(`${model.bases?.[0]}Input`);
+    }
+    const writeFields = model.fields.filter((f) => f.visibility !== "readonly");
+    for (const field of writeFields) {
+      collectInputTypeRefs(field.type, refs, modelsWithInput);
+    }
+  }
+  for (const name of localNames) {
+    refs.delete(`${name}Input`);
+  }
+  return [
+    ...refs
+  ].sort();
+}
+__name(collectExternalInputRefs, "collectExternalInputRefs");
+function collectInputTypeRefs(type, out, modelsWithInput) {
+  switch (type.kind) {
+    case "ref":
+      if (modelsWithInput.has(type.name)) out.add(`${type.name}Input`);
+      break;
+    case "array":
+      collectInputTypeRefs(type.item, out, modelsWithInput);
+      break;
+    case "tuple":
+      type.items.forEach((i) => collectInputTypeRefs(i, out, modelsWithInput));
+      break;
+    case "record":
+      collectInputTypeRefs(type.key, out, modelsWithInput);
+      collectInputTypeRefs(type.value, out, modelsWithInput);
+      break;
+    case "union":
+      type.members.forEach((m) => collectInputTypeRefs(m, out, modelsWithInput));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((m) => collectInputTypeRefs(m, out, modelsWithInput));
+      break;
+    case "intersection":
+      type.members.forEach((m) => collectInputTypeRefs(m, out, modelsWithInput));
+      break;
+    case "lazy":
+      collectInputTypeRefs(type.inner, out, modelsWithInput);
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectInputTypeRefs(f.type, out, modelsWithInput));
+      break;
+  }
+}
+__name(collectInputTypeRefs, "collectInputTypeRefs");
+function topoSortModels(models) {
+  const localNames = new Set(models.map((m) => m.name));
+  const modelMap = new Map(models.map((m) => [
+    m.name,
+    m
+  ]));
+  const deps = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const refs = /* @__PURE__ */ new Set();
+    if (model.bases?.[0] && localNames.has(model.bases?.[0])) refs.add(model.bases?.[0]);
+    if (model.type) collectTypeRefs(model.type, refs);
+    for (const field of model.fields) {
+      collectTypeRefs(field.type, refs);
+    }
+    const localDeps = /* @__PURE__ */ new Set();
+    for (const r of refs) {
+      if (localNames.has(r) && r !== model.name) localDeps.add(r);
+    }
+    deps.set(model.name, localDeps);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const name of localNames) inDegree.set(name, 0);
+  for (const [, d] of deps) {
+    for (const dep of d) {
+      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+    }
+  }
+  const remaining = /* @__PURE__ */ new Map();
+  for (const [name, d] of deps) {
+    remaining.set(name, new Set(d));
+  }
+  const queue = [];
+  for (const name of localNames) {
+    if (remaining.get(name).size === 0) queue.push(name);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    sorted.push(modelMap.get(name));
+    for (const [other, rem] of remaining) {
+      if (rem.delete(name) && rem.size === 0) {
+        queue.push(other);
+      }
+    }
+  }
+  for (const model of models) {
+    if (!sorted.includes(model)) sorted.push(model);
+  }
+  return sorted;
+}
+__name(topoSortModels, "topoSortModels");
+function resolveImportPath(refName, context) {
+  if (context) {
+    const refOutPath = context.modelOutPaths.get(refName);
+    if (refOutPath) {
+      const fromDir = dirname(context.currentOutPath);
+      let rel = relative(fromDir, refOutPath);
+      rel = rel.replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      return rel;
+    }
+  }
+  const moduleName = pascalToDotCase(refName);
+  return `./${moduleName}.js`;
+}
+__name(resolveImportPath, "resolveImportPath");
+function pascalToDotCase(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1.$2").toLowerCase();
+}
+__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)) {
+    case "urlencoded":
+      return "urlencoded";
+    case "multipart":
+      return "multipart";
+    case "text":
+      return "text";
+    case "binary":
+      return "text";
+    default:
+      return "json";
+  }
+}
+__name(bodyParserToken, "bodyParserToken");
+function bodyTypesStructurallyEqual(a, b) {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "scalar": {
+      const bb = b;
+      return a.name === bb.name && a.min === bb.min && a.max === bb.max && a.len === bb.len && a.regex === bb.regex && a.format === bb.format;
+    }
+    case "array": {
+      const bb = b;
+      return a.min === bb.min && a.max === bb.max && bodyTypesStructurallyEqual(a.item, bb.item);
+    }
+    case "tuple": {
+      const bb = b;
+      return a.items.length === bb.items.length && a.items.every((x, i) => bodyTypesStructurallyEqual(x, bb.items[i]));
+    }
+    case "record": {
+      const bb = b;
+      return bodyTypesStructurallyEqual(a.key, bb.key) && bodyTypesStructurallyEqual(a.value, bb.value);
+    }
+    case "enum": {
+      const bb = b;
+      return a.values.length === bb.values.length && a.values.every((v, i) => v === bb.values[i]);
+    }
+    case "literal": {
+      const bb = b;
+      return a.value === bb.value;
+    }
+    case "union":
+    case "intersection": {
+      const bb = b;
+      return a.members.length === bb.members.length && a.members.every((m, i) => bodyTypesStructurallyEqual(m, bb.members[i]));
+    }
+    case "discriminatedUnion": {
+      const bb = b;
+      return a.discriminator === bb.discriminator && a.members.length === bb.members.length && a.members.every((m, i) => bodyTypesStructurallyEqual(m, bb.members[i]));
+    }
+    case "ref": {
+      const bb = b;
+      return a.name === bb.name && !!a.lazy === !!bb.lazy;
+    }
+    case "lazy": {
+      const bb = b;
+      return bodyTypesStructurallyEqual(a.inner, bb.inner);
+    }
+    case "inlineObject": {
+      const bb = b;
+      if (a.mode !== bb.mode) return false;
+      if (a.fields.length !== bb.fields.length) return false;
+      return a.fields.every((f, i) => {
+        const g = bb.fields[i];
+        return f.name === g.name && f.optional === g.optional && f.nullable === g.nullable && f.visibility === g.visibility && f.default === g.default && !!f.deprecated === !!g.deprecated && bodyTypesStructurallyEqual(f.type, g.type);
+      });
+    }
+  }
+}
+__name(bodyTypesStructurallyEqual, "bodyTypesStructurallyEqual");
+function generateOp(root, options = {}) {
+  const types = collectTypes(root, options.modelsWithInput, options.modelsWithOutput);
+  const services = collectServices(root);
+  const routerName = deriveRouterName(root.file);
+  const needsParseAndValidate = routeNeedsValidation(root);
+  const body = [];
+  const needsSignature = fileNeedsSignature(root);
+  const needsSecurity = fileNeedsSecurity(root);
+  const koaImports = [
+    "ServerKitRouter",
+    "bodyParserMiddleware"
+  ];
+  if (needsSecurity) koaImports.push("requireSecurity");
+  if (needsSignature) koaImports.push("requireSignature");
+  body.push(`import { ${koaImports.join(", ")} } from '@maroonedsoftware/koa';`);
+  for (const svc of services) {
+    const modulePath = root.services?.[svc] ?? root.meta[svc] ?? deriveModulePath(svc, options.servicePathTemplate);
+    body.push(`import { ${svc} } from '${modulePath}';`);
+  }
+  if (types.length > 0) {
+    body.push(...generateTypeImports(types, root.file, options));
+  }
+  if (opNeedsDateTime(root)) {
+    body.push(`import { DateTime } from 'luxon';`);
+  }
+  if (needsParseAndValidate) {
+    body.push(`import { parseAndValidate } from '@maroonedsoftware/zod';`);
+  }
+  const helpers = [];
+  if (opNeedsScalar(root, "binary")) {
+    helpers.push(`const _ZodBinary = z.custom<Buffer>((val) => Buffer.isBuffer(val), { error: 'Must be binary data' });`);
+  }
+  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, "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)]));`);
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("/**");
+  const relFile = options.outPath ? relative2(dirname2(options.outPath), root.file) : root.file;
+  lines.push(` * generated from [${basename(root.file)}](file://./${relFile})`);
+  lines.push("*/");
+  lines.push(`export const ${routerName} = ServerKitRouter();`);
+  lines.push("");
+  const includeInternal = options.includeInternal ?? true;
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+      lines.push(...generateHandler(route, op, root, options));
+      lines.push("");
+    }
+  }
+  const allContent = [
+    ...body,
+    ...helpers.length ? [
+      "",
+      ...helpers
+    ] : [],
+    ...lines
+  ].join("\n");
+  const needsZod = /\bz\./.test(allContent);
+  return (needsZod ? `import { z } from 'zod';
+` : "") + allContent;
+}
+__name(generateOp, "generateOp");
+function generateHandler(route, op, root, options) {
+  const lines = [];
+  const file = root.file;
+  const outPath = options.outPath;
+  const modelsWithInput = options.modelsWithInput;
+  lines.push("/**");
+  const desc = op.description ?? route.description;
+  if (desc) {
+    lines.push(` * ${desc}`);
+  }
+  const relFile = outPath ? relative2(dirname2(outPath), file) : file;
+  lines.push(` * from [${basename(file)}](file://./${relFile}#L${op.loc.line})`);
+  const effectiveSecurity = resolveSecurity(route, op, root);
+  if (effectiveSecurity === SECURITY_NONE) {
+    lines.push(` * anonymous access, no security required`);
+  }
+  const mods = resolveModifiers(route, op);
+  if (mods.includes("internal")) lines.push(` * @internal`);
+  if (mods.includes("deprecated")) lines.push(` * @deprecated`);
+  lines.push("*/");
+  const method = op.method;
+  const path = route.path.replace(/\{(\w+)\}/g, ":$1");
+  const bodies = op.request?.bodies ?? [];
+  const hasBody = bodies.length > 0;
+  const isSingleMultipart = bodies.length === 1 && bodies[0].contentType === "multipart/form-data";
+  const middlewares = [];
+  if (effectiveSecurity !== SECURITY_NONE) {
+    const roles = effectiveSecurity && effectiveSecurity.roles?.length ? `roles: [${effectiveSecurity.roles.map((r) => `'${r}'`).join(", ")}]` : "";
+    middlewares.push(`requireSecurity({ ${roles} })`);
+  }
+  if (hasBody) {
+    const parserTokens = Array.from(new Set(bodies.map((b) => bodyParserToken(b.contentType))));
+    const tokensExpr = parserTokens.map((t) => `'${t}'`).join(", ");
+    middlewares.push(`bodyParserMiddleware([${tokensExpr}])`);
+  }
+  if (op.signature) {
+    middlewares.push(`requireSignature('${op.signature}')`);
+  }
+  const middlewareStr = middlewares.length > 0 ? `, ${middlewares.join(", ")},` : ",";
+  lines.push(`${deriveRouterName(file)}.${method}('${path}'${middlewareStr} async (ctx, next) => {`);
+  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));
+  if (hasBody && op.request) {
+    if (isSingleMultipart) {
+      lines.push(`    const multipartBody = ctx.body as MultipartBody;`);
+      lines.push("");
+    } else if (bodies.length === 1) {
+      lines.push(`    const body = await parseAndValidate(ctx.body, ${renderInputType(bodies[0].bodyType, modelsWithInput)});`);
+      lines.push("");
+    } else if (bodies.every((b) => bodyTypesStructurallyEqual(b.bodyType, bodies[0].bodyType))) {
+      lines.push(`    const body = await parseAndValidate(ctx.body, ${renderInputType(bodies[0].bodyType, modelsWithInput)});`);
+      lines.push("");
+    } else {
+      const annotation = bodies.map((b) => b.contentType === "multipart/form-data" ? "MultipartBody" : `z.infer<typeof ${renderInputType(b.bodyType, modelsWithInput)}>`).join(" | ");
+      lines.push(`    let body!: ${annotation};`);
+      lines.push(`    switch (ctx.request.type) {`);
+      for (const b of bodies) {
+        lines.push(`        case '${b.contentType}':`);
+        if (b.contentType === "multipart/form-data") {
+          lines.push(`            body = ctx.body as MultipartBody;`);
+        } else {
+          lines.push(`            body = await parseAndValidate(ctx.body, ${renderInputType(b.bodyType, modelsWithInput)});`);
+        }
+        lines.push(`            break;`);
+      }
+      lines.push(`    }`);
+      lines.push("");
+    }
+  }
+  const primaryResponse = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+  const serviceParts = inferService(op, route, file);
+  const respHeaders = primaryResponse?.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);
+    if (prelude) {
+      lines.push(`    ${prelude}`);
+    }
+    lines.push(`    const service = ctx.container.get(${serviceParts.className});`);
+    if (hasRespHeaders) {
+      lines.push(`    const result: { body: ${annotation}; headers: ${headersAnnotation} } = await service.${serviceParts.methodName}(${buildArgs(route, op)});`);
+    } else {
+      lines.push(`    const result: ${annotation} = await service.${serviceParts.methodName}(${buildArgs(route, op)});`);
+    }
+  } else {
+    lines.push(`    const service = ctx.container.get(${serviceParts.className});`);
+    if (hasRespHeaders) {
+      lines.push(`    const result: { headers: ${headersAnnotation} } = await service.${serviceParts.methodName}(${buildArgs(route, op)});`);
+    } else {
+      lines.push(`    await service.${serviceParts.methodName}(${buildArgs(route, op)});`);
+    }
+  }
+  lines.push("");
+  lines.push(`    ctx.status = ${primaryResponse?.statusCode ?? 200};`);
+  if (hasRespHeaders) {
+    for (const h of respHeaders) {
+      const accessor = `result.headers[${JSON.stringify(headerNameToProperty(h.name))}]`;
+      if (h.optional) {
+        lines.push(`    if (${accessor} !== undefined) ctx.set('${h.name}', String(${accessor}));`);
+      } else {
+        lines.push(`    ctx.set('${h.name}', String(${accessor}));`);
+      }
+    }
+  }
+  if (primaryResponse?.bodyType && primaryResponse.contentType) {
+    lines.push(`    ctx.type = '${primaryResponse.contentType}';`);
+    lines.push(`    ctx.body = ${hasRespHeaders ? "result.body" : "result"};`);
+  }
+  lines.push("");
+  lines.push(`    await next();`);
+  lines.push(`});`);
+  return lines;
+}
+__name(generateHandler, "generateHandler");
+function inferService(op, route, file) {
+  if (op.service) {
+    const [cls = "", method] = op.service.split(".");
+    return {
+      className: cls,
+      methodName: method ?? "handle"
+    };
+  }
+  const baseName = deriveBaseName(file);
+  const className = `${baseName}Service`;
+  const methodName = inferMethodName(op.method, route.path);
+  return {
+    className,
+    methodName
+  };
+}
+__name(inferService, "inferService");
+function inferMethodName(method, path) {
+  const hasParam = path.includes("{");
+  switch (method) {
+    case "get":
+      return hasParam ? "getById" : "list";
+    case "post":
+      return "create";
+    case "put":
+      return "replace";
+    case "patch":
+      return "update";
+    case "delete":
+      return "delete";
+    default:
+      return "handle";
+  }
+}
+__name(inferMethodName, "inferMethodName");
+function buildArgs(route, op) {
+  const args = [];
+  if (route.params) {
+    if (route.params.kind === "params") {
+      args.push(...route.params.nodes.map((p) => p.name));
+    } else {
+      args.push("params");
+    }
+  }
+  if (op.request && op.request.bodies.length > 0) {
+    const bodies = op.request.bodies;
+    const isSingleMultipart = bodies.length === 1 && bodies[0].contentType === "multipart/form-data";
+    args.push(isSingleMultipart ? "multipartBody" : "body");
+  }
+  if (op.query) args.push("query");
+  if (op.headers) args.push("headers");
+  return args.join(", ");
+}
+__name(buildArgs, "buildArgs");
+function formatTypeAnnotation(bodyType, modelsWithOutput) {
+  if (bodyType.kind === "array") {
+    const inner = formatTypeAnnotation(bodyType.item, modelsWithOutput);
+    return {
+      annotation: `${inner.annotation}[]`,
+      prelude: inner.prelude
+    };
+  }
+  if (bodyType.kind === "ref") {
+    const name = modelsWithOutput?.has(bodyType.name) ? `${bodyType.name}Output` : bodyType.name;
+    return {
+      annotation: name
+    };
+  }
+  if (bodyType.kind === "scalar") return {
+    annotation: bodyType.name
+  };
+  const schema = renderType(bodyType);
+  return {
+    annotation: "z.infer<typeof resultType>",
+    prelude: `const resultType = ${schema};`
+  };
+}
+__name(formatTypeAnnotation, "formatTypeAnnotation");
+function generateParamValidation(source, ctxExpr, varName, mode, suffix = "", modelsWithInput) {
+  if (!source) return [];
+  const lines = [];
+  const isQuery = ctxExpr === "ctx.query";
+  if (source.kind === "ref") {
+    const typeName = modelsWithInput?.has(source.name) ? `${source.name}Input` : source.name;
+    lines.push(`    const ${varName} = await parseAndValidate(${ctxExpr}, ${typeName}.${mode}());`);
+    lines.push("");
+  } else if (source.kind === "params") {
+    if (source.nodes.length > 0) {
+      const lhs = varName === "params" ? `{ ${source.nodes.map((p) => p.name).join(", ")} }` : varName;
+      lines.push(`    const ${lhs} = await parseAndValidate(`);
+      lines.push(`        ${ctxExpr},`);
+      lines.push(`        ${modeToWrapper(mode)}({`);
+      for (const param of source.nodes) {
+        const key = isValidIdentifier2(param.name) ? param.name : `'${param.name}'`;
+        if (isQuery && param.type.kind === "array") {
+          const inner = renderType(param.type);
+          lines.push(`            ${key}: z.preprocess((v) => typeof v === 'string' ? v.split(',') : v, ${inner}),`);
+        } else {
+          lines.push(`            ${key}: ${renderType(param.type)},`);
+        }
+      }
+      lines.push(`        })${suffix},`);
+      lines.push(`    );`);
+      lines.push("");
+    }
+  } else {
+    const schema = isQuery ? renderQueryType(source.node, modelsWithInput) : renderInputType(source.node, modelsWithInput);
+    lines.push(`    const ${varName} = await parseAndValidate(${ctxExpr}, (${schema}).${mode}());`);
+    lines.push("");
+  }
+  return lines;
+}
+__name(generateParamValidation, "generateParamValidation");
+function generateTypeImports(types, opFile, options) {
+  const lines = [];
+  const { modelOutPaths, outPath } = options;
+  if (modelOutPaths && outPath) {
+    const byFile = /* @__PURE__ */ new Map();
+    const unresolved = [];
+    for (const type of types) {
+      const typeOutPath = modelOutPaths.get(type);
+      if (typeOutPath) {
+        const group = byFile.get(typeOutPath) ?? [];
+        group.push(type);
+        byFile.set(typeOutPath, group);
+      } else {
+        unresolved.push(type);
+      }
+    }
+    const fromDir = dirname2(outPath);
+    for (const [typeOutPath, names] of byFile) {
+      let rel = relative2(fromDir, typeOutPath);
+      rel = rel.replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      lines.push(`import { ${names.sort().join(", ")} } from '${rel}';`);
+    }
+    for (const type of unresolved) {
+      const moduleName = pascalToDotCase(type);
+      lines.push(`import { ${type} } from './${moduleName}.js';`);
+    }
+  } else {
+    const typeImport = deriveTypeImportPath(opFile, options.typeImportPathTemplate);
+    lines.push(`import { ${types.join(", ")} } from '${typeImport}';`);
+  }
+  return lines;
+}
+__name(generateTypeImports, "generateTypeImports");
+function collectTypes(root, modelsWithInput, modelsWithOutput) {
+  const types = /* @__PURE__ */ new Set();
+  for (const route of root.routes) {
+    collectParamSourceRefs(route.params, types);
+    collectParamSourceInputRefs(route.params, types, modelsWithInput);
+    for (const op of route.operations) {
+      if (op.request) {
+        for (const body of op.request.bodies) {
+          collectTypeNodeRefs(body.bodyType, types);
+          collectInputTypeNodeRefs(body.bodyType, types, modelsWithInput);
+        }
+      }
+      for (const resp of op.responses) {
+        if (resp.bodyType) {
+          collectTypeNodeRefs(resp.bodyType, types);
+          collectOutputTypeNodeRefs(resp.bodyType, types, modelsWithOutput);
+        }
+        if (resp.headers) {
+          for (const h of resp.headers) {
+            collectTypeNodeRefs(h.type, types);
+            collectOutputTypeNodeRefs(h.type, types, modelsWithOutput);
+          }
+        }
+      }
+      collectParamSourceRefs(op.query, types);
+      collectParamSourceInputRefs(op.query, types, modelsWithInput);
+      collectParamSourceRefs(op.headers, types);
+      collectParamSourceInputRefs(op.headers, types, modelsWithInput);
+    }
+  }
+  return [
+    ...types
+  ].sort();
+}
+__name(collectTypes, "collectTypes");
+function collectOutputTypeNodeRefs(type, out, modelsWithOutput) {
+  if (!modelsWithOutput) return;
+  switch (type.kind) {
+    case "ref":
+      if (modelsWithOutput.has(type.name)) out.add(`${type.name}Output`);
+      break;
+    case "array":
+      collectOutputTypeNodeRefs(type.item, out, modelsWithOutput);
+      break;
+    case "tuple":
+      type.items.forEach((t) => collectOutputTypeNodeRefs(t, out, modelsWithOutput));
+      break;
+    case "record":
+      collectOutputTypeNodeRefs(type.key, out, modelsWithOutput);
+      collectOutputTypeNodeRefs(type.value, out, modelsWithOutput);
+      break;
+    case "union":
+      type.members.forEach((t) => collectOutputTypeNodeRefs(t, out, modelsWithOutput));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((t) => collectOutputTypeNodeRefs(t, out, modelsWithOutput));
+      break;
+    case "intersection":
+      type.members.forEach((t) => collectOutputTypeNodeRefs(t, out, modelsWithOutput));
+      break;
+    case "lazy":
+      collectOutputTypeNodeRefs(type.inner, out, modelsWithOutput);
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectOutputTypeNodeRefs(f.type, out, modelsWithOutput));
+      break;
+  }
+}
+__name(collectOutputTypeNodeRefs, "collectOutputTypeNodeRefs");
+function collectParamSourceRefs(source, out) {
+  if (!source) return;
+  if (source.kind === "ref") {
+    if (/^[A-Z]/.test(source.name)) out.add(source.name);
+  } else if (source.kind === "params") {
+    for (const param of source.nodes) {
+      collectTypeNodeRefs(param.type, out);
+    }
+  } else {
+    collectTypeNodeRefs(source.node, out);
+  }
+}
+__name(collectParamSourceRefs, "collectParamSourceRefs");
+function collectParamSourceInputRefs(source, out, modelsWithInput) {
+  if (!source || !modelsWithInput) return;
+  if (source.kind === "ref") {
+    if (modelsWithInput.has(source.name)) out.add(`${source.name}Input`);
+  } else if (source.kind === "type") {
+    collectInputTypeNodeRefs(source.node, out, modelsWithInput);
+  }
+}
+__name(collectParamSourceInputRefs, "collectParamSourceInputRefs");
+function collectInputTypeNodeRefs(type, out, modelsWithInput) {
+  if (!modelsWithInput) return;
+  switch (type.kind) {
+    case "ref":
+      if (modelsWithInput.has(type.name)) out.add(`${type.name}Input`);
+      break;
+    case "array":
+      collectInputTypeNodeRefs(type.item, out, modelsWithInput);
+      break;
+    case "tuple":
+      type.items.forEach((t) => collectInputTypeNodeRefs(t, out, modelsWithInput));
+      break;
+    case "record":
+      collectInputTypeNodeRefs(type.key, out, modelsWithInput);
+      collectInputTypeNodeRefs(type.value, out, modelsWithInput);
+      break;
+    case "union":
+      type.members.forEach((t) => collectInputTypeNodeRefs(t, out, modelsWithInput));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((t) => collectInputTypeNodeRefs(t, out, modelsWithInput));
+      break;
+    case "intersection":
+      type.members.forEach((t) => collectInputTypeNodeRefs(t, out, modelsWithInput));
+      break;
+    case "lazy":
+      collectInputTypeNodeRefs(type.inner, out, modelsWithInput);
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectInputTypeNodeRefs(f.type, out, modelsWithInput));
+      break;
+  }
+}
+__name(collectInputTypeNodeRefs, "collectInputTypeNodeRefs");
+function collectTypeNodeRefs(type, out) {
+  switch (type.kind) {
+    case "ref":
+      if (/^[A-Z]/.test(type.name)) out.add(type.name);
+      break;
+    case "array":
+      collectTypeNodeRefs(type.item, out);
+      break;
+    case "tuple":
+      type.items.forEach((t) => collectTypeNodeRefs(t, out));
+      break;
+    case "record":
+      collectTypeNodeRefs(type.key, out);
+      collectTypeNodeRefs(type.value, out);
+      break;
+    case "union":
+      type.members.forEach((t) => collectTypeNodeRefs(t, out));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((t) => collectTypeNodeRefs(t, out));
+      break;
+    case "intersection":
+      type.members.forEach((t) => collectTypeNodeRefs(t, out));
+      break;
+    case "lazy":
+      collectTypeNodeRefs(type.inner, out);
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectTypeNodeRefs(f.type, out));
+      break;
+  }
+}
+__name(collectTypeNodeRefs, "collectTypeNodeRefs");
+function paramSourceNeedsDateTime(source) {
+  if (!source) return false;
+  if (source.kind === "ref") return false;
+  if (source.kind === "params") return source.nodes.some((p) => typeNeedsDateTime(p.type));
+  return typeNeedsDateTime(source.node);
+}
+__name(paramSourceNeedsDateTime, "paramSourceNeedsDateTime");
+function opNeedsDateTime(root) {
+  return root.routes.some((route) => paramSourceNeedsDateTime(route.params) || route.operations.some((op) => !!op.request?.bodies.some((b) => typeNeedsDateTime(b.bodyType)) || op.responses.some((r) => r.bodyType && typeNeedsDateTime(r.bodyType)) || paramSourceNeedsDateTime(op.query) || paramSourceNeedsDateTime(op.headers)));
+}
+__name(opNeedsDateTime, "opNeedsDateTime");
+function paramSourceNeedsScalar(source, name) {
+  if (!source) return false;
+  if (source.kind === "ref") return false;
+  if (source.kind === "params") return source.nodes.some((p) => typeNeedsScalar(p.type, name));
+  return typeNeedsScalar(source.node, name);
+}
+__name(paramSourceNeedsScalar, "paramSourceNeedsScalar");
+function opNeedsScalar(root, name) {
+  return root.routes.some((route) => paramSourceNeedsScalar(route.params, name) || route.operations.some((op) => !!op.request?.bodies.some((b) => typeNeedsScalar(b.bodyType, name)) || op.responses.some((r) => r.bodyType && typeNeedsScalar(r.bodyType, name)) || paramSourceNeedsScalar(op.query, name) || paramSourceNeedsScalar(op.headers, name)));
+}
+__name(opNeedsScalar, "opNeedsScalar");
+function collectServices(root) {
+  const services = /* @__PURE__ */ new Set();
+  const inferredService = `${deriveBaseName(root.file)}Service`;
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (op.service) {
+        services.add(op.service.split(".")[0] ?? op.service);
+      } else {
+        services.add(inferredService);
+      }
+    }
+  }
+  return [
+    ...services
+  ].sort();
+}
+__name(collectServices, "collectServices");
+function hasParamSource(source) {
+  if (!source) return false;
+  if (source.kind === "ref") return true;
+  if (source.kind === "params") return source.nodes.length > 0;
+  return true;
+}
+__name(hasParamSource, "hasParamSource");
+function routeNeedsValidation(root) {
+  return root.routes.some((r) => hasParamSource(r.params) || r.operations.some((op) => !!op.request || hasParamSource(op.query) || hasParamSource(op.headers)));
+}
+__name(routeNeedsValidation, "routeNeedsValidation");
+function fileNeedsSecurity(root) {
+  return root.routes.some((route) => route.operations.some((op) => resolveSecurity(route, op, root) !== SECURITY_NONE));
+}
+__name(fileNeedsSecurity, "fileNeedsSecurity");
+function fileNeedsSignature(root) {
+  return root.routes.some((route) => route.operations.some((op) => !!op.signature));
+}
+__name(fileNeedsSignature, "fileNeedsSignature");
+function isValidIdentifier2(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+__name(isValidIdentifier2, "isValidIdentifier");
+function deriveBaseName(file) {
+  const base = file.split("/").pop()?.replace(/\.(op|ck)$/, "") ?? "Resource";
+  return base.split(".").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+__name(deriveBaseName, "deriveBaseName");
+function deriveRouterName(file) {
+  return `${deriveBaseName(file)}Router`;
+}
+__name(deriveRouterName, "deriveRouterName");
+function deriveModulePath(serviceName, template) {
+  const base = serviceName.replace(/Service$/, "");
+  const kebab = base.replace(/([A-Z])/g, (m) => `-${m.toLowerCase()}`).replace(/^-/, "");
+  if (template) {
+    return template.replace(/\{name\}/g, base).replace(/\{kebab\}/g, kebab);
+  }
+  return `#modules/${kebab}/${kebab}.service.js`;
+}
+__name(deriveModulePath, "deriveModulePath");
+function deriveTypeImportPath(file, template) {
+  const base = file.split("/").pop()?.replace(/\.(op|ck)$/, "") ?? "resource";
+  const module = base.split(".")[0] ?? base;
+  if (template) {
+    return template.replace(/\{module\}/g, module).replace(/\{base\}/g, base);
+  }
+  return `#modules/${module}/types/index.js`;
+}
+__name(deriveTypeImportPath, "deriveTypeImportPath");
+
+// src/codegen-sdk.ts
+import { resolveModifiers as resolveModifiers2, isJsonMime, classifyContentType as classifyContentType2 } from "@contractkit/core";
+import { basename as basename2, dirname as dirname3, relative as relative3 } from "path";
+function jsonOrFormSerialize(varName, contentType) {
+  if (contentType === "application/x-www-form-urlencoded") {
+    return `new URLSearchParams(${varName} as unknown as Record<string, string>).toString()`;
+  }
+  if (contentType === "multipart/form-data") {
+    return `(${varName} as FormData)`;
+  }
+  return `JSON.stringify(${varName}, bigIntReplacer)`;
+}
+__name(jsonOrFormSerialize, "jsonOrFormSerialize");
+function renderSerializeExpr(varName, bodies, ctVar) {
+  const arms = bodies.slice(0, -1);
+  const last = bodies[bodies.length - 1];
+  let expr = jsonOrFormSerialize(varName, last.contentType);
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i];
+    expr = `${ctVar} === '${arm.contentType}' ? ${jsonOrFormSerialize(varName, arm.contentType)} : ${expr}`;
+  }
+  return expr;
+}
+__name(renderSerializeExpr, "renderSerializeExpr");
+function classifyBodyStrategy(op) {
+  const bodies = op.request?.bodies ?? [];
+  if (bodies.length === 0) return {
+    kind: "none"
+  };
+  if (bodies.length === 1) return {
+    kind: "single",
+    body: bodies[0]
+  };
+  if (bodies.every((b) => bodyTypesStructurallyEqual(b.bodyType, bodies[0].bodyType))) {
+    return {
+      kind: "multi-equal",
+      bodies
+    };
+  }
+  if (bodies.some((b) => b.contentType === "multipart/form-data")) {
+    return {
+      kind: "multi-formdata-detect",
+      bodies
+    };
+  }
+  return {
+    kind: "multi-required-arg",
+    bodies
+  };
+}
+__name(classifyBodyStrategy, "classifyBodyStrategy");
+function hasPublicOperations(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (includeInternal || !resolveModifiers2(route, op).includes("internal")) return true;
+    }
+  }
+  return false;
+}
+__name(hasPublicOperations, "hasPublicOperations");
+function generateSdk(root, options = {}) {
+  const lines = [];
+  const includeInternal = options.includeInternal ?? false;
+  const types = collectTypes2(root, options.modelsWithInput, options.modelsWithOutput, includeInternal);
+  const clientClassName = deriveClientClassName(root.file);
+  if (types.length > 0) {
+    lines.push(...generateTypeImports2(types, root.file, options));
+  }
+  if (options.sdkOptionsPath && options.outPath) {
+    let rel = relative3(dirname3(options.outPath), options.sdkOptionsPath);
+    rel = rel.replace(/\.ts$/, ".js");
+    if (!rel.startsWith(".")) rel = "./" + rel;
+    const jsonImport = sdkNeedsJson(root, includeInternal) ? ", JsonValue" : "";
+    lines.push(`import type { SdkFetch${jsonImport} } from '${rel}';`);
+    const valueImports = [];
+    if (sdkNeedsBigIntReplacer(root, includeInternal)) valueImports.push("bigIntReplacer");
+    if (sdkNeedsBigIntReviver(root, includeInternal)) valueImports.push("parseJson");
+    if (sdkNeedsQueryString(root, includeInternal)) valueImports.push("buildQueryString");
+    if (valueImports.length > 0) {
+      lines.push(`import { ${valueImports.join(", ")} } from '${rel}';`);
+    }
+  } else {
+    lines.push("");
+    lines.push("export class SdkError extends Error {");
+    lines.push("    constructor(");
+    lines.push("        public readonly status: number,");
+    lines.push("        public readonly statusText: string,");
+    lines.push("        public readonly body: unknown,");
+    lines.push("    ) {");
+    lines.push("        super(`${status} ${statusText}`);");
+    lines.push("        this.name = 'SdkError';");
+    lines.push("    }");
+    lines.push("}");
+    lines.push("");
+    lines.push("export type SdkFetch = (url: string, init: RequestInit) => Promise<Response>;");
+    lines.push("");
+    lines.push("export interface SdkOptions {");
+    lines.push("    baseUrl: string;");
+    lines.push("    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);");
+    lines.push("    fetch?: SdkFetch;");
+    lines.push("    /** Called once per request to produce a unique X-Request-ID header value */");
+    lines.push("    requestIdFactory?: () => string;");
+    lines.push("}");
+    lines.push("");
+    lines.push("export function createSdkFetch(options: SdkOptions): SdkFetch {");
+    lines.push("    const getRequestId = options.requestIdFactory ?? (() => crypto.randomUUID());");
+    lines.push("    return async (url: string, init: RequestInit): Promise<Response> => {");
+    lines.push("        const baseHeaders = typeof options.headers === 'function'");
+    lines.push("            ? await options.headers()");
+    lines.push("            : options.headers ?? {};");
+    lines.push("        const res = await fetch(`${options.baseUrl}${url}`, {");
+    lines.push("            ...init,");
+    lines.push("            headers: { ...baseHeaders, 'X-Request-ID': getRequestId(), ...init.headers as Record<string, string> },");
+    lines.push("        });");
+    lines.push("        if (!res.ok) {");
+    lines.push("            const text = await res.text();");
+    lines.push("            let body: unknown;");
+    lines.push("            try { body = JSON.parse(text); } catch { body = text; }");
+    lines.push("            throw new SdkError(res.status, res.statusText, body);");
+    lines.push("        }");
+    lines.push("        return res;");
+    lines.push("    };");
+    lines.push("}");
+    lines.push("");
+    lines.push("export function buildQueryString(query: object | undefined): string {");
+    lines.push("    const searchParams = new URLSearchParams();");
+    lines.push("    if (query) {");
+    lines.push("        for (const [k, v] of Object.entries(query)) {");
+    lines.push("            if (v === undefined || v === null) continue;");
+    lines.push("            if (Array.isArray(v)) { for (const item of v) searchParams.append(k, String(item)); }");
+    lines.push("            else searchParams.set(k, String(v));");
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("    const qs = searchParams.toString();");
+    lines.push("    return qs ? `?${qs}` : '';");
+    lines.push("}");
+    lines.push("");
+    lines.push("export async function parseJson<T>(res: Response): Promise<T> {");
+    lines.push("    return JSON.parse(await res.text(), bigIntReviver) as T;");
+    lines.push("}");
+  }
+  if (sdkNeedsJson(root, includeInternal) && !(options.sdkOptionsPath && options.outPath)) {
+    lines.push(JSON_VALUE_TYPE_DECL);
+  }
+  lines.push("");
+  lines.push("/**");
+  const relFile = options.outPath ? relative3(dirname3(options.outPath), root.file) : root.file;
+  lines.push(` * generated from [${basename2(root.file)}](file://./${relFile})`);
+  lines.push(" */");
+  lines.push(`export class ${clientClassName} {`);
+  lines.push("    constructor(private fetch: SdkFetch) {}");
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      const mods = resolveModifiers2(route, op);
+      if (!includeInternal && mods.includes("internal")) continue;
+      lines.push("");
+      if (mods.includes("deprecated")) lines.push("    /** @deprecated */");
+      lines.push(...generateMethod(route, op, root.file, options));
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateSdk, "generateSdk");
+function generateMethod(route, op, file, options) {
+  const lines = [];
+  const methodName = deriveMethodName(op, route);
+  const httpMethod = op.method.toUpperCase();
+  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 hasRespHeaders = respHeaders.length > 0;
+  const headersShape = hasRespHeaders ? `{ ${respHeaders.map((h) => `${quoteKey2(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]} */`);
+    } else {
+      lines.push(`    /**`);
+      for (const tag of tags) lines.push(`     * ${tag}`);
+      lines.push(`     */`);
+    }
+  }
+  lines.push(`    async ${methodName}(${paramStr}): Promise<${returnType}> {`);
+  const urlExpr = buildUrlExpression(route.path, route.params);
+  const hasQuery = !!op.query;
+  let fetchUrl = urlExpr;
+  if (hasQuery) {
+    lines.push(`        const qs = buildQueryString(query);`);
+    fetchUrl = urlExpr;
+  }
+  const strategy = classifyBodyStrategy(op);
+  const hasBody = strategy.kind !== "none";
+  const hasOpHeaders = !!op.headers;
+  if (strategy.kind === "multi-equal") {
+    const defaultCt = strategy.bodies[0].contentType;
+    lines.push(`        const __contentType = options?.contentType ?? '${defaultCt}';`);
+    lines.push(`        const __serialized = ${renderSerializeExpr("body", strategy.bodies, "__contentType")};`);
+  } else if (strategy.kind === "multi-formdata-detect") {
+    lines.push(`        const __isFormData = body instanceof FormData;`);
+    const nonMultipart = strategy.bodies.find((b) => b.contentType !== "multipart/form-data");
+    lines.push(`        const __contentType: string = __isFormData ? 'multipart/form-data' : '${nonMultipart.contentType}';`);
+    lines.push(`        const __serialized: BodyInit = __isFormData ? (body as FormData) : ${jsonOrFormSerialize("body", nonMultipart.contentType)};`);
+  } else if (strategy.kind === "multi-required-arg") {
+    lines.push(`        const __contentType = options.contentType;`);
+    lines.push(`        const __serialized = ${renderSerializeExpr("body", strategy.bodies, "__contentType")};`);
+  }
+  const fetchArgs = [];
+  if (hasQuery) {
+    fetchArgs.push(`url: \`${fetchUrl}\${qs}\``);
+  } else {
+    fetchArgs.push(`url: \`${fetchUrl}\``);
+  }
+  fetchArgs.push(`method: '${httpMethod}'`);
+  if (strategy.kind === "single") {
+    const body = strategy.body;
+    const cat = classifyContentType2(body.contentType);
+    if (cat === "multipart") {
+      fetchArgs.push("body: body");
+    } else if (cat === "urlencoded") {
+      fetchArgs.push(`headers: { 'Content-Type': '${body.contentType}' }`);
+      fetchArgs.push("body: new URLSearchParams(body as unknown as Record<string, string>).toString()");
+    } else if (cat === "text" || cat === "binary") {
+      fetchArgs.push(`headers: { 'Content-Type': '${body.contentType}' }`);
+      fetchArgs.push("body: body");
+    } else {
+      fetchArgs.push(`headers: { 'Content-Type': '${body.contentType}' }`);
+      fetchArgs.push("body: JSON.stringify(body, bigIntReplacer)");
+    }
+  } else if (hasBody) {
+    fetchArgs.push(`headers: { 'Content-Type': __contentType }`);
+    fetchArgs.push("body: __serialized");
+  }
+  if (hasOpHeaders) {
+    const lastHeaderIdx = fetchArgs.findIndex((a) => a.startsWith("headers:"));
+    if (lastHeaderIdx !== -1) {
+      const existing = fetchArgs[lastHeaderIdx];
+      const inner = existing.slice("headers: ".length).replace(/^\{\s*|\s*\}$/g, "");
+      fetchArgs[lastHeaderIdx] = `headers: { ${inner}, ...customHeaders }`;
+    } else {
+      fetchArgs.push("headers: customHeaders");
+    }
+  }
+  const resultPrefix = isVoid && !hasRespHeaders ? "" : "const result = ";
+  if (fetchArgs.length === 2 && !hasBody && !hasOpHeaders && !hasQuery) {
+    lines.push(`        ${resultPrefix}await this.fetch(\`${fetchUrl}\`, { method: '${httpMethod}' });`);
+  } else {
+    lines.push(`        ${resultPrefix}await this.fetch(${fetchArgs[0].split(": ").slice(1).join(": ")}, {`);
+    for (let i = 1; i < fetchArgs.length; i++) {
+      lines.push(`            ${fetchArgs[i]},`);
+    }
+    lines.push(`        });`);
+  }
+  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(", ");
+    if (isVoid) {
+      lines.push(`        return { headers: { ${headerEntries} } };`);
+    } else {
+      lines.push(`        const data = ${readBodyExpr};`);
+      lines.push(`        return { data, headers: { ${headerEntries} } };`);
+    }
+  } else if (!isVoid) {
+    lines.push(`        return ${readBodyExpr};`);
+  }
+  lines.push("    }");
+  return lines;
+}
+__name(generateMethod, "generateMethod");
+function buildUrlExpression(path, _) {
+  return path.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_match, name) => {
+    return `\${encodeURIComponent(${name})}`;
+  });
+}
+__name(buildUrlExpression, "buildUrlExpression");
+function buildMethodParams(route, op, modelsWithInput) {
+  const params = [];
+  if (route.params) {
+    if (route.params.kind === "params") {
+      for (const p of route.params.nodes) {
+        params.push({
+          name: p.name,
+          type: renderInputTsType(p.type, modelsWithInput),
+          optional: false
+        });
+      }
+    } else if (route.params.kind === "ref") {
+      const typeName = modelsWithInput?.has(route.params.name) ? `${route.params.name}Input` : route.params.name;
+      params.push({
+        name: "params",
+        type: typeName,
+        optional: false
+      });
+    } else {
+      params.push({
+        name: "params",
+        type: renderInputTsType(route.params.node, modelsWithInput),
+        optional: false
+      });
+    }
+  }
+  const strategy = classifyBodyStrategy(op);
+  if (strategy.kind === "single") {
+    const body = strategy.body;
+    const cat = classifyContentType2(body.contentType);
+    if (cat === "multipart") {
+      params.push({
+        name: "body",
+        type: "FormData",
+        optional: false
+      });
+    } else if (cat === "text") {
+      params.push({
+        name: "body",
+        type: "string",
+        optional: false
+      });
+    } else if (cat === "binary") {
+      params.push({
+        name: "body",
+        type: "Blob | ArrayBuffer | Uint8Array | string",
+        optional: false
+      });
+    } else {
+      params.push({
+        name: "body",
+        type: renderInputTsType(body.bodyType, modelsWithInput),
+        optional: false
+      });
+    }
+  } else if (strategy.kind === "multi-equal") {
+    const bodies = strategy.bodies;
+    const bodyType = renderInputTsType(bodies[0].bodyType, modelsWithInput);
+    params.push({
+      name: "body",
+      type: bodyType,
+      optional: false
+    });
+    const ctUnion = bodies.map((b) => `'${b.contentType}'`).join(" | ");
+    params.push({
+      name: "options",
+      type: `{ contentType?: ${ctUnion} }`,
+      optional: true
+    });
+  } else if (strategy.kind === "multi-formdata-detect") {
+    const types = strategy.bodies.map((b) => b.contentType === "multipart/form-data" ? "FormData" : renderInputTsType(b.bodyType, modelsWithInput)).join(" | ");
+    params.push({
+      name: "body",
+      type: types,
+      optional: false
+    });
+  } else if (strategy.kind === "multi-required-arg") {
+    const types = strategy.bodies.map((b) => b.contentType === "multipart/form-data" ? "FormData" : renderInputTsType(b.bodyType, modelsWithInput)).join(" | ");
+    params.push({
+      name: "body",
+      type: types,
+      optional: false
+    });
+    const ctUnion = strategy.bodies.map((b) => `'${b.contentType}'`).join(" | ");
+    params.push({
+      name: "options",
+      type: `{ contentType: ${ctUnion} }`,
+      optional: false
+    });
+  }
+  if (op.query) {
+    if (op.query.kind === "params") {
+      const fields = op.query.nodes.map((p) => `${quoteKey2(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
+      params.push({
+        name: "query",
+        type: `{ ${fields} }`,
+        optional: true
+      });
+    } else if (op.query.kind === "ref") {
+      const typeName = modelsWithInput?.has(op.query.name) ? `${op.query.name}Input` : op.query.name;
+      params.push({
+        name: "query",
+        type: typeName,
+        optional: true
+      });
+    } else {
+      params.push({
+        name: "query",
+        type: renderInputTsType(op.query.node, modelsWithInput),
+        optional: true
+      });
+    }
+  }
+  if (op.headers) {
+    if (op.headers.kind === "params") {
+      const fields = op.headers.nodes.map((p) => `${quoteKey2(p.name)}?: ${renderInputTsType(p.type, modelsWithInput)}`).join("; ");
+      params.push({
+        name: "customHeaders",
+        type: `{ ${fields} }`,
+        optional: true
+      });
+    } else if (op.headers.kind === "ref") {
+      const typeName = modelsWithInput?.has(op.headers.name) ? `${op.headers.name}Input` : op.headers.name;
+      params.push({
+        name: "customHeaders",
+        type: typeName,
+        optional: true
+      });
+    } else {
+      params.push({
+        name: "customHeaders",
+        type: renderInputTsType(op.headers.node, modelsWithInput),
+        optional: true
+      });
+    }
+  }
+  return params;
+}
+__name(buildMethodParams, "buildMethodParams");
+function deriveMethodName(op, route) {
+  if (op.sdk) return op.sdk;
+  if (op.name) return nameToMethodName(op.name);
+  return inferMethodName2(op.method, route.path);
+}
+__name(deriveMethodName, "deriveMethodName");
+function nameToMethodName(name) {
+  const parts = name.split(/[\s\-_]+/).filter(Boolean);
+  return parts.map((p, i) => i === 0 ? p.charAt(0).toLowerCase() + p.slice(1) : p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+__name(nameToMethodName, "nameToMethodName");
+function inferMethodName2(method, path) {
+  const segments = path.split("/").filter((s) => s.length > 0);
+  const parts = [
+    method.toLowerCase()
+  ];
+  for (const seg of segments) {
+    if (seg.startsWith("{")) {
+      const paramName = seg.slice(1, -1);
+      parts.push("By" + paramName.charAt(0).toUpperCase() + paramName.slice(1));
+    } else {
+      const segParts = seg.split(/[.-]/).filter(Boolean);
+      for (const sp of segParts) {
+        parts.push(sp.charAt(0).toUpperCase() + sp.slice(1));
+      }
+    }
+  }
+  return parts[0] + parts.slice(1).join("");
+}
+__name(inferMethodName2, "inferMethodName");
+function deriveBaseName2(file) {
+  const base = file.split("/").pop()?.replace(/\.(op|ck)$/, "") ?? "Resource";
+  return base.split(".").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+__name(deriveBaseName2, "deriveBaseName");
+function deriveClientClassName(file) {
+  return `${deriveBaseName2(file)}Client`;
+}
+__name(deriveClientClassName, "deriveClientClassName");
+function deriveClientPropertyName(file) {
+  const base = deriveBaseName2(file);
+  return base.charAt(0).toLowerCase() + base.slice(1);
+}
+__name(deriveClientPropertyName, "deriveClientPropertyName");
+function collectTypes2(root, modelsWithInput, modelsWithOutput, includeInternal = false) {
+  const types = /* @__PURE__ */ new Set();
+  for (const route of root.routes) {
+    const publicOps = route.operations.filter((op) => includeInternal || !resolveModifiers2(route, op).includes("internal"));
+    if (publicOps.length === 0) continue;
+    collectParamSourceRefs2(route.params, types);
+    collectParamSourceInputRefs2(route.params, types, modelsWithInput);
+    for (const op of publicOps) {
+      if (op.request) {
+        for (const body of op.request.bodies) {
+          collectTypeNodeRefs2(body.bodyType, types);
+          collectInputTypeNodeRefs2(body.bodyType, types, modelsWithInput);
+        }
+      }
+      for (const resp of op.responses) {
+        if (resp.bodyType) {
+          collectTypeNodeRefs2(resp.bodyType, types);
+          collectOutputTypeNodeRefs2(resp.bodyType, types, modelsWithOutput);
+        }
+        if (resp.headers) {
+          for (const h of resp.headers) {
+            collectTypeNodeRefs2(h.type, types);
+            collectOutputTypeNodeRefs2(h.type, types, modelsWithOutput);
+          }
+        }
+      }
+      collectParamSourceRefs2(op.query, types);
+      collectParamSourceInputRefs2(op.query, types, modelsWithInput);
+      collectParamSourceRefs2(op.headers, types);
+      collectParamSourceInputRefs2(op.headers, types, modelsWithInput);
+    }
+  }
+  return [
+    ...types
+  ].sort();
+}
+__name(collectTypes2, "collectTypes");
+function collectOutputTypeNodeRefs2(type, out, modelsWithOutput) {
+  if (!modelsWithOutput) return;
+  switch (type.kind) {
+    case "ref":
+      if (modelsWithOutput.has(type.name)) out.add(`${type.name}Output`);
+      break;
+    case "array":
+      collectOutputTypeNodeRefs2(type.item, out, modelsWithOutput);
+      break;
+    case "intersection":
+    case "union":
+    case "discriminatedUnion":
+      type.members.forEach((m) => collectOutputTypeNodeRefs2(m, out, modelsWithOutput));
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectOutputTypeNodeRefs2(f.type, out, modelsWithOutput));
+      break;
+    case "lazy":
+      collectOutputTypeNodeRefs2(type.inner, out, modelsWithOutput);
+      break;
+  }
+}
+__name(collectOutputTypeNodeRefs2, "collectOutputTypeNodeRefs");
+function collectParamSourceInputRefs2(source, out, modelsWithInput) {
+  if (!source || !modelsWithInput) return;
+  if (source.kind === "ref") {
+    if (modelsWithInput.has(source.name)) out.add(`${source.name}Input`);
+  } else if (source.kind === "params") {
+    for (const param of source.nodes) {
+      collectInputTypeNodeRefs2(param.type, out, modelsWithInput);
+    }
+  } else {
+    collectInputTypeNodeRefs2(source.node, out, modelsWithInput);
+  }
+}
+__name(collectParamSourceInputRefs2, "collectParamSourceInputRefs");
+function collectInputTypeNodeRefs2(type, out, modelsWithInput) {
+  if (!modelsWithInput) return;
+  switch (type.kind) {
+    case "ref":
+      if (modelsWithInput.has(type.name)) out.add(`${type.name}Input`);
+      break;
+    case "array":
+      collectInputTypeNodeRefs2(type.item, out, modelsWithInput);
+      break;
+    case "intersection":
+    case "union":
+    case "discriminatedUnion":
+      type.members.forEach((m) => collectInputTypeNodeRefs2(m, out, modelsWithInput));
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectInputTypeNodeRefs2(f.type, out, modelsWithInput));
+      break;
+    case "lazy":
+      collectInputTypeNodeRefs2(type.inner, out, modelsWithInput);
+      break;
+  }
+}
+__name(collectInputTypeNodeRefs2, "collectInputTypeNodeRefs");
+function collectParamSourceRefs2(source, out) {
+  if (!source) return;
+  if (source.kind === "ref") {
+    if (/^[A-Z]/.test(source.name)) out.add(source.name);
+  } else if (source.kind === "params") {
+    for (const param of source.nodes) {
+      collectTypeNodeRefs2(param.type, out);
+    }
+  } else {
+    collectTypeNodeRefs2(source.node, out);
+  }
+}
+__name(collectParamSourceRefs2, "collectParamSourceRefs");
+function sdkNeedsQueryString(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers2(route, op).includes("internal")) continue;
+      if (op.query) return true;
+    }
+  }
+  return false;
+}
+__name(sdkNeedsQueryString, "sdkNeedsQueryString");
+function sdkNeedsBigIntReplacer(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers2(route, op).includes("internal")) continue;
+      if (op.request && op.request.bodies.some((b) => isJsonMime(b.contentType))) return true;
+    }
+  }
+  return false;
+}
+__name(sdkNeedsBigIntReplacer, "sdkNeedsBigIntReplacer");
+function sdkNeedsBigIntReviver(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers2(route, op).includes("internal")) continue;
+      if (op.responses.some((r) => {
+        if (!r.bodyType) return false;
+        return !r.contentType || classifyContentType2(r.contentType) === "json";
+      })) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(sdkNeedsBigIntReviver, "sdkNeedsBigIntReviver");
+function sdkNeedsJson(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers2(route, op).includes("internal")) continue;
+      const check = /* @__PURE__ */ __name((src) => {
+        if (!src || src.kind === "ref") return false;
+        if (src.kind === "params") return src.nodes.some((p) => typeNeedsScalar(p.type, "json"));
+        return typeNeedsScalar(src.node, "json");
+      }, "check");
+      if (!!op.request?.bodies.some((b) => typeNeedsScalar(b.bodyType, "json")) || op.responses.some((r) => r.bodyType && typeNeedsScalar(r.bodyType, "json")) || check(op.query) || check(op.headers) || check(route.params)) return true;
+    }
+  }
+  return false;
+}
+__name(sdkNeedsJson, "sdkNeedsJson");
+function collectTypeNodeRefs2(type, out) {
+  switch (type.kind) {
+    case "ref":
+      if (/^[A-Z]/.test(type.name)) out.add(type.name);
+      break;
+    case "array":
+      collectTypeNodeRefs2(type.item, out);
+      break;
+    case "tuple":
+      type.items.forEach((t) => collectTypeNodeRefs2(t, out));
+      break;
+    case "record":
+      collectTypeNodeRefs2(type.key, out);
+      collectTypeNodeRefs2(type.value, out);
+      break;
+    case "union":
+      type.members.forEach((t) => collectTypeNodeRefs2(t, out));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((t) => collectTypeNodeRefs2(t, out));
+      break;
+    case "intersection":
+      type.members.forEach((t) => collectTypeNodeRefs2(t, out));
+      break;
+    case "lazy":
+      collectTypeNodeRefs2(type.inner, out);
+      break;
+    case "inlineObject":
+      type.fields.forEach((f) => collectTypeNodeRefs2(f.type, out));
+      break;
+  }
+}
+__name(collectTypeNodeRefs2, "collectTypeNodeRefs");
+function generateTypeImports2(types, opFile, options) {
+  const lines = [];
+  const { modelOutPaths, outPath } = options;
+  if (modelOutPaths && outPath) {
+    const byFile = /* @__PURE__ */ new Map();
+    const unresolved = [];
+    for (const type of types) {
+      const typeOutPath = modelOutPaths.get(type);
+      if (typeOutPath) {
+        const group = byFile.get(typeOutPath) ?? [];
+        group.push(type);
+        byFile.set(typeOutPath, group);
+      } else {
+        unresolved.push(type);
+      }
+    }
+    const fromDir = dirname3(outPath);
+    for (const [typeOutPath, names] of byFile) {
+      let rel = relative3(fromDir, typeOutPath);
+      rel = rel.replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      lines.push(`import type { ${names.sort().join(", ")} } from '${rel}';`);
+    }
+    for (const type of unresolved) {
+      const moduleName = pascalToDotCase(type);
+      lines.push(`import type { ${type} } from './${moduleName}.js';`);
+    }
+  } else {
+    const typeImport = deriveTypeImportPath2(opFile, options.typeImportPathTemplate);
+    lines.push(`import type { ${types.join(", ")} } from '${typeImport}';`);
+  }
+  return lines;
+}
+__name(generateTypeImports2, "generateTypeImports");
+function deriveTypeImportPath2(file, template) {
+  const base = file.split("/").pop()?.replace(/\.(op|ck)$/, "") ?? "resource";
+  const module = base.split(".")[0] ?? base;
+  if (template) {
+    return template.replace(/\{module\}/g, module).replace(/\{base\}/g, base);
+  }
+  return `#modules/${module}/types/index.js`;
+}
+__name(deriveTypeImportPath2, "deriveTypeImportPath");
+function generateSdkOptions() {
+  return [
+    "export class SdkError extends Error {",
+    "    constructor(",
+    "        public readonly status: number,",
+    "        public readonly statusText: string,",
+    "        public readonly body: unknown,",
+    "    ) {",
+    "        super(`${status} ${statusText}`);",
+    "        this.name = 'SdkError';",
+    "    }",
+    "}",
+    "",
+    "export type SdkFetch = (url: string, init: RequestInit) => Promise<Response>;",
+    "",
+    "export interface SdkOptions {",
+    "    baseUrl: string;",
+    "    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);",
+    "    fetch?: SdkFetch;",
+    "    /** Called once per request to produce a unique X-Request-ID header value */",
+    "    requestIdFactory?: () => string;",
+    "}",
+    "",
+    "export const bigIntReplacer = (_: string, value: any): any => {",
+    "    if (typeof value === 'bigint') {",
+    "        return value.toString() + 'n';",
+    "    }",
+    "    return value;",
+    "};",
+    "",
+    "export const bigIntReviver = (_: string, value: any): any => {",
+    "    if (typeof value === 'string' && /^-?\\d+n$/.test(value)) {",
+    "        return BigInt(value.slice(0, -1));",
+    "    }",
+    "    return value;",
+    "};",
+    "",
+    JSON_VALUE_TYPE_DECL,
+    "",
+    "export function createSdkFetch(options: SdkOptions): SdkFetch {",
+    "    const getRequestId = options.requestIdFactory ?? (() => crypto.randomUUID());",
+    "    return async (url: string, init: RequestInit): Promise<Response> => {",
+    "        const baseHeaders = typeof options.headers === 'function'",
+    "            ? await options.headers()",
+    "            : options.headers ?? {};",
+    "        const res = await fetch(`${options.baseUrl}${url}`, {",
+    "            ...init,",
+    "            headers: { ...baseHeaders, 'X-Request-ID': getRequestId(), ...init.headers as Record<string, string> },",
+    "        });",
+    "        if (!res.ok) {",
+    "            const text = await res.text();",
+    "            let body: unknown;",
+    "            try { body = JSON.parse(text); } catch { body = text; }",
+    "            throw new SdkError(res.status, res.statusText, body);",
+    "        }",
+    "        return res;",
+    "    };",
+    "}",
+    "",
+    "export function buildQueryString(query: object | undefined): string {",
+    "    const searchParams = new URLSearchParams();",
+    "    if (query) {",
+    "        for (const [k, v] of Object.entries(query)) {",
+    "            if (v === undefined || v === null) continue;",
+    "            if (Array.isArray(v)) { for (const item of v) searchParams.append(k, String(item)); }",
+    "            else searchParams.set(k, String(v));",
+    "        }",
+    "    }",
+    "    const qs = searchParams.toString();",
+    "    return qs ? `?${qs}` : '';",
+    "}",
+    "",
+    "export async function parseJson<T>(res: Response): Promise<T> {",
+    "    return JSON.parse(await res.text(), bigIntReviver) as T;",
+    "}",
+    ""
+  ].join("\n");
+}
+__name(generateSdkOptions, "generateSdkOptions");
+function generateSdkAggregator(clients, sdkOptionsImportPath = "./sdk-options.js", sdkClassName = "Sdk") {
+  const lines = [];
+  lines.push(`import type { SdkOptions } from '${sdkOptionsImportPath}';`);
+  lines.push(`import { createSdkFetch } from '${sdkOptionsImportPath}';`);
+  for (const c of clients) {
+    lines.push(`import { ${c.className} } from '${c.importPath}';`);
+  }
+  lines.push("");
+  lines.push(`export class ${sdkClassName} {`);
+  for (const c of clients) {
+    lines.push(`    readonly ${c.propertyName}: ${c.className};`);
+  }
+  lines.push("");
+  lines.push("    constructor(options: SdkOptions) {");
+  lines.push("        const sdkFetch = options.fetch ?? createSdkFetch(options);");
+  for (const c of clients) {
+    lines.push(`        this.${c.propertyName} = new ${c.className}(sdkFetch);`);
+  }
+  lines.push("    }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateSdkAggregator, "generateSdkAggregator");
+
+// src/codegen-plain-types.ts
+import { relative as relative4, dirname as dirname4 } from "path";
+import { computeModelsWithOutput, collectExternalOutputRefs } from "@contractkit/core";
+function generatePlainTypes(root, context) {
+  const externalRefs = collectExternalRefs(root);
+  const lines = [];
+  const externalModelsWithInput = context?.modelsWithInput ?? /* @__PURE__ */ new Set();
+  const localModelsWithInput = computeModelsWithInput(root.models, externalModelsWithInput);
+  const allModelsWithInput = /* @__PURE__ */ new Set([
+    ...localModelsWithInput,
+    ...externalModelsWithInput
+  ]);
+  const externalModelsWithOutput = context?.modelsWithOutput ?? /* @__PURE__ */ new Set();
+  const localModelsWithOutput = computeModelsWithOutput(root.models, externalModelsWithOutput);
+  const allModelsWithOutput = /* @__PURE__ */ new Set([
+    ...localModelsWithOutput,
+    ...externalModelsWithOutput
+  ]);
+  const externalInputRefs = allModelsWithInput.size > 0 ? collectExternalInputRefs(root, allModelsWithInput) : [];
+  const externalOutputRefs = allModelsWithOutput.size > 0 ? collectExternalOutputRefs(root, allModelsWithOutput) : [];
+  const allExternalRefs = [
+    .../* @__PURE__ */ new Set([
+      ...externalRefs,
+      ...externalInputRefs,
+      ...externalOutputRefs
+    ])
+  ].sort();
+  for (const ref of allExternalRefs) {
+    const importPath = resolveImportPath(ref, context);
+    lines.push(`import type { ${ref} } from '${importPath}';`);
+  }
+  if (allExternalRefs.length > 0) lines.push("");
+  if (rootNeedsScalar(root, "json")) {
+    if (context?.jsonValueImportPath) {
+      lines.push(`import type { JsonValue } from '${context.jsonValueImportPath}';`);
+    } else {
+      lines.push(JSON_VALUE_TYPE_DECL);
+    }
+    lines.push("");
+  }
+  for (const model of topoSortModels(root.models)) {
+    lines.push(...generateModel2(model, context?.currentOutPath, allModelsWithInput, allModelsWithOutput));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+__name(generatePlainTypes, "generatePlainTypes");
+function generateModel2(model, outPath, modelsWithInput, modelsWithOutput) {
+  if (model.type) {
+    return generateTypeAlias2(model, outPath, modelsWithInput, modelsWithOutput);
+  }
+  const needsInputSplit = model.fields.some((f) => f.visibility !== "normal") || (modelsWithInput?.has(model.name) ?? false);
+  const lines = needsInputSplit ? generateVisibilityModel(model, outPath, modelsWithInput) : generateSimpleModel2(model, outPath);
+  if (modelsWithOutput?.has(model.name)) {
+    lines.push("");
+    lines.push(...generateOutputModel(model, modelsWithOutput));
+  }
+  return lines;
+}
+__name(generateModel2, "generateModel");
+function generateComments2(model, outPath) {
+  const lines = [];
+  lines.push("/**");
+  if (model.deprecated) {
+    lines.push(` * @deprecated`);
+  }
+  if (model.description) {
+    lines.push(` * ${model.description}`);
+  }
+  const relPath = outPath ? relative4(dirname4(outPath), model.loc.file) : model.loc.file;
+  lines.push(` * generated from [${model.name}](file://./${relPath}#L${model.loc.line})`);
+  lines.push(" */");
+  return lines;
+}
+__name(generateComments2, "generateComments");
+function generateTypeAlias2(model, outPath, modelsWithInput, modelsWithOutput) {
+  const lines = [];
+  lines.push(...generateComments2(model, outPath));
+  lines.push(`export type ${model.name} = ${renderTsType(model.type)};`);
+  if (modelsWithInput?.has(model.name)) {
+    lines.push(`export type ${model.name}Input = ${renderInputTsType(model.type, modelsWithInput)};`);
+  }
+  if (modelsWithOutput?.has(model.name)) {
+    lines.push(`export type ${model.name}Output = ${renderOutputTsType(model.type, modelsWithOutput)};`);
+  }
+  return lines;
+}
+__name(generateTypeAlias2, "generateTypeAlias");
+function buildExtendsClause(bases, overrideNames, baseNameResolver) {
+  if (bases.length === 0) return "";
+  if (overrideNames.length === 0) return ` extends ${bases.map(baseNameResolver).join(", ")}`;
+  const omitKeys = overrideNames.map((n) => `'${n}'`).join(" | ");
+  const wrapped = bases.map((b) => `Omit<${baseNameResolver(b)}, ${omitKeys}>`);
+  return ` extends ${wrapped.join(", ")}`;
+}
+__name(buildExtendsClause, "buildExtendsClause");
+function generateSimpleModel2(model, outPath) {
+  const lines = [];
+  lines.push(...generateComments2(model, outPath));
+  const bases = model.bases ?? [];
+  const overrideNames = model.fields.filter((f) => f.override).map((f) => f.name);
+  lines.push(`export interface ${model.name}${buildExtendsClause(bases, overrideNames, (b) => b)} {`);
+  for (const field of model.fields) {
+    lines.push(`    ${renderField2(field)}`);
+  }
+  lines.push("}");
+  return lines;
+}
+__name(generateSimpleModel2, "generateSimpleModel");
+function generateVisibilityModel(model, outPath, modelsWithInput) {
+  const lines = [];
+  lines.push(...generateComments2(model, outPath));
+  const bases = model.bases ?? [];
+  const overrideNames = model.fields.filter((f) => f.override).map((f) => f.name);
+  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("}");
+  lines.push("");
+  const writeFields = model.fields.filter((f) => f.visibility !== "readonly");
+  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("}");
+  return lines;
+}
+__name(generateVisibilityModel, "generateVisibilityModel");
+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 jsdocParts = [];
+  if (field.deprecated) jsdocParts.push("@deprecated");
+  if (field.description) jsdocParts.push(field.description);
+  if (jsdocParts.length > 0) {
+    return `/** ${jsdocParts.join(" ")} */
+    ${line}`;
+  }
+  return 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 jsdocParts = [];
+  if (field.deprecated) jsdocParts.push("@deprecated");
+  if (field.description) jsdocParts.push(field.description);
+  if (jsdocParts.length > 0) {
+    return `/** ${jsdocParts.join(" ")} */
+    ${line}`;
+  }
+  return line;
+}
+__name(renderInputField2, "renderInputField");
+function camelToSnake2(s) {
+  return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+__name(camelToSnake2, "camelToSnake");
+function camelToPascal2(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+__name(camelToPascal2, "camelToPascal");
+function applyOutputCase(name, c) {
+  if (!c || c === "camel") return name;
+  if (c === "snake") return camelToSnake2(name);
+  return camelToPascal2(name);
+}
+__name(applyOutputCase, "applyOutputCase");
+function generateOutputModel(model, modelsWithOutput) {
+  const lines = [];
+  const outputCase = model.outputCase && model.outputCase !== "camel" ? model.outputCase : void 0;
+  const readFields = model.fields.filter((f) => f.visibility !== "writeonly");
+  if (!outputCase) {
+    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("}");
+    return lines;
+  }
+  lines.push(`export interface ${model.name}Output {`);
+  for (const field of readFields) {
+    lines.push(`    ${renderOutputField(field, outputCase, modelsWithOutput)}`);
+  }
+  lines.push("}");
+  return lines;
+}
+__name(generateOutputModel, "generateOutputModel");
+function renderOutputField(field, outputCase, modelsWithOutput) {
+  const opt = field.optional || field.default !== void 0 ? "?" : "";
+  const key = applyOutputCase(field.name, outputCase);
+  let typeStr = renderOutputTsType(field.type, modelsWithOutput);
+  if (field.nullable) typeStr += " | null";
+  const line = `${quoteKey2(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;
+}
+__name(renderOutputField, "renderOutputField");
+
+// src/path-utils.ts
+import { resolve, join, relative as relative5, dirname as dirname5 } from "path";
+import { collectTypeRefs as collectTypeRefs2, collectPublicTypeNames } from "@contractkit/core";
+var TEMPLATE_VAR_RE = /\{\w+\}/;
+function resolveTemplate(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? `{${key}}`);
+}
+__name(resolveTemplate, "resolveTemplate");
+function includesFilename(p) {
+  const last = p.split("/").pop() ?? "";
+  return last.includes(".");
+}
+__name(includesFilename, "includesFilename");
+function commonDir(files, rootDir) {
+  if (files.length === 0) return resolve(rootDir);
+  const parts = files.map((f) => dirname5(f).split("/"));
+  const first = parts[0];
+  let depth = first.length;
+  for (const p of parts) {
+    for (let i = 0; i < depth; i++) {
+      if (p[i] !== first[i]) {
+        depth = i;
+        break;
+      }
+    }
+  }
+  return first.slice(0, depth).join("/") || "/";
+}
+__name(commonDir, "commonDir");
+function computeOpOutPath(filePath, baseDir, output, defaultSuffix, commonRoot, meta = {}) {
+  const baseName = filePath.split("/").pop();
+  const relDir = relative5(commonRoot, dirname5(filePath));
+  const filename = baseName.replace(/\.ck$/, "");
+  const defaultName = `${filename}${defaultSuffix}`;
+  const baseOutDir = resolve(baseDir);
+  if (output && TEMPLATE_VAR_RE.test(output)) {
+    const resolved = resolveTemplate(output, {
+      filename,
+      dir: relDir,
+      ext: "ck",
+      ...meta
+    });
+    if (includesFilename(resolved)) return join(baseOutDir, resolved);
+    return join(baseOutDir, resolved, defaultName);
+  }
+  if (output) {
+    if (includesFilename(output)) return join(baseOutDir, output);
+    return join(baseOutDir, output, relDir, defaultName);
+  }
+  return join(baseOutDir, relDir, defaultName);
+}
+__name(computeOpOutPath, "computeOpOutPath");
+function computeContractOutPath(filePath, baseDir, output, defaultSuffix, commonRoot, meta = {}) {
+  return computeOpOutPath(filePath, baseDir, output, defaultSuffix, commonRoot, meta);
+}
+__name(computeContractOutPath, "computeContractOutPath");
+function computeSdkOutPath(filePath, rootDir, clientOutput, commonRoot, meta = {}) {
+  if (!filePath.endsWith(".ck")) return null;
+  const baseName = filePath.split("/").pop();
+  const defaultOutName = baseName.replace(/\.ck$/, ".client.ts");
+  const baseOutDir = resolve(rootDir);
+  const relDir = relative5(commonRoot, dirname5(filePath));
+  const filename = baseName.replace(/\.ck$/, "");
+  if (clientOutput && TEMPLATE_VAR_RE.test(clientOutput)) {
+    const resolved = resolveTemplate(clientOutput, {
+      filename,
+      dir: relDir,
+      ext: "ck",
+      ...meta
+    });
+    if (includesFilename(resolved)) return join(baseOutDir, resolved);
+    return join(baseOutDir, resolved, defaultOutName);
+  }
+  if (clientOutput) {
+    if (includesFilename(clientOutput)) return join(baseOutDir, clientOutput);
+    return join(baseOutDir, clientOutput, relDir, defaultOutName);
+  }
+  return join(baseOutDir, relDir, defaultOutName);
+}
+__name(computeSdkOutPath, "computeSdkOutPath");
+function computeSdkTypeOutPath(filePath, rootDir, typeOutput, commonRoot, meta = {}) {
+  if (!filePath.endsWith(".ck")) return null;
+  const baseName = filePath.split("/").pop();
+  const defaultOutName = baseName.replace(/\.ck$/, ".ts");
+  const baseOutDir = resolve(rootDir);
+  const relDir = relative5(commonRoot, dirname5(filePath));
+  const filename = baseName.replace(/\.ck$/, "");
+  if (TEMPLATE_VAR_RE.test(typeOutput)) {
+    const resolved = resolveTemplate(typeOutput, {
+      filename,
+      dir: relDir,
+      ext: "ck",
+      ...meta
+    });
+    if (includesFilename(resolved)) return join(baseOutDir, resolved);
+    return join(baseOutDir, resolved, defaultOutName);
+  }
+  if (includesFilename(typeOutput)) return join(baseOutDir, typeOutput);
+  return 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 group = byDir.get(dir) ?? [];
+    group.push(outPath);
+    byDir.set(dir, group);
+  }
+  const results = [];
+  for (const [dir, files] of byDir) {
+    const exports = files.map((f) => `export * from './${f.split("/").pop().replace(/\.ts$/, ".js")}';`).sort().join("\n");
+    results.push({
+      outPath: join(dir, "index.ts"),
+      content: `// Auto-generated barrel file
+${exports}
+`
+    });
+  }
+  return results;
+}
+__name(generateBarrelFiles, "generateBarrelFiles");
+function computePubliclyReachableTypes(opAsts, contractAsts, modelsWithInput, modelsWithOutput = /* @__PURE__ */ new Set()) {
+  if (opAsts.length === 0) return null;
+  const reachable = /* @__PURE__ */ new Set();
+  for (const opAst of opAsts) {
+    for (const name of collectPublicTypeNames(opAst, modelsWithInput, modelsWithOutput)) reachable.add(name);
+  }
+  const modelDeps = /* @__PURE__ */ new Map();
+  for (const contractAst of contractAsts) {
+    for (const model of contractAst.models) {
+      const deps = /* @__PURE__ */ new Set();
+      if (model.bases) for (const b of model.bases) deps.add(b);
+      if (model.type) collectTypeRefs2(model.type, deps);
+      for (const field of model.fields) collectTypeRefs2(field.type, deps);
+      modelDeps.set(model.name, deps);
+    }
+  }
+  const frontier = [
+    ...reachable
+  ];
+  while (frontier.length > 0) {
+    const name = frontier.pop();
+    const baseName = name.endsWith("Input") ? name.slice(0, -5) : name.endsWith("Output") ? name.slice(0, -6) : name;
+    for (const dep of modelDeps.get(baseName) ?? []) {
+      if (!reachable.has(dep)) {
+        reachable.add(dep);
+        frontier.push(dep);
+      }
+      if (modelsWithInput.has(dep)) {
+        const inputDep = `${dep}Input`;
+        if (!reachable.has(inputDep)) {
+          reachable.add(inputDep);
+          frontier.push(inputDep);
+        }
+      }
+      if (modelsWithOutput.has(dep)) {
+        const outputDep = `${dep}Output`;
+        if (!reachable.has(outputDep)) {
+          reachable.add(outputDep);
+          frontier.push(outputDep);
+        }
+      }
+    }
+  }
+  return reachable;
+}
+__name(computePubliclyReachableTypes, "computePubliclyReachableTypes");
+
+// src/index.ts
+function runServerGeneration(config, rootDir, inputs, emitFile) {
+  const serverBase = resolve2(rootDir, config.baseDir ?? ".");
+  const modelsWithInput = inputs.modelsWithInput;
+  const modelsWithOutput = inputs.modelsWithOutput;
+  const allFiles = [
+    ...inputs.contractRoots.map((r) => r.file),
+    ...inputs.opRoots.map((r) => r.file)
+  ];
+  const commonRoot = commonDir(allFiles, rootDir);
+  let serverModelOutPaths = /* @__PURE__ */ new Map();
+  if (config.output?.types) {
+    serverModelOutPaths = /* @__PURE__ */ new Map();
+    const typeEntries = [];
+    for (const ast of inputs.contractRoots) {
+      const typeOutPath = computeContractOutPath(ast.file, serverBase, config.output.types, ".ts", commonRoot, ast.meta);
+      typeEntries.push({
+        ast,
+        typeOutPath
+      });
+      for (const model of ast.models) {
+        serverModelOutPaths.set(model.name, typeOutPath);
+        if (modelsWithInput.has(model.name)) {
+          serverModelOutPaths.set(`${model.name}Input`, typeOutPath);
+        }
+        if (modelsWithOutput.has(model.name)) {
+          serverModelOutPaths.set(`${model.name}Output`, typeOutPath);
+        }
+      }
+    }
+    for (const { ast, typeOutPath } of typeEntries) {
+      const ctx = {
+        modelOutPaths: serverModelOutPaths,
+        currentOutPath: typeOutPath,
+        modelsWithInput,
+        modelsWithOutput
+      };
+      const content = config.zod ? generateContract(ast, ctx) : generatePlainTypes(ast, ctx);
+      emitFile(typeOutPath, content);
+    }
+  }
+  for (const ast of inputs.opRoots) {
+    const outPath = computeOpOutPath(ast.file, serverBase, config.output?.routes, ".router.ts", commonRoot, ast.meta);
+    const content = generateOp(ast, {
+      servicePathTemplate: config.servicePathTemplate,
+      outPath,
+      modelOutPaths: serverModelOutPaths,
+      modelsWithInput,
+      modelsWithOutput,
+      includeInternal: config.includeInternal
+    });
+    emitFile(outPath, content);
+  }
+}
+__name(runServerGeneration, "runServerGeneration");
+function runSdkGeneration(config, rootDir, inputs, emitFile) {
+  const sdkBase = config.baseDir ? resolve2(rootDir, config.baseDir) : rootDir;
+  const sdkName = config.name;
+  const sdkOutput = config.output?.sdk;
+  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 modelsWithInput = inputs.modelsWithInput;
+  const modelsWithOutput = inputs.modelsWithOutput;
+  const allFiles = [
+    ...inputs.contractRoots.map((r) => r.file),
+    ...inputs.opRoots.map((r) => r.file)
+  ];
+  const ckCommonRoot = commonDir(allFiles, rootDir);
+  let sdkModelOutPaths = /* @__PURE__ */ new Map();
+  const sdkTypePaths = [];
+  const sdkClientInfos = [];
+  if (config.output?.types) {
+    sdkModelOutPaths = /* @__PURE__ */ new Map();
+    const publicTypes = computePubliclyReachableTypes(inputs.opRoots, inputs.contractRoots, modelsWithInput, modelsWithOutput);
+    const sdkContractEntries = [];
+    for (const ast of inputs.contractRoots) {
+      const typeOutPath = computeSdkTypeOutPath(ast.file, sdkBase, config.output.types, ckCommonRoot, ast.meta);
+      if (!typeOutPath) continue;
+      if (publicTypes !== null && !ast.models.some((m) => publicTypes.has(m.name))) continue;
+      sdkTypePaths.push(typeOutPath);
+      sdkContractEntries.push({
+        ast,
+        typeOutPath
+      });
+      for (const model of ast.models) {
+        sdkModelOutPaths.set(model.name, typeOutPath);
+        if (modelsWithInput.has(model.name)) sdkModelOutPaths.set(`${model.name}Input`, typeOutPath);
+        if (modelsWithOutput.has(model.name)) sdkModelOutPaths.set(`${model.name}Output`, typeOutPath);
+      }
+    }
+    for (const { ast, typeOutPath } of sdkContractEntries) {
+      let content;
+      if (config.zod) {
+        content = generateContract(ast, {
+          modelOutPaths: sdkModelOutPaths,
+          currentOutPath: typeOutPath,
+          modelsWithInput,
+          modelsWithOutput
+        });
+      } else {
+        let rel = relative6(dirname6(typeOutPath), sdkOptionsPath).replace(/\.ts$/, ".js");
+        if (!rel.startsWith(".")) rel = "./" + rel;
+        content = generatePlainTypes(ast, {
+          modelOutPaths: sdkModelOutPaths,
+          currentOutPath: typeOutPath,
+          modelsWithInput,
+          modelsWithOutput,
+          jsonValueImportPath: rel
+        });
+      }
+      emitFile(typeOutPath, content);
+    }
+  }
+  if (config.output?.clients) {
+    for (const ast of inputs.opRoots) {
+      const sdkOutPath = computeSdkOutPath(ast.file, sdkBase, config.output.clients, ckCommonRoot, ast.meta);
+      if (!sdkOutPath || !hasPublicOperations(ast, config.includeInternal)) continue;
+      sdkClientInfos.push({
+        outPath: sdkOutPath,
+        className: deriveClientClassName(ast.file),
+        propertyName: deriveClientPropertyName(ast.file)
+      });
+      emitFile(sdkOutPath, generateSdk(ast, {
+        typeImportPathTemplate: void 0,
+        outPath: sdkOutPath,
+        modelOutPaths: sdkModelOutPaths,
+        sdkOptionsPath,
+        modelsWithInput,
+        modelsWithOutput,
+        includeInternal: config.includeInternal
+      }));
+    }
+  }
+  emitFile(sdkOptionsPath, generateSdkOptions());
+  if (sdkClientInfos.length > 0) {
+    const sdkEntryDir = dirname6(sdkEntryPath);
+    const clients = sdkClientInfos.map((c) => {
+      let rel = relative6(sdkEntryDir, c.outPath).replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      return {
+        className: c.className,
+        propertyName: c.propertyName,
+        importPath: rel
+      };
+    });
+    const sdkOptionsRel = relative6(sdkEntryDir, sdkOptionsPath).replace(/\.ts$/, ".js");
+    const sdkClassName = sdkName ? sdkName.split(/[-._\s]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Sdk" : "Sdk";
+    emitFile(sdkEntryPath, generateSdkAggregator(clients, sdkOptionsRel.startsWith(".") ? sdkOptionsRel : "./" + sdkOptionsRel, sdkClassName));
+  }
+  const sdkSrcDir = dirname6(sdkEntryPath);
+  const sdkTypeBarrels = generateBarrelFiles(sdkTypePaths);
+  for (const barrel of sdkTypeBarrels) emitFile(barrel.outPath, barrel.content);
+  const rootExports = [
+    `export * from './${basename3(sdkOptionsPath).replace(/\.ts$/, ".js")}';`
+  ];
+  if (sdkClientInfos.length > 0) {
+    rootExports.push(`export * from './${basename3(sdkEntryPath).replace(/\.ts$/, ".js")}';`);
+  }
+  for (const c of sdkClientInfos) {
+    let rel = relative6(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");
+    if (!rel.startsWith(".")) rel = "./" + rel;
+    rootExports.push(`export * from '${rel}';`);
+  }
+  emitFile(join2(sdkSrcDir, "index.ts"), `// Auto-generated barrel file
+${rootExports.sort().join("\n")}
+`);
+}
+__name(runSdkGeneration, "runSdkGeneration");
+function runZodGeneration(config, rootDir, inputs, emitFile) {
+  const zodBase = resolve2(rootDir, config.baseDir ?? ".");
+  const allFiles = [
+    ...inputs.contractRoots.map((r) => r.file),
+    ...inputs.opRoots.map((r) => r.file)
+  ];
+  const commonRoot = commonDir(allFiles, rootDir);
+  const modelsWithInput = inputs.modelsWithInput;
+  const modelsWithOutput = inputs.modelsWithOutput;
+  const modelOutPaths = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const ast of inputs.contractRoots) {
+    const outPath = computeContractOutPath(ast.file, zodBase, config.output, ".schema.ts", commonRoot, ast.meta);
+    entries.push({
+      ast,
+      outPath
+    });
+    for (const model of ast.models) {
+      modelOutPaths.set(model.name, outPath);
+      if (modelsWithInput.has(model.name)) modelOutPaths.set(`${model.name}Input`, outPath);
+      if (modelsWithOutput.has(model.name)) modelOutPaths.set(`${model.name}Output`, outPath);
+    }
+  }
+  for (const { ast, outPath } of entries) {
+    const content = generateContract(ast, {
+      modelOutPaths,
+      currentOutPath: outPath,
+      modelsWithInput,
+      modelsWithOutput
+    });
+    emitFile(outPath, content);
+  }
+}
+__name(runZodGeneration, "runZodGeneration");
+function runTypesGeneration(config, rootDir, inputs, emitFile) {
+  const typesBase = resolve2(rootDir, config.baseDir ?? ".");
+  const allFiles = [
+    ...inputs.contractRoots.map((r) => r.file),
+    ...inputs.opRoots.map((r) => r.file)
+  ];
+  const commonRoot = commonDir(allFiles, rootDir);
+  const modelsWithInput = inputs.modelsWithInput;
+  const modelsWithOutput = inputs.modelsWithOutput;
+  const modelOutPaths = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const ast of inputs.contractRoots) {
+    const outPath = computeContractOutPath(ast.file, typesBase, config.output, ".types.ts", commonRoot, ast.meta);
+    entries.push({
+      ast,
+      outPath
+    });
+    for (const model of ast.models) {
+      modelOutPaths.set(model.name, outPath);
+      if (modelsWithInput.has(model.name)) modelOutPaths.set(`${model.name}Input`, outPath);
+      if (modelsWithOutput.has(model.name)) modelOutPaths.set(`${model.name}Output`, outPath);
+    }
+  }
+  for (const { ast, outPath } of entries) {
+    const content = generatePlainTypes(ast, {
+      modelOutPaths,
+      currentOutPath: outPath,
+      modelsWithInput,
+      modelsWithOutput
+    });
+    emitFile(outPath, content);
+  }
+}
+__name(runTypesGeneration, "runTypesGeneration");
+var plugin = {
+  name: "typescript",
+  cacheKey: "typescript",
+  async generateTargets(inputs, ctx) {
+    const config = ctx.options;
+    if (config.server) {
+      runServerGeneration(config.server, ctx.rootDir, inputs, ctx.emitFile.bind(ctx));
+    }
+    if (config.sdk) {
+      runSdkGeneration(config.sdk, ctx.rootDir, inputs, ctx.emitFile.bind(ctx));
+    }
+    if (config.zod) {
+      runZodGeneration(config.zod, ctx.rootDir, inputs, ctx.emitFile.bind(ctx));
+    }
+    if (config.types) {
+      runTypesGeneration(config.types, ctx.rootDir, inputs, ctx.emitFile.bind(ctx));
+    }
+  }
+};
+var index_default = plugin;
+function createTypescriptPlugin(config, rootDir) {
+  return {
+    name: "typescript",
+    cacheKey: `typescript:${JSON.stringify(config)}`,
+    async generateTargets(inputs, ctx) {
+      if (config.server) {
+        runServerGeneration(config.server, rootDir, inputs, ctx.emitFile.bind(ctx));
+      }
+      if (config.sdk) {
+        runSdkGeneration(config.sdk, rootDir, inputs, ctx.emitFile.bind(ctx));
+      }
+      if (config.zod) {
+        runZodGeneration(config.zod, rootDir, inputs, ctx.emitFile.bind(ctx));
+      }
+      if (config.types) {
+        runTypesGeneration(config.types, rootDir, inputs, ctx.emitFile.bind(ctx));
+      }
+    }
+  };
+}
+__name(createTypescriptPlugin, "createTypescriptPlugin");
+export {
+  createTypescriptPlugin,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map