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

package/dist/index.js

@@ -1,24 +1,41 @@
 // src/index.ts
-import path from "path";
-import {
-  runCanisterPipeline
-} from "@ic-reactor/codegen";
+import fs2 from "fs";
+import path2 from "path";
 
 // src/env.ts
-import { execFileSync } from "child_process";
-function getIcEnvironmentInfo(canisterNames, projectRoot = process.cwd()) {
+import { execFile } from "child_process";
+var ICP_TIMEOUT_MS = 1e4;
+function runIcp(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "icp",
+      args,
+      {
+        cwd,
+        encoding: "utf-8",
+        timeout: ICP_TIMEOUT_MS,
+        windowsHide: true
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(Object.assign(error, { stderr }));
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+    child.stdin?.end();
+  });
+}
+async 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
-        // the caller decides to print the diagnostics we collect below.
-        stdio: ["ignore", "pipe", "pipe"]
-      })
+      await runIcp(
+        ["network", "status", "-e", networkName, "--json"],
+        projectRoot
+      )
     );
     const rootKey = networkStatus.root_key;
     const proxyTarget = networkStatus.api_url || networkStatus.gateway_url || (networkStatus.port ? `http://127.0.0.1:${networkStatus.port}` : void 0);
@@ -31,15 +48,10 @@ function getIcEnvironmentInfo(canisterNames, projectRoot = process.cwd()) {
     const canisterIds = {};
     for (const name of canisterNames) {
       try {
-        const canisterId = execFileSync(
-          "icp",
+        const canisterId = (await runIcp(
           ["canister", "status", name, "-e", networkName, "-i"],
-          {
-            cwd: projectRoot,
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "pipe"]
-          }
-        ).trim();
+          projectRoot
+        )).trim();
         if (canisterId) {
           canisterIds[name] = canisterId;
         }
@@ -100,254 +112,804 @@ function localInternetIdentityProvider(proxyTarget) {
   return `${protocol}//id.ai.localhost${portSuffix}/authorize`;
 }
 
-// src/index.ts
-var PLUGIN_NAME = "ic-reactor-plugin";
+// src/dev-environment.ts
 var DEFAULT_LOCAL_REPLICA = "http://127.0.0.1:4943";
-function icReactor(options) {
+var DEFAULT_INTERNET_IDENTITY_PROVIDER = "http://id.ai.localhost:8000/authorize";
+function createLocalEnvironment(options) {
   const {
-    canisters,
-    outDir = "src/declarations",
-    clientManagerPath = "../../clients",
-    target = "react",
-    injectEnvironment = true,
-    failOnError
+    canisterNames,
+    configuredCanisterIds,
+    projectRoot,
+    onDiagnostic,
+    onUpdate
   } = options;
-  const globalConfig = {
-    outDir,
-    clientManagerPath,
-    target
+  const requiredNames = [...new Set(canisterNames)];
+  const lookupNames = requiredNames.includes("internet_identity") ? requiredNames : [...requiredNames, "internet_identity"];
+  let state;
+  let running;
+  const toState = (environment) => {
+    const canisterIds = {
+      ...environment?.canisterIds,
+      ...configuredCanisterIds
+    };
+    const missingCanisterIds = requiredNames.filter(
+      (name) => !canisterIds[name]
+    );
+    let cookie;
+    if (environment) {
+      cookie = buildIcEnvCookie(
+        canisterIds,
+        environment.rootKey,
+        environment.internetIdentityProvider
+      );
+    } else if (requiredNames.length === 0) {
+      cookie = buildIcEnvCookie(
+        {},
+        void 0,
+        DEFAULT_INTERNET_IDENTITY_PROVIDER
+      );
+    }
+    return {
+      environment,
+      cookie,
+      proxyTarget: environment?.proxyTarget ?? DEFAULT_LOCAL_REPLICA,
+      missingCanisterIds,
+      complete: environment !== null && missingCanisterIds.length === 0
+    };
   };
-  let projectRoot = process.cwd();
-  let command = "build";
-  let devServer = null;
-  const resolveDidPath = (didFile) => path.normalize(
-    path.isAbsolute(didFile) ? didFile : path.resolve(projectRoot, didFile)
+  const run = async () => {
+    const previous = state;
+    try {
+      const { environment, diagnostics } = await getIcEnvironmentInfo(
+        lookupNames,
+        projectRoot
+      );
+      diagnostics.forEach(onDiagnostic);
+      state = toState(
+        mergeDetections(previous?.environment ?? null, environment)
+      );
+    } catch (error) {
+      onDiagnostic(
+        `Detecting the local IC environment failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      state = previous ?? toState(null);
+    }
+    try {
+      onUpdate?.(previous, state);
+    } catch (error) {
+      onDiagnostic(
+        `Applying the detected IC environment failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return state;
+  };
+  return {
+    get state() {
+      return state;
+    },
+    detect() {
+      running ?? (running = run().finally(() => {
+        running = void 0;
+      }));
+      return running;
+    }
+  };
+}
+function mergeDetections(previous, next) {
+  if (!next) return previous;
+  if (!previous || previous.rootKey !== next.rootKey) return next;
+  const canisterIds = { ...previous.canisterIds, ...next.canisterIds };
+  return {
+    ...next,
+    canisterIds,
+    // The built-in provider stands in only for a project that has no
+    // internet_identity canister, as getIcEnvironmentInfo decides it.
+    internetIdentityProvider: canisterIds.internet_identity ? void 0 : next.internetIdentityProvider
+  };
+}
+function isDocumentRequest(req) {
+  if (req.method !== "GET" && req.method !== "HEAD") return false;
+  const { accept } = req.headers;
+  return typeof accept === "string" && accept.includes("text/html");
+}
+function setIcEnvCookie(res, value) {
+  const existing = res.getHeader("Set-Cookie");
+  const others = (existing === void 0 ? [] : Array.isArray(existing) ? existing : [String(existing)]).filter((cookie2) => !cookie2.startsWith("ic_env="));
+  const cookie = `ic_env=${value}; Path=/; SameSite=Lax;`;
+  res.setHeader("Set-Cookie", others.length > 0 ? [...others, cookie] : cookie);
+}
+function icEnvMiddleware(environment) {
+  return (req, res, next) => {
+    const respond = (state2) => {
+      if (state2?.cookie !== void 0) setIcEnvCookie(res, state2.cookie);
+      next();
+    };
+    const { state } = environment;
+    if (state?.complete || !isDocumentRequest(req)) {
+      respond(state);
+      return;
+    }
+    void environment.detect().then(respond);
+  };
+}
+
+// src/generate.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+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 = createRequire(path.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(fs.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 path.resolve(path.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 = 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, omitted, diagnostics } = entry;
+    return {
+      status: String(status),
+      module: typeof module === "string" ? module : 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)
+    )
   );
-  const configuredCanisterIds = Object.fromEntries(
-    canisters.filter((canister) => !!canister.canisterId).map((canister) => [canister.name, canister.canisterId])
+  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 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
+  const probe = (entry) => {
+    const swapped = path.join(
+      path.dirname(entry),
+      swapCase(path.basename(entry))
+    );
+    if (swapped === entry) return void 0;
+    try {
+      const found = fs.lstatSync(entry, { bigint: true });
+      if (found.ino === 0n) return void 0;
+      try {
+        const other = fs.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 = path.dirname(at)) {
+    let names = [];
+    try {
+      names = fs.readdirSync(at);
+    } catch {
+    }
+    const named = names.find((name) => swapCase(name) !== name);
+    const verdict = (named === void 0 ? void 0 : probe(path.join(at, named))) ?? probe(at);
+    if (verdict !== void 0) return verdict;
+    if (path.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
     };
-    server?.ws.send({ type: "error", err });
-    return { message: err.message, stack: err.stack };
+    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 ${path.relative(root, moduleOf(unit))}, which ${quoteNames(owner.names)} already writes` + (moduleOf(unit) === moduleOf(owner) ? ". " : ` as ${path.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)]
   };
-  const inFlight = /* @__PURE__ */ new Map();
-  const rerunQueued = /* @__PURE__ */ new Set();
-  const regenerate = (canisterConfig, server) => {
-    const { name } = canisterConfig;
-    const running = inFlight.get(name);
-    if (running) {
-      rerunQueued.add(name);
-      return running;
+}
+function moduleOf(unit) {
+  return path.join(
+    unit.outDir,
+    path.basename(unit.didFile, path.extname(unit.didFile)) + ".ts"
+  );
+}
+
+// src/index.ts
+var PLUGIN_NAME = "ic-reactor-plugin";
+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 didPath = (canister) => path2.resolve(projectRoot, canister.didFile);
+  const relativeToRoot = (file) => path2.relative(projectRoot, file) || ".";
+  const generatedFrom = /* @__PURE__ */ new Map();
+  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 fs2.readFileSync(didPath(canister), "utf-8");
+    } catch {
+      return void 0;
     }
-    const run = runCanisterPipeline({
-      canisterConfig,
-      projectRoot,
-      globalConfig
-    }).then((result) => {
-      if (result.success) {
-        pendingFailures.delete(name);
-        server.ws.send({ type: "full-reload" });
-      } else {
-        pendingFailures.set(
-          name,
-          reportFailure(
-            server,
-            `Regeneration failed for ${name}: ${result.error ?? "unknown error"}`
-          )
-        );
-      }
-    }).catch((error) => {
-      pendingFailures.set(
-        name,
-        reportFailure(
-          server,
-          `Regeneration failed for ${name}: ${describeError(error)}`,
-          error
-        )
+  };
+  const generateNow = async (wanted, force, signal) => {
+    if (signal.aborted) return void 0;
+    try {
+      const sources = new Map(
+        wanted.map((canister) => [canister.name, readDid(canister)])
       );
-    }).finally(() => {
-      inFlight.delete(name);
-      if (rerunQueued.delete(name)) {
-        void regenerate(canisterConfig, server);
+      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: path2.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 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 publish = (attempted, failures) => {
+    let wasFailing = false;
+    for (const { name } of attempted) {
+      if (unfixed.delete(name)) wasFailing = true;
+    }
+    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 showOverlay = (client) => {
+    if (unfixed.size === 0) return;
+    const payload = {
+      type: "error",
+      err: {
+        message: describeFailures([...unfixed.values()]),
+        stack: "",
+        plugin: PLUGIN_NAME
+      }
+    };
+    if (typeof client?.send === "function") {
+      try {
+        client.send(JSON.stringify(payload));
+      } catch {
+      }
+      return;
+    }
+    devServer?.ws.send(payload);
+  };
+  const onDidSaved = (file) => {
+    const saved = path2.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(", ")}`
+    );
+    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 = path2.normalize(file);
+    const affected = generated.filter(
+      (canister) => didPath(canister) === removed
+    );
+    if (affected.length === 0) return;
+    const { signal } = stopper;
+    void serially(async () => {
+      try {
+        if (signal.aborted || fs2.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)}`);
       }
     });
-    inFlight.set(name, run);
-    return run;
+  };
+  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
-    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 canisterNames = canisters.map((c) => c.name).filter((n) => !!n);
-      if (!canisterNames.includes("internet_identity")) {
-        canisterNames.push("internet_identity");
-      }
-      const { environment: icEnv, diagnostics } = getIcEnvironmentInfo(
-        canisterNames,
-        path.resolve(userConfig.root ?? process.cwd())
-      );
-      if (!icEnv) {
-        if (canisters.length > 0) {
-          console.warn(
-            `[ic-reactor] Could not detect the local IC environment, falling back to ${DEFAULT_LOCAL_REPLICA}. Canister IDs and the root key will not be injected \u2014 is the local replica running? Re-run with DEBUG=ic-reactor to see the \`icp\` output.`
-          );
-        }
-        for (const diagnostic of diagnostics) {
-          debugLog(diagnostic);
-        }
-        const envOnlyCookie = canisters.length === 0 ? buildIcEnvCookie(
-          {},
-          void 0,
-          "http://id.ai.localhost:8000/authorize"
-        ) : void 0;
-        return {
-          server: {
-            headers: envOnlyCookie ? {
-              "Set-Cookie": `ic_env=${envOnlyCookie}; Path=/; SameSite=Lax;`
-            } : void 0,
-            proxy: apiProxy(userConfig, DEFAULT_LOCAL_REPLICA)
+      const ownsApiProxy = !userConfig.server?.proxy?.["/api"];
+      const environment = createLocalEnvironment({
+        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: path2.resolve(userConfig.root ?? process.cwd()),
+        onDiagnostic: debugLog,
+        onUpdate: (previous, next) => {
+          for (const proxyOptions of apiProxyOptions) {
+            proxyOptions.target = next.proxyTarget;
           }
-        };
-      }
-      const missingCanisterIds = canisters.map((canister) => canister.name).filter((name) => !!name).filter(
-        (name) => !icEnv.canisterIds[name] && !configuredCanisterIds[name]
-      );
-      if (missingCanisterIds.length > 0) {
-        const names = missingCanisterIds.map((name) => `"${name}"`).join(", ");
-        const it = missingCanisterIds.length === 1 ? "it" : "them";
-        console.warn(
-          `[ic-reactor] The local replica is running, but no canister ID could be resolved for ${names}. Deploy ${it} (\`icp deploy\`) \u2014 until then the injected ic_env carries no PUBLIC_CANISTER_ID for ${it} and the app will see an undefined canister id. Re-run with DEBUG=ic-reactor to see the \`icp\` output.`
-        );
-      }
-      for (const diagnostic of diagnostics) {
-        debugLog(diagnostic);
-      }
-      const cookieValue = buildIcEnvCookie(
-        {
-          ...icEnv.canisterIds,
-          ...configuredCanisterIds
-        },
-        icEnv.rootKey,
-        icEnv.internetIdentityProvider
-      );
+          if (previous) {
+            reportDetectionProgress(previous, next, apiProxyOptions.size > 0);
+          }
+        }
+      });
+      localEnvironment = environment;
+      const state = await environment.detect();
+      warnAboutIncompleteDetection(state, names.length > 0, ownsApiProxy);
       return {
         server: {
-          headers: {
-            "Set-Cookie": `ic_env=${cookieValue}; Path=/; SameSite=Lax;`
-          },
-          proxy: apiProxy(userConfig, icEnv.proxyTarget)
+          // The cookie is not a static `server.headers` entry: the middleware
+          // that configureServer adds sets it per response, from the latest
+          // detection. See dev-environment.ts.
+          proxy: apiProxy(userConfig, state.proxyTarget, (proxyOptions) => {
+            if (proxyOptions.target !== state.proxyTarget) {
+              debugLog(
+                "Another plugin changed the target of the /api proxy, so the plugin leaves that proxy alone."
+              );
+              return;
+            }
+            apiProxyOptions.add(proxyOptions);
+            proxyOptions.target = environment.state?.proxyTarget ?? state.proxyTarget;
+          })
         }
       };
     },
     configResolved(config) {
       projectRoot = config.root;
       command = config.command;
+      log = config.logger;
     },
     configureServer(server) {
       devServer = server;
-      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);
-    },
-    async buildStart() {
-      console.log(
-        `[ic-reactor] Generating canister bindings for ${canisters.length} canisters...`
-      );
-      const outcomes = await Promise.allSettled(
-        canisters.map(
-          (canisterConfig) => runCanisterPipeline({
-            canisterConfig,
-            projectRoot,
-            globalConfig
-          })
-        )
-      );
-      const failures = outcomes.flatMap((outcome, index) => {
-        const name = canisters[index]?.name ?? `canister #${index}`;
-        if (outcome.status === "rejected") {
-          return [{ name, detail: `${name}: ${describeError(outcome.reason)}` }];
-        }
-        if (!outcome.value.success) {
-          return [
-            {
-              name,
-              detail: `${name}: ${outcome.value.error ?? "unknown error"}`
-            }
-          ];
-        }
-        return [];
-      });
-      if (failures.length === 0) {
-        return;
-      }
-      const message = `Failed to generate ${failures.length} of ${canisters.length} canisters:
-` + 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: ""
-        });
+      if (localEnvironment) {
+        server.middlewares.use(icEnvMiddleware(localEnvironment));
       }
+      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);
     },
-    handleHotUpdate({ file, server }) {
-      if (!file.endsWith(".did")) {
-        return;
+    // `vite preview` resolves the config with the `serve` command too, and
+    // used to inherit the cookie from `server.headers`.
+    configurePreviewServer(server) {
+      if (localEnvironment) {
+        server.middlewares.use(icEnvMiddleware(localEnvironment));
       }
-      const changedPath = path.normalize(file);
-      const affectedCanisters = canisters.filter(
-        (canister) => resolveDidPath(canister.didFile) === changedPath
+    },
+    async buildStart() {
+      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 (affectedCanisters.length === 0) {
-        return;
+      if (!failures) return;
+      if (failures.length > 0 && (failOnError ?? command === "build")) {
+        this.error(describeFailures(failures));
       }
-      console.log(
-        `[ic-reactor] .did file changed: ${affectedCanisters.map((canister) => canister.name).join(", ")}. Regenerating...`
-      );
-      return Promise.all(
-        affectedCanisters.map((canister) => regenerate(canister, server))
-      ).then(() => void 0);
+      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;
 }
-function describeError(error) {
+function describe(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function apiProxy(userConfig, target) {
+function apiProxy(userConfig, target, configure) {
   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 } };
+  return {
+    "/api": {
+      target,
+      changeOrigin: true,
+      configure: (_proxy, options) => configure(options)
+    }
+  };
+}
+function quoteNames2(names) {
+  return names.map((name) => `"${name}"`).join(", ");
+}
+function warnAboutIncompleteDetection(state, hasCanisters, ownsApiProxy) {
+  if (!state.environment) {
+    if (!hasCanisters) return;
+    const proxyNote = ownsApiProxy ? ` and /api goes to ${state.proxyTarget} for now` : "";
+    console.warn(
+      `[ic-reactor] Could not detect the local IC environment, so no ic_env cookie is set${proxyNote}. Is the local network running? The plugin asks \`icp\` again on each page load until it answers${ownsApiProxy ? ", then sends /api to the network it reports" : ""}: start the network (\`icp network start\`) and reload the page. Re-run with DEBUG=ic-reactor to see the \`icp\` output.`
+    );
+    return;
+  }
+  const missing = state.missingCanisterIds;
+  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 ${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.`
+    );
+  }
+}
+function reportDetectionProgress(previous, next, followsApiProxy) {
+  if (!previous.environment && next.environment) {
+    console.log(
+      `[ic-reactor] Detected the local IC network: the ic_env cookie now carries its root key` + (followsApiProxy ? ` and /api goes to ${next.proxyTarget}.` : ".")
+    );
+  }
+  const resolved = previous.missingCanisterIds.filter(
+    (name) => !next.missingCanisterIds.includes(name)
+  );
+  if (next.environment && resolved.length > 0) {
+    console.log(
+      `[ic-reactor] The ic_env cookie now carries the canister ID${resolved.length === 1 ? "" : "s"} for ${quoteNames2(resolved)}.`
+    );
+  }
+  if (next.complete && !previous.complete) {
+    console.log(
+      "[ic-reactor] Every configured canister has an ID, so page loads no longer run `icp`. Restart the dev server after redeploying into a fresh network."
+    );
+  }
 }
 function debugLog(message) {
   const enabled = (process.env.DEBUG ?? "").split(",").some((entry) => {