tape-six 1.8.0 → 1.10.0

package/README.md

@@ -122,6 +122,8 @@ See how it can be used in [tests/](https://github.com/uhop/tape-six/tree/master/
 
 For AI assistants: see [llms.txt](https://github.com/uhop/tape-six/blob/master/llms.txt) and [llms-full.txt](https://github.com/uhop/tape-six/blob/master/llms-full.txt) for LLM-optimized documentation.
 
+When you use `tape-six` as a dependency, point your AI coding agent at the guides shipped inside `node_modules/tape-six/`: [`TESTING.md`](https://github.com/uhop/tape-six/blob/master/TESTING.md) and the `skills/` directory (`write-tests`, `run-tests`). They are written so an agent can write and run `tape-six` tests correctly without fetching anything.
+
 The whole API is based on two objects: `test` and `Tester`.
 
 ### `test`
@@ -319,7 +321,7 @@ The following methods are available (all `msg` arguments are optional):
   - `any` — a symbol that can be used in deep equivalency asserts to match any value.
     See [deep6's any](https://github.com/uhop/deep6/wiki/any) for details.
     - `_` — an alias of `any`.
-  - `plan(n)` — sets the number of tests in the test suite. Rarely used.
+  - `plan(n)` — records the expected number of direct assertions; emits a TAP-comment diagnostic at test end if the count diverges (does not fail the test).
   - `comment(msg)` — sends a comment to the test harness. Rarely used.
   - `skipTest(...args, msg)` — skips the current test yet sends a message to the test harness.
   - `bailOut(msg)` — stops the test suite and sends a message to the test harness.
@@ -425,8 +427,10 @@ Test output can be controlled by flags. See [Supported flags](https://github.com
 
 The most recent releases:
 
-- 1.8.0 _New subpath modules `tape-six/server` (withServer/startServer/setupServer — ephemeral HTTP server harness with port-busy-rejects-not-hangs lifecycle, plus a hook helper for suite-shared servers) and `tape-six/response` (asText/asJson/asBytes/header/headers — reading helpers that work uniformly on W3C Response and Node http.IncomingMessage). Cross-runtime via `node:http` (Node, Bun, Deno). `bin/tape6-server.js` migrated to use `startServer` and `process.exitCode`. `node:` protocol prefix consistently applied to all Node built-in imports; added `types: ["node"]` to tsconfig._
-- 1.7.14 _Updated vendored `deep6` to 1.2.0: added `URL` support (unifier/walker/cloner + processors), named exports alongside default exports, fast path for naked objects, performance optimizations, improved TS typings, removed CommonJS build._
+- 1.10.0 _Worker control channel stops in-flight workers, draining cleanup before a force-kill._
+- 1.9.0 _New features: `t.plan(n)` emits a TAP-comment diagnostic on mismatch, `registerTesterMethod(name, fn)` registers tester plugins idempotently._
+- 1.8.0 _New subpath modules: `tape-six/server` (HTTP server harness) and `tape-six/response` (response reading helpers for `Response` and `IncomingMessage`)._
+- 1.7.14 _Updated vendored `deep6` to 1.2.0._
 - 1.7.13 _Replaced `process.exit()` / `Deno.exit()` with `process.exitCode` in test runners and `index.js` for graceful stdout flushing. Updated dependencies, GitHub Actions._
 - 1.7.12 _Added `--help`/`-h` and `--version`/`-v` options to all CLI utilities. Added flag documentation to help output._
 - 1.7.11 _Documentation consistency: added missing sequential test commands to AI docs, fixed test glob references._

package/TESTING.md

@@ -221,7 +221,7 @@ By default tests have **no timeout**. Set `timeout` per test, or wrap a fixture
 - `t.comment(msg)` — emit a TAP comment line.
 - `t.skipTest(msg)` — skip the **current** test from inside it (e.g. when a precondition isn't met at runtime).
 - `t.bailOut(msg)` — stop the entire run. Catastrophic; use sparingly.
-- `t.plan(n)` — currently a documented no-op kept for migration compatibility from `tape` and `node:test`.
+- `t.plan(n)` — record the expected number of direct assertions. If the count diverges at test end, a `# plan != count: expected N, ran M` TAP comment is emitted (diagnostic only, doesn't fail the test). Subtest assertions don't count toward the parent's plan.
 - `t.OK(expr, msg)` (aliases `t.TRUE`, `t.ASSERT`) — returns a code string for `eval()` that asserts an expression and dumps the values of the top-level identifiers in the expression on failure. Useful for compact arithmetic/state checks. Not usable in CSP-restricted contexts (uses `eval`).
 
   ```js
@@ -335,127 +335,6 @@ test('suite B', dbOpts, async t => {
 });
 ```
 
-## Testing HTTP code
-
-Two subpath modules ship for tests that need HTTP-shaped fixtures. Both work on Node, Bun, and Deno via `node:http`. Browsers don't get them — running an HTTP server inside a webpage isn't a use case.
-
-> **Placement matters.** Test files that import `tape-six/server`, `tape-six/response`, or any other node-only API (e.g. `node:http`, `node:fs`, `node:child_process`) **must not** match a `tape6.tests` pattern that's universal to all environments — the browser worker would try to load them and fail with `Worker error` on the missing built-in. Put them in a CLI-only location (e.g. `tests/cli/test-*.js`) and add the matching glob to `tape6.cli` so it covers Node/Bun/Deno but not browsers. See [Configuring test discovery](#configuring-test-discovery).
-
-### `tape-six/server` — server harness
-
-```js
-import {withServer, startServer, setupServer} from 'tape-six/server';
-```
-
-Three exports for three lifetimes. `withServer` is the per-test scoped resource (95% case). `startServer` is the procedural primitive. `setupServer` registers `beforeAll`/`afterAll` for suite-shared servers.
-
-**Per-test server** — start before the test body, tear down in `finally`:
-
-```js
-import test from 'tape-six';
-import {withServer} from 'tape-six/server';
-
-test('GET / returns 200', t =>
-  withServer(myHandler, async base => {
-    const res = await fetch(`${base}/`);
-    t.equal(res.status, 200);
-  }));
-```
-
-`myHandler` is a `(req, res) => void` callback (`http.RequestListener`). `base` is the bound URL, e.g. `"http://127.0.0.1:54321"`. Default host is `'127.0.0.1'` (explicit IPv4); pass `{host, port}` to override.
-
-`withServer` handles the symmetric case where the test makes requests directly. It's also the right tool when the SUT is something else (a CLI spawned in a subprocess) and the handler is a mock — the test body just looks different:
-
-```js
-test('CLI hits the API correctly', t =>
-  withServer(mockApi, async base => {
-    const result = await spawnCli({env: {API_URL: base}});
-    t.equal(result.exitCode, 0);
-    t.equal(recordedRequests.length, 1);
-  }));
-```
-
-Either side may be the SUT. The names `serverHandler` / `clientHandler` reflect role on the wire, not which side is being tested.
-
-**Suite-shared server** — register hooks once, share across many tests:
-
-```js
-import test, {beforeEach} from 'tape-six';
-import {setupServer} from 'tape-six/server';
-
-let recorded;
-const server = setupServer((req, res) => {
-  recorded.push({method: req.method, url: req.url});
-  res.writeHead(204).end();
-});
-beforeEach(() => {
-  recorded = [];
-});
-
-test('records exactly one request', async t => {
-  await fetch(`${server.base}/foo`);
-  t.equal(recorded.length, 1);
-});
-
-test('records the path correctly', async t => {
-  await fetch(`${server.base}/bar`);
-  t.equal(recorded[0].url, '/bar');
-});
-```
-
-The returned handle has live getters — `server.base` reads the current state on each access. **Don't destructure** at module load (`const {base} = setupServer(...)`); `base` is `undefined` until `beforeAll` runs. Per-test state reset (the `recorded = []` above) is user-side via your own `beforeEach`; `setupServer` owns the server lifecycle, you own state.
-
-**Procedural primitive** — for multi-phase tests or non-test code:
-
-```js
-import http from 'node:http';
-import {startServer} from 'tape-six/server';
-
-const lc = await startServer(http.createServer(handler), {host, port});
-try {
-  // ... lc.base, lc.port, lc.host ...
-} finally {
-  await lc.close();
-}
-```
-
-`startServer` accepts a fully-constructed server (so the caller can attach `'clientError'` listeners or configure TLS first). It races `'listening'` against `'error'` so port-busy / `EACCES` rejects with the original error rather than hanging — the failure mode existing helpers across the ecosystem suffer from on busy CI machines.
-
-`close()` is idempotent and calls `server.closeAllConnections()` (when available, Node 18.2+) so keep-alive sockets from `fetch` don't delay teardown.
-
-### `tape-six/response` — response reading helpers
-
-```js
-import {asText, asJson, asBytes, header, headers} from 'tape-six/response';
-```
-
-Five reading helpers that work uniformly on both W3C `Response` (from `fetch`) and Node `http.IncomingMessage` (from `http.request`).
-
-```js
-import test from 'tape-six';
-import {withServer} from 'tape-six/server';
-import {asJson, header} from 'tape-six/response';
-
-test('GET / returns JSON', t =>
-  withServer(handler, async base => {
-    const res = await fetch(`${base}/`);
-    t.equal(res.status, 200);
-    t.match(header(res, 'content-type'), /^application\/json/);
-    const body = await asJson(res);
-    t.deepEqual(body, {ok: true});
-  }));
-```
-
-| Helper              | Returns                  | Notes                               |
-| ------------------- | ------------------------ | ----------------------------------- |
-| `asText(res)`       | `Promise<string>`        | UTF-8                               |
-| `asJson(res)`       | `Promise<unknown>`       | parses JSON                         |
-| `asBytes(res)`      | `Promise<Uint8Array>`    | raw bytes                           |
-| `header(res, name)` | `string \| null`         | case-insensitive single-header read |
-| `headers(res)`      | `Record<string, string>` | all headers, lowercase keys         |
-
-For status code, just use `res.status` (W3C `Response`) or `res.statusCode` (Node `IncomingMessage`) directly — no helper needed.
-
 ## Migrating from other test frameworks
 
 `tape-six` supports `describe`/`it` and `before`/`after` aliases. When called inside a test body, all top-level functions automatically delegate to the current tester. This means migration from Mocha, Jest, or `node:test` is nearly mechanical — change the import and swap assertions.

package/index.d.ts

@@ -95,8 +95,11 @@ export declare interface Tester {
   signal: AbortSignal;
 
   /**
-   * Plans the number of assertions that will be run. Unused.
-   * @param n - The number of assertions
+   * Records the expected number of direct assertions. When the test ends, a
+   * `# plan != count: expected N, ran M` TAP comment is emitted if the count
+   * diverges. Diagnostic only — does not fail the test. Subtest assertions
+   * don't count toward the parent's plan.
+   * @param n - The expected number of assertions (non-negative integer)
    */
   plan(n: number): void;
 
@@ -1251,4 +1254,29 @@ export declare const before: typeof test.before;
  */
 export declare const after: typeof test.after;
 
+/**
+ * Idempotently install a method on `Tester.prototype` so it appears as a
+ * method on every tester instance (`t.<name>(...)`). Same name + same function
+ * is a no-op (allows duplicate side-effect imports). Same name + a different
+ * function throws so collisions surface loudly.
+ *
+ * Usage from a plugin module (e.g., `tape-six-spawn`):
+ *
+ * ```ts
+ * import {registerTesterMethod} from 'tape-six/Tester.js';
+ *
+ * declare module 'tape-six' {
+ *   interface Tester {
+ *     spawnBin(bin: string, args: string[]): Promise<{code: number; stdout: string; stderr: string}>;
+ *   }
+ * }
+ *
+ * registerTesterMethod('spawnBin', async function (bin, args) { ... });
+ * ```
+ *
+ * @param name - non-empty method name
+ * @param fn - function to install on `Tester.prototype`
+ */
+export declare const registerTesterMethod: (name: string, fn: (...args: any[]) => any) => void;
+
 export default test;

package/index.js

@@ -162,6 +162,33 @@ const init = async () => {
     setCurrentReporter?.(reporter);
   }
 
+  if (isBrowser && typeof window.addEventListener == 'function') {
+    // Control plane: the parent page posts `tape6-terminate` to drain a running
+    // test (failOnce / bail / worker deadline). The reporter arms stopTest +
+    // fires the abort signal so the test unwinds. There is no in-page
+    // force-kill — see dev-docs/worker-control-channel.md.
+    window.addEventListener('message', event => {
+      if (event.data?.type === 'tape6-terminate') getReporter()?.terminate();
+    });
+  }
+
+  if (isCli) {
+    // Control plane (proc transport): a child spawned by tape-six-proc is
+    // marked with TAPE6_CONTROL. Open the stdin control channel so the parent
+    // can drain / terminate it, and so it stays alive after `end` until told to
+    // exit — see dev-docs/worker-control-channel.md.
+    const controlled =
+      (isDeno && Deno.env.get('TAPE6_CONTROL')) ||
+      (isBun && Bun.env.TAPE6_CONTROL) ||
+      (isNode && process.env.TAPE6_CONTROL);
+    if (controlled) {
+      const {listenControlChannel} = await import(
+        new URL('./src/utils/control-channel.js', import.meta.url)
+      );
+      listenControlChannel(getReporter);
+    }
+  }
+
   return {options, isBrowser, isBun, isDeno, isNode, isCli};
 };
 
@@ -254,6 +281,8 @@ if (!getConfiguredFlag()) {
   registerNotifyCallback(testRunner);
 }
 
+export {registerTesterMethod} from './src/Tester.js';
+
 export {
   test,
   before,

package/llms-full.txt

@@ -10,7 +10,7 @@
 - Before/after hooks: `beforeAll`, `afterAll`, `beforeEach`, `afterEach`
 - `test()` is aliased as `suite()`, `describe()`, and `it()` for easy migration
 - When called inside a test body, top-level functions auto-delegate to the current tester
-- Compatible with `AssertionError`-based libraries like `node:assert` and `chai`
+- BYO assertion / mocking / property-based libs: `node:assert`, `chai`, `expect`, `node:test` mock, `sinon`, `fast-check`
 
 ## Quick start
 
@@ -192,7 +192,7 @@ The `Tester` object is passed to test functions. All `msg` arguments are optiona
 
 ### Miscellaneous
 
-- `plan(n)` — set expected number of assertions.
+- `plan(n)` — record expected number of direct assertions. On test end, emits a `# plan != count: expected N, ran M` TAP comment if the count diverges (diagnostic only, doesn't fail the test). Subtest assertions don't count toward the parent's plan.
 - `comment(msg)` — send a comment to the reporter.
 - `skipTest(...args, msg)` — skip current test with a message.
 - `bailOut(msg)` — abort the test suite.
@@ -257,107 +257,27 @@ test('suite', opts, async t => {
 
 Multiple hooks of the same type run in registration order (before) or reverse order (after).
 
-## Subpath modules
+## Plugins
 
-Two helper modules ship as separate subpath imports for tests that need HTTP-shaped fixtures. Both are cross-runtime (Node, Bun, Deno via `node:http`); browsers don't need them because running an HTTP server inside a webpage isn't a use case.
-
-### tape-six/server — HTTP server harness
-
-```js
-import {withServer, startServer, setupServer} from 'tape-six/server';
-```
-
-#### `withServer(serverHandler, clientHandler, opts?)` — scoped resource (95% case)
-
-Spins up an `http.Server` with `serverHandler`, runs `clientHandler` with the bound base URL, tears down in `finally`. Cleanup runs whether `clientHandler` resolves, rejects, or throws synchronously. Returns whatever `clientHandler` returns.
-
-```js
-test('GET / returns 200', t =>
-  withServer(handler, async base => {
-    const res = await fetch(`${base}/`);
-    t.equal(res.status, 200);
-  }));
-```
-
-`serverHandler` is the per-request callback Node invokes on each incoming request. `clientHandler` is the per-scope test body, called once with `(base, lifecycle)` — naming reflects role on the wire (server side / client side), not which side is the SUT. Either side may be the code under test.
-
-`clientHandler` may make HTTP requests itself (`fetch(base)`-style), or set up a separate SUT that does (e.g., a spawned CLI given `${base}` as its endpoint env var), or do neither (multi-phase setup + assertions).
-
-#### `startServer(server, opts?)` — procedural primitive
-
-For multi-phase tests that span the lifecycle, or non-test code (e.g. `bin/tape6-server`) that wants long-term control. Accepts a fully-constructed `http.Server` (so callers can attach `'clientError'` handlers, configure TLS, etc., before listen).
-
-```js
-const lc = await startServer(http.createServer(handler), {host, port});
-// ... use lc.base ...
-await lc.close();
-```
-
-Returns a lifecycle handle:
-
-- `server` — the underlying `http.Server`.
-- `base` — bound base URL, e.g. `"http://127.0.0.1:54321"`.
-- `port` — actual bound port (OS-assigned when `port: 0`).
-- `host` — bound host.
-- `close()` — idempotent. Calls `server.closeAllConnections()` (when available) so keep-alive sockets don't delay teardown.
-
-Races `'listening'` against `'error'`: port-busy / `EACCES` rejects with the original error rather than hanging. Existing helpers across the toolkit ecosystem don't do this and have hung CI machines as a result.
-
-#### `setupServer(serverHandler, opts?)` — hook helper
-
-Registers `beforeAll` (start) and `afterAll` (close) and returns a live-getter handle for suite-shared servers:
+Tester methods can be added via `registerTesterMethod(name, fn)`. Same name + same fn → no-op (idempotent re-import); same name + different fn → throws (loud collision detection).
 
 ```js
-const server = setupServer(handler);
+import {registerTesterMethod} from 'tape-six';
 
-test('first', async t => {
-  const res = await fetch(`${server.base}/foo`);
+registerTesterMethod('spawnBin', async function (bin, args) {
+  // ... implementation, can call this.equal(...), this.reporter.report({...}), etc.
 });
 
-test('second', async t => {
-  const res = await fetch(`${server.base}/bar`);
-});
-```
-
-The returned object is `Object.freeze`d and uses property getters that read the live lifecycle. Don't destructure at module load (`const {base} = setupServer(...)`) — `base` is `undefined` until `beforeAll` runs.
-
-State reset stays user-side. For mock-server scenarios that need per-test state clearing, compose your own `beforeEach`:
-
-```js
-const server = setupServer((req, res) => {
-  recorded.push({method: req.method, url: req.url});
-  res.writeHead(204).end();
+// then in tests:
+test('cli', async t => {
+  const {code} = await t.spawnBin('node', ['-v']);
+  t.equal(code, 0);
 });
-let recorded;
-beforeEach(() => { recorded = []; });
-```
-
-`setupServer` owns the suite lifecycle; the caller owns suite state.
-
-#### Options
-
-```ts
-interface ServerOptions {
-  host?: string;  // default '127.0.0.1' — explicit IPv4 avoids dual-stack ambiguity
-  port?: number;  // default 0 — OS-assigned
-}
-```
-
-### tape-six/response — HTTP response helpers
-
-Reading helpers that work uniformly with both `Response` (fetch results) and Node `http.IncomingMessage`:
-
-```js
-import {asText, asJson, asBytes, header, headers} from 'tape-six/response';
 ```
 
-- `asText(res)` → `Promise<string>` — body as UTF-8.
-- `asJson(res)` → `Promise<unknown>` — body parsed as JSON.
-- `asBytes(res)` → `Promise<Uint8Array>` — body as raw bytes.
-- `header(res, name)` → `string | null` — case-insensitive single-header read. Array-valued `IncomingMessage` headers (e.g. `set-cookie`) are joined with `, `.
-- `headers(res)` → `Record<string, string>` — all headers as a plain object with lowercase keys.
+`Tester` is declared as an `interface` in `index.d.ts` to make TS module augmentation natural — plugins extend the interface, no full class shape needed. The built-in `t.OK()` evaluator (`src/OK.js`) uses this exact pattern.
 
-For status code, just use `res.status` — same on both `Response` and `IncomingMessage`.
+Plugin installation is **per-file**. `tape6-seq` runs all files in one process; `tape6` uses workers; `tape6-proc` (from the sister package `tape-six-proc`) uses subprocesses; browser tests run in iframes. Each isolation context has its own module graph, so a plugin import in file A is invisible to file B when they're in different contexts. Every test file that uses a plugin must import it directly. `registerTesterMethod`'s idempotency makes repeated imports safe. See [Writing plugins](https://github.com/uhop/tape-six/wiki/Writing-plugins) for the full guide.
 
 ## Configuring tests
 
@@ -458,6 +378,8 @@ Browser: `http://localhost:3000/?flags=FO`
 - `TAPE6_JSONL` — force JSONL reporter (any non-empty value).
 - `TAPE6_MIN` — force minimal reporter (any non-empty value).
 - `TAPE6_TEST_FILE_NAME` — set by runners to identify the current test file.
+- `TAPE6_GRACE_TIMEOUT` — ms a worker gets to drain (run cleanup, flush) after the runner asks it to stop, before being force-killed (default: 5000).
+- `TAPE6_WORKER_TIMEOUT` — per-file wall-clock budget in ms; on expiry the runner stops that worker (default: 0, disabled). The complement to the per-test `timeout` option: this one can stop a worker that ignores `t.signal`.
 
 ## Browser testing
 
@@ -473,19 +395,18 @@ Browser: `http://localhost:3000/?flags=FO`
 - tape-six-puppeteer (https://www.npmjs.com/package/tape-six-puppeteer) — automates browser testing with Puppeteer.
 - tape-six-playwright (https://www.npmjs.com/package/tape-six-playwright) — automates browser testing with Playwright.
 
-## 3rd-party assertion libraries
+## 3rd-party libraries (bring-your-own)
 
-`tape-six` supports `AssertionError`-based assertions. You can use `node:assert` or `chai` inside test functions:
+`tape-six` doesn't bundle assertion / mock / property-based libraries. It catches whatever the test throws — anything throwing a node-compatible `AssertionError` (with `name`, `operator`, `actual`, `expected`) is reported as a regular assertion; other errors are reported as `UNEXPECTED EXCEPTION` (test still fails).
 
-```js
-import test from 'tape-six';
-import {assert, expect} from 'chai';
+**Verified candidates** (full per-lib examples and browser importmap snippets in the wiki):
 
-test('with chai', t => {
-  expect(1).to.be.lessThan(2);
-  assert.deepEqual([1], [1]);
-});
-```
+- `node:assert` — built-in to Node/Bun/Deno, throws `AssertionError`. Cleanest path.
+- `chai` — `expect`/`should`/`assert` styles, throws `AssertionError`. Works in browsers via importmap entry.
+- `expect` (Jest's standalone) — throws plain `Error`, not `AssertionError`. Works but failures render as `UNEXPECTED EXCEPTION` with ANSI-colored messages. Wrap negative cases in `t.throws()`.
+- `node:test` mock — built-in spies/stubs/timers via `import {mock} from 'node:test'`. Doesn't throw; assert on `spy.mock.calls` with `t.*`.
+- `sinon` — same pattern as `node:test` mock. Assert on `spy.callCount` / `spy.firstCall.args`.
+- `fast-check` — property-based testing. Throws plain `Error` on counterexample (with seed + path for repro). Wrap negative cases in `t.throws()`.
 
 ```js
 import test from 'tape-six';
@@ -497,4 +418,18 @@ test('with node:assert', t => {
 });
 ```
 
+```js
+import test from 'tape-six';
+import {mock} from 'node:test';
+
+test('with node:test mock', t => {
+  const spy = mock.fn();
+  spy(1, 2);
+  t.equal(spy.mock.calls.length, 1);
+  t.deepEqual(spy.mock.calls[0].arguments, [1, 2]);
+});
+```
+
+Wiki: [3rd-party assertion libraries](https://github.com/uhop/tape-six/wiki/3rd%E2%80%90party-assertion-libraries), [mock libraries](https://github.com/uhop/tape-six/wiki/3rd%E2%80%90party-mock-libraries), [property-based testing](https://github.com/uhop/tape-six/wiki/3rd%E2%80%90party-property-based-testing).
+
 Assertions that throw `AssertionError` are automatically caught and reported.

package/llms.txt

@@ -105,11 +105,15 @@ The object passed to test functions. Provides assertions and test control.
 
 #### Utilities
 
-- `t.plan(n)` — declare expected assertion count (rarely needed).
+- `t.plan(n)` — record expected direct-assertion count; emits a `# plan != count: expected N, ran M` TAP comment at test end on mismatch (diagnostic, doesn't fail).
 - `t.comment(msg)` — emit a comment.
 - `t.skipTest(msg)` — skip current test with a message.
 - `t.bailOut(msg)` — abort entire test suite.
 
+### Plugins
+
+- `registerTesterMethod(name, fn)` — install a method on `Tester.prototype` from a plugin module. Idempotent for same `fn`; throws on collision with a different `fn`. Plugin imports are per-file (workers / subprocesses / iframes don't share module graphs).
+
 ### Hooks
 
 Hooks can be registered as standalone functions or via test options or Tester methods.
@@ -139,37 +143,6 @@ test('suite', async t => {
 test.beforeAll(() => { /* ... */ });
 ```
 
-## Subpath modules
-
-### tape-six/server — HTTP server harness
-
-Helpers for tests that need an ephemeral `node:http` server. Cross-runtime (Node, Bun, Deno; not for browser-side tests).
-
-```js
-import {withServer, startServer, setupServer} from 'tape-six/server';
-```
-
-- `withServer(serverHandler, clientHandler, opts?)` — scoped resource: spin up a server, run the test body with the base URL, tear down in `finally`. The 95% case.
-- `startServer(server, opts?)` — procedural primitive: returns `{server, base, port, host, close}`. For multi-phase tests or non-test code (e.g., `bin/tape6-server`) that wants long-term control. Races `'listening'` against `'error'` so port-busy rejects instead of hanging.
-- `setupServer(serverHandler, opts?)` — registers `beforeAll`/`afterAll` and returns a live-getter context for suite-shared servers. Don't destructure the returned object at module load — properties read live state on each access.
-- Options: `{host = '127.0.0.1', port = 0}`. Default host is explicit IPv4.
-
-`serverHandler` is the per-request callback (Node calls it once per incoming request). `clientHandler` is the per-scope test body (called once with the base URL). Either side may be the SUT.
-
-### tape-six/response — HTTP response helpers
-
-Reading helpers that work uniformly with both `Response` (fetch results) and `http.IncomingMessage` (Node low-level requests).
-
-```js
-import {asText, asJson, asBytes, header, headers} from 'tape-six/response';
-```
-
-- `asText(res)` — body as UTF-8 string.
-- `asJson(res)` — body parsed as JSON.
-- `asBytes(res)` — body as `Uint8Array`.
-- `header(res, name)` — single header value, case-insensitive. Returns `null` if absent.
-- `headers(res)` — all headers as a plain object with lowercase keys.
-
 ## Common patterns
 
 ### Basic test file
@@ -244,41 +217,6 @@ describe('my module', () => {
 });
 ```
 
-### Testing HTTP code with `withServer`
-
-```js
-import test from 'tape-six';
-import {withServer} from 'tape-six/server';
-import {asJson} from 'tape-six/response';
-
-test('GET /users returns the list', t =>
-  withServer(myHandler, async base => {
-    const res = await fetch(`${base}/users`);
-    t.equal(res.status, 200);
-    const body = await asJson(res);
-    t.equal(body.length, 3);
-  }));
-```
-
-Suite-shared server (multiple tests against one instance):
-
-```js
-import test, {beforeEach} from 'tape-six';
-import {setupServer} from 'tape-six/server';
-
-const server = setupServer((req, res) => {
-  recorded.push({method: req.method, url: req.url});
-  res.writeHead(204).end();
-});
-let recorded;
-beforeEach(() => { recorded = []; });
-
-test('records one request', async t => {
-  await fetch(`${server.base}/foo`);
-  t.equal(recorded.length, 1);
-});
-```
-
 ### Skip and TODO
 
 ```js
@@ -303,6 +241,8 @@ npx tape6-server --trace   # start browser test server
 - `TAPE6_JSONL` — force JSONL reporter (any non-empty value).
 - `TAPE6_MIN` — force minimal reporter (any non-empty value).
 - `TAPE6_TEST_FILE_NAME` — set by runners to identify the current test file.
+- `TAPE6_GRACE_TIMEOUT` — ms a worker gets to drain (run cleanup, flush) after the runner asks it to stop, before being force-killed (default: 5000).
+- `TAPE6_WORKER_TIMEOUT` — per-file wall-clock budget in ms; on expiry the runner stops that worker (default: 0, disabled). Complements the per-test `timeout` option: this one can stop a worker that ignores `t.signal`.
 
 ## Configuration (package.json)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "TAP-inspired unit test library for Node, Deno, Bun, and browsers. ES modules, TypeScript, zero dependencies.",
   "type": "module",
   "main": "index.js",
@@ -8,15 +8,6 @@
   "types": "index.d.ts",
   "exports": {
     ".": "./index.js",
-    "./server": {
-      "types": "./src/server.d.ts",
-      "default": "./src/server.js"
-    },
-    "./response": {
-      "types": "./src/response.d.ts",
-      "default": "./src/response.js"
-    },
-    "./bin/*": "./bin/*",
     "./*": "./src/*"
   },
   "bin": {
@@ -98,21 +89,21 @@
       "/tests/test-*.cjs",
       "/tests/cli/test-*.js"
     ],
+    "node": [
+      "/tests/node/test-*.js"
+    ],
     "browser": [
       "/tests/browser/test-*.html"
     ],
     "importmap": {
       "imports": {
         "tape-six": "../index.js",
-        "tape-six/": "../src/",
-        "chai": "../node_modules/chai/index.js"
+        "tape-six/": "../src/"
       }
     }
   },
   "devDependencies": {
-    "@types/chai": "^5.2.3",
-    "@types/node": "^25.6.0",
-    "chai": "^6.2.2",
+    "@types/node": "^25.9.1",
     "typescript": "^6.0.3"
   }
 }