@ic-reactor/codegen 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,18 +1,248 @@
-import {
-  generateCodecDeclarations
-} from "./chunk-VBCR5IVT.js";
-
 // src/pipeline.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path3 from "path";
 
 // src/generators/declarations.ts
 import { didToJs, didToTs } from "@ic-reactor/parser";
-import path from "path";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/validate.ts
 import fs from "fs";
+import path from "path";
+
+// src/naming.ts
+import { camelCase, pascalCase } from "change-case";
+function toPascalCase(str) {
+  return pascalCase(str);
+}
+function toCamelCase(str) {
+  return camelCase(str);
+}
+function getReactorName(canisterName) {
+  return `${toCamelCase(canisterName)}Reactor`;
+}
+function getServiceTypeName(canisterName) {
+  return `${toPascalCase(canisterName)}Service`;
+}
+function getHookPrefix(canisterName) {
+  return toPascalCase(canisterName);
+}
+
+// src/validate.ts
+var CodegenConfigError = class extends Error {
+  name = "CodegenConfigError";
+  constructor(message) {
+    super(message);
+  }
+};
+var CANISTER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var MAX_CANISTER_NAME_LENGTH = 64;
+var HAS_URI_SCHEME = /^(?:[A-Za-z][A-Za-z0-9+.-]*:|\/\/)/;
+var BREAKS_OUT_OF_LITERAL = /["'`\\\u0000-\u001f\u2028\u2029]/;
+function assertSafeCanisterName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new CodegenConfigError(
+      `Invalid canister name: expected a non-empty string, received ${name === void 0 ? "undefined" : JSON.stringify(name)}. Check the "canisters" entries in your ic-reactor.json (or the plugin's "canisters" option).`
+    );
+  }
+  if (name.length > MAX_CANISTER_NAME_LENGTH) {
+    throw new CodegenConfigError(
+      `Invalid canister name ${JSON.stringify(name)}: must be at most ${MAX_CANISTER_NAME_LENGTH} characters.`
+    );
+  }
+  if (!CANISTER_NAME_PATTERN.test(name)) {
+    throw new CodegenConfigError(
+      `Invalid canister name ${JSON.stringify(name)}: may contain only letters, digits, "_", "." and "-" (${CANISTER_NAME_PATTERN.source}). Canister names become directory names, so path separators, quotes and whitespace are not allowed.`
+    );
+  }
+  if (name === "." || name === "..") {
+    throw new CodegenConfigError(
+      `Invalid canister name ${JSON.stringify(name)}: refers to a directory, not a canister.`
+    );
+  }
+  if (toPascalCase(name).length === 0) {
+    throw new CodegenConfigError(
+      `Invalid canister name ${JSON.stringify(name)}: contains no letters or digits, so it collapses to an empty identifier in generated code.`
+    );
+  }
+  const derived = [
+    ["reactor constant", getReactorName(name)],
+    ["service type", getServiceTypeName(name)],
+    ["hook name", `use${getHookPrefix(name)}Query`]
+  ];
+  for (const [what, identifier] of derived) {
+    if (!IDENTIFIER_PATTERN.test(identifier)) {
+      throw new CodegenConfigError(
+        `Invalid canister name ${JSON.stringify(name)}: it derives the ${what} ${JSON.stringify(identifier)}, which is not a valid TypeScript identifier. Rename the canister so it does not begin with a digit.`
+      );
+    }
+  }
+}
+function assertSafeModuleSpecifier(label, specifier) {
+  if (typeof specifier !== "string" || specifier.length === 0) {
+    throw new CodegenConfigError(
+      `Invalid ${label}: expected a non-empty string, received ${specifier === void 0 ? "undefined" : JSON.stringify(specifier)}.`
+    );
+  }
+  if (BREAKS_OUT_OF_LITERAL.test(specifier)) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(specifier)}: must not contain quotes, backslashes or control characters.`
+    );
+  }
+  if (/^\s|\s$/.test(specifier)) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(specifier)}: must not begin or end with whitespace.`
+    );
+  }
+  if (HAS_URI_SCHEME.test(specifier.trim())) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(specifier)}: must be a relative path ("./\u2026", "../\u2026") or a bare package name. URLs are not allowed \u2014 the generated file imports from this specifier.`
+    );
+  }
+}
+function resolveDeclarationsBaseName(didFile) {
+  if (typeof didFile !== "string" || didFile.length === 0) {
+    throw new CodegenConfigError(
+      `Invalid didFile: expected a non-empty string, received ${didFile === void 0 ? "undefined" : JSON.stringify(didFile)}.`
+    );
+  }
+  const baseName = path.basename(didFile, ".did");
+  if (baseName === "" || baseName === "." || baseName === "..") {
+    throw new CodegenConfigError(
+      `Invalid didFile ${JSON.stringify(didFile)}: its file name ${JSON.stringify(baseName)} refers to a directory, not a Candid file. Generated declarations are named after the .did file, so this would emit an import of a directory.`
+    );
+  }
+  assertSafeModuleSpecifier(
+    `declarations import derived from didFile ${JSON.stringify(didFile)}`,
+    `./declarations/${baseName}`
+  );
+  return baseName;
+}
+var REACTOR_CLASS_NAMES = [
+  "Reactor",
+  "DisplayReactor",
+  "CandidReactor",
+  "CandidDisplayReactor",
+  "MetadataDisplayReactor"
+];
+var CODEGEN_TARGETS = ["react", "core"];
+function assertOneOf(label, value, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(value)}: must be one of ${allowed.map((a) => JSON.stringify(a)).join(", ")}.`
+    );
+  }
+}
+function realpathAllowingMissing(target) {
+  let current = path.resolve(target);
+  const missing = [];
+  for (; ; ) {
+    try {
+      return path.join(fs.realpathSync(current), ...missing);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return path.resolve(target);
+      missing.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}
+function assertContainedPath(label, resolved, projectRoot, original = resolved) {
+  const relative = path.relative(
+    realpathAllowingMissing(projectRoot),
+    realpathAllowingMissing(resolved)
+  );
+  const [firstSegment] = relative.split(/[\\/]/);
+  if (firstSegment === ".." || path.isAbsolute(relative)) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(original)}: resolves to ${JSON.stringify(resolved)}, which is outside the project root ${JSON.stringify(path.resolve(projectRoot))}. Generated output must stay inside the project \u2014 generated directories are deleted and rewritten on every run.`
+    );
+  }
+}
+function resolveContainedOutDir(label, outDir, projectRoot) {
+  if (typeof outDir !== "string" || outDir.length === 0) {
+    throw new CodegenConfigError(
+      `Invalid ${label}: expected a non-empty string, received ${outDir === void 0 ? "undefined" : JSON.stringify(outDir)}.`
+    );
+  }
+  const resolved = path.isAbsolute(outDir) ? path.resolve(outDir) : path.resolve(projectRoot, outDir);
+  assertContainedPath(label, resolved, projectRoot, outDir);
+  return resolved;
+}
+function assertSafeCanisterConfig(options) {
+  const {
+    name,
+    canisterOutDir,
+    globalOutDir,
+    clientManagerPath,
+    projectRoot,
+    mode,
+    target
+  } = options;
+  assertSafeCanisterName(name);
+  assertSafeModuleSpecifier("clientManagerPath", clientManagerPath);
+  if (mode != null) assertOneOf("mode", mode, REACTOR_CLASS_NAMES);
+  if (target != null) assertOneOf("target", target, CODEGEN_TARGETS);
+  const outDir = canisterOutDir != null ? resolveContainedOutDir(
+    `outDir for canister ${JSON.stringify(name)}`,
+    canisterOutDir,
+    projectRoot
+  ) : path.join(
+    resolveContainedOutDir("outDir", globalOutDir, projectRoot),
+    name
+  );
+  assertContainedPath(
+    `output directory for canister ${JSON.stringify(name)}`,
+    outDir,
+    projectRoot
+  );
+  return { name, outDir, clientManagerPath };
+}
+
+// src/generators/declarations.ts
+function replaceDirectory(from, to) {
+  if (!fs2.existsSync(to)) {
+    fs2.renameSync(from, to);
+    return;
+  }
+  const displaced = fs2.mkdtempSync(
+    path2.join(path2.dirname(to), `.${path2.basename(to)}.old-`)
+  );
+  fs2.rmdirSync(displaced);
+  fs2.renameSync(to, displaced);
+  try {
+    fs2.renameSync(from, to);
+  } catch (error) {
+    fs2.renameSync(displaced, to);
+    throw error;
+  }
+  fs2.rmSync(displaced, { recursive: true, force: true });
+}
+var HAS_IDL_FACTORY = /\bexport\s+const\s+idlFactory\b/;
+var OWNER_FILE = ".ic-reactor-owner";
 async function generateDeclarations(options) {
   const { didFile, outDir, canisterName } = options;
-  if (!fs.existsSync(didFile)) {
+  const declarationsDir = path2.join(outDir, "declarations");
+  let baseName;
+  try {
+    baseName = resolveDeclarationsBaseName(didFile);
+  } catch (error) {
+    if (error instanceof CodegenConfigError) {
+      return {
+        success: false,
+        declarationsDir: "",
+        files: [],
+        error: `[${canisterName}] ${error.message}`
+      };
+    }
+    throw error;
+  }
+  let didStat;
+  try {
+    didStat = fs2.statSync(didFile);
+  } catch {
     return {
       success: false,
       declarationsDir: "",
@@ -20,25 +250,39 @@ async function generateDeclarations(options) {
       error: `DID file not found: ${didFile}`
     };
   }
-  const declarationsDir = path.join(outDir, "declarations");
-  const baseName = path.basename(didFile, ".did");
+  if (!didStat.isFile()) {
+    return {
+      success: false,
+      declarationsDir: "",
+      files: [],
+      error: `[${canisterName}] DID path is not a regular file: ${didFile}`
+    };
+  }
+  let staging;
   try {
-    const didContent = fs.readFileSync(didFile, "utf-8");
-    if (!fs.existsSync(outDir)) {
-      fs.mkdirSync(outDir, { recursive: true });
-    }
-    if (fs.existsSync(declarationsDir)) {
-      fs.rmSync(declarationsDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(declarationsDir, { recursive: true });
+    const didContent = fs2.readFileSync(didFile, "utf-8");
     const jsContent = didToJs(didContent);
     const tsContent = didToTs(didContent);
-    const jsPath = path.join(declarationsDir, `${baseName}.js`);
-    const dtsPath = path.join(declarationsDir, `${baseName}.d.ts`);
-    const didCopyPath = path.join(declarationsDir, `${baseName}.did`);
-    fs.writeFileSync(jsPath, jsContent);
-    fs.writeFileSync(dtsPath, tsContent);
-    fs.writeFileSync(didCopyPath, didContent);
+    if (!HAS_IDL_FACTORY.test(jsContent)) {
+      return {
+        success: false,
+        declarationsDir,
+        files: [],
+        error: `[${canisterName}] ${didFile} produces no idlFactory, so there is no service to generate against. Point this canister at the .did file that declares its service.`
+      };
+    }
+    fs2.mkdirSync(outDir, { recursive: true });
+    fs2.writeFileSync(path2.join(outDir, OWNER_FILE), `${canisterName}
+`);
+    staging = fs2.mkdtempSync(path2.join(outDir, ".declarations.tmp-"));
+    const jsPath = path2.join(declarationsDir, `${baseName}.js`);
+    const dtsPath = path2.join(declarationsDir, `${baseName}.d.ts`);
+    const didCopyPath = path2.join(declarationsDir, `${baseName}.did`);
+    fs2.writeFileSync(path2.join(staging, `${baseName}.js`), jsContent);
+    fs2.writeFileSync(path2.join(staging, `${baseName}.d.ts`), tsContent);
+    fs2.writeFileSync(path2.join(staging, `${baseName}.did`), didContent);
+    replaceDirectory(staging, declarationsDir);
+    staging = void 0;
     return {
       success: true,
       declarationsDir,
@@ -56,29 +300,24 @@ async function generateDeclarations(options) {
       files: [],
       error: `[${canisterName}] Failed to generate declarations: ${message}`
     };
+  } finally {
+    if (staging) fs2.rmSync(staging, { recursive: true, force: true });
   }
 }
-function declarationsExist(outDir, canisterName) {
-  const dtsPath = path.join(outDir, "declarations", `${canisterName}.d.ts`);
-  return fs.existsSync(dtsPath);
-}
-
-// src/generators/reactor.ts
-import path2 from "path";
-
-// src/naming.ts
-import { camelCase, pascalCase } from "change-case";
-function toPascalCase(str) {
-  return pascalCase(str);
-}
-function toCamelCase(str) {
-  return camelCase(str);
-}
-function getReactorName(canisterName) {
-  return `${toCamelCase(canisterName)}Reactor`;
-}
-function getServiceTypeName(canisterName) {
-  return `${toPascalCase(canisterName)}Service`;
+function declarationsExist(outDir, canisterName, didFile) {
+  const declarationsDir = path2.join(outDir, "declarations");
+  if (didFile !== void 0) {
+    const baseName = path2.basename(didFile, ".did");
+    return fs2.existsSync(path2.join(declarationsDir, `${baseName}.d.ts`));
+  }
+  if (fs2.existsSync(path2.join(declarationsDir, `${canisterName}.d.ts`))) {
+    return true;
+  }
+  try {
+    return fs2.readdirSync(declarationsDir).some((entry) => entry.endsWith(".d.ts"));
+  } catch {
+    return false;
+  }
 }
 
 // src/generators/reactor.ts
@@ -91,6 +330,10 @@ function getReactorClassImportSource(reactorClass, runtimeTarget) {
     case "CandidDisplayReactor":
     case "MetadataDisplayReactor":
       return "@ic-reactor/candid";
+    default:
+      throw new Error(
+        `Unknown reactor class ${JSON.stringify(reactorClass)}. Expected one of: Reactor, DisplayReactor, CandidReactor, CandidDisplayReactor, MetadataDisplayReactor.`
+      );
   }
 }
 function generateReactorFile(options) {
@@ -105,7 +348,7 @@ function generateReactorFile(options) {
   const pascalName = toPascalCase(canisterName);
   const reactorName = getReactorName(canisterName);
   const serviceName = getServiceTypeName(canisterName);
-  const baseName = path2.basename(didFile, ".did");
+  const baseName = resolveDeclarationsBaseName(didFile);
   const declarationsPath = `./declarations/${baseName}`;
   const reactorImportSource = getReactorClassImportSource(
     reactorClass,
@@ -124,9 +367,9 @@ export const {
   useActorMethod: use${pascalName}Method,
 } = createActorHooks(${reactorName})
 ` : "";
-  return `${runtimeTarget === "react" ? 'import { createActorHooks } from "@ic-reactor/react"\n' : ""}import { ${reactorClass} } from "${reactorImportSource}"
-import { clientManager } from "${clientManagerPath}"
-import { idlFactory, type _SERVICE } from "${declarationsPath}"
+  return `${runtimeTarget === "react" ? 'import { createActorHooks } from "@ic-reactor/react"\n' : ""}import { ${reactorClass} } from ${JSON.stringify(reactorImportSource)}
+import { clientManager } from ${JSON.stringify(clientManagerPath)}
+import { idlFactory, type _SERVICE } from ${JSON.stringify(declarationsPath)}
 
 export type ${serviceName} = _SERVICE
 
@@ -142,7 +385,7 @@ export type ${serviceName} = _SERVICE
 export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
-${canisterIdLine}  name: "${canisterName}",
+${canisterIdLine}  name: ${JSON.stringify(canisterName)},
 })${hookExports || "\n"}`;
 }
 function generateReactorEntryFile() {
@@ -175,8 +418,48 @@ function resolveRuntimeTarget(canisterConfig, globalConfig) {
 function normalizeFileContent(content) {
   return content.replace(/\r\n/g, "\n").trim();
 }
-function isLegacyGeneratedIndexFile(content) {
-  return content.includes("Auto-generated by @ic-reactor/codegen") && content.includes("createActorHooks(");
+var GENERATED_MARKER = "Auto-generated by @ic-reactor/codegen";
+var GENERATED_CANISTER_NAME = /^ {2}name: "([A-Za-z0-9_.-]+)",$/m;
+var EXPORT_STATEMENT = /^export\b.*$/gm;
+function isLegacyGeneratedIndexFile(content, canisterName) {
+  if (!content.includes(GENERATED_MARKER)) return false;
+  const reactorName = getReactorName(canisterName);
+  const serviceName = getServiceTypeName(canisterName);
+  if (!content.includes(`export const ${reactorName} = new `)) return false;
+  if (!content.includes(`= createActorHooks(${reactorName})`)) return false;
+  const allowed = [
+    `export type ${serviceName} = _SERVICE`,
+    `export const ${reactorName} = new `,
+    // Opens the destructured hook block; its members are not export statements.
+    "export const {"
+  ];
+  const statements = normalizeFileContent(content).match(EXPORT_STATEMENT) ?? [];
+  return statements.every(
+    (statement) => allowed.some((prefix) => statement.startsWith(prefix))
+  );
+}
+function backUpFile(filePath) {
+  let backupPath = `${filePath}.bak`;
+  for (let n = 2; fs3.existsSync(backupPath); n += 1) {
+    backupPath = `${filePath}.bak.${n}`;
+  }
+  fs3.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function findOutDirOwner(outDir) {
+  try {
+    const owner = fs3.readFileSync(path3.join(outDir, OWNER_FILE), "utf-8").trim();
+    if (owner) return owner;
+  } catch {
+  }
+  let content;
+  try {
+    content = fs3.readFileSync(path3.join(outDir, "index.generated.ts"), "utf-8");
+  } catch {
+    return void 0;
+  }
+  if (!content.includes(GENERATED_MARKER)) return void 0;
+  return GENERATED_CANISTER_NAME.exec(content)?.[1];
 }
 function isManagedEntryWrapper(content, expectedEntryContent) {
   return normalizeFileContent(content) === normalizeFileContent(expectedEntryContent);
@@ -190,8 +473,30 @@ async function runCanisterPipeline(options) {
   } = options;
   const { name, didFile, clientManagerPath } = canisterConfig;
   const files = [];
+  let validated;
+  try {
+    validated = assertSafeCanisterConfig({
+      name,
+      canisterOutDir: canisterConfig.outDir,
+      globalOutDir: globalConfig.outDir,
+      clientManagerPath: clientManagerPath ?? globalConfig.clientManagerPath ?? "../../clients",
+      projectRoot,
+      mode: canisterConfig.mode,
+      target: canisterConfig.target ?? globalConfig.target
+    });
+  } catch (err) {
+    if (err instanceof CodegenConfigError) {
+      return {
+        canisterName: typeof name === "string" ? name : String(name),
+        success: false,
+        files,
+        error: err.message
+      };
+    }
+    throw err;
+  }
   const resolvedDidFile = path3.isAbsolute(didFile) ? didFile : path3.resolve(projectRoot, didFile);
-  if (!fs2.existsSync(resolvedDidFile)) {
+  if (!fs3.existsSync(resolvedDidFile)) {
     return {
       canisterName: name,
       success: false,
@@ -199,8 +504,30 @@ async function runCanisterPipeline(options) {
       error: `DID file not found: ${resolvedDidFile}`
     };
   }
-  const canisterOutDir = canisterConfig.outDir != null ? path3.isAbsolute(canisterConfig.outDir) ? canisterConfig.outDir : path3.resolve(projectRoot, canisterConfig.outDir) : path3.resolve(projectRoot, globalConfig.outDir, name);
-  const resolvedClientManagerPath = clientManagerPath ?? globalConfig.clientManagerPath ?? "../../clients";
+  try {
+    resolveDeclarationsBaseName(resolvedDidFile);
+  } catch (err) {
+    if (err instanceof CodegenConfigError) {
+      return {
+        canisterName: name,
+        success: false,
+        files,
+        error: `[${name}] ${err.message}`
+      };
+    }
+    throw err;
+  }
+  const canisterOutDir = validated.outDir;
+  const owner = findOutDirOwner(canisterOutDir);
+  if (owner !== void 0 && owner !== name) {
+    return {
+      canisterName: name,
+      success: false,
+      files,
+      error: `[${name}] Output directory ${canisterOutDir} was generated for canister "${owner}". Two canisters cannot share an outDir \u2014 each run replaces the declarations directory and index.generated.ts, so they would overwrite each other. Give each canister its own "outDir". If you renamed "${owner}" to "${name}", delete that directory and regenerate.`
+    };
+  }
+  const resolvedClientManagerPath = validated.clientManagerPath;
   try {
     const declResult = await generateDeclarations({
       didFile: resolvedDidFile,
@@ -245,16 +572,21 @@ async function runCanisterPipeline(options) {
       reactorClass
     });
     const entryContent = generateReactorEntryFile();
-    fs2.mkdirSync(canisterOutDir, { recursive: true });
-    fs2.writeFileSync(reactorPath, reactorContent);
+    fs3.mkdirSync(canisterOutDir, { recursive: true });
+    fs3.writeFileSync(reactorPath, reactorContent);
     files.push({ success: true, filePath: reactorPath });
-    if (!fs2.existsSync(entryPath)) {
-      fs2.writeFileSync(entryPath, entryContent);
+    if (!fs3.existsSync(entryPath)) {
+      fs3.writeFileSync(entryPath, entryContent);
       files.push({ success: true, filePath: entryPath });
     } else {
-      const existingEntryContent = fs2.readFileSync(entryPath, "utf-8");
-      if (isLegacyGeneratedIndexFile(existingEntryContent) || isManagedEntryWrapper(existingEntryContent, entryContent)) {
-        fs2.writeFileSync(entryPath, entryContent);
+      const existingEntryContent = fs3.readFileSync(entryPath, "utf-8");
+      if (isManagedEntryWrapper(existingEntryContent, entryContent)) {
+        fs3.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: entryPath });
+      } else if (isLegacyGeneratedIndexFile(existingEntryContent, name)) {
+        const backupPath = backUpFile(entryPath);
+        fs3.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: backupPath });
         files.push({ success: true, filePath: entryPath });
       } else {
         files.push({ success: true, filePath: entryPath, skipped: true });
@@ -280,40 +612,6 @@ async function runCanisterPipeline(options) {
   };
 }
 
-// src/parser.ts
-import { didToJs as didToJs2 } from "@ic-reactor/parser";
-import fs3 from "fs";
-function extractMethods(didContent) {
-  try {
-    const jsContent = didToJs2(didContent);
-    const methods = [];
-    const serviceMatch = /IDL\.Service\(\{([\s\S]*?)\}\)/.exec(jsContent);
-    if (!serviceMatch) return methods;
-    const serviceBody = serviceMatch[1];
-    const methodRegex = /['"]([\w]+)['"]\s*:\s*IDL\.Func\(\s*\[(.*?)\],\s*\[.*?\],\s*\[(.*?)\]\)/g;
-    let match;
-    while ((match = methodRegex.exec(serviceBody)) !== null) {
-      const [, name, args, annotations] = match;
-      methods.push({
-        name,
-        type: annotations.includes("'query'") ? "query" : "mutation",
-        hasArgs: args.trim().length > 0
-      });
-    }
-    return methods;
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse Candid: ${msg}`);
-  }
-}
-function parseDIDFile(didFilePath) {
-  if (!fs3.existsSync(didFilePath)) {
-    throw new Error(`DID file not found: ${didFilePath}`);
-  }
-  const content = fs3.readFileSync(didFilePath, "utf-8");
-  return extractMethods(content);
-}
-
 // src/generators/client.ts
 function generateClientFile(options = {}) {
   const { queryClientPath } = options;
@@ -335,16 +633,24 @@ export const clientManager = new ClientManager({
 `;
 }
 export {
+  CANISTER_NAME_PATTERN,
+  CODEGEN_TARGETS,
+  CodegenConfigError,
+  REACTOR_CLASS_NAMES,
+  assertContainedPath,
+  assertOneOf,
+  assertSafeCanisterConfig,
+  assertSafeCanisterName,
+  assertSafeModuleSpecifier,
   declarationsExist,
-  extractMethods,
   generateClientFile,
-  generateCodecDeclarations,
   generateDeclarations,
   generateReactorEntryFile,
   generateReactorFile,
   getReactorName,
   getServiceTypeName,
-  parseDIDFile,
+  resolveContainedOutDir,
+  resolveDeclarationsBaseName,
   runCanisterPipeline,
   toPascalCase
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/codegen",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Shared code generation utilities for IC Reactor",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -17,21 +17,15 @@
         "default": "./dist/index.cjs"
       }
     },
-    "./renderer": {
-      "import": {
-        "types": "./dist/renderer.d.ts",
-        "default": "./dist/renderer.js"
-      },
-      "require": {
-        "types": "./dist/renderer.d.cts",
-        "default": "./dist/renderer.cjs"
-      }
-    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/__snapshots__/**",
+    "!**/*.tsbuildinfo",
     "README.md",
     "llms.txt"
   ],
@@ -53,17 +47,17 @@
   "homepage": "https://ic-reactor.b3pay.net/v3/packages/codegen",
   "dependencies": {
     "change-case": "^5.4.4",
-    "@ic-reactor/parser": "0.4.7"
+    "@ic-reactor/parser": "0.4.8"
   },
   "devDependencies": {
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/renderer.ts --format esm,cjs --dts --tsconfig tsconfig.json",
-    "dev": "tsup src/index.ts src/renderer.ts --format esm,cjs --dts --watch --tsconfig tsconfig.json",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.json",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch --tsconfig tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"