@ic-reactor/codegen 0.12.1 → 0.13.0

package/README.md

@@ -45,7 +45,9 @@ Set `target` to control whether generated files include React hooks:
 - `react` (default): generates the reactor plus bound `createActorHooks` exports
 - `core`: generates only the typed reactor exports with no `@ic-reactor/react` dependency
 
-Codegen now writes two files per canister: a managed `index.generated.ts` implementation that is regenerated on every run, and an `index.ts` entry wrapper. The wrapper is created once, then preserved unless it still matches the default generated wrapper or an older generated scaffold that can be migrated automatically.
+Codegen now writes two files per canister: a managed `index.generated.ts` implementation that is regenerated on every run, and an `index.ts` entry wrapper. The wrapper is created once, then preserved unless it still matches the default generated wrapper or an older generated scaffold that can be migrated automatically. A scaffold that carries any export the old generator never wrote counts as user-owned and is left alone; one that is migrated is copied to `index.ts.bak` first.
+
+Each canister needs its own `outDir`. Generating into a directory that already holds another canister's `index.generated.ts` fails rather than overwriting it, because every run replaces `declarations/` wholesale.
 
 Set `generateReactor: false` if you only want the bindgen/declaration output and
 need to skip `index.generated.ts` and `index.ts`.
@@ -54,7 +56,7 @@ need to skip `index.generated.ts` and `index.ts`.
 
 You can also use individual generators if you need more granular control:
 
-- **`generateDeclarations`**: Writes `declarations/<did-basename>.js` (factory), `.d.ts` (types), and a `.did` copy. The `declarations/` directory is wiped and recreated on every run.
+- **`generateDeclarations`**: Writes `declarations/<did-basename>.js` (factory), `.d.ts` (types), and a `.did` copy. Generation runs in a staging directory that replaces `declarations/` only once every file is written, so a `.did` that fails to parse leaves the previous declarations untouched. A `.did` that parses but declares no `service` is rejected — it would produce no `idlFactory` and no `_SERVICE`.
 - **`generateReactorFile`**: Generates the managed `index.generated.ts` implementation using any `ReactorClassName` — `Reactor`, `DisplayReactor` (default), `CandidReactor`, `CandidDisplayReactor`, or `MetadataDisplayReactor`. With `target: "react"` it also emits the six `createActorHooks` exports (`use<Canister>Query`, `use<Canister>SuspenseQuery`, `use<Canister>InfiniteQuery`, `use<Canister>SuspenseInfiniteQuery`, `use<Canister>Mutation`, `use<Canister>Method`). No `createQuery` / `createMutation` objects are generated.
 - **`generateReactorEntryFile`**: Generates the stable `index.ts` wrapper that re-exports from `index.generated.ts`.
 - **`generateClientFile`**: Generates a `ClientManager` boilerplate file that
@@ -62,8 +64,17 @@ You can also use individual generators if you need more granular control:
 
 ## Utilities
 
-- **`parseDIDFile` / `extractMethods`**: Parse a `.did` file and extract method signatures.
 - **`toPascalCase` / `getReactorName` / `getServiceTypeName`**: Naming helpers.
+- **`assertSafeCanisterConfig` and friends**: Validate a canister config before generating; the pipeline runs these itself.
+
+`parseDIDFile` / `extractMethods` (and the `MethodInfo` / `MethodType` types)
+have been removed. They regex-scraped the pretty-printed JS from
+`didToJs`, which silently returned no methods for any service whose first
+method took an inline record, dropped every method whose signature wrapped over
+80 columns, and reported `composite_query` as a mutation. Read a `.did` with
+[`parseDid()`](https://ic-reactor.b3pay.net/v3/packages/parser) from
+`@ic-reactor/parser` instead — it returns `{ name, mode, args, returns }` per
+method, straight from the Rust parser.
 
 ## License
 

package/dist/index.cjs

@@ -40,15 +40,14 @@ __export(index_exports, {
   assertSafeCanisterName: () => assertSafeCanisterName,
   assertSafeModuleSpecifier: () => assertSafeModuleSpecifier,
   declarationsExist: () => declarationsExist,
-  extractMethods: () => extractMethods,
   generateClientFile: () => generateClientFile,
   generateDeclarations: () => generateDeclarations,
   generateReactorEntryFile: () => generateReactorEntryFile,
   generateReactorFile: () => generateReactorFile,
   getReactorName: () => getReactorName,
   getServiceTypeName: () => getServiceTypeName,
-  parseDIDFile: () => parseDIDFile,
   resolveContainedOutDir: () => resolveContainedOutDir,
+  resolveDeclarationsBaseName: () => resolveDeclarationsBaseName,
   runCanisterPipeline: () => runCanisterPipeline,
   toPascalCase: () => toPascalCase
 });
@@ -56,67 +55,16 @@ module.exports = __toCommonJS(index_exports);
 
 // src/pipeline.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 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_fs = __toESM(require("fs"), 1);
-async function generateDeclarations(options) {
-  const { didFile, outDir, canisterName } = options;
-  if (!import_node_fs.default.existsSync(didFile)) {
-    return {
-      success: false,
-      declarationsDir: "",
-      files: [],
-      error: `DID file not found: ${didFile}`
-    };
-  }
-  const declarationsDir = import_node_path.default.join(outDir, "declarations");
-  const baseName = import_node_path.default.basename(didFile, ".did");
-  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 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);
-    return {
-      success: true,
-      declarationsDir,
-      files: [
-        { success: true, filePath: jsPath },
-        { success: true, filePath: dtsPath },
-        { success: true, filePath: didCopyPath }
-      ]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      declarationsDir,
-      files: [],
-      error: `[${canisterName}] Failed to generate declarations: ${message}`
-    };
-  }
-}
-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);
+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");
@@ -136,97 +84,7 @@ function getHookPrefix(canisterName) {
   return toPascalCase(canisterName);
 }
 
-// src/generators/reactor.ts
-function getReactorClassImportSource(reactorClass, runtimeTarget) {
-  switch (reactorClass) {
-    case "Reactor":
-    case "DisplayReactor":
-      return runtimeTarget === "core" ? "@ic-reactor/core" : "@ic-reactor/react";
-    case "CandidReactor":
-    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) {
-  const {
-    canisterName,
-    didFile,
-    clientManagerPath = "../../clients",
-    canisterId,
-    runtimeTarget = "react",
-    reactorClass = "DisplayReactor"
-  } = options;
-  const pascalName = toPascalCase(canisterName);
-  const reactorName = getReactorName(canisterName);
-  const serviceName = getServiceTypeName(canisterName);
-  const baseName = import_node_path2.default.basename(didFile, ".did");
-  const declarationsPath = `./declarations/${baseName}`;
-  const reactorImportSource = getReactorClassImportSource(
-    reactorClass,
-    runtimeTarget
-  );
-  const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
-` : "";
-  const hookExports = runtimeTarget === "react" ? `
-
-export const {
-  useActorQuery: use${pascalName}Query,
-  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
-  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
-  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
-  useActorMutation: use${pascalName}Mutation,
-  useActorMethod: use${pascalName}Method,
-} = createActorHooks(${reactorName})
-` : "";
-  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
-
-/**
- * ${pascalName} Reactor
- *
- * Auto-generated by @ic-reactor/codegen \u2014 do not edit.
- * This file is overwritten whenever generation runs.
- *
- * Keep app-specific logic in the stable \`index.ts\` wrapper (or adjacent
- * factory modules). Avoid editing this managed file directly.
- */
-export const ${reactorName} = new ${reactorClass}<${serviceName}>({
-  clientManager,
-  idlFactory,
-${canisterIdLine}  name: ${JSON.stringify(canisterName)},
-})${hookExports || "\n"}`;
-}
-function generateReactorEntryFile() {
-  return `/**
- * Canister entrypoint.
- *
- * Created once by @ic-reactor/codegen and safe to customize.
- * Keep the re-export below if you want generated exports and types to stay in sync.
- *
- * Recommended customization points:
- * - define reusable query/mutation factories
- * - add app-specific hooks and cache invalidation wiring
- * - compose generated APIs into route loaders/actions
- *
- * Do not edit \`index.generated.ts\`; it is regenerated on each codegen run.
- * AI guide: https://ic-reactor.b3pay.net/llms-full.txt
- * Skill install: npx skills add B3Pay/ic-reactor-skills --full-depth --skill ic-reactor-hooks
- */
-export * from "./index.generated"
-`;
-}
-
 // src/validate.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
 var CodegenConfigError = class extends Error {
   name = "CodegenConfigError";
   constructor(message) {
@@ -299,6 +157,24 @@ function assertSafeModuleSpecifier(label, 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",
@@ -315,28 +191,28 @@ function assertOneOf(label, value, allowed) {
   }
 }
 function realpathAllowingMissing(target) {
-  let current = import_node_path3.default.resolve(target);
+  let current = import_node_path.default.resolve(target);
   const missing = [];
   for (; ; ) {
     try {
-      return import_node_path3.default.join(import_node_fs2.default.realpathSync(current), ...missing);
+      return import_node_path.default.join(import_node_fs.default.realpathSync(current), ...missing);
     } catch {
-      const parent = import_node_path3.default.dirname(current);
-      if (parent === current) return import_node_path3.default.resolve(target);
-      missing.unshift(import_node_path3.default.basename(current));
+      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_path3.default.relative(
+  const relative = import_node_path.default.relative(
     realpathAllowingMissing(projectRoot),
     realpathAllowingMissing(resolved)
   );
   const [firstSegment] = relative.split(/[\\/]/);
-  if (firstSegment === ".." || import_node_path3.default.isAbsolute(relative)) {
+  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_path3.default.resolve(projectRoot))}. Generated output must stay inside the project \u2014 generated directories are deleted and rewritten on every run.`
+      `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.`
     );
   }
 }
@@ -346,7 +222,7 @@ function resolveContainedOutDir(label, outDir, projectRoot) {
       `Invalid ${label}: expected a non-empty string, received ${outDir === void 0 ? "undefined" : JSON.stringify(outDir)}.`
     );
   }
-  const resolved = import_node_path3.default.isAbsolute(outDir) ? import_node_path3.default.resolve(outDir) : import_node_path3.default.resolve(projectRoot, 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;
 }
@@ -368,7 +244,7 @@ function assertSafeCanisterConfig(options) {
     `outDir for canister ${JSON.stringify(name)}`,
     canisterOutDir,
     projectRoot
-  ) : import_node_path3.default.join(
+  ) : import_node_path.default.join(
     resolveContainedOutDir("outDir", globalOutDir, projectRoot),
     name
   );
@@ -380,6 +256,213 @@ function assertSafeCanisterConfig(options) {
   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;
+  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: "",
+      files: [],
+      error: `DID file not found: ${didFile}`
+    };
+  }
+  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_fs2.default.readFileSync(didFile, "utf-8");
+    const jsContent = (0, import_parser.didToJs)(didContent);
+    const tsContent = (0, import_parser.didToTs)(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,
+      files: [
+        { success: true, filePath: jsPath },
+        { success: true, filePath: dtsPath },
+        { success: true, filePath: didCopyPath }
+      ]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      declarationsDir,
+      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, 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
+function getReactorClassImportSource(reactorClass, runtimeTarget) {
+  switch (reactorClass) {
+    case "Reactor":
+    case "DisplayReactor":
+      return runtimeTarget === "core" ? "@ic-reactor/core" : "@ic-reactor/react";
+    case "CandidReactor":
+    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) {
+  const {
+    canisterName,
+    didFile,
+    clientManagerPath = "../../clients",
+    canisterId,
+    runtimeTarget = "react",
+    reactorClass = "DisplayReactor"
+  } = options;
+  const pascalName = toPascalCase(canisterName);
+  const reactorName = getReactorName(canisterName);
+  const serviceName = getServiceTypeName(canisterName);
+  const baseName = resolveDeclarationsBaseName(didFile);
+  const declarationsPath = `./declarations/${baseName}`;
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  );
+  const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
+` : "";
+  const hookExports = runtimeTarget === "react" ? `
+
+export const {
+  useActorQuery: use${pascalName}Query,
+  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
+  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
+  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
+  useActorMutation: use${pascalName}Mutation,
+  useActorMethod: use${pascalName}Method,
+} = createActorHooks(${reactorName})
+` : "";
+  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
+
+/**
+ * ${pascalName} Reactor
+ *
+ * Auto-generated by @ic-reactor/codegen \u2014 do not edit.
+ * This file is overwritten whenever generation runs.
+ *
+ * Keep app-specific logic in the stable \`index.ts\` wrapper (or adjacent
+ * factory modules). Avoid editing this managed file directly.
+ */
+export const ${reactorName} = new ${reactorClass}<${serviceName}>({
+  clientManager,
+  idlFactory,
+${canisterIdLine}  name: ${JSON.stringify(canisterName)},
+})${hookExports || "\n"}`;
+}
+function generateReactorEntryFile() {
+  return `/**
+ * Canister entrypoint.
+ *
+ * Created once by @ic-reactor/codegen and safe to customize.
+ * Keep the re-export below if you want generated exports and types to stay in sync.
+ *
+ * Recommended customization points:
+ * - define reusable query/mutation factories
+ * - add app-specific hooks and cache invalidation wiring
+ * - compose generated APIs into route loaders/actions
+ *
+ * Do not edit \`index.generated.ts\`; it is regenerated on each codegen run.
+ * AI guide: https://ic-reactor.b3pay.net/llms-full.txt
+ * Skill install: npx skills add B3Pay/ic-reactor-skills --full-depth --skill ic-reactor-hooks
+ */
+export * from "./index.generated"
+`;
+}
+
 // src/pipeline.ts
 function resolveReactorClass(canisterConfig) {
   return canisterConfig.mode ?? "DisplayReactor";
@@ -390,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);
@@ -427,7 +550,7 @@ async function runCanisterPipeline(options) {
     }
     throw err;
   }
-  const resolvedDidFile = import_node_path4.default.isAbsolute(didFile) ? didFile : import_node_path4.default.resolve(projectRoot, didFile);
+  const resolvedDidFile = import_node_path3.default.isAbsolute(didFile) ? didFile : import_node_path3.default.resolve(projectRoot, didFile);
   if (!import_node_fs3.default.existsSync(resolvedDidFile)) {
     return {
       canisterName: name,
@@ -436,7 +559,29 @@ async function runCanisterPipeline(options) {
       error: `DID file not found: ${resolvedDidFile}`
     };
   }
+  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({
@@ -468,8 +613,8 @@ async function runCanisterPipeline(options) {
       files
     };
   }
-  const reactorPath = import_node_path4.default.join(canisterOutDir, "index.generated.ts");
-  const entryPath = import_node_path4.default.join(canisterOutDir, "index.ts");
+  const reactorPath = import_node_path3.default.join(canisterOutDir, "index.generated.ts");
+  const entryPath = import_node_path3.default.join(canisterOutDir, "index.ts");
   const reactorClass = resolveReactorClass(canisterConfig);
   const runtimeTarget = resolveRuntimeTarget(canisterConfig, globalConfig);
   try {
@@ -490,9 +635,14 @@ async function runCanisterPipeline(options) {
       files.push({ success: true, filePath: entryPath });
     } else {
       const existingEntryContent = import_node_fs3.default.readFileSync(entryPath, "utf-8");
-      if (isLegacyGeneratedIndexFile(existingEntryContent) || isManagedEntryWrapper(existingEntryContent, entryContent)) {
+      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 });
       }
@@ -517,40 +667,6 @@ async function runCanisterPipeline(options) {
   };
 }
 
-// src/parser.ts
-var import_parser2 = require("@ic-reactor/parser");
-var import_node_fs4 = __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_fs4.default.existsSync(didFilePath)) {
-    throw new Error(`DID file not found: ${didFilePath}`);
-  }
-  const content = import_node_fs4.default.readFileSync(didFilePath, "utf-8");
-  return extractMethods(content);
-}
-
 // src/generators/client.ts
 function generateClientFile(options = {}) {
   const { queryClientPath } = options;
@@ -583,15 +699,14 @@ export const clientManager = new ClientManager({
   assertSafeCanisterName,
   assertSafeModuleSpecifier,
   declarationsExist,
-  extractMethods,
   generateClientFile,
   generateDeclarations,
   generateReactorEntryFile,
   generateReactorFile,
   getReactorName,
   getServiceTypeName,
-  parseDIDFile,
   resolveContainedOutDir,
+  resolveDeclarationsBaseName,
   runCanisterPipeline,
   toPascalCase
 });