zeitzeuge 0.3.0

package/dist/cli.js

@@ -0,0 +1,1695 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/models/init.ts
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+function initModel() {
+  const modelOverride = process.env.ZEITZEUGE_MODEL;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (openaiKey) {
+    return new ChatOpenAI({
+      model: modelOverride ?? "gpt-5.2",
+      apiKey: openaiKey
+    });
+  }
+  if (anthropicKey) {
+    return new ChatAnthropic({
+      model: modelOverride ?? "claude-opus-4-6",
+      apiKey: anthropicKey
+    });
+  }
+  throw new Error(`No API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY in your environment.
+
+` + `  export OPENAI_API_KEY=sk-...
+` + `  # or
+` + `  export ANTHROPIC_API_KEY=sk-ant-...
+`);
+}
+
+// src/browser/launch.ts
+import { remote } from "webdriverio";
+async function launchBrowser(options = {}) {
+  const { headless = true } = options;
+  const browser = await remote({
+    capabilities: {
+      browserName: "chrome",
+      "goog:chromeOptions": {
+        args: [
+          ...headless ? ["--headless=new"] : [],
+          "--no-sandbox",
+          "--disable-gpu",
+          "--disable-dev-shm-usage"
+        ]
+      }
+    },
+    logLevel: "warn"
+  });
+  return browser;
+}
+async function closeBrowser(browser) {
+  try {
+    await browser.deleteSession();
+  } catch {}
+}
+
+// src/browser/runtime-trace.ts
+var SCRIPTING_EVENTS = new Set([
+  "FunctionCall",
+  "EvaluateScript",
+  "TimerFire",
+  "RequestAnimationFrame",
+  "FireAnimationFrame"
+]);
+var LAYOUT_EVENTS = new Set(["Layout", "UpdateLayoutTree", "RecalculateStyles"]);
+var PAINTING_EVENTS = new Set(["Paint", "CompositeLayers", "RasterTask"]);
+var GC_EVENT_NAMES = new Set(["MajorGC", "MinorGC"]);
+var BLOCKING_EVENT_NAMES = new Set(["FunctionCall", "EvaluateScript"]);
+var BLOCKING_THRESHOLD_US = 50000;
+function parseRuntimeTrace(traceEvents, navigationStartTs) {
+  if (traceEvents.length === 0) {
+    return emptyRuntimeTrace();
+  }
+  const mainThreadId = findMainThread(traceEvents);
+  const mainEvents = traceEvents.filter((e) => e.tid === mainThreadId);
+  const blockingFunctions = extractBlockingFunctions(mainEvents, navigationStartTs);
+  const eventListeners = extractEventListenerInfo(mainEvents);
+  const frameBreakdown = buildFrameBreakdown(mainEvents);
+  const gcEvents = extractGCEvents(mainEvents, navigationStartTs);
+  const frequentEvents = findFrequentEvents(mainEvents);
+  let minTs = Infinity;
+  let maxTs = -Infinity;
+  for (const e of traceEvents) {
+    if (e.ts < minTs)
+      minTs = e.ts;
+    const endTs = e.ts + (e.dur ?? 0);
+    if (endTs > maxTs)
+      maxTs = endTs;
+  }
+  const traceDuration = (maxTs - minTs) / 1000;
+  return {
+    totalEvents: traceEvents.length,
+    mainThreadId,
+    traceDuration,
+    frameBreakdown,
+    blockingFunctions,
+    eventListeners,
+    gcEvents,
+    frequentEvents
+  };
+}
+function findMainThread(events) {
+  const metadata = events.find((e) => e.cat === "__metadata" && e.name === "thread_name" && e.args?.name === "CrRendererMain");
+  if (metadata)
+    return metadata.tid;
+  const threadCounts = new Map;
+  for (const e of events) {
+    if (e.name === "FunctionCall") {
+      threadCounts.set(e.tid, (threadCounts.get(e.tid) ?? 0) + 1);
+    }
+  }
+  let maxTid = 0;
+  let maxCount = 0;
+  for (const [tid, count] of threadCounts) {
+    if (count > maxCount) {
+      maxTid = tid;
+      maxCount = count;
+    }
+  }
+  return maxTid;
+}
+function extractBlockingFunctions(mainEvents, navigationStartTs) {
+  const results = [];
+  for (const e of mainEvents) {
+    if (e.ph !== "X" || !BLOCKING_EVENT_NAMES.has(e.name) || !e.dur || e.dur < BLOCKING_THRESHOLD_US) {
+      continue;
+    }
+    const data = e.args?.data;
+    const functionName = data?.functionName || e.name;
+    const scriptUrl = data?.url || "";
+    const lineNumber = data?.lineNumber ?? 0;
+    const columnNumber = data?.columnNumber ?? 0;
+    const callStack = [];
+    if (data?.stackTrace) {
+      for (const frame of data.stackTrace) {
+        callStack.push({
+          functionName: frame.functionName || "(anonymous)",
+          scriptUrl: frame.url || "",
+          lineNumber: frame.lineNumber ?? 0
+        });
+      }
+    }
+    results.push({
+      functionName,
+      scriptUrl,
+      lineNumber,
+      columnNumber,
+      duration: e.dur / 1000,
+      startTime: (e.ts - navigationStartTs) / 1000,
+      callStack,
+      category: "scripting"
+    });
+  }
+  results.sort((a, b) => b.duration - a.duration);
+  return results;
+}
+function extractEventListenerInfo(mainEvents) {
+  const eventMap = new Map;
+  for (const e of mainEvents) {
+    if (e.name !== "EventDispatch" || e.ph !== "X")
+      continue;
+    const eventType = e.args?.data?.type || "unknown";
+    let entry = eventMap.get(eventType);
+    if (!entry) {
+      entry = { count: 0, totalDuration: 0, sources: new Map };
+      eventMap.set(eventType, entry);
+    }
+    entry.count++;
+    entry.totalDuration += (e.dur ?? 0) / 1000;
+    const url = e.args?.data?.url || "";
+    const line = e.args?.data?.lineNumber ?? 0;
+    if (url) {
+      const key = `${url}:${line}`;
+      const src = entry.sources.get(key);
+      if (src) {
+        src.count++;
+      } else {
+        entry.sources.set(key, { scriptUrl: url, lineNumber: line, count: 1 });
+      }
+    }
+  }
+  const results = [];
+  for (const [eventType, data] of eventMap) {
+    results.push({
+      eventType,
+      addCount: data.count,
+      removeCount: 0,
+      activeCount: data.count,
+      sources: Array.from(data.sources.values())
+    });
+  }
+  results.sort((a, b) => b.addCount - a.addCount);
+  return results;
+}
+function buildFrameBreakdown(mainEvents) {
+  let scripting = 0;
+  let layout = 0;
+  let painting = 0;
+  let gc = 0;
+  let other = 0;
+  for (const e of mainEvents) {
+    if (e.ph !== "X" || !e.dur)
+      continue;
+    const durMs = e.dur / 1000;
+    if (SCRIPTING_EVENTS.has(e.name)) {
+      scripting += durMs;
+    } else if (LAYOUT_EVENTS.has(e.name)) {
+      layout += durMs;
+    } else if (PAINTING_EVENTS.has(e.name)) {
+      painting += durMs;
+    } else if (GC_EVENT_NAMES.has(e.name)) {
+      gc += durMs;
+    } else {
+      other += durMs;
+    }
+  }
+  const totalTime = scripting + layout + painting + gc + other;
+  return {
+    totalTime: round(totalTime),
+    scripting: round(scripting),
+    layout: round(layout),
+    painting: round(painting),
+    gc: round(gc),
+    other: round(other)
+  };
+}
+function extractGCEvents(mainEvents, navigationStartTs) {
+  const results = [];
+  for (const e of mainEvents) {
+    if (e.ph !== "X" || !GC_EVENT_NAMES.has(e.name))
+      continue;
+    results.push({
+      startTime: round((e.ts - navigationStartTs) / 1000),
+      duration: round((e.dur ?? 0) / 1000),
+      type: e.name,
+      usedHeapSizeBefore: e.args?.data?.usedHeapSizeBefore,
+      usedHeapSizeAfter: e.args?.data?.usedHeapSizeAfter
+    });
+  }
+  results.sort((a, b) => a.startTime - b.startTime);
+  return results;
+}
+function findFrequentEvents(mainEvents) {
+  const counts = new Map;
+  for (const e of mainEvents) {
+    if (e.name !== "EventDispatch" || e.ph !== "X")
+      continue;
+    const eventType = e.args?.data?.type || "unknown";
+    const entry = counts.get(eventType);
+    if (entry) {
+      entry.count++;
+      entry.totalDuration += (e.dur ?? 0) / 1000;
+    } else {
+      counts.set(eventType, { count: 1, totalDuration: (e.dur ?? 0) / 1000 });
+    }
+  }
+  const results = [];
+  for (const [eventType, data] of counts) {
+    if (data.count > 10) {
+      results.push({
+        eventType,
+        count: data.count,
+        totalDuration: round(data.totalDuration)
+      });
+    }
+  }
+  results.sort((a, b) => b.count - a.count);
+  return results;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function emptyRuntimeTrace() {
+  return {
+    totalEvents: 0,
+    mainThreadId: 0,
+    traceDuration: 0,
+    frameBreakdown: {
+      totalTime: 0,
+      scripting: 0,
+      layout: 0,
+      painting: 0,
+      gc: 0,
+      other: 0
+    },
+    blockingFunctions: [],
+    eventListeners: [],
+    gcEvents: [],
+    frequentEvents: []
+  };
+}
+
+// src/browser/trace.ts
+var TEXT_RESOURCE_TYPES = new Set(["Script", "Stylesheet", "Document", "XHR", "Fetch"]);
+var MAX_BODY_SIZE = 2 * 1024 * 1024;
+var TRACE_CATEGORIES = [
+  "devtools.timeline",
+  "disabled-by-default-devtools.timeline",
+  "disabled-by-default-devtools.timeline.stack",
+  "v8.execute",
+  "blink.user_timing",
+  "disabled-by-default-v8.gc"
+];
+var TRACING_COMPLETE_TIMEOUT = 1e4;
+async function tracePageLoad(cdpSession, _options = {}) {
+  const requests = new Map;
+  const finishedIds = new Set;
+  const traceEvents = [];
+  let tracingStarted = false;
+  try {
+    cdpSession.on("Tracing.dataCollected", (params) => {
+      if (params.value && Array.isArray(params.value)) {
+        traceEvents.push(...params.value);
+      }
+    });
+    await cdpSession.send("Tracing.start", {
+      traceConfig: {
+        includedCategories: TRACE_CATEGORIES,
+        recordMode: "recordUntilFull"
+      },
+      transferMode: "ReportEvents"
+    });
+    tracingStarted = true;
+  } catch {}
+  await cdpSession.send("Network.enable");
+  cdpSession.on("Network.requestWillBeSent", (params) => {
+    requests.set(params.requestId, {
+      requestId: params.requestId,
+      url: params.request.url,
+      method: params.request.method,
+      startTime: params.timestamp * 1000,
+      initiator: params.initiator?.type ?? "other",
+      resourceType: params.type ?? "Other"
+    });
+  });
+  cdpSession.on("Network.responseReceived", (params) => {
+    const req = requests.get(params.requestId);
+    if (req) {
+      req.status = params.response.status;
+      req.mimeType = params.response.mimeType;
+      req.encodedSize = params.response.encodedDataLength ?? 0;
+      req.priority = params.response.priority ?? "Medium";
+      req.isRenderBlocking = params.response.renderBlocking === "blocking";
+      req.resourceType = params.type ?? req.resourceType ?? "Other";
+    }
+  });
+  cdpSession.on("Network.loadingFinished", (params) => {
+    const req = requests.get(params.requestId);
+    if (req) {
+      req.endTime = params.timestamp * 1000;
+      req.duration = (req.endTime ?? 0) - (req.startTime ?? 0);
+      req.decodedSize = params.encodedDataLength ?? 0;
+      finishedIds.add(params.requestId);
+    }
+  });
+  await cdpSession.send("Page.enable");
+  await cdpSession.send("Page.addScriptToEvaluateOnNewDocument", {
+    source: `
+      window.__zeitzeuge_longTasks = [];
+      new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          window.__zeitzeuge_longTasks.push({
+            startTime: entry.startTime,
+            duration: entry.duration,
+            scriptUrl: null,
+          });
+        }
+      }).observe({ type: "longtask", buffered: true });
+    `
+  });
+  return {
+    async stop() {
+      let runtimeTrace;
+      if (tracingStarted) {
+        try {
+          const tracingComplete = new Promise((resolve) => {
+            cdpSession.on("Tracing.tracingComplete", () => resolve());
+          });
+          await cdpSession.send("Tracing.end");
+          await Promise.race([
+            tracingComplete,
+            new Promise((resolve) => setTimeout(resolve, TRACING_COMPLETE_TIMEOUT))
+          ]);
+        } catch {}
+        if (traceEvents.length > 0) {
+          const navEvent = traceEvents.find((e) => e.name === "navigationStart" || e.name === "NavigationStart");
+          const navigationStartTs = navEvent?.ts ?? traceEvents[0]?.ts ?? 0;
+          runtimeTrace = parseRuntimeTrace(traceEvents, navigationStartTs);
+        }
+      }
+      const networkRequests = [];
+      for (const [id, req] of requests) {
+        let responseBody = null;
+        if (finishedIds.has(id) && TEXT_RESOURCE_TYPES.has(req.resourceType ?? "")) {
+          try {
+            const bodyResult = await cdpSession.send("Network.getResponseBody", { requestId: id });
+            responseBody = bodyResult.body;
+            if (responseBody && responseBody.length > MAX_BODY_SIZE) {
+              responseBody = null;
+            }
+          } catch {}
+        }
+        networkRequests.push({
+          requestId: req.requestId ?? id,
+          url: req.url ?? "",
+          method: req.method ?? "GET",
+          resourceType: req.resourceType ?? "Other",
+          mimeType: req.mimeType ?? "",
+          status: req.status ?? 0,
+          encodedSize: req.encodedSize ?? 0,
+          decodedSize: req.decodedSize ?? 0,
+          startTime: req.startTime ?? 0,
+          endTime: req.endTime ?? 0,
+          duration: req.duration ?? 0,
+          isRenderBlocking: req.isRenderBlocking ?? false,
+          responseBody,
+          priority: req.priority ?? "Medium",
+          initiator: req.initiator ?? "other"
+        });
+      }
+      let longTasks = [];
+      try {
+        const longTaskResult = await cdpSession.send("Runtime.evaluate", {
+          expression: "JSON.stringify(window.__zeitzeuge_longTasks || [])"
+        });
+        longTasks = JSON.parse(longTaskResult.result.value || "[]");
+      } catch {}
+      let perfMetrics = {};
+      try {
+        const metricsResult = await cdpSession.send("Runtime.evaluate", {
+          expression: `JSON.stringify({
+            navigationStart: performance.timing.navigationStart,
+            domContentLoaded: performance.timing.domContentLoadedEventEnd - performance.timing.navigationStart,
+            loadComplete: performance.timing.loadEventEnd - performance.timing.navigationStart,
+          })`
+        });
+        perfMetrics = JSON.parse(metricsResult.result.value || "{}");
+      } catch {}
+      let paintEntries = [];
+      try {
+        const paintResult = await cdpSession.send("Runtime.evaluate", {
+          expression: `JSON.stringify(
+            performance.getEntriesByType("paint").map(e => ({ name: e.name, startTime: e.startTime }))
+          )`
+        });
+        paintEntries = JSON.parse(paintResult.result.value || "[]");
+      } catch {}
+      const fp = paintEntries.find((e) => e.name === "first-paint");
+      const fcp = paintEntries.find((e) => e.name === "first-contentful-paint");
+      await cdpSession.send("Network.disable");
+      const metrics = {
+        navigationStart: perfMetrics.navigationStart ?? 0,
+        domContentLoaded: perfMetrics.domContentLoaded ?? 0,
+        loadComplete: perfMetrics.loadComplete ?? 0,
+        firstPaint: fp?.startTime ?? 0,
+        firstContentfulPaint: fcp?.startTime ?? 0,
+        largestContentfulPaint: 0,
+        totalBlockingTime: longTasks.reduce((sum, t) => sum + Math.max(0, t.duration - 50), 0),
+        longTasks
+      };
+      return {
+        networkRequests,
+        metrics,
+        runtimeTrace,
+        rawTraceEvents: tracingStarted ? traceEvents : undefined
+      };
+    }
+  };
+}
+
+// src/browser/capture.ts
+async function capturePage(browser, url, options = {}) {
+  const { timeout = 30000 } = options;
+  const puppeteerBrowser = await browser.getPuppeteer();
+  const pages = await puppeteerBrowser.pages();
+  const page = pages[0];
+  if (!page) {
+    throw new Error("No page found in Puppeteer browser");
+  }
+  const cdpSession = await page.createCDPSession();
+  const traceHandle = await tracePageLoad(cdpSession, options);
+  await page.goto(url, {
+    waitUntil: "load",
+    timeout
+  });
+  await new Promise((r) => setTimeout(r, 2000));
+  const traceResult = await traceHandle.stop();
+  await cdpSession.send("HeapProfiler.enable");
+  const chunks = [];
+  cdpSession.on("HeapProfiler.addHeapSnapshotChunk", (params) => {
+    chunks.push(params.chunk);
+  });
+  await cdpSession.send("HeapProfiler.collectGarbage");
+  await cdpSession.send("HeapProfiler.takeHeapSnapshot", {
+    reportProgress: false
+  });
+  await cdpSession.send("HeapProfiler.disable");
+  await cdpSession.detach();
+  return {
+    heapSnapshot: {
+      data: chunks.join(""),
+      capturedAt: Date.now(),
+      url
+    },
+    trace: traceResult
+  };
+}
+
+// src/analysis/parser.ts
+function parseSnapshot(rawSnapshot) {
+  const v8 = JSON.parse(rawSnapshot.data);
+  const meta = v8.snapshot.meta;
+  const nodeFieldCount = meta.node_fields.length;
+  const edgeFieldCount = meta.edge_fields.length;
+  const nodeTypes = meta.node_types[0];
+  const edgeTypes = meta.edge_types[0];
+  const nodeTypeIdx = meta.node_fields.indexOf("type");
+  const nodeNameIdx = meta.node_fields.indexOf("name");
+  const nodeIdIdx = meta.node_fields.indexOf("id");
+  const nodeSelfSizeIdx = meta.node_fields.indexOf("self_size");
+  const nodeEdgeCountIdx = meta.node_fields.indexOf("edge_count");
+  const nodeDetachednessIdx = meta.node_fields.indexOf("detachedness");
+  const edgeTypeIdx = meta.edge_fields.indexOf("type");
+  const edgeNameIdx = meta.edge_fields.indexOf("name_or_index");
+  const edgeToNodeIdx = meta.edge_fields.indexOf("to_node");
+  const nodeCount = v8.snapshot.node_count;
+  const nodes = [];
+  let edgeOffset = 0;
+  let totalSize = 0;
+  for (let i = 0;i < nodeCount; i++) {
+    const base = i * nodeFieldCount;
+    const selfSize = v8.nodes[base + nodeSelfSizeIdx] ?? 0;
+    totalSize += selfSize;
+    nodes.push({
+      ordinal: i,
+      type: nodeTypes[v8.nodes[base + nodeTypeIdx] ?? 0] ?? "unknown",
+      name: v8.strings[v8.nodes[base + nodeNameIdx] ?? 0] ?? "",
+      id: v8.nodes[base + nodeIdIdx] ?? 0,
+      selfSize,
+      edgeCount: v8.nodes[base + nodeEdgeCountIdx] ?? 0,
+      detachedness: nodeDetachednessIdx >= 0 ? v8.nodes[base + nodeDetachednessIdx] ?? 0 : 0,
+      edgeStartIndex: edgeOffset
+    });
+    edgeOffset += (v8.nodes[base + nodeEdgeCountIdx] ?? 0) * edgeFieldCount;
+  }
+  const adjacency = Array.from({ length: nodeCount }, () => []);
+  for (let i = 0;i < nodeCount; i++)
+    adjacency[i] = [];
+  const reverseAdj = Array.from({ length: nodeCount }, () => []);
+  for (let i = 0;i < nodeCount; i++)
+    reverseAdj[i] = [];
+  for (let i = 0;i < nodeCount; i++) {
+    const node = nodes[i];
+    for (let e = 0;e < node.edgeCount; e++) {
+      const edgeBase = node.edgeStartIndex + e * edgeFieldCount;
+      const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
+      if (edgeTypeVal === "weak")
+        continue;
+      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
+      const toOrdinal = toNodeArrayIdx / nodeFieldCount;
+      if (toOrdinal >= 0 && toOrdinal < nodeCount) {
+        adjacency[i].push(toOrdinal);
+        reverseAdj[toOrdinal].push(i);
+      }
+    }
+  }
+  const visited = new Uint8Array(nodeCount);
+  const bfsOrder = [];
+  const queue = [0];
+  visited[0] = 1;
+  while (queue.length > 0) {
+    const curr = queue.shift();
+    bfsOrder.push(curr);
+    for (const next of adjacency[curr]) {
+      if (!visited[next]) {
+        visited[next] = 1;
+        queue.push(next);
+      }
+    }
+  }
+  const dominators = new Int32Array(nodeCount).fill(-1);
+  dominators[0] = 0;
+  const nodeToRpo = new Int32Array(nodeCount).fill(-1);
+  for (let i = 0;i < bfsOrder.length; i++) {
+    nodeToRpo[bfsOrder[i]] = i;
+  }
+  function intersect(b1Init, b2Init) {
+    let b1 = b1Init;
+    let b2 = b2Init;
+    let finger1 = nodeToRpo[b1];
+    let finger2 = nodeToRpo[b2];
+    while (finger1 !== finger2) {
+      while (finger1 > finger2) {
+        b1 = dominators[b1];
+        if (b1 < 0)
+          return 0;
+        finger1 = nodeToRpo[b1];
+      }
+      while (finger2 > finger1) {
+        b2 = dominators[b2];
+        if (b2 < 0)
+          return 0;
+        finger2 = nodeToRpo[b2];
+      }
+    }
+    return b1;
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let i = 1;i < bfsOrder.length; i++) {
+      const node = bfsOrder[i];
+      let newIdom = -1;
+      for (const pred of reverseAdj[node]) {
+        if (dominators[pred] < 0)
+          continue;
+        if (newIdom < 0) {
+          newIdom = pred;
+        } else {
+          newIdom = intersect(newIdom, pred);
+        }
+      }
+      if (newIdom >= 0 && dominators[node] !== newIdom) {
+        dominators[node] = newIdom;
+        changed = true;
+      }
+    }
+  }
+  const retainedSizes = new Float64Array(nodeCount);
+  for (let i = 0;i < nodeCount; i++) {
+    retainedSizes[i] = nodes[i].selfSize;
+  }
+  for (let i = bfsOrder.length - 1;i > 0; i--) {
+    const node = bfsOrder[i];
+    const dom = dominators[node];
+    if (dom >= 0 && dom !== node) {
+      retainedSizes[dom] = retainedSizes[dom] + retainedSizes[node];
+    }
+  }
+  const indexed = bfsOrder.filter((i) => i > 0).map((i) => ({ ordinal: i, retainedSize: retainedSizes[i] })).sort((a, b) => b.retainedSize - a.retainedSize).slice(0, 50);
+  function getEdgeName(toOrdinal) {
+    const dom = dominators[toOrdinal];
+    if (dom < 0)
+      return "";
+    const domNode = nodes[dom];
+    for (let e = 0;e < domNode.edgeCount; e++) {
+      const edgeBase = domNode.edgeStartIndex + e * edgeFieldCount;
+      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
+      if (toNodeArrayIdx / nodeFieldCount === toOrdinal) {
+        const nameOrIndex = v8.edges[edgeBase + edgeNameIdx] ?? 0;
+        const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
+        if (edgeTypeVal === "element")
+          return `[${nameOrIndex}]`;
+        return v8.strings[nameOrIndex] ?? String(nameOrIndex);
+      }
+    }
+    return "";
+  }
+  function getRetainerPath(targetOrdinal, maxDepth = 10) {
+    const path = [];
+    let current = targetOrdinal;
+    const pathVisited = new Set;
+    for (let depth = 0;depth < maxDepth; depth++) {
+      const node = nodes[current];
+      const edgeName = getEdgeName(current);
+      path.unshift(edgeName ? `${node.name || node.type}` : node.name || node.type);
+      if (current === 0)
+        break;
+      pathVisited.add(current);
+      const dom = dominators[current];
+      if (dom < 0 || dom === current || pathVisited.has(dom))
+        break;
+      current = dom;
+    }
+    return path;
+  }
+  const largestObjects = indexed.map(({ ordinal, retainedSize }) => {
+    const node = nodes[ordinal];
+    return {
+      name: node.name || `(${node.type})`,
+      type: node.type,
+      selfSize: node.selfSize,
+      retainedSize,
+      retainerPath: getRetainerPath(ordinal)
+    };
+  });
+  const typeMap = new Map;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    const existing = typeMap.get(node.type);
+    if (existing) {
+      existing.count++;
+      existing.totalSize += node.selfSize;
+    } else {
+      typeMap.set(node.type, { count: 1, totalSize: node.selfSize });
+    }
+  }
+  const typeStats = Array.from(typeMap.entries()).map(([type, stats]) => ({
+    type,
+    count: stats.count,
+    totalSize: stats.totalSize,
+    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
+  })).sort((a, b) => b.totalSize - a.totalSize);
+  const ctorMap = new Map;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    if (node.type !== "object" || !node.name)
+      continue;
+    const existing = ctorMap.get(node.name);
+    if (existing) {
+      existing.count++;
+      existing.totalSize += node.selfSize;
+    } else {
+      ctorMap.set(node.name, { count: 1, totalSize: node.selfSize });
+    }
+  }
+  const constructorStats = Array.from(ctorMap.entries()).map(([ctor, stats]) => ({
+    constructor: ctor,
+    count: stats.count,
+    totalSize: stats.totalSize,
+    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
+  })).sort((a, b) => b.totalSize - a.totalSize).slice(0, 30);
+  const detachedExamples = [];
+  let detachedCount = 0;
+  let detachedTotalSize = 0;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    const isDetached = nodeDetachednessIdx >= 0 && node.detachedness > 0 || node.name.includes("Detached") || node.type === "native" && /HTML\w*Element|Document|Node/.test(node.name) && node.name.includes("Detached");
+    if (isDetached) {
+      detachedCount++;
+      detachedTotalSize += node.selfSize;
+      if (detachedExamples.length < 10) {
+        detachedExamples.push({
+          name: node.name || `(${node.type})`,
+          retainerPath: getRetainerPath(node.ordinal)
+        });
+      }
+    }
+  }
+  const detachedNodes = {
+    count: detachedCount,
+    totalSize: detachedTotalSize,
+    examples: detachedExamples
+  };
+  const closureNodes = nodes.filter((n) => visited[n.ordinal] && n.type === "closure");
+  const closureTotalSize = closureNodes.reduce((sum, n) => sum + n.selfSize, 0);
+  const topClosures = closureNodes.sort((a, b) => b.selfSize - a.selfSize).slice(0, 20).map((n) => ({
+    name: n.name || "(anonymous)",
+    contextSize: n.selfSize,
+    retainerPath: getRetainerPath(n.ordinal)
+  }));
+  const closureStats = {
+    count: closureNodes.length,
+    totalSize: closureTotalSize,
+    topClosures
+  };
+  return {
+    metadata: {
+      url: rawSnapshot.url,
+      capturedAt: rawSnapshot.capturedAt,
+      totalSize,
+      nodeCount: v8.snapshot.node_count,
+      edgeCount: v8.snapshot.edge_count
+    },
+    largestObjects,
+    typeStats,
+    constructorStats,
+    detachedNodes,
+    closureStats
+  };
+}
+
+// src/analysis/agent.ts
+import { createDeepAgent } from "deepagents";
+import { providerStrategy } from "langchain";
+
+// src/analysis/prompts.ts
+var SYSTEM_PROMPT = `You are an expert web performance engineer. You have access to a virtual filesystem workspace containing captured data from a real page load: heap snapshot, network trace, and Chrome runtime trace.
+
+## Workspace structure
+
+- /heap/summary.json — Parsed V8 heap snapshot: largest objects, type stats, constructor stats, detached DOM nodes, closure stats
+- /trace/summary.json — Page load metrics: timing, long tasks, render-blocking resources, resource breakdown
+- /trace/network-waterfall.json — Every network request with timing, size, priority, render-blocking status
+- /trace/asset-manifest.json — Index of all assets with paths to stored files
+- /trace/runtime/summary.json — Runtime trace overview: frame breakdown (scripting/layout/paint/GC), blocking function count, listener imbalances, GC stats
+- /trace/runtime/blocking-functions.json — Functions that blocked the main thread > 50ms, with script URL, line number, call stack, and duration
+- /trace/runtime/event-listeners.json — Event listener add/remove counts per event type, with source locations
+- /trace/runtime/frame-breakdown.json — Time spent in scripting vs layout vs paint vs GC
+- /trace/runtime/raw-events.json — Full Chrome trace events (large file — read to investigate specific function calls, layouts, GC, and event dispatches)
+- /scripts/*.js — Actual JavaScript source files captured during page load
+- /styles/*.css — Actual CSS source files
+- /html/document.html — The HTML document
+
+## Your workflow
+
+1. Read /heap/summary.json, /trace/summary.json, AND /trace/runtime/summary.json first for the big picture
+2. Identify the highest-impact issues from all datasets
+3. For each issue, dive into the relevant source files to understand the root cause
+4. Provide specific, code-level fixes
+
+## What to look for
+
+### Memory issues (from heap data)
+- Memory leaks: unbounded arrays, maps, caches that grow without bound
+- Detached DOM nodes: DOM elements removed from the document but still referenced
+- Large retained objects: single objects or trees retaining disproportionate memory
+- Closure leaks: closures capturing variables they no longer need
+
+### Page-load issues (from trace + source code)
+- Render-blocking scripts: <script> in <head> without async/defer — read the script to judge if it must be synchronous
+- Render-blocking CSS: large stylesheets blocking first paint
+- Long tasks (> 50ms): identify the function/module causing the block by reading the source
+- Large bundles: scripts > 100KB — search for unused imports or code that could be lazy-loaded
+- Sequential waterfalls: resources chained sequentially that could load in parallel
+
+### Runtime issues (from Chrome trace)
+- Frame-blocking functions: read /trace/runtime/blocking-functions.json first, then inspect the actual script source at the reported line number to understand what the function does and how to optimize it
+- Event listener leaks: check /trace/runtime/event-listeners.json for event types where addCount >> removeCount, then grep the scripts for those addEventListener calls
+- GC pressure: high GC pause counts or duration suggest excessive short-lived object creation — look for hot loops creating objects
+- Layout thrashing: forced synchronous layouts caused by reading layout properties (offsetHeight, getBoundingClientRect) after DOM writes
+
+## Output guidelines
+
+- Report 3–7 findings, ordered by impact (mix of memory, page-load, and runtime if all have issues)
+- Be specific — name actual files, functions, object constructors, and retention paths
+- Provide concrete code fixes, not generic advice
+- If heap, trace, and runtime all look healthy, say so — don't manufacture issues`;
+
+// src/vitest/prompts.ts
+var VITEST_SYSTEM_PROMPT = `You are an expert in JavaScript/TypeScript performance optimization.
+You have access to a workspace containing V8 CPU profiling data captured during
+a Vitest test run. The workspace may also include V8 heap profiling data
+captured via Node's \`--heap-prof\` (allocation sampling).
+
+The profiling data covers BOTH the test code AND the application code being tested.
+
+**Your primary goal is to analyze the PERFORMANCE OF THE APPLICATION CODE
+being tested** — the functions, modules, and algorithms that the developer
+wrote and is benchmarking or testing. Test infrastructure overhead (Vitest,
+tinybench, test setup) is secondary context.
+
+## Source categories
+
+Every hot function and script in the workspace has a \`sourceCategory\` field:
+
+- **application** — Code in the user's project (the code being tested).
+  This is your PRIMARY focus. Find bottlenecks, inefficiencies, and
+  optimization opportunities in these functions.
+- **dependency** — Third-party code in node_modules. Report when a dependency
+  is a significant bottleneck, since the developer may be able to choose
+  an alternative, configure it differently, or avoid calling it in hot paths.
+- **test** — Test files. Only mention if the test setup itself is creating
+  artificial overhead that masks application performance.
+- **framework** — Vitest/tinybench/V8 internals. Generally ignore unless
+  they dominate the profile in an unexpected way.
+
+## Workspace structure
+
+- /summary.json — Overall test run: total tests, duration, pass/fail, GC stats
+- /timing/overview.json — Per-file test durations and individual test times
+- /timing/slow-tests.json — Tests exceeding the slow threshold
+- /profiles/index.json — Manifest mapping test files to their CPU profiles
+- /profiles/<file>.json — CPU profile summary: hot functions (with sourceCategory),
+  call trees, GC samples, script breakdown (with sourceCategory)
+- /heap-profiles/index.json — (optional) Manifest mapping test files to heap profiles
+- /heap-profiles/<file>.json — (optional) Heap profile summary: allocation hotspots,
+  per-script allocated bytes (with sourceCategory)
+- /hot-functions/application.json — **START HERE**: Hot functions from application code only
+- /hot-functions/dependencies.json — Hot functions from third-party dependencies
+- /hot-functions/global.json — All hot functions across all categories
+- /scripts/application.json — Per-script time breakdown for application code
+- /scripts/dependencies.json — Per-script time breakdown for dependencies
+- /tests/*.ts — Test source files
+- /src/*.ts — Application and dependency source files referenced by hot functions
+
+## Your workflow
+
+1. Read /hot-functions/application.json FIRST — these are the application-level
+   bottlenecks the developer wants to optimize
+2. Read /scripts/application.json for the per-file view of application code time
+3. Read /hot-functions/dependencies.json for costly dependency calls
+4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json to identify
+   allocation hotspots (functions/scripts allocating lots of bytes)
+5. Read /summary.json and /timing/overview.json for the big picture
+6. Read CPU profiles in /profiles/ for detailed call trees of the slowest tests
+7. Read the actual source code in /src/ and /tests/ to understand root causes
+8. Provide specific, actionable fixes targeting the application code
+
+## What to look for
+
+### Application code bottlenecks (PRIMARY FOCUS)
+- Functions with high self time — where is the application spending CPU?
+- Expensive algorithms: O(n²) loops, unnecessary sorting, repeated work
+- String/JSON operations: excessive serialization, string concatenation in loops
+- Object allocation hotspots: functions creating many short-lived objects
+- Synchronous blocking: file I/O, crypto, or compression in hot paths
+- Redundant computation: values computed repeatedly that could be cached/memoized
+- Data structure choices: using arrays where Maps/Sets would be O(1)
+
+### Dependency-related bottlenecks
+- Dependencies consuming disproportionate CPU — suggest alternatives or configuration
+- Unnecessary calls to expensive dependency APIs in hot paths
+- Dependencies pulled in for simple operations that could be hand-written
+
+### GC pressure from application code
+- Application functions creating many temporary objects in tight loops
+- Large array/object allocations that could be pooled or reused
+- Closures capturing large scopes unnecessarily
+
+### Allocation hotspots (from heap profiles, if present)
+- Functions allocating a large share of total bytes (even if CPU isn't dominant)
+- Scripts/modules responsible for most allocation — suggest caching, reuse, pooling,
+  or avoiding intermediate arrays/objects
+- When allocation hotspots match CPU hotspots, prioritize fixes there first
+
+### Call chain analysis
+- Trace expensive call trees to find which APPLICATION function triggers them
+- Follow the call tree from application entry points down to the hot leaf functions
+- Identify which application-level design decisions lead to the bottleneck
+
+### Test infrastructure (SECONDARY — only if impactful)
+- Test setup creating artificial overhead that dwarfs application execution
+- Benchmarks measuring setup cost instead of application performance
+- Only mention if it prevents getting clean application performance data
+
+## Finding categories
+
+Each finding MUST use one of these exact category values:
+
+- **algorithm** — Inefficient algorithm: O(n²) loops, brute-force search, repeated work
+- **serialization** — Excessive JSON.stringify/parse, string concatenation, encoding
+- **allocation** — Excessive object/array creation causing GC pressure
+- **event-handling** — Listener leaks, unbounded event handler accumulation
+- **hot-function** — Generic CPU-hot function that doesn't fit a more specific category
+- **gc-pressure** — High garbage collection overhead
+- **listener-leak** — Event listeners not cleaned up properly
+- **unnecessary-computation** — Redundant work that could be cached or eliminated
+- **blocking-io** — Synchronous I/O or blocking operations in hot paths
+- **dependency-bottleneck** — Expensive dependency call the developer can optimize
+- **slow-test** — Test itself is slow due to setup or teardown
+- **expensive-setup** — Costly test setup (beforeAll/beforeEach)
+- **import-overhead** — Expensive module imports at test time
+- **other** — Doesn't fit any of the above
+
+Prefer more specific categories (algorithm, serialization, allocation, event-handling)
+over generic ones (hot-function, other) when the root cause is clear.
+
+## Output guidelines
+
+- Report 3–7 findings, ordered by impact ON THE APPLICATION CODE
+- Focus findings on functions the developer CAN change (application code first,
+  then dependency usage patterns, then test structure)
+- Be specific — name actual files, functions, line numbers from the source code
+- Provide concrete code-level fixes, not generic advice
+- When reporting a dependency bottleneck, explain what application code is
+  calling it and how the developer can reduce that cost
+- If the application code is already efficient, say so — don't force findings
+  about test infrastructure just to fill the report`;
+
+// src/schema.ts
+import { z } from "zod";
+var ALL_CATEGORIES = [
+  "memory-leak",
+  "large-retained-object",
+  "detached-dom",
+  "render-blocking",
+  "long-task",
+  "unused-code",
+  "waterfall-bottleneck",
+  "large-asset",
+  "frame-blocking-function",
+  "listener-leak",
+  "gc-pressure",
+  "slow-test",
+  "expensive-setup",
+  "hot-function",
+  "unnecessary-computation",
+  "import-overhead",
+  "dependency-bottleneck",
+  "algorithm",
+  "serialization",
+  "allocation",
+  "event-handling",
+  "blocking-io",
+  "other"
+];
+var FindingSchema = z.object({
+  severity: z.enum(["critical", "warning", "info"]),
+  title: z.string().describe("Short title for the finding"),
+  description: z.string().describe("Detailed explanation of the issue"),
+  category: z.string().describe(`Category of the performance issue. Use one of: ${ALL_CATEGORIES.join(", ")}`),
+  resourceUrl: z.string().optional().describe("URL of the resource involved"),
+  workspacePath: z.string().optional().describe("Path in the VFS workspace"),
+  impactMs: z.number().optional().describe("Impact on page load time in ms"),
+  retainedSize: z.number().optional().describe("Retained heap size in bytes"),
+  retainerPath: z.array(z.string()).optional().describe("Object retention path in the heap"),
+  suggestedFix: z.string().describe("Code snippet or guidance to fix the issue"),
+  testFile: z.string().optional().describe("Test file path (for test performance findings)"),
+  hotFunction: z.object({
+    name: z.string(),
+    scriptUrl: z.string(),
+    lineNumber: z.number(),
+    selfTime: z.number(),
+    selfPercent: z.number()
+  }).optional().describe("Hot function details (for hot-function findings)")
+});
+var FindingsSchema = z.object({
+  findings: z.array(FindingSchema)
+});
+
+// src/analysis/agent.ts
+async function analyze(model, backend) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = [
+    "Analyze the frontend performance data in this workspace.",
+    "",
+    "The workspace contains heap snapshot data, page-load trace data, and Chrome runtime trace data.",
+    "",
+    "Start by reading /heap/summary.json, /trace/summary.json, and /trace/runtime/summary.json",
+    "to understand the overall picture. Then explore:",
+    "",
+    "- /trace/network-waterfall.json for request timing",
+    "- /trace/runtime/blocking-functions.json for function-level main thread blocking",
+    "- /trace/runtime/event-listeners.json for listener add/remove imbalances",
+    "- /trace/runtime/frame-breakdown.json for frame breakdown (scripting vs layout vs paint vs GC)",
+    "- /scripts/ for the actual JavaScript source code",
+    "- /styles/ for CSS source",
+    "- /html/document.html for the page markup",
+    "",
+    "Look for memory issues (from the heap data), page-load issues (from the network trace),",
+    "and runtime issues (from the Chrome trace — blocking functions, listener leaks, GC pressure).",
+    "When you find a problem, read the actual source file to provide a specific, code-level fix."
+  ].join(`
+`);
+  const result = await agent.invoke({
+    messages: [{ role: "user", content: userMessage }]
+  });
+  return result.structuredResponse.findings;
+}
+async function analyzeTestPerformance(model, backend) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: VITEST_SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = [
+    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
+    "",
+    "Follow this order:",
+    "1. Read /hot-functions/application.json — these are the hotspots IN the user's own code",
+    "2. Read /scripts/application.json — per-file CPU time for application source files",
+    "3. Read /hot-functions/dependencies.json — expensive dependency calls",
+    "4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json for allocation hotspots",
+    "5. Read /summary.json and /timing/overview.json for the big picture",
+    "6. Read CPU profiles in /profiles/ for detailed call trees",
+    "7. Read source files in /src/ and /tests/ to understand root causes and propose code-level fixes",
+    "",
+    "Focus findings on the APPLICATION code — what can the developer change in their own codebase",
+    "to improve performance? Dependency bottlenecks are worth reporting if the developer can",
+    "reduce how they call the dependency or choose an alternative."
+  ].join(`
+`);
+  const result = await agent.invoke({
+    messages: [{ role: "user", content: userMessage }]
+  });
+  return result.structuredResponse.findings;
+}
+
+// src/sandbox/workspace.ts
+import { FilesystemBackend } from "deepagents";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+async function createWorkspace(options) {
+  const { heapSummary, traceResult, url, maxAssetSize = 10 * 1024 * 1024 } = options;
+  const files = {};
+  files["/heap/summary.json"] = JSON.stringify(heapSummary, null, 2);
+  files["/trace/summary.json"] = JSON.stringify({
+    url,
+    timing: traceResult.metrics,
+    requestCount: traceResult.networkRequests.length,
+    totalTransferSize: traceResult.networkRequests.reduce((s, r) => s + r.encodedSize, 0),
+    totalDecodedSize: traceResult.networkRequests.reduce((s, r) => s + r.decodedSize, 0),
+    renderBlockingResources: traceResult.networkRequests.filter((r) => r.isRenderBlocking).map((r) => ({
+      url: r.url,
+      type: r.resourceType,
+      size: r.decodedSize,
+      duration: r.duration,
+      path: r.responseBody ? getAssetPath(r) : null
+    })),
+    longTasks: traceResult.metrics.longTasks,
+    resourceBreakdown: buildResourceBreakdown(traceResult.networkRequests)
+  }, null, 2);
+  files["/trace/network-waterfall.json"] = JSON.stringify(traceResult.networkRequests.sort((a, b) => a.startTime - b.startTime).map((r) => ({
+    url: r.url,
+    type: r.resourceType,
+    status: r.status,
+    size: r.decodedSize,
+    startTime: Math.round(r.startTime),
+    endTime: Math.round(r.endTime),
+    duration: Math.round(r.duration),
+    isRenderBlocking: r.isRenderBlocking,
+    priority: r.priority,
+    path: r.responseBody ? getAssetPath(r) : null
+  })), null, 2);
+  let totalStored = 0;
+  for (const req of traceResult.networkRequests) {
+    if (!req.responseBody)
+      continue;
+    if (totalStored + req.responseBody.length > maxAssetSize)
+      continue;
+    files[getAssetPath(req)] = req.responseBody;
+    totalStored += req.responseBody.length;
+  }
+  files["/trace/asset-manifest.json"] = JSON.stringify(traceResult.networkRequests.map((r) => ({
+    url: r.url,
+    type: r.resourceType,
+    size: r.decodedSize,
+    duration: r.duration,
+    isRenderBlocking: r.isRenderBlocking,
+    stored: !!r.responseBody,
+    path: r.responseBody ? getAssetPath(r) : null
+  })), null, 2);
+  if (traceResult.runtimeTrace) {
+    const rt = traceResult.runtimeTrace;
+    files["/trace/runtime/summary.json"] = JSON.stringify({
+      totalEvents: rt.totalEvents,
+      traceDuration: rt.traceDuration,
+      mainThreadId: rt.mainThreadId,
+      frameBreakdown: rt.frameBreakdown,
+      blockingFunctionCount: rt.blockingFunctions.length,
+      listenerImbalances: rt.eventListeners.filter((l) => l.activeCount > l.removeCount + 10).length,
+      gcPauseCount: rt.gcEvents.length,
+      gcTotalDuration: rt.gcEvents.reduce((s, e) => s + e.duration, 0),
+      frequentEventTypes: rt.frequentEvents.map((e) => e.eventType)
+    }, null, 2);
+    files["/trace/runtime/blocking-functions.json"] = JSON.stringify(rt.blockingFunctions.slice(0, 50), null, 2);
+    files["/trace/runtime/event-listeners.json"] = JSON.stringify(rt.eventListeners.filter((l) => l.addCount > 0), null, 2);
+    files["/trace/runtime/frame-breakdown.json"] = JSON.stringify(rt.frameBreakdown, null, 2);
+  }
+  if (traceResult.rawTraceEvents && traceResult.rawTraceEvents.length > 0) {
+    const rawJson = JSON.stringify(traceResult.rawTraceEvents);
+    if (rawJson.length < 5 * 1024 * 1024) {
+      files["/trace/runtime/raw-events.json"] = rawJson;
+    } else {
+      const mainTid = traceResult.runtimeTrace?.mainThreadId;
+      const filtered = traceResult.rawTraceEvents.filter((e) => e.tid === mainTid && e.dur && e.dur > 0);
+      const filteredJson = JSON.stringify(filtered);
+      if (filteredJson.length < 5 * 1024 * 1024) {
+        files["/trace/runtime/raw-events.json"] = filteredJson;
+      } else {
+        const important = filtered.filter((e) => (e.dur ?? 0) > 1000);
+        files["/trace/runtime/raw-events.json"] = JSON.stringify(important);
+      }
+    }
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "zeitzeuge-workspace-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const relPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    const fullPath = join(tempDir, relPath);
+    mkdirSync(join(fullPath, ".."), { recursive: true });
+    writeFileSync(fullPath, content, "utf-8");
+  }
+  const backend = new FilesystemBackend({
+    rootDir: tempDir,
+    virtualMode: true
+  });
+  const cleanup = () => {
+    console.log(111, tempDir);
+  };
+  return { backend, cleanup };
+}
+function getAssetPath(req) {
+  let filename;
+  try {
+    const pathname = new URL(req.url).pathname;
+    filename = pathname.split("/").pop() || "index";
+  } catch {
+    filename = "unknown";
+  }
+  switch (req.resourceType) {
+    case "Script":
+      return `/scripts/${filename}`;
+    case "Stylesheet":
+      return `/styles/${filename}`;
+    case "Font":
+      return `/fonts/${filename}`;
+    case "Document":
+      return `/html/${filename}`;
+    default:
+      return `/other/${filename}`;
+  }
+}
+function buildResourceBreakdown(requests) {
+  const groups = {
+    scripts: { count: 0, totalSize: 0 },
+    stylesheets: { count: 0, totalSize: 0 },
+    fonts: { count: 0, totalSize: 0 },
+    images: { count: 0, totalSize: 0 },
+    other: { count: 0, totalSize: 0 }
+  };
+  for (const r of requests) {
+    const key = r.resourceType === "Script" ? "scripts" : r.resourceType === "Stylesheet" ? "stylesheets" : r.resourceType === "Font" ? "fonts" : r.resourceType === "Image" ? "images" : "other";
+    groups[key].count++;
+    groups[key].totalSize += r.decodedSize;
+  }
+  return groups;
+}
+
+// src/output/terminal.ts
+import chalk from "chalk";
+import ora from "ora";
+var SEVERITY_ICONS = {
+  critical: chalk.red("\uD83D\uDD34 CRITICAL"),
+  warning: chalk.yellow("\uD83D\uDFE1 WARNING"),
+  info: chalk.green("\uD83D\uDFE2 INFO")
+};
+var CATEGORY_LABELS = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function printHeader(url, version) {
+  const urlDisplay = url.length > 44 ? url.slice(0, 41) + "..." : url;
+  console.log(chalk.cyan(`
+┌${"─".repeat(57)}┐
+` + `│  zeitzeuge v${version.padEnd(44)}│
+` + `│  Analyzing: ${urlDisplay.padEnd(44)}│
+` + `└${"─".repeat(57)}┘
+`));
+}
+function createSpinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function printFindings(findings) {
+  console.log(chalk.dim(`
+` + "━".repeat(58) + `
+`));
+  if (findings.length === 0) {
+    console.log(chalk.green(`  ✔ No significant performance issues found. Page looks healthy!
+`));
+    console.log(chalk.dim("━".repeat(58)));
+    return;
+  }
+  for (const finding of findings) {
+    const icon = SEVERITY_ICONS[finding.severity];
+    const categoryLabel = CATEGORY_LABELS[finding.category] ?? finding.category;
+    console.log(`${icon} [${categoryLabel}]: ${chalk.bold(finding.title)}`);
+    if (finding.retainedSize != null) {
+      console.log(chalk.dim(`   Retained size: ${formatBytes(finding.retainedSize)}`));
+    }
+    if (finding.impactMs != null) {
+      console.log(chalk.dim(`   Impact: ${finding.impactMs.toFixed(0)}ms`));
+    }
+    if (finding.resourceUrl) {
+      console.log(chalk.dim(`   Resource: ${finding.resourceUrl}`));
+    }
+    if (finding.retainerPath && finding.retainerPath.length > 0) {
+      console.log(chalk.dim(`   Path: ${finding.retainerPath.join(" → ")}`));
+    }
+    if (finding.testFile) {
+      console.log(chalk.dim(`   Test file: ${finding.testFile}`));
+    }
+    if (finding.hotFunction) {
+      const hf = finding.hotFunction;
+      console.log(chalk.dim(`   Function: ${hf.name} at ${hf.scriptUrl}:${hf.lineNumber} (selfTime: ${hf.selfTime.toFixed(0)}ms, ${hf.selfPercent.toFixed(1)}%)`));
+    }
+    console.log(`
+   ${finding.description}
+`);
+    if (finding.suggestedFix) {
+      console.log(chalk.dim("   Suggested fix:"));
+      const lines = finding.suggestedFix.split(`
+`);
+      const boxWidth = Math.max(...lines.map((l) => l.length), 20) + 4;
+      console.log(chalk.dim(`   ┌${"─".repeat(boxWidth)}┐`));
+      for (const line of lines) {
+        console.log(chalk.dim("   │ ") + chalk.white(line.padEnd(boxWidth - 2)) + chalk.dim(" │"));
+      }
+      console.log(chalk.dim(`   └${"─".repeat(boxWidth)}┘`));
+    }
+    console.log();
+  }
+  console.log(chalk.dim("━".repeat(58)));
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  console.log(`
+Summary: ${chalk.red(`${counts.critical} critical`)}, ` + `${chalk.yellow(`${counts.warning} warning`)}, ` + `${chalk.green(`${counts.info} info`)}
+`);
+}
+function printCaptureInfo(heapSummary, trace) {
+  console.log(chalk.dim(`Heap: ${formatBytes(heapSummary.metadata.totalSize)} | ` + `Nodes: ${heapSummary.metadata.nodeCount.toLocaleString()} | ` + `Requests: ${trace.networkRequests.length} | ` + `Long tasks: ${trace.metrics.longTasks.length}`));
+}
+function printError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(chalk.red(`
+✖ Error: ${message}
+`));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/output/report.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+var SEVERITY_EMOJI = {
+  critical: "\uD83D\uDD34",
+  warning: "\uD83D\uDFE1",
+  info: "ℹ️"
+};
+var CATEGORY_LABELS2 = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function writeReport(outputPath, options) {
+  const md = generateMarkdown(options);
+  writeFileSync2(outputPath, md, "utf-8");
+  return outputPath;
+}
+function generateMarkdown(options) {
+  const { url, version, findings, heapSummary, trace } = options;
+  const now = new Date;
+  const sections = [];
+  sections.push(`# Performance Report`);
+  sections.push("");
+  sections.push(`> **${url}** — analyzed ${now.toISOString().replace("T", " ").slice(0, 16)} UTC by zeitzeuge v${version}`);
+  sections.push("");
+  const totalTransfer = trace.networkRequests.reduce((s, r) => s + r.encodedSize, 0);
+  const loadSec = (trace.metrics.loadComplete / 1000).toFixed(1);
+  const fcpSec = (trace.metrics.firstContentfulPaint / 1000).toFixed(2);
+  const tbt = trace.metrics.totalBlockingTime.toFixed(0);
+  const heapSize = formatBytes(heapSummary.metadata.totalSize);
+  const reqCount = trace.networkRequests.length;
+  sections.push(`**Page load** ${loadSec}s · **FCP** ${fcpSec}s · **TBT** ${tbt}ms · ` + `**Heap** ${heapSize} · **${reqCount} requests** (${formatBytes(totalTransfer)} transferred)`);
+  sections.push("");
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  if (findings.length === 0) {
+    sections.push(`## ✅ No issues found`);
+    sections.push("");
+    sections.push(`No significant performance problems were detected. ` + `The page loads in ${loadSec}s with ${tbt}ms of total blocking time — looking healthy.`);
+    sections.push("");
+  } else {
+    sections.push(`**${findings.length} issues found** — ` + `${counts.critical} critical, ${counts.warning} warning, ${counts.info} info`);
+    sections.push("");
+    for (let i = 0;i < findings.length; i++) {
+      const f = findings[i];
+      if (!f)
+        continue;
+      const emoji = SEVERITY_EMOJI[f.severity];
+      const categoryLabel = CATEGORY_LABELS2[f.category] ?? f.category;
+      sections.push(`---`);
+      sections.push("");
+      sections.push(`## ${emoji} ${f.title}`);
+      sections.push("");
+      const context = [`**${categoryLabel}**`];
+      if (f.impactMs != null)
+        context.push(`${f.impactMs.toFixed(0)}ms impact`);
+      if (f.retainedSize != null)
+        context.push(`${formatBytes(f.retainedSize)} retained`);
+      if (f.resourceUrl)
+        context.push(`\`${f.resourceUrl}\``);
+      sections.push(context.join(" · "));
+      sections.push("");
+      sections.push(f.description);
+      sections.push("");
+      if (f.suggestedFix) {
+        sections.push(`### How to fix`);
+        sections.push("");
+        const looksLikeCode = f.suggestedFix.includes("{") || f.suggestedFix.includes(";") || f.suggestedFix.includes("=>") || f.suggestedFix.includes("import ") || f.suggestedFix.includes("function ");
+        if (looksLikeCode) {
+          sections.push("```js");
+          sections.push(f.suggestedFix);
+          sections.push("```");
+        } else {
+          sections.push(f.suggestedFix);
+        }
+        sections.push("");
+      }
+      if (f.retainerPath && f.retainerPath.length > 0) {
+        sections.push(`*Retention path:* ${f.retainerPath.map((p) => `\`${p}\``).join(" → ")}`);
+        sections.push("");
+      }
+    }
+  }
+  sections.push(`---`);
+  sections.push("");
+  sections.push(`*Generated by zeitzeuge v${version}*`);
+  sections.push("");
+  return sections.join(`
+`);
+}
+function writeTestReport(outputPath, options) {
+  const md = generateTestMarkdown(options);
+  writeFileSync2(outputPath, md, "utf-8");
+  return outputPath;
+}
+function generateTestMarkdown(options) {
+  const { version, findings, testTiming, profiles } = options;
+  const now = new Date;
+  const sections = [];
+  sections.push(`# Vitest Performance Report`);
+  sections.push("");
+  sections.push(`> Analyzed ${now.toISOString().replace("T", " ").slice(0, 16)} UTC by zeitzeuge v${version}`);
+  sections.push("");
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const totalFiles = testTiming.length;
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const slowest = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalDuration > 0 ? (totalGcTime / totalDuration * 100).toFixed(2) : "0";
+  sections.push(`**Test run** ${totalTests} tests across ${totalFiles} files · ` + `**Total duration** ${(totalDuration / 1000).toFixed(2)}s · ` + `**Slowest file** ${slowest ? `${slowest.file} (${(slowest.duration / 1000).toFixed(2)}s)` : "—"} · ` + `**GC overhead** ${gcPercentage}% (${totalGcTime.toFixed(0)}ms)`);
+  sections.push("");
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  if (findings.length === 0) {
+    sections.push(`## ✅ No issues found`);
+    sections.push("");
+    sections.push(`No significant performance problems were detected. ` + `Tests complete in ${(totalDuration / 1000).toFixed(2)}s — looking healthy.`);
+    sections.push("");
+  } else {
+    sections.push(`**${findings.length} issues found** — ` + `${counts.critical} critical, ${counts.warning} warning, ${counts.info} info`);
+    sections.push("");
+    for (const f of findings) {
+      const emoji = SEVERITY_EMOJI[f.severity];
+      const categoryLabel = CATEGORY_LABELS2[f.category] ?? f.category;
+      sections.push(`---`);
+      sections.push("");
+      sections.push(`## ${emoji} ${f.title}`);
+      sections.push("");
+      const context = [`**${categoryLabel}**`];
+      if (f.impactMs != null)
+        context.push(`${f.impactMs.toFixed(0)}ms impact`);
+      if (f.testFile)
+        context.push(`\`${f.testFile}\``);
+      if (f.hotFunction) {
+        context.push(`\`${f.hotFunction.name}\` (${f.hotFunction.selfTime.toFixed(0)}ms, ${f.hotFunction.selfPercent.toFixed(1)}%)`);
+      }
+      if (f.resourceUrl)
+        context.push(`\`${f.resourceUrl}\``);
+      sections.push(context.join(" · "));
+      sections.push("");
+      sections.push(f.description);
+      sections.push("");
+      if (f.suggestedFix) {
+        sections.push(`### How to fix`);
+        sections.push("");
+        const looksLikeCode = f.suggestedFix.includes("{") || f.suggestedFix.includes(";") || f.suggestedFix.includes("=>") || f.suggestedFix.includes("import ") || f.suggestedFix.includes("function ");
+        if (looksLikeCode) {
+          sections.push("```ts");
+          sections.push(f.suggestedFix);
+          sections.push("```");
+        } else {
+          sections.push(f.suggestedFix);
+        }
+        sections.push("");
+      }
+    }
+  }
+  sections.push(`---`);
+  sections.push("");
+  sections.push(`*Generated by zeitzeuge v${version}*`);
+  sections.push("");
+  return sections.join(`
+`);
+}
+
+// src/cli.ts
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+function getVersion() {
+  try {
+    const __dirname2 = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version ?? "0.3.0";
+  } catch {
+    return "0.3.0";
+  }
+}
+var VERSION = getVersion();
+var argv = yargs(hideBin(process.argv)).scriptName("zeitzeuge").usage("Usage: $0 <url> [options]").command("$0 <url>", "Analyze frontend performance of a URL", (yargs2) => {
+  return yargs2.positional("url", {
+    describe: "Target URL to analyze (e.g. http://localhost:3000)",
+    type: "string",
+    demandOption: true
+  });
+}).option("verbose", {
+  alias: "v",
+  type: "boolean",
+  default: false,
+  describe: "Enable verbose/debug logging"
+}).option("headless", {
+  type: "boolean",
+  default: true,
+  describe: "Run Chrome in headless mode"
+}).option("timeout", {
+  type: "number",
+  default: 30000,
+  describe: "Page load timeout in milliseconds"
+}).option("output", {
+  alias: "o",
+  type: "string",
+  default: "zeitzeuge-report.md",
+  describe: "Output path for the Markdown report"
+}).help("help", "Show help").alias("h", "help").version(VERSION).strict().parseSync();
+function validateUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error("URL must use http:// or https:// protocol");
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("protocol")) {
+      throw err;
+    }
+    throw new Error(`Invalid URL: "${url}". Please provide a valid URL (e.g. http://localhost:3000)`);
+  }
+}
+async function main() {
+  const url = argv.url;
+  const verbose = argv.verbose;
+  let browser;
+  try {
+    validateUrl(url);
+    printHeader(url, VERSION);
+    if (verbose)
+      console.log("[verbose] Detecting API key and initializing model...");
+    const model = initModel();
+    if (verbose)
+      console.log(`[verbose] Model initialized: ${model.constructor.name}`);
+    const browserSpinner = createSpinner("Launching browser...");
+    try {
+      browser = activeBrowser = await launchBrowser({ headless: argv.headless });
+      browserSpinner.succeed(`Browser launched (${argv.headless ? "headless" : "headed"})`);
+    } catch (err) {
+      browserSpinner.fail("Failed to launch browser");
+      throw new Error(`Could not launch Chrome. Make sure Chrome/Chromium is installed.
+` + `  Install: https://www.google.com/chrome/
+` + (err instanceof Error ? `  Details: ${err.message}` : ""));
+    }
+    const captureSpinner = createSpinner(`Loading ${url} & capturing data...`);
+    let captureResult;
+    try {
+      captureResult = await capturePage(browser, url, {
+        timeout: argv.timeout
+      });
+      const heapSizeMB = (captureResult.heapSnapshot.data.length / (1024 * 1024)).toFixed(1);
+      const reqCount = captureResult.trace.networkRequests.length;
+      const longTaskCount = captureResult.trace.metrics.longTasks.length;
+      const runtimeTraceInfo = captureResult.trace.runtimeTrace ? `
+   Runtime trace: ${captureResult.trace.runtimeTrace.totalEvents.toLocaleString()} events captured` : "";
+      captureSpinner.succeed(`Page loaded in ${(captureResult.trace.metrics.loadComplete / 1000).toFixed(1)}s
+` + `   Heap snapshot: ${heapSizeMB} MB
+` + `   Network requests: ${reqCount} captured
+` + `   Long tasks: ${longTaskCount} detected` + runtimeTraceInfo);
+    } catch (err) {
+      captureSpinner.fail("Failed to capture page data");
+      throw new Error(`Failed to capture data from ${url}.
+` + `  Try running with --no-headless if the page requires interaction.
+` + (err instanceof Error ? `  Details: ${err.message}` : ""));
+    }
+    const parseSpinner = createSpinner("Parsing heap snapshot...");
+    const heapSummary = parseSnapshot(captureResult.heapSnapshot);
+    parseSpinner.succeed(`Parsed: ${heapSummary.metadata.nodeCount.toLocaleString()} nodes, ${heapSummary.metadata.edgeCount.toLocaleString()} edges`);
+    const workspaceSpinner = createSpinner("Building workspace...");
+    let workspace;
+    try {
+      workspace = await createWorkspace({
+        heapSummary,
+        traceResult: captureResult.trace,
+        url
+      });
+      const storedCount = captureResult.trace.networkRequests.filter((r) => r.responseBody).length;
+      const totalSize = captureResult.trace.networkRequests.filter((r) => r.responseBody).reduce((sum, r) => sum + (r.responseBody?.length ?? 0), 0);
+      const runtimeWorkspaceInfo = captureResult.trace.runtimeTrace ? `
+   Runtime trace: summaries + raw events` : "";
+      workspaceSpinner.succeed(`${storedCount} assets stored in workspace (${formatBytes(totalSize)} total)` + runtimeWorkspaceInfo);
+    } catch (err) {
+      workspaceSpinner.fail("Failed to build workspace");
+      throw new Error(`Failed to create workspace.
+` + (err instanceof Error ? `  Details: ${err.message}` : ""));
+    }
+    const agentSpinner = createSpinner("Deep Agent analyzing...");
+    let findings;
+    try {
+      findings = await analyze(model, workspace.backend);
+      agentSpinner.succeed(`Analysis complete — ${findings.length} findings`);
+    } catch (err) {
+      agentSpinner.fail(`Analysis failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      throw new Error(`LLM analysis failed. Check your API key and network connection.
+` + (err instanceof Error ? `  Details: ${err.message}` : ""));
+    } finally {
+      workspace.cleanup();
+    }
+    printFindings(findings);
+    printCaptureInfo(heapSummary, captureResult.trace);
+    const outputPath = argv.output;
+    const reportPath = writeReport(resolve(outputPath), {
+      url,
+      version: VERSION,
+      findings,
+      heapSummary,
+      trace: captureResult.trace
+    });
+    console.log(`
+\uD83D\uDCC4 Report written to ${reportPath}
+`);
+  } catch (err) {
+    printError(err);
+    process.exit(1);
+  } finally {
+    if (browser) {
+      await closeBrowser(browser);
+    }
+  }
+}
+var activeBrowser;
+process.on("SIGINT", async () => {
+  if (activeBrowser) {
+    await closeBrowser(activeBrowser);
+  }
+  process.exit(130);
+});
+main();