@intentius/behold 0.10.1 → 0.11.0

package/dist/cli.js

@@ -1121,7 +1121,7 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname4, join as join16, relative as relative3, resolve as resolve5, sep as sep4 } from "node:path";
+import { basename, dirname as dirname4, join as join16, relative as relative3, resolve as resolve5, sep as sep4 } from "node:path";
 
 // src/recents.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
@@ -1552,8 +1552,15 @@ function parseYAMLArray(lines, startIndex, baseIndent) {
         result.push(obj);
         i = j;
       } else {
-        result.push(parseScalar(itemValue));
-        i++;
+        const header = blockScalarHeader(itemValue);
+        if (header) {
+          const block = parseBlockScalar(lines, i + 1, indent, header);
+          result.push(block.value);
+          i = block.endIndex;
+        } else {
+          result.push(parseScalar(itemValue));
+          i++;
+        }
       }
     } else {
       break;
@@ -4187,6 +4194,7 @@ function renderGraph(ir, opts = {}) {
   const layout = layoutIr(ir, { fit: true, ...boxes ? { groups: boxes } : {} });
   if (opts.radial && !boxes) radializeLayout(layout, groupKeyByNode(ir), footprints(ir));
   else if (!boxes) packComponents(layout, ir);
+  else if (boxKey === "byStack" && boxes) packMemberBoxes(layout, ir, boxes);
   const svg = renderSvg(ir, layout, {
     fit: true,
     hideTitle: true,
@@ -4409,6 +4417,92 @@ function packComponents(layout, ir) {
   layout.width = Math.max(...nodes.map((n) => n.x + halfW(n))) + pad;
   layout.height = Math.max(...nodes.map((n) => n.y + halfH(n))) + pad;
 }
+function packMemberBoxes(layout, ir, members) {
+  const boxes = layout.groups ?? [];
+  if (boxes.length < 4) return;
+  const nodes = layout.nodes;
+  const size = footprints(ir);
+  const halfW = (n) => (size.get(n.id)?.w ?? NODE_W) / 2;
+  const halfH = (n) => (size.get(n.id)?.h ?? NODE_H) / 2;
+  for (const n of nodes) n.y = layout.height - n.y;
+  for (const b of boxes) b.y = layout.height - b.y;
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const claimed = /* @__PURE__ */ new Set();
+  const blocks = boxes.map((box) => {
+    const ns = (members[box.id ?? box.title] ?? members[box.title] ?? []).flatMap((id) => byId.get(id) ?? []);
+    for (const n of ns) claimed.add(n.id);
+    let minX = box.x - box.w / 2;
+    let maxX2 = box.x + box.w / 2;
+    let minY = box.y - box.h / 2;
+    let maxY2 = box.y + box.h / 2;
+    for (const n of ns) {
+      minX = Math.min(minX, n.x - halfW(n));
+      maxX2 = Math.max(maxX2, n.x + halfW(n));
+      minY = Math.min(minY, n.y - halfH(n));
+      maxY2 = Math.max(maxY2, n.y + halfH(n));
+    }
+    return { ns, box, minX, minY, w: maxX2 - minX, h: maxY2 - minY };
+  });
+  const rest = nodes.filter((n) => !claimed.has(n.id));
+  if (rest.length) {
+    const idxOf = new Map(rest.map((n, i) => [n.id, i]));
+    const parent = rest.map((_, i) => i);
+    const find = (x) => {
+      while (parent[x] !== x) x = parent[x] = parent[parent[x]];
+      return x;
+    };
+    for (const e of ir.edges) {
+      const a = idxOf.get(e.from);
+      const b = idxOf.get(e.to);
+      if (a != null && b != null) parent[find(a)] = find(b);
+    }
+    const comps = /* @__PURE__ */ new Map();
+    rest.forEach((n, i) => (comps.get(find(i)) ?? comps.set(find(i), []).get(find(i))).push(n));
+    for (const ns of comps.values()) {
+      const minX = Math.min(...ns.map((n) => n.x - halfW(n)));
+      const minY = Math.min(...ns.map((n) => n.y - halfH(n)));
+      blocks.push({
+        ns,
+        minX,
+        minY,
+        w: Math.max(...ns.map((n) => n.x + halfW(n))) - minX,
+        h: Math.max(...ns.map((n) => n.y + halfH(n))) - minY
+      });
+    }
+  }
+  const totalArea = blocks.reduce((s, b) => s + (b.w + MEMBER_GAP) * (b.h + MEMBER_GAP), 0);
+  const targetW = Math.max(Math.max(...blocks.map((b) => b.w)), Math.sqrt(totalArea) * 1.3);
+  let shelfX = 0;
+  let shelfY = 0;
+  let shelfH = 0;
+  let maxX = 0;
+  let maxY = 0;
+  for (const b of blocks) {
+    if (shelfX > 0 && shelfX + b.w > targetW) {
+      shelfX = 0;
+      shelfY += shelfH + MEMBER_GAP;
+      shelfH = 0;
+    }
+    const dx = shelfX - b.minX;
+    const dy = shelfY - b.minY;
+    for (const n of b.ns) {
+      n.x += dx;
+      n.y += dy;
+    }
+    if (b.box) {
+      b.box.x += dx;
+      b.box.y += dy;
+    }
+    maxX = Math.max(maxX, shelfX + b.w);
+    maxY = Math.max(maxY, shelfY + b.h);
+    shelfX += b.w + MEMBER_GAP;
+    shelfH = Math.max(shelfH, b.h);
+  }
+  layout.width = maxX;
+  layout.height = maxY;
+  for (const n of nodes) n.y = maxY - n.y;
+  for (const b of boxes) b.y = maxY - b.y;
+}
 function groupKeyByNode(ir) {
   const out = /* @__PURE__ */ new Map();
   for (const n of ir.nodes) {
@@ -4796,6 +4890,67 @@ async function runCarvePlan(demo) {
     noDestroy: r.noDestroy
   };
 }
+async function runCarveObserve(demo, select) {
+  if (!demo.live) {
+    return refuse2(
+      "carve-action",
+      "the observe beat reads the scratch Floci, and this server isn't serving one",
+      "run `behold demo carve --live` (needs docker + terraform)"
+    );
+  }
+  if (!existsSync8(join10(demo.out, "src"))) {
+    return refuse2("carve-action", "nothing has been emitted yet", "run Emit first \u2014 observe reads the carveout emit writes");
+  }
+  const args = ["lifecycle", "diff", "prod", "--live", "--json"];
+  const run3 = await runChantRaw(args, demo.out, { AWS_ENDPOINT_URL: demo.live.endpoint }).catch((err) => ({
+    code: 127,
+    stdout: "",
+    stderr: err instanceof Error ? err.message : String(err)
+  }));
+  if (run3.code !== 0) {
+    return refuse2(
+      "carve-action",
+      `chant lifecycle diff exited ${run3.code}: ${merge(run3, demo.root) || "(no output)"}`,
+      "Is the scratch Floci still up? `docker ps` should list " + demo.live.container + "."
+    );
+  }
+  let aws;
+  try {
+    aws = JSON.parse(run3.stdout).lexicons?.aws ?? {};
+  } catch {
+    return refuse2("carve-action", "chant lifecycle diff answered something that isn't JSON", "re-run \u2014 a partial read is not a verdict");
+  }
+  const entity = select.split(".").pop() ?? select;
+  const command = `AWS_ENDPOINT_URL=${demo.live.endpoint} chant ${args.join(" ")}  # in ${shortenIn(demo.out, demo.root)}`;
+  const queried = aws.resources?.queried?.[entity];
+  const meta = aws.observed?.[entity];
+  if (meta) {
+    return {
+      ok: true,
+      select,
+      command,
+      entity,
+      verdict: "observed",
+      ...meta.status ? { status: meta.status } : {},
+      ...meta.ownership ? { ownership: meta.ownership } : {},
+      ...meta.physicalId ? { physicalId: meta.physicalId } : {},
+      ...queried ? { queried } : {}
+    };
+  }
+  const hole = aws.resources?.unobserved?.find((u) => u.name === entity);
+  if (hole) {
+    return {
+      ok: true,
+      select,
+      command,
+      entity,
+      verdict: "unobserved",
+      ...hole.detail || hole.reason ? { detail: [hole.reason, hole.detail].filter(Boolean).join(": ") } : {},
+      ...queried ? { queried } : {}
+    };
+  }
+  return { ok: true, select, command, entity, verdict: "missing", ...queried ? { queried } : {} };
+}
 var MAX_ARTIFACT_BYTES = 64 * 1024;
 var MAX_ARTIFACTS = 24;
 var MAX_OUTPUT_BYTES = 32 * 1024;
@@ -5126,6 +5281,11 @@ function statusTree(o) {
   if (!attrs) return void 0;
   return rec2(attrs.status) ?? attrs;
 }
+function specTree(o) {
+  const attrs = rec2(o.attributes);
+  if (!attrs) return void 0;
+  return rec2(attrs.spec) ?? attrs;
+}
 var ARGO_HEALTH = {
   Healthy: "healthy",
   Degraded: "degraded",
@@ -5226,6 +5386,7 @@ function revisionVerdict(tree) {
   return { health: "progressing", detail: `applied ${applied}, attempted ${attempted}` };
 }
 var FLUX_TYPE_PREFIX = "K8s::Flux::";
+var FLUX_HELMREPOSITORY_TYPE = "K8s::Flux::HelmRepository";
 function fluxVerdict(o) {
   if (!o.type?.startsWith(FLUX_TYPE_PREFIX)) return void 0;
   const tree = statusTree(o);
@@ -5233,6 +5394,9 @@ function fluxVerdict(o) {
   if (ready?.status === "False") return { health: "degraded", detail: describeReady(ready) };
   if (ready?.status === "Unknown") return { health: "progressing", detail: describeReady(ready) };
   if (ready?.status === "True") return revisionVerdict(tree) ?? { health: "healthy", detail: describeReady(ready) };
+  if (o.type === FLUX_HELMREPOSITORY_TYPE && str2(specTree(o)?.type) === "oci") {
+    return { health: "healthy", detail: "spec.type=oci (nothing to reconcile)" };
+  }
   const conditions = tree?.conditions;
   const reconciling = Array.isArray(conditions) && conditions.some((c) => {
     const cond = rec2(c);
@@ -5244,9 +5408,41 @@ function fluxVerdict(o) {
   }
   return void 0;
 }
+var DEPLOYMENT_TYPE = "K8s::Apps::Deployment";
+function unhappyCondition(o, type) {
+  const fromStrings = rec2(o.attributes)?.conditions;
+  if (Array.isArray(fromStrings)) {
+    for (const c of fromStrings) {
+      if (typeof c === "string" && c.startsWith(type)) return c;
+    }
+  }
+  const tree = statusTree(o);
+  const raw = tree?.conditions;
+  if (Array.isArray(raw)) {
+    for (const c of raw) {
+      const cond = rec2(c);
+      if (!cond || cond.type !== type) continue;
+      const status = str2(cond.status);
+      const unhappy = type === "ReplicaFailure" ? status === "True" : status === "False";
+      if (!unhappy) continue;
+      const reason = str2(cond.reason);
+      const message = str2(cond.message);
+      return `${type}${reason ? `=${reason}` : ""}${message ? `: ${message}` : ""}`;
+    }
+  }
+  return void 0;
+}
+function deploymentVerdict(o) {
+  if (o.type !== DEPLOYMENT_TYPE) return void 0;
+  const damage = unhappyCondition(o, "ReplicaFailure") ?? unhappyCondition(o, "Progressing");
+  if (damage) return { health: "degraded", detail: damage };
+  const available = unhappyCondition(o, "Available");
+  if (available) return { health: "progressing", detail: available };
+  return void 0;
+}
 function classifyObservedHealth(observed) {
   if (!observed) return { health: "unknown" };
-  return argoVerdict(observed) ?? fluxVerdict(observed) ?? { health: classifyHealth(observed.status) };
+  return argoVerdict(observed) ?? fluxVerdict(observed) ?? deploymentVerdict(observed) ?? { health: classifyHealth(observed.status) };
 }
 
 // src/apply.ts
@@ -5377,9 +5573,14 @@ var OpRunner = class {
    * Start `chant run <name>` unless one is already running (the Sync/Adopt/auto-
    * sync path). `cwd` is the Op's own project dir (#31 multi-estate); defaults to
    * the primary. Returns true if it started, false if busy.
+   *
+   * `temporal` — pass `--temporal` so the run gets the durable runtime. Callers
+   * set it from the Op's declared gate: chant refuses a gated Op outright in
+   * local mode ("gates and schedules need a durable runtime"), so without the
+   * flag a gated Op could never run from behold at all.
    */
-  trigger(name, opEnv, cwd) {
-    return this.start(["run", name], name, opEnv, cwd);
+  trigger(name, opEnv, cwd, temporal) {
+    return this.start(temporal ? ["run", name, "--temporal"] : ["run", name], name, opEnv, cwd);
   }
   /**
    * Run an arbitrary `chant` invocation through the same guard/stream/PR/capture
@@ -5772,13 +5973,31 @@ async function openRollbackBranches(projectDir, env) {
 
 // src/estate.ts
 import { statSync as statSync3 } from "node:fs";
+import { availableParallelism } from "node:os";
 import { join as join13, resolve as resolve3, sep as sep2 } from "node:path";
 import { composeStacks, shortStackNames } from "@intentius/pinhole";
+function estateReadPool(members, env = process.env) {
+  const override = Number.parseInt(env.BEHOLD_ESTATE_CONCURRENCY ?? "", 10);
+  const cap = Number.isInteger(override) && override >= 1 ? override : Math.min(4, availableParallelism());
+  return Math.max(1, Math.min(cap, members));
+}
+async function mapPool(items, width, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (let i = next++; i < items.length; i = next++) {
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(width, items.length)) }, () => worker()));
+  return results;
+}
 async function composeEstate(projectDirs, opts = {}) {
   const names = shortStackNames(projectDirs);
-  const stacks = await Promise.all(
-    projectDirs.map(async (dir, i) => ({ name: names[i], ir: await graphIr(dir, opts) }))
-  );
+  const stacks = await mapPool(projectDirs, estateReadPool(projectDirs.length), async (dir, i) => ({
+    name: names[i],
+    ir: await graphIr(dir, opts)
+  }));
   return composeStacks(stacks);
 }
 var firstLine2 = (e) => {
@@ -5872,7 +6091,11 @@ function joinNamespaceBindings(members, isDir = realIsDir) {
 async function estateNamespaceScopes(projectDirs, opts, isDir = realIsDir) {
   if (projectDirs.length < 2) return /* @__PURE__ */ new Map();
   const { live: _live, overlay: _overlay, namespace: _namespace, ...src } = opts;
-  const irs = await Promise.all(projectDirs.map((dir) => graphIr(dir, { ...src, detail: 3 }).catch(() => void 0)));
+  const irs = await mapPool(
+    projectDirs,
+    estateReadPool(projectDirs.length),
+    (dir) => graphIr(dir, { ...src, detail: 3 }).catch(() => void 0)
+  );
   const scopes = /* @__PURE__ */ new Map();
   for (const j of joinNamespaceBindings(projectDirs.map((dir, i) => ({ dir, ir: irs[i] })), isDir)) {
     if (!meetsFloor(resolveChant(j.dir).version, NAMESPACE_JOIN_FLOOR)) continue;
@@ -5891,28 +6114,26 @@ async function composeEstateOverlay(projectDirs, opts, classify) {
   const joined = [];
   const stacks = new Array(projectDirs.length);
   const scopes = await estateNamespaceScopes(projectDirs, opts);
-  await Promise.all(
-    projectDirs.map(async (dir, i) => {
-      const name = names[i];
-      const namespace = scopes.get(dir);
+  await mapPool(projectDirs, estateReadPool(projectDirs.length), async (dir, i) => {
+    const name = names[i];
+    const namespace = scopes.get(dir);
+    try {
+      const live = { ...opts, live: true, overlay: true, ...namespace ? { namespace } : {} };
+      stacks[i] = { name, ir: namespaceRuntimeOwners(name, classify(await graphIr(dir, live))) };
+      if (namespace) joined.push({ name, namespace });
+    } catch (err) {
+      const reason = firstLine2(err);
       try {
-        const live = { ...opts, live: true, overlay: true, ...namespace ? { namespace } : {} };
-        stacks[i] = { name, ir: namespaceRuntimeOwners(name, classify(await graphIr(dir, live))) };
-        if (namespace) joined.push({ name, namespace });
-      } catch (err) {
-        const reason = firstLine2(err);
-        try {
-          const { env: _env, live: _live, overlay: _overlay, ...srcOpts } = opts;
-          const src = await graphIr(dir, srcOpts);
-          for (const n of src.nodes) n.attrs = { ...n.attrs, _status: "neutral", _unobserved: reason };
-          stacks[i] = { name, ir: src };
-          unobserved.push({ name, reason });
-        } catch (err2) {
-          dropped.push({ name, reason: firstLine2(err2) });
-        }
+        const { env: _env, live: _live, overlay: _overlay, ...srcOpts } = opts;
+        const src = await graphIr(dir, srcOpts);
+        for (const n of src.nodes) n.attrs = { ...n.attrs, _status: "neutral", _unobserved: reason };
+        stacks[i] = { name, ir: src };
+        unobserved.push({ name, reason });
+      } catch (err2) {
+        dropped.push({ name, reason: firstLine2(err2) });
       }
-    })
-  );
+    }
+  });
   const present = stacks.filter((s) => !!s);
   return {
     ir: composeStacks(present),
@@ -5959,6 +6180,12 @@ function watchSource(projectDir, onChange, debounceMs = 200) {
     watcher.close();
   };
 }
+function watchSources(projectDirs, onChange, debounceMs = 200) {
+  const stops = projectDirs.map((dir) => watchSource(dir, () => onChange(dir), debounceMs));
+  return () => {
+    for (const stop of stops) stop();
+  };
+}
 
 // src/poll.ts
 function digestOf(nodes) {
@@ -5986,18 +6213,22 @@ function changedLexicons(prev, next) {
 }
 function startDriftPoll(opts) {
   let stopped = false;
-  let last;
+  const last = /* @__PURE__ */ new Map();
   let timer;
   const tick = async () => {
-    try {
-      const digests = driftDigestsByLexicon(await opts.query());
-      if (last !== void 0) {
-        const moved = changedLexicons(last, digests);
-        if (moved.length) opts.onChange(moved);
+    for (const member of opts.members) {
+      if (stopped) return;
+      try {
+        const digests = driftDigestsByLexicon(await member.query());
+        const prev = last.get(member.dir);
+        if (prev !== void 0) {
+          const moved = changedLexicons(prev, digests);
+          if (moved.length) opts.onChange(member.dir, moved);
+        }
+        last.set(member.dir, digests);
+      } catch (err) {
+        opts.onError?.(member.dir, err);
       }
-      last = digests;
-    } catch (err) {
-      opts.onError?.(err);
     }
     if (!stopped) timer = setTimeout(tick, opts.intervalMs);
   };
@@ -6571,6 +6802,7 @@ function carveRoutes(app, reportPath, demo) {
   };
   app.post("/api/carve/emit", (c) => runStep2(c, runCarveEmit));
   app.post("/api/carve/bridge", (c) => runStep2(c, runCarveBridge));
+  app.post("/api/carve/observe", (c) => runStep2(c, runCarveObserve));
   app.post("/api/carve/plan", async (c) => {
     const block = demoBlock();
     if (block) {
@@ -6647,7 +6879,7 @@ function createApp(cfg, broadcaster = new Broadcaster(), frames = new FrameBuffe
     if (!info) {
       return c.json({ error: `no Op named "${name}" in the estate` }, 404);
     }
-    if (!runner.trigger(name, info.env, info.dir)) {
+    if (!runner.trigger(name, info.env, info.dir, Boolean(info.gate))) {
       return c.json({ error: `an Op is already running (${runner.running})` }, 409);
     }
     return c.json({ started: true, name });
@@ -6692,7 +6924,7 @@ function createApp(cfg, broadcaster = new Broadcaster(), frames = new FrameBuffe
     const { name, gate } = c.req.param();
     const info = estateOps().find((o) => o.name === name);
     broadcaster.emit("op", `\u270E signal ${name} ${gate}`);
-    const { code, stderr } = await runChantRaw(["run", "signal", name, gate], info?.dir ?? cfg.projectDir);
+    const { code, stderr } = await runChantRaw(["run", "signal", name, gate, "--temporal"], info?.dir ?? cfg.projectDir);
     if (code !== 0) return c.json({ error: stderr.trim() || `signal exited ${code}` }, 500);
     return c.json({ signalled: true });
   });
@@ -7434,17 +7666,18 @@ async function startServer(cfg) {
   const app = createApp(cfg, broadcaster, frames, runner);
   const autoSync = cfg.autoSync ?? "off";
   const capture2 = () => captureFrame(cfg.projectDir, cfg.env, frames, broadcaster);
-  const onEstateChange = () => {
-    broadcaster.emit("changed");
+  const onEstateChange = (memberDir) => {
+    broadcaster.emit("changed", memberDir ?? "");
     void capture2();
   };
-  const onPollDrift = (movedLexicons) => {
-    onEstateChange();
+  const memberTag = (dir) => (cfg.projectDirs?.length ?? 0) > 1 ? ` [${basename(dir)}]` : "";
+  const onPollDrift = (dir, movedLexicons) => {
+    onEstateChange(dir);
     if (autoSync === "off") return;
-    void routeAutoSync(movedLexicons);
+    void routeAutoSync(dir, movedLexicons);
   };
-  const routeAutoSync = async (movedLexicons) => {
-    const suspended = autoSync === "pull-request" ? suspendedByRollback(await openRollbackBranches(cfg.projectDir, cfg.env), movedLexicons) : /* @__PURE__ */ new Set();
+  const routeAutoSync = async (dir, movedLexicons) => {
+    const suspended = autoSync === "pull-request" ? suspendedByRollback(await openRollbackBranches(dir, cfg.env), movedLexicons) : /* @__PURE__ */ new Set();
     const { picks, declined } = pickAutoSyncOps(
       autoSync,
       discoverEstateOps(cfg.projectDirs ?? [cfg.projectDir]),
@@ -7453,31 +7686,37 @@ async function startServer(cfg) {
       suspended
     );
     for (const d of declined) {
-      broadcaster.emit("op", `\u27F3 auto-sync (${autoSync}) declined ${d.lexicon}: ${d.reason}`);
+      broadcaster.emit("op", `\u27F3 auto-sync (${autoSync})${memberTag(dir)} declined ${d.lexicon}: ${d.reason}`);
     }
     for (const { op, lexicons } of picks) {
       const scope = lexicons.join("+");
-      if (runner.trigger(op.name, op.env, op.dir)) {
-        broadcaster.emit("op", `\u27F3 auto-sync (${autoSync}) ${scope} \u2192 ${op.name}`);
+      if (runner.trigger(op.name, op.env, op.dir, Boolean(op.gate))) {
+        broadcaster.emit("op", `\u27F3 auto-sync (${autoSync})${memberTag(dir)} ${scope} \u2192 ${op.name}`);
       } else {
-        broadcaster.emit("op", `\u27F3 auto-sync (${autoSync}) ${scope} \u2192 ${op.name} waiting \u2014 ${runner.running} is running`);
+        broadcaster.emit("op", `\u27F3 auto-sync (${autoSync})${memberTag(dir)} ${scope} \u2192 ${op.name} waiting \u2014 ${runner.running} is running`);
       }
     }
   };
   const carve = !!cfg.carveReport;
   let stopWatch = carve ? () => {
-  } : watchSource(cfg.projectDir, onEstateChange);
+  } : watchSources(cfg.projectDirs ?? [cfg.projectDir], onEstateChange);
   let stopPoll = !carve && cfg.env && cfg.pollSecs ? startDriftPoll({
     intervalMs: cfg.pollSecs * 1e3,
-    query: () => graphIr(cfg.projectDir, { live: true, overlay: true, env: cfg.env }),
+    // Per-member queries, swept sequentially inside the poll (#297): a
+    // member read can take seconds (#295), so an estate-wide tick must
+    // stretch, not stampede N describes at once.
+    members: (cfg.projectDirs ?? [cfg.projectDir]).map((dir) => ({
+      dir,
+      query: () => graphIr(dir, { live: true, overlay: true, env: cfg.env })
+    })),
     onChange: onPollDrift,
-    onError: (err) => process.stderr.write(`poll: ${err instanceof Error ? err.message : String(err)}
+    onError: (dir, err) => process.stderr.write(`poll${memberTag(dir)}: ${err instanceof Error ? err.message : String(err)}
 `)
   }) : () => {
   };
   cfg.onProjectSwitch = (dir) => {
     stopWatch();
-    stopWatch = watchSource(dir, onEstateChange);
+    stopWatch = watchSources(cfg.projectDirs ?? [dir], onEstateChange);
     stopPoll();
     stopPoll = () => {
     };
@@ -7551,7 +7790,7 @@ async function startServer(cfg) {
 
 // src/export.ts
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, copyFileSync, readFileSync as readFileSync14, readdirSync as readdirSync5 } from "node:fs";
-import { join as join17, dirname as dirname5, basename } from "node:path";
+import { join as join17, dirname as dirname5, basename as basename2 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var LENS_PARAMS = ["components", "detail", "env", "logical", "radial", "tier"];
 function canonicalKey(path, params) {
@@ -7602,7 +7841,7 @@ function webDir() {
   return join17(dirname5(fileURLToPath4(import.meta.url)), "..", "web");
 }
 function workerName(project, override) {
-  const raw = override ?? `behold-${basename(project)}`;
+  const raw = override ?? `behold-${basename2(project)}`;
   const name = raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
   return name || "behold-export";
 }