@ic-reactor/vite-plugin 0.13.0 → 0.14.0

package/README.md

@@ -40,8 +40,14 @@ export const clientManager = new ClientManager({
 })
 ```
 
-No opt-in flag is needed to pick up the plugin's environment: the plugin sets
-the `ic_env` cookie and `ClientManager` reads it automatically in the browser.
+No opt-in flag is needed to pick up the plugin's environment in development:
+the plugin sets the `ic_env` cookie and `ClientManager` reads it automatically
+in the browser. That trust stops at the local replica — cookies are not
+origin-isolated, so on a custom domain or mainnet the cookie is ignored and a
+reactor with no `canisterId` throws. Set the per-canister `canisterId` in the
+plugin config to bake it into the generated output for those builds, or pass
+`allowEnvConfig: true` to `ClientManager` if you trust every subdomain of the
+domain you serve from.
 
 The plugin generates files under `src/declarations/<canister>/` by default —
 `declarations/<did-basename>.{js,d.ts,did}` plus a managed `index.generated.ts`
@@ -51,6 +57,12 @@ exports the reactor and six hooks named after the canister
 `use<Canister>InfiniteQuery`, `use<Canister>SuspenseInfiniteQuery`,
 `use<Canister>Mutation`, `use<Canister>Method`).
 
+If Prettier resolves from Vite's `config.root`, the plugin formats the
+generated `.js` and `.d.ts` with it and your Prettier config, so a rebuild
+leaves formatted, committed declarations unchanged. Without Prettier they hold
+the Candid parser's output followed by a newline, and a formatting error never
+fails the build.
+
 If you want non-React output, set `target: "core"` and install the matching
 runtime package instead of `@ic-reactor/react`.
 
@@ -134,6 +146,9 @@ when that happens with canisters configured, because the failure is otherwise
 indistinguishable from success until the app breaks on an undefined canister
 id. Run with `DEBUG=ic-reactor` to see the `icp` output behind the warning.
 
+If your Vite config already sets `server.proxy["/api"]`, the plugin leaves that
+entry alone, whether detection succeeds or not.
+
 ## File Regeneration
 
 On startup and on `.did` file changes, the plugin regenerates declarations and

package/dist/index.cjs

@@ -38,12 +38,13 @@ var import_codegen = require("@ic-reactor/codegen");
 
 // src/env.ts
 var import_child_process = require("child_process");
-function getIcEnvironmentInfo(canisterNames) {
+function getIcEnvironmentInfo(canisterNames, projectRoot = process.cwd()) {
   const networkName = process.env.ICP_ENVIRONMENT || "local";
   const diagnostics = [];
   try {
     const networkStatus = JSON.parse(
       (0, import_child_process.execFileSync)("icp", ["network", "status", "-e", networkName, "--json"], {
+        cwd: projectRoot,
         encoding: "utf-8",
         // stderr is piped rather than ignored so a failure can explain itself.
         // Piping still keeps it off the terminal — it only reaches the user if
@@ -65,7 +66,11 @@ function getIcEnvironmentInfo(canisterNames) {
         const canisterId = (0, import_child_process.execFileSync)(
           "icp",
           ["canister", "status", name, "-e", networkName, "-i"],
-          { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
+          {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"]
+          }
         ).trim();
         if (canisterId) {
           canisterIds[name] = canisterId;
@@ -153,7 +158,7 @@ function icReactor(options) {
   const configuredCanisterIds = Object.fromEntries(
     canisters.filter((canister) => !!canister.canisterId).map((canister) => [canister.name, canister.canisterId])
   );
-  let pendingFailure = null;
+  const pendingFailures = /* @__PURE__ */ new Map();
   const reportFailure = (server, message, cause) => {
     console.error(`[ic-reactor] ${message}`);
     const err = {
@@ -161,8 +166,8 @@ function icReactor(options) {
       stack: cause instanceof Error && cause.stack ? cause.stack : "",
       plugin: PLUGIN_NAME
     };
-    pendingFailure = { message: err.message, stack: err.stack };
     server?.ws.send({ type: "error", err });
+    return { message: err.message, stack: err.stack };
   };
   const inFlight = /* @__PURE__ */ new Map();
   const rerunQueued = /* @__PURE__ */ new Set();
@@ -179,19 +184,25 @@ function icReactor(options) {
       globalConfig
     }).then((result) => {
       if (result.success) {
-        pendingFailure = null;
+        pendingFailures.delete(name);
         server.ws.send({ type: "full-reload" });
       } else {
-        reportFailure(
-          server,
-          `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+        pendingFailures.set(
+          name,
+          reportFailure(
+            server,
+            `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+          )
         );
       }
     }).catch((error) => {
-      reportFailure(
-        server,
-        `Regeneration failed for ${name}: ${describeError(error)}`,
-        error
+      pendingFailures.set(
+        name,
+        reportFailure(
+          server,
+          `Regeneration failed for ${name}: ${describeError(error)}`,
+          error
+        )
       );
     }).finally(() => {
       inFlight.delete(name);
@@ -206,7 +217,7 @@ function icReactor(options) {
     name: PLUGIN_NAME,
     enforce: "pre",
     // Run before other plugins
-    config(_config, { command: viteCommand }) {
+    config(userConfig, { command: viteCommand }) {
       command = viteCommand;
       if (viteCommand !== "serve" || !injectEnvironment) {
         return {};
@@ -215,7 +226,10 @@ function icReactor(options) {
       if (!canisterNames.includes("internet_identity")) {
         canisterNames.push("internet_identity");
       }
-      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(canisterNames);
+      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(
+        canisterNames,
+        import_node_path.default.resolve(userConfig.root ?? process.cwd())
+      );
       if (!icEnv) {
         if (canisters.length > 0) {
           console.warn(
@@ -235,12 +249,7 @@ function icReactor(options) {
             headers: envOnlyCookie ? {
               "Set-Cookie": `ic_env=${envOnlyCookie}; Path=/; SameSite=Lax;`
             } : void 0,
-            proxy: {
-              "/api": {
-                target: DEFAULT_LOCAL_REPLICA,
-                changeOrigin: true
-              }
-            }
+            proxy: apiProxy(userConfig, DEFAULT_LOCAL_REPLICA)
           }
         };
       }
@@ -270,12 +279,7 @@ function icReactor(options) {
           headers: {
             "Set-Cookie": `ic_env=${cookieValue}; Path=/; SameSite=Lax;`
           },
-          proxy: {
-            "/api": {
-              target: icEnv.proxyTarget,
-              changeOrigin: true
-            }
-          }
+          proxy: apiProxy(userConfig, icEnv.proxyTarget)
         }
       };
     },
@@ -286,10 +290,15 @@ function icReactor(options) {
     configureServer(server) {
       devServer = server;
       server.ws.on?.("connection", () => {
-        if (!pendingFailure) return;
+        if (pendingFailures.size === 0) return;
+        const failures = [...pendingFailures.values()];
         server.ws.send({
           type: "error",
-          err: { ...pendingFailure, plugin: PLUGIN_NAME }
+          err: {
+            message: failures.map((failure) => failure.message).join("\n"),
+            stack: failures.map((failure) => failure.stack).filter(Boolean).join("\n"),
+            plugin: PLUGIN_NAME
+          }
         });
       });
       const didFiles = canisters.map((c) => resolveDidPath(c.didFile));
@@ -311,10 +320,15 @@ function icReactor(options) {
       const failures = outcomes.flatMap((outcome, index) => {
         const name = canisters[index]?.name ?? `canister #${index}`;
         if (outcome.status === "rejected") {
-          return [`${name}: ${describeError(outcome.reason)}`];
+          return [{ name, detail: `${name}: ${describeError(outcome.reason)}` }];
         }
         if (!outcome.value.success) {
-          return [`${name}: ${outcome.value.error ?? "unknown error"}`];
+          return [
+            {
+              name,
+              detail: `${name}: ${outcome.value.error ?? "unknown error"}`
+            }
+          ];
         }
         return [];
       });
@@ -322,28 +336,35 @@ function icReactor(options) {
         return;
       }
       const message = `Failed to generate ${failures.length} of ${canisters.length} canisters:
-` + failures.map((failure) => `  - ${failure}`).join("\n");
+` + failures.map(({ detail }) => `  - ${detail}`).join("\n");
       if (failOnError ?? command === "build") {
         this.error(`[ic-reactor] ${message}`);
       }
       reportFailure(devServer, message);
+      for (const { name, detail } of failures) {
+        pendingFailures.set(name, {
+          message: `[ic-reactor] Failed to generate ${detail}`,
+          stack: ""
+        });
+      }
     },
     handleHotUpdate({ file, server }) {
       if (!file.endsWith(".did")) {
         return;
       }
       const changedPath = import_node_path.default.normalize(file);
-      const affectedCanister = canisters.find(
-        // Check if changed file matches configured didFile
+      const affectedCanisters = canisters.filter(
         (canister) => resolveDidPath(canister.didFile) === changedPath
       );
-      if (!affectedCanister) {
+      if (affectedCanisters.length === 0) {
         return;
       }
       console.log(
-        `[ic-reactor] .did file changed: ${affectedCanister.name}. Regenerating...`
+        `[ic-reactor] .did file changed: ${affectedCanisters.map((canister) => canister.name).join(", ")}. Regenerating...`
       );
-      return regenerate(affectedCanister, server);
+      return Promise.all(
+        affectedCanisters.map((canister) => regenerate(canister, server))
+      ).then(() => void 0);
     }
   };
   return plugin;
@@ -351,6 +372,15 @@ function icReactor(options) {
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function apiProxy(userConfig, target) {
+  if (userConfig.server?.proxy?.["/api"]) {
+    debugLog(
+      `The Vite config already proxies /api, so the plugin keeps that proxy instead of sending /api to ${target}.`
+    );
+    return void 0;
+  }
+  return { "/api": { target, changeOrigin: true } };
+}
 function debugLog(message) {
   const enabled = (process.env.DEBUG ?? "").split(",").some((entry) => {
     const scope = entry.trim();

package/dist/index.js

@@ -6,12 +6,13 @@ import {
 
 // src/env.ts
 import { execFileSync } from "child_process";
-function getIcEnvironmentInfo(canisterNames) {
+function getIcEnvironmentInfo(canisterNames, projectRoot = process.cwd()) {
   const networkName = process.env.ICP_ENVIRONMENT || "local";
   const diagnostics = [];
   try {
     const networkStatus = JSON.parse(
       execFileSync("icp", ["network", "status", "-e", networkName, "--json"], {
+        cwd: projectRoot,
         encoding: "utf-8",
         // stderr is piped rather than ignored so a failure can explain itself.
         // Piping still keeps it off the terminal — it only reaches the user if
@@ -33,7 +34,11 @@ function getIcEnvironmentInfo(canisterNames) {
         const canisterId = execFileSync(
           "icp",
           ["canister", "status", name, "-e", networkName, "-i"],
-          { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
+          {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"]
+          }
         ).trim();
         if (canisterId) {
           canisterIds[name] = canisterId;
@@ -121,7 +126,7 @@ function icReactor(options) {
   const configuredCanisterIds = Object.fromEntries(
     canisters.filter((canister) => !!canister.canisterId).map((canister) => [canister.name, canister.canisterId])
   );
-  let pendingFailure = null;
+  const pendingFailures = /* @__PURE__ */ new Map();
   const reportFailure = (server, message, cause) => {
     console.error(`[ic-reactor] ${message}`);
     const err = {
@@ -129,8 +134,8 @@ function icReactor(options) {
       stack: cause instanceof Error && cause.stack ? cause.stack : "",
       plugin: PLUGIN_NAME
     };
-    pendingFailure = { message: err.message, stack: err.stack };
     server?.ws.send({ type: "error", err });
+    return { message: err.message, stack: err.stack };
   };
   const inFlight = /* @__PURE__ */ new Map();
   const rerunQueued = /* @__PURE__ */ new Set();
@@ -147,19 +152,25 @@ function icReactor(options) {
       globalConfig
     }).then((result) => {
       if (result.success) {
-        pendingFailure = null;
+        pendingFailures.delete(name);
         server.ws.send({ type: "full-reload" });
       } else {
-        reportFailure(
-          server,
-          `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+        pendingFailures.set(
+          name,
+          reportFailure(
+            server,
+            `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+          )
         );
       }
     }).catch((error) => {
-      reportFailure(
-        server,
-        `Regeneration failed for ${name}: ${describeError(error)}`,
-        error
+      pendingFailures.set(
+        name,
+        reportFailure(
+          server,
+          `Regeneration failed for ${name}: ${describeError(error)}`,
+          error
+        )
       );
     }).finally(() => {
       inFlight.delete(name);
@@ -174,7 +185,7 @@ function icReactor(options) {
     name: PLUGIN_NAME,
     enforce: "pre",
     // Run before other plugins
-    config(_config, { command: viteCommand }) {
+    config(userConfig, { command: viteCommand }) {
       command = viteCommand;
       if (viteCommand !== "serve" || !injectEnvironment) {
         return {};
@@ -183,7 +194,10 @@ function icReactor(options) {
       if (!canisterNames.includes("internet_identity")) {
         canisterNames.push("internet_identity");
       }
-      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(canisterNames);
+      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(
+        canisterNames,
+        path.resolve(userConfig.root ?? process.cwd())
+      );
       if (!icEnv) {
         if (canisters.length > 0) {
           console.warn(
@@ -203,12 +217,7 @@ function icReactor(options) {
             headers: envOnlyCookie ? {
               "Set-Cookie": `ic_env=${envOnlyCookie}; Path=/; SameSite=Lax;`
             } : void 0,
-            proxy: {
-              "/api": {
-                target: DEFAULT_LOCAL_REPLICA,
-                changeOrigin: true
-              }
-            }
+            proxy: apiProxy(userConfig, DEFAULT_LOCAL_REPLICA)
           }
         };
       }
@@ -238,12 +247,7 @@ function icReactor(options) {
           headers: {
             "Set-Cookie": `ic_env=${cookieValue}; Path=/; SameSite=Lax;`
           },
-          proxy: {
-            "/api": {
-              target: icEnv.proxyTarget,
-              changeOrigin: true
-            }
-          }
+          proxy: apiProxy(userConfig, icEnv.proxyTarget)
         }
       };
     },
@@ -254,10 +258,15 @@ function icReactor(options) {
     configureServer(server) {
       devServer = server;
       server.ws.on?.("connection", () => {
-        if (!pendingFailure) return;
+        if (pendingFailures.size === 0) return;
+        const failures = [...pendingFailures.values()];
         server.ws.send({
           type: "error",
-          err: { ...pendingFailure, plugin: PLUGIN_NAME }
+          err: {
+            message: failures.map((failure) => failure.message).join("\n"),
+            stack: failures.map((failure) => failure.stack).filter(Boolean).join("\n"),
+            plugin: PLUGIN_NAME
+          }
         });
       });
       const didFiles = canisters.map((c) => resolveDidPath(c.didFile));
@@ -279,10 +288,15 @@ function icReactor(options) {
       const failures = outcomes.flatMap((outcome, index) => {
         const name = canisters[index]?.name ?? `canister #${index}`;
         if (outcome.status === "rejected") {
-          return [`${name}: ${describeError(outcome.reason)}`];
+          return [{ name, detail: `${name}: ${describeError(outcome.reason)}` }];
         }
         if (!outcome.value.success) {
-          return [`${name}: ${outcome.value.error ?? "unknown error"}`];
+          return [
+            {
+              name,
+              detail: `${name}: ${outcome.value.error ?? "unknown error"}`
+            }
+          ];
         }
         return [];
       });
@@ -290,28 +304,35 @@ function icReactor(options) {
         return;
       }
       const message = `Failed to generate ${failures.length} of ${canisters.length} canisters:
-` + failures.map((failure) => `  - ${failure}`).join("\n");
+` + failures.map(({ detail }) => `  - ${detail}`).join("\n");
       if (failOnError ?? command === "build") {
         this.error(`[ic-reactor] ${message}`);
       }
       reportFailure(devServer, message);
+      for (const { name, detail } of failures) {
+        pendingFailures.set(name, {
+          message: `[ic-reactor] Failed to generate ${detail}`,
+          stack: ""
+        });
+      }
     },
     handleHotUpdate({ file, server }) {
       if (!file.endsWith(".did")) {
         return;
       }
       const changedPath = path.normalize(file);
-      const affectedCanister = canisters.find(
-        // Check if changed file matches configured didFile
+      const affectedCanisters = canisters.filter(
         (canister) => resolveDidPath(canister.didFile) === changedPath
       );
-      if (!affectedCanister) {
+      if (affectedCanisters.length === 0) {
         return;
       }
       console.log(
-        `[ic-reactor] .did file changed: ${affectedCanister.name}. Regenerating...`
+        `[ic-reactor] .did file changed: ${affectedCanisters.map((canister) => canister.name).join(", ")}. Regenerating...`
       );
-      return regenerate(affectedCanister, server);
+      return Promise.all(
+        affectedCanisters.map((canister) => regenerate(canister, server))
+      ).then(() => void 0);
     }
   };
   return plugin;
@@ -319,6 +340,15 @@ function icReactor(options) {
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function apiProxy(userConfig, target) {
+  if (userConfig.server?.proxy?.["/api"]) {
+    debugLog(
+      `The Vite config already proxies /api, so the plugin keeps that proxy instead of sending /api to ${target}.`
+    );
+    return void 0;
+  }
+  return { "/api": { target, changeOrigin: true } };
+}
 function debugLog(message) {
   const enabled = (process.env.DEBUG ?? "").split(",").some((entry) => {
     const scope = entry.trim();

package/llms.txt

@@ -34,7 +34,14 @@ icReactor({
   `injectEnvironment`, `failOnError`
 - Per canister (inside `canisters[]`): `name`, `didFile`, `outDir`,
   `clientManagerPath`, `target`, `mode`, `canisterId`
-- `injectEnvironment` for local `ic_env` cookie + `/api` proxy behavior
+- `injectEnvironment` for local `ic_env` cookie + `/api` proxy behavior. The
+  consumer side is a positive allowlist: `ClientManager` trusts the cookie — its
+  root key, its Internet Identity provider, and the canister IDs a reactor
+  resolves by name — only for loopback, `localhost`, and dev-container hosts.
+  Serving a dev build over a tunnel or custom domain needs
+  `allowEnvConfig: true` (formerly `allowEnvRootKey`); without it a generated
+  reactor that carries no `canisterId` throws instead of reading one from the
+  cookie — see `packages/core/llms.txt`
 - `failOnError` overrides the default (`true` for build, `false` for dev)
 
 ## Best Practices

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/vite-plugin",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Vite plugin for zero-config IC reactor generation from Candid files",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -50,16 +50,16 @@
   },
   "homepage": "https://ic-reactor.b3pay.net/v3/packages/vite-plugin",
   "dependencies": {
-    "@ic-reactor/codegen": "0.13.0"
+    "@ic-reactor/codegen": "0.14.0"
   },
   "peerDependencies": {
     "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.5.1",
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.json",

package/src/env.ts

@@ -29,9 +29,14 @@ export interface IcEnvironmentDetection {
 
 /**
  * Detect the IC environment using the `icp` CLI.
+ *
+ * @param projectRoot - Directory `icp` runs in. `icp` finds its project by
+ * looking for `icp.yaml` there and in each parent directory, so this has to be
+ * the app's root and not wherever the process happened to start.
  */
 export function getIcEnvironmentInfo(
-  canisterNames: string[]
+  canisterNames: string[],
+  projectRoot: string = process.cwd()
 ): IcEnvironmentDetection {
   const networkName = process.env.ICP_ENVIRONMENT || "local"
   const diagnostics: string[] = []
@@ -39,6 +44,7 @@ export function getIcEnvironmentInfo(
   try {
     const networkStatus = JSON.parse(
       execFileSync("icp", ["network", "status", "-e", networkName, "--json"], {
+        cwd: projectRoot,
         encoding: "utf-8",
         // stderr is piped rather than ignored so a failure can explain itself.
         // Piping still keeps it off the terminal — it only reaches the user if
@@ -69,7 +75,11 @@ export function getIcEnvironmentInfo(
         const canisterId = execFileSync(
           "icp",
           ["canister", "status", name, "-e", networkName, "-i"],
-          { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
+          {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+          }
         ).trim()
 
         if (canisterId) {

package/src/index.ts

@@ -7,7 +7,7 @@
  * 3. Hot-reloads when .did files change
  */
 
-import type { Plugin, ResolvedConfig, ViteDevServer } from "vite"
+import type { Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite"
 import path from "node:path"
 import {
   runCanisterPipeline,
@@ -115,16 +115,21 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
    * the browser error overlay is the signal that actually gets noticed.
    */
   /**
-   * The last failure, kept so a browser that was not connected when it happened
-   * still gets the overlay.
+   * The failures that are still unfixed, one per canister, kept so a browser
+   * that was not connected when one happened still gets the overlay.
    *
    * Vite awaits the plugin container's `buildStart` before the HTTP server
    * starts listening, so a generation failure during `vite dev` startup is
    * broadcast when there are no WebSocket clients at all and the payload is
    * simply dropped. The terminal shows it; the overlay never appears — for
    * precisely the failures a developer is most likely to hit.
+   *
+   * A success only proves that the canister which regenerated is fixed. This
+   * used to be one slot that any success emptied, so a canister that was still
+   * broken vanished from the overlay as soon as another canister regenerated
+   * and its reload reconnected every tab.
    */
-  let pendingFailure: { message: string; stack: string } | null = null
+  const pendingFailures = new Map<string, { message: string; stack: string }>()
 
   const reportFailure = (
     server: ViteDevServer | null,
@@ -139,8 +144,8 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
       plugin: PLUGIN_NAME,
     }
 
-    pendingFailure = { message: err.message, stack: err.stack }
     server?.ws.send({ type: "error", err })
+    return { message: err.message, stack: err.stack }
   }
 
   // Keep at most one regeneration per canister in flight and collapse every save
@@ -183,13 +188,16 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
         if (result.success) {
           // A later connection must not be handed a failure that has since been
           // fixed.
-          pendingFailure = null
+          pendingFailures.delete(name)
           // Reload page to reflect new types/hooks
           server.ws.send({ type: "full-reload" })
         } else {
-          reportFailure(
-            server,
-            `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+          pendingFailures.set(
+            name,
+            reportFailure(
+              server,
+              `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
+            )
           )
         }
       })
@@ -198,10 +206,13 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
       // rejection: invisible in the browser and, depending on the Node version,
       // fatal to the dev server.
       .catch((error: unknown) => {
-        reportFailure(
-          server,
-          `Regeneration failed for ${name}: ${describeError(error)}`,
-          error
+        pendingFailures.set(
+          name,
+          reportFailure(
+            server,
+            `Regeneration failed for ${name}: ${describeError(error)}`,
+            error
+          )
         )
       })
       .finally(() => {
@@ -219,7 +230,7 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
     name: PLUGIN_NAME,
     enforce: "pre", // Run before other plugins
 
-    config(_config, { command: viteCommand }) {
+    config(userConfig, { command: viteCommand }) {
       command = viteCommand
 
       if (viteCommand !== "serve" || !injectEnvironment) {
@@ -236,8 +247,13 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
         canisterNames.push("internet_identity")
       }
 
-      const { environment: icEnv, diagnostics } =
-        getIcEnvironmentInfo(canisterNames)
+      // `configResolved` has not run yet, so resolve the root the way Vite
+      // will. icp finds the project from the directory it starts in, and with
+      // `vite apps/web` or a `root` option that is not the process cwd.
+      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(
+        canisterNames,
+        path.resolve(userConfig.root ?? process.cwd())
+      )
 
       if (!icEnv) {
         // Failing detection used to be indistinguishable from success: no
@@ -274,12 +290,7 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
                   "Set-Cookie": `ic_env=${envOnlyCookie}; Path=/; SameSite=Lax;`,
                 }
               : undefined,
-            proxy: {
-              "/api": {
-                target: DEFAULT_LOCAL_REPLICA,
-                changeOrigin: true,
-              },
-            },
+            proxy: apiProxy(userConfig, DEFAULT_LOCAL_REPLICA),
           },
         }
       }
@@ -334,12 +345,7 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
           headers: {
             "Set-Cookie": `ic_env=${cookieValue}; Path=/; SameSite=Lax;`,
           },
-          proxy: {
-            "/api": {
-              target: icEnv.proxyTarget,
-              changeOrigin: true,
-            },
-          },
+          proxy: apiProxy(userConfig, icEnv.proxyTarget),
         },
       }
     },
@@ -355,16 +361,24 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
     configureServer(server) {
       devServer = server
 
-      // Replay a startup failure to the first client that connects — see
-      // pendingFailure. Cleared once generation succeeds.
+      // Replay the unfixed failures described at pendingFailures to each client
+      // that connects. A canister leaves the replay once it regenerates.
       // Guarded: the peer range spans several Vite majors and `ws.on` is not
       // present on every one of them. Losing the replay is acceptable; throwing
       // out of configureServer is not.
       server.ws.on?.("connection", () => {
-        if (!pendingFailure) return
+        if (pendingFailures.size === 0) return
+        const failures = [...pendingFailures.values()]
         server.ws.send({
           type: "error",
-          err: { ...pendingFailure, plugin: PLUGIN_NAME },
+          err: {
+            message: failures.map((failure) => failure.message).join("\n"),
+            stack: failures
+              .map((failure) => failure.stack)
+              .filter(Boolean)
+              .join("\n"),
+            plugin: PLUGIN_NAME,
+          },
         })
       })
 
@@ -397,10 +411,15 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
         const name = canisters[index]?.name ?? `canister #${index}`
 
         if (outcome.status === "rejected") {
-          return [`${name}: ${describeError(outcome.reason)}`]
+          return [{ name, detail: `${name}: ${describeError(outcome.reason)}` }]
         }
         if (!outcome.value.success) {
-          return [`${name}: ${outcome.value.error ?? "unknown error"}`]
+          return [
+            {
+              name,
+              detail: `${name}: ${outcome.value.error ?? "unknown error"}`,
+            },
+          ]
         }
         return []
       })
@@ -411,7 +430,7 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
 
       const message =
         `Failed to generate ${failures.length} of ${canisters.length} canisters:\n` +
-        failures.map((failure) => `  - ${failure}`).join("\n")
+        failures.map(({ detail }) => `  - ${detail}`).join("\n")
 
       // Previously every failure here was a `console.error` and nothing more,
       // so `vite build` exited 0 and CI shipped whatever stale bindings were
@@ -421,6 +440,15 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
       }
 
       reportFailure(devServer, message)
+
+      // One entry per canister, so fixing one of them removes only its own line
+      // from the replay.
+      for (const { name, detail } of failures) {
+        pendingFailures.set(name, {
+          message: `[ic-reactor] Failed to generate ${detail}`,
+          stack: "",
+        })
+      }
     },
 
     handleHotUpdate({ file, server }) {
@@ -430,23 +458,29 @@ export function icReactor(options: IcReactorPluginOptions): Plugin {
       }
 
       const changedPath = path.normalize(file)
-      const affectedCanister = canisters.find(
-        // Check if changed file matches configured didFile
+      // Every canister, not only the first match. Deployed instances of one
+      // canister, such as two ledgers, share a .did file. Stopping at the first
+      // match left the others on stale bindings, and the full reload hid that.
+      const affectedCanisters = canisters.filter(
         (canister) => resolveDidPath(canister.didFile) === changedPath
       )
 
-      if (!affectedCanister) {
+      if (affectedCanisters.length === 0) {
         return
       }
 
       console.log(
-        `[ic-reactor] .did file changed: ${affectedCanister.name}. Regenerating...`
+        `[ic-reactor] .did file changed: ${affectedCanisters
+          .map((canister) => canister.name)
+          .join(", ")}. Regenerating...`
       )
 
       // Returned so Vite waits for the write to finish before applying the
       // update; it resolves to `undefined`, which leaves the affected module
       // list untouched.
-      return regenerate(affectedCanister, server)
+      return Promise.all(
+        affectedCanisters.map((canister) => regenerate(canister, server))
+      ).then(() => undefined)
     },
   }
 
@@ -458,6 +492,27 @@ function describeError(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
+/**
+ * The `server.proxy` entry that sends `/api` to `target`, or nothing when the
+ * user's Vite config already proxies `/api`.
+ *
+ * Vite deep-merges the object a `config` hook returns over the user's config,
+ * so an `/api` entry returned here replaced the user's own. A project that
+ * pointed `/api` at icp-cli's port 8000 got 4943 instead, and nothing reported
+ * the swap. Vite's merge skips an undefined value, so returning nothing leaves
+ * the user's entry in place.
+ */
+function apiProxy(userConfig: UserConfig, target: string) {
+  if (userConfig.server?.proxy?.["/api"]) {
+    debugLog(
+      `The Vite config already proxies /api, so the plugin keeps that proxy instead of sending /api to ${target}.`
+    )
+    return undefined
+  }
+
+  return { "/api": { target, changeOrigin: true } }
+}
+
 /**
  * `icp` failing to answer is routine — no local replica, or a canister that has
  * never been deployed — so its stderr is noise until someone is actually