tape-six-playwright 1.0.0

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2005-2026 Eugene Lazutkin
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,111 @@
+# tape-six-playwright [![NPM version][npm-img]][npm-url]
+
+[npm-img]: https://img.shields.io/npm/v/tape-six-playwright.svg
+[npm-url]: https://npmjs.org/package/tape-six-playwright
+
+`tape-six-playwright` is a helper for [tape-six](https://www.npmjs.com/package/tape-six)
+to run tests in a headless browser via Playwright. Each test file runs in its own
+iframe inside headless Chromium, providing full browser isolation.
+
+## Why?
+
+The standard `tape6` runner uses worker threads. `tape6-playwright` launches headless
+Chromium and runs each test file in a separate iframe, giving tests access to real DOM,
+browser APIs, and the full web platform. Tests can be `.js`/`.mjs` modules or `.html` files.
+
+## Install
+
+```bash
+npm i -D tape-six-playwright
+```
+
+Playwright's bundled Chromium is installed automatically via `postinstall`.
+
+## Quick start
+
+1. Write tests using [tape-six](https://www.npmjs.com/package/tape-six) that use browser APIs:
+
+```js
+import test from 'tape-six';
+
+test('DOM works', t => {
+  const el = document.createElement('div');
+  el.textContent = 'hello';
+  document.body.appendChild(el);
+  t.equal(document.body.lastChild.textContent, 'hello', 'element created');
+});
+```
+
+2. Configure tests in `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-playwright --start-server --flags FO"
+  },
+  "tape6": {
+    "browser": ["/tests/test-*.html"],
+    "tests": ["/tests/test-*.*js"],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  }
+}
+```
+
+3. Run:
+
+```bash
+npm test
+```
+
+## Server
+
+`tape6-playwright` requires `tape6-server` (from `tape-six`) to serve test files to the browser.
+
+- **Auto-start:** use `--start-server` to launch it automatically.
+- **Manual:** run `npx tape6-server` in a separate terminal, then run tests without `--start-server`.
+- **Custom URL:** use `--server-url URL` (`-u`), or set `TAPE6_SERVER_URL` or `HOST`/`PORT` environment variables.
+
+## Cross-runtime usage
+
+```json
+{
+  "scripts": {
+    "test": "tape6-playwright --start-server --flags FO",
+    "test:bun": "bun run `tape6-playwright --self` --start-server --flags FO",
+    "test:deno": "deno run -A `tape6-playwright --self` --start-server --flags FO"
+  }
+}
+```
+
+## Docs
+
+See the [wiki](https://github.com/uhop/tape-six-playwright/wiki) for full documentation.
+`tape-six` has its own [wiki](https://github.com/uhop/tape-six/wiki).
+
+`tape-six-playwright` uses the same test configuration and CLI conventions as `tape-six`.
+
+### Command-line utilities
+
+- [tape6-playwright](https://github.com/uhop/tape-six-playwright/wiki/Utility-‐-tape6‐playwright) — the main utility of this package to run browser tests.
+
+## AI agents
+
+If you are an AI coding agent, see [AGENTS.md](./AGENTS.md) for project conventions, commands, and architecture.
+
+LLM-friendly documentation is available:
+
+- [llms.txt](./llms.txt) — concise reference.
+- [llms-full.txt](./llms-full.txt) — full reference with architecture details.
+
+## Release notes
+
+The most recent releases:
+
+- 1.0.0 _The first official release._
+
+See the full [release notes](https://github.com/uhop/tape-six-playwright/wiki/Release-notes) for details.

package/bin/tape6-playwright-node.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+
+import {getOptions, initReporter, showInfo} from 'tape-six/utils/config.js';
+
+import {getReporter, setReporter} from 'tape-six/test.js';
+import {selectTimer} from 'tape-six/utils/timer.js';
+
+import TestWorker from '../src/TestWorker.js';
+
+const rootFolder = process.cwd();
+
+const showSelf = () => {
+  const self = new URL(import.meta.url);
+  if (self.protocol === 'file:') {
+    console.log(fileURLToPath(self));
+  } else {
+    console.log(self);
+  }
+  process.exit(0);
+};
+
+const getServerUrl = () => {
+  if (process.env.TAPE6_SERVER_URL) return process.env.TAPE6_SERVER_URL;
+  const host = process.env.HOST || 'localhost',
+    port = process.env.PORT || '3000';
+  return `http://${host}:${port}`;
+};
+
+const ensureServer = async (serverUrl, startServer) => {
+  try {
+    const response = await fetch(serverUrl + '/--tests');
+    if (response.ok) return null;
+  } catch (error) {
+    void error;
+  }
+
+  if (!startServer) {
+    console.error(
+      `Error: tape6-server is not reachable at ${serverUrl}\n\n` +
+        'Start it manually:\n' +
+        '  npx tape6-server\n\n' +
+        'Or re-run with --start-server:\n' +
+        '  tape6-playwright --start-server --flags FO\n'
+    );
+    process.exit(1);
+  }
+
+  // start the server
+  const serverBin = fileURLToPath(
+    new URL('../node_modules/tape-six/bin/tape6-server.js', import.meta.url)
+  );
+  const host = new URL(serverUrl).hostname,
+    port = new URL(serverUrl).port || '3000';
+  const child = spawn(process.execPath, [serverBin], {
+    cwd: rootFolder,
+    stdio: ['ignore', 'ignore', 'pipe'],
+    detached: false,
+    env: {...process.env, HOST: host, PORT: port}
+  });
+
+  let exited = false,
+    exitCode = null,
+    stderrData = '';
+  child.stderr.on('data', chunk => (stderrData += chunk));
+  child.on('exit', code => {
+    exited = true;
+    exitCode = code;
+  });
+  child.unref();
+
+  // wait for server to become available
+  for (let i = 0; i < 30; ++i) {
+    await new Promise(resolve => setTimeout(resolve, 500));
+    if (exited) {
+      console.error(
+        `Error: tape6-server exited with code ${exitCode} while starting on ${host}:${port}` +
+          (stderrData ? '\n' + stderrData.trim() : '')
+      );
+      process.exit(1);
+    }
+    try {
+      const response = await fetch(serverUrl + '/--tests');
+      if (response.ok) return child;
+    } catch (error) {
+      void error;
+    }
+  }
+
+  child.kill();
+  console.error(
+    `Error: tape6-server failed to start on ${host}:${port} (timed out after 15s)` +
+      (stderrData ? '\n' + stderrData.trim() : '')
+  );
+  process.exit(1);
+};
+
+const main = async () => {
+  const options = getOptions({
+    '--self': showSelf,
+    '--start-server': {isValueRequired: false},
+    '--info': {isValueRequired: false},
+    '--server-url': {aliases: ['-u'], initialValue: getServerUrl(), isValueRequired: true}
+  });
+  options.flags.serverUrl = options.optionFlags['--server-url'];
+
+  await Promise.all([initReporter(getReporter, setReporter, options.flags), selectTimer()]);
+
+  if (options.optionFlags['--info'] === '') {
+    showInfo(options, []);
+    process.exit(0);
+  }
+
+  const startServer = options.optionFlags['--start-server'] === '';
+
+  const serverUrl = options.optionFlags['--server-url'].replace(/\/+$/, '');
+  const serverChild = await ensureServer(serverUrl, startServer);
+
+  console.log(`Connected to ${serverUrl} (${serverChild ? 'self-launched' : 'external'})`);
+
+  const shutdown = code => {
+    serverChild?.kill();
+    process.exit(code);
+  };
+
+  process.on('uncaughtException', (error, origin) => {
+    console.error('UNHANDLED ERROR:', origin, error);
+    shutdown(1);
+  });
+
+  // fetch test files from server
+  let files = [];
+  try {
+    if (options.files.length) {
+      const query = options.files.map(p => 'q=' + encodeURIComponent(p)).join('&');
+      const response = await fetch(serverUrl + '/--patterns?' + query);
+      if (response.ok) files = await response.json();
+    }
+    if (!files.length) {
+      const response = await fetch(serverUrl + '/--tests');
+      if (response.ok) files = await response.json();
+    }
+  } catch (error) {
+    void error;
+  }
+
+  if (!files.length) {
+    console.log('No test files found on the server.');
+    shutdown(1);
+  }
+
+  // fetch importmap from server
+  let importmap = null;
+  try {
+    const response = await fetch(serverUrl + '/--importmap');
+    if (response.ok) importmap = await response.json();
+  } catch (error) {
+    void error;
+  }
+
+  const reporter = getReporter(),
+    worker = new TestWorker(reporter, options.parallel, {
+      ...options.flags,
+      serverUrl,
+      importmap
+    });
+
+  reporter.report({type: 'test', test: 0});
+
+  await new Promise(resolve => {
+    worker.done = () => resolve();
+    worker.execute(files);
+  });
+
+  const hasFailed = reporter.state && reporter.state.failed > 0;
+
+  reporter.report({
+    type: 'end',
+    test: 0,
+    fail: hasFailed
+  });
+
+  await worker.cleanup();
+
+  shutdown(hasFailed ? 1 : 0);
+};
+
+main().catch(error => console.error('ERROR:', error));

package/bin/tape6-playwright.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+
+if (process.argv.includes('--self')) {
+  const self = new URL(import.meta.url);
+  if (self.protocol === 'file:') {
+    console.log(fileURLToPath(self));
+  } else {
+    console.log(self);
+  }
+} else {
+  await import('./tape6-playwright-node.js');
+}

package/llms-full.txt

@@ -0,0 +1,253 @@
+# tape-six-playwright
+
+> A helper for [tape-six](https://github.com/uhop/tape-six) that runs test files in a headless browser via Playwright. Each test file runs in its own iframe inside headless Chromium. The npm package name is `tape-six-playwright` and the CLI command is `tape6-playwright`.
+
+- Real browser environment: tests run in headless Chromium with full DOM and browser API access
+- Iframe isolation: each test file runs in its own iframe
+- Cross-runtime: Node, Deno, and Bun with the same test files
+- Drop-in companion for `tape6` (worker-thread runner) and `tape6-proc` (subprocess runner)
+- Same configuration format as `tape-six`
+- Parallel execution with configurable concurrency
+- TAP, TTY (colored), JSONL, and minimal output formats
+
+## Install
+
+```bash
+npm i -D tape-six-playwright
+```
+
+Playwright's bundled Chromium is installed automatically via `postinstall`.
+
+## Quick start
+
+Write a test (`tests/test-dom.js`):
+
+```js
+import test from 'tape-six'
+
+test('DOM works', t => {
+  const el = document.createElement('div')
+  el.textContent = 'hello'
+  document.body.appendChild(el)
+  t.equal(document.body.lastChild.textContent, 'hello', 'element created')
+})
+```
+
+Run all configured tests via Playwright:
+
+```bash
+tape6-playwright --start-server --flags FO
+```
+
+## CLI: tape6-playwright
+
+Runs test files in parallel, each in its own iframe inside headless Chromium.
+
+```bash
+tape6-playwright [--flags FLAGS] [--par N] [--start-server] [--server-url URL] [--info] [tests...]
+```
+
+### Options
+
+- `--flags FLAGS` (`-f`) — output control flags (see Supported flags below).
+- `--par N` (`-p`) — number of parallel iframes. Default: all CPU cores (via `os.availableParallelism()` or `navigator.hardwareConcurrency`).
+- `--start-server` — auto-start `tape6-server` if not already running.
+- `--server-url URL` (`-u`) — server URL. Overrides `TAPE6_SERVER_URL` and `HOST`/`PORT`.
+- `--self` — prints the absolute path to `tape6-playwright.js` and exits. Used in cross-runtime scripts.
+- `--info` — prints runtime, reporter, flags, parallelism, and resolved test files, then exits. Does not require a running server.
+- Positional arguments: test file glob patterns. If none given, resolved from configuration.
+- Options accept `--flags FO` or `--flags=FO`. The `=` form does not support quoting.
+
+### Examples
+
+```bash
+# Run all configured tests
+tape6-playwright --start-server --flags FO
+
+# Run specific test files
+tape6-playwright --start-server tests/test-dom.js
+
+# Limit parallelism
+tape6-playwright --start-server --par 2 --flags FO
+
+# Use with already-running server
+tape6-playwright --flags FO
+```
+
+## Cross-runtime usage
+
+`tape6-playwright` is a Node CLI by default. For Bun and Deno, use the `--self` flag to get the script path:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-playwright --start-server --flags FO",
+    "test:bun": "bun run `tape6-playwright --self` --start-server --flags FO",
+    "test:deno": "deno run -A `tape6-playwright --self` --start-server --flags FO"
+  }
+}
+```
+
+## Supported flags
+
+Flags are a string of characters. Uppercase = enabled, lowercase = disabled.
+
+- `F` — Failures only: show only failed tests.
+- `T` — show Time for each test.
+- `B` — show Banner with summary.
+- `D` — show Data of failed tests.
+- `O` — fail Once: stop at first failure.
+- `N` — show assert Number.
+- `M` — Monochrome: no colors.
+- `C` — don't Capture console output.
+- `H` — Hide streams and console output.
+
+Usage:
+
+```bash
+tape6-playwright --start-server --flags FO
+TAPE6_FLAGS=FO tape6-playwright --start-server
+```
+
+## Server
+
+`tape6-playwright` requires `tape6-server` (from `tape-six`) to serve test files to the browser.
+
+- `--start-server`: auto-starts the server before running tests.
+- Without it: the server must already be running. The runner prints instructions if it's unreachable.
+- Server URL: `TAPE6_SERVER_URL` env var, or `HOST`/`PORT`, or default `http://localhost:3000`.
+- Server endpoints used: `GET /--tests` (test file list), `GET /--patterns?q=...` (filtered file list), `GET /--importmap` (import map).
+
+## Configuration
+
+Configuration is read from `tape6.json` or the `"tape6"` section of `package.json` (same format as `tape-six`):
+
+```json
+{
+  "tape6": {
+    "browser": ["/tests/test-*.html"],
+    "tests": ["/tests/test-*.*js"],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  }
+}
+```
+
+The `importmap` section is served by `tape6-server` at `/--importmap` and injected into each iframe for module resolution.
+
+## Environment variables
+
+- `TAPE6_FLAGS` — flags string (combined with `--flags` CLI argument).
+- `TAPE6_PAR` — number of parallel iframes (overridden by `--par`).
+- `TAPE6_TAP` — force TAP reporter (any non-empty value).
+- `TAPE6_JSONL` — force JSONL reporter (any non-empty value).
+- `TAPE6_MIN` — force minimal reporter (any non-empty value).
+- `TAPE6_SERVER_URL` — full server URL override (e.g. `http://localhost:4000`). Overridden by `--server-url`.
+- `HOST` — server hostname (default: `localhost`).
+- `PORT` — server port (default: `3000`).
+
+## Architecture
+
+### Entry point
+
+`bin/tape6-playwright.js` is the CLI entry point:
+
+- With `--self`: prints its own absolute path and exits.
+- Otherwise: delegates to `bin/tape6-playwright-node.js`.
+
+### Main CLI (`bin/tape6-playwright-node.js`)
+
+1. Parses CLI arguments via `getOptions()` from `tape-six` (`--flags`, `--par`, `--start-server`, `--server-url`, `--info`, positional test patterns).
+2. Initializes the reporter via `initReporter()` from `tape-six`.
+3. Ensures `tape6-server` is reachable (auto-starts if `--start-server`).
+4. Fetches test files from server via `GET /--patterns?q=...` (if patterns given) or `GET /--tests`.
+5. Fetches importmap from `GET /--importmap`.
+6. Creates a `TestWorker` instance and executes all test files.
+7. Reports final results and exits with code 0 (success) or 1 (failures).
+8. Kills auto-started server on exit.
+
+### TestWorker (`src/TestWorker.js`)
+
+Extends `EventServer` from `tape-six`. Manages Playwright browser and iframe execution:
+
+- **`constructor(reporter, numberOfTasks, options)`** — launches headless Chromium, creates a page, exposes `__tape6_reporter` and `__tape6_error` as page globals.
+- **`makeTask(fileName)`** — creates an iframe for the test file. Returns a task ID.
+- **`destroyTask(id)`** — removes the iframe from the page.
+- **`cleanup()`** — closes the browser.
+
+### Iframe lifecycle
+
+For `.html` files:
+1. Set iframe `src` to the file URL with query parameters (`id`, `test-file-name`, `flags`).
+2. The HTML file loads `tape-six` which auto-detects `window.parent.__tape6_reporter`.
+
+For `.js`/`.mjs` files:
+1. Create iframe, write an HTML document with `importmap` and a dynamic `<script type="module">`.
+2. The script sets `window.__tape6_id`, `window.__tape6_testFileName`, `window.__tape6_flags`.
+3. Dynamically appends a `<script>` element pointing to the test file URL on the server.
+4. `tape-six` initializes, detects `window.parent.__tape6_reporter`, and uses `ProxyReporter`.
+
+### Event flow
+
+```
+iframe tape-six → ProxyReporter → window.parent.__tape6_reporter(id, event)
+  → page.exposeFunction → Node.js TestWorker.report(id, event) → reporter
+```
+
+### Unsupported files
+
+`.cjs`, `.ts`, `.cts`, `.mts` files are skipped with a warning.
+
+## Dependencies
+
+- **`tape-six`** — the core test library. Imports: `State.js`, `utils/EventServer.js`, `utils/config.js` (`getOptions`, `initReporter`, `showInfo`), `test.js`, `utils/timer.js`.
+- **`playwright`** — headless browser automation. Bundled Chromium installed via `postinstall`.
+
+## Writing tests
+
+Tests are standard `tape-six` tests. See the [tape-six documentation](https://github.com/uhop/tape-six/wiki) for the full API.
+
+```js
+import test from 'tape-six'
+
+test('browser APIs', t => {
+  t.ok(typeof window === 'object', 'window exists')
+  t.ok(typeof document === 'object', 'document exists')
+  t.equal(typeof fetch, 'function', 'fetch available')
+})
+
+test('DOM manipulation', t => {
+  const el = document.createElement('div')
+  el.classList.add('test')
+  t.ok(el.classList.contains('test'), 'classList works')
+})
+```
+
+`.html` test files can include their own importmap and inline scripts:
+
+```html
+<!doctype html>
+<html>
+  <head>
+    <script type="importmap">
+      { "imports": { "tape-six": "/node_modules/tape-six/index.js" } }
+    </script>
+    <script type="module">
+      import test from 'tape-six'
+      test('html test', t => { t.ok(true, 'works') })
+    </script>
+  </head>
+  <body></body>
+</html>
+```
+
+## Links
+
+- Docs: https://github.com/uhop/tape-six-playwright/wiki
+- npm: https://www.npmjs.com/package/tape-six-playwright
+- tape-six: https://github.com/uhop/tape-six
+- tape-six LLM reference: https://github.com/uhop/tape-six/blob/master/llms.txt

package/llms.txt

@@ -0,0 +1,122 @@
+# tape-six-playwright
+
+> Helper for [tape-six](https://github.com/uhop/tape-six) that runs test files in a headless browser via Playwright. Each test file runs in its own iframe inside headless Chromium. Works with Node, Deno, and Bun.
+
+## Install
+
+```bash
+npm i -D tape-six-playwright
+```
+
+## Quick start
+
+1. Write tests using `tape-six` with browser APIs:
+
+```js
+import test from 'tape-six'
+
+test('DOM test', t => {
+  const el = document.createElement('div')
+  el.textContent = 'hello'
+  t.equal(el.textContent, 'hello', 'element works')
+})
+```
+
+2. Configure tests in `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-playwright --start-server --flags FO"
+  },
+  "tape6": {
+    "browser": ["/tests/test-*.html"],
+    "tests": ["/tests/test-*.*js"],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  }
+}
+```
+
+3. Run: `npm test`
+
+## Why use tape-six-playwright?
+
+- **Real browser environment** — tests run in headless Chromium with full DOM and browser API access.
+- **Iframe isolation** — each test file runs in its own iframe.
+- **Cross-runtime** — works with Node, Deno, and Bun using the same test files.
+- **Drop-in companion** — uses the same configuration and test format as `tape6` and `tape6-proc`.
+
+## CLI: tape6-playwright
+
+```bash
+tape6-playwright [--flags FLAGS] [--par N] [--start-server] [--server-url URL] [--info] [tests...]
+```
+
+### Options
+
+- `--flags FLAGS` (`-f`) — output control flags (same as tape6: F=failures only, T=time, B=banner, D=data, O=fail once, N=assert number, M=monochrome, C=don't capture console, H=hide streams). Can be specified multiple times.
+- `--par N` (`-p`) — number of parallel iframes (default: all CPU cores).
+- `--start-server` — auto-start `tape6-server` if not already running.
+- `--server-url URL` (`-u`) — server URL (overrides `TAPE6_SERVER_URL`).
+- `--self` — prints the path to `tape6-playwright.js` (for cross-runtime scripts).
+- `--info` — prints runtime, reporter, flags, parallelism, and resolved test files, then exits.
+- No arguments: runs tests from configuration.
+- Options accept `--flags FO` or `--flags=FO`. The `=` form does not support quoting.
+
+### Cross-runtime usage
+
+```json
+{
+  "scripts": {
+    "test": "tape6-playwright --start-server --flags FO",
+    "test:bun": "bun run `tape6-playwright --self` --start-server --flags FO",
+    "test:deno": "deno run -A `tape6-playwright --self` --start-server --flags FO"
+  }
+}
+```
+
+## Server
+
+Requires `tape6-server` (from `tape-six`) to serve test files. Use `--start-server` to auto-start it, or run `npx tape6-server` manually.
+
+Server URL: `TAPE6_SERVER_URL` env var, or `HOST`/`PORT`, default `http://localhost:3000`.
+
+## Configuration
+
+Same as `tape-six`. Reads from `tape6.json` or the `"tape6"` section of `package.json`:
+
+```json
+{
+  "tape6": {
+    "browser": ["/tests/test-*.html"],
+    "tests": ["/tests/test-*.*js"],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  }
+}
+```
+
+## Environment variables
+
+- `TAPE6_FLAGS` — flags string.
+- `TAPE6_PAR` — number of parallel iframes.
+- `TAPE6_TAP` — force TAP reporter.
+- `TAPE6_JSONL` — force JSONL reporter.
+- `TAPE6_MIN` — force minimal reporter.
+- `TAPE6_SERVER_URL` — full server URL override.
+
+## Links
+
+- Docs: https://github.com/uhop/tape-six-playwright/wiki
+- npm: https://www.npmjs.com/package/tape-six-playwright
+- tape-six: https://github.com/uhop/tape-six
+- Full LLM reference: https://github.com/uhop/tape-six-playwright/blob/master/llms-full.txt

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "tape-six-playwright",
+  "version": "1.0.0",
+  "description": "Playwright-based browser test runner for tape-six. Runs each test file in its own iframe inside headless Chromium. Works with Node, Deno, and Bun.",
+  "type": "module",
+  "bin": {
+    "tape6-playwright": "bin/tape6-playwright.js",
+    "tape6-playwright-node": "bin/tape6-playwright-node.js"
+  },
+  "scripts": {
+    "lint": "prettier --check .",
+    "lint:fix": "prettier --write .",
+    "browser": "playwright install chromium",
+    "postinstall": "playwright install chromium",
+    "test": "node ./bin/tape6-playwright.js --start-server --flags FO",
+    "test:bun": "bun run ./bin/tape6-playwright.js --start-server --flags FO",
+    "test:deno": "deno run -A ./bin/tape6-playwright.js --start-server --flags FO"
+  },
+  "keywords": [
+    "tap",
+    "tape6",
+    "tape-six",
+    "test",
+    "test-runner",
+    "unit-test",
+    "testing",
+    "harness",
+    "browser",
+    "playwright",
+    "headless",
+    "chromium",
+    "iframe",
+    "parallel",
+    "cross-runtime",
+    "nodejs",
+    "deno",
+    "bun",
+    "esm",
+    "es-modules"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com)",
+  "funding": "https://github.com/sponsors/uhop",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/tape-six-playwright.git"
+  },
+  "bugs": {
+    "url": "https://github.com/uhop/tape-six-playwright/issues"
+  },
+  "homepage": "https://github.com/uhop/tape-six-playwright#readme",
+  "github": "http://github.com/uhop/tape-six-playwright",
+  "llms": "https://raw.githubusercontent.com/uhop/tape-six-playwright/master/llms.txt",
+  "llmsFull": "https://raw.githubusercontent.com/uhop/tape-six-playwright/master/llms-full.txt",
+  "files": [
+    "bin",
+    "src",
+    "llms.txt",
+    "llms-full.txt"
+  ],
+  "dependencies": {
+    "playwright": "^1.52.0",
+    "tape-six": "^1.7.8"
+  },
+  "tape6": {
+    "browser": [
+      "/tests/test-*.html"
+    ],
+    "tests": [
+      "/tests/test-*.*js"
+    ],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  },
+  "devDependencies": {
+    "prettier": "^3.8.1"
+  }
+}

package/src/TestWorker.js

@@ -0,0 +1,169 @@
+import {chromium} from 'playwright';
+
+import {isStopTest} from 'tape-six/State.js';
+import EventServer from 'tape-six/utils/EventServer.js';
+
+const supportedExtRe = /\.(?:js|mjs|htm|html)$/i;
+
+export default class TestWorker extends EventServer {
+  #ready;
+  constructor(reporter, numberOfTasks, options) {
+    super(reporter, numberOfTasks, options);
+    this.counter = 0;
+    this.browser = null;
+    this.page = null;
+    this.#ready = this.#init();
+  }
+  async #init() {
+    this.browser = await chromium.launch({headless: true, args: ['--no-sandbox']});
+    this.page = await this.browser.newPage();
+
+    this.page.on('pageerror', e => console.error(e));
+
+    // navigate to server so iframes inherit the correct origin
+    await this.page.goto(this.options.serverUrl + '/--tests', {waitUntil: 'load'});
+    await this.page.evaluate(() => {
+      document.documentElement.innerHTML = '<head></head><body></body>';
+    });
+
+    // forward console messages only after the page is set up
+    this.page.on('console', msg =>
+      console[typeof console[msg.type()] == 'function' ? msg.type() : 'log'](msg.text())
+    );
+
+    await this.page.exposeFunction('__tape6_reporter', (id, event) => {
+      try {
+        this.report(id, event);
+        if ((event.type === 'end' && event.test === 0) || event.type === 'terminated') {
+          this.close(id);
+        }
+      } catch (error) {
+        if (!isStopTest(error)) throw error;
+      }
+    });
+
+    await this.page.exposeFunction('__tape6_error', (id, error) => {
+      if (error) {
+        this.report(id, {
+          type: 'comment',
+          name: 'fail to load: ' + (error.message || 'Worker error'),
+          test: 0
+        });
+        try {
+          this.report(id, {
+            name: String(error),
+            test: 0,
+            marker: new Error(),
+            operator: 'error',
+            fail: true,
+            data: {actual: error}
+          });
+        } catch (error) {
+          if (!isStopTest(error)) throw error;
+        }
+      }
+      this.close(id);
+    });
+  }
+  makeTask(fileName) {
+    const id = String(++this.counter);
+    if (!supportedExtRe.test(fileName)) {
+      this.report(id, {
+        name: 'unsupported file type: ' + fileName,
+        test: 0,
+        marker: new Error(),
+        operator: 'error',
+        fail: true
+      });
+      this.report(id, {type: 'terminated', test: 0, name: 'FILE: /' + fileName});
+      this.close(id);
+      return id;
+    }
+    this.#ready
+      .then(() => this.#runInIframe(id, fileName))
+      .catch(error => {
+        console.error('Failed to run test:', fileName, error);
+        this.close(id);
+      });
+    return id;
+  }
+  async #runInIframe(id, fileName) {
+    const importmap = this.options.importmap,
+      flags = this.options.flags || '';
+
+    try {
+      if (/\.html?$/i.test(fileName)) {
+        const search = new URLSearchParams({id, 'test-file-name': fileName});
+        if (flags) search.set('flags', flags);
+        const url = '/' + fileName + '?' + search.toString();
+        await this.page.evaluate(
+          ({url, frameId}) => {
+            const iframe = document.createElement('iframe');
+            iframe.id = 'test-iframe-' + frameId;
+            iframe.src = url;
+            iframe.onerror = error => window.__tape6_error(frameId, error);
+            document.body.append(iframe);
+          },
+          {url, frameId: id}
+        );
+      } else {
+        const html =
+          '<!doctype html>' +
+          '<html lang="en"><head>' +
+          '<meta charset="utf-8" />' +
+          (importmap
+            ? '<script type="importmap">' + JSON.stringify(importmap) + '<\/script>'
+            : '') +
+          '<script type="module">' +
+          'window.__tape6_id = ' +
+          JSON.stringify(id) +
+          ';' +
+          'window.__tape6_testFileName = ' +
+          JSON.stringify(fileName) +
+          ';' +
+          'window.__tape6_flags = ' +
+          JSON.stringify(flags) +
+          ';' +
+          'const s = document.createElement("script");' +
+          's.setAttribute("type", "module");' +
+          's.src = "/' +
+          fileName +
+          '";' +
+          's.onerror = error => window.parent.__tape6_error(' +
+          JSON.stringify(id) +
+          ', error && error.message || "Script load error");' +
+          'document.documentElement.appendChild(s);' +
+          '<\/script>' +
+          '</head><body></body></html>';
+        await this.page.evaluate(
+          ({frameId, srcdoc}) => {
+            const iframe = document.createElement('iframe');
+            iframe.id = 'test-iframe-' + frameId;
+            iframe.srcdoc = srcdoc;
+            document.body.append(iframe);
+          },
+          {frameId: id, srcdoc: html}
+        );
+      }
+    } catch (error) {
+      console.error('Failed to create iframe for:', fileName, error);
+      this.close(id);
+    }
+  }
+  destroyTask(id) {
+    if (!this.page) return;
+    this.page
+      .evaluate(frameId => {
+        const iframe = document.getElementById('test-iframe-' + frameId);
+        if (iframe) iframe.parentElement.removeChild(iframe);
+      }, id)
+      .catch(() => {});
+  }
+  async cleanup() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.page = null;
+    }
+  }
+}