@contractkit/plugin-typescript 0.17.5 → 0.19.0

package/dist/index.js

@@ -3,6 +3,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { resolve as resolve2, join as join2, relative as relative6, dirname as dirname6, basename as basename3 } from "path";
+import { existsSync, readFileSync, rmSync, readdirSync, rmdirSync } from "fs";
 
 // src/codegen-contract.ts
 import { relative, dirname } from "path";
@@ -1734,6 +1735,9 @@ function deriveTypeImportPath(file, template) {
 }
 __name(deriveTypeImportPath, "deriveTypeImportPath");
 
+// src/index.ts
+import { runIncrementalCodegen, parseIncrementalManifest, emptyIncrementalManifest, hashFingerprint, collectTransitiveModelRefs } from "@contractkit/core";
+
 // 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";
@@ -1798,7 +1802,7 @@ 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);
+  const clientClassName = options.clientClassName ?? deriveClientClassName(root.file);
   if (types.length > 0) {
     lines.push(...generateTypeImports2(types, root.file, options));
   }
@@ -1899,6 +1903,26 @@ function generateSdk(root, options = {}) {
   return lines.join("\n");
 }
 __name(generateSdk, "generateSdk");
+function generateClientMethods(root, options) {
+  const lines = [];
+  const methodNames = [];
+  const includeInternal = options.includeInternal ?? false;
+  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));
+      methodNames.push(deriveMethodName(op, route));
+    }
+  }
+  return {
+    lines,
+    methodNames
+  };
+}
+__name(generateClientMethods, "generateClientMethods");
 function generateMethod(route, op, file, options) {
   const lines = [];
   const methodName = deriveMethodName(op, route);
@@ -2202,6 +2226,38 @@ function deriveClientPropertyName(file) {
   return base.charAt(0).toLowerCase() + base.slice(1);
 }
 __name(deriveClientPropertyName, "deriveClientPropertyName");
+function getAreaSubarea(root) {
+  return {
+    area: root.meta?.area,
+    subarea: root.meta?.subarea
+  };
+}
+__name(getAreaSubarea, "getAreaSubarea");
+function pascal(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+__name(pascal, "pascal");
+function camel(value) {
+  const p = pascal(value);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+__name(camel, "camel");
+function deriveAreaClientClassName(area) {
+  return `${pascal(area)}Client`;
+}
+__name(deriveAreaClientClassName, "deriveAreaClientClassName");
+function deriveAreaPropertyName(area) {
+  return camel(area);
+}
+__name(deriveAreaPropertyName, "deriveAreaPropertyName");
+function deriveSubareaClientClassName(area, subarea) {
+  return `${pascal(area)}${pascal(subarea)}Client`;
+}
+__name(deriveSubareaClientClassName, "deriveSubareaClientClassName");
+function deriveSubareaPropertyName(subarea) {
+  return camel(subarea);
+}
+__name(deriveSubareaPropertyName, "deriveSubareaPropertyName");
 function collectTypes2(root, modelsWithInput, modelsWithOutput, includeInternal = false) {
   const types = /* @__PURE__ */ new Set();
   for (const route of root.routes) {
@@ -2516,22 +2572,128 @@ function generateSdkOptions() {
   ].join("\n");
 }
 __name(generateSdkOptions, "generateSdkOptions");
-function generateSdkAggregator(clients, sdkOptionsImportPath = "./sdk-options.js", sdkClassName = "Sdk") {
+function generateSdkAggregator(input) {
+  const sdkOptionsImportPath = input.sdkOptionsImportPath ?? "./sdk-options.js";
+  const sdkClassName = input.sdkClassName ?? "Sdk";
+  const inlinedByArea = /* @__PURE__ */ new Map();
+  const typesByImportPath = /* @__PURE__ */ new Map();
+  const unresolvedTypes = /* @__PURE__ */ new Set();
+  let needsJson = false;
+  let needsBigIntReplacer = false;
+  let needsBigIntReviver = false;
+  let needsQueryString = false;
+  for (const area of input.areas) {
+    const collected = [];
+    const seenMethods = /* @__PURE__ */ new Set();
+    for (const inline of area.inlineFiles) {
+      const includeInternal = inline.codegenOptions.includeInternal ?? false;
+      const { lines: methodLines, methodNames } = generateClientMethods(inline.root, inline.codegenOptions);
+      for (const name of methodNames) {
+        if (seenMethods.has(name)) {
+          throw new Error(`[sdk] duplicate method '${name}' in area '${area.area}': two area-level files contribute the same method. Disambiguate via 'sdk:' or move one into a subarea.`);
+        }
+        seenMethods.add(name);
+      }
+      collected.push(...methodLines);
+      if (sdkNeedsJson(inline.root, includeInternal)) needsJson = true;
+      if (sdkNeedsBigIntReplacer(inline.root, includeInternal)) needsBigIntReplacer = true;
+      if (sdkNeedsBigIntReviver(inline.root, includeInternal)) needsBigIntReviver = true;
+      if (sdkNeedsQueryString(inline.root, includeInternal)) needsQueryString = true;
+      const typesForFile = collectTypes2(inline.root, inline.codegenOptions.modelsWithInput, inline.codegenOptions.modelsWithOutput, includeInternal);
+      const { modelOutPaths, outPath } = inline.codegenOptions;
+      if (modelOutPaths && outPath) {
+        const fromDir = dirname3(outPath);
+        for (const t of typesForFile) {
+          const typeOutPath = modelOutPaths.get(t);
+          if (typeOutPath) {
+            let rel = relative3(fromDir, typeOutPath).replace(/\.ts$/, ".js");
+            if (!rel.startsWith(".")) rel = "./" + rel;
+            const set = typesByImportPath.get(rel) ?? /* @__PURE__ */ new Set();
+            set.add(t);
+            typesByImportPath.set(rel, set);
+          } else {
+            unresolvedTypes.add(t);
+          }
+        }
+      }
+    }
+    inlinedByArea.set(area.area, {
+      lines: collected,
+      methodNames: seenMethods
+    });
+  }
   const lines = [];
+  const jsonImport = needsJson ? ", JsonValue" : "";
+  lines.push(`import type { SdkFetch${jsonImport} } from '${sdkOptionsImportPath}';`);
+  const valueImports = [];
+  if (needsBigIntReplacer) valueImports.push("bigIntReplacer");
+  if (needsBigIntReviver) valueImports.push("parseJson");
+  if (needsQueryString) valueImports.push("buildQueryString");
+  if (valueImports.length > 0) {
+    lines.push(`import { ${valueImports.join(", ")} } from '${sdkOptionsImportPath}';`);
+  }
   lines.push(`import type { SdkOptions } from '${sdkOptionsImportPath}';`);
   lines.push(`import { createSdkFetch } from '${sdkOptionsImportPath}';`);
-  for (const c of clients) {
+  const typeImportPaths = [
+    ...typesByImportPath.keys()
+  ].sort();
+  for (const path of typeImportPaths) {
+    const names = [
+      ...typesByImportPath.get(path)
+    ].sort();
+    lines.push(`import type { ${names.join(", ")} } from '${path}';`);
+  }
+  for (const t of [
+    ...unresolvedTypes
+  ].sort()) {
+    lines.push(`import type { ${t} } from './${pascalToDotCase(t)}.js';`);
+  }
+  const importedClients = /* @__PURE__ */ new Set();
+  const pushClientImport = /* @__PURE__ */ __name((c) => {
+    const key = `${c.className}|${c.importPath}`;
+    if (importedClients.has(key)) return;
+    importedClients.add(key);
     lines.push(`import { ${c.className} } from '${c.importPath}';`);
+  }, "pushClientImport");
+  for (const c of input.topLevelClients) pushClientImport(c);
+  for (const area of input.areas) {
+    for (const sc of area.subareaClients) pushClientImport(sc.client);
   }
   lines.push("");
+  for (const area of input.areas) {
+    const areaClassName = deriveAreaClientClassName(area.area);
+    const inlined = inlinedByArea.get(area.area);
+    lines.push(`class ${areaClassName} {`);
+    for (const sc of area.subareaClients) {
+      lines.push(`    readonly ${sc.propertyName}: ${sc.client.className};`);
+    }
+    if (area.subareaClients.length > 0) lines.push("");
+    if (inlined.lines.length > 0 || area.subareaClients.length > 0) {
+      const fetchModifier = inlined.lines.length > 0 ? "private " : "";
+      lines.push(`    constructor(${fetchModifier}fetch: SdkFetch) {`);
+      for (const sc of area.subareaClients) {
+        lines.push(`        this.${sc.propertyName} = new ${sc.client.className}(fetch);`);
+      }
+      lines.push("    }");
+    }
+    for (const ln of inlined.lines) lines.push(ln);
+    lines.push("}");
+    lines.push("");
+  }
   lines.push(`export class ${sdkClassName} {`);
-  for (const c of clients) {
+  for (const area of input.areas) {
+    lines.push(`    readonly ${deriveAreaPropertyName(area.area)}: ${deriveAreaClientClassName(area.area)};`);
+  }
+  for (const c of input.topLevelClients) {
     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) {
+  for (const area of input.areas) {
+    lines.push(`        this.${deriveAreaPropertyName(area.area)} = new ${deriveAreaClientClassName(area.area)}(sdkFetch);`);
+  }
+  for (const c of input.topLevelClients) {
     lines.push(`        this.${c.propertyName} = new ${c.className}(sdkFetch);`);
   }
   lines.push("    }");
@@ -2945,19 +3107,149 @@ function computePubliclyReachableTypes(opAsts, contractAsts, modelsWithInput, mo
 __name(computePubliclyReachableTypes, "computePubliclyReachableTypes");
 
 // src/index.ts
-function runServerGeneration(config, rootDir, inputs, emitFile) {
+var TYPESCRIPT_CODEGEN_VERSION = "1";
+var MANIFEST_FILENAME = ".contractkit-typescript-manifest.json";
+var plugin = {
+  name: "typescript",
+  async generateTargets(inputs, ctx) {
+    const config = ctx.options;
+    await runTypescriptCodegen(inputs, ctx, config, ctx.rootDir);
+  }
+};
+var index_default = plugin;
+function createTypescriptPlugin(config, rootDir) {
+  return {
+    name: "typescript",
+    async generateTargets(inputs, ctx) {
+      await runTypescriptCodegen(inputs, ctx, config, rootDir);
+    }
+  };
+}
+__name(createTypescriptPlugin, "createTypescriptPlugin");
+async function runTypescriptCodegen(inputs, ctx, config, rootDir) {
+  const manifestPath = resolve2(rootDir, MANIFEST_FILENAME);
+  const prevManifest = ctx.cacheEnabled ? readManifest(manifestPath) : emptyIncrementalManifest(TYPESCRIPT_CODEGEN_VERSION);
+  const units = [];
+  const globalFiles = [];
+  if (config.server) collectServerOutput(config.server, rootDir, inputs, units);
+  if (config.sdk) collectSdkOutput(config.sdk, rootDir, inputs, units, globalFiles);
+  if (config.zod) collectZodOutput(config.zod, rootDir, inputs, units);
+  if (config.types) collectTypesOutput(config.types, rootDir, inputs, units);
+  const result = runIncrementalCodegen({
+    codegenVersion: TYPESCRIPT_CODEGEN_VERSION,
+    manifestFilename: manifestPath,
+    prevManifest,
+    globalFiles,
+    units,
+    // Paths are absolute, so existsSync works directly.
+    fileExists: existsSync
+  });
+  deleteStalePaths(result.deletedPaths);
+  for (const { relativePath, content } of result.filesToWrite) {
+    ctx.emitFile(relativePath, content);
+  }
+}
+__name(runTypescriptCodegen, "runTypescriptCodegen");
+function buildModelMap(contractRoots) {
+  const map = /* @__PURE__ */ new Map();
+  for (const root of contractRoots) {
+    for (const model of root.models) map.set(model.name, model);
+  }
+  return map;
+}
+__name(buildModelMap, "buildModelMap");
+function collectContractRootRefs(root, modelMap) {
+  const seeds = [];
+  for (const m of root.models) {
+    if (m.type) seeds.push(m.type);
+    for (const f of m.fields) seeds.push(f.type);
+    if (m.bases) {
+      for (const b of m.bases) seeds.push({
+        kind: "ref",
+        name: b
+      });
+    }
+  }
+  return collectTransitiveModelRefs(seeds, modelMap);
+}
+__name(collectContractRootRefs, "collectContractRootRefs");
+function collectOpRootRefs(root, modelMap) {
+  const seeds = [];
+  for (const route of root.routes) {
+    if (route.params) seeds.push(...paramSourceTypes(route.params));
+    for (const op of route.operations) {
+      if (op.query) seeds.push(...paramSourceTypes(op.query));
+      if (op.headers) seeds.push(...paramSourceTypes(op.headers));
+      if (op.request) {
+        for (const body of op.request.bodies) seeds.push(body.bodyType);
+      }
+      for (const resp of op.responses) {
+        if (resp.bodyType) seeds.push(resp.bodyType);
+        if (resp.headers) {
+          for (const h of resp.headers) seeds.push(h.type);
+        }
+      }
+    }
+  }
+  return collectTransitiveModelRefs(seeds, modelMap);
+}
+__name(collectOpRootRefs, "collectOpRootRefs");
+function paramSourceTypes(src) {
+  const out = [];
+  if (src.kind === "params") {
+    for (const n of src.nodes) out.push(n.type);
+  } else if (src.kind === "ref") {
+    out.push({
+      kind: "ref",
+      name: src.name
+    });
+  } else if (src.kind === "type") {
+    out.push(src.node);
+  }
+  return out;
+}
+__name(paramSourceTypes, "paramSourceTypes");
+function sliceOutPathMap(refs, modelOutPaths, modelsWithInput, modelsWithOutput) {
+  const slice = {};
+  for (const ref of [
+    ...refs
+  ].sort()) {
+    const p = modelOutPaths.get(ref);
+    if (p) slice[ref] = p;
+    if (modelsWithInput.has(ref)) {
+      const ip = modelOutPaths.get(`${ref}Input`);
+      if (ip) slice[`${ref}Input`] = ip;
+    }
+    if (modelsWithOutput.has(ref)) {
+      const op = modelOutPaths.get(`${ref}Output`);
+      if (op) slice[`${ref}Output`] = op;
+    }
+  }
+  return slice;
+}
+__name(sliceOutPathMap, "sliceOutPathMap");
+function sliceModelSet(refs, ownNames, set) {
+  const result = [];
+  for (const name of set) {
+    if (refs.has(name) || ownNames.has(name)) result.push(name);
+  }
+  return result.sort();
+}
+__name(sliceModelSet, "sliceModelSet");
+function collectServerOutput(config, rootDir, inputs, units) {
   const serverBase = resolve2(rootDir, config.baseDir ?? ".");
   const modelsWithInput = inputs.modelsWithInput;
   const modelsWithOutput = inputs.modelsWithOutput;
+  const modelMap = buildModelMap(inputs.contractRoots);
   const allFiles = [
     ...inputs.contractRoots.map((r) => r.file),
     ...inputs.opRoots.map((r) => r.file)
   ];
   const commonRoot = commonDir(allFiles, rootDir);
-  let serverModelOutPaths = /* @__PURE__ */ new Map();
+  const subConfigKey = stableSubConfig(config);
+  const serverModelOutPaths = /* @__PURE__ */ new Map();
+  const typeEntries = [];
   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({
@@ -2966,40 +3258,81 @@ function runServerGeneration(config, rootDir, inputs, emitFile) {
       });
       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);
-        }
+        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, typeOutPath } of typeEntries) {
+    const refs = collectContractRootRefs(ast, modelMap);
+    const ownNames = new Set(ast.models.map((m) => m.name));
+    const fingerprint = hashFingerprint({
+      kind: "server-types",
+      v: TYPESCRIPT_CODEGEN_VERSION,
+      outPath: typeOutPath,
+      root: ast,
+      outPathSlice: sliceOutPathMap(refs, serverModelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, ownNames, modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, ownNames, modelsWithOutput),
+      sub: subConfigKey
+    });
+    units.push({
+      key: `server-types::${typeOutPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => {
+        const renderCtx = {
+          modelOutPaths: serverModelOutPaths,
+          currentOutPath: typeOutPath,
+          modelsWithInput,
+          modelsWithOutput
+        };
+        const content = config.zod ? generateContract(ast, renderCtx) : generatePlainTypes(ast, renderCtx);
+        return [
+          {
+            relativePath: typeOutPath,
+            content
+          }
+        ];
+      }, "render")
+    });
   }
   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,
+    const refs = collectOpRootRefs(ast, modelMap);
+    const fingerprint = hashFingerprint({
+      kind: "server-router",
+      v: TYPESCRIPT_CODEGEN_VERSION,
       outPath,
-      modelOutPaths: serverModelOutPaths,
-      modelsWithInput,
-      modelsWithOutput,
-      includeInternal: config.includeInternal
+      root: ast,
+      // The router imports types from each contract root's type file; the slice covers exactly that.
+      outPathSlice: sliceOutPathMap(refs, serverModelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithOutput),
+      servicePathTemplate: config.servicePathTemplate ?? null,
+      includeInternal: config.includeInternal ?? true,
+      sub: subConfigKey
+    });
+    units.push({
+      key: `server-router::${outPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: outPath,
+          content: generateOp(ast, {
+            servicePathTemplate: config.servicePathTemplate,
+            outPath,
+            modelOutPaths: serverModelOutPaths,
+            modelsWithInput,
+            modelsWithOutput,
+            includeInternal: config.includeInternal
+          })
+        }
+      ], "render")
     });
-    emitFile(outPath, content);
   }
 }
-__name(runServerGeneration, "runServerGeneration");
-function runSdkGeneration(config, rootDir, inputs, emitFile) {
+__name(collectServerOutput, "collectServerOutput");
+function collectSdkOutput(config, rootDir, inputs, units, globalFiles) {
   const sdkBase = config.baseDir ? resolve2(rootDir, config.baseDir) : rootDir;
   const sdkName = config.name;
   const sdkOutput = config.output?.sdk;
@@ -3007,20 +3340,21 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
     name: sdkName ?? "sdk"
   }) : sdkOutput) : join2(sdkBase, "sdk.ts");
   const sdkOptionsPath = join2(dirname6(sdkEntryPath), "sdk-options.ts");
+  const subConfigKey = stableSubConfig(config);
   const modelsWithInput = inputs.modelsWithInput;
   const modelsWithOutput = inputs.modelsWithOutput;
+  const modelMap = buildModelMap(inputs.contractRoots);
   const allFiles = [
     ...inputs.contractRoots.map((r) => r.file),
     ...inputs.opRoots.map((r) => r.file)
   ];
   const ckCommonRoot = commonDir(allFiles, rootDir);
-  let sdkModelOutPaths = /* @__PURE__ */ new Map();
+  const sdkModelOutPaths = /* @__PURE__ */ new Map();
   const sdkTypePaths = [];
   const sdkClientInfos = [];
+  const sdkContractEntries = [];
   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;
@@ -3036,74 +3370,240 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
         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);
-    }
   }
+  for (const { ast, typeOutPath } of sdkContractEntries) {
+    const refs = collectContractRootRefs(ast, modelMap);
+    const ownNames = new Set(ast.models.map((m) => m.name));
+    const fingerprint = hashFingerprint({
+      kind: "sdk-types",
+      v: TYPESCRIPT_CODEGEN_VERSION,
+      outPath: typeOutPath,
+      root: ast,
+      outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, ownNames, modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, ownNames, modelsWithOutput),
+      sdkOptionsPath,
+      sub: subConfigKey
+    });
+    units.push({
+      key: `sdk-types::${typeOutPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => {
+        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
+          });
+        }
+        return [
+          {
+            relativePath: typeOutPath,
+            content
+          }
+        ];
+      }, "render")
+    });
+  }
+  const areaBuckets = /* @__PURE__ */ new Map();
+  const topLevelEntries = [];
   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;
+      const { area, subarea } = getAreaSubarea(ast);
+      if (area && subarea) {
+        const bucket = areaBuckets.get(area) ?? {
+          leaves: [],
+          inlineRoots: []
+        };
+        bucket.leaves.push({
+          ast,
+          outPath: sdkOutPath,
+          subarea
+        });
+        areaBuckets.set(area, bucket);
+      } else if (area) {
+        const bucket = areaBuckets.get(area) ?? {
+          leaves: [],
+          inlineRoots: []
+        };
+        bucket.inlineRoots.push(ast);
+        areaBuckets.set(area, bucket);
+      } else {
+        topLevelEntries.push({
+          ast,
+          outPath: sdkOutPath
+        });
+      }
+    }
+    for (const [area, bucket] of areaBuckets.entries()) {
+      for (const leaf of bucket.leaves) {
+        const className = deriveSubareaClientClassName(area, leaf.subarea);
+        sdkClientInfos.push({
+          outPath: leaf.outPath,
+          className,
+          propertyName: deriveSubareaPropertyName(leaf.subarea)
+        });
+        const refs = collectOpRootRefs(leaf.ast, modelMap);
+        const fingerprint = hashFingerprint({
+          kind: "sdk-leaf-client",
+          v: TYPESCRIPT_CODEGEN_VERSION,
+          outPath: leaf.outPath,
+          root: leaf.ast,
+          outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
+          modelsWithInput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithInput),
+          modelsWithOutput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithOutput),
+          sdkOptionsPath,
+          className,
+          includeInternal: config.includeInternal ?? false,
+          sub: subConfigKey
+        });
+        units.push({
+          key: `sdk-leaf-client::${leaf.outPath}`,
+          fingerprint,
+          render: /* @__PURE__ */ __name(() => [
+            {
+              relativePath: leaf.outPath,
+              content: generateSdk(leaf.ast, {
+                typeImportPathTemplate: void 0,
+                outPath: leaf.outPath,
+                modelOutPaths: sdkModelOutPaths,
+                sdkOptionsPath,
+                modelsWithInput,
+                modelsWithOutput,
+                includeInternal: config.includeInternal,
+                clientClassName: className
+              })
+            }
+          ], "render")
+        });
+      }
+    }
+    for (const { ast, outPath } of topLevelEntries) {
+      const className = deriveClientClassName(ast.file);
       sdkClientInfos.push({
-        outPath: sdkOutPath,
-        className: deriveClientClassName(ast.file),
+        outPath,
+        className,
         propertyName: deriveClientPropertyName(ast.file)
       });
-      emitFile(sdkOutPath, generateSdk(ast, {
-        typeImportPathTemplate: void 0,
-        outPath: sdkOutPath,
-        modelOutPaths: sdkModelOutPaths,
+      const refs = collectOpRootRefs(ast, modelMap);
+      const fingerprint = hashFingerprint({
+        kind: "sdk-top-client",
+        v: TYPESCRIPT_CODEGEN_VERSION,
+        outPath,
+        root: ast,
+        outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
+        modelsWithInput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithInput),
+        modelsWithOutput: sliceModelSet(refs, /* @__PURE__ */ new Set(), modelsWithOutput),
         sdkOptionsPath,
-        modelsWithInput,
-        modelsWithOutput,
-        includeInternal: config.includeInternal
-      }));
+        includeInternal: config.includeInternal ?? false,
+        sub: subConfigKey
+      });
+      units.push({
+        key: `sdk-top-client::${outPath}`,
+        fingerprint,
+        render: /* @__PURE__ */ __name(() => [
+          {
+            relativePath: outPath,
+            content: generateSdk(ast, {
+              typeImportPathTemplate: void 0,
+              outPath,
+              modelOutPaths: sdkModelOutPaths,
+              sdkOptionsPath,
+              modelsWithInput,
+              modelsWithOutput,
+              includeInternal: config.includeInternal
+            })
+          }
+        ], "render")
+      });
     }
   }
-  emitFile(sdkOptionsPath, generateSdkOptions());
-  if (sdkClientInfos.length > 0) {
+  globalFiles.push({
+    relativePath: sdkOptionsPath,
+    content: generateSdkOptions()
+  });
+  const hasAnything = sdkClientInfos.length > 0 || areaBuckets.size > 0;
+  if (hasAnything) {
     const sdkEntryDir = dirname6(sdkEntryPath);
-    const clients = sdkClientInfos.map((c) => {
-      let rel = relative6(sdkEntryDir, c.outPath).replace(/\.ts$/, ".js");
+    const sdkOptionsRel = relative6(sdkEntryDir, sdkOptionsPath).replace(/\.ts$/, ".js");
+    const sdkOptionsImportPath = sdkOptionsRel.startsWith(".") ? sdkOptionsRel : "./" + sdkOptionsRel;
+    const sdkClassName = sdkName ? sdkName.split(/[-._\s]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Sdk" : "Sdk";
+    const toClientImport = /* @__PURE__ */ __name((info) => {
+      let rel = relative6(sdkEntryDir, info.outPath).replace(/\.ts$/, ".js");
       if (!rel.startsWith(".")) rel = "./" + rel;
       return {
-        className: c.className,
-        propertyName: c.propertyName,
+        className: info.className,
+        propertyName: info.propertyName,
         importPath: rel
       };
+    }, "toClientImport");
+    const topLevelClients = topLevelEntries.map((e) => ({
+      className: deriveClientClassName(e.ast.file),
+      propertyName: deriveClientPropertyName(e.ast.file),
+      importPath: (() => {
+        const rel = relative6(sdkEntryDir, e.outPath).replace(/\.ts$/, ".js");
+        return rel.startsWith(".") ? rel : "./" + rel;
+      })()
+    }));
+    const areas = [
+      ...areaBuckets.entries()
+    ].sort(([a], [b]) => a.localeCompare(b)).map(([area, bucket]) => ({
+      area,
+      inlineFiles: bucket.inlineRoots.map((root) => ({
+        root,
+        codegenOptions: {
+          typeImportPathTemplate: void 0,
+          outPath: sdkEntryPath,
+          modelOutPaths: sdkModelOutPaths,
+          sdkOptionsPath,
+          modelsWithInput,
+          modelsWithOutput,
+          includeInternal: config.includeInternal
+        }
+      })),
+      subareaClients: bucket.leaves.sort((a, b) => a.subarea.localeCompare(b.subarea)).map((l) => ({
+        propertyName: deriveSubareaPropertyName(l.subarea),
+        client: toClientImport({
+          outPath: l.outPath,
+          className: deriveSubareaClientClassName(area, l.subarea),
+          propertyName: deriveSubareaPropertyName(l.subarea)
+        })
+      }))
+    }));
+    globalFiles.push({
+      relativePath: sdkEntryPath,
+      content: generateSdkAggregator({
+        topLevelClients,
+        areas,
+        sdkOptionsImportPath,
+        sdkClassName
+      })
     });
-    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);
+  for (const barrel of sdkTypeBarrels) globalFiles.push({
+    relativePath: barrel.outPath,
+    content: barrel.content
+  });
   const rootExports = [
     `export * from './${basename3(sdkOptionsPath).replace(/\.ts$/, ".js")}';`
   ];
-  if (sdkClientInfos.length > 0) {
-    rootExports.push(`export * from './${basename3(sdkEntryPath).replace(/\.ts$/, ".js")}';`);
-  }
+  if (hasAnything) 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;
@@ -3114,12 +3614,15 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
     if (!rel.startsWith(".")) rel = "./" + rel;
     rootExports.push(`export * from '${rel}';`);
   }
-  emitFile(join2(sdkSrcDir, "index.ts"), `// Auto-generated barrel file
+  globalFiles.push({
+    relativePath: join2(sdkSrcDir, "index.ts"),
+    content: `// Auto-generated barrel file
 ${rootExports.sort().join("\n")}
-`);
+`
+  });
 }
-__name(runSdkGeneration, "runSdkGeneration");
-function runZodGeneration(config, rootDir, inputs, emitFile) {
+__name(collectSdkOutput, "collectSdkOutput");
+function collectZodOutput(config, rootDir, inputs, units) {
   const zodBase = resolve2(rootDir, config.baseDir ?? ".");
   const allFiles = [
     ...inputs.contractRoots.map((r) => r.file),
@@ -3128,6 +3631,8 @@ function runZodGeneration(config, rootDir, inputs, emitFile) {
   const commonRoot = commonDir(allFiles, rootDir);
   const modelsWithInput = inputs.modelsWithInput;
   const modelsWithOutput = inputs.modelsWithOutput;
+  const modelMap = buildModelMap(inputs.contractRoots);
+  const subConfigKey = stableSubConfig(config);
   const modelOutPaths = /* @__PURE__ */ new Map();
   const entries = [];
   for (const ast of inputs.contractRoots) {
@@ -3143,17 +3648,37 @@ function runZodGeneration(config, rootDir, inputs, emitFile) {
     }
   }
   for (const { ast, outPath } of entries) {
-    const content = generateContract(ast, {
-      modelOutPaths,
-      currentOutPath: outPath,
-      modelsWithInput,
-      modelsWithOutput
+    const refs = collectContractRootRefs(ast, modelMap);
+    const ownNames = new Set(ast.models.map((m) => m.name));
+    const fingerprint = hashFingerprint({
+      kind: "zod",
+      v: TYPESCRIPT_CODEGEN_VERSION,
+      outPath,
+      root: ast,
+      outPathSlice: sliceOutPathMap(refs, modelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, ownNames, modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, ownNames, modelsWithOutput),
+      sub: subConfigKey
+    });
+    units.push({
+      key: `zod::${outPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: outPath,
+          content: generateContract(ast, {
+            modelOutPaths,
+            currentOutPath: outPath,
+            modelsWithInput,
+            modelsWithOutput
+          })
+        }
+      ], "render")
     });
-    emitFile(outPath, content);
   }
 }
-__name(runZodGeneration, "runZodGeneration");
-function runTypesGeneration(config, rootDir, inputs, emitFile) {
+__name(collectZodOutput, "collectZodOutput");
+function collectTypesOutput(config, rootDir, inputs, units) {
   const typesBase = resolve2(rootDir, config.baseDir ?? ".");
   const allFiles = [
     ...inputs.contractRoots.map((r) => r.file),
@@ -3162,6 +3687,8 @@ function runTypesGeneration(config, rootDir, inputs, emitFile) {
   const commonRoot = commonDir(allFiles, rootDir);
   const modelsWithInput = inputs.modelsWithInput;
   const modelsWithOutput = inputs.modelsWithOutput;
+  const modelMap = buildModelMap(inputs.contractRoots);
+  const subConfigKey = stableSubConfig(config);
   const modelOutPaths = /* @__PURE__ */ new Map();
   const entries = [];
   for (const ast of inputs.contractRoots) {
@@ -3177,58 +3704,79 @@ function runTypesGeneration(config, rootDir, inputs, emitFile) {
     }
   }
   for (const { ast, outPath } of entries) {
-    const content = generatePlainTypes(ast, {
-      modelOutPaths,
-      currentOutPath: outPath,
-      modelsWithInput,
-      modelsWithOutput
+    const refs = collectContractRootRefs(ast, modelMap);
+    const ownNames = new Set(ast.models.map((m) => m.name));
+    const fingerprint = hashFingerprint({
+      kind: "plain-types",
+      v: TYPESCRIPT_CODEGEN_VERSION,
+      outPath,
+      root: ast,
+      outPathSlice: sliceOutPathMap(refs, modelOutPaths, modelsWithInput, modelsWithOutput),
+      modelsWithInput: sliceModelSet(refs, ownNames, modelsWithInput),
+      modelsWithOutput: sliceModelSet(refs, ownNames, modelsWithOutput),
+      sub: subConfigKey
+    });
+    units.push({
+      key: `plain-types::${outPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: outPath,
+          content: generatePlainTypes(ast, {
+            modelOutPaths,
+            currentOutPath: outPath,
+            modelsWithInput,
+            modelsWithOutput
+          })
+        }
+      ], "render")
     });
-    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));
+__name(collectTypesOutput, "collectTypesOutput");
+function readManifest(manifestPath) {
+  if (!existsSync(manifestPath)) return emptyIncrementalManifest(TYPESCRIPT_CODEGEN_VERSION);
+  try {
+    return parseIncrementalManifest(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return emptyIncrementalManifest(TYPESCRIPT_CODEGEN_VERSION);
+  }
+}
+__name(readManifest, "readManifest");
+function deleteStalePaths(absPaths) {
+  if (absPaths.length === 0) return;
+  const removedDirs = /* @__PURE__ */ new Set();
+  for (const abs of absPaths) {
+    if (existsSync(abs)) {
+      rmSync(abs, {
+        force: true
+      });
+      removedDirs.add(dirname6(abs));
     }
   }
-};
-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));
+  for (const dir of removedDirs) {
+    let current = dir;
+    while (current.length > 1) {
+      try {
+        if (readdirSync(current).length === 0) {
+          rmdirSync(current);
+          current = dirname6(current);
+        } else {
+          break;
+        }
+      } catch {
+        break;
       }
     }
-  };
+  }
 }
-__name(createTypescriptPlugin, "createTypescriptPlugin");
+__name(deleteStalePaths, "deleteStalePaths");
+function stableSubConfig(config) {
+  return JSON.stringify(config ?? null);
+}
+__name(stableSubConfig, "stableSubConfig");
 export {
+  TYPESCRIPT_CODEGEN_VERSION,
   createTypescriptPlugin,
   index_default as default
 };