craftdriver 1.1.1 → 1.3.0

package/docs/api-reference.md

@@ -82,6 +82,7 @@ Capture console output, JavaScript errors, and trace artifacts.
 | `JavaScriptError` | type | — | [browser-logs](browser-logs.md) |
 | `LogMessage` | type | — | [browser-logs](browser-logs.md) |
 | `TraceStartOptions` | type | — | [tracing](tracing.md) |
+| `TraceStopOptions` | type | — | [tracing](tracing.md) |
 | `TraceScreenshotMode` | type | Screenshot mode for tracing. | [tracing](tracing.md) |
 | `TraceEvent` | type | — | [tracing](tracing.md) |
 
@@ -130,4 +131,4 @@ Handle stable CraftDriver errors or customize browser driver services.
 | `FirefoxService` | class | — | [getting-started](getting-started.md) |
 | `FirefoxServiceOptions` | type | — | [getting-started](getting-started.md) |
 
-Total exports: **60**.
+Total exports: **61**.

package/docs/browser-api.md

@@ -29,7 +29,6 @@ const browser = await Browser.launch({
 |--------|------|---------|-------------|
 | `browserName` | `'chrome' \| 'chromium' \| 'firefox'` | `'chrome'` | Browser to launch |
 | `enableBiDi` | `boolean` | `true` | Use WebDriver BiDi. Set `false` only when running against a browser that does not support it — every BiDi-only feature then throws a `requires BiDi` error if called. |
-| `captureLogs` | `boolean` | `false` | Start console/error log capture immediately at launch instead of lazily on first `browser.logs`/`onConsole`/`onError`/`waitForConsole` touch. See [Console Logs And JavaScript Errors](./browser-logs.md). |
 | `storageState` | `string` | — | Path to a session-state JSON file to load on startup |
 | `mobileEmulation` | `MobileEmulation \| DeviceName` | — | Mobile device emulation settings (Chrome/Chromium only) |
 | `downloadsDir` | `string` | temp dir | Directory where downloaded files are saved |

package/docs/browser-logs.md

@@ -12,35 +12,20 @@ emitted a known log message.
 
 ## Capture Timing
 
-Capture is lazy by default. CraftDriver subscribes to log events the first time
-you touch `browser.logs.onLog()`, `.onConsole()`, `.onError()`, `.on()`,
-`.waitForConsole()`, or `.waitForError()`.
-
-Messages emitted before that first touch are not captured, so this can return an
-empty array:
+Capture is automatic. CraftDriver subscribes to log events at launch, so
+messages emitted at any point — including during the first navigation, before you
+ever touch `browser.logs` — are captured. There is nothing to enable and no
+listener to pre-arm:
 
 ```typescript
 await browser.navigateTo('https://example.com');
-const messages = browser.logs.getMessages();
-```
-
-Start capture before the action that logs:
-
-```typescript
-const warning = browser.logs.waitForConsole((msg) => msg.level === 'warn');
-
 await browser.getByRole('button', { name: 'Show warning' }).click();
-expect((await warning).text).toContain('Heads up');
+const messages = browser.logs.getMessages(); // includes the warning
 ```
 
-Or start capture immediately at launch:
-
-```typescript
-const browser = await Browser.launch({
-  browserName: 'chrome',
-  captureLogs: true,
-});
-```
+The subscription rides the connect-time batch, so it costs no extra round trip
+and no measurable overhead. Use `clearLogs()` if you want to assert only on
+messages emitted after a certain point.
 
 ## Read Collected Messages
 

package/docs/mcp.md

@@ -53,7 +53,7 @@ goose configure   # add craftdriver as a stdio server
 
 ## Tools
 
-Compact set — 14 tools, one line each. Long help lives in the schema
+Compact set — 15 tools, one line each. Long help lives in the schema
 description; clients render it in the model's context once per session.
 
 | Tool                     | Purpose                                                                |
@@ -70,11 +70,25 @@ description; clients render it in the model's context once per session.
 | `browser_pages`          | List open pages (id, url, title).                                      |
 | `browser_snapshot`       | **Sanitized DOM summary with refs.** Use `ref=eN` as the selector for subsequent calls. |
 | `browser_screenshot`     | Capture PNG to a file (auto-allocated under the per-session artifact dir; never inlined). |
+| `browser_trace`          | Start/stop tracing and export a Vibium Player compatible zip.            |
 | `browser_status`         | Browser up? Which URL is active?                                       |
 | `browser_advanced_eval`  | Evaluate JS in the page. Last resort.                                  |
 
-`browser_trace` (start/stop/explain) and trace resources are slated
-for a future release alongside richer trace introspection.
+Trace a complete agent-driven session with two calls:
+
+```jsonc
+{ "name": "browser_trace", "arguments": {
+  "action": "start", "out_dir": "./traces/agent-raw", "title": "Agent flow"
+} }
+// ...browser_navigate / browser_fill / browser_click calls...
+{ "name": "browser_trace", "arguments": {
+  "action": "stop", "path": "./traces/agent-flow.zip"
+} }
+```
+
+The zip opens at [player.vibium.dev](https://player.vibium.dev/). The raw
+directory remains available if the MCP client disconnects before the stop
+call; in that case there is no finalized zip.
 
 ## Selector syntax
 

package/docs/public/recipes/trace-failing-test.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="refresh" content="0; url=./debug-failing-tests-with-traces">
+    <link
+      rel="canonical"
+      href="https://dtopuzov.github.io/craftdriver/recipes/debug-failing-tests-with-traces"
+    >
+    <title>Vitest traces moved</title>
+    <script>location.replace('./debug-failing-tests-with-traces')</script>
+  </head>
+  <body>
+    <p>This recipe moved to <a href="./debug-failing-tests-with-traces">Debug With Traces</a>.</p>
+  </body>
+</html>

package/docs/public/recipes/vitest-vibium-trace.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="refresh" content="0; url=./debug-failing-tests-with-traces">
+    <link
+      rel="canonical"
+      href="https://dtopuzov.github.io/craftdriver/recipes/debug-failing-tests-with-traces"
+    >
+    <title>Vitest trace recipe moved</title>
+    <script>location.replace('./debug-failing-tests-with-traces')</script>
+  </head>
+  <body>
+    <p>This recipe moved to <a href="./debug-failing-tests-with-traces">Debug With Traces</a>.</p>
+  </body>
+</html>

package/docs/recipes/console-error-gate.md

@@ -1,17 +1,14 @@
 # Fail On Console And JavaScript Errors
 
 A flow can look correct in the DOM while quietly throwing in the console — a
-failed fetch, an undefined access, a rejected promise. Capture logs at launch,
-run the flow, then assert no JavaScript errors were reported so those failures
-break the test instead of reaching users. This recipe uses the live
+failed fetch, an undefined access, a rejected promise. Logs are captured
+automatically from launch, so you can run the flow and then assert no JavaScript
+errors were reported, breaking the test instead of reaching users. This recipe
+uses the live
 [console errors example](https://dtopuzov.github.io/craftdriver/examples/console-errors.html).
-It enables `captureLogs` at launch, so it shows the `launch` call.
 
 ```ts
-const browser = await Browser.launch({
-  browserName: 'chrome',
-  captureLogs: true,
-});
+const browser = await Browser.launch();
 
 await browser.navigateTo('https://dtopuzov.github.io/craftdriver/examples/console-errors.html');
 browser.logs.clearLogs();
@@ -38,7 +35,7 @@ await logged;
 
 ## Notes
 
-- `assertNoErrors()` checks captured JavaScript errors, so keep `captureLogs: true`.
+- `assertNoErrors()` checks captured JavaScript errors — capture is automatic, nothing to enable.
 - Call `clearLogs()` before the flow so errors from earlier tests don't bleed in.
 - Use `waitForConsole()` / `waitForError()` when a specific message is the thing you're asserting.
 

package/docs/recipes/debug-failing-tests-with-traces.md

@@ -0,0 +1,117 @@
+# Use Traces To Debug Failing Tests
+
+A failed assertion tells you what was wrong at the end of a test, but often not
+how the browser got there. A trace preserves the actions, screenshots, console
+and JavaScript events, navigation, and network activity that led to the
+failure.
+
+## A Shared Trace Format
+
+[Jason Huggins' SeleniumConf talk](https://www.youtube.com/watch?v=c-OGZK3F0tk&t=1530s)
+was one of the reasons Craftdriver adopted portable browser traces instead of
+a Craftdriver-only viewer format.
+
+The exported zip follows the Playwright-style
+recording layout also used by tools like
+[Vibium](https://github.com/VibiumDev/vibium/blob/main/docs/explanation/recording-format.md)
+and WDIO, so the same artifact can be opened in viewers such as
+[Vibium Player](https://player.vibium.dev/).
+
+Craftdriver still records a crash-resilient raw NDJSON trace first, then
+packages it into the shared zip format when a test runner asks for an artifact.
+
+## Keep A Trace When A Vitest Test Fails
+
+Start one browser for the suite, but scope tracing to the test hooks.
+`afterEach()` knows whether the test failed, so it can keep only the useful zip:
+
+```ts
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it } from 'vitest';
+import { rmSync } from 'node:fs';
+import path from 'node:path';
+import { Browser } from 'craftdriver';
+
+describe('login', () => {
+  let browser: Browser;
+  const rawTraceDir = path.resolve('test-results/traces/login-raw');
+  const traceZip = path.resolve('test-results/traces/login-failure.zip');
+
+  beforeAll(async () => {
+    browser = await Browser.launch();
+  });
+
+  beforeEach(async () => {
+    await browser.startTrace({
+      outDir: rawTraceDir,
+      title: 'Failing login test',
+    });
+  });
+
+  afterEach(async ({ task }) => {
+    const failed = task.result?.state === 'fail';
+    await browser.stopTrace(failed ? { path: traceZip } : undefined);
+    if (!failed) rmSync(rawTraceDir, { recursive: true, force: true });
+  });
+
+  afterAll(async () => browser.quit());
+
+  it('fills and submits the login form', async () => {
+    await browser.navigateTo(
+      'https://dtopuzov.github.io/craftdriver/examples/login.html',
+    );
+    await browser.fill('#username', 'alice');
+    await browser.fill('#password', 'secret');
+    await browser.click('#submit');
+    await browser.expect('#welcome').toContainText('Welcome back, alice!');
+  });
+});
+```
+
+A passing run removes the raw trace and leaves no artifact. After a normal
+Vitest failure, the evidence is kept here:
+
+```text
+test-results/
+└── traces/
+    ├── login-raw/              # trace.ndjson and evidence screenshots
+    └── login-failure.zip       # open this in Vibium Player
+```
+
+For the best online experience, drop the zip into
+[Vibium Player](https://player.vibium.dev/). To keep the trace entirely local,
+use Playwright Trace Viewer:
+
+```sh
+npx playwright show-trace test-results/traces/login-failure.zip
+```
+
+Craftdriver includes screenshot-backed frame snapshots, so Playwright's main
+browser panel shows the captured page state. It is a visual snapshot rather
+than a restorable DOM, so the DOM/locator inspector is intentionally limited.
+
+If the test process is killed before `afterEach()` runs, a zip cannot be
+finalized, but the append-only `trace.ndjson` and completed screenshots remain
+in `login-raw/`.
+
+## Try A Trace Before Creating A Failure
+
+1. [Download the sample login trace](https://dtopuzov.github.io/craftdriver/traces/vitest-login.zip).
+2. Open [Vibium Player](https://player.vibium.dev/).
+3. Drop `vitest-login.zip` onto the player and step through the login.
+
+`stopTrace()` captures the final page state, so a failed assertion is visible
+as the last player frame. The sample was generated by the runnable Vitest proof
+for this recipe against the same published login page. To exercise the failure
+workflow yourself, change the expected message to `Welcome back, bob!`, run the
+test, and open the resulting `login-failure.zip`.
+
+Trace files can contain screenshots, URLs, console messages, network metadata,
+selectors, and entered values. Use test credentials and review a trace before
+publishing it outside your team.
+
+## Learn More
+
+- [Tracing](../tracing.md)
+- [Use CraftDriver With Vitest Hooks](./vitest-browser-lifecycle.md)
+- [Vibium Player](https://player.vibium.dev/)
+- [Jason Huggins on standardized tracing](https://www.youtube.com/watch?v=c-OGZK3F0tk&t=1530s)

package/docs/recipes/file-upload-download.md

@@ -10,10 +10,7 @@ then downloads a report from the
 It sets `downloadsDir` at launch, so it shows the `launch` call.
 
 ```ts
-const browser = await Browser.launch({
-  browserName: 'chrome',
-  downloadsDir: '.tmp/downloads',
-});
+const browser = await Browser.launch({ downloadsDir: '.tmp/downloads' });
 
 await browser.navigateTo('https://dtopuzov.github.io/craftdriver/examples/upload.html');
 await browser.find('#file-input').setInputFiles('tests/fixtures/sample.txt');

package/docs/recipes/login-once-reuse-session.md

@@ -15,7 +15,7 @@ Run this once as a setup step. It is one of the few recipes that shows
 ```ts
 import { Browser } from 'craftdriver';
 
-const browser = await Browser.launch({ browserName: 'chrome' });
+const browser = await Browser.launch();
 
 await browser.navigateTo('https://dtopuzov.github.io/craftdriver/examples/login.html');
 await browser.getByLabel('Username').fill('alice');
@@ -32,10 +32,7 @@ await browser.quit();
 Launch with `storageState` and the browser starts already signed in.
 
 ```ts
-const browser = await Browser.launch({
-  browserName: 'chrome',
-  storageState: '.auth/alice.json',
-});
+const browser = await Browser.launch({ storageState: '.auth/alice.json' });
 
 await browser.navigateTo('https://dtopuzov.github.io/craftdriver/examples/login.html');
 await browser.expect('#welcome').toContainText('Welcome back, alice!');

package/docs/recipes/mobile-flow-with-network-and-logs.md

@@ -9,11 +9,7 @@ Because mobile emulation is a launch-time capability, this recipe shows the
 `launch` call.
 
 ```ts
-const browser = await Browser.launch({
-  browserName: 'chrome', // mobile emulation is Chrome/Chromium only
-  mobileEmulation: 'Pixel 7',
-  captureLogs: true,
-});
+const browser = await Browser.launch({ mobileEmulation: 'Pixel 7' });
 
 // ?bidi=true makes the demo page issue real requests for interception.
 await browser.navigateTo('https://dtopuzov.github.io/craftdriver/examples/network.html?bidi=true');
@@ -33,7 +29,7 @@ browser.logs.assertNoErrors();
 
 - Mobile emulation is currently Chrome/Chromium only.
 - Mock before the action if the page reads data during that step.
-- Keep `captureLogs: true` so `assertNoErrors()` has something to check.
+- Console/error capture is automatic, so `assertNoErrors()` always has the full picture.
 
 ## Learn More
 

package/docs/recipes/vitest-browser-lifecycle.md

@@ -16,10 +16,7 @@ describe('login page', () => {
   let browser: Browser;
 
   beforeAll(async () => {
-    browser = await Browser.launch({
-      browserName: 'chrome',
-      captureLogs: true,
-    });
+    browser = await Browser.launch();
   });
 
   beforeEach(async () => {

package/docs/recipes.md

@@ -49,4 +49,4 @@ For exact signatures, use the linked feature docs and the
 | ----------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
 | Accessibility regression gate | CI should fail on serious page or component accessibility issues.               | [Run Accessibility Gates](./recipes/accessibility-gate.md)               |
 | Console and JavaScript errors | Tests should fail if the browser reports unexpected client-side errors.         | [Fail On Console And JavaScript Errors](./recipes/console-error-gate.md) |
-| Evidence on failure           | You want a replayable trail of actions, network, logs, errors, and screenshots. | [Capture Failure Evidence With Tracing](./recipes/trace-failing-test.md) |
+| Debug failing tests           | You need the actions, screenshots, logs, and network activity behind a failure. | [Use Traces To Debug Failing Tests](./recipes/debug-failing-tests-with-traces.md) |

package/docs/tracing.md

@@ -14,7 +14,7 @@ process crash cannot lose the evidence that led up to it.
 ```ts
 import { chromium } from 'craftdriver';
 
-const browser = await chromium.launch({ enableBiDi: true });
+const browser = await chromium.launch();
 
 await browser.startTrace({ outDir: './artefacts/login' });
 try {
@@ -39,6 +39,50 @@ artefacts/login/
 `try/finally` is the recommended shape, but it's a courtesy — see the
 next section.
 
+## Export for Vibium Player
+
+Pass a zip path when stopping the trace to create a portable recording that
+opens in [Vibium Player](https://player.vibium.dev/) and Playwright Trace
+Viewer:
+
+```ts
+await browser.startTrace({
+  outDir: './artefacts/login-raw',
+  title: 'Login flow',
+});
+
+try {
+  await browser.navigateTo('https://example.com/login');
+  await browser.fill('#user', 'alice');
+  await browser.click('#submit');
+} finally {
+  await browser.stopTrace({ path: './artefacts/login.zip' });
+}
+```
+
+The raw `trace.ndjson` remains the crash-resilient source. The zip is produced
+during `stopTrace()` and contains the Vibium/Playwright layout:
+
+```text
+login.zip
+├── trace.trace       # context-options + before/after actions + browser events
+├── trace.network     # HAR-style resource-snapshot events
+└── resources/        # PNG frames referenced by screencast-frame events
+```
+
+Vibium Player is the recommended online viewer. For local-only inspection:
+
+```sh
+npx playwright show-trace ./artefacts/login.zip
+```
+
+The export includes Craftdriver actions, screenshots, screenshot-backed frame
+snapshots, navigation/console events, and the network metadata that WebDriver
+BiDi exposes to the tracer. Screenshot-backed snapshots make the main panel of
+Playwright Trace Viewer useful while staying honest: they are not a restorable
+DOM. Response bodies and source files remain future work. Browser action spans
+use real start/end times and preserve thrown action errors.
+
 ## What happens when a test throws
 
 Every recorded event hits disk **before** the next line of your test
@@ -70,13 +114,14 @@ since `startTrace`) and a `type`:
 | `type`         | Fields                                                      |
 | -------------- | ----------------------------------------------------------- |
 | `meta`         | `startedAt` / `endedAt`, `opts` on the start line           |
-| `action`       | `name`, `args?`, `selector?`                                |
+| `action`       | `actionIndex`, `name`, `args?`, `selector?`                 |
+| `action-end`   | `actionIndex`, `error?`                                     |
 | `console`      | `level`, `text`                                             |
 | `error`        | `text` (uncaught page errors)                               |
 | `request`      | `url`, `method`, `requestId?`                               |
 | `response`     | `url`, `status`, `mimeType?`, `fromCache?`, `requestId?`    |
 | `navigation`   | `url`, `context?`                                           |
-| `screenshot`   | `file` (relative path), `reason` (`'action'` \| `'error'`), `actionIndex?` |
+| `screenshot`   | `file` (relative path), `reason` (`'action'` \| `'error'` \| `'final'`), `actionIndex?` |
 
 Actions currently logged: `navigateTo`, `goBack`, `goForward`, `reload`,
 `setContent`, `click`, `fill`, `clear`, `acceptDialog`, `dismissDialog`.
@@ -88,6 +133,8 @@ Screenshots are tied to **meaningful moments**, not a timer:
 * Before every logged action — answers *"what did the page look like
   when I clicked?"*
 * On every page error — answers *"what was on screen when it broke?"*
+* Once when `stopTrace()` runs — preserves the state left by the final action
+  or failed assertion.
 
 A 30-second test with 5 clicks produces 5 PNGs, not 300. Turn it off
 when you only want the JSON log:
@@ -149,7 +196,7 @@ Drop this into your test folder (e.g. `tests/auto-trace.ts`):
 
 ```ts
 import { beforeEach, afterEach } from 'vitest';
-import { rmSync, writeFileSync } from 'node:fs';
+import { rmSync } from 'node:fs';
 import { join } from 'node:path';
 import type { Browser, TraceScreenshotMode } from 'craftdriver';
 
@@ -170,19 +217,15 @@ export function autoTrace(getBrowser: () => Browser): void {
 
   afterEach(async ({ task }) => {
     const failed = task.result?.state === 'fail';
-    // Snap the page as it looked at the failed assertion (not just
-    // before the last click).
-    if (failed) {
-      try {
-        const buf = await getBrowser().screenshot();
-        writeFileSync(join(currentDir, 'final.png'), buf);
-      } catch { /* browser may already be dead */ }
-    }
-    try { await getBrowser().stopTrace(); } catch { return; }
+    const keep = MODE === 'always' || failed;
+    const zipPath = `${currentDir}.zip`;
+    try {
+      await getBrowser().stopTrace(keep ? { path: zipPath } : undefined);
+    } catch { return; }
     if (MODE === 'on-failure' && !failed) {
       rmSync(currentDir, { recursive: true, force: true });
     } else if (failed) {
-      console.error(`  📁 trace: ${currentDir}`);
+      console.error(`  📦 Vibium trace: ${zipPath}`);
     }
   });
 }
@@ -202,7 +245,7 @@ import { autoTrace } from './auto-trace';
 
 describe('Login', () => {
   let browser: Browser;
-  beforeAll(async () => { browser = await Browser.launch({ enableBiDi: true }); });
+  beforeAll(async () => { browser = await Browser.launch(); });
   afterAll(async () => { await browser.quit(); });
 
   autoTrace(() => browser);   // ← that's it
@@ -211,7 +254,7 @@ describe('Login', () => {
     await browser.navigateTo('http://127.0.0.1:8080/login.html');
     await browser.fill('#user', 'alice');
     await browser.click('#submit');
-    // If this expect throws, ./traces/login/signs-in/trace.ndjson is on disk.
+    // If this expect throws, ./traces/login/signs-in.zip opens in Vibium Player.
   });
 });
 ```
@@ -238,6 +281,42 @@ craftdriver — and the runner-specific glue (pass/fail detection, hook
 order, output paths) belongs on your side. The helper is ~30 lines you
 can read, copy, and adjust to your team's conventions.
 
+### One trace for the whole suite
+
+If the desired boundary is exactly `beforeAll()` → `afterAll()`, record the
+suite continuously and remember failures in `afterEach()`. A passing suite
+does not create a zip; a failing suite does:
+
+```ts
+import { afterAll, afterEach, beforeAll, describe } from 'vitest';
+import { rmSync } from 'node:fs';
+import { Browser } from 'craftdriver';
+
+describe('checkout', () => {
+  let browser: Browser;
+  let failed = false;
+  const rawDir = './traces/checkout-raw';
+  const zipPath = './traces/checkout-failure.zip';
+
+  beforeAll(async () => {
+    browser = await Browser.launch();
+    await browser.startTrace({ outDir: rawDir, title: 'Checkout suite' });
+  });
+
+  afterEach(({ task }) => {
+    failed ||= task.result?.state === 'fail';
+  });
+
+  afterAll(async () => {
+    await browser.stopTrace(failed ? { path: zipPath } : undefined);
+    if (!failed) rmSync(rawDir, { recursive: true, force: true });
+    await browser.quit();
+  });
+
+  // ...tests...
+});
+```
+
 ## API
 
 ### `browser.startTrace(opts)`
@@ -249,6 +328,7 @@ interface TraceStartOptions {
   network?: boolean;                            // default true
   console?: boolean;                            // default true
   screenshots?: boolean | 'auto' | 'off';       // default 'auto'
+  title?: string;                                // viewer title
 }
 ```
 
@@ -256,11 +336,12 @@ Creates `outDir` if missing, opens `outDir/trace.ndjson` for writing,
 and emits the start `meta` line. Throws if a trace is already running
 or BiDi is not enabled.
 
-### `browser.stopTrace()`
+### `browser.stopTrace(opts?)`
 
-Drains in-flight screenshot captures, writes the closing `meta` line,
-and closes the file. Returns `Promise<void>`. Throws if no trace is
-running.
+Captures the final page state, drains in-flight screenshot captures, writes the closing `meta` line,
+and closes the file. With `{ path: './trace.zip' }`, it also exports a
+Vibium/Playwright-compatible zip. Returns `Promise<void>`. Throws if no
+trace is active.
 
 ### Cleanup on `browser.quit()`
 
@@ -272,11 +353,8 @@ case. No file is deleted.
 
 By design, the tracer does not:
 
-* produce a self-contained `.zip` or hosted viewer,
 * record video / fixed-interval screencast,
-* emit HAR (the NDJSON already holds request/response events),
-* capture DOM snapshots or sourcemaps.
+* capture a restorable DOM or sourcemaps.
 
-Those features make sense at much larger scale (Playwright Trace
-Viewer). For a single failing test, a tail-able NDJSON log plus a
-handful of PNGs beats a zip you can't open.
+The raw NDJSON stays deliberately small and tail-able; richer portable
+features can be added to the zip format without weakening crash resilience.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craftdriver",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Modern WebDriver automation library for NodeJS",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,6 @@
     "test:chromium": "BROWSER_NAME=chromium vitest run",
     "test:recipes": "HEADLESS=true vitest run --config vitest.recipes.config.ts",
     "bench": "HEADLESS=true vitest run --config vitest.perf.config.ts",
-    "bench:realapp": "HEADLESS=true vitest run --config vitest.perf.realapp.config.ts",
     "clean": "rimraf dist",
     "serve": "http-server ./examples -a 127.0.0.1 -p 8080 -c-1 --cors",
     "examples:start": "npm run serve",
@@ -82,13 +81,9 @@
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^20.0.0",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.1.0",
+    "@types/yazl": "^3.3.1",
     "@typescript-eslint/parser": "^8.1.0",
     "eslint": "^9.8.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.10.1",
-    "eslint-plugin-promise": "^6.4.0",
     "http-server": "^14.1.1",
     "prettier": "^3.3.3",
     "rimraf": "^6.1.3",
@@ -99,7 +94,8 @@
   },
   "dependencies": {
     "axe-core": "^4.12.1",
-    "ws": "^8.21.0"
+    "ws": "^8.21.0",
+    "yazl": "^3.3.1"
   },
   "overrides": {
     "brace-expansion": "5.0.6",

package/skills/craftdriver/SKILL.md

@@ -34,8 +34,9 @@ break the moment markup shifts.
 3. `instanceof CraftdriverError` is true on every public throw;
    `instanceof Error` is also true.
 4. BiDi features (`network`, `logs`, tracing, init scripts, true load
-   events) require `Browser.launch({ enableBiDi: true })`. The error
-   code on the wrong transport is `UNSUPPORTED`.
+   events) work out of the box — `enableBiDi` defaults to `true`. They only
+   break if you explicitly pass `enableBiDi: false`; the error code on the
+   wrong transport is `UNSUPPORTED`.
 5. Tests fetch from the example server. Start it in a separate
    terminal: `npm run examples:start` before `npm test`.