tape-six 1.7.1 → 1.7.2

package/README.md

@@ -411,6 +411,7 @@ Test output can be controlled by flags. See [Supported flags](https://github.com
 
 The most recent releases:
 
+- 1.7.2 _Minor internal refactoring and fixes._
 - 1.7.1 _Added AI support, added timeout to start test runners, fixed some bugs in the sequential test runner._
 - 1.7.0 _New features: after/before hooks for tests, aliases for `suite()`, `describe()`, `it()`, `tape6-seq` — an in-process sequential test runner. Improvements: stricter monochrome detection, refactoring, bugfixes, updated dev dependencies and the documentation._
 - 1.6.0 _New features: support for `AssertionError` and 3rd-party assertion libraries based on it like `node:assert` and `chai`, support for `console.assert()`, support for `signal` to cancel asynchronous operations, tests wait for embedded tests, improved reporting of errors, updated dev dependencies._

package/bin/tape6-node.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import process from 'node:process';
+import os from 'node:os';
 import {fileURLToPath} from 'node:url';
 
 import {
@@ -88,7 +89,18 @@ const config = () => {
   } else {
     parallel = 0;
   }
-  if (!parallel) parallel = globalThis.navigator?.hardwareConcurrency || 1;
+  if (!parallel) {
+    if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+      parallel = navigator.hardwareConcurrency;
+    } else {
+      try {
+        parallel = os.availableParallelism();
+      } catch (e) {
+        void e;
+        parallel = 1;
+      }
+    }
+  }
 };
 
 const init = async () => {

package/llms-full.txt

@@ -0,0 +1,384 @@
+# tape-six
+
+> A TAP-based unit testing library for modern JavaScript (ES6+). Works in Node, Deno, Bun, and browsers. Runs ES modules natively, supports TypeScript without transpilation. The npm package name is `tape-six` but all internal names use `tape6`.
+
+- Minimal, zero-dependency test library with a familiar API
+- Test files are directly executable: `node test.js`, `bun run test.js`, `deno run -A test.js`
+- Parallel test execution via worker threads
+- TAP, TTY (colored), and JSONL output formats
+- Browser testing with built-in web UI and automation support (Puppeteer, Playwright)
+- Before/after hooks: `beforeAll`, `afterAll`, `beforeEach`, `afterEach`
+- `test()` is aliased as `suite()`, `describe()`, and `it()` for easy migration
+- Compatible with `AssertionError`-based libraries like `node:assert` and `chai`
+
+## Quick start
+
+Install:
+
+```bash
+npm i -D tape-six
+```
+
+Write a test (`tests/test-example.js`):
+
+```js
+import test from 'tape-six';
+
+test('example', t => {
+  t.ok(true, 'truthy');
+  t.equal(1 + 1, 2, 'math works');
+  t.deepEqual([1, 2], [1, 2], 'arrays match');
+});
+```
+
+Run it directly:
+
+```bash
+node tests/test-example.js
+```
+
+Or run all configured tests:
+
+```bash
+npx tape6 --flags FO
+```
+
+## Importing
+
+```js
+import test from 'tape-six';
+// or: import {test} from 'tape-six';
+// or: import {test, beforeAll, afterAll, beforeEach, afterEach} from 'tape-six';
+// or: import {describe, it} from 'tape-six';
+
+// CommonJS:
+// const {test} = require('tape-six');
+```
+
+## test() API
+
+`test` registers a test suite. All three arguments are optional and recognized by type:
+
+- `async test(name, options, testFn)` — registers a test suite.
+- `test.skip(name, options, testFn)` — registers a skipped test suite.
+- `test.todo(name, options, testFn)` — registers a TODO test suite (failures not counted).
+- `test.asPromise(name, options, testPromiseFn)` — registers a callback-style test: `testPromiseFn(tester, resolve, reject)`.
+
+Arguments:
+
+- `name` (string, optional) — test name. Defaults to function name or `'(anonymous)'`.
+- `options` (object, optional):
+  - `name` — overridden by the `name` argument.
+  - `skip` (boolean) — skip this test.
+  - `todo` (boolean) — mark as TODO.
+  - `timeout` (number, ms) — timeout for async tests.
+  - `beforeAll`, `afterAll`, `beforeEach`, `afterEach` — hook functions.
+  - `before` — alias for `beforeAll`.
+  - `after` — alias for `afterAll`.
+- `testFn` (function) — `async testFn(tester)`. Can be sync or async.
+
+Flexible call signatures:
+
+```js
+test(name, options, testFn);
+test(name, testFn);
+test(testFn);
+test(name, options);
+test(options, testFn);
+test(options);
+```
+
+Examples:
+
+```js
+test('foo', t => {
+  t.pass();
+});
+
+test('bar', async t => {
+  const result = await fetchData();
+  t.equal(result.status, 200);
+});
+
+test.skip('not ready yet', t => {
+  t.fail();
+});
+
+test.todo('work in progress', t => {
+  t.ok(false); // reported but not counted as failure
+});
+
+test.asPromise('callback style', (t, resolve, reject) => {
+  const stream = getStream();
+  stream.on('end', resolve);
+  stream.on('error', reject);
+});
+```
+
+### Embedded tests
+
+```js
+test('top', async t => {
+  t.pass();
+  await t.test('nested', async t => {
+    t.pass();
+  });
+});
+```
+
+Always `await` embedded tests to preserve execution order.
+
+## Tester API
+
+The `Tester` object is passed to test functions. All `msg` arguments are optional.
+
+### Properties
+
+- `signal` — `AbortSignal` triggered when the test is stopped or timed out.
+- `any` (alias `_`) — wildcard for deep equality matching.
+
+### Assert methods
+
+- `pass(msg)` — assert pass.
+- `fail(msg)` — assert fail.
+- `ok(val, msg)` — assert truthy. Aliases: `true()`, `assert()`.
+- `notOk(val, msg)` — assert falsy. Aliases: `false()`, `notok()`.
+- `error(err, msg)` — assert err is falsy. Aliases: `ifError()`, `ifErr()`, `iferror()`.
+- `strictEqual(a, b, msg)` — assert `a === b`. Aliases: `is()`, `equal()`, `isEqual()`, `equals()`, `strictEquals()`.
+- `notStrictEqual(a, b, msg)` — assert `a !== b`. Aliases: `not()`, `notEqual()`, `notEquals()`, `notStrictEquals()`, `doesNotEqual()`, `isUnequal()`, `isNotEqual()`, `isNot()`.
+- `looseEqual(a, b, msg)` — assert `a == b`. Alias: `looseEquals()`.
+- `notLooseEqual(a, b, msg)` — assert `a != b`. Alias: `notLooseEquals()`.
+- `deepEqual(a, b, msg)` — deep strict equality. Aliases: `same()`, `deepEquals()`, `isEquivalent()`.
+- `notDeepEqual(a, b, msg)` — not deeply equal. Aliases: `notSame()`, `notDeepEquals()`, `notEquivalent()`, `notDeeply()`, `isNotDeepEqual()`, `isNotEquivalent()`.
+- `deepLooseEqual(a, b, msg)` — deep loose equality.
+- `notDeepLooseEqual(a, b, msg)` — not deeply loosely equal.
+- `throws(fn, msg)` — assert fn throws.
+- `doesNotThrow(fn, msg)` — assert fn does not throw.
+- `matchString(string, regexp, msg)` — assert string matches regexp.
+- `doesNotMatchString(string, regexp, msg)` — assert string does not match regexp.
+- `match(a, b, msg)` — deep structural match (supports wildcards).
+- `doesNotMatch(a, b, msg)` — assert no deep match.
+- `rejects(promise, msg)` — assert promise rejects (async, await it). Alias: `doesNotResolve()`.
+- `resolves(promise, msg)` — assert promise resolves (async, await it). Alias: `doesNotReject()`.
+
+### Embedded test methods
+
+- `test(name, options, testFn)` — nested test suite (async, await it).
+- `skip(name, options, testFn)` — skip nested suite.
+- `todo(name, options, testFn)` — TODO nested suite.
+- `asPromise(name, options, testPromiseFn)` — callback-style nested suite.
+
+### Hooks
+
+- `beforeAll(fn)` / `before(fn)` — run before first nested test.
+- `afterAll(fn)` / `after(fn)` — run after last nested test.
+- `beforeEach(fn)` — run before each nested test.
+- `afterEach(fn)` — run after each nested test.
+
+### Miscellaneous
+
+- `plan(n)` — set expected number of assertions.
+- `comment(msg)` — send a comment to the reporter.
+- `skipTest(...args, msg)` — skip current test with a message.
+- `bailOut(msg)` — abort the test suite.
+
+### Expression evaluator
+
+- `OK(condition, msg, options)` — returns code string for `eval()`. Aliases: `TRUE()`, `ASSERT()`.
+  - `condition`: a JavaScript expression as a string.
+  - On failure, reports values of all variables in the expression.
+  - `options.self`: tester variable name (default: `"t"`).
+
+```js
+test('evaluator', t => {
+  const a = 1, b = 2;
+  eval(t.OK('a + b === 3'));
+});
+```
+
+## Before and after hooks
+
+Hooks are scoped — they only affect tests at their level.
+
+Top-level hooks (affect top-level tests only):
+
+```js
+import {test, beforeAll, afterAll, beforeEach, afterEach} from 'tape-six';
+
+beforeAll(() => { /* runs once before first top-level test */ });
+afterAll(() => { /* runs once after last top-level test */ });
+beforeEach(() => { /* runs before each top-level test */ });
+afterEach(() => { /* runs after each top-level test */ });
+```
+
+Nested hooks (via tester object):
+
+```js
+test('suite', async t => {
+  t.beforeEach(() => { /* before each nested test */ });
+  t.afterEach(() => { /* after each nested test */ });
+
+  await t.test('test 1', t => t.pass());
+  await t.test('test 2', t => t.pass());
+});
+```
+
+Hooks via options (reusable):
+
+```js
+const opts = {
+  beforeEach: () => setupDb(),
+  afterEach: () => teardownDb()
+};
+
+test('suite', opts, async t => {
+  await t.test('test 1', t => t.pass());
+});
+```
+
+Multiple hooks of the same type run in registration order (before) or reverse order (after).
+
+## Configuring tests
+
+Configuration is read from `tape6.json` or the `"tape6"` section of `package.json`:
+
+```json
+{
+  "tape6": {
+    "tests": ["/tests/test-*.*js"],
+    "cli": ["/tests/test-*.cjs"],
+    "browser": ["/tests/web/test-*.html"],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "tape-six/": "/node_modules/tape-six/src/"
+      }
+    }
+  }
+}
+```
+
+Environment-specific subsections: `node`, `deno`, `bun`, `browser`.
+
+## Command-line utilities
+
+### tape6
+
+Runs test files in parallel using worker threads.
+
+```bash
+tape6 [--flags FLAGS] [--par N] [tests...]
+```
+
+- `--flags FLAGS` — output control flags (see below).
+- `--par N` — number of parallel workers (default: all CPU cores).
+- No arguments: runs tests from configuration.
+
+### tape6-seq
+
+Sequential in-process runner. Same options as `tape6` but no threads.
+
+### tape6-server
+
+Web server for browser testing:
+
+```bash
+tape6-server [--trace] [--port N]
+```
+
+Default port: 3000. Navigate to `http://localhost:3000` for the web UI.
+
+### Runtime-specific runners
+
+- `tape6-node` — Node.js runner.
+- `tape6-bun` — Bun runner.
+- `tape6-deno` — Deno runner.
+
+## 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 --flags FO
+TAPE6_FLAGS=FO node tests/test-example.js
+```
+
+Browser: `http://localhost:3000/?flags=FO`
+
+## Environment variables
+
+- `TAPE6_FLAGS` — flags string.
+- `TAPE6_PAR` — number of parallel workers.
+- `TAPE6_TAP` — force TAP reporter (any non-empty value).
+- `TAPE6_JSONL` — force JSONL reporter (any non-empty value).
+- `TAPE6_TEST_FILE_NAME` — set by runners to identify the current test file.
+
+## Browser testing
+
+1. Start the server: `npm start` (runs `tape6-server --trace`).
+2. Open `http://localhost:3000` for the web UI.
+3. Or automate with Puppeteer/Playwright:
+
+```js
+// Puppeteer example
+import puppeteer from 'puppeteer';
+const browser = await puppeteer.launch({headless: true});
+const page = await browser.newPage();
+page.on('console', msg => console.log(msg.text()));
+await page.exposeFunction('__tape6_reportResults', async text => {
+  await browser.close();
+  process.exit(text === 'success' ? 0 : 1);
+});
+await page.goto('http://localhost:3000/tests/web/test-simple.html?flags=M');
+```
+
+```js
+// Playwright example
+import {chromium} from 'playwright';
+const browser = await chromium.launch({headless: true});
+const page = await browser.newPage();
+page.on('console', msg => console.log(msg.text()));
+await page.exposeFunction('__tape6_reportResults', async text => {
+  await browser.close();
+  process.exit(text === 'success' ? 0 : 1);
+});
+await page.goto('http://localhost:3000/tests/web/test-simple.html?flags=M');
+```
+
+## 3rd-party assertion libraries
+
+`tape-six` supports `AssertionError`-based assertions. You can use `node:assert` or `chai` inside test functions:
+
+```js
+import test from 'tape-six';
+import {assert, expect} from 'chai';
+
+test('with chai', t => {
+  expect(1).to.be.lessThan(2);
+  assert.deepEqual([1], [1]);
+});
+```
+
+```js
+import test from 'tape-six';
+import assert from 'node:assert/strict';
+
+test('with node:assert', t => {
+  assert.equal(1 + 1, 2);
+  assert.deepEqual({a: 1}, {a: 1});
+});
+```
+
+Assertions that throw `AssertionError` are automatically caught and reported.

package/llms.txt

@@ -0,0 +1,243 @@
+# tape-six
+
+> TAP-based unit test library for modern JavaScript and TypeScript. Works in Node, Deno, Bun, and browsers.
+
+## Install
+
+npm i -D tape-six
+
+## Quick start
+
+```js
+import test from 'tape-six';
+
+test('my test', async t => {
+  t.ok(true, 'truthy value');
+  t.equal(1 + 1, 2, 'addition works');
+  t.deepEqual({a: 1}, {a: 1}, 'objects are equal');
+});
+```
+
+Run: `node my-test.js` or `npx tape6 --flags FO`
+
+## API
+
+### test(name, options, testFn)
+
+Registers a test. All three arguments are optional and can be in any order (recognized by type).
+
+- `name` (string) — test name. Defaults to function name or '(anonymous)'.
+- `options` (object) — see TestOptions below.
+- `testFn` (function) — `async (t: Tester) => void`. Can be sync or async.
+
+Returns a promise that resolves when the test finishes. Usually no need to await.
+
+Aliases: `suite`, `describe`, `it` — all are the same function.
+
+```js
+import {test, describe, it, suite} from 'tape-six';
+```
+
+#### test.skip(name, options, testFn)
+
+Registers a test that will be skipped (not executed).
+
+#### test.todo(name, options, testFn)
+
+Registers a test marked as work-in-progress. Failures are reported but not counted.
+
+#### test.asPromise(name, options, testPromiseFn)
+
+Registers a test using callback-style completion: `(t, resolve, reject) => void`.
+
+### TestOptions
+
+- `name` (string) — test name.
+- `testFn` (function) — test function.
+- `skip` (boolean) — skip this test.
+- `todo` (boolean) — mark as TODO.
+- `timeout` (number) — timeout in ms. Test is marked failed if exceeded.
+- `beforeAll` / `before` (function) — run before all embedded tests.
+- `afterAll` / `after` (function) — run after all embedded tests.
+- `beforeEach` (function) — run before each embedded test.
+- `afterEach` (function) — run after each embedded test.
+
+### Tester (the `t` object)
+
+The object passed to test functions. Provides assertions and test control.
+
+#### Properties
+
+- `t.signal` — AbortSignal, aborted when test times out. Use for cancellation.
+- `t.any` (or `t._`) — symbol for matching any value in deepEqual/match.
+
+#### Assertions (all `msg` arguments are optional)
+
+- `t.pass(msg)` — unconditional pass.
+- `t.fail(msg)` — unconditional fail.
+- `t.ok(value, msg)` — assert truthy. Aliases: `true`, `assert`.
+- `t.notOk(value, msg)` — assert falsy. Aliases: `false`, `notok`.
+- `t.error(err, msg)` — assert err is falsy. Aliases: `ifError`, `ifErr`, `iferror`.
+- `t.strictEqual(a, b, msg)` — assert `a === b`. Aliases: `is`, `equal`, `equals`, `isEqual`, `strictEquals`.
+- `t.notStrictEqual(a, b, msg)` — assert `a !== b`. Aliases: `not`, `notEqual`, `notEquals`, `isNotEqual`, `doesNotEqual`, `isUnequal`, `notStrictEquals`, `isNot`.
+- `t.looseEqual(a, b, msg)` — assert `a == b`. Alias: `looseEquals`.
+- `t.notLooseEqual(a, b, msg)` — assert `a != b`. Alias: `notLooseEquals`.
+- `t.deepEqual(a, b, msg)` — recursive strict deep equality. Aliases: `same`, `deepEquals`, `isEquivalent`.
+- `t.notDeepEqual(a, b, msg)` — assert not deeply equal. Aliases: `notSame`, `notDeepEquals`, `notEquivalent`, `notDeeply`, `isNotDeepEqual`, `isNotEquivalent`.
+- `t.deepLooseEqual(a, b, msg)` — recursive loose deep equality.
+- `t.notDeepLooseEqual(a, b, msg)` — assert not deeply loosely equal.
+- `t.throws(fn, msg)` — assert fn() throws.
+- `t.doesNotThrow(fn, msg)` — assert fn() does not throw.
+- `t.matchString(string, regexp, msg)` — assert string matches regexp.
+- `t.doesNotMatchString(string, regexp, msg)` — assert string does not match regexp.
+- `t.match(a, b, msg)` — assert a matches pattern b (structural).
+- `t.doesNotMatch(a, b, msg)` — assert a does not match pattern b.
+- `t.rejects(promise, msg)` — assert promise rejects. **Async: must await.** Alias: `doesNotResolve`.
+- `t.resolves(promise, msg)` — assert promise resolves. **Async: must await.** Alias: `doesNotReject`.
+
+#### Embedded tests (all async, should be awaited)
+
+- `await t.test(name, options, testFn)` — nested test.
+- `await t.skip(name, options, testFn)` — nested skipped test.
+- `await t.todo(name, options, testFn)` — nested TODO test.
+- `await t.asPromise(name, options, testPromiseFn)` — nested callback-style test.
+
+#### Utilities
+
+- `t.plan(n)` — declare expected assertion count (rarely needed).
+- `t.comment(msg)` — emit a comment.
+- `t.skipTest(msg)` — skip current test with a message.
+- `t.bailOut(msg)` — abort entire test suite.
+
+### Hooks
+
+Hooks can be registered as standalone functions or via test options or Tester methods.
+
+```js
+import {test, beforeAll, afterAll, beforeEach, afterEach} from 'tape-six';
+// `before` is an alias for `beforeAll`, `after` is an alias for `afterAll`.
+
+beforeAll(() => { /* runs once before all tests */ });
+afterAll(() => { /* runs once after all tests */ });
+beforeEach(() => { /* runs before each test */ });
+afterEach(() => { /* runs after each test */ });
+
+// Or inside a test:
+test('suite', async t => {
+  t.beforeAll(() => { /* before embedded tests */ });
+  t.afterAll(() => { /* after embedded tests */ });
+  t.beforeEach(() => { /* before each embedded test */ });
+  t.afterEach(() => { /* after each embedded test */ });
+
+  await t.test('inner', t => { t.pass(); });
+});
+
+// Or via test.beforeAll(), test.afterAll(), etc:
+test.beforeAll(() => { /* ... */ });
+```
+
+## Common patterns
+
+### Basic test file
+
+```js
+import test from 'tape-six';
+
+test('arithmetic', t => {
+  t.equal(2 + 2, 4, 'addition');
+  t.ok(10 > 5, 'comparison');
+});
+
+test('async operation', async t => {
+  const result = await fetchData();
+  t.ok(result, 'got result');
+  t.equal(result.status, 200, 'status is 200');
+});
+```
+
+### Testing exceptions
+
+```js
+test('errors', async t => {
+  t.throws(() => { throw new Error('boom'); }, 'should throw');
+  t.doesNotThrow(() => 42, 'should not throw');
+  await t.rejects(Promise.reject(new Error('fail')), 'should reject');
+  await t.resolves(Promise.resolve(42), 'should resolve');
+});
+```
+
+### Nested tests with setup/teardown
+
+```js
+test('database tests', async t => {
+  let db;
+  t.beforeAll(async () => { db = await connect(); });
+  t.afterAll(async () => { await db.close(); });
+
+  await t.test('insert', async t => {
+    const result = await db.insert({name: 'Alice'});
+    t.ok(result.id, 'got an id');
+  });
+
+  await t.test('query', async t => {
+    const rows = await db.query('SELECT * FROM users');
+    t.ok(rows.length > 0, 'has rows');
+  });
+});
+```
+
+### Using any for partial matching
+
+```js
+test('partial match', t => {
+  const result = {id: 123, name: 'Alice', timestamp: Date.now()};
+  t.deepEqual(result, {id: 123, name: 'Alice', timestamp: t.any});
+});
+```
+
+### Using describe/it style
+
+```js
+import {describe, it} from 'tape-six';
+
+describe('my module', () => {
+  it('should work', t => {
+    t.ok(true);
+  });
+});
+```
+
+### Skip and TODO
+
+```js
+test.skip('not ready yet', t => { t.fail(); });
+test.todo('work in progress', t => { t.equal(1, 2); }); // failure not counted
+```
+
+## Running tests
+
+```bash
+node test-file.js          # run single file directly
+npx tape6 --flags FO       # run all configured tests, show failures only + fail once
+npx tape6-seq              # run sequentially (no worker threads)
+npx tape6-server --trace   # start browser test server
+```
+
+## Configuration (package.json)
+
+```json
+{
+  "scripts": {
+    "test": "tape6 --flags FO"
+  },
+  "tape6": {
+    "tests": ["/tests/test-*.*js"]
+  }
+}
+```
+
+## Links
+
+- Docs: https://github.com/uhop/tape-six/wiki
+- npm: https://www.npmjs.com/package/tape-six
+- Full LLM reference: https://github.com/uhop/tape-six/blob/master/llms-full.txt

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tape-six",
-  "version": "1.7.1",
-  "description": "The test harness for the modern JavaScript and TypeScript.",
+  "version": "1.7.2",
+  "description": "TAP-based unit test library for Node, Deno, Bun, and browsers. ES modules, TypeScript, zero dependencies.",
   "type": "module",
   "main": "index.js",
   "module": "index.js",
@@ -76,7 +76,9 @@
     "index.*",
     "bin",
     "web-app",
-    "src"
+    "src",
+    "llms.txt",
+    "llms-full.txt"
   ],
   "tape6": {
     "tests": [