@ic-reactor/codegen 0.12.0 → 0.13.0

package/dist/index.cjs

@@ -30,32 +30,274 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CANISTER_NAME_PATTERN: () => CANISTER_NAME_PATTERN,
+  CODEGEN_TARGETS: () => CODEGEN_TARGETS,
+  CodegenConfigError: () => CodegenConfigError,
+  REACTOR_CLASS_NAMES: () => REACTOR_CLASS_NAMES,
+  assertContainedPath: () => assertContainedPath,
+  assertOneOf: () => assertOneOf,
+  assertSafeCanisterConfig: () => assertSafeCanisterConfig,
+  assertSafeCanisterName: () => assertSafeCanisterName,
+  assertSafeModuleSpecifier: () => assertSafeModuleSpecifier,
   declarationsExist: () => declarationsExist,
-  extractMethods: () => extractMethods,
   generateClientFile: () => generateClientFile,
-  generateCodecDeclarations: () => generateCodecDeclarations,
   generateDeclarations: () => generateDeclarations,
   generateReactorEntryFile: () => generateReactorEntryFile,
   generateReactorFile: () => generateReactorFile,
   getReactorName: () => getReactorName,
   getServiceTypeName: () => getServiceTypeName,
-  parseDIDFile: () => parseDIDFile,
+  resolveContainedOutDir: () => resolveContainedOutDir,
+  resolveDeclarationsBaseName: () => resolveDeclarationsBaseName,
   runCanisterPipeline: () => runCanisterPipeline,
   toPascalCase: () => toPascalCase
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/pipeline.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
 
 // src/generators/declarations.ts
 var import_parser = require("@ic-reactor/parser");
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// src/validate.ts
 var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// src/naming.ts
+var import_change_case = require("change-case");
+function toPascalCase(str) {
+  return (0, import_change_case.pascalCase)(str);
+}
+function toCamelCase(str) {
+  return (0, import_change_case.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 = import_node_path.default.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 = import_node_path.default.resolve(target);
+  const missing = [];
+  for (; ; ) {
+    try {
+      return import_node_path.default.join(import_node_fs.default.realpathSync(current), ...missing);
+    } catch {
+      const parent = import_node_path.default.dirname(current);
+      if (parent === current) return import_node_path.default.resolve(target);
+      missing.unshift(import_node_path.default.basename(current));
+      current = parent;
+    }
+  }
+}
+function assertContainedPath(label, resolved, projectRoot, original = resolved) {
+  const relative = import_node_path.default.relative(
+    realpathAllowingMissing(projectRoot),
+    realpathAllowingMissing(resolved)
+  );
+  const [firstSegment] = relative.split(/[\\/]/);
+  if (firstSegment === ".." || import_node_path.default.isAbsolute(relative)) {
+    throw new CodegenConfigError(
+      `Invalid ${label} ${JSON.stringify(original)}: resolves to ${JSON.stringify(resolved)}, which is outside the project root ${JSON.stringify(import_node_path.default.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 = import_node_path.default.isAbsolute(outDir) ? import_node_path.default.resolve(outDir) : import_node_path.default.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
+  ) : import_node_path.default.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 (!import_node_fs2.default.existsSync(to)) {
+    import_node_fs2.default.renameSync(from, to);
+    return;
+  }
+  const displaced = import_node_fs2.default.mkdtempSync(
+    import_node_path2.default.join(import_node_path2.default.dirname(to), `.${import_node_path2.default.basename(to)}.old-`)
+  );
+  import_node_fs2.default.rmdirSync(displaced);
+  import_node_fs2.default.renameSync(to, displaced);
+  try {
+    import_node_fs2.default.renameSync(from, to);
+  } catch (error) {
+    import_node_fs2.default.renameSync(displaced, to);
+    throw error;
+  }
+  import_node_fs2.default.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 (!import_node_fs.default.existsSync(didFile)) {
+  const declarationsDir = import_node_path2.default.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 = import_node_fs2.default.statSync(didFile);
+  } catch {
     return {
       success: false,
       declarationsDir: "",
@@ -63,25 +305,39 @@ async function generateDeclarations(options) {
       error: `DID file not found: ${didFile}`
     };
   }
-  const declarationsDir = import_node_path.default.join(outDir, "declarations");
-  const baseName = import_node_path.default.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 = import_node_fs.default.readFileSync(didFile, "utf-8");
-    if (!import_node_fs.default.existsSync(outDir)) {
-      import_node_fs.default.mkdirSync(outDir, { recursive: true });
-    }
-    if (import_node_fs.default.existsSync(declarationsDir)) {
-      import_node_fs.default.rmSync(declarationsDir, { recursive: true, force: true });
-    }
-    import_node_fs.default.mkdirSync(declarationsDir, { recursive: true });
+    const didContent = import_node_fs2.default.readFileSync(didFile, "utf-8");
     const jsContent = (0, import_parser.didToJs)(didContent);
     const tsContent = (0, import_parser.didToTs)(didContent);
-    const jsPath = import_node_path.default.join(declarationsDir, `${baseName}.js`);
-    const dtsPath = import_node_path.default.join(declarationsDir, `${baseName}.d.ts`);
-    const didCopyPath = import_node_path.default.join(declarationsDir, `${baseName}.did`);
-    import_node_fs.default.writeFileSync(jsPath, jsContent);
-    import_node_fs.default.writeFileSync(dtsPath, tsContent);
-    import_node_fs.default.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.`
+      };
+    }
+    import_node_fs2.default.mkdirSync(outDir, { recursive: true });
+    import_node_fs2.default.writeFileSync(import_node_path2.default.join(outDir, OWNER_FILE), `${canisterName}
+`);
+    staging = import_node_fs2.default.mkdtempSync(import_node_path2.default.join(outDir, ".declarations.tmp-"));
+    const jsPath = import_node_path2.default.join(declarationsDir, `${baseName}.js`);
+    const dtsPath = import_node_path2.default.join(declarationsDir, `${baseName}.d.ts`);
+    const didCopyPath = import_node_path2.default.join(declarationsDir, `${baseName}.did`);
+    import_node_fs2.default.writeFileSync(import_node_path2.default.join(staging, `${baseName}.js`), jsContent);
+    import_node_fs2.default.writeFileSync(import_node_path2.default.join(staging, `${baseName}.d.ts`), tsContent);
+    import_node_fs2.default.writeFileSync(import_node_path2.default.join(staging, `${baseName}.did`), didContent);
+    replaceDirectory(staging, declarationsDir);
+    staging = void 0;
     return {
       success: true,
       declarationsDir,
@@ -99,29 +355,24 @@ async function generateDeclarations(options) {
       files: [],
       error: `[${canisterName}] Failed to generate declarations: ${message}`
     };
+  } finally {
+    if (staging) import_node_fs2.default.rmSync(staging, { recursive: true, force: true });
   }
 }
-function declarationsExist(outDir, canisterName) {
-  const dtsPath = import_node_path.default.join(outDir, "declarations", `${canisterName}.d.ts`);
-  return import_node_fs.default.existsSync(dtsPath);
-}
-
-// src/generators/reactor.ts
-var import_node_path2 = __toESM(require("path"), 1);
-
-// src/naming.ts
-var import_change_case = require("change-case");
-function toPascalCase(str) {
-  return (0, import_change_case.pascalCase)(str);
-}
-function toCamelCase(str) {
-  return (0, import_change_case.camelCase)(str);
-}
-function getReactorName(canisterName) {
-  return `${toCamelCase(canisterName)}Reactor`;
-}
-function getServiceTypeName(canisterName) {
-  return `${toPascalCase(canisterName)}Service`;
+function declarationsExist(outDir, canisterName, didFile) {
+  const declarationsDir = import_node_path2.default.join(outDir, "declarations");
+  if (didFile !== void 0) {
+    const baseName = import_node_path2.default.basename(didFile, ".did");
+    return import_node_fs2.default.existsSync(import_node_path2.default.join(declarationsDir, `${baseName}.d.ts`));
+  }
+  if (import_node_fs2.default.existsSync(import_node_path2.default.join(declarationsDir, `${canisterName}.d.ts`))) {
+    return true;
+  }
+  try {
+    return import_node_fs2.default.readdirSync(declarationsDir).some((entry) => entry.endsWith(".d.ts"));
+  } catch {
+    return false;
+  }
 }
 
 // src/generators/reactor.ts
@@ -134,6 +385,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) {
@@ -148,7 +403,7 @@ function generateReactorFile(options) {
   const pascalName = toPascalCase(canisterName);
   const reactorName = getReactorName(canisterName);
   const serviceName = getServiceTypeName(canisterName);
-  const baseName = import_node_path2.default.basename(didFile, ".did");
+  const baseName = resolveDeclarationsBaseName(didFile);
   const declarationsPath = `./declarations/${baseName}`;
   const reactorImportSource = getReactorClassImportSource(
     reactorClass,
@@ -167,9 +422,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
 
@@ -185,7 +440,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() {
@@ -218,8 +473,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; import_node_fs3.default.existsSync(backupPath); n += 1) {
+    backupPath = `${filePath}.bak.${n}`;
+  }
+  import_node_fs3.default.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function findOutDirOwner(outDir) {
+  try {
+    const owner = import_node_fs3.default.readFileSync(import_node_path3.default.join(outDir, OWNER_FILE), "utf-8").trim();
+    if (owner) return owner;
+  } catch {
+  }
+  let content;
+  try {
+    content = import_node_fs3.default.readFileSync(import_node_path3.default.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);
@@ -233,8 +528,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 = import_node_path3.default.isAbsolute(didFile) ? didFile : import_node_path3.default.resolve(projectRoot, didFile);
-  if (!import_node_fs2.default.existsSync(resolvedDidFile)) {
+  if (!import_node_fs3.default.existsSync(resolvedDidFile)) {
     return {
       canisterName: name,
       success: false,
@@ -242,8 +559,30 @@ async function runCanisterPipeline(options) {
       error: `DID file not found: ${resolvedDidFile}`
     };
   }
-  const canisterOutDir = canisterConfig.outDir != null ? import_node_path3.default.isAbsolute(canisterConfig.outDir) ? canisterConfig.outDir : import_node_path3.default.resolve(projectRoot, canisterConfig.outDir) : import_node_path3.default.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,
@@ -288,16 +627,21 @@ async function runCanisterPipeline(options) {
       reactorClass
     });
     const entryContent = generateReactorEntryFile();
-    import_node_fs2.default.mkdirSync(canisterOutDir, { recursive: true });
-    import_node_fs2.default.writeFileSync(reactorPath, reactorContent);
+    import_node_fs3.default.mkdirSync(canisterOutDir, { recursive: true });
+    import_node_fs3.default.writeFileSync(reactorPath, reactorContent);
     files.push({ success: true, filePath: reactorPath });
-    if (!import_node_fs2.default.existsSync(entryPath)) {
-      import_node_fs2.default.writeFileSync(entryPath, entryContent);
+    if (!import_node_fs3.default.existsSync(entryPath)) {
+      import_node_fs3.default.writeFileSync(entryPath, entryContent);
       files.push({ success: true, filePath: entryPath });
     } else {
-      const existingEntryContent = import_node_fs2.default.readFileSync(entryPath, "utf-8");
-      if (isLegacyGeneratedIndexFile(existingEntryContent) || isManagedEntryWrapper(existingEntryContent, entryContent)) {
-        import_node_fs2.default.writeFileSync(entryPath, entryContent);
+      const existingEntryContent = import_node_fs3.default.readFileSync(entryPath, "utf-8");
+      if (isManagedEntryWrapper(existingEntryContent, entryContent)) {
+        import_node_fs3.default.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: entryPath });
+      } else if (isLegacyGeneratedIndexFile(existingEntryContent, name)) {
+        const backupPath = backUpFile(entryPath);
+        import_node_fs3.default.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: backupPath });
         files.push({ success: true, filePath: entryPath });
       } else {
         files.push({ success: true, filePath: entryPath, skipped: true });
@@ -323,40 +667,6 @@ async function runCanisterPipeline(options) {
   };
 }
 
-// src/parser.ts
-var import_parser2 = require("@ic-reactor/parser");
-var import_node_fs3 = __toESM(require("fs"), 1);
-function extractMethods(didContent) {
-  try {
-    const jsContent = (0, import_parser2.didToJs)(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 (!import_node_fs3.default.existsSync(didFilePath)) {
-    throw new Error(`DID file not found: ${didFilePath}`);
-  }
-  const content = import_node_fs3.default.readFileSync(didFilePath, "utf-8");
-  return extractMethods(content);
-}
-
 // src/generators/client.ts
 function generateClientFile(options = {}) {
   const { queryClientPath } = options;
@@ -377,620 +687,26 @@ export const clientManager = new ClientManager({
 })
 `;
 }
-
-// src/metadata-rules.json
-var metadata_rules_default = {
-  defaultValidationMessages: {
-    minimum: {
-      template: "Must be at least {value}"
-    },
-    maximum: {
-      template: "Must be at most {value}"
-    },
-    minLength: {
-      template: "Must be at least {value} character{plural}"
-    },
-    maxLength: {
-      template: "Must be at most {value} character{plural}"
-    }
-  },
-  email: {
-    helper: "email",
-    regex: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$",
-    jsonSchemaFormat: "email",
-    errorMessage: "Must be a valid email address"
-  },
-  "date-time": {
-    helper: "dateTime",
-    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d))$",
-    jsonSchemaFormat: "date-time",
-    errorMessage: "Must be a valid ISO datetime"
-  },
-  datetime: {
-    helper: "datetime",
-    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d))$",
-    jsonSchemaFormat: "date-time",
-    errorMessage: "Must be a valid ISO datetime"
-  },
-  date: {
-    helper: "date",
-    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))$",
-    jsonSchemaFormat: "date",
-    errorMessage: "Must be a valid ISO date"
-  },
-  time: {
-    helper: "time",
-    regex: "^(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?$",
-    errorMessage: "Must be a valid ISO time"
-  },
-  duration: {
-    helper: "duration",
-    regex: "^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$",
-    jsonSchemaFormat: "duration",
-    errorMessage: "Must be a valid ISO duration"
-  },
-  url: {
-    helper: "url",
-    regex: "^[a-zA-Z][a-zA-Z\\d+.-]*:.+",
-    jsonSchemaFormat: "uri",
-    errorMessage: "Must be a valid URL"
-  },
-  uri: {
-    helper: "uri",
-    regex: "^[a-zA-Z][a-zA-Z\\d+.-]*:.+",
-    jsonSchemaFormat: "uri",
-    errorMessage: "Must be a valid URI"
-  },
-  httpsUrl: {
-    helper: "httpsUrl",
-    regex: "^https://.+",
-    jsonSchemaFormat: "uri",
-    errorMessage: "Must be a valid HTTPS URL"
-  },
-  ipv4: {
-    helper: "ipv4",
-    regex: "^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.|$)){4}$",
-    jsonSchemaFormat: "ipv4",
-    errorMessage: "Must be a valid IPv4 address"
-  },
-  ipv6: {
-    helper: "ipv6",
-    regex: "^((?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}|::1|::|(?:[0-9A-Fa-f]{1,4}:){1,7}:|(?:[0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,5}(?::[0-9A-Fa-f]{1,4}){1,2}|(?:[0-9A-Fa-f]{1,4}:){1,4}(?::[0-9A-Fa-f]{1,4}){1,3}|(?:[0-9A-Fa-f]{1,4}:){1,3}(?::[0-9A-Fa-f]{1,4}){1,4}|(?:[0-9A-Fa-f]{1,4}:){1,2}(?::[0-9A-Fa-f]{1,4}){1,5}|[0-9A-Fa-f]{1,4}:(?:(?::[0-9A-Fa-f]{1,4}){1,6}))$",
-    jsonSchemaFormat: "ipv6",
-    errorMessage: "Must be a valid IPv6 address"
-  },
-  uuid: {
-    helper: "uuid",
-    regex: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$",
-    jsonSchemaFormat: "uuid",
-    errorMessage: "Must be a valid UUID"
-  },
-  guid: {
-    helper: "guid",
-    regex: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$",
-    jsonSchemaFormat: "uuid",
-    errorMessage: "Must be a valid GUID"
-  },
-  base64: {
-    helper: "base64",
-    regex: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
-    contentEncoding: "base64",
-    errorMessage: "Must be valid base64"
-  },
-  base64url: {
-    helper: "base64url",
-    regex: "^[A-Za-z0-9_-]+$",
-    errorMessage: "Must be valid base64url"
-  },
-  cuid: {
-    helper: "cuid",
-    regex: "^c[a-z0-9]{24}$",
-    errorMessage: "Must be a valid CUID"
-  },
-  cuid2: {
-    helper: "cuid2",
-    regex: "^[a-z][a-z0-9]*$",
-    errorMessage: "Must be a valid CUID2"
-  },
-  ulid: {
-    helper: "ulid",
-    regex: "^[0-9A-HJKMNP-TV-Z]{26}$",
-    errorMessage: "Must be a valid ULID"
-  },
-  nanoid: {
-    helper: "nanoid",
-    regex: "^[A-Za-z0-9_-]{21}$",
-    errorMessage: "Must be a valid nanoid"
-  },
-  emoji: {
-    helper: "emoji",
-    regex: "^\\p{Extended_Pictographic}+$",
-    errorMessage: "Must contain only emoji characters"
-  },
-  cidrv4: {
-    helper: "cidrv4",
-    regex: "^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)/(?:3[0-2]|[12]?\\d)$",
-    errorMessage: "Must be a valid IPv4 CIDR range"
-  },
-  cidrv6: {
-    helper: "cidrv6",
-    regex: "^[0-9A-Fa-f:]+/(?:12[0-8]|1[01]\\d|\\d?\\d)$",
-    errorMessage: "Must be a valid IPv6 CIDR range"
-  },
-  mac: {
-    helper: "mac",
-    regex: "^(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$",
-    errorMessage: "Must be a valid MAC address"
-  }
-};
-
-// src/metadata.ts
-var metadataRulesFile = metadata_rules_default;
-var defaultValidationMessages = metadataRulesFile.defaultValidationMessages ?? {};
-var rawRuleEntries = Object.entries(metadata_rules_default).filter(
-  ([type]) => type !== "defaultValidationMessages"
-);
-var BUILT_IN_JSDOC_FORMAT_TYPES = Object.fromEntries(
-  rawRuleEntries.map(([type, rule]) => [
-    type,
-    {
-      regex: rule.regex,
-      jsonSchemaFormat: rule.jsonSchemaFormat,
-      contentEncoding: rule.contentEncoding,
-      errorMessage: rule.errorMessage
-    }
-  ])
-);
-var BUILT_IN_FORMAT_HELPERS = Object.fromEntries(
-  rawRuleEntries.filter(([, rule]) => rule.helper).map(([type, rule]) => [type, rule.helper])
-);
-function normalizeFormatDefinition(definition) {
-  if (!definition) return void 0;
-  return typeof definition === "string" ? { regex: definition } : definition;
-}
-function formatDefinitionFor(type, options) {
-  const builtIn = BUILT_IN_JSDOC_FORMAT_TYPES[type];
-  const custom = normalizeFormatDefinition(
-    options.customJSDocFormatTypes?.[type]
-  );
-  if (!custom) return builtIn;
-  return {
-    ...builtIn,
-    ...custom,
-    errorMessage: custom.errorMessage ?? builtIn?.errorMessage
-  };
-}
-function stripUndefined(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entry]) => entry !== void 0)
-  );
-}
-function defaultBoundMessage(kind, value) {
-  const template = defaultValidationMessages[kind]?.template ?? (kind === "minimum" ? "Must be at least {value}" : kind === "maximum" ? "Must be at most {value}" : kind === "minLength" ? "Must be at least {value} character{plural}" : "Must be at most {value} character{plural}");
-  return template.replace("{value}", value).replace("{plural}", value === "1" ? "" : "s");
-}
-function withDefaultBoundMessage(bound, kind) {
-  if (!bound || bound.message !== void 0) return bound;
-  return {
-    ...bound,
-    message: defaultBoundMessage(kind, bound.value)
-  };
-}
-function normalizeValidationMetadata(validation, options) {
-  const normalized = {
-    ...validation,
-    minimum: withDefaultBoundMessage(validation.minimum, "minimum"),
-    maximum: withDefaultBoundMessage(validation.maximum, "maximum"),
-    minLength: withDefaultBoundMessage(validation.minLength, "minLength"),
-    maxLength: withDefaultBoundMessage(validation.maxLength, "maxLength")
-  };
-  const format = validation.format;
-  const formatDefinition = format ? formatDefinitionFor(format.type, options) : void 0;
-  if (format && formatDefinition) {
-    normalized.format = stripUndefined({
-      ...format,
-      regex: formatDefinition.regex,
-      jsonSchemaFormat: formatDefinition.jsonSchemaFormat,
-      contentEncoding: formatDefinition.contentEncoding,
-      errorMessage: format.message ?? formatDefinition.errorMessage
-    });
-  } else if (format) {
-    normalized.format = format;
-  }
-  return normalized;
-}
-
-// src/renderer.ts
-var reservedWords = /* @__PURE__ */ new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield",
-  "let",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "static"
-]);
-function isValidIdentifier(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !reservedWords.has(name);
-}
-function assertIdentifier(name, label) {
-  if (!isValidIdentifier(name)) {
-    throw new Error(`${label} must be a valid TypeScript identifier: ${name}`);
-  }
-}
-function propertyName(name) {
-  return isValidIdentifier(name) ? name : JSON.stringify(name);
-}
-function normalizeOptions(options = {}) {
-  return typeof options === "string" ? { serviceExportName: options } : options;
-}
-function toServiceExportName(canisterName) {
-  return canisterName.replace(/[-\s]+/g, "_").toUpperCase();
-}
-function resolveServiceExportName(options, declaredTypeNames) {
-  if (options.serviceExportName) return options.serviceExportName;
-  if (options.canisterName) {
-    let name = toServiceExportName(options.canisterName);
-    if (declaredTypeNames.has(name)) {
-      name = `${name}_SERVICE`;
-    }
-    return name;
-  }
-  return "_SERVICE";
-}
-function hasMetadata(metadata) {
-  return metadata != null && Object.keys(metadata).length > 0;
-}
-function stripUndefined2(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entry]) => entry !== void 0)
-  );
-}
-function isEmptyObject(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
-}
-function textFormatHelperFor(expression, metadata, options) {
-  const format = metadata.validation?.format;
-  if (!format || expression !== "c.text()") return void 0;
-  if (options.customJSDocFormatTypes?.[format.type]) {
-    return void 0;
-  }
-  return BUILT_IN_FORMAT_HELPERS[format.type];
-}
-function hasOnlyDescriptionDocs(docs, description) {
-  return docs != null && description != null && docs.length === 1 && docs[0] === description;
-}
-function metadataForRender(metadata, options) {
-  if (!metadata.validation) {
-    return metadata;
-  }
-  return {
-    ...metadata,
-    validation: normalizeValidationMetadata(metadata.validation, {
-      customJSDocFormatTypes: options.customJSDocFormatTypes
-    })
-  };
-}
-function applyMetadata(expression, metadata, options) {
-  if (!hasMetadata(metadata)) return expression;
-  const textFormatHelper = textFormatHelperFor(expression, metadata, options);
-  const textFormatMessage = metadata.validation?.format?.message;
-  const renderedMetadata = metadataForRender(metadata, options);
-  const { description, ...metadataRest } = renderedMetadata;
-  const rest = { ...metadataRest };
-  let result = textFormatHelper ? `c.${textFormatHelper}(${textFormatMessage ? JSON.stringify(textFormatMessage) : ""})` : expression;
-  if (textFormatHelper) {
-    delete rest.docs;
-    if (rest.validation) {
-      const { format: _format, ...validationRest } = rest.validation;
-      rest.validation = stripUndefined2(validationRest);
-      if (isEmptyObject(rest.validation)) {
-        delete rest.validation;
-      }
-    }
-  } else if (hasOnlyDescriptionDocs(rest.docs, description)) {
-    delete rest.docs;
-  }
-  if (description) {
-    result += `.describe(${JSON.stringify(description)})`;
-  }
-  if (Object.keys(rest).length > 0) {
-    result += `.meta(${JSON.stringify(rest)})`;
-  }
-  return result;
-}
-function getReferencedNames(type) {
-  const refs = [];
-  function visit(node) {
-    switch (node.kind) {
-      case "reference":
-        refs.push(node.name);
-        break;
-      case "opt":
-      case "vec":
-        visit(node.type);
-        break;
-      case "record":
-      case "variant":
-        for (const field of node.fields) {
-          visit(field.type);
-        }
-        break;
-      case "tuple":
-        for (const item of node.types) {
-          visit(item);
-        }
-        break;
-    }
-  }
-  visit(type);
-  return refs;
-}
-function sortDeclarations(declarations) {
-  const sorted = [];
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = [];
-  const declarationByName = new Map(
-    declarations.map((decl) => [decl.name, decl])
-  );
-  function visit(name) {
-    if (visited.has(name)) return;
-    const cycleStart = visiting.indexOf(name);
-    if (cycleStart !== -1) {
-      const cycle = [...visiting.slice(cycleStart), name].join(" -> ");
-      throw new Error(`Recursive Candid types are not supported yet: ${cycle}`);
-    }
-    const declaration = declarationByName.get(name);
-    if (!declaration) return;
-    visiting.push(name);
-    for (const dependency of getReferencedNames(declaration.type)) {
-      visit(dependency);
-    }
-    visiting.pop();
-    visited.add(name);
-    sorted.push(declaration);
-  }
-  for (const declaration of declarations) {
-    visit(declaration.name);
-  }
-  return sorted;
-}
-function renderType(type, indent = "", options = {}) {
-  const nextIndent = `${indent}  `;
-  let expression;
-  switch (type.kind) {
-    case "null":
-      expression = "c.null()";
-      break;
-    case "bool":
-      expression = "c.bool()";
-      break;
-    case "nat":
-      expression = "c.nat()";
-      break;
-    case "int":
-      expression = "c.int()";
-      break;
-    case "nat8":
-      expression = "c.nat8()";
-      break;
-    case "nat16":
-      expression = "c.nat16()";
-      break;
-    case "nat32":
-      expression = "c.nat32()";
-      break;
-    case "nat64":
-      expression = "c.nat64()";
-      break;
-    case "int8":
-      expression = "c.int8()";
-      break;
-    case "int16":
-      expression = "c.int16()";
-      break;
-    case "int32":
-      expression = "c.int32()";
-      break;
-    case "int64":
-      expression = "c.int64()";
-      break;
-    case "float32":
-      expression = "c.float32()";
-      break;
-    case "float64":
-      expression = "c.float64()";
-      break;
-    case "text":
-      expression = "c.text()";
-      break;
-    case "reserved":
-      expression = "c.reserved()";
-      break;
-    case "empty":
-      expression = "c.empty()";
-      break;
-    case "principal":
-      expression = "c.principal()";
-      break;
-    case "blob":
-      expression = "c.blob()";
-      break;
-    case "reference":
-      assertIdentifier(type.name, "Type reference");
-      expression = type.name;
-      break;
-    case "opt":
-      expression = `c.opt(${renderType(type.type, indent, options)})`;
-      break;
-    case "vec":
-      expression = `c.vec(${renderType(type.type, indent, options)})`;
-      break;
-    case "record": {
-      if (type.fields.length === 0) {
-        expression = "c.record({})";
-      } else {
-        const fields = type.fields.map((field) => {
-          const fieldExpression = applyMetadata(
-            renderType(field.type, nextIndent, options),
-            field.metadata,
-            options
-          );
-          return `${nextIndent}${propertyName(field.name)}: ${fieldExpression},`;
-        }).join("\n");
-        expression = `c.record({
-${fields}
-${indent}})`;
-      }
-      break;
-    }
-    case "variant": {
-      if (type.fields.length === 0) {
-        expression = "c.variant({})";
-      } else {
-        const fields = type.fields.map((field) => {
-          const fieldExpression = applyMetadata(
-            renderType(field.type, nextIndent, options),
-            field.metadata,
-            options
-          );
-          return `${nextIndent}${propertyName(field.name)}: ${fieldExpression},`;
-        }).join("\n");
-        expression = `c.variant({
-${fields}
-${indent}})`;
-      }
-      break;
-    }
-    case "tuple":
-      expression = `c.tuple([${type.types.map((item) => renderType(item, indent, options)).join(", ")}])`;
-      break;
-    case "func":
-    case "service":
-    case "class":
-    case "unknown":
-    case "knot":
-    case "future":
-      expression = `/* c.${type.kind} is not supported */ c.reserved()`;
-      break;
-  }
-  return applyMetadata(expression, type.metadata, options);
-}
-function renderMethodReturn(method, options) {
-  if (method.mode === "oneway") return "";
-  if (method.returns.length === 0) return "";
-  if (method.returns.length === 1) {
-    return `, ${renderType(method.returns[0], "    ", options)}`;
-  }
-  return `, [${method.returns.map((returnType) => renderType(returnType, "    ", options)).join(", ")}]`;
-}
-function generateCodecDeclarations(schema, optionsOrServiceExportName = {}) {
-  const options = normalizeOptions(optionsOrServiceExportName);
-  const lines = ['import { c } from "@ic-reactor/cod"', ""];
-  for (const declaration of sortDeclarations(schema.types)) {
-    assertIdentifier(declaration.name, "Type declaration name");
-    lines.push(
-      `export const ${declaration.name} = ${applyMetadata(
-        renderType(declaration.type, "", options),
-        declaration.metadata,
-        options
-      )}`
-    );
-    lines.push(
-      `export type ${declaration.name} = c.infer<typeof ${declaration.name}>`
-    );
-    lines.push("");
-  }
-  if (schema.service) {
-    const includeCompatibilityExports = options.includeCompatibilityExports ?? false;
-    const declaredTypeNames = new Set(schema.types.map((t) => t.name));
-    const serviceExportName = resolveServiceExportName(
-      options,
-      declaredTypeNames
-    );
-    assertIdentifier(serviceExportName, "Service export name");
-    const methods = schema.service.methods.map((method) => {
-      const args = method.args.map((arg) => renderType(arg, "    ", options)).join(", ");
-      const methodExpression = `c.${method.mode}([${args}]${renderMethodReturn(
-        method,
-        options
-      )})`;
-      return `  ${propertyName(method.name)}: ${applyMetadata(
-        methodExpression,
-        method.metadata,
-        options
-      )},`;
-    }).join("\n");
-    const serviceExpression = methods.length > 0 ? `c.service({
-${methods}
-})` : "c.service({})";
-    lines.push(
-      `export const ${serviceExportName} = ${applyMetadata(
-        serviceExpression,
-        schema.service.metadata,
-        options
-      )}`
-    );
-    lines.push("");
-    if (includeCompatibilityExports) {
-      lines.push(`export const idlFactory = ${serviceExportName}.idlFactory`);
-      lines.push(
-        `export type _SERVICE = c.ServiceOf<typeof ${serviceExportName}>`
-      );
-      lines.push("");
-      lines.push(`export const manifest = ${serviceExportName}.manifest()`);
-    }
-  }
-  return `${lines.join("\n").trimEnd()}
-`;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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
 });