aihand 0.0.1 → 0.1.0

package/dist/chunk-JLYC76XL.js

@@ -0,0 +1,2448 @@
+import {
+  buildPanel,
+  buildStateGraph,
+  classifyKnob,
+  fmtTransitions,
+  openProject
+} from "./chunk-G7KVJ7NF.js";
+import {
+  TYPES,
+  appStackFrames,
+  appendAction,
+  argsFromQuery,
+  compactUrl,
+  diagnose,
+  dispatchAction,
+  dispatchScreen,
+  formatActions,
+  formatTabs,
+  formatValue,
+  isDispatchAction,
+  isLive,
+  isSecretKey,
+  misroutedAction,
+  redactSecretValue,
+  resolveAction,
+  runChain,
+  truncate
+} from "./chunk-YKSYW77R.js";
+import {
+  loadConfig
+} from "./chunk-PQSQN4CN.js";
+import {
+  scan
+} from "./chunk-GNEUSRGP.js";
+
+// src/vite.ts
+import { resolve as resolve4 } from "path";
+
+// src/read/vite.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function resolveCliCmd() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const src = resolve(here, "..", "cli.ts");
+    if (existsSync(src)) {
+      return { cmd: process.execPath, args: ["--import", "tsx", src, "read"] };
+    }
+    for (const rel of ["../cli.js", "../../dist/cli.js"]) {
+      const p = resolve(here, rel);
+      if (existsSync(p))
+        return { cmd: process.execPath, args: [p, "read"] };
+    }
+  } catch {
+  }
+  return { cmd: "npx", args: ["aihand", "read"] };
+}
+function repodexWatchPlugin(opts = {}) {
+  const { args = [], stdio = "inherit" } = opts;
+  return {
+    name: "aihand-read-watch",
+    apply: "serve",
+    configureServer(server) {
+      const { cmd, args: prefix } = resolveCliCmd();
+      const child = spawn(cmd, [...prefix, "--watch", ...args], {
+        stdio,
+        env: { ...process.env, FORCE_COLOR: process.env.FORCE_COLOR ?? "1" }
+      });
+      let done = false;
+      const cleanup = () => {
+        if (done)
+          return;
+        done = true;
+        if (!child.killed)
+          child.kill();
+      };
+      child.once("exit", () => {
+        done = true;
+      });
+      server.httpServer?.once("close", cleanup);
+      process.once("exit", cleanup);
+      for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.once(sig, () => {
+          cleanup();
+          process.kill(process.pid, sig);
+        });
+      }
+    }
+  };
+}
+
+// src/ui/self/store-refs.ts
+import { relative } from "path";
+
+// src/ui/self/discover.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+function projectRootFor(start) {
+  let dir = statSync(start).isDirectory() ? start : dirname2(start);
+  for (; ; ) {
+    if (["tsconfig.app.json", "tsconfig.json"].some((f) => existsSync2(resolve2(dir, f))))
+      return dir;
+    const up = dirname2(dir);
+    if (up === dir)
+      return start;
+    dir = up;
+  }
+}
+function scopePrefix(root) {
+  const abs = resolve2(root);
+  try {
+    return statSync(abs).isDirectory() ? `${abs}/` : abs;
+  } catch {
+    return abs;
+  }
+}
+async function discover(roots, marker = "_loading") {
+  return (await discoverWithPaths(roots, marker)).map(({ abs: _abs, ...n }) => {
+    const i = n.anchor.lastIndexOf(":");
+    const abs = n.anchor.slice(0, i);
+    return { ...n, anchor: `${abs.split("/").slice(-2).join("/")}${n.anchor.slice(i)}` };
+  });
+}
+async function discoverWithPaths(roots, marker = "_loading") {
+  const rawRoots = Array.isArray(roots) ? roots : [roots];
+  const list = rawRoots.map(scopePrefix);
+  const project = await openProject(projectRootFor(resolve2(rawRoots[0])));
+  const { nodes } = buildStateGraph(project, (abs) => abs, marker);
+  return nodes.filter((n) => {
+    const fp = n.anchor.slice(0, n.anchor.lastIndexOf(":"));
+    return list.some((p) => p.endsWith("/") ? fp.startsWith(p) : fp === p);
+  }).map((n) => ({ ...n, abs: n.anchor.slice(0, n.anchor.lastIndexOf(":")) }));
+}
+async function locateExports(roots, names) {
+  const rawRoots = Array.isArray(roots) ? roots : [roots];
+  const project = await openProject(projectRootFor(resolve2(rawRoots[0])));
+  const out = /* @__PURE__ */ new Map();
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    if (fp.endsWith(".d.ts") || fp.includes("/node_modules/"))
+      continue;
+    for (const v of sf.getVariableDeclarations()) {
+      const name = v.getName();
+      if (!names.has(name) || out.has(name))
+        continue;
+      const stmt = v.getVariableStatement();
+      if (stmt && stmt.isExported())
+        out.set(name, fp);
+    }
+  }
+  return out;
+}
+
+// src/ui/self/store-refs.ts
+var VIRTUAL = "virtual:store-refs";
+var RESOLVED = `\0${VIRTUAL}`;
+function toAlias(abs, srcRoot) {
+  let rel = relative(srcRoot, abs);
+  for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
+    if (rel.endsWith(ext)) {
+      rel = rel.slice(0, -ext.length);
+      break;
+    }
+  }
+  return `@/${rel}`;
+}
+function pickFacades(knobNames, discoveredNames) {
+  return [...knobNames].filter((n) => !discoveredNames.has(n));
+}
+function emitModule(refs) {
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const r of refs) {
+    const names = byAlias.get(r.alias) ?? [];
+    names.push(r.name);
+    byAlias.set(r.alias, names);
+  }
+  const imports = [];
+  for (const [alias, names] of byAlias)
+    imports.push(`import { ${[...new Set(names)].sort().join(", ")} } from '${alias}'`);
+  const all = [...new Set(refs.map((r) => r.name))].sort();
+  return `${imports.join("\n")}
+export const stores = { ${all.join(", ")} }
+`;
+}
+function storeRefs(options) {
+  const roots = Array.isArray(options.roots) ? options.roots : [options.roots];
+  let cache = null;
+  const build = async () => {
+    if (cache)
+      return cache;
+    const discovered = await discoverWithPaths(roots, options.storeMarker);
+    const byName = new Map(discovered.map((d) => [d.store, d.abs]));
+    const knobs = await buildPanel(options.knobFiles);
+    const knobNames = new Set(knobs.map((k) => k.store).filter(Boolean));
+    const facadeNames = new Set(pickFacades(knobNames, new Set(byName.keys())));
+    const facadePaths = facadeNames.size ? await locateExports(roots, facadeNames) : /* @__PURE__ */ new Map();
+    const refs = [];
+    const missing = [];
+    for (const name of knobNames) {
+      const abs = byName.get(name) ?? facadePaths.get(name);
+      if (!abs) {
+        missing.push(name);
+        continue;
+      }
+      refs.push({ name, alias: toAlias(abs, options.srcRoot) });
+    }
+    if (missing.length)
+      console.warn(`[aihand:store-refs] \u65CB\u94AE\u5F15\u7528\u4F46\u5B9A\u4F4D\u4E0D\u5230\u58F0\u660E\u7684 store(\u5DF2\u8DF3\u8FC7): ${missing.join(", ")}`);
+    cache = emitModule(refs);
+    return cache;
+  };
+  return {
+    name: "aihand:store-refs",
+    resolveId(id) {
+      if (id === VIRTUAL)
+        return RESOLVED;
+    },
+    async load(id) {
+      if (id !== RESOLVED)
+        return;
+      return build();
+    },
+    // store 文件或组件改动 → 失效缓存,下次 cold load 重 codegen(加旋钮引新 store → 自动并入)。
+    handleHotUpdate(ctx) {
+      if (roots.some((r) => ctx.file.startsWith(r)) || ctx.file.endsWith(".tsx") || ctx.file.endsWith(".jsx"))
+        cache = null;
+    }
+  };
+}
+
+// src/ui/self/store-schema.ts
+var VIRTUAL2 = "virtual:store-schema";
+var RESOLVED2 = "\0" + VIRTUAL2;
+function storeSchema(options) {
+  let cache = null;
+  const roots = Array.isArray(options.roots) ? options.roots : [options.roots];
+  const build = async () => {
+    if (!cache)
+      cache = await discover(roots, options.storeMarker);
+    return cache;
+  };
+  return {
+    name: "aihand:store-schema",
+    resolveId(id) {
+      if (id === VIRTUAL2)
+        return RESOLVED2;
+    },
+    async load(id) {
+      if (id !== RESOLVED2)
+        return;
+      const grown = await build();
+      const byStore = {};
+      for (const g of grown)
+        byStore[g.store] = g;
+      return `export const schema = ${JSON.stringify(byStore)}
+`;
+    },
+    // store 文件改动 → 失效缓存。下次 cold load 重跑引擎(~2s),值域改了 schema 跟着变。
+    // 不在 handleHotUpdate 里同步重投影:引擎离线纪律,绝不让 ts-morph 进同步 HMR 热路径 ——
+    // 值域是类型注解(改动罕见),下次 load 拿到即可,不值得为它在热路径养一个常驻 Project。
+    handleHotUpdate(ctx) {
+      if (roots.some((r) => ctx.file.startsWith(r)))
+        cache = null;
+    }
+  };
+}
+
+// src/ui/server/knob-schema.ts
+import { globSync } from "glob";
+var VIRTUAL3 = "virtual:aihand-knobs";
+var RESOLVED3 = "\0" + VIRTUAL3;
+function keyOf(label, tag, file) {
+  return `${label ?? `<${tag}>`} ${file}`;
+}
+function knobSchema(options = {}) {
+  const include = options.include ?? ["src/**/*.tsx", "src/**/*.jsx"];
+  let cache = null;
+  const build = async () => {
+    if (cache)
+      return cache;
+    const files = globSync(include, { nodir: true, ignore: ["**/node_modules/**"] });
+    const knobs = await buildPanel(files);
+    const byKey = {};
+    for (const k of knobs) {
+      const file = k.filePath.split("/").slice(-2).join("/");
+      const { ops, arity, executable } = classifyKnob(k.transitions);
+      byKey[keyOf(k.label, k.tag, file)] = {
+        transitions: fmtTransitions(k.transitions),
+        store: k.store,
+        line: k.line,
+        ops,
+        arity,
+        executable
+      };
+    }
+    cache = byKey;
+    return byKey;
+  };
+  return {
+    name: "aihand:knob-schema",
+    resolveId(id) {
+      if (id === VIRTUAL3)
+        return RESOLVED3;
+    },
+    async load(id) {
+      if (id !== RESOLVED3)
+        return;
+      const knobs = await build();
+      return `export const knobs = ${JSON.stringify(knobs)}
+`;
+    },
+    // 组件改动 → 失效缓存,HMR 重投影(onClick 改了 → 态射跟着变)。
+    handleHotUpdate(ctx) {
+      if (ctx.file.endsWith(".tsx") || ctx.file.endsWith(".jsx"))
+        cache = null;
+    }
+  };
+}
+
+// src/ui/server/plugin.ts
+import { Buffer } from "buffer";
+import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname3, isAbsolute, relative as relative2, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { transformSync } from "esbuild";
+
+// src/ui/babel/source-loc.ts
+import path from "path";
+function sourceLocPlugin(t) {
+  return {
+    name: "aihand-source-loc",
+    visitor: {
+      JSXOpeningElement(nodePath, state) {
+        const filename = state.file?.opts?.filename ?? "";
+        if (!filename || filename.includes("node_modules"))
+          return;
+        if (filename.includes("packages/aidev/"))
+          return;
+        const nameNode = nodePath.node.name;
+        if (!t.isJSXIdentifier(nameNode))
+          return;
+        const tag = nameNode.name;
+        if (tag[0] === tag[0].toUpperCase())
+          return;
+        if (hasInspAttr(t, nodePath.node))
+          return;
+        const loc = nodePath.node.loc;
+        if (!loc)
+          return;
+        const root = state.file?.opts?.root ?? "";
+        const rel = root ? path.relative(root, filename) : filename;
+        const value = `${rel}:${loc.start.line}:${loc.start.column + 1}:${path.basename(rel, path.extname(rel))}`;
+        nodePath.node.attributes.push(
+          t.jsxAttribute(t.jsxIdentifier("data-insp-path"), t.stringLiteral(value))
+        );
+      }
+    }
+  };
+}
+function hasInspAttr(t, node) {
+  return node.attributes.some((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === "data-insp-path");
+}
+
+// src/ui/bridge/vite-bridge.ts
+var VISIBLE_MS = 400;
+function viteBridge(server, deps) {
+  const progressAt = /* @__PURE__ */ new Map();
+  server.hot.on("aihand:action-progress", (data) => {
+    if (typeof data.id === "number")
+      progressAt.set(data.id, Date.now());
+  });
+  const request = (reqEvent, replyEvent, payload, opts) => {
+    const tab = opts?.tab;
+    const fullMs = opts?.timeoutMs ?? 3e3;
+    const id = payload.id;
+    const lastProgress = opts?.lastProgress ?? (id !== void 0 ? () => progressAt.get(id) : void 0);
+    return new Promise((resolve5, reject) => {
+      let settled = false;
+      const onReply = (data) => {
+        if (settled)
+          return;
+        if (id !== void 0 && data.id !== id)
+          return;
+        settled = true;
+        cleanup();
+        resolve5(data);
+      };
+      server.hot.on(replyEvent, onReply);
+      const cleanup = () => {
+        server.hot.off(replyEvent, onReply);
+        if (id !== void 0)
+          progressAt.delete(id);
+      };
+      if (tab) {
+        const RETRY_MS = 500;
+        const ABSENT_CEILING_MS = 1e4;
+        const startedAt = Date.now();
+        const deliver = () => server.hot.send(reqEvent, { ...payload, tab });
+        deliver();
+        const iv = setInterval(() => {
+          if (settled) {
+            clearInterval(iv);
+            return;
+          }
+          const t = deps.tabs.get(tab);
+          const live = !!t && isLive(t, Date.now());
+          const progress = lastProgress?.();
+          const sinceLife = Date.now() - Math.max(startedAt, progress ?? 0);
+          const elapsed = Date.now() - startedAt;
+          if (live) {
+            if (sinceLife > fullMs) {
+              clearInterval(iv);
+              cleanup();
+              reject(new Error(deps.diagnose(tab)));
+            }
+          } else if (elapsed > ABSENT_CEILING_MS) {
+            clearInterval(iv);
+            cleanup();
+            reject(new Error(deps.diagnose(tab)));
+          } else {
+            deliver();
+          }
+        }, RETRY_MS);
+        return;
+      }
+      server.hot.send(reqEvent, { ...payload, requireVisible: true });
+      setTimeout(() => {
+        if (settled)
+          return;
+        server.hot.send(reqEvent, { ...payload, requireVisible: false });
+        setTimeout(() => {
+          if (settled)
+            return;
+          cleanup();
+          reject(new Error(deps.diagnose(tab)));
+        }, fullMs);
+      }, VISIBLE_MS);
+    });
+  };
+  const emit2 = (event, payload) => server.hot.send(event, payload);
+  return { request, emit: emit2 };
+}
+
+// src/ui/core/check.ts
+function check(raw) {
+  const consoleErrors = raw.console.filter((l) => l.level === "error");
+  const failedRequests = raw.network.filter((r) => r.status >= 400 || r.failed);
+  const assertions = [
+    {
+      name: "no-console-errors",
+      pass: consoleErrors.length === 0,
+      ...consoleErrors.length && { detail: consoleErrors[0].text }
+    },
+    {
+      name: "no-uncaught-errors",
+      pass: raw.errors.length === 0,
+      ...raw.errors.length && { detail: raw.errors[0].message }
+    },
+    {
+      name: "no-failed-requests",
+      pass: failedRequests.length === 0,
+      ...failedRequests.length && { detail: `${failedRequests[0].method} ${failedRequests[0].url} ${failedRequests[0].status}` }
+    },
+    {
+      name: "ui-not-empty",
+      pass: raw.ui.trim().length > 0,
+      ...!raw.ui.trim().length && { detail: "UI tree is empty" }
+    }
+  ];
+  return {
+    pass: assertions.every((a) => a.pass),
+    assertions
+  };
+}
+
+// src/ui/core/perf.ts
+var FRAME_NOISE_PCT = 3;
+var SELF_NOISE_REL = 0.1;
+var SELF_NOISE_MS = 5;
+var avgOf = (samples) => samples.length > 0 ? samples.reduce((s, v) => s + v, 0) / samples.length : 0;
+function summarizeStat(stat) {
+  const avg = stat.n > 0 ? stat.total / stat.n : 0;
+  return {
+    total: stat.total,
+    n: stat.n,
+    avg,
+    max: stat.max
+  };
+}
+function compactPerformance(p) {
+  const all = p.buckets.find((b) => b.name === "__all__");
+  if (!all) return "perf: (no data)";
+  const { total, long, samples } = all.frames;
+  const fps = total > 0 ? Math.round(1e3 / avgOf(samples) * 10) / 10 : 0;
+  const droppedPct = total > 0 ? Math.round(long / total * 100) : 0;
+  const parts = [`${fps}fps`, `${droppedPct}% dropped`];
+  if (p.longtasks.count > 0) {
+    parts.push(`${p.longtasks.count} longtasks(max ${Math.round(p.longtasks.max)}ms)`);
+  }
+  const topComps = Object.entries(all.components).map(([name, stat]) => ({ name, total: stat.total })).sort((a, b) => b.total - a.total).slice(0, 2);
+  if (topComps.length > 0 && p.mobxPatched) {
+    const hot = topComps.map((c) => `${c.name} ${Math.round(c.total)}ms`).join(", ");
+    parts.push(`hot: ${hot}`);
+  }
+  return `perf: ${parts.join(" \xB7 ")}`;
+}
+function detailPerformance(p) {
+  const lines = [];
+  const windowSec = (p.windowMs / 1e3).toFixed(1);
+  lines.push(`=== Performance (${windowSec}s window) ===`);
+  if (p.hiddenFrames > 0) {
+    lines.push(`\u26A0 Tab was backgrounded or unfocused \u2014 ${p.hiddenFrames} throttled frames skipped (rAF throttling lies about timing)`);
+    lines.push("For accurate profiling: keep tab FOREGROUND + FOCUSED + run /profile/reset before reproducing");
+  }
+  lines.push(`MobX attribution: ${p.mobxPatched ? "ON" : "OFF"}`);
+  if (!p.mobxPatched) {
+    lines.push("(Component attribution disabled \u2014 set window.__AIPEEK_MOBX__={Reaction} in src/lib/mobx.ts to enable)");
+  }
+  lines.push("");
+  if (p.longtasks.count > 0) {
+    lines.push(`Longtasks (>50ms): ${p.longtasks.count}, max ${Math.round(p.longtasks.max)}ms`);
+    lines.push("");
+  }
+  const showPerView = p.buckets.length > 1;
+  for (const bucket of p.buckets) {
+    if (bucket.name !== "__all__" && !showPerView) continue;
+    lines.push(`--- ${bucket.name} ---`);
+    const { total, long, max, samples } = bucket.frames;
+    if (total === 0) {
+      lines.push("Frames: none sampled (tab unfocused/hidden \u2014 no frame data this window)");
+    } else {
+      const droppedPct = (long / total * 100).toFixed(1);
+      const avgFrame = avgOf(samples).toFixed(1);
+      lines.push(`Frames: ${total} total, ${long} dropped (${droppedPct}%), max ${Math.round(max)}ms, avg ${avgFrame}ms`);
+    }
+    const comps = Object.entries(bucket.components).map(([name, stat]) => ({ name, ...summarizeStat(stat) })).sort((a, b) => b.total - a.total).slice(0, 20);
+    if (comps.length > 0 && p.mobxPatched) {
+      lines.push("Components (by total self-time):");
+      for (const c of comps) {
+        lines.push(`  ${c.name.padEnd(30)} ${Math.round(c.total)}ms / ${c.n}\xD7 = ${c.avg.toFixed(1)}ms avg, max ${Math.round(c.max)}ms`);
+      }
+    } else if (!p.mobxPatched) {
+      lines.push("(no component data \u2014 attribution OFF)");
+    }
+    const hotLines = Object.entries(bucket.lines ?? {}).map(([label, stat]) => ({ label, ...summarizeStat(stat) })).sort((a, b) => b.total - a.total).slice(0, 15);
+    if (hotLines.length > 0) {
+      lines.push("Hot lines (by total inclusive time \u2014 contains nested calls):");
+      for (const l of hotLines) {
+        lines.push(`  ${l.label.padEnd(36)} ${Math.round(l.total)}ms / ${l.n}\xD7 = ${l.avg.toFixed(1)}ms avg, max ${Math.round(l.max)}ms`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function diffPerformance(before, after) {
+  const out = [];
+  const beforeAll = before.buckets.find((b) => b.name === "__all__");
+  const afterAll = after.buckets.find((b) => b.name === "__all__");
+  const droppedPct = (b) => b && b.frames.total > 0 ? b.frames.long / b.frames.total * 100 : 0;
+  const beforeDrop = droppedPct(beforeAll);
+  const afterDrop = droppedPct(afterAll);
+  const dropDelta = afterDrop - beforeDrop;
+  const sumTotal = (b) => b ? Object.values(b.components).reduce((s, c) => s + c.total, 0) : 0;
+  const beforeSelf = sumTotal(beforeAll);
+  const afterSelf = sumTotal(afterAll);
+  const selfDelta = afterSelf - beforeSelf;
+  const bothSampledFrames = (beforeAll?.frames.total ?? 0) > 0 && (afterAll?.frames.total ?? 0) > 0;
+  const sawDrops = (beforeAll?.frames.long ?? 0) > 0 || (afterAll?.frames.long ?? 0) > 0;
+  const framesExercised = bothSampledFrames && sawDrops;
+  const afterBlind = afterSelf === 0 && (beforeSelf > 0 || (afterAll?.frames.total ?? 0) === 0);
+  let verdict;
+  if (afterBlind) {
+    verdict = "NO DATA";
+  } else if (framesExercised) {
+    if (dropDelta < -FRAME_NOISE_PCT) verdict = "IMPROVED";
+    else if (dropDelta > FRAME_NOISE_PCT) verdict = "REGRESSED";
+    else verdict = "UNCHANGED";
+  } else {
+    const floor = Math.max(SELF_NOISE_MS, beforeSelf * SELF_NOISE_REL);
+    if (selfDelta < -floor) verdict = "IMPROVED";
+    else if (selfDelta > floor) verdict = "REGRESSED";
+    else verdict = "UNCHANGED";
+  }
+  out.push(`=== Perf diff: ${verdict} ===`);
+  if (afterBlind) {
+    const why = (afterAll?.frames.total ?? 0) === 0 ? "recorded no frames and no re-renders" : `recorded frames but zero re-renders (was ${Math.round(beforeSelf)}ms self-time)`;
+    out.push(`after-window ${why} \u2014 tab backgrounded or workload not reproduced. Re-run with the tab focused and the interaction repeated.`);
+    out.push("");
+    return out.join("\n").trimEnd();
+  }
+  out.push(`Dropped frames: ${beforeDrop.toFixed(1)}% \u2192 ${afterDrop.toFixed(1)}% (${dropDelta >= 0 ? "+" : ""}${dropDelta.toFixed(1)}%)`);
+  if (!framesExercised && Math.round(selfDelta) !== 0) {
+    out.push(`Total self-time: ${Math.round(beforeSelf)}ms \u2192 ${Math.round(afterSelf)}ms (${selfDelta >= 0 ? "+" : ""}${Math.round(selfDelta)}ms) \u2014 frames flat, verdict by self-time`);
+  }
+  if (before.longtasks.count !== after.longtasks.count) {
+    out.push(`Longtasks: ${before.longtasks.count} \u2192 ${after.longtasks.count}`);
+  }
+  out.push("");
+  const compDelta = keyedTotalDelta(beforeAll?.components ?? {}, afterAll?.components ?? {});
+  if (compDelta.length > 0) {
+    out.push("Components (\u0394 total self-time):");
+    for (const d of compDelta) out.push("  " + formatDelta(d));
+    out.push("");
+  }
+  const lineDelta = keyedTotalDelta(beforeAll?.lines ?? {}, afterAll?.lines ?? {});
+  if (lineDelta.length > 0) {
+    out.push("Hot lines (\u0394 total inclusive time):");
+    for (const d of lineDelta) out.push("  " + formatDelta(d));
+  }
+  return out.join("\n").trimEnd();
+}
+function keyedTotalDelta(a, b) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  const rows = [];
+  for (const key of keys) {
+    const beforeT = a[key]?.total ?? 0;
+    const afterT = b[key]?.total ?? 0;
+    const delta = afterT - beforeT;
+    if (Math.round(delta) === 0) continue;
+    rows.push({ key, before: beforeT, after: afterT, delta, isNew: !a[key], gone: !b[key] });
+  }
+  return rows.sort((x, y) => Math.abs(y.delta) - Math.abs(x.delta)).slice(0, 20);
+}
+function formatDelta(d) {
+  const sign = d.delta >= 0 ? "+" : "";
+  const tag = d.isNew ? " (new)" : d.gone ? " (gone)" : "";
+  return `${d.key.padEnd(36)} ${Math.round(d.before)}ms \u2192 ${Math.round(d.after)}ms (${sign}${Math.round(d.delta)}ms)${tag}`;
+}
+
+// src/ui/core/compact.ts
+var SLOW_THRESHOLD = 1e3;
+var MAX_UI_DEPTH = 6;
+var UI_PRIMITIVES = /* @__PURE__ */ new Set([
+  "Button",
+  "Input",
+  "Label",
+  "Badge",
+  "Checkbox",
+  "Skeleton",
+  "Spinner",
+  "Switch",
+  "Tabs",
+  "Tooltip",
+  "Popover",
+  "Dialog",
+  "Select",
+  "Card",
+  "Table",
+  "Slider",
+  "Progress",
+  "RadioGroup",
+  "HoverCard",
+  "DropdownMenu",
+  "ContextMenu",
+  "Command",
+  "Form",
+  "Alert",
+  "Pagination",
+  "Textarea",
+  "TooltipProvider",
+  "DialogPortal",
+  "Router",
+  "RenderErrorBoundary",
+  "RouterProvider",
+  "RouterProvider2",
+  "PanelGroup",
+  "Panel"
+]);
+function nameOf(line) {
+  let end = 0;
+  while (end < line.length) {
+    const c = line[end];
+    if (c === " " || c === "	" || c === "[" || c === "\u2014")
+      break;
+    end++;
+  }
+  return line.slice(0, end);
+}
+function compactUI(tree) {
+  if (!tree)
+    return "";
+  const lines = tree.split("\n");
+  const result = [];
+  const repeatTracker = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trimStart();
+    if (!trimmed)
+      continue;
+    const indent = line.length - trimmed.length;
+    const depth = Math.floor(indent / 2);
+    if (depth > MAX_UI_DEPTH)
+      continue;
+    const componentName = nameOf(trimmed);
+    if (UI_PRIMITIVES.has(componentName))
+      continue;
+    const key = `${depth}:${componentName}`;
+    const tracker = repeatTracker.get(key);
+    if (tracker && i - tracker.lastIndex <= 2) {
+      tracker.count++;
+      tracker.lastIndex = i;
+      continue;
+    }
+    for (const [k, t] of repeatTracker) {
+      if (t.count > 1) {
+        const d = Number.parseInt(k.split(":")[0]);
+        const name = k.split(":").slice(1).join(":");
+        result.push(`${"  ".repeat(d)}${name} \xD7${t.count}`);
+      }
+      if (t.count > 1 || i - t.lastIndex > 2) {
+        repeatTracker.delete(k);
+      }
+    }
+    repeatTracker.set(key, { count: 1, lastIndex: i });
+    result.push(line);
+  }
+  for (const [k, t] of repeatTracker) {
+    if (t.count > 1) {
+      const d = Number.parseInt(k.split(":")[0]);
+      const name = k.split(":").slice(1).join(":");
+      result.push(`${"  ".repeat(d)}${name} \xD7${t.count}`);
+    }
+  }
+  return result.join("\n");
+}
+var NOISE_SUBSTRINGS = [
+  "[hmr]",
+  "[vite]",
+  "hot module",
+  "react-devtools",
+  "download the react devtools",
+  "warning: react does not recognize",
+  "source map",
+  "favicon.ico",
+  "webpack"
+];
+function compactConsole(logs) {
+  if (!logs.length)
+    return "";
+  const filtered = logs.filter((l) => {
+    const lower = l.text.toLowerCase();
+    return !NOISE_SUBSTRINGS.some((s) => lower.includes(s));
+  });
+  if (!filtered.length)
+    return "";
+  const deduped = [];
+  for (const log of filtered) {
+    const last = deduped[deduped.length - 1];
+    if (last && last.entry.text === log.text && last.entry.level === log.level) {
+      last.count++;
+    } else {
+      deduped.push({ entry: log, count: 1 });
+    }
+  }
+  const errors = deduped.filter((d) => d.entry.level === "error");
+  const warns = deduped.filter((d) => d.entry.level === "warn");
+  const rest = deduped.filter((d) => d.entry.level !== "error" && d.entry.level !== "warn");
+  const recentRest = rest.slice(-10);
+  const lines = [];
+  for (const group of [...errors, ...warns, ...recentRest]) {
+    const prefix = `[${group.entry.level}]`;
+    const count = group.count > 1 ? ` \xD7${group.count}` : "";
+    const source = group.entry.source ? ` (${group.entry.source})` : "";
+    const text = truncate(group.entry.text, 200);
+    lines.push(`${prefix}${count} ${text}${source}`);
+  }
+  return lines.join("\n");
+}
+function compactNetwork(requests) {
+  if (!requests.length)
+    return "";
+  const relevant = requests.filter(
+    (r) => r.resourceType === "fetch" || r.resourceType === "xhr" || r.resourceType === "websocket" || r.resourceType === "eventsource" || isApiUrl(r.url)
+  );
+  if (!relevant.length)
+    return "";
+  const lines = [];
+  for (const req of relevant) {
+    const duration = req.duration > 0 ? ` ${formatDuration(req.duration)}` : "";
+    const slow = req.duration >= SLOW_THRESHOLD ? " [SLOW]" : "";
+    const url = compactUrl(req.url, 50);
+    const headers = diagnosticHeaders(req);
+    if (req.failed || req.status >= 400) {
+      const body = req.responseBody ? ` "${truncate(req.responseBody, 100)}"` : "";
+      const failure = req.failureText ? ` (${req.failureText})` : "";
+      lines.push(`${req.method} ${url} ${req.status}${failure}${body}${headers}${duration}${slow}`);
+    } else {
+      lines.push(`${req.method} ${url} ${req.status}${headers}${duration}${slow}`);
+    }
+  }
+  return lines.join("\n");
+}
+function isApiUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.pathname.startsWith("/api") || u.pathname.includes("/graphql");
+  } catch {
+    return false;
+  }
+}
+var DIAGNOSTIC_HEADERS = ["content-type", "x-error", "www-authenticate", "access-control-allow-origin"];
+function diagnosticHeaders(req) {
+  const h = req.responseHeaders;
+  if (!h)
+    return "";
+  const parts = [];
+  for (const key of DIAGNOSTIC_HEADERS) {
+    const val = h[key];
+    if (!val)
+      continue;
+    if (key === "content-type" && req.status < 400 && val.includes("application/json"))
+      continue;
+    parts.push(`${key}: ${truncate(val, 60)}`);
+  }
+  if (!parts.length)
+    return "";
+  return ` [${parts.join(", ")}]`;
+}
+function formatDuration(ms) {
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
+}
+function compactErrors(errors) {
+  if (!errors.length)
+    return "";
+  const seen = /* @__PURE__ */ new Map();
+  for (const err of errors) {
+    if (!seen.has(err.message)) {
+      seen.set(err.message, err);
+    }
+  }
+  const lines = [];
+  for (const err of seen.values()) {
+    lines.push(err.message);
+    if (err.stack) {
+      for (const frame of appStackFrames(err.stack, 5))
+        lines.push(`  ${frame}`);
+    }
+  }
+  return lines.join("\n");
+}
+function compactState(state) {
+  if (!state || !Object.keys(state).length)
+    return "";
+  const lines = [];
+  for (const [name, value] of Object.entries(state)) {
+    lines.push(`${name}:`);
+    if (typeof value === "object" && value !== null) {
+      for (const [k, v] of Object.entries(value)) {
+        lines.push(`  ${k}: ${truncate(formatValue(v), 120)}`);
+      }
+    } else {
+      lines.push(`  ${String(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function compact(raw) {
+  return {
+    url: raw.url,
+    ui: compactUI(raw.ui),
+    console: compactConsole(raw.console),
+    network: compactNetwork(raw.network),
+    errors: compactErrors(raw.errors),
+    state: compactState(raw.state),
+    performance: raw.performance ? detailPerformance(raw.performance) : void 0,
+    timestamp: raw.timestamp,
+    counts: {
+      console: raw.console.length,
+      network: raw.network.length,
+      errors: raw.errors.length,
+      state: Object.keys(raw.state).length
+    }
+  };
+}
+
+// src/ui/core/detail.ts
+var headerLine = (k, v) => `  ${k}: ${isSecretKey(k) ? redactSecretValue(v) : v}`;
+function detail(raw, section, index, full) {
+  switch (section) {
+    case "ui":
+      return full ? raw.ui || null : compactUI(raw.ui) || null;
+    case "console":
+      return detailConsole(raw.console, index, full);
+    case "network":
+      return detailNetwork(raw.network, index, full);
+    case "errors":
+      return detailError(raw.errors, index, full);
+    case "state":
+      return detailState(raw.state, index, full);
+    case "profile":
+      return raw.performance ? detailPerformance(raw.performance) : "(no perf data \u2014 is the tab foreground?)";
+    default:
+      return null;
+  }
+}
+function detailConsole(logs, index, full) {
+  if (index === void 0) {
+    if (!logs.length)
+      return "(empty)";
+    return logs.map((log2, i2) => `[${i2}] [${log2.level}] ${truncate(log2.text, 120)}`).join("\n");
+  }
+  const i = Number.parseInt(index);
+  if (Number.isNaN(i) || i < 0 || i >= logs.length)
+    return null;
+  const log = logs[i];
+  if (full) {
+    const parts = [`[${log.level}] ${log.text}`];
+    if (log.timestamp)
+      parts.push(`timestamp: ${new Date(log.timestamp).toISOString()}`);
+    if (log.source)
+      parts.push(`source: ${log.source}`);
+    return parts.join("\n");
+  }
+  return `[${log.level}] ${truncate(log.text, 200)}`;
+}
+function detailNetwork(requests, index, full) {
+  if (index === void 0) {
+    if (!requests.length)
+      return "(empty)";
+    return requests.map((req2, i2) => `[${i2}] ${req2.method} ${req2.status} ${truncate(req2.url, 80)} ${req2.duration}ms${req2.failed ? " FAILED" : ""}`).join("\n");
+  }
+  const i = Number.parseInt(index);
+  if (Number.isNaN(i) || i < 0 || i >= requests.length)
+    return null;
+  const req = requests[i];
+  const lines = [
+    `${req.method} ${req.url}`,
+    `status: ${req.status}`,
+    `duration: ${req.duration}ms`,
+    `type: ${req.resourceType}`
+  ];
+  if (req.failed)
+    lines.push(`failed: ${req.failureText || "true"}`);
+  if (full) {
+    if (req.requestHeaders && Object.keys(req.requestHeaders).length) {
+      lines.push("request-headers:");
+      for (const [k, v] of Object.entries(req.requestHeaders)) lines.push(headerLine(k, v));
+    }
+    if (req.requestBody)
+      lines.push(`request-body:
+${req.requestBody}`);
+    if (req.responseHeaders && Object.keys(req.responseHeaders).length) {
+      lines.push("response-headers:");
+      for (const [k, v] of Object.entries(req.responseHeaders)) lines.push(headerLine(k, v));
+    }
+    if (req.responseBody)
+      lines.push(`response-body:
+${req.responseBody}`);
+  } else {
+    if (req.requestBody) {
+      lines.push(`request-body: ${byteSize(req.requestBody)}`);
+      if (req.requestSample) {
+        const schema = jsonSchema(req.requestSample);
+        if (schema)
+          lines.push(schema);
+      }
+    }
+    if (req.responseBody) {
+      if (req.status >= 400) {
+        lines.push(`response-body: ${byteSize(req.responseBody)} "${truncate(req.responseBody, 100)}"`);
+      } else {
+        if (req.responseSample) {
+          lines.push(`response-body: ${byteSize(req.responseBody)}`);
+          const schema = jsonSchema(req.responseSample);
+          if (schema)
+            lines.push(schema);
+        } else {
+          lines.push(`response-body: ${byteSize(req.responseBody)} ${truncate(req.responseBody, 100)}`);
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function detailError(errors, index, full) {
+  if (index === void 0) {
+    if (!errors.length)
+      return "(empty)";
+    return errors.map((err2, i2) => `[${i2}] ${truncate(err2.message, 120)}`).join("\n");
+  }
+  const i = Number.parseInt(index);
+  if (Number.isNaN(i) || i < 0 || i >= errors.length)
+    return null;
+  const err = errors[i];
+  if (full) {
+    const lines2 = [err.message];
+    if (err.stack)
+      lines2.push(err.stack);
+    if (err.source)
+      lines2.push(`source: ${err.source}`);
+    if (err.line != null)
+      lines2.push(`location: ${err.source || ""}:${err.line}:${err.column ?? 0}`);
+    return lines2.join("\n");
+  }
+  const lines = [err.message];
+  if (err.stack) {
+    const all = appStackFrames(err.stack, Infinity);
+    lines.push(...all.slice(0, 3));
+    if (all.length > 3)
+      lines.push(`  ... ${all.length - 3} more app frames`);
+  }
+  if (err.line != null)
+    lines.push(`location: ${err.source || ""}:${err.line}:${err.column ?? 0}`);
+  return lines.join("\n");
+}
+function detailState(state, name, full) {
+  if (!name) {
+    const keys = Object.keys(state);
+    if (!keys.length)
+      return "(empty)";
+    return keys.map((k) => `${k}: ${formatSummaryValue(state[k])}`).join("\n");
+  }
+  if (!(name in state))
+    return null;
+  const value = state[name];
+  if (full) {
+    try {
+      return JSON.stringify(value, null, 2) ?? formatValue(value);
+    } catch {
+      return formatValue(value);
+    }
+  }
+  if (typeof value !== "object" || value === null)
+    return `${name}: ${typeof value}`;
+  const lines = [];
+  for (const [k, v] of Object.entries(value)) {
+    lines.push(`${k}: ${formatSummaryValue(v)}`);
+  }
+  return lines.join("\n");
+}
+function isArraySentinel(v) {
+  if (!v.startsWith("Array(") || !v.endsWith(")"))
+    return false;
+  const digits = v.slice(6, -1);
+  return digits.length > 0 && [...digits].every((c) => c >= "0" && c <= "9");
+}
+function formatSummaryValue(v) {
+  if (typeof v === "string" && isArraySentinel(v))
+    return v;
+  return truncate(formatValue(v), 80);
+}
+function jsonSchema(sample) {
+  try {
+    return schemaOf(JSON.parse(sample), 0);
+  } catch {
+    return null;
+  }
+}
+function schemaOf(v, d) {
+  if (v === null)
+    return "null";
+  if (typeof v === "string")
+    return "string";
+  if (typeof v === "number")
+    return "number";
+  if (typeof v === "boolean")
+    return "boolean";
+  if (Array.isArray(v)) {
+    if (!v.length)
+      return "[]";
+    if (d >= 3)
+      return "[\u2026]";
+    return `${schemaOf(v[0], d + 1)}[]`;
+  }
+  if (typeof v === "object") {
+    if (d >= 3)
+      return "{\u2026}";
+    const entries = Object.entries(v);
+    if (!entries.length)
+      return "{}";
+    const max = d === 0 ? 12 : 6;
+    const fields = entries.slice(0, max).map(([k, val]) => `${k}: ${schemaOf(val, d + 1)}`);
+    if (entries.length > max)
+      fields.push(`\u2026 ${entries.length - max} more`);
+    return `{ ${fields.join(", ")} }`;
+  }
+  return typeof v;
+}
+function byteSize(s) {
+  const bytes = new TextEncoder().encode(s).length;
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/ui/core/diff.ts
+var GONE_FRAC = 0.15;
+function regionsChanged(before, after) {
+  if (!before.length || !after.length)
+    return false;
+  const afterKeys = new Set(after.map((r) => r.key));
+  const beforeKeys = new Set(before.map((r) => r.key));
+  const gone = before.filter((r) => !afterKeys.has(r.key)).length;
+  const appeared = after.filter((r) => !beforeKeys.has(r.key)).length;
+  return gone >= before.length * GONE_FRAC && appeared > 0;
+}
+var POPOVER_MIN_CHILDREN = 2;
+function popoverChange(before, after) {
+  const beforeKeys = new Set(before.map((r) => r.key));
+  const afterKeys = new Set(after.map((r) => r.key));
+  const appeared = after.filter((r) => !beforeKeys.has(r.key));
+  const gone = before.filter((r) => !afterKeys.has(r.key));
+  const top = (rs) => rs.reduce((m, r) => !m || childCount(r) > childCount(m) ? r : m, void 0);
+  const add = top(appeared);
+  if (appeared.length > gone.length && add && childCount(add) >= POPOVER_MIN_CHILDREN)
+    return `panel: appeared (${add.label})`;
+  const rm = top(gone);
+  if (gone.length > appeared.length && rm && childCount(rm) >= POPOVER_MIN_CHILDREN)
+    return `panel: dismissed (${rm.label})`;
+  return void 0;
+}
+function childCount(r) {
+  const i = r.key.lastIndexOf("#");
+  return i < 0 ? 0 : Number(r.key.slice(i + 1)) || 0;
+}
+function diffScreen(before, after, newErrors, newExceptions, newFailedRequests) {
+  const lines = [];
+  let bodyOrModalNamed = false;
+  if (after.view !== before.view) {
+    lines.push(`view: ${before.view} \u2192 ${after.view}`);
+    bodyOrModalNamed = true;
+  } else if (before.view === "(unknown)" && after.modal === "none" && regionsChanged(before.regions ?? [], after.regions ?? [])) {
+    lines.push("view: changed (DOM \u533A\u57DF\u6307\u7EB9)");
+    bodyOrModalNamed = true;
+  }
+  if (after.modal !== before.modal) {
+    if (after.modal === "none")
+      lines.push(`modal: closed (${before.modal})`);
+    else if (before.modal === "none")
+      lines.push(`modal: opened ${after.modal}`);
+    else
+      lines.push(`modal: ${before.modal} \u2192 ${after.modal}`);
+    bodyOrModalNamed = true;
+  }
+  if (!bodyOrModalNamed) {
+    const pop = popoverChange(before.regions ?? [], after.regions ?? []);
+    if (pop)
+      lines.push(pop);
+  }
+  if (after.focus !== before.focus)
+    lines.push(`focus: ${after.focus}`);
+  const beforeDomain = before.domain ?? {};
+  const afterDomain = after.domain ?? {};
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(beforeDomain), ...Object.keys(afterDomain)])) {
+    const b = redactDomain(key, beforeDomain[key]);
+    const a = redactDomain(key, afterDomain[key]);
+    if (b !== a)
+      lines.push(`${key}: ${b} \u2192 ${a}`);
+  }
+  for (const e of newErrors)
+    lines.push(`+error: ${e.text}`);
+  for (const e of newExceptions)
+    lines.push(`+exception: ${e.message}`);
+  for (const r of newFailedRequests)
+    lines.push(`+failed: ${r.method} ${r.url} \u2192 ${r.status || "failed"}`);
+  return lines;
+}
+function stringifyDomain(v) {
+  if (v === null || v === void 0)
+    return String(v);
+  if (typeof v === "object")
+    return JSON.stringify(v).slice(0, 80);
+  return String(v).slice(0, 80);
+}
+function redactDomain(key, v) {
+  const s = stringifyDomain(v);
+  if (!isSecretKey(key))
+    return s;
+  const raw = v === null || v === void 0 ? "" : String(v);
+  return raw ? redactSecretValue(raw) : s;
+}
+function diffState(prev, curr) {
+  if (!prev) {
+    return {
+      newErrors: curr.console.filter((l) => l.level === "error"),
+      newExceptions: [...curr.errors],
+      newFailedRequests: curr.network.filter((r) => r.status >= 400 || r.failed),
+      uiGone: false,
+      clean: curr.console.filter((l) => l.level === "error").length === 0 && curr.errors.length === 0 && curr.network.filter((r) => r.status >= 400 || r.failed).length === 0
+    };
+  }
+  const prevErrorTexts = new Set(prev.console.filter((l) => l.level === "error").map((l) => l.text));
+  const newErrors = curr.console.filter((l) => l.level === "error" && !prevErrorTexts.has(l.text));
+  const prevExceptionMsgs = new Set(prev.errors.map((e) => e.message));
+  const newExceptions = curr.errors.filter((e) => !prevExceptionMsgs.has(e.message));
+  const prevFailedKeys = new Set(
+    prev.network.filter((r) => r.status >= 400 || r.failed).map((r) => `${r.method}|${r.url}|${r.status}`)
+  );
+  const newFailedRequests = curr.network.filter((r) => r.status >= 400 || r.failed).filter((r) => !prevFailedKeys.has(`${r.method}|${r.url}|${r.status}`));
+  const uiGone = prev.ui.trim().length > 0 && curr.ui.trim().length === 0;
+  return {
+    newErrors,
+    newExceptions,
+    newFailedRequests,
+    uiGone,
+    clean: newErrors.length === 0 && newExceptions.length === 0 && newFailedRequests.length === 0 && !uiGone
+  };
+}
+
+// src/ui/core/emit.ts
+import pc from "picocolors";
+var SECTIONS = ["ui", "console", "network", "errors", "state", "performance"];
+var COUNTED_SECTIONS = {
+  console: "console",
+  network: "network",
+  errors: "errors",
+  state: "state"
+};
+function emit(state) {
+  const sections = [];
+  for (const key of SECTIONS) {
+    if (state[key]) {
+      const countKey = COUNTED_SECTIONS[key];
+      const count = countKey ? state.counts?.[countKey] ?? 0 : 0;
+      const attr = count ? ` count="${count}"` : "";
+      sections.push(`<${key}${attr}>
+${state[key]}
+</${key}>`);
+    }
+  }
+  if (!sections.length) {
+    sections.push("<empty/>");
+  }
+  return `<aihand url="${state.url}">
+
+${sections.join("\n\n")}
+
+</aihand>
+
+detail: GET /__aihand/{section}/{index}?full`;
+}
+function emitSummary(raw) {
+  const consoleErrors = raw.console.filter((l) => l.level === "error");
+  const consoleWarns = raw.console.filter((l) => l.level === "warn");
+  const failedReqs = raw.network.filter((r) => r.status >= 400 || r.failed);
+  const hasIssues = consoleErrors.length > 0 || raw.errors.length > 0 || failedReqs.length > 0;
+  const lines = [];
+  if (raw.ui.trim()) {
+    lines.push(`ui: ${summarizeUI(raw.ui)}`);
+  }
+  if (raw.console.length) {
+    if (consoleErrors.length || consoleWarns.length) {
+      const parts = [];
+      for (const e of consoleErrors) parts.push(`  [error] ${truncate(e.text, 150)}`);
+      for (const w of consoleWarns) parts.push(`  [warn] ${truncate(w.text, 150)}`);
+      const rest = raw.console.length - consoleErrors.length - consoleWarns.length;
+      if (rest > 0)
+        parts.push(`  \u2026 ${rest} more`);
+      lines.push(`console (${raw.console.length}):`);
+      lines.push(...parts);
+    } else {
+      lines.push(`console: ${raw.console.length} logs`);
+    }
+  }
+  if (raw.network.length) {
+    if (failedReqs.length) {
+      lines.push(`network (${raw.network.length}):`);
+      for (const r of failedReqs) {
+        const body = r.responseBody ? ` "${truncate(r.responseBody, 80)}"` : "";
+        lines.push(`  ${r.method} ${compactUrl(r.url)} ${r.status}${body}`);
+      }
+      const ok = raw.network.length - failedReqs.length;
+      if (ok > 0)
+        lines.push(`  \u2026 ${ok} ok`);
+    } else {
+      lines.push(`network: ${raw.network.length} ok`);
+    }
+  }
+  if (raw.errors.length) {
+    lines.push(`errors (${raw.errors.length}):`);
+    for (const e of raw.errors) lines.push(`  ${truncate(e.message, 150)}`);
+  }
+  if (raw.performance) {
+    const all = raw.performance.buckets.find((b) => b.name === "__all__");
+    if (all) {
+      const droppedPct = all.frames.total > 0 ? all.frames.long / all.frames.total * 100 : 0;
+      if (droppedPct > 10) {
+        lines.push(compactPerformance(raw.performance));
+      }
+    }
+  }
+  const storeNames = Object.keys(raw.state);
+  if (storeNames.length) {
+    const parts = storeNames.map((n) => {
+      const v = raw.state[n];
+      const keys = typeof v === "object" && v !== null ? Object.keys(v).length : 0;
+      return keys > 0 ? `${n}(${keys})` : n;
+    });
+    lines.push(`state: ${parts.join(", ")}`);
+  }
+  if (!lines.length)
+    return "<aihand>empty</aihand>";
+  const status = hasIssues ? `${consoleErrors.length + raw.errors.length + failedReqs.length} issues` : "ok";
+  return `<aihand url="${raw.url}" status="${status}">
+${lines.join("\n")}
+</aihand>${hasIssues ? "\n\ndetail: GET /__aihand/{section}/{index}" : ""}`;
+}
+function summarizeUI(tree) {
+  const components = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of tree.split("\n")) {
+    const trimmed = line.trimStart();
+    if (!trimmed)
+      continue;
+    const indent = line.length - trimmed.length;
+    if (indent > 2)
+      continue;
+    const name = nameOf(trimmed);
+    if (!name)
+      continue;
+    const focused = trimmed.includes("[focused]");
+    const generating = trimmed.includes("[generating]");
+    const loading = trimmed.includes("[loading]");
+    const existing = counts.get(name) || 0;
+    if (existing > 0) {
+      counts.set(name, existing + 1);
+      continue;
+    }
+    counts.set(name, 1);
+    let label = name;
+    if (focused)
+      label += "[focused]";
+    if (generating)
+      label += "[generating]";
+    if (loading)
+      label += "[loading]";
+    components.push(label);
+  }
+  const result = components.map((c) => {
+    const name = c.split("[")[0];
+    const count = counts.get(name) || 1;
+    return count > 1 ? `${c}(\xD7${count})` : c;
+  });
+  return result.join(", ") || "empty";
+}
+function emitCheck(result) {
+  const lines = result.assertions.map(
+    (a) => a.pass ? `\u2713 ${a.name}` : `\u2717 ${a.name}${a.detail ? `: ${a.detail}` : ""}`
+  );
+  return `<aihand-check pass="${result.pass}">
+${lines.join("\n")}
+</aihand-check>`;
+}
+function emitDiff(diff) {
+  const issues = [];
+  for (const e of diff.newErrors) issues.push(pc.red(`  [error] ${e.text}`));
+  for (const e of diff.newExceptions) issues.push(pc.red(`  [exception] ${e.message}`));
+  for (const r of diff.newFailedRequests) issues.push(pc.yellow(`  [network] ${r.method} ${r.url} ${r.status}`));
+  if (diff.uiGone)
+    issues.push(pc.magenta("  [ui] component tree disappeared"));
+  if (!issues.length)
+    return "";
+  const count = issues.length;
+  return `${pc.bold("[aihand]")} ${pc.red(`\u2717 ${count} issue${count > 1 ? "s" : ""} after HMR`)}
+${issues.join("\n")}`;
+}
+
+// src/ui/server/help-text.ts
+function helpText(port) {
+  const base = `http://localhost:${port}/__aihand`;
+  return `
+# aihand \u2014 Runtime Browser Inspector
+
+IMPORTANT: Before debugging any UI issue, visual bug, or runtime error, ALWAYS fetch the live app state first. Do NOT guess \u2014 look at the actual browser state.
+
+## Read state \u2014 cheapest first
+
+\`\`\`bash
+curl ${base}/screen   # semantic layout tree (indent=nesting, \u5DE6/\u4E2D/\u53F3) + {view, modal, focus, knobs} \u2014 START HERE (returns token: tN)
+curl '${base}/screen?form=visual' # same screen as an ASCII art sketch instead of the layout tree
+curl '${base}/screen?form=knobs'  # only the control surface: clickable knobs + their store morphisms, grouped by column
+curl '${base}/screen?since=tN'  # only what moved since that token (view/modal/focus + new errors), not a full snapshot
+curl ${base}/ui                  # React component tree \u2014 deep-dive when /screen isn't enough
+curl '${base}/dom?scope=ChatInput' # semantic DOM scoped to a component \u2014 UI as text, src locations
+curl ${base}          # high-density summary (ok sections \u2192 1 line, issues \u2192 expanded)
+curl ${base}?full     # full dump: UI tree + console + network + errors + state
+curl ${base}/check    # pass/fail health check \u2014 use after code changes
+curl ${base}/console  # console logs (errors, warnings, info)
+curl ${base}/network  # fetch/XHR requests with status and timing
+curl ${base}/errors   # uncaught errors and unhandled rejections
+curl ${base}/state    # registered store snapshots (overview)
+curl ${base}/state/imStore           # drill into one store (domain)
+curl '${base}/state?path=imStore.conversations.0' # expand a nested value the overview collapsed to Array(N) (point)
+curl ${base}/tabs     # list live tabs (id, visible/background, title) for ?tab= addressing
+curl ${base}/timeline # interleaved action stream across all tabs (who clicked what, in order)
+curl '${base}/query?sel=[role=menuitem]' # this selector right now: count + each element's text/visible/attrs
+curl ${base}/profile  # performance profiler: which component/function is burning frames (+ source lines with AIPEEK_LINES=1)
+curl ${base}/profile/reset  # clear the profiler window, then reproduce the interaction
+curl ${base}/profile/diff  # closed loop: 1st call marks baseline, fix+reproduce, 2nd call \u2192 IMPROVED/REGRESSED verdict
+\`\`\`
+
+\`/profile\` is a verdict, not a flame graph \u2014 read it, fix, re-read, don't eyeball frames.
+Three tiers, escalate only as needed:
+
+\`\`\`bash
+# 1. Diagnose \u2014 one read names the component/function burning frames (self-time \xD7 render count)
+curl ${base}/profile
+
+# 2. Closed-loop A/B \u2014 proves a fix worked instead of guessing
+curl ${base}/profile/reset   # clear the window
+#   \u2026reproduce the slow interaction (scroll, stream, type)\u2026
+curl ${base}/profile         # 1st call = baseline snapshot
+#   \u2026edit code + reproduce the SAME interaction\u2026
+curl ${base}/profile/diff    # 2nd call \u2192 IMPROVED / REGRESSED / NO DATA verdict
+
+# 3. Line-level \u2014 break a hot component down to the exact source line
+AIPEEK_LINES=1 <your dev command>   # opt-in: line instrumentation taxes every render, off by default
+curl ${base}/profile
+\`\`\`
+
+Profiling is the ONE read that needs the tab FOREGROUND + FOCUSED \u2014 the OS throttles rAF
+for backgrounded/unfocused windows, so timing there is a lie. The profiler refuses to launder
+that lie: a throttled window reads \`Frames: none sampled\` and a window that didn't reproduce
+the workload reads \`NO DATA\`, never a fabricated \`0.0% dropped\` / \`IMPROVED\`. A real verdict
+requires: tab in front, \`/profile/reset\`, then repeat the exact interaction. (\`/screen\` and
+\`/dom\` work fine backgrounded \u2014 only profiling needs focus.)
+
+\`/query\` is the read-side twin of click/fill's \`sel=\` \u2014 assert on a specific element
+(how many match, its text, \`data-state\`, \`aria-*\`/\`data-*\`, value, disabled) without \`/eval\`.
+Secret fields (password inputs, API-key/token fields) show \`\u2039redacted N chars\u203A\` instead of
+their value across \`/dom\`, \`/query\` and \`/screen\` \u2014 length stays visible, the secret doesn't.
+
+\`/screen\` projects the whole UI to a few state variables \u2014 start there, not \`/ui\`. Append
+\`?full\` for untruncated output. Each read prints a \`token: tN\` line; pass it back as
+\`/screen?since=tN\` to get only the transition since that read (view/modal/focus + new
+errors/failed requests), \`(no state change)\` if nothing moved \u2014 the cheap "what changed
+after I acted" read, without re-paying for the unchanged 99%.
+
+To inspect or edit a component, work top-down \u2014 the full DOM is huge, a scoped view is
+accurate: \`/screen\` or \`/ui\` to find the component, then \`/dom?scope=<Name>\` (matches the
+source path) or \`/dom?sel=<css>\` for just that subtree. Each line carries its source
+location (\`@File.tsx:line\`), so the DOM view tells you exactly where to edit.
+
+## UI \u2192 code reason (reverse morphism)
+
+\`\`\`bash
+curl '${base}/source?path=src/features/Sidebar/index.tsx:78'  # which symbol owns this line + its callers/callees
+curl -G ${base}/source --data-urlencode 'path=<data-insp-path>'  # feed /dom's data-insp-path raw (rel:line:col:Name)
+\`\`\`
+
+\`/dom\` tells you *where* a UI element lives (\`@File.tsx:line\`); \`/source\` tells you *what code
+backs it* \u2014 the enclosing symbol, who calls it, what it calls. Paste a \`data-insp-path\`
+(\`rel:line:col:Name\`) straight from \`/dom\`. This is the static twin of \`/open\` (which sends the
+same coordinate to your editor): point at a rendered element \u2192 get its code reason, without grepping.
+
+## Drive the page (acts on the currently-open tab \u2014 no separate browser)
+
+Pass \`text=\`/\`sel=\`/\`value=\` via \`-G --data-urlencode\` \u2014 **always**, not just for CJK. A raw
+\`?text=\u7FA4\u804A\` is an illegal HTTP request-target, rejected with an empty 400 *before aihand runs*
+(a wasted round-trip); \`--data-urlencode\` escapes it for you, so the same form works for \`New\`
+and \`\u7FA4\u804A\` alike \u2014 write it right the first time.
+
+\`\`\`bash
+curl -G ${base}/click  --data-urlencode 'text=New'              # click by visible text (or 'sel=<css>')
+curl -G ${base}/dblclick --data-urlencode 'text=todo'          # double-click (inline edit / rename / select); fires dblclick handlers click can't
+curl -G ${base}/hover  --data-urlencode 'text=More'             # hover only (reveal a menu/tooltip; no click)
+curl -G ${base}/fill   --data-urlencode 'sel=textarea' --data-urlencode 'value=hi'  # set input/textarea; <select> matches by option text
+curl -G ${base}/press  --data-urlencode 'key=Enter'            # key on focused element (e.g. Control+a)
+curl -G ${base}/wait   --data-urlencode 'text=Done' -d 'timeout=8000'  # poll until text/sel appears (gone=1 until it disappears; enabled=1 until not [disabled])
+curl '${base}/screenshot?out=shot.png'                          # DOM\u2192PNG into .aidev/ (html-to-image; lossy)
+\`\`\`
+
+ASCII-only values may use the bare \`?text=New\` form, but \`-G --data-urlencode\` is never wrong \u2014
+prefer it so a value that turns out to contain CJK/space/\`&\` doesn't silently 400.
+
+\`click\`/\`fill\`/\`press\` settle the DOM and append \`--- changed ---\`: only the state-machine
+transition this action caused (\`view: a \u2192 b\`, \`modal: opened X\`, \`focus: \u2026\`) plus any new
+errors/failed requests \u2014 not a fresh snapshot. \`(no state change)\` means nothing moved. Read
+the delta, then drill into /ui or /dom for detail if you need it. On a miss, the response lists
+the reachable clickable elements so you can re-target.
+
+Each \`click\`/\`fill\`/\`press\` response also carries a \`--- recent actions ---\` timeline:
+the semantic page actions (yours and the user's) in order, \`T\`=trusted human / \`S\`=synthetic
+aihand, each with its resulting UI change (\`\u2192 \u5F39\u7A97\u6253\u5F00\u300C\u2026\u300D\`/\`\u2192 \u5F39\u7A97\u5173\u95ED\`). Your own action is
+bracketed by \`\u4F60\u5F53\u524D\u7684\u884C\u4E3A\` dividers. So if the user closed a dialog you just opened, you see
+their \`T key:Escape \u2192 \u5F39\u7A97\u5173\u95ED\` right after your \`S\` action \u2014 no need to query for it.
+
+**Beyond click/fill/press** \u2014 four more interactions for what those can't reach:
+
+\`\`\`bash
+curl '${base}/scrollIntoView?text=Row 99'              # scroll a target into view (off-screen list rows)
+curl '${base}/drag?sel=.item&to=.slot'                 # synthetic pointer drag, source \u2192 destination
+curl '${base}/drop?sel=.dropzone&files=a.png,b.pdf'    # fire a file-drop (DataTransfer) on a target
+curl '${base}/clipboard?mode=write&value=hi'           # seed the clipboard (mode=read reports it back)
+\`\`\`
+
+\`drag\` fires a real pointer sequence (down \u2192 stepped moves past dnd-kit's activation
+distance \u2192 up); if a dnd-kit reorder doesn't take, retry the same gesture via \`realclick\`
+(trusted events). \`drop\` delivers the drop event with the named files (synthetic Files have
+no byte content \u2014 fine for triggering handlers, not for real uploads). \`clipboard\` needs the
+tab focused (browser security) and says so plainly when it isn't, rather than hanging.
+
+A control tagged \`{needs-trusted?}\` in \`/screen\` or \`/dom\` opens a popup (\`aria-haspopup\`)
+that a synthetic click may not trigger \u2014 reach for \`realclick\` on it from the start instead
+of discovering it via a dead click. (Right-click-only menus carry no DOM marker, so they
+still surface only on a miss \u2014 use \`realclick\` with \`button=right\` there.)
+
+**Green channel \u2014 replay a knob's morphism, no DOM.** \`/screen?form=knobs\` lists every
+control with its store morphism (\`\u300C\u7FA4\u804A\u300D\u2192 appUIStore.{ mode=im }\`). \`/action?knob=<label>\`
+replays that morphism by writing the store directly \u2014 bypassing selector resolution, disabled
+gating, and the silent-false-success a covered \`/click\` can return. It's smoother than
+\`/click\`+\`/fill\` for any control whose effect is a store write:
+
+\`\`\`bash
+curl -G ${base}/action --data-urlencode 'knob=\u7FA4\u804A'            # literal:  appUIStore.mode='im'
+curl -G ${base}/action --data-urlencode 'knob=\u6DF1\u5EA6\u7814\u7A76'        # toggle:   flips the bool
+curl -G ${base}/action --data-urlencode 'knob=\u6700\u5927Token' --data-urlencode 'value=8'   # param: needs ?value=
+curl ${base}/action?knob=@k3                                   # @kN: addressable ref from /screen, no CJK escaping
+\`\`\`
+
+Every \`/screen\` projection tags each knob with a stable \`@kN\` ref (the number in \`?form=knobs\`,
+shared across the ASCII art / tree / legend). \`/action?knob=@k3\` resolves it back to the label \u2014
+saving the CJK \`--data-urlencode\` round-trip and any \`&file=\` disambiguation. A stale/unknown
+\`@kN\` is refused (422 listing the current numbers) \u2014 re-read \`/screen\` for fresh ones; it never
+silently hits the wrong knob.
+
+Returns the same \`--- changed ---\` trajectory a \`/click\` does (waitForStable + diffScreen),
+not a full state dump. A knob whose value depends on runtime context (\`e.target.value\`, a
+mapped array, a method with args) is **refused** (422 + reason) \u2014 fall back to \`/click\`/\`/fill\`
+there; it never fake-replays. A label two components share returns 422 + candidates; add
+\`&file=<path-fragment>\` to disambiguate.
+
+**Multiple tabs.** Every read/drive command takes \`?tab=<id>\` to address one specific tab \u2014
+including a **background** one (you can drive the Chat tab while the user is looking at a
+different tab). Run \`${base}/tabs\` to see the live ids. With one tab open, omit \`?tab=\` and
+it just works. With several tabs open and no \`?tab=\`, the command returns \`409\` + the tab
+list (rather than randomly hitting one) \u2014 pick an id from it and retry with \`?tab=\`.
+
+**Multiple servers (federation).** When several dev servers run at once \u2014 a micro-frontend,
+separate front/back servers, or a teammate's machine \u2014 every command also takes
+\`?host=<host:port>\` to reach a *sibling* aihand. The plugin you curl reverse-proxies the
+request to that peer (server-side, no browser): \`${base}/screen?host=localhost:5174\` reads
+the app on :5174; combine with \`?tab=\` to point at one tab over there
+(\`?host=192.168.1.9:5173&tab=t3\`). Omit \`?host=\` and it's the local server as always. There's
+no registry \u2014 you name the peer, so list its tabs with \`/tabs?host=<host:port>\` first.
+
+**Cross-tab timeline.** \`${base}/timeline\` interleaves the semantic actions of *every* tab
+in time order \u2014 each line \`<tab> [T|S] <action> \u2192 <ui change>\` (\`T\`=trusted human,
+\`S\`=synthetic aihand). The per-action \`--- recent actions ---\` tail only shows the acting
+tab; \`/timeline\` is the group view, so an A/B comparison across two tabs (drive A, watch B
+react) is one read. \`?tab=<id>\` filters to one tab's history.
+
+**Chain \u2014 a whole interaction in one round-trip.** POST a JSON array; runs in sequence,
+each step settles before the next, stops on first failure. A failed step carries the same
+\`clickable:\` fallback list a single-shot \`/click\` gives, and a trailing
+\`[n..m] skipped (\u2026 not run)\` line names every step the fail-fast stop left unrun \u2014 the page
+is parked in a half-done state, not rolled back (page actions aren't transactional):
+
+\`\`\`bash
+curl -X POST ${base}/chain -d '[
+  {"type":"knob","knob":"\u7FA4\u804A"},
+  {"type":"assert","screen":"appUIStore.mode","equals":"im"},
+  {"type":"click","sel":"button[title=\\"\u77E5\u8BC6\u5E93\\"]"},
+  {"type":"wait","text":"Done"},
+  {"type":"fill","sel":"textarea","value":"hi"},
+  {"type":"assert","screen":"<a domain key from /screen>","equals":"false"},
+  {"type":"press","key":"Enter"}
+]'
+\`\`\`
+
+The \`screen\` key in an \`assert\` must be a real field from \`/screen\`'s \`domain:\` block (e.g.
+\`streaming\`, \`appUIStore.mode\`) \u2014 copy it verbatim, the names are app-specific. A wrong key
+fails with \`no domain key "X" \u2014 available: \u2026\` listing every real one.
+
+A \`knob\` step (\`{type:"knob",knob:"<panel label>"[,value,file]}\`) replays a panel morphism
+via the green channel \u2014 the store-direct optimal path \`/action?knob=\` takes, now inside a
+batch. Prefer it over \`click\` when a knob exists: no selector resolution, no overlay gating.
+
+\`assert\` is the chain's mid-step judge: \`{type,screen,equals}\` checks a domain variable
+(from the app's \`window.__AIPEEK_SCREEN__\`), or \`{type,sel,equals}\` an element's text. On
+mismatch the chain stops and reports \`asserted X=="Y", actual "Z"\` \u2014 a test, not a guess.
+Domain variables also show up in \`/screen\`'s \`domain:\` block and in every \`--- changed ---\`
+diff (e.g. \`\u6D41\u5F0F\u4E2D: false \u2192 true\`) \u2014 the app's own state machine, which a DOM-only inspector
+can't see. The app opts in by setting \`window.__AIPEEK_SCREEN__ = () => ({...})\`.
+
+**Escape hatch.** \`curl '${base}/eval?code=...'\` (or POST the code as the body) runs arbitrary
+JS in the page and returns the result \u2014 for what the typed endpoints can't do (install listeners,
+read closures, probe event flow). For count/text/state/attr assertions reach for \`/query\` first.
+When the code is a hand-rolled \`/state\` (or the selector is illegal), the response tail carries a \`hint:\` line pointing at the typed twin.
+
+aihand auto-detects errors after HMR and prints them to the terminal \u2014 watch for \`[aihand]\` messages.
+
+**Iterating on aihand itself.** Editing this server's own code (\`plugin.ts\` and anything in the Vite
+config dependency graph) makes Vite AUTO-restart the dev server in-process \u2014 terminal prints
+\`\u2026changed, restarting server\u2026\` then \`server restarted.\`, PID unchanged. You do NOT restart it by
+hand and you do NOT ask the user to; just edit and wait ~2-4s, then poll \`${base}/tabs\` for the page
+to re-register (it self-heals via an unthrottled heartbeat). The client probe (\`client.ts\`) instead
+hot-swaps in place keeping app state. Server stdout goes to the user's terminal (you can't read it) \u2014
+to make server-side state curl-observable, add a temporary debug route, let Vite auto-restart, then
+remove it.
+`;
+}
+
+// src/ui/server/plugin.ts
+function readBody(req) {
+  return new Promise((resolve5) => {
+    let s = "";
+    req.on("data", (c) => s += c);
+    req.on("end", () => resolve5(s));
+  });
+}
+function send(res, status, body) {
+  res.writeHead(status, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end(body);
+}
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var clientDir = [
+  resolve3(__dirname2, "../client"),
+  resolve3(__dirname2, "../src/ui/client")
+].find(existsSync3) ?? resolve3(__dirname2, "../src/ui/client");
+var clientPath = resolve3(clientDir, "client.ts");
+var patchPath = resolve3(clientDir, "client-patch.ts");
+function compilePatch() {
+  const source = readFileSync(patchPath, "utf-8");
+  const result = transformSync(source, {
+    loader: "ts",
+    target: "es2020",
+    format: "iife",
+    minify: false
+  });
+  return result.code;
+}
+function sourceInjectPlugin() {
+  let babel = null;
+  let plugin = null;
+  let root = "";
+  return {
+    name: "aihand:source-loc",
+    apply: "serve",
+    enforce: "pre",
+    async configResolved(config) {
+      root = config.root;
+    },
+    async transform(code, id) {
+      const file = id.split("?")[0];
+      if (!file.endsWith(".tsx") && !file.endsWith(".jsx"))
+        return;
+      if (file.includes("node_modules") || file.includes("packages/aidev/"))
+        return;
+      if (!babel) {
+        babel = await import("@babel/core");
+        plugin = sourceLocPlugin(babel.types);
+      }
+      const result = await babel.transformAsync(code, {
+        filename: file,
+        root,
+        plugins: [plugin],
+        parserOpts: { plugins: ["jsx", "typescript"] },
+        sourceMaps: true,
+        configFile: false,
+        babelrc: false
+      });
+      if (!result?.code)
+        return;
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+function aihandPlugin() {
+  return [aihandMainPlugin(), sourceInjectPlugin()];
+}
+function aihandMainPlugin() {
+  let pendingResolve = null;
+  let server;
+  let lastRaw = null;
+  let perfBaseline = null;
+  let pushTimer;
+  const pendingActions = /* @__PURE__ */ new Map();
+  const actionProgressAt = /* @__PURE__ */ new Map();
+  let actionId = 0;
+  let graphCache = null;
+  let graphBuilding = null;
+  async function cachedGraph() {
+    if (graphCache)
+      return graphCache;
+    if (!graphBuilding) {
+      graphBuilding = (async () => {
+        const { loadConfig: loadConfig2, isTsFile } = await import("./config-PJPYKDLQ.js");
+        const { scan: scan2 } = await import("./scan-VF54GAAX.js");
+        const { buildCallGraph } = await import("./graph-IH56SCPK.js");
+        const config = await loadConfig2(server.config.root);
+        const g = await buildCallGraph(scan2(config).filter(isTsFile));
+        graphCache = g;
+        graphBuilding = null;
+        return g;
+      })();
+    }
+    return graphBuilding;
+  }
+  const tabs = /* @__PURE__ */ new Map();
+  function seen(data) {
+    if (!data.tab)
+      return;
+    const prev = tabs.get(data.tab);
+    tabs.set(data.tab, {
+      id: data.tab,
+      url: data.url ?? prev?.url ?? "",
+      title: data.title ?? prev?.title ?? "",
+      visible: data.visible ?? prev?.visible ?? false,
+      lastSeen: Date.now()
+    });
+  }
+  const liveTabs = () => [...tabs.values()].filter((t) => isLive(t, Date.now()));
+  const diagnose2 = (tab) => diagnose(tab, [...tabs.values()], Date.now(), server.ws.clients.size, server.config.server.port || 5173);
+  const actionLog = [];
+  const BOOT_ID = Date.now().toString(36);
+  const droppedByTab = /* @__PURE__ */ new Map();
+  const mergeActions = (tab, actions, dropped) => {
+    if (!tab)
+      return;
+    if (typeof dropped === "number")
+      droppedByTab.set(tab, dropped);
+    if (!actions?.length)
+      return;
+    for (const entry of actions) {
+      if (!actionLog.some((e) => e.tab === tab && e.ts === entry.ts))
+        appendAction(actionLog, tab, entry, 200);
+    }
+  };
+  const cdpQueue = [];
+  let cdpWaiter = null;
+  const cdpResults = /* @__PURE__ */ new Map();
+  let cdpId = 0;
+  function runCdpClick(x, y, button) {
+    const id = ++cdpId;
+    const cmd = { id, x, y, button };
+    return new Promise((resolve5, reject) => {
+      cdpResults.set(id, resolve5);
+      if (cdpWaiter) {
+        cdpWaiter(cmd);
+        cdpWaiter = null;
+      } else {
+        cdpQueue.push(cmd);
+      }
+      setTimeout(() => {
+        if (cdpResults.delete(id))
+          reject(new Error("cdp timeout: no extension result within 10s (is the aihand extension loaded and the debugger attached?)"));
+      }, 1e4);
+    });
+  }
+  let pendingDom = null;
+  let pendingStatePath = null;
+  let pendingScreen = null;
+  const pendingEvals = /* @__PURE__ */ new Map();
+  let evalId = 0;
+  const pendingSemantic = /* @__PURE__ */ new Map();
+  let semanticId = 0;
+  const pendingKnob = /* @__PURE__ */ new Map();
+  let knobId = 0;
+  const knobProgressAt = /* @__PURE__ */ new Map();
+  const screenStash = /* @__PURE__ */ new Map();
+  let screenToken = 0;
+  function stashScreen(r) {
+    const token = `t${++screenToken}`;
+    screenStash.set(token, { snap: r.snap, console: r.console, network: r.network, errors: r.errors });
+    if (screenStash.size > 32)
+      screenStash.delete(screenStash.keys().next().value);
+    return token;
+  }
+  const VISIBLE_MS2 = 400;
+  function twoPhase(event, payload, arm, fullMs = 3e3, tab, lastProgress) {
+    return new Promise((resolve5, reject) => {
+      let settled = false;
+      const clear = arm((v) => {
+        settled = true;
+        resolve5(v);
+      });
+      if (tab) {
+        const RETRY_MS = 500;
+        const ABSENT_CEILING_MS = 1e4;
+        const startedAt = Date.now();
+        const deliver = () => server.hot.send(event, { ...payload, tab });
+        deliver();
+        const iv = setInterval(() => {
+          if (settled) {
+            clearInterval(iv);
+            return;
+          }
+          const t = tabs.get(tab);
+          const live = !!t && isLive(t, Date.now());
+          const progressAt = lastProgress?.();
+          const sinceLife = Date.now() - Math.max(startedAt, progressAt ?? 0);
+          const elapsed = Date.now() - startedAt;
+          if (live) {
+            if (sinceLife > fullMs) {
+              clearInterval(iv);
+              clear();
+              reject(new Error(diagnose2(tab)));
+            }
+          } else if (elapsed > ABSENT_CEILING_MS) {
+            clearInterval(iv);
+            clear();
+            reject(new Error(diagnose2(tab)));
+          } else {
+            deliver();
+          }
+        }, RETRY_MS);
+        return;
+      }
+      server.hot.send(event, { ...payload, requireVisible: true });
+      setTimeout(() => {
+        if (settled)
+          return;
+        server.hot.send(event, { ...payload, requireVisible: false });
+        setTimeout(() => {
+          if (settled)
+            return;
+          clear();
+          reject(new Error(diagnose2(tab)));
+        }, fullMs);
+      }, VISIBLE_MS2);
+    });
+  }
+  function collectFromClient(tab) {
+    return twoPhase("aihand:collect", {}, (resolve5) => {
+      pendingResolve = resolve5;
+      return () => {
+        pendingResolve = null;
+      };
+    }, 3e3, tab);
+  }
+  function collectDomFromClient(scope, sel, tab) {
+    return twoPhase("aihand:collect-dom", { scope, sel }, (resolve5) => {
+      pendingDom = resolve5;
+      return () => {
+        pendingDom = null;
+      };
+    }, 3e3, tab);
+  }
+  function collectStatePathFromClient(path2, tab) {
+    return twoPhase("aihand:collect-state-path", { path: path2 }, (resolve5) => {
+      pendingStatePath = resolve5;
+      return () => {
+        pendingStatePath = null;
+      };
+    }, 3e3, tab);
+  }
+  function collectScreenFromClient(tab, form) {
+    return twoPhase("aihand:collect-screen", { form }, (resolve5) => {
+      pendingScreen = resolve5;
+      return () => {
+        pendingScreen = null;
+      };
+    }, 3e3, tab);
+  }
+  function sendAction(type, args, tab) {
+    const id = ++actionId;
+    const fullMs = Math.max(args.timeout ?? 0, 3e3) + 2e3;
+    return twoPhase("aihand:action", { id, type, args }, (resolve5) => {
+      pendingActions.set(id, resolve5);
+      return () => {
+        pendingActions.delete(id);
+        actionProgressAt.delete(id);
+      };
+    }, fullMs, tab, () => actionProgressAt.get(id));
+  }
+  async function runAction(type, args, tab) {
+    const result = await sendAction(type, args, tab);
+    lastRaw = null;
+    if (type === "realclick" && result.ok && !result.fired) {
+      const cdp = await runCdpClick(result.x, result.y, args.button ?? "left");
+      if (!cdp.ok)
+        return { ok: false, error: `cdp click failed: ${cdp.error ?? "unknown"}` };
+      result.detail = `${result.detail} \u2192 clicked via extension`;
+      result.screen = (await collectScreenFromClient(tab)).screen;
+    }
+    return result;
+  }
+  function evalInClient(code, tab) {
+    const id = ++evalId;
+    return twoPhase("aihand:eval", { id, code }, (resolve5) => {
+      pendingEvals.set(id, resolve5);
+      return () => {
+        pendingEvals.delete(id);
+      };
+    }, 8e3, tab);
+  }
+  function semanticInClient(name, args, tab) {
+    const id = ++semanticId;
+    return twoPhase("aihand:semantic-action", { id, name, args }, (resolve5) => {
+      pendingSemantic.set(id, resolve5);
+      return () => {
+        pendingSemantic.delete(id);
+      };
+    }, 15e3, tab);
+  }
+  function knobInClient(knob, file, value, tab) {
+    const id = ++knobId;
+    return twoPhase("aihand:knob-action", { id, knob, file, value }, (resolve5) => {
+      pendingKnob.set(id, resolve5);
+      return () => {
+        pendingKnob.delete(id);
+        knobProgressAt.delete(id);
+      };
+    }, 15e3, tab, () => knobProgressAt.get(id));
+  }
+  return {
+    name: "aihand",
+    apply: "serve",
+    transformIndexHtml() {
+      const patchCode = compilePatch();
+      return [
+        // Synchronous inline script — patches console/fetch/XHR/errors
+        // BEFORE any ES modules execute
+        {
+          tag: "script",
+          children: patchCode,
+          injectTo: "head-prepend"
+        },
+        // Module script — collectors + HMR channel (can be deferred)
+        {
+          tag: "script",
+          attrs: { type: "module" },
+          children: `import '/@fs/${clientPath}'`,
+          injectTo: "body"
+        }
+      ];
+    },
+    configureServer(_server) {
+      server = _server;
+      const bridge = viteBridge(server, { tabs, diagnose: diagnose2 });
+      const isTs = (f) => f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx");
+      const invalidateGraph = (f) => {
+        if (isTs(f)) graphCache = null;
+      };
+      server.watcher.on("change", invalidateGraph);
+      server.watcher.on("add", invalidateGraph);
+      server.watcher.on("unlink", invalidateGraph);
+      server.hot.on("aihand:state", (data) => {
+        seen(data);
+        mergeActions(data.tab, data.actions, data.actionsDropped);
+        if (pendingResolve) {
+          pendingResolve(data);
+          pendingResolve = null;
+        }
+      });
+      server.hot.on("aihand:hello", (data) => {
+        seen(data);
+        if (data.tab)
+          server.hot.send("aihand:hello-ack", { tab: data.tab });
+      });
+      server.hot.on("aihand:result", (data) => {
+        seen(data);
+        const resolve5 = pendingActions.get(data.id);
+        if (resolve5) {
+          pendingActions.delete(data.id);
+          resolve5(data);
+        }
+      });
+      server.hot.on("aihand:action-progress", (data) => {
+        seen(data);
+        if (data.kind === "knob") {
+          if (pendingKnob.has(data.id))
+            knobProgressAt.set(data.id, Date.now());
+        } else if (pendingActions.has(data.id)) {
+          actionProgressAt.set(data.id, Date.now());
+        }
+      });
+      server.hot.on("aihand:eval-result", (data) => {
+        seen(data);
+        const resolve5 = pendingEvals.get(data.id);
+        if (resolve5) {
+          pendingEvals.delete(data.id);
+          resolve5(data);
+        }
+      });
+      server.hot.on("aihand:semantic-result", (data) => {
+        seen(data);
+        const resolve5 = pendingSemantic.get(data.id);
+        if (resolve5) {
+          pendingSemantic.delete(data.id);
+          resolve5(data);
+        }
+      });
+      server.hot.on("aihand:knob-result", (data) => {
+        seen(data);
+        const resolve5 = pendingKnob.get(data.id);
+        if (resolve5) {
+          pendingKnob.delete(data.id);
+          resolve5(data);
+        }
+      });
+      server.hot.on("aihand:dom", (data) => {
+        seen(data);
+        if (pendingDom) {
+          pendingDom(data.dom);
+          pendingDom = null;
+        }
+      });
+      server.hot.on("aihand:state-path", (data) => {
+        seen(data);
+        if (pendingStatePath) {
+          pendingStatePath(data);
+          pendingStatePath = null;
+        }
+      });
+      server.hot.on("aihand:screen", (data) => {
+        seen(data);
+        if (pendingScreen) {
+          pendingScreen(data);
+          pendingScreen = null;
+        }
+      });
+      server.hot.on("vite:afterUpdate", () => {
+        clearTimeout(pushTimer);
+        pushTimer = setTimeout(async () => {
+          try {
+            const raw = await collectFromClient();
+            const diff = diffState(lastRaw, raw);
+            lastRaw = raw;
+            if (!diff.clean) {
+              const msg = emitDiff(diff);
+              if (msg)
+                server.config.logger.warn(msg);
+            }
+          } catch {
+          }
+        }, 500);
+      });
+      server.middlewares.use("/__aihand", async (req, res) => {
+        const url = new URL(req.url || "/", "http://localhost");
+        const parts = url.pathname.split("/").filter(Boolean);
+        const full = url.searchParams.has("full");
+        const explicitTab = url.searchParams.get("tab") || void 0;
+        const live = liveTabs();
+        const tab = explicitTab ?? (live.length === 1 ? live[0].id : void 0);
+        const host = url.searchParams.get("host") || void 0;
+        const selfPort = server.config.server.port || 5173;
+        const selfHosts = /* @__PURE__ */ new Set([`localhost:${selfPort}`, `127.0.0.1:${selfPort}`, `:${selfPort}`, `${selfPort}`]);
+        if (host && !selfHosts.has(host)) {
+          const fwd = new URL(url);
+          fwd.searchParams.delete("host");
+          const target = `http://${host}/__aihand/${parts.join("/")}${fwd.search}`;
+          try {
+            const body = req.method === "POST" ? await readBody(req) : void 0;
+            const r = await fetch(target, { method: req.method, body });
+            send(res, r.status, await r.text());
+          } catch (e) {
+            const code = e.cause?.code;
+            const why = code === "ECONNREFUSED" ? `nothing is listening on ${host} \u2014 its dev server isn't running (start it), or the port is wrong.` : code === "ENOTFOUND" ? `host '${host}' doesn't resolve \u2014 check the hostname.` : code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT" ? `connection to ${host} timed out \u2014 it's unreachable (firewall, or wrong host).` : `${e.message} (code ${code ?? "unknown"}).`;
+            send(res, 502, `cannot reach aihand peer at ${host}: ${why}`);
+          }
+          return;
+        }
+        if (parts[0] === "ping") {
+          send(res, 200, BOOT_ID);
+          return;
+        }
+        if (parts[0] === "help") {
+          send(res, 200, helpText(selfPort).trim());
+          return;
+        }
+        if (parts[0] === "open") {
+          const file = url.searchParams.get("file") || "";
+          const line = Number(url.searchParams.get("line")) || 1;
+          const column = Number(url.searchParams.get("column")) || 1;
+          const root = server.config.root;
+          const abs = isAbsolute(file) ? file : resolve3(root, file);
+          const rel = relative2(root, abs);
+          if (!file || rel.startsWith("..") || isAbsolute(rel)) {
+            send(res, 400, `refusing to open '${file}' \u2014 not under project root`);
+            return;
+          }
+          try {
+            const { launchIDE } = await import("launch-ide");
+            launchIDE({ file: abs, line, column });
+            send(res, 200, `opening ${rel}:${line}:${column}`);
+          } catch (err) {
+            send(res, 500, `launch-ide failed: ${err instanceof Error ? err.message : "unknown"}`);
+          }
+          return;
+        }
+        if (parts[0] === "source") {
+          const path2 = url.searchParams.get("path") || "";
+          if (!path2) {
+            send(res, 400, "usage: /__aihand/source?path=<file:line>  (path \u53EF\u76F4\u63A5\u662F /dom \u7684 data-insp-path)");
+            return;
+          }
+          const { parseInspPath, locate, renderLocate } = await import("./locate-NKSUGL3A.js");
+          const { file, line } = parseInspPath(path2);
+          if (!file || !Number.isFinite(line)) {
+            send(res, 400, `bad path '${path2}' \u2014 expected file:line (or data-insp-path)`);
+            return;
+          }
+          try {
+            const graph = await cachedGraph();
+            const result = locate(graph, file, line);
+            if (!result) {
+              send(res, 404, `no symbol covers ${file}:${line} \u2014 file not in scan scope, or line outside any symbol`);
+              return;
+            }
+            send(res, 200, renderLocate(result, url.searchParams.has("json")));
+          } catch (err) {
+            send(res, 500, `source lookup failed: ${err instanceof Error ? err.message : "unknown"}`);
+          }
+          return;
+        }
+        const ambiguous = () => !tab && !["tabs", "timeline", "cdp"].includes(parts[0]) && liveTabs().length > 1;
+        const refuse = () => send(res, 409, `multiple live tabs \u2014 add ?tab=<id>:
+
+${formatTabs(liveTabs(), Date.now())}`);
+        try {
+          if (parts[0] === "tabs") {
+            const roster = formatTabs(liveTabs(), Date.now());
+            send(res, 200, roster === "(no live tabs)" ? `(${diagnose2()})` : roster);
+            return;
+          }
+          if (parts[0] === "timeline") {
+            const targets = tab ? [tab] : liveTabs().map((t) => t.id);
+            for (const id of targets)
+              await collectFromClient(id).catch(() => {
+              });
+            const entries = tab ? actionLog.filter((e) => e.tab === tab) : actionLog;
+            const dropped = targets.reduce((n, id) => n + (droppedByTab.get(id) ?? 0), 0);
+            send(res, 200, formatActions(entries, void 0, dropped));
+            return;
+          }
+          if (ambiguous()) {
+            refuse();
+            return;
+          }
+          if (parts[0] === "eval") {
+            let code = url.searchParams.get("code") || "";
+            if (!code && req.method === "POST")
+              code = await readBody(req);
+            if (!code) {
+              send(res, 400, "eval needs ?code= or a POST body");
+              return;
+            }
+            const r = await evalInClient(code, tab);
+            const body = r.ok ? r.value ?? "undefined" : `error: ${r.error}`;
+            send(res, r.ok ? 200 : 422, r.hint ? `${body}
+
+hint: ${r.hint}` : body);
+            return;
+          }
+          if (parts[0] === "action") {
+            const knob = url.searchParams.get("knob") || "";
+            if (knob) {
+              lastRaw = null;
+              const r2 = await knobInClient(
+                knob,
+                url.searchParams.get("file") || void 0,
+                url.searchParams.get("value") ?? void 0,
+                tab
+              );
+              send(res, r2.ok ? 200 : 422, r2.ok ? r2.value ?? "undefined" : `error: ${r2.error}`);
+              return;
+            }
+            const name = url.searchParams.get("name") || "";
+            if (!name) {
+              const hint = misroutedAction([...url.searchParams.keys()]);
+              const base = "action needs ?knob= (a panel label) or ?name= (a __AIHAND_ACTIONS__ key)";
+              send(res, 400, hint ? `${base}
+
+hint: ${hint}` : base);
+              return;
+            }
+            let args = [];
+            const rawArgs = url.searchParams.get("args") || (req.method === "POST" ? await readBody(req) : "");
+            if (rawArgs) {
+              try {
+                const parsed = JSON.parse(rawArgs);
+                args = Array.isArray(parsed) ? parsed : [parsed];
+              } catch {
+                send(res, 400, `action args= must be a JSON array, got: ${rawArgs.slice(0, 80)}`);
+                return;
+              }
+            }
+            lastRaw = null;
+            const r = await semanticInClient(name, args, tab);
+            send(res, r.ok ? 200 : 422, r.ok ? r.value ?? "undefined" : `error: ${r.error}`);
+            return;
+          }
+          if (parts[0] === "dom") {
+            const dom = await collectDomFromClient(
+              url.searchParams.get("scope") || void 0,
+              url.searchParams.get("sel") || void 0,
+              tab
+            );
+            send(res, 200, dom || "(empty)");
+            return;
+          }
+          if (parts[0] === "state" && url.searchParams.has("path")) {
+            const path2 = url.searchParams.get("path") || "";
+            const r = await collectStatePathFromClient(path2, tab);
+            if (!r.ok) {
+              send(res, 404, `path not found: ${r.error}`);
+              return;
+            }
+            let body;
+            try {
+              body = JSON.stringify(r.value, null, 2) ?? String(r.value);
+            } catch {
+              body = String(r.value);
+            }
+            send(res, 200, body);
+            return;
+          }
+          if (parts[0] === "screen") {
+            const { reply, result } = await dispatchScreen(bridge, { tab, form: url.searchParams.get("form") || void 0 });
+            const since = url.searchParams.get("since");
+            const token = stashScreen(reply);
+            if (since) {
+              const prev = screenStash.get(since);
+              if (!prev) {
+                send(res, 422, `unknown since token "${since}" (expired or never issued) \u2014 read /screen first for a fresh token`);
+                return;
+              }
+              const d = diffState(
+                { ui: "", console: prev.console, network: prev.network, errors: prev.errors, state: {}, url: "", timestamp: 0 },
+                { ui: "", console: reply.console, network: reply.network, errors: reply.errors, state: {}, url: "", timestamp: 0 }
+              );
+              const changed = diffScreen(prev.snap, reply.snap, d.newErrors, d.newExceptions, d.newFailedRequests);
+              send(res, 200, `token: ${token}
+${changed.length ? changed.join("\n") : "(no state change)"}`);
+              return;
+            }
+            send(res, 200, result.body === "(empty)" ? "(empty)" : `token: ${token}
+${result.body}`);
+            return;
+          }
+          if (parts[0] === "cdp" && parts[1] === "poll") {
+            const queued = cdpQueue.shift();
+            if (queued) {
+              send(res, 200, JSON.stringify(queued));
+              return;
+            }
+            const cmd = await new Promise((resolve5) => {
+              cdpWaiter = resolve5;
+              setTimeout(() => {
+                if (cdpWaiter === resolve5) {
+                  cdpWaiter = null;
+                  resolve5(null);
+                }
+              }, 25e3);
+            });
+            if (cmd)
+              send(res, 200, JSON.stringify(cmd));
+            else
+              send(res, 204, "");
+            return;
+          }
+          if (parts[0] === "cdp" && parts[1] === "result") {
+            const body = await readBody(req);
+            let data;
+            try {
+              data = JSON.parse(body);
+            } catch {
+              send(res, 400, "cdp/result needs a JSON body {id, ok, error?}");
+              return;
+            }
+            const resolveCdp = cdpResults.get(data.id);
+            if (resolveCdp) {
+              cdpResults.delete(data.id);
+              resolveCdp({ ok: data.ok, error: data.error });
+            }
+            send(res, 200, "ok");
+            return;
+          }
+          if (parts[0] === "chain") {
+            const body = await readBody(req);
+            let steps;
+            try {
+              steps = JSON.parse(body);
+              if (!Array.isArray(steps))
+                throw new Error("body must be a JSON array");
+            } catch (e) {
+              send(res, 400, `invalid chain body: ${e instanceof Error ? e.message : String(e)}`);
+              return;
+            }
+            lastRaw = null;
+            const dr = await runChain(steps, async (type, args) => {
+              if (type === "knob") {
+                const k = args;
+                if (!k.knob)
+                  return { ok: false, label: "knob", error: "needs knob=<panel label>" };
+                const kr = await knobInClient(k.knob, k.file, k.value, tab);
+                return { ok: kr.ok, label: "knob", detail: kr.ok ? `replayed ${k.knob}` : void 0, error: kr.ok ? void 0 : kr.error, screen: kr.ok ? kr.value : void 0 };
+              }
+              const check2 = resolveAction(type, args);
+              if (!check2.valid)
+                return { ok: false, label: type, error: check2.error };
+              const r = await runAction(type, args, tab);
+              return { ok: r.ok, label: type, detail: r.detail, error: r.error, screen: r.screen, actions: r.actions };
+            });
+            send(res, dr.status, dr.body);
+            return;
+          }
+          if (TYPES.includes(parts[0])) {
+            const args = argsFromQuery(url.searchParams);
+            if (isDispatchAction(parts[0])) {
+              const dr = await dispatchAction(bridge, parts[0], args, { nextId: () => ++actionId, tab });
+              lastRaw = null;
+              send(res, dr.status, dr.body);
+              return;
+            }
+            const check2 = resolveAction(parts[0], args);
+            if (!check2.valid) {
+              send(res, 400, check2.error ?? "invalid action");
+              return;
+            }
+            const result = await runAction(parts[0], args, tab);
+            if (parts[0] === "screenshot" && result.dataUrl) {
+              const dir = resolve3(server.config.root, ".aidev");
+              mkdirSync(dir, { recursive: true });
+              const name = url.searchParams.get("out") || `shot-${result.dataUrl.length}.png`;
+              const file = resolve3(dir, name);
+              writeFileSync(file, Buffer.from(result.dataUrl.split(",")[1], "base64"));
+              send(res, 200, `saved: ${file}`);
+              return;
+            }
+            const head = result.ok ? result.detail || "ok" : `${result.error}${result.detail ? `
+
+clickable: ${result.detail}` : ""}`;
+            const actionsTail = result.actions ? `
+
+--- recent actions ---
+${result.actions}` : "";
+            const changedTail = result.screen ? `
+
+--- changed ---
+${result.screen}` : "";
+            const flowTail = result.flow ? `
+
+--- flow ---
+${result.flow}` : "";
+            send(res, result.ok ? 200 : 422, `${head}${actionsTail}${changedTail}${flowTail}`);
+            return;
+          }
+          if (parts[0] === "check") {
+            const raw2 = await collectFromClient(tab);
+            lastRaw = raw2;
+            const result = check(raw2);
+            const output = emitCheck(result);
+            send(res, result.pass ? 200 : 417, output);
+            return;
+          }
+          if (parts[0] === "profile") {
+            const noPerfMsg = (t) => {
+              const info = t ? tabs.get(t) : liveTabs()[0];
+              return info ? `tab '${info.id}' is connected but BACKGROUNDED \u2014 the browser throttles rAF to ~1fps for hidden tabs, so there are no real frames to profile. You don't need to open anything: the page is already running. Ask the user to click that browser tab to the foreground and keep it there ~2s, then re-run /profile. (Profiling is the only read needing foreground \u2014 /screen and /dom work backgrounded.)` : `(${diagnose2(t)})`;
+            };
+            const resetPerfWindow = () => new Promise((resolve5, reject) => {
+              const timeout = setTimeout(() => reject(new Error("timeout waiting for perf-reset-ack")), 3e3);
+              const handler = (data) => {
+                if (tab && data.tab !== tab) return;
+                clearTimeout(timeout);
+                server.hot.off("aihand:perf-reset-ack", handler);
+                resolve5();
+              };
+              server.hot.on("aihand:perf-reset-ack", handler);
+              server.hot.send("aihand:perf-reset", { tab, requireVisible: false });
+            });
+            if (parts[1] === "reset") {
+              await resetPerfWindow();
+              send(res, 200, "perf window cleared \u2014 reproduce the interaction, then GET /profile");
+              return;
+            }
+            if (parts[1] === "diff") {
+              const raw3 = await collectFromClient(tab);
+              lastRaw = raw3;
+              if (!raw3.performance) {
+                send(res, 200, noPerfMsg(tab));
+                return;
+              }
+              if (!perfBaseline) {
+                perfBaseline = raw3.performance;
+                await resetPerfWindow();
+                send(res, 200, "baseline captured + window cleared \u2014 make your fix, reproduce the interaction, then GET /profile/diff again for the verdict");
+                return;
+              }
+              const report = diffPerformance(perfBaseline, raw3.performance);
+              perfBaseline = null;
+              send(res, 200, report);
+              return;
+            }
+            const raw2 = await collectFromClient(tab);
+            lastRaw = raw2;
+            if (!raw2.performance) {
+              send(res, 200, noPerfMsg(tab));
+              return;
+            }
+            const hiddenNote = raw2.performance.hiddenFrames > 10 ? `
+
+\u26A0 ${raw2.performance.hiddenFrames} frames skipped while tab was hidden \u2014 bring it to foreground and /profile/reset for accurate data.` : "";
+            send(res, 200, detail(raw2, "profile", void 0, false) + hiddenNote);
+            return;
+          }
+          if (parts.length >= 1) {
+            if (!lastRaw)
+              lastRaw = await collectFromClient(tab);
+            const result = detail(lastRaw, parts[0], parts[1], full);
+            if (result !== null) {
+              send(res, 200, result);
+              return;
+            }
+            const SECTIONS2 = ["ui", "console", "network", "errors", "state", "profile"];
+            send(res, 404, SECTIONS2.includes(parts[0]) ? `'${parts[0]}' is empty right now \u2014 nothing captured this window (not an error).` : `unknown section '${parts[0]}'. Valid: ${SECTIONS2.join(", ")}. (Or /screen, /dom, /tabs, /timeline, /check.)`);
+            return;
+          }
+          const raw = await collectFromClient(tab);
+          lastRaw = raw;
+          if (full) {
+            const compacted = compact(raw);
+            send(res, 200, emit(compacted));
+          } else {
+            send(res, 200, emitSummary(raw));
+          }
+        } catch (err) {
+          send(res, 504, err instanceof Error ? err.message : "unknown error");
+        }
+      });
+    }
+  };
+}
+
+// src/vite.ts
+async function aihand(opts = {}) {
+  const config = await loadConfig();
+  const plugins = [];
+  if (config.runtime.enabled) {
+    plugins.push(...aihandPlugin(), knobSchema());
+    const files = scan(config).map((f) => resolve4(f));
+    plugins.push(storeSchema({ roots: files, storeMarker: config.runtime.storeMarker }));
+    const knobFiles = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".jsx"));
+    plugins.push(storeRefs({ roots: files, knobFiles, srcRoot: resolve4("src"), storeMarker: config.runtime.storeMarker }));
+  }
+  if (config.read.enabled)
+    plugins.push(repodexWatchPlugin(opts));
+  return plugins;
+}
+
+export {
+  discover,
+  storeSchema,
+  check,
+  diffState,
+  emitSummary,
+  emitCheck,
+  emitDiff,
+  aihand
+};