zeitzeuge 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Christian Bromann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+<p align="center">
+  <img src=".github/assets/zeitzeuge.png" alt="ZeitZeuge mascot: a detective stopwatch with a magnifying glass witnessing slowdowns" width="220" />
+</p>
+
+# zeitzeuge
+
+AI-powered performance analysis for frontend page loads and Vitest test suites. Captures V8 heap snapshots, performance traces, Chrome runtime traces, and CPU profiles — stores everything in a virtual filesystem and hands it to a Deep Agent that investigates bottlenecks and provides code-level fixes.
+
+> _"Zeuge" = witness — the tool "witnesses" slowdowns in your page loads and test runs._
+
+## Quick start
+
+### Page-load analysis
+
+```bash
+# Set your API key
+export OPENAI_API_KEY=sk-...    # or ANTHROPIC_API_KEY
+
+# Analyze any URL
+npx zeitzeuge http://localhost:3000
+```
+
+### Vitest integration
+
+Add the plugin to your `vitest.config.ts` to profile your test suite and get AI-powered analysis of your **application code** performance:
+
+```ts
+import { defineConfig } from 'vitest/config';
+import { zeitzeuge } from 'zeitzeuge/vitest';
+
+export default defineConfig({
+  plugins: [zeitzeuge()],
+});
+```
+
+Run your tests as usual — zeitzeuge instruments the run with V8 CPU profiling, collects the profiles, and runs a Deep Agent analysis after tests complete:
+
+```bash
+vitest run
+```
+
+A Markdown report is written to `zeitzeuge-report.md` with findings and suggested fixes.
+
+## How it works
+
+### Page-load mode (`npx zeitzeuge <url>`)
+
+1. **Launches Chrome** via WebdriverIO with DevTools Protocol access
+2. **Captures everything in one page load:**
+   - V8 heap snapshot (memory analysis)
+   - Performance trace (network waterfall, long tasks, paint timing)
+   - **Chrome runtime trace** via the [Tracing domain](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/) — every function call, event dispatch, layout, paint, and GC event on the main thread
+   - All network assets (scripts, CSS, HTML source code)
+3. **Builds a VFS workspace** using `@langchain/node-vfs` — an in-memory virtual filesystem containing:
+   - `/heap/summary.json` — parsed heap snapshot data
+   - `/trace/summary.json` — page load timing & metrics
+   - `/trace/runtime/blocking-functions.json` — functions blocking the main thread > 50ms
+   - `/trace/runtime/event-listeners.json` — event listener add/remove imbalances
+   - `/trace/runtime/frame-breakdown.json` — time breakdown: scripting vs layout vs paint vs GC
+   - `/scripts/`, `/styles/`, `/html/` — actual source files
+4. **Deep Agent explores** — a LangChain Deep Agent (`deepagents`) autonomously browses the workspace, reads actual source code, greps for patterns, and correlates heap data with trace data and runtime analysis
+5. **Reports findings** — memory leaks, frame-blocking functions, listener leaks, render-blocking scripts, GC pressure — with code-level fixes
+
+### Vitest mode (`zeitzeuge/vitest` plugin)
+
+1. **Instruments Vitest** — injects `--cpu-prof` into worker process args, forces `pool: 'forks'` for reliable profiling, disables file parallelism for clean per-file profiles
+2. **Captures V8 CPU profiles** for each test file during the test run
+3. **Classifies hot functions** — every profiled function is categorized as `application`, `dependency`, `test`, or `framework` based on its file path relative to your project root
+4. **Builds a VFS workspace** containing:
+   - `/hot-functions/application.json` — hotspots in **your** code (primary focus)
+   - `/hot-functions/dependencies.json` — hotspots in third-party code
+   - `/scripts/application.json` — per-file CPU time for your source files
+   - `/scripts/dependencies.json` — per-file CPU time for dependencies
+   - `/profiles/*.json` — full CPU profile summaries with call trees
+   - `/timing/overview.json` — per-test timing data
+   - `/src/`, `/tests/` — actual source files referenced by hot functions
+5. **Deep Agent analyzes your application code** — focuses on bottlenecks in the code you wrote, not test infrastructure overhead. Reports dependency issues when your code makes expensive calls into libraries.
+
+## What it finds
+
+### Page-load findings
+
+**Memory issues:**
+
+- Memory leaks (unbounded caches, growing arrays/maps)
+- Detached DOM nodes still referenced in JavaScript
+- Large retained objects and closure leaks
+
+**Page-load issues:**
+
+- Render-blocking scripts (`<script>` without `async`/`defer`)
+- Render-blocking stylesheets
+- Long main-thread tasks (> 50ms)
+- Oversized bundles and unused code
+- Sequential waterfall bottlenecks
+
+**Runtime issues:**
+
+- **Frame-blocking functions** — exact function name, script URL, line number, and call stack for any function blocking the main thread > 50ms
+- **Event listener leaks** — `addEventListener` calls without matching `removeEventListener`, growing listener counts
+- **GC pressure** — frequent or long garbage collection pauses indicating memory churn
+- **Layout thrashing** — forced synchronous layouts from reading layout properties after DOM mutations
+
+### Vitest analysis
+
+**Application code bottlenecks:**
+
+- Hot functions with high self time in your source code
+- Expensive algorithms (O(n^2) loops, redundant computation, unnecessary sorting)
+- Object allocation hotspots driving GC pressure
+- Synchronous blocking in hot paths (file I/O, crypto, JSON serialization)
+
+**Dependency bottlenecks:**
+
+- Third-party libraries consuming disproportionate CPU
+- Unnecessary calls to expensive dependency APIs in hot paths
+- Suggestions for alternative libraries or configuration changes
+
+**GC pressure:**
+
+- Functions creating many short-lived objects in tight loops
+- Large allocations that could be pooled or reused
+
+## Vitest plugin options
+
+```ts
+zeitzeuge({
+  // Enable/disable the plugin (default: true)
+  enabled: true,
+
+  // Path for the Markdown report (default: 'zeitzeuge-report.md')
+  output: 'zeitzeuge-report.md',
+
+  // Directory for temporary .cpuprofile files (default: '.zeitzeuge-profiles')
+  profileDir: '.zeitzeuge-profiles',
+
+  // Also write V8 heap profiles (.heapprofile) for workers (default: false)
+  // Uses: --heap-prof + --heap-prof-dir=<profileDir>
+  heapProf: false,
+
+  // Run Deep Agent analysis after tests finish (default: true)
+  analyzeOnFinish: true,
+
+  // Project root for classifying application vs dependency code (default: process.cwd())
+  projectRoot: process.cwd(),
+
+  // Enable debug logging (default: false)
+  verbose: false,
+});
+```
+
+### Heap profiling (`heapProf`) — when to enable it
+
+`heapProf` captures **allocation sampling** (written as `.heapprofile` files) and can help you find:
+
+- Allocation hotspots (functions / modules allocating lots of bytes)
+- High GC pressure caused by excessive short-lived objects
+
+It defaults to **`false`** because it can be a net negative for everyday runs:
+
+- **Overhead**: allocation sampling adds runtime overhead and can skew timings/CPU profiles
+- **Artifact size / IO**: `.heapprofile` files can be large, increasing IO and CI flakiness
+- **Noise**: test runners allocate a lot in setup/framework code; heap data can be less actionable unless you’re specifically chasing allocations/GC
+
+Recommendation: keep it off by default and enable it when you suspect **allocation/GC issues** or when CPU hotspots alone aren’t explaining slow tests.
+
+## CLI options
+
+```text
+zeitzeuge <url> [options]
+
+Options:
+  --verbose, -v   Enable verbose/debug logging       [boolean] [default: false]
+  --headless      Run Chrome in headless mode         [boolean] [default: true]
+  --timeout       Page load timeout in milliseconds   [number]  [default: 30000]
+  --help, -h      Show help                           [boolean]
+  --version       Show version number                 [boolean]
+```
+
+## Environment variables
+
+| Variable            | Description                                                     |
+| ------------------- | --------------------------------------------------------------- |
+| `OPENAI_API_KEY`    | OpenAI API key (preferred)                                      |
+| `ANTHROPIC_API_KEY` | Anthropic API key (fallback)                                    |
+| `ZEITZEUGE_MODEL`   | Override model name (e.g. `gpt-4o`, `claude-sonnet-4-20250514`) |
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development
+bun run dev -- http://localhost:3000
+
+# Run tests
+bun test
+
+# Build for distribution
+bun run build
+```
+
+## Tech stack
+
+- **Runtime:** [Bun](https://bun.sh) (works across JS runtimes)
+- **Browser automation:** [WebdriverIO](https://webdriver.io) + Chrome DevTools Protocol
+- **Runtime tracing:** [CDP Tracing domain](https://chromedevtools.github.io/devtools-protocol/tot/Tracing/) for function-level main-thread analysis
+- **V8 CPU profiling:** `--cpu-prof` for per-function timing in test suites
+- **AI analysis:** [Deep Agents](https://docs.langchain.com/oss/javascript/deepagents/overview) + [LangChain](https://langchain.com)
+- **Virtual filesystem:** [@langchain/node-vfs](https://docs.langchain.com/oss/javascript/integrations/providers/node-vfs) — in-memory VFS sandbox
+- **LLM providers:** OpenAI, Anthropic (auto-detected from environment)

package/dist/analysis/agent.d.ts

@@ -0,0 +1,19 @@
+import { type BackendProtocol } from 'deepagents';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { Finding } from '../types.js';
+/**
+ * Analyze performance data using a Deep Agent that explores
+ * the workspace containing heap + trace data + source files.
+ */
+export declare function analyze(model: BaseChatModel, backend: BackendProtocol): Promise<Finding[]>;
+/**
+ * Analyze Vitest test performance data using a Deep Agent that explores
+ * the workspace containing CPU profiles + test timing + source files.
+ */
+export declare function analyzeTestPerformance(model: BaseChatModel, backend: BackendProtocol): Promise<Finding[]>;
+/**
+ * Format bytes into a human-readable string.
+ * Kept for backwards compatibility with existing imports.
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=agent.d.ts.map

package/dist/analysis/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/analysis/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAEnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAKjF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;GAGG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAkChG;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,OAAO,EAAE,CAAC,CA8BpB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/dist/analysis/parser.d.ts

@@ -0,0 +1,3 @@
+import type { RawSnapshot, HeapSummary } from '../types.js';
+export declare function parseSnapshot(rawSnapshot: RawSnapshot): HeapSummary;
+//# sourceMappingURL=parser.d.ts.map

package/dist/analysis/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/analysis/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EAMZ,MAAM,aAAa,CAAC;AA6BrB,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAyVnE"}

package/dist/analysis/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare const 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.\n\n## Workspace structure\n\n- /heap/summary.json \u2014 Parsed V8 heap snapshot: largest objects, type stats, constructor stats, detached DOM nodes, closure stats\n- /trace/summary.json \u2014 Page load metrics: timing, long tasks, render-blocking resources, resource breakdown\n- /trace/network-waterfall.json \u2014 Every network request with timing, size, priority, render-blocking status\n- /trace/asset-manifest.json \u2014 Index of all assets with paths to stored files\n- /trace/runtime/summary.json \u2014 Runtime trace overview: frame breakdown (scripting/layout/paint/GC), blocking function count, listener imbalances, GC stats\n- /trace/runtime/blocking-functions.json \u2014 Functions that blocked the main thread > 50ms, with script URL, line number, call stack, and duration\n- /trace/runtime/event-listeners.json \u2014 Event listener add/remove counts per event type, with source locations\n- /trace/runtime/frame-breakdown.json \u2014 Time spent in scripting vs layout vs paint vs GC\n- /trace/runtime/raw-events.json \u2014 Full Chrome trace events (large file \u2014 read to investigate specific function calls, layouts, GC, and event dispatches)\n- /scripts/*.js \u2014 Actual JavaScript source files captured during page load\n- /styles/*.css \u2014 Actual CSS source files\n- /html/document.html \u2014 The HTML document\n\n## Your workflow\n\n1. Read /heap/summary.json, /trace/summary.json, AND /trace/runtime/summary.json first for the big picture\n2. Identify the highest-impact issues from all datasets\n3. For each issue, dive into the relevant source files to understand the root cause\n4. Provide specific, code-level fixes\n\n## What to look for\n\n### Memory issues (from heap data)\n- Memory leaks: unbounded arrays, maps, caches that grow without bound\n- Detached DOM nodes: DOM elements removed from the document but still referenced\n- Large retained objects: single objects or trees retaining disproportionate memory\n- Closure leaks: closures capturing variables they no longer need\n\n### Page-load issues (from trace + source code)\n- Render-blocking scripts: <script> in <head> without async/defer \u2014 read the script to judge if it must be synchronous\n- Render-blocking CSS: large stylesheets blocking first paint\n- Long tasks (> 50ms): identify the function/module causing the block by reading the source\n- Large bundles: scripts > 100KB \u2014 search for unused imports or code that could be lazy-loaded\n- Sequential waterfalls: resources chained sequentially that could load in parallel\n\n### Runtime issues (from Chrome trace)\n- 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\n- Event listener leaks: check /trace/runtime/event-listeners.json for event types where addCount >> removeCount, then grep the scripts for those addEventListener calls\n- GC pressure: high GC pause counts or duration suggest excessive short-lived object creation \u2014 look for hot loops creating objects\n- Layout thrashing: forced synchronous layouts caused by reading layout properties (offsetHeight, getBoundingClientRect) after DOM writes\n\n## Output guidelines\n\n- Report 3\u20137 findings, ordered by impact (mix of memory, page-load, and runtime if all have issues)\n- Be specific \u2014 name actual files, functions, object constructors, and retention paths\n- Provide concrete code fixes, not generic advice\n- If heap, trace, and runtime all look healthy, say so \u2014 don't manufacture issues";
+//# sourceMappingURL=prompts.d.ts.map

package/dist/analysis/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/analysis/prompts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,ytHAkDwD,CAAC"}

package/dist/browser/capture.d.ts

@@ -0,0 +1,14 @@
+import type { Browser } from 'webdriverio';
+import type { CaptureResult, CaptureOptions } from '../types.js';
+/**
+ * Capture both a heap snapshot and a performance trace from a single page load.
+ *
+ * Flow:
+ * 1. Set up network interception + performance tracing BEFORE navigation
+ * 2. Navigate to URL and wait for load
+ * 3. Wait for settle period (2s) to catch late-firing long tasks
+ * 4. Stop tracing and collect network data
+ * 5. Take heap snapshot (after page is loaded + settled)
+ */
+export declare function capturePage(browser: Browser, url: string, options?: CaptureOptions): Promise<CaptureResult>;
+//# sourceMappingURL=capture.d.ts.map

package/dist/browser/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../src/browser/capture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGjE;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAwDxB"}

package/dist/browser/launch.d.ts

@@ -0,0 +1,6 @@
+import { type Browser } from 'webdriverio';
+import type { LaunchOptions } from '../types.js';
+export type { Browser } from 'webdriverio';
+export declare function launchBrowser(options?: LaunchOptions): Promise<Browser>;
+export declare function closeBrowser(browser: Browser): Promise<void>;
+//# sourceMappingURL=launch.d.ts.map

package/dist/browser/launch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/browser/launch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBjF;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAMlE"}

package/dist/browser/runtime-trace.d.ts

@@ -0,0 +1,52 @@
+import type { TraceEvent, BlockingFunction, EventListenerInfo, FrameBreakdown, GCEvent, RuntimeTraceSummary } from '../types.js';
+/**
+ * Parse raw Chrome trace events into a structured RuntimeTraceSummary.
+ *
+ * @param traceEvents - Array of Chrome trace events from Tracing.dataCollected
+ * @param navigationStartTs - Navigation start timestamp in microseconds (from trace)
+ */
+export declare function parseRuntimeTrace(traceEvents: TraceEvent[], navigationStartTs: number): RuntimeTraceSummary;
+/**
+ * Identify the main renderer thread (CrRendererMain).
+ *
+ * Strategy:
+ * 1. Look for __metadata thread_name event with args.name === "CrRendererMain"
+ * 2. Fallback: thread with the most FunctionCall events
+ * 3. Return 0 if no events
+ */
+export declare function findMainThread(events: TraceEvent[]): number;
+/**
+ * Extract function calls that block the main thread (> 50ms).
+ *
+ * Looks for "FunctionCall" and "EvaluateScript" events with phase "X" (complete)
+ * and duration > 50ms. Extracts function name, script URL, line number, and call stack.
+ */
+export declare function extractBlockingFunctions(mainEvents: TraceEvent[], navigationStartTs: number): BlockingFunction[];
+/**
+ * Extract event listener dispatch patterns.
+ *
+ * Groups EventDispatch events by event type and counts dispatches.
+ * Also collects source location information.
+ */
+export declare function extractEventListenerInfo(mainEvents: TraceEvent[]): EventListenerInfo[];
+/**
+ * Build a frame time breakdown from main-thread events.
+ *
+ * Categorises all events with duration into: scripting, layout, painting, gc, other.
+ * All values are in milliseconds.
+ */
+export declare function buildFrameBreakdown(mainEvents: TraceEvent[]): FrameBreakdown;
+/**
+ * Extract GC events (MajorGC, MinorGC) with timing and heap size data.
+ */
+export declare function extractGCEvents(mainEvents: TraceEvent[], navigationStartTs: number): GCEvent[];
+/**
+ * Find frequently dispatched events (> 10 dispatches of the same type).
+ * High-frequency dispatches without throttle/debounce indicate potential issues.
+ */
+export declare function findFrequentEvents(mainEvents: TraceEvent[]): Array<{
+    eventType: string;
+    count: number;
+    totalDuration: number;
+}>;
+//# sourceMappingURL=runtime-trace.d.ts.map

package/dist/browser/runtime-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-trace.d.ts","sourceRoot":"","sources":["../../src/browser/runtime-trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,OAAO,EACP,mBAAmB,EACpB,MAAM,aAAa,CAAC;AA4BrB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,UAAU,EAAE,EACzB,iBAAiB,EAAE,MAAM,GACxB,mBAAmB,CAkCrB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAwB3D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EAAE,EACxB,iBAAiB,EAAE,MAAM,GACxB,gBAAgB,EAAE,CA6CpB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,iBAAiB,EAAE,CAkDtF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,cAAc,CAmC5E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,EAAE,CAkB9F;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EAAE,GACvB,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CA4BpE"}

package/dist/browser/trace.d.ts

@@ -0,0 +1,8 @@
+import type { TraceHandle, CaptureOptions } from '../types.js';
+/**
+ * Start tracing page load on a CDP session.
+ * Call this BEFORE navigation so it captures everything from the start.
+ * Returns a TraceHandle — call `stop()` after the page has loaded and settled.
+ */
+export declare function tracePageLoad(cdpSession: any, _options?: CaptureOptions): Promise<TraceHandle>;
+//# sourceMappingURL=trace.d.ts.map

package/dist/browser/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/browser/trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAMV,WAAW,EACX,cAAc,EAEf,MAAM,aAAa,CAAC;AA8BrB;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,GAAG,EACf,QAAQ,GAAE,cAAmB,GAC5B,OAAO,CAAC,WAAW,CAAC,CA4NtB"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}