@ic-reactor/vite-plugin 0.15.1 → 4.0.0-beta.1

package/dist/index.cjs

@@ -33,9 +33,8 @@ __export(index_exports, {
   icReactor: () => icReactor
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_codegen = require("@ic-reactor/codegen");
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/env.ts
 var import_child_process = require("child_process");
@@ -268,149 +267,549 @@ function icEnvMiddleware(environment) {
   };
 }
 
+// src/generate.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var CANDID_CORE_CLI_VERSION = "0.2.0-beta.1";
+var REPORT_SCHEMA_VERSION = 1;
+var GENERATE_TIMEOUT_MS = 6e4;
+var MAX_STREAMED_LINES = 200;
+var MAX_LINE_CHARS = 4096;
+var MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+function resolveCliBin(root) {
+  const requireFromApp = (0, import_node_module.createRequire)(import_node_path.default.join(root, "package.json"));
+  let manifestPath;
+  try {
+    manifestPath = requireFromApp.resolve("@candid-core/cli/package.json");
+  } catch {
+    throw new Error(
+      `cannot find @candid-core/cli from ${root}. Install the generator that pairs with this plugin next to @candid-core/schema: npm install --save-dev --save-exact @candid-core/cli@${CANDID_CORE_CLI_VERSION}`
+    );
+  }
+  const manifest = JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf-8"));
+  const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.["candid-core-cli"];
+  if (!bin) {
+    throw new Error(
+      `${manifestPath} declares no candid-core-cli bin, so it is not the generator this plugin runs`
+    );
+  }
+  return import_node_path.default.resolve(import_node_path.default.dirname(manifestPath), bin);
+}
+var keep = (text, chunk) => text.length >= MAX_OUTPUT_BYTES ? text : text + chunk;
+function runProcess(bin, args, cwd, timeoutMs, signal, onStderrLine) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const stopped = {
+      code: null,
+      signal: null,
+      problem: "was stopped",
+      stopped: true
+    };
+    if (signal?.aborted) {
+      resolve({ stdout, stderr, ...stopped });
+      return;
+    }
+    let unfinished = "";
+    let cut = false;
+    let passed = 0;
+    const pass = (text) => {
+      if (!text.trim() || passed > MAX_STREAMED_LINES) return;
+      passed++;
+      onStderrLine?.(
+        passed > MAX_STREAMED_LINES ? `more than ${MAX_STREAMED_LINES} lines on stderr: the rest is not logged` : text.trimEnd()
+      );
+    };
+    const passUnfinished = () => {
+      pass(
+        cut ? `${unfinished} [line cut at ${MAX_LINE_CHARS} characters]` : unfinished
+      );
+      unfinished = "";
+      cut = false;
+    };
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      passUnfinished();
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", stop);
+      resolve({ stdout, stderr, ...result });
+    };
+    const stop = () => {
+      unfinished = "";
+      cut = false;
+      child.kill("SIGKILL");
+      settle(stopped);
+    };
+    const child = (0, import_node_child_process.spawn)(process.execPath, [bin, ...args], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    signal?.addEventListener("abort", stop, { once: true });
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => stdout = keep(stdout, chunk));
+    child.stderr.on("data", (chunk) => {
+      stderr = keep(stderr, chunk);
+      if (settled || !onStderrLine || passed > MAX_STREAMED_LINES) return;
+      const pieces = chunk.split(/\r?\n/);
+      pieces.forEach((piece, index) => {
+        const room = MAX_LINE_CHARS - unfinished.length;
+        if (piece.length > room) cut = true;
+        unfinished += piece.slice(0, room);
+        if (index < pieces.length - 1) passUnfinished();
+      });
+    });
+    child.on(
+      "error",
+      (error) => settle({
+        code: null,
+        signal: null,
+        problem: `could not start: ${error.message}`,
+        unstartable: true
+      })
+    );
+    child.on(
+      "close",
+      (code, signal2) => settle({
+        code,
+        signal: signal2,
+        problem: timedOut ? `did not finish within ${timeoutMs / 1e3}s and was killed` : void 0
+      })
+    );
+  });
+}
+function describeProcess(run, reason) {
+  const ending = run.problem ?? (run.signal ? `was killed by ${run.signal}` : `exited with code ${run.code}`);
+  const lines = [`candid-core-cli ${ending}`];
+  if (reason) lines.push(reason);
+  const stderr = run.stderr.trim();
+  if (stderr) lines.push(stderr);
+  return lines.join("\n");
+}
+function parseReport(stdout, count) {
+  let report;
+  try {
+    report = JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+  const { schemaVersion, entries } = report ?? {};
+  if (schemaVersion !== REPORT_SCHEMA_VERSION) {
+    throw new Error(
+      `its report has schemaVersion ${String(schemaVersion)}, and this plugin reads ${REPORT_SCHEMA_VERSION}; install @candid-core/cli@${CANDID_CORE_CLI_VERSION}`
+    );
+  }
+  if (!Array.isArray(entries) || entries.length !== count) {
+    throw new Error(`its report does not have one entry per .did (${count})`);
+  }
+  return entries.map((entry) => {
+    const { status, module: module2, omitted, diagnostics } = entry;
+    return {
+      status: String(status),
+      module: typeof module2 === "string" ? module2 : void 0,
+      omitted: Array.isArray(omitted) ? omitted : [],
+      diagnostics: Array.isArray(diagnostics) ? diagnostics : []
+    };
+  });
+}
+function formatDiagnostic(diagnostic) {
+  const { code, message, notes } = diagnostic ?? {};
+  if (typeof message !== "string") return JSON.stringify(diagnostic);
+  const lead = typeof code === "string" ? `${code}: ${message}` : message;
+  const extra = Array.isArray(notes) ? notes.map((note) => `  ${note}`) : [];
+  return [lead, ...extra].join("\n");
+}
+async function runGroup(context, outDir, units) {
+  const run = await runProcess(
+    context.cli,
+    ["gen", ...units.map((unit) => unit.didFile), "-o", outDir, "--json"],
+    context.root,
+    context.timeoutMs,
+    context.signal,
+    (line) => context.onStderr?.(
+      line,
+      units.map((unit) => unit.didFile)
+    )
+  );
+  let entries;
+  let reason;
+  if (!run.problem) {
+    try {
+      entries = parseReport(run.stdout, units.length);
+      if (!entries && run.code === 0) reason = "it printed no report";
+    } catch (error) {
+      reason = error instanceof Error ? error.message : String(error);
+    }
+  }
+  if (!entries) {
+    if (units.length > 1 && !run.unstartable && !run.stopped) {
+      const results = await Promise.all(
+        units.map((unit) => runGroup(context, outDir, [unit]))
+      );
+      return { outcomes: results.flatMap((result) => result.outcomes) };
+    }
+    const failure = describeProcess(run, reason);
+    return {
+      outcomes: units.map(({ names }) => ({
+        names,
+        status: "failed",
+        omitted: [],
+        failure
+      }))
+    };
+  }
+  return {
+    outcomes: units.map((unit, index) => {
+      const entry = entries[index];
+      if (entry.status === "failed") {
+        return {
+          names: unit.names,
+          status: "failed",
+          omitted: [],
+          failure: entry.diagnostics.map(formatDiagnostic).join("\n") || "candid-core-cli reported the entry as failed"
+        };
+      }
+      return {
+        names: unit.names,
+        module: entry.module,
+        status: entry.status === "unchanged" ? "unchanged" : "written",
+        omitted: entry.omitted
+      };
+    })
+  };
+}
+function quoteNames(names) {
+  return names.map((name) => `"${name}"`).join(", ");
+}
+function foldsCase(dir) {
+  const swapCase = (name) => name.replace(
+    /[a-z]/gi,
+    (letter) => letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase()
+  );
+  const probe = (entry) => {
+    const swapped = import_node_path.default.join(
+      import_node_path.default.dirname(entry),
+      swapCase(import_node_path.default.basename(entry))
+    );
+    if (swapped === entry) return void 0;
+    try {
+      const found = import_node_fs.default.lstatSync(entry, { bigint: true });
+      if (found.ino === 0n) return void 0;
+      try {
+        const other = import_node_fs.default.lstatSync(swapped, { bigint: true });
+        return other.dev === found.dev && other.ino === found.ino;
+      } catch (error) {
+        return error.code === "ENOENT" ? false : void 0;
+      }
+    } catch {
+      return void 0;
+    }
+  };
+  for (let at = dir; ; at = import_node_path.default.dirname(at)) {
+    let names = [];
+    try {
+      names = import_node_fs.default.readdirSync(at);
+    } catch {
+    }
+    const named = names.find((name) => swapCase(name) !== name);
+    const verdict = (named === void 0 ? void 0 : probe(import_node_path.default.join(at, named))) ?? probe(at);
+    if (verdict !== void 0) return verdict;
+    if (import_node_path.default.dirname(at) === at) return void 0;
+  }
+}
+async function generate(request) {
+  const { root } = request;
+  const units = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Map();
+  const refused = /* @__PURE__ */ new Map();
+  const folding = /* @__PURE__ */ new Map();
+  const targetOf = (unit) => {
+    let folds = folding.get(unit.outDir);
+    if (folds === void 0) {
+      folds = (request.foldsCase ?? foldsCase)(unit.outDir) ?? false;
+      folding.set(unit.outDir, folds);
+    }
+    return folds ? moduleOf(unit).toLowerCase() : moduleOf(unit);
+  };
+  for (const canister of request.canisters) {
+    const key = JSON.stringify([canister.didFile, canister.outDir]);
+    const same = units.get(key);
+    if (same) {
+      same.names.push(canister.name);
+      continue;
+    }
+    const unit = {
+      names: [canister.name],
+      didFile: canister.didFile,
+      outDir: canister.outDir
+    };
+    units.set(key, unit);
+    const target = targetOf(unit);
+    const owner = claimed.get(target);
+    if (owner) refused.set(unit, owner);
+    else claimed.set(target, unit);
+  }
+  const outcomes = [...refused].map(([unit, owner]) => ({
+    names: unit.names,
+    status: "failed",
+    omitted: [],
+    failure: `would write ${import_node_path.default.relative(root, moduleOf(unit))}, which ${quoteNames(owner.names)} already writes` + (moduleOf(unit) === moduleOf(owner) ? ". " : ` as ${import_node_path.default.relative(root, moduleOf(owner))}: the filesystem does not tell the two names apart. `) + `The generator names a module after its .did file: rename one file or give one canister its own outDir`
+  }));
+  const groups = /* @__PURE__ */ new Map();
+  for (const unit of units.values()) {
+    if (refused.has(unit)) continue;
+    groups.set(unit.outDir, [...groups.get(unit.outDir) ?? [], unit]);
+  }
+  const results = await Promise.all(
+    [...groups].map(([outDir, members]) => runGroup(request, outDir, members))
+  );
+  return {
+    outcomes: [...outcomes, ...results.flatMap((result) => result.outcomes)]
+  };
+}
+function moduleOf(unit) {
+  return import_node_path.default.join(
+    unit.outDir,
+    import_node_path.default.basename(unit.didFile, import_node_path.default.extname(unit.didFile)) + ".ts"
+  );
+}
+
 // src/index.ts
 var PLUGIN_NAME = "ic-reactor-plugin";
-function icReactor(options) {
-  const {
-    canisters,
-    outDir = "src/declarations",
-    clientManagerPath = "../../clients",
-    target = "react",
-    injectEnvironment = true,
-    failOnError
-  } = options;
-  const globalConfig = {
-    outDir,
-    clientManagerPath,
-    target
-  };
+var DEFAULT_OUT_DIR = "src/canisters";
+var GUIDE_LINE = "ic-reactor: agent guide at node_modules/@ic-reactor/core/llms.txt";
+var consoleLog = {
+  info: (message) => console.log(message),
+  warn: (message) => console.warn(message),
+  error: (message) => console.error(message)
+};
+function icReactor(options = {}) {
+  const { canisters = {}, injectEnvironment = true, failOnError } = options;
+  const names = Object.keys(canisters);
+  const configuredCanisterIds = Object.fromEntries(
+    names.flatMap((name) => {
+      const { canisterId } = canisters[name];
+      return canisterId ? [[name, canisterId]] : [];
+    })
+  );
+  const generated = names.flatMap((name) => {
+    const { didFile, outDir = DEFAULT_OUT_DIR } = canisters[name];
+    return didFile === void 0 ? [] : [{ name, didFile, outDir }];
+  });
   let projectRoot = process.cwd();
   let command = "build";
+  let log = consoleLog;
+  let announced = false;
   let localEnvironment;
   const apiProxyOptions = /* @__PURE__ */ new Set();
   let devServer = null;
-  const resolveDidPath = (didFile) => import_node_path.default.normalize(
-    import_node_path.default.isAbsolute(didFile) ? didFile : import_node_path.default.resolve(projectRoot, didFile)
-  );
+  const didPath = (canister) => import_node_path2.default.resolve(projectRoot, canister.didFile);
+  const relativeToRoot = (file) => import_node_path2.default.relative(projectRoot, file) || ".";
   const generatedFrom = /* @__PURE__ */ new Map();
-  const readDidSource = (canister) => {
+  const unfixed = /* @__PURE__ */ new Map();
+  let tail = Promise.resolve();
+  const serially = (job) => {
+    const result = tail.then(job);
+    tail = result.catch(() => void 0);
+    return result;
+  };
+  const queued = /* @__PURE__ */ new Set();
+  let stopper = new AbortController();
+  const readDid = (canister) => {
     try {
-      return import_node_fs.default.readFileSync(resolveDidPath(canister.didFile), "utf-8");
+      return import_node_fs2.default.readFileSync(didPath(canister), "utf-8");
     } catch {
       return void 0;
     }
   };
-  const describeEntry = (canister) => `canisters[${canisters.indexOf(canister)}] (${JSON.stringify(canister.name)})`;
-  const sharedOutDirError = (canister) => {
-    const first = (0, import_codegen.findSharedOutDirs)(
-      canisters.map((entry) => [entry, entry]),
-      outDir,
-      projectRoot
-    ).get(canister);
-    return first === void 0 ? void 0 : (0, import_codegen.sharedOutDirMessage)(describeEntry(canister), describeEntry(first));
+  const generateNow = async (wanted, force, signal) => {
+    if (signal.aborted) return void 0;
+    try {
+      const sources = new Map(
+        wanted.map((canister) => [canister.name, readDid(canister)])
+      );
+      const stale = wanted.filter(
+        ({ name }) => force || sources.get(name) === void 0 || generatedFrom.get(name) !== sources.get(name)
+      );
+      if (stale.length === 0) return [];
+      let cli;
+      try {
+        cli = resolveCliBin(projectRoot);
+      } catch (error) {
+        return stale.map((canister) => ({ canister, message: describe(error) }));
+      }
+      const result = await generate({
+        cli,
+        root: projectRoot,
+        timeoutMs: GENERATE_TIMEOUT_MS,
+        signal,
+        // Shown as it arrives: a run that takes long, or is killed at the
+        // timeout, would otherwise say nothing until it is over.
+        onStderr: (line, didFiles) => {
+          if (signal.aborted) return;
+          log.warn(
+            `ic-reactor: candid-core-cli (${didFiles.map((file) => relativeToRoot(file)).join(", ")}): ${line}`
+          );
+        },
+        canisters: stale.map((canister) => ({
+          name: canister.name,
+          didFile: didPath(canister),
+          outDir: import_node_path2.default.resolve(projectRoot, canister.outDir)
+        }))
+      });
+      if (signal.aborted) return void 0;
+      const failures = [];
+      for (const outcome of result.outcomes) {
+        const members = stale.filter(({ name }) => outcome.names.includes(name));
+        const names2 = members.map(({ name }) => name).join(", ");
+        if (outcome.status === "failed") {
+          for (const canister of members) {
+            generatedFrom.delete(canister.name);
+            failures.push({ canister, message: outcome.failure ?? "" });
+          }
+          continue;
+        }
+        for (const { name } of members) {
+          const source = sources.get(name);
+          if (source !== void 0) generatedFrom.set(name, source);
+        }
+        if (outcome.status === "written" && outcome.module) {
+          log.info(
+            `ic-reactor: generated ${names2} into ${relativeToRoot(outcome.module)}`
+          );
+        }
+        for (const { kind, name: what, reason, via } of outcome.omitted) {
+          log.warn(
+            `ic-reactor: ${names2}: omitted ${kind} ${what} (${reason}${via ? ` via ${via}` : ""})`
+          );
+        }
+      }
+      return failures;
+    } catch (error) {
+      if (signal.aborted) return void 0;
+      return wanted.map((canister) => ({ canister, message: describe(error) }));
+    }
   };
-  const configuredCanisterIds = Object.fromEntries(
-    canisters.filter((canister) => !!canister.canisterId).map((canister) => [canister.name, canister.canisterId])
-  );
-  const pendingFailures = /* @__PURE__ */ new Map();
-  const reportFailure = (server, message, cause) => {
-    console.error(`[ic-reactor] ${message}`);
-    const err = {
-      message: `[ic-reactor] ${message}`,
-      stack: cause instanceof Error && cause.stack ? cause.stack : "",
-      plugin: PLUGIN_NAME
-    };
-    server?.ws.send({ type: "error", err });
-    return { message: err.message, stack: err.stack };
+  const describeFailures = (failures) => {
+    const byMessage = /* @__PURE__ */ new Map();
+    for (const { canister, message } of failures) {
+      const label = `${canister.name} (${relativeToRoot(didPath(canister))})`;
+      byMessage.set(message, [...byMessage.get(message) ?? [], label]);
+    }
+    return `ic-reactor: could not generate ${failures.length} of ${generated.length} canisters:
+` + [...byMessage].map(
+      ([message, labels]) => `  - ${labels.join(", ")}: ${message.replace(/\n/g, "\n    ")}`
+    ).join("\n");
   };
-  const inFlight = /* @__PURE__ */ new Map();
-  const rerunQueued = /* @__PURE__ */ new Set();
-  const regenerate = (canisterConfig, server) => {
-    const { name } = canisterConfig;
-    const running = inFlight.get(canisterConfig);
-    if (running) {
-      rerunQueued.add(canisterConfig);
-      return running;
+  const publish = (attempted, failures) => {
+    let wasFailing = false;
+    for (const { name } of attempted) {
+      if (unfixed.delete(name)) wasFailing = true;
     }
-    const sharedError = sharedOutDirError(canisterConfig);
-    if (sharedError !== void 0) {
-      pendingFailures.set(
-        canisterConfig,
-        reportFailure(server, `Regeneration failed for ${sharedError}`)
-      );
-      return Promise.resolve();
+    for (const failure of failures) unfixed.set(failure.canister.name, failure);
+    if (failures.length > 0) {
+      log.error(describeFailures(failures));
+      showOverlay();
+    } else if (wasFailing && unfixed.size > 0) {
+      showOverlay();
+    } else if (wasFailing) {
+      devServer?.ws.send({ type: "full-reload" });
     }
-    const run = (0, import_codegen.runCanisterPipeline)({
-      canisterConfig,
-      projectRoot,
-      globalConfig
-    }).then((result) => {
-      reportWarnings(name, result.warnings);
-      if (result.success) {
-        pendingFailures.delete(canisterConfig);
-        server.ws.send({ type: "full-reload" });
-      } else {
-        pendingFailures.set(
-          canisterConfig,
-          reportFailure(
-            server,
-            `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
-          )
-        );
+  };
+  const showOverlay = (client) => {
+    if (unfixed.size === 0) return;
+    const payload = {
+      type: "error",
+      err: {
+        message: describeFailures([...unfixed.values()]),
+        stack: "",
+        plugin: PLUGIN_NAME
       }
-    }).catch((error) => {
-      pendingFailures.set(
-        canisterConfig,
-        reportFailure(
-          server,
-          `Regeneration failed for ${name}: ${describeError(error)}`,
-          error
-        )
-      );
-    }).finally(() => {
-      inFlight.delete(canisterConfig);
-      if (rerunQueued.delete(canisterConfig)) {
-        void regenerate(canisterConfig, server);
+    };
+    if (typeof client?.send === "function") {
+      try {
+        client.send(JSON.stringify(payload));
+      } catch {
       }
-    });
-    inFlight.set(canisterConfig, run);
-    return run;
-  };
-  const regenerateForDid = (file, server) => {
-    if (!file.endsWith(".did")) {
       return;
     }
-    const changedPath = import_node_path.default.normalize(file);
-    const affectedCanisters = canisters.filter(
-      (canister) => resolveDidPath(canister.didFile) === changedPath
+    devServer?.ws.send(payload);
+  };
+  const onDidSaved = (file) => {
+    const saved = import_node_path2.default.normalize(file);
+    const affected = generated.filter((canister) => didPath(canister) === saved);
+    if (affected.length === 0 || queued.has(saved)) return;
+    queued.add(saved);
+    log.info(
+      `ic-reactor: ${relativeToRoot(saved)} changed, regenerating ${affected.map(({ name }) => name).join(", ")}`
     );
-    if (affectedCanisters.length === 0) {
-      return;
-    }
-    console.log(
-      `[ic-reactor] .did file changed: ${affectedCanisters.map((canister) => canister.name).join(", ")}. Regenerating...`
+    const { signal } = stopper;
+    void serially(async () => {
+      queued.delete(saved);
+      const failures = await generateNow(affected, true, signal);
+      if (failures) publish(affected, failures);
+    });
+  };
+  const onDidRemoved = (file) => {
+    const removed = import_node_path2.default.normalize(file);
+    const affected = generated.filter(
+      (canister) => didPath(canister) === removed
     );
-    for (const canister of affectedCanisters) {
-      void regenerate(canister, server);
+    if (affected.length === 0) return;
+    const { signal } = stopper;
+    void serially(async () => {
+      try {
+        if (signal.aborted || import_node_fs2.default.existsSync(removed)) return;
+        for (const { name } of affected) generatedFrom.delete(name);
+        publish(
+          affected,
+          affected.map((canister) => ({
+            canister,
+            message: "the .did file was deleted; its module is not regenerated until the file comes back"
+          }))
+        );
+      } catch (error) {
+        log.error(`ic-reactor: ${describe(error)}`);
+      }
+    });
+  };
+  const announceGuide = (userConfig) => {
+    if (announced) return;
+    announced = true;
+    if (userConfig.customLogger) {
+      userConfig.customLogger.info(GUIDE_LINE);
+    } else if (!["silent", "error", "warn"].includes(userConfig.logLevel ?? "")) {
+      console.log(GUIDE_LINE);
     }
   };
   const plugin = {
     name: PLUGIN_NAME,
     enforce: "pre",
     // Run before other plugins
-    async config(userConfig, { command: viteCommand }) {
+    async config(userConfig, { command: viteCommand, mode }) {
+      announceGuide(userConfig);
       command = viteCommand;
-      if (viteCommand !== "serve" || !injectEnvironment) {
+      if (viteCommand !== "serve" || mode === "test" || !injectEnvironment) {
         return {};
       }
       const ownsApiProxy = !userConfig.server?.proxy?.["/api"];
       const environment = createLocalEnvironment({
-        canisterNames: canisters.map((canister) => canister.name).filter((name) => !!name),
+        canisterNames: names,
         configuredCanisterIds,
         // `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.
-        projectRoot: import_node_path.default.resolve(userConfig.root ?? process.cwd()),
+        projectRoot: import_node_path2.default.resolve(userConfig.root ?? process.cwd()),
         onDiagnostic: debugLog,
         onUpdate: (previous, next) => {
           for (const proxyOptions of apiProxyOptions) {
@@ -423,7 +822,7 @@ function icReactor(options) {
       });
       localEnvironment = environment;
       const state = await environment.detect();
-      warnAboutIncompleteDetection(state, canisters.length > 0, ownsApiProxy);
+      warnAboutIncompleteDetection(state, names.length > 0, ownsApiProxy);
       return {
         server: {
           // The cookie is not a static `server.headers` entry: the middleware
@@ -445,29 +844,19 @@ function icReactor(options) {
     configResolved(config) {
       projectRoot = config.root;
       command = config.command;
+      log = config.logger;
     },
     configureServer(server) {
       devServer = server;
       if (localEnvironment) {
         server.middlewares.use(icEnvMiddleware(localEnvironment));
       }
-      server.ws.on?.("connection", () => {
-        if (pendingFailures.size === 0) return;
-        const failures = [...pendingFailures.values()];
-        server.ws.send({
-          type: "error",
-          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));
-      server.watcher.add(didFiles);
-      const onDidEvent = (file) => regenerateForDid(file, server);
-      server.watcher.on("change", onDidEvent);
-      server.watcher.on("add", onDidEvent);
+      if (generated.length === 0) return;
+      server.ws.on?.("connection", showOverlay);
+      server.watcher.add(generated.map(didPath));
+      server.watcher.on("change", onDidSaved);
+      server.watcher.on("add", onDidSaved);
+      server.watcher.on("unlink", onDidRemoved);
     },
     // `vite preview` resolves the config with the `serve` command too, and
     // used to inherit the cookie from `server.headers`.
@@ -477,90 +866,28 @@ function icReactor(options) {
       }
     },
     async buildStart() {
-      for (const canister of canisters) {
-        if (typeof canister.didFile === "string") {
-          this.addWatchFile(resolveDidPath(canister.didFile));
-        }
-      }
-      const sources = canisters.map(readDidSource);
-      const pending = canisters.filter(
-        (canister, index) => !this.meta.watchMode || sources[index] === void 0 || generatedFrom.get(canister) !== sources[index]
+      if (generated.length === 0) return;
+      for (const canister of generated) this.addWatchFile(didPath(canister));
+      const { signal } = stopper;
+      const failures = await serially(
+        () => generateNow(generated, false, signal)
       );
-      if (pending.length === 0) {
-        return;
-      }
-      console.log(
-        `[ic-reactor] Generating canister bindings for ${pending.length} canisters...`
-      );
-      const outcomes = await Promise.allSettled(
-        pending.map((canisterConfig) => {
-          const sharedError = sharedOutDirError(canisterConfig);
-          if (sharedError !== void 0) {
-            return Promise.reject(new SharedOutDirError(sharedError));
-          }
-          return (0, import_codegen.runCanisterPipeline)({
-            canisterConfig,
-            projectRoot,
-            globalConfig
-          });
-        })
-      );
-      outcomes.forEach((outcome, index) => {
-        const canister = pending[index];
-        const source = sources[canisters.indexOf(canister)];
-        if (outcome.status === "fulfilled") {
-          reportWarnings(canister.name, outcome.value.warnings);
-        }
-        if (outcome.status === "fulfilled" && outcome.value.success && source !== void 0) {
-          generatedFrom.set(canister, source);
-        } else {
-          generatedFrom.delete(canister);
-        }
-      });
-      const failures = outcomes.flatMap((outcome, index) => {
-        const canister = pending[index];
-        const name = canister?.name ?? `canister #${index}`;
-        if (outcome.status === "rejected") {
-          const detail = outcome.reason instanceof SharedOutDirError ? outcome.reason.message : `${name}: ${describeError(outcome.reason)}`;
-          return [{ canister, detail }];
-        }
-        if (!outcome.value.success) {
-          return [
-            {
-              canister,
-              detail: `${name}: ${outcome.value.error ?? "unknown error"}`
-            }
-          ];
-        }
-        return [];
-      });
-      if (failures.length === 0) {
-        return;
-      }
-      const message = `Failed to generate ${failures.length} of ${pending.length} canisters:
-` + failures.map(({ detail }) => `  - ${detail}`).join("\n");
-      if (failOnError ?? command === "build") {
-        this.error(`[ic-reactor] ${message}`);
-      }
-      reportFailure(devServer, message);
-      for (const { canister, detail } of failures) {
-        pendingFailures.set(canister, {
-          message: `[ic-reactor] Failed to generate ${detail}`,
-          stack: ""
-        });
+      if (!failures) return;
+      if (failures.length > 0 && (failOnError ?? command === "build")) {
+        this.error(describeFailures(failures));
       }
+      publish(generated, failures);
+    },
+    // The end of a build, and the close of a dev server, which Vite reports
+    // here once for each of its environments.
+    closeBundle() {
+      stopper.abort();
+      stopper = new AbortController();
     }
   };
   return plugin;
 }
-var SharedOutDirError = class extends Error {
-};
-function reportWarnings(name, warnings) {
-  for (const warning of warnings ?? []) {
-    console.warn(`[ic-reactor] ${name}: ${warning}`);
-  }
-}
-function describeError(error) {
+function describe(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function apiProxy(userConfig, target, configure) {
@@ -578,7 +905,7 @@ function apiProxy(userConfig, target, configure) {
     }
   };
 }
-function quoteNames(names) {
+function quoteNames2(names) {
   return names.map((name) => `"${name}"`).join(", ");
 }
 function warnAboutIncompleteDetection(state, hasCanisters, ownsApiProxy) {
@@ -594,7 +921,7 @@ function warnAboutIncompleteDetection(state, hasCanisters, ownsApiProxy) {
   if (missing.length > 0) {
     const it = missing.length === 1 ? "it" : "them";
     console.warn(
-      `[ic-reactor] The local replica is running, but no canister ID could be resolved for ${quoteNames(missing)}. Until one is, the ic_env cookie carries no PUBLIC_CANISTER_ID for ${it} and the app will see an undefined canister id. Deploy ${it} (\`icp deploy\`) and reload the page: the plugin asks \`icp\` again on each page load until every configured canister has an ID. Re-run with DEBUG=ic-reactor to see the \`icp\` output.`
+      `[ic-reactor] The local replica is running, but no canister ID could be resolved for ${quoteNames2(missing)}. Until one is, the ic_env cookie carries no PUBLIC_CANISTER_ID for ${it} and the app will see an undefined canister id. Deploy ${it} (\`icp deploy\`) and reload the page: the plugin asks \`icp\` again on each page load until every configured canister has an ID. Re-run with DEBUG=ic-reactor to see the \`icp\` output.`
     );
   }
 }
@@ -609,7 +936,7 @@ function reportDetectionProgress(previous, next, followsApiProxy) {
   );
   if (next.environment && resolved.length > 0) {
     console.log(
-      `[ic-reactor] The ic_env cookie now carries the canister ID${resolved.length === 1 ? "" : "s"} for ${quoteNames(resolved)}.`
+      `[ic-reactor] The ic_env cookie now carries the canister ID${resolved.length === 1 ? "" : "s"} for ${quoteNames2(resolved)}.`
     );
   }
   if (next.complete && !previous.complete) {