@contractkit/plugin-typescript 0.18.0 → 0.19.1

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";
@@ -3103,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({
@@ -3124,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;
@@ -3165,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;
@@ -3194,28 +3370,52 @@ 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 = [];
@@ -3249,28 +3449,48 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
         });
       }
     }
-    for (const { ast, outPath, subarea } of [
-      ...areaBuckets.entries()
-    ].flatMap(([area, b]) => b.leaves.map((l) => ({
-      ...l,
-      area
-    })))) {
-      const className = deriveSubareaClientClassName(ast.meta?.area ?? "", subarea);
-      sdkClientInfos.push({
-        outPath,
-        className,
-        propertyName: deriveSubareaPropertyName(subarea)
-      });
-      emitFile(outPath, generateSdk(ast, {
-        typeImportPathTemplate: void 0,
-        outPath,
-        modelOutPaths: sdkModelOutPaths,
-        sdkOptionsPath,
-        modelsWithInput,
-        modelsWithOutput,
-        includeInternal: config.includeInternal,
-        clientClassName: className
-      }));
+    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);
@@ -3279,18 +3499,43 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
         className,
         propertyName: deriveClientPropertyName(ast.file)
       });
-      emitFile(outPath, generateSdk(ast, {
-        typeImportPathTemplate: void 0,
+      const refs = collectOpRootRefs(ast, modelMap);
+      const fingerprint = hashFingerprint({
+        kind: "sdk-top-client",
+        v: TYPESCRIPT_CODEGEN_VERSION,
         outPath,
-        modelOutPaths: sdkModelOutPaths,
+        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());
+  globalFiles.push({
+    relativePath: sdkOptionsPath,
+    content: generateSdkOptions()
+  });
   const hasAnything = sdkClientInfos.length > 0 || areaBuckets.size > 0;
   if (hasAnything) {
     const sdkEntryDir = dirname6(sdkEntryPath);
@@ -3339,22 +3584,26 @@ function runSdkGeneration(config, rootDir, inputs, emitFile) {
         })
       }))
     }));
-    emitFile(sdkEntryPath, generateSdkAggregator({
-      topLevelClients,
-      areas,
-      sdkOptionsImportPath,
-      sdkClassName
-    }));
+    globalFiles.push({
+      relativePath: sdkEntryPath,
+      content: generateSdkAggregator({
+        topLevelClients,
+        areas,
+        sdkOptionsImportPath,
+        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 (hasAnything) {
-    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;
@@ -3365,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),
@@ -3379,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) {
@@ -3394,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),
@@ -3413,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) {
@@ -3428,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
 };