tape-six 1.14.0 → 1.15.0

package/README.md

@@ -46,7 +46,7 @@ _(The examples below show actual output of test functions. In real life, success
 Running a test file directly:
 
 ```txt
-$ node tests/test-console.js
+$ node tests/manual/test-console.js
 ○ console test
   log: log #1
   ✓ pass - 1.542ms
@@ -63,8 +63,8 @@ $ node tests/test-console.js
 Running a test suite:
 
 ```txt
-$ npx tape6 tests/test-console.js tests/test-eval.js
-○ FILE: /tests/test-console.js
+$ npx tape6 tests/manual/test-console.js tests/test-eval.js
+○ FILE: /tests/manual/test-console.js
   ○ console test
     log: log #1
     ✓ pass - 0.338ms
@@ -75,7 +75,7 @@ $ npx tape6 tests/test-console.js tests/test-eval.js
     log: log #3
     err: error #2
   ✓ console test  2  0  - 1.286ms
-✓ FILE: /tests/test-console.js  2  0  - 7.411ms
+✓ FILE: /tests/manual/test-console.js  2  0  - 7.411ms
 ○ FILE: /tests/test-eval.js
   ○ OK test
     ✓ 1 < 2 - 1.28ms
@@ -427,6 +427,8 @@ Test output can be controlled by flags. See [Supported flags](https://github.com
 
 The most recent releases:
 
+- 1.15.0 _New: an HTTP request recorder. Bug fixes._
+- 1.14.1 _Bug fixes. Updated dependencies._
 - 1.14.0 _Internal housekeeping. Removed the Deno 2.9.0 workaround shim._
 - 1.13.0 _TypeScript declarations for the `EventServer`._
 - 1.12.0 _`tape6-server` is now pluggable, embeddable server for hermetic integration tests, runtime plugin registration, and an opt-in HTTP/2 mode._
@@ -455,5 +457,3 @@ The most recent releases:
 - 1.5.0 _Internal refactoring (moved state to reporters), added type identification of values in the DOM and TTY reporters, multiple minor fixes._
 
 The full release notes are in the wiki: [Release notes](https://github.com/uhop/tape-six/wiki/Release-notes).
-
-For more info consult full [release notes](https://github.com/uhop/tape-six/wiki/Release-notes).

package/index.js

@@ -166,6 +166,8 @@ const init = async () => {
     }
     reporter ||= new TapReporter({
       useJson: true,
+      // flat TAP stream: nested-test ids repeat, consumers need 1..N
+      renumberAsserts: true,
       originalConsole,
       hasColors
     });
@@ -225,60 +227,67 @@ const getTestFileName = ({isBrowser, isBun, isDeno, isNode}) => {
 let settings = null;
 
 const testRunner = async () => {
-  if (!settings) {
-    await selectTimer();
-    settings = await init();
-  }
+  // ref'd keep-alive — a bare run holds no other ref'd handle, so a test awaiting
+  // only an unref'd timer (AbortSignal.timeout on Node/Bun) would exit 0 mid-suite
+  const keepAlive = setInterval(() => {}, 2 ** 31 - 1);
+  try {
+    if (!settings) {
+      await selectTimer();
+      settings = await init();
+    }
 
-  const {isBrowser, isCli} = settings,
-    reporter = getReporter(),
-    testFileName = getTestFileName(settings);
+    const {isBrowser, isCli} = settings,
+      reporter = getReporter(),
+      testFileName = getTestFileName(settings);
 
-  reporter.report({
-    type: 'test',
-    test: 0,
-    name: testFileName ? 'FILE: /' + testFileName : ''
-  });
+    reporter.report({
+      type: 'test',
+      test: 0,
+      name: testFileName ? 'FILE: /' + testFileName : ''
+    });
 
-  reporter.state.beforeAll = getBeforeAll();
-  clearBeforeAll();
-  reporter.state.afterAll = getAfterAll();
-  clearAfterAll();
-  reporter.state.beforeEach = getBeforeEach();
-  clearBeforeEach();
-  reporter.state.afterEach = getAfterEach();
-  clearAfterEach();
-  reporter.state.isBeforeAllUsed = false;
+    reporter.state.beforeAll = getBeforeAll();
+    clearBeforeAll();
+    reporter.state.afterAll = getAfterAll();
+    clearAfterAll();
+    reporter.state.beforeEach = getBeforeEach();
+    clearBeforeEach();
+    reporter.state.afterEach = getAfterEach();
+    clearAfterEach();
+    reporter.state.isBeforeAllUsed = false;
 
-  const currentState = reporter.state;
+    const currentState = reporter.state;
 
-  for (;;) {
-    const tests = getTests();
-    if (!tests.length) break;
-    clearTests();
-    const canContinue = await runTests(tests);
-    if (!canContinue) break;
-    await new Promise(resolve => defer(resolve));
-  }
+    for (;;) {
+      const tests = getTests();
+      if (!tests.length) break;
+      clearTests();
+      const canContinue = await runTests(tests);
+      if (!canContinue) break;
+      await new Promise(resolve => defer(resolve));
+    }
 
-  await currentState?.runAfterAll();
+    await currentState?.runAfterAll();
 
-  const runHasFailed = reporter.state && reporter.state.failed > 0;
+    const runHasFailed = reporter.state && reporter.state.failed > 0;
 
-  reporter.report({
-    type: 'end',
-    test: 0,
-    name: testFileName ? 'FILE: /' + testFileName : '',
-    fail: runHasFailed
-  });
+    reporter.report({
+      type: 'end',
+      test: 0,
+      name: testFileName ? 'FILE: /' + testFileName : '',
+      fail: runHasFailed
+    });
 
-  if (!getConfiguredFlag() && runHasFailed) {
-    if (isCli) {
-      process.exitCode = 1;
+    if (!getConfiguredFlag() && runHasFailed) {
+      if (isCli) {
+        process.exitCode = 1;
+      }
     }
-  }
-  if (isBrowser && typeof __tape6_reportResults == 'function') {
-    __tape6_reportResults(runHasFailed ? 'failure' : 'success');
+    if (isBrowser && typeof __tape6_reportResults == 'function') {
+      __tape6_reportResults(runHasFailed ? 'failure' : 'success');
+    }
+  } finally {
+    clearInterval(keepAlive);
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "TAP-inspired unit test library for Node, Deno, Bun, and browsers. ES modules, TypeScript, zero dependencies.",
   "type": "module",
   "main": "index.js",
@@ -101,8 +101,8 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^26.1.0",
-    "prettier": "^3.9.4",
-    "typescript": "^6.0.3"
+    "@types/node": "^26.1.1",
+    "prettier": "^3.9.5",
+    "typescript": "^7.0.2"
   }
 }

package/src/State.js

@@ -186,9 +186,9 @@ export class State {
       typeof event.diffTime !== 'number' && (event.diffTime = event.time - this.startTime);
     }
 
-    // reporters read event.at / event.stackList only for failures — stack
-    // walking on passing assertions is wasted work
-    if (isFailed) {
+    // reporters read event.at / event.stackList for displayed failures (todo
+    // included) — stack walking on passing assertions is wasted work
+    if (event.fail && !event.skip) {
       if (
         event.type === 'assert' &&
         (event.operator === 'error' || event.operator === 'exception') &&

package/src/driver/TestWorker.d.ts

@@ -0,0 +1,54 @@
+import EventServer, {EventServerOptions, EventServerReporter} from '../utils/EventServer.js';
+
+/**
+ * Base class for driver-backed browser workers (`tape-six-puppeteer`,
+ * `tape-six-playwright`): owns the whole shared task lifecycle — per-task
+ * BrowserContext + Page with completion driven by the page `close` event, the
+ * `__tape6_reporter` / `__tape6_error` wiring, iframe injection via
+ * `driver/bootstrap`, cooperative drain (`tape6-terminate`) with a
+ * `graceTimeout` force-kill, and cleanup.
+ *
+ * Subclasses supply the four driver-adapter members below. Driver handles
+ * (browser, context, page) are `any` — they belong to the driver's API, not
+ * to this contract. The base standardizes on the single-object
+ * `page.evaluate(fn, arg)` convention, which both Puppeteer and Playwright
+ * accept.
+ */
+export class TestWorker extends EventServer {
+  constructor(reporter: EventServerReporter, numberOfTasks?: number, options?: EventServerOptions);
+
+  /** Engines this driver can launch; index 0 is the default. Adapter member. */
+  readonly supportedBrowsers: string[];
+  /** The driver's page-level error event: `'error'` (Puppeteer) or `'pageerror'` (Playwright). Adapter member. */
+  readonly pageErrorEvent: string;
+  /**
+   * Launch the named engine and return the driver's browser handle. Owns
+   * driver-specific launch options and the install-remediation error message.
+   * Adapter member.
+   */
+  launchBrowser(name: string, options: {insecure: boolean}): Promise<any>;
+  /**
+   * Create an isolated browsing context on the launched browser. `insecure`
+   * asks to accept the tape6 self-signed certificate (h2 mode) wherever the
+   * driver takes that flag. Adapter member.
+   */
+  newContext(browser: any, options: {insecure: boolean}): Promise<any>;
+
+  /**
+   * Diagnostic sink for task-setup failures (defaults to `console.error`).
+   * Overridable — e.g. tests collect instead of printing.
+   */
+  logError(...args: any[]): void;
+
+  /** `true` when `options.serverUrl` is `https:` — the h2 / TLS mode. */
+  readonly insecure: boolean;
+
+  /** The launched driver browser handle, `null` before launch / after cleanup. */
+  browser: any;
+
+  makeTask(fileName: string): string;
+  destroyTask(id: string, reason?: string): void;
+  cleanup(): Promise<void>;
+}
+
+export default TestWorker;

package/src/driver/TestWorker.js

@@ -0,0 +1,274 @@
+// @ts-self-types="./TestWorker.d.ts"
+
+import {isStopTest} from '../State.js';
+import EventServer from '../utils/EventServer.js';
+import {
+  htmlTestUrl,
+  iframeId,
+  supportedTestFileRe,
+  terminateMessage,
+  testPageSrcdoc
+} from './bootstrap.js';
+
+export class TestWorker extends EventServer {
+  #ready;
+  constructor(reporter, numberOfTasks, options) {
+    super(reporter, numberOfTasks, options);
+    this.counter = 0;
+    this.browser = null;
+    this.tasks = {};
+    this.graceTimers = {};
+    // deferred a microtask: subclass field initializers (the adapter members)
+    // run only after super() returns — #init must not read them earlier
+    this.#ready = Promise.resolve().then(() => this.#init());
+  }
+
+  // the driver adapter — subclasses supply these four members
+  get supportedBrowsers() {
+    throw new Error('TestWorker subclass must define supportedBrowsers');
+  }
+  get pageErrorEvent() {
+    throw new Error('TestWorker subclass must define pageErrorEvent');
+  }
+  async launchBrowser() {
+    throw new Error('TestWorker subclass must implement launchBrowser(name, {insecure})');
+  }
+  async newContext() {
+    throw new Error('TestWorker subclass must implement newContext(browser, {insecure})');
+  }
+
+  // diagnostic sink — embedders/tests may override (the default is fine in driver bins)
+  logError(...args) {
+    console.error(...args);
+  }
+
+  get insecure() {
+    return /^https:/i.test(this.options.serverUrl || '');
+  }
+
+  async #init() {
+    const name = this.options.browser || this.supportedBrowsers[0];
+    if (!this.supportedBrowsers.includes(name)) {
+      throw new Error(
+        `Unsupported browser "${name}". Supported: ${this.supportedBrowsers.join(', ')}.`
+      );
+    }
+    this.browser = await this.launchBrowser(name, {insecure: this.insecure});
+  }
+
+  makeTask(fileName) {
+    const id = String(++this.counter);
+    if (!supportedTestFileRe.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.#runTask(id, fileName))
+      .catch(error => {
+        // Launch/setup failure (e.g. the engine isn't installed): no page
+        // exists, so no 'close' event can drive completion — and without a
+        // reported failure the run would exit 0 (a false pass).
+        this.logError('Failed to run test:', fileName, error);
+        try {
+          this.report(id, {
+            name: error && error.message ? error.message : String(error),
+            test: 0,
+            marker: new Error(),
+            operator: 'error',
+            fail: true
+          });
+        } catch (reportError) {
+          if (!isStopTest(reportError)) throw reportError;
+        }
+        this.close(id);
+      });
+    return id;
+  }
+
+  // Each task runs in its own BrowserContext + Page (full origin/storage
+  // isolation), so the Node-side driver can force-kill a hung test by closing
+  // the context — the backstop in-page JS can't provide for itself. The test
+  // still runs in an iframe inside that page, so the proven srcdoc / importmap
+  // injection and the window.parent.__tape6_reporter data plane are unchanged.
+  //
+  // Completion is driven by the page 'close' event, never directly from a
+  // reported event: a normal end, a cooperative drain, and a force-kill all end
+  // in the context being closed, so close(id) fires exactly once per task down
+  // every path — including the hung-test kill that emits no event at all.
+  async #runTask(id, fileName) {
+    let context, page;
+    try {
+      context = await this.newContext(this.browser, {insecure: this.insecure});
+      page = await context.newPage();
+    } catch (error) {
+      this.logError('Failed to open context for:', fileName, error);
+      if (context) context.close().catch(() => {});
+      this.close(id);
+      return;
+    }
+    this.tasks[id] = {context, page};
+
+    page.on('close', () => {
+      this.#clearGrace(id);
+      if (this.tasks[id]) {
+        delete this.tasks[id];
+        this.close(id);
+      }
+    });
+    page.on(this.pageErrorEvent, e => console.error(e));
+
+    try {
+      await page.exposeFunction('__tape6_reporter', (taskId, event) => {
+        try {
+          this.report(taskId, event);
+          if ((event.type === 'end' && event.test === 0) || event.type === 'terminated') {
+            this.destroyTask(taskId, 'done');
+          }
+        } catch (error) {
+          if (!isStopTest(error)) throw error;
+        }
+      });
+
+      await page.exposeFunction('__tape6_error', (taskId, error) => {
+        if (error) {
+          this.report(taskId, {
+            type: 'comment',
+            name: 'fail to load: ' + (error.message || 'Worker error'),
+            test: 0
+          });
+          try {
+            this.report(taskId, {
+              name: String(error),
+              test: 0,
+              marker: new Error(),
+              operator: 'error',
+              fail: true,
+              data: {actual: error}
+            });
+          } catch (error) {
+            if (!isStopTest(error)) throw error;
+          }
+        }
+        this.destroyTask(taskId, 'done');
+      });
+
+      // navigate to the server so the iframe inherits the correct origin
+      await page.goto(this.options.serverUrl + '/--tests', {waitUntil: 'load'});
+      await page.evaluate(() => {
+        document.documentElement.innerHTML = '<head></head><body></body>';
+      });
+
+      // forward console messages only after the page is set up
+      page.on('console', msg =>
+        console[typeof console[msg.type()] == 'function' ? msg.type() : 'log'](msg.text())
+      );
+
+      await this.#runInIframe(id, page, fileName);
+
+      // A stop/bail (or deadline) can fire while this context is still being
+      // created — its destroyTask hits a not-yet-tracked task and no-ops. Catch
+      // up now that the iframe exists so a just-started task still aborts.
+      if (this.stopRequested) this.destroyTask(id, 'failOnce');
+    } catch (error) {
+      this.logError('Failed to set up test:', fileName, error);
+      this.destroyTask(id, 'done');
+    }
+  }
+
+  async #runInIframe(id, page, fileName) {
+    const flags = this.options.flags || '',
+      domId = iframeId(id);
+
+    if (/\.html?$/i.test(fileName)) {
+      const url = htmlTestUrl(fileName, {id, flags});
+      await page.evaluate(
+        ({id, domId, url}) => {
+          const iframe = document.createElement('iframe');
+          iframe.id = domId;
+          iframe.src = url;
+          iframe.onerror = error => /** @type {*} */ (window).__tape6_error(id, error);
+          document.body.append(iframe);
+        },
+        {id, domId, url}
+      );
+    } else {
+      const srcdoc = testPageSrcdoc(fileName, {id, flags, importmap: this.options.importmap});
+      await page.evaluate(
+        ({domId, srcdoc}) => {
+          const iframe = document.createElement('iframe');
+          iframe.id = domId;
+          iframe.srcdoc = srcdoc;
+          document.body.append(iframe);
+        },
+        {domId, srcdoc}
+      );
+    }
+  }
+
+  // Control plane. EventServer calls this with reason ∈ done | failOnce | timeout.
+  destroyTask(id, reason = 'done') {
+    if (reason === 'done') {
+      this.#kill(id);
+      return;
+    }
+    if (this.graceTimers[id]) return; // already draining
+    const task = this.tasks[id];
+    if (!task) return;
+    // Cooperative drain: post `tape6-terminate` into the running test's iframe so
+    // it unwinds at the next assertion (StopTest) and its cleanup hooks run. If
+    // it doesn't exit within graceTimeout, force-kill by closing the context —
+    // the real Node-side kill an in-page iframe can't perform on itself.
+    task.page
+      .evaluate(
+        ({domId, message}) => {
+          const iframe = /** @type {*} */ (document.getElementById(domId));
+          iframe?.contentWindow?.postMessage(message, '*');
+        },
+        {domId: iframeId(id), message: terminateMessage(reason)}
+      )
+      .catch(() => {});
+    this.graceTimers[id] = setTimeout(() => this.#kill(id), this.graceTimeout);
+  }
+
+  // Idempotent: the page 'close' handler clears tracking and calls close(id),
+  // so a second call (e.g. base close() -> destroyTask('done')) finds no task
+  // and returns.
+  #kill(id) {
+    this.#clearGrace(id);
+    const task = this.tasks[id];
+    if (!task) return;
+    task.context.close().catch(() => {});
+  }
+
+  #clearGrace(id) {
+    const grace = this.graceTimers[id];
+    if (grace) {
+      clearTimeout(grace);
+      delete this.graceTimers[id];
+    }
+  }
+
+  async cleanup() {
+    for (const id of Object.keys(this.graceTimers)) {
+      clearTimeout(this.graceTimers[id]);
+    }
+    this.graceTimers = {};
+    // Drop task tracking first so the page 'close' events fired by browser.close()
+    // below are no-ops (the run has already finished by the time cleanup runs).
+    this.tasks = {};
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+}
+
+export default TestWorker;

package/src/driver/bootstrap.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The in-page half of the browser-worker contract: the strings and shapes a
+ * driver (or the standalone web app) injects into a test page. Browser-safe —
+ * pure string building, no platform imports.
+ */
+
+/** Test files a browser worker can run: `.js`, `.mjs`, `.htm`, `.html`. */
+export const supportedTestFileRe: RegExp;
+
+/** DOM id of the iframe hosting task `id`: `test-iframe-<id>`. */
+export function iframeId(id: string): string;
+
+/** The cooperative-drain message posted into a running test's iframe. */
+export function terminateMessage(reason: string): {type: 'tape6-terminate'; reason: string};
+
+/** URL (path + query) that loads an `.html` test file as a task. */
+export function htmlTestUrl(fileName: string, options: {id: string; flags?: string}): string;
+
+/**
+ * Complete srcdoc HTML that runs a JS test file as a task: injects the
+ * importmap, the `__tape6_id` / `__tape6_testFileName` / `__tape6_flags`
+ * globals, and a module-script loader wired to `__tape6_error`.
+ */
+export function testPageSrcdoc(
+  fileName: string,
+  options: {id: string; flags?: string; importmap?: object | null}
+): string;

package/src/driver/bootstrap.js

@@ -0,0 +1,44 @@
+// @ts-self-types="./bootstrap.d.ts"
+
+// The in-page half of the browser-worker contract lives here: index.js talks
+// back through __tape6_reporter / __tape6_error / __tape6_reportResults, and
+// the iframe transport listens for the tape6-terminate message.
+
+export const supportedTestFileRe = /\.(?:js|mjs|htm|html)$/i;
+
+export const iframeId = id => 'test-iframe-' + id;
+
+export const terminateMessage = reason => ({type: 'tape6-terminate', reason});
+
+export const htmlTestUrl = (fileName, {id, flags = ''} = {}) => {
+  const search = new URLSearchParams({id, 'test-file-name': fileName});
+  if (flags) search.set('flags', flags);
+  return '/' + fileName + '?' + search.toString();
+};
+
+export const testPageSrcdoc = (fileName, {id, flags = '', importmap = null} = {}) =>
+  '<!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>';

package/src/driver/cli.d.ts

@@ -0,0 +1,40 @@
+import {TestWorker as DriverTestWorker} from './TestWorker.js';
+import {EventServerOptions, EventServerReporter} from '../utils/EventServer.js';
+
+/**
+ * Resolve the `--browsers` fan-out list against the singular `--browser`
+ * fallback: splits, honors `"all"`, dedupes, validates. Returns either the
+ * final list or the first unsupported name.
+ */
+export function resolveBrowsers(
+  listValue: string | undefined,
+  singular: string,
+  supportedBrowsers: string[]
+): {browsers: string[]; badBrowser?: undefined} | {browsers?: undefined; badBrowser: string};
+
+/**
+ * The whole driver-bin flow shared by `tape6-puppeteer` / `tape6-playwright`:
+ * option/env parsing (`--server-url`, `--browser`/`--browsers`, `--flags`,
+ * `--par`, `--start-server`, `--h2`, `--info`/`--self`/`--help`/`--version`),
+ * config + protocol resolution, the `controlFetch` readiness probe,
+ * `ensureServer` (self-launches this package's own `tape6-server`), the
+ * per-engine run loop, and summary / exit-code handling.
+ *
+ * A driver bin reduces to one call:
+ * `runDriverCli({packageUrl: import.meta.url, commandName, description, supportedBrowsers, TestWorker})`.
+ * By convention the bin lives in `bin/` — the version is read from
+ * `../package.json` relative to `packageUrl`.
+ */
+export function runDriverCli(config: {
+  packageUrl: string;
+  commandName: string;
+  description: string;
+  supportedBrowsers: string[];
+  TestWorker: new (
+    reporter: EventServerReporter,
+    numberOfTasks?: number,
+    options?: EventServerOptions
+  ) => DriverTestWorker;
+}): Promise<void>;
+
+export default runDriverCli;

package/src/driver/cli.js

@@ -0,0 +1,358 @@
+// @ts-self-types="./cli.d.ts"
+
+import {readFileSync} from 'node:fs';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+
+import {
+  getOptions,
+  getConfig,
+  initReporter,
+  showInfo,
+  printFlagOptions,
+  runtime
+} from '../utils/config.js';
+import {getReporter, setReporter} from '../test.js';
+import {selectTimer} from '../utils/timer.js';
+import {createControlFetch, isProtocolMismatch} from '../utils/controlFetch.js';
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+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}`;
+};
+
+// --browsers (fan-out) overrides --browser; the singular value is the
+// one-element fallback, so a single validation covers both paths
+export const resolveBrowsers = (listValue, singular, supportedBrowsers) => {
+  let browsers = String(listValue || '')
+    .split(',')
+    .map(name => name.trim())
+    .filter(Boolean);
+  if (browsers.includes('all')) browsers = [...supportedBrowsers];
+  browsers = [...new Set(browsers)];
+  if (!browsers.length) browsers = [singular];
+  const badBrowser = browsers.find(name => !supportedBrowsers.includes(name));
+  return badBrowser === undefined ? {browsers} : {badBrowser};
+};
+
+export const runDriverCli = async ({
+  packageUrl,
+  commandName,
+  description,
+  supportedBrowsers,
+  TestWorker
+}) => {
+  const rootFolder = process.cwd();
+  const controlFetch = createControlFetch(rootFolder);
+
+  const getVersion = () => {
+    // by convention the caller is bin/<commandName>.js — package.json is one up
+    const pkgPath = fileURLToPath(new URL('../package.json', packageUrl));
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+  };
+
+  const showSelf = () => {
+    const self = new URL(packageUrl);
+    if (self.protocol === 'file:') {
+      console.log(fileURLToPath(self));
+    } else {
+      console.log(self);
+    }
+    process.exit(0);
+  };
+
+  const showVersion = () => {
+    console.log(commandName + ' ' + getVersion());
+    process.exit(0);
+  };
+
+  const showHelp = () => {
+    console.log(commandName + ' ' + getVersion() + ' — ' + description + '\n');
+    console.log('Usage: ' + commandName + ' [options] [patterns...]\n');
+    const options = [
+      ['--flags, -f <flags>', 'Set reporter flags (env: TAPE6_FLAGS)'],
+      ['--par, -p <n>', 'Set parallelism level (env: TAPE6_PAR)'],
+      [
+        '--browser, -b <name>',
+        `Browser engine: ${supportedBrowsers.join('|')} (env: TAPE6_BROWSER, default: ${supportedBrowsers[0]})`
+      ],
+      [
+        '--browsers <list>',
+        'Run several engines: comma-separated or "all" (env: TAPE6_BROWSERS; overrides --browser)'
+      ],
+      [
+        '--server-url, -u <url>',
+        'Server URL (env: TAPE6_SERVER_URL, default: http://localhost:3000)'
+      ],
+      ['--start-server', 'Auto-start tape6-server'],
+      ['--h2', 'HTTP/2 mode: https server URL, --h2 self-launch (env: TAPE6_PROTOCOL=h2)'],
+      ['--info', 'Show configuration info and exit'],
+      ['--self', 'Print the path to this script and exit'],
+      ['--help, -h', 'Show this help message and exit'],
+      ['--version, -v', 'Show version and exit']
+    ];
+    console.log('Options:');
+    const width = options.reduce((max, [flag]) => Math.max(max, flag.length), 0) + 2;
+    for (const [flag, desc] of options) {
+      console.log('  ' + flag.padEnd(width) + desc);
+    }
+    printFlagOptions();
+    process.exit(0);
+  };
+
+  const probeServer = async serverUrl => {
+    try {
+      const response = await controlFetch(serverUrl + '/--tests');
+      return response.ok ? 'ok' : 'down';
+    } catch (error) {
+      return isProtocolMismatch(error) ? 'mismatch' : 'down';
+    }
+  };
+
+  const ensureServer = async (serverUrl, startServer, h2) => {
+    const mismatchMsg =
+      `Error: a TLS request to ${serverUrl} got a plaintext HTTP answer — ` +
+      'an h1 (non-TLS) server is listening there.\n' +
+      'Stop it, or drop --h2 / use an http: --server-url to match it.\n';
+
+    let status = await probeServer(serverUrl);
+    if (status === 'ok') return null;
+
+    if (!startServer) {
+      console.error(
+        status === 'mismatch'
+          ? mismatchMsg
+          : `Error: tape6-server is not reachable at ${serverUrl}\n\n` +
+              'Start it manually:\n' +
+              `  npx tape6-server${h2 ? ' --h2' : ''}\n\n` +
+              'Or re-run with --start-server:\n' +
+              `  ${commandName} --start-server --flags FO\n`
+      );
+      process.exit(1);
+    }
+
+    if (status === 'mismatch') {
+      // chained runs: the previous run's h1 server child may still be releasing
+      // the port — give it a grace window before self-launching
+      const graceDeadline = Date.now() + 4000;
+      while (status === 'mismatch' && Date.now() < graceDeadline) {
+        await sleep(250);
+        status = await probeServer(serverUrl);
+      }
+      if (status === 'ok') return null;
+      if (status === 'mismatch') {
+        console.error(mismatchMsg);
+        process.exit(1);
+      }
+    }
+
+    // this module ships inside tape-six — its own server bin is two levels up
+    const serverBin = fileURLToPath(new URL('../../bin/tape6-server.js', import.meta.url)),
+      serverParts = new URL(serverUrl),
+      host = serverParts.hostname,
+      port = serverParts.port || '3000',
+      // h2 server mode is Node-only (tape6-server refuses it elsewhere), so
+      // under Bun/Deno the h2 server child runs on PATH's node
+      execPath = h2 && runtime.name !== 'node' ? 'node' : process.execPath,
+      child = spawn(execPath, h2 ? [serverBin, '--h2'] : [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('error', error => {
+      exited = true;
+      exitCode = null;
+      stderrData += (error && error.message) || String(error);
+    });
+    child.on('exit', code => {
+      exited = true;
+      exitCode = code;
+    });
+    child.unref();
+
+    const startDeadline = Date.now() + 15000;
+    while (Date.now() < startDeadline) {
+      await sleep(500);
+      if (exited) {
+        console.error(
+          `Error: tape6-server exited with code ${exitCode} while starting on ${host}:${port}` +
+            (stderrData ? '\n' + stderrData.trim() : '')
+        );
+        process.exit(1);
+      }
+      status = await probeServer(serverUrl);
+      if (status === 'ok') return child;
+      if (status === 'mismatch') {
+        child.kill();
+        console.error(mismatchMsg);
+        process.exit(1);
+      }
+    }
+
+    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 options = getOptions({
+    '--self': {fn: showSelf, isValueRequired: false},
+    '--start-server': {isValueRequired: false},
+    '--h2': {isValueRequired: false},
+    '--info': {isValueRequired: false},
+    '--server-url': {aliases: ['-u'], initialValue: getServerUrl(), isValueRequired: true},
+    '--browser': {
+      aliases: ['-b'],
+      initialValue: process.env.TAPE6_BROWSER || supportedBrowsers[0],
+      isValueRequired: true
+    },
+    '--browsers': {initialValue: process.env.TAPE6_BROWSERS || '', isValueRequired: true},
+    '--help': {aliases: ['-h'], fn: showHelp, isValueRequired: false},
+    '--version': {aliases: ['-v'], fn: showVersion, isValueRequired: false}
+  });
+
+  // mirrors tape6-server's flag > env > config resolution, so the URL scheme
+  // below agrees with the protocol a self-launched server will pick
+  let protocol = options.optionFlags['--h2'] === '' ? 'h2' : process.env.TAPE6_PROTOCOL || '';
+  if (!protocol) protocol = (await getConfig(rootFolder)).server?.protocol || 'h1';
+
+  let serverUrl = options.optionFlags['--server-url'].replace(/\/+$/, '');
+  if (protocol === 'h2') serverUrl = serverUrl.replace(/^http:/i, 'https:');
+  // an explicit https: --server-url means TLS regardless of --h2
+  const secure = /^https:/i.test(serverUrl);
+
+  options.flags.serverUrl = serverUrl;
+  options.flags.browser = options.optionFlags['--browser'];
+
+  const resolved = resolveBrowsers(
+    options.optionFlags['--browsers'],
+    options.flags.browser,
+    supportedBrowsers
+  );
+  if (resolved.badBrowser !== undefined) {
+    console.error(
+      `Error: unsupported browser "${resolved.badBrowser}". Choose one of: ${supportedBrowsers.join(', ')}.`
+    );
+    await new Promise(r => process.stderr.write('', r));
+    process.exitCode = 1;
+    return;
+  }
+  const browsers = resolved.browsers;
+
+  await Promise.all([initReporter(getReporter, setReporter, options.flags), selectTimer()]);
+
+  if (options.optionFlags['--info'] === '') {
+    showInfo(options, []);
+    await new Promise(r => process.stdout.write('', r));
+    process.exitCode = 0;
+    return;
+  }
+
+  const startServer = options.optionFlags['--start-server'] === '';
+
+  const serverChild = await ensureServer(serverUrl, startServer, secure);
+
+  console.log(
+    `Connected to ${serverUrl} (${serverChild ? 'self-launched' : 'external'}); ` +
+      (browsers.length > 1 ? `browsers: ${browsers.join(', ')}` : `browser: ${browsers[0]}`)
+  );
+
+  const shutdown = code => {
+    serverChild?.kill();
+    process.exit(code);
+  };
+
+  process.on('uncaughtException', (error, origin) => {
+    console.error('UNHANDLED ERROR:', origin, error);
+    shutdown(1);
+  });
+
+  let files = [];
+  try {
+    if (options.files.length) {
+      const query = options.files.map(p => 'q=' + encodeURIComponent(p)).join('&');
+      const response = await controlFetch(serverUrl + '/--patterns?' + query);
+      if (response.ok) files = await response.json();
+    }
+    if (!files.length) {
+      const response = await controlFetch(serverUrl + '/--tests');
+      if (response.ok) files = await response.json();
+    }
+  } catch {}
+
+  if (!files.length) {
+    console.log('No test files found on the server.');
+    shutdown(1);
+  }
+
+  let importmap = null;
+  try {
+    const response = await controlFetch(serverUrl + '/--importmap');
+    if (response.ok) importmap = await response.json();
+  } catch {}
+
+  const failedBrowsers = [];
+  for (let i = 0; i < browsers.length; ++i) {
+    const browser = browsers[i];
+    if (i) {
+      // fresh reporter per engine (correct per-engine counts and summary):
+      // initReporter() only constructs into an empty slot
+      setReporter(null);
+      await initReporter(getReporter, setReporter, options.flags);
+    }
+    if (browsers.length > 1) console.log(`\nBrowser: ${browser}`);
+
+    const reporter = getReporter(),
+      worker = new TestWorker(reporter, options.parallel, {
+        ...options.flags,
+        browser,
+        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();
+
+    if (hasFailed) failedBrowsers.push(browser);
+  }
+
+  if (browsers.length > 1) {
+    console.log(
+      '\nBrowsers: ' +
+        browsers.map(name => name + (failedBrowsers.includes(name) ? ' FAIL' : ' PASS')).join(', ')
+    );
+  }
+
+  serverChild?.kill();
+  await new Promise(r => process.stdout.write('', r));
+  process.exitCode = failedBrowsers.length ? 1 : 0;
+};
+
+export default runDriverCli;

package/src/reporters/TTYReporter.js

@@ -302,8 +302,10 @@ export class TTYReporter extends Reporter {
             this.out(this.lowWhite('  actual:   ') + this.formatValue(actual));
           }
 
-          this.out(this.lowWhite('  stack: |-'));
-          event.stackList.forEach(line => this.out(this.lowWhite('    at ' + line)));
+          if (Array.isArray(event.stackList) && event.stackList.length) {
+            this.out(this.lowWhite('  stack: |-'));
+            event.stackList.forEach(line => this.out(this.lowWhite('    at ' + line)));
+          }
         }
         break;
     }

package/src/reporters/TapReporter.js

@@ -30,18 +30,37 @@ const formatValue = value => {
   return JSON.stringify(value);
 };
 
+// expected/actual arrive pre-serialized; parse for the signature strip
+const parseValue = text => {
+  if (typeof text != 'string') return text;
+  try {
+    const value = JSON.parse(text);
+    if (value && value[signature] === signature) delete value[signature];
+    return value;
+  } catch {
+    return text;
+  }
+};
+
+const formatSerialized = text => {
+  const value = parseValue(text);
+  return typeof value == 'string' ? JSON.stringify(value) : formatValue(value);
+};
+
 export class TapReporter extends Reporter {
   constructor({
     write,
     failOnce = false,
     useJson = false,
-    renumberAsserts = false,
+    // flat TAP output repeats nested/per-file ids — consumers need 1..N
+    renumberAsserts = true,
     hasColors = true,
     originalConsole
   } = {}) {
     super({failOnce});
     this.console = originalConsole || console;
-    this.write = write || (hasColors ? this.logger : (...args) => this.writeOut(...args));
+    // the style arg must not reach writeOut — it prints every argument
+    this.write = write || (hasColors ? this.logger : text => this.writeOut(text));
     this.renumberAsserts = renumberAsserts;
     this.useJson = useJson;
     this.assertCounter = 0;
@@ -163,10 +182,10 @@ export class TapReporter extends Reporter {
               this.write('  operator: ' + event.operator, 'yaml');
               this.write('  message:  ' + formatValue(nameLines), 'yaml');
               if (event.hasOwnProperty('expected')) {
-                this.write('  expected: ' + formatValue(event.expected), 'yaml');
+                this.write('  expected: ' + formatSerialized(event.expected), 'yaml');
               }
               if (event.hasOwnProperty('actual')) {
-                this.write('  actual:   ' + formatValue(event.actual), 'yaml');
+                this.write('  actual:   ' + formatSerialized(event.actual), 'yaml');
               }
               event.at && this.write('  at: ' + event.at, 'yaml');
             } else {
@@ -176,8 +195,8 @@ export class TapReporter extends Reporter {
               ).forEach(line => this.write(line, 'yaml'));
               yamlFormatter(
                 {
-                  expected: event.expected && JSON.parse(event.expected),
-                  actual: event.actual && JSON.parse(event.actual)
+                  expected: parseValue(event.expected),
+                  actual: parseValue(event.actual)
                 },
                 formatterOptions
               ).forEach(line => this.write(line, 'yaml'));
@@ -185,8 +204,13 @@ export class TapReporter extends Reporter {
                 this.write(line, 'yaml')
               );
             }
-            this.write('  stack: |-', 'yaml');
-            event.stackList.forEach(line => this.write('    at ' + line, 'yaml'));
+            if (Array.isArray(event.stackList) && event.stackList.length) {
+              // quoted list, not a block scalar: prove's YAMLish reader has no |-
+              this.write('  stack:', 'yaml');
+              event.stackList.forEach(line =>
+                this.write('    - ' + JSON.stringify('at ' + line), 'yaml')
+              );
+            }
             this.write('  ...', 'yaml');
           }
         }

package/src/server.d.ts

@@ -1,4 +1,4 @@
-import type {RequestListener, Server} from 'node:http';
+import type {IncomingMessage, RequestListener, Server, ServerResponse} from 'node:http';
 
 /**
  * Result of starting a server. Properties reflect the actual bound address
@@ -57,6 +57,32 @@ export function withServer<T>(
   opts?: ServerOptions
 ): Promise<T>;
 
+/** One request captured by a `record()` listener. */
+export interface RecordedRequest {
+  method: string;
+  url: string;
+  /** Lower-cased header names (Node's normalization), copied to a plain object. */
+  headers: Record<string, string | string[] | undefined>;
+  /** The full request body, eagerly buffered as UTF-8 text (`''` when empty). */
+  body: string;
+}
+
+/** A request listener that records every request it serves into `requests`. */
+export type RecordingListener = RequestListener & {requests: RecordedRequest[]};
+
+/**
+ * Recording wrapper for the harness: returns a request listener that buffers
+ * each incoming request into a `RecordedRequest` on its `requests` array,
+ * then answers `204` — or delegates to `handler` when one is given.
+ *
+ * Eager by design: the body is fully drained before delegation, so `handler`
+ * reads `entry.body` (its third argument) — never the already-consumed `req`
+ * stream. Reset between tests with `rec.requests.length = 0`.
+ */
+export function record(
+  handler?: (req: IncomingMessage, res: ServerResponse, entry: RecordedRequest) => void
+): RecordingListener;
+
 /**
  * Hook-registering helper for suite-shared servers. Registers `beforeAll` to
  * start the server and `afterAll` to close it; returns a live-getter context

package/src/server.js

@@ -41,6 +41,27 @@ export const withServer = async (serverHandler, clientHandler, opts) => {
   }
 };
 
+export const record = handler => {
+  const recorder = (req, res) => {
+    req.setEncoding('utf8');
+    let body = '';
+    req.on('data', chunk => (body += chunk));
+    req.on('end', () => {
+      const entry = {method: req.method, url: req.url, headers: {...req.headers}, body};
+      recorder.requests.push(entry);
+      if (handler) {
+        // eager: the body is already drained — handlers read entry.body, not req
+        handler(req, res, entry);
+      } else {
+        res.statusCode = 204;
+        res.end();
+      }
+    });
+  };
+  recorder.requests = [];
+  return recorder;
+};
+
 export const setupServer = (serverHandler, opts) => {
   let lifecycle = null;
   beforeAll(async () => {

package/src/utils/EventServer.d.ts

@@ -10,10 +10,11 @@
 export type DestroyReason = 'done' | 'failOnce' | 'timeout';
 
 /**
- * A test event routed to the reporter — a loose bag (`type`, `test`,
- * `name`, `marker`, `operator`, `fail`, `data`, ...). See TESTING.md.
+ * A test event routed to the reporter. `type` / `test` are the protocol
+ * spine (declared — sisters branch on them); the rest is a loose bag
+ * (`name`, `marker`, `operator`, `fail`, `data`, ...). See TESTING.md.
  */
-export type TestEvent = {[key: string]: unknown};
+export type TestEvent = {type: string; test?: number; [key: string]: unknown};
 
 /**
  * The reporter surface `EventServer` needs. Structural — every tape-six
@@ -21,13 +22,16 @@ export type TestEvent = {[key: string]: unknown};
  */
 export interface EventServerReporter {
   report(event: TestEvent, suppressStopTest?: boolean): void;
-  state?: {stopTest?: boolean; [key: string]: unknown} | null;
+  // no index signature: class-typed states (`State`) have none and must remain assignable;
+  // declared keys = the State-owned surface sisters read (proc: `failed`)
+  state?: {stopTest?: boolean; failed?: number} | null;
 }
 
 /**
  * Options consumed by the base class. Runners pass their own keys through
  * (`flags`, `importmap`, `serverUrl`, `browser`, ...) — hence the index
- * signature.
+ * signature; `any`, not `unknown`, so checked-JS siblings read pass-through
+ * keys without casts (2026-07-10 decision, applies to all sidecar bags).
  */
 export interface EventServerOptions {
   /**
@@ -40,7 +44,7 @@ export interface EventServerOptions {
    * `TAPE6_WORKER_TIMEOUT` via `getOptions()`.
    */
   workerTimeout?: number;
-  [key: string]: unknown;
+  [key: string]: any;
 }
 
 /**

package/src/utils/config.d.ts

@@ -21,13 +21,29 @@ export const printFlagOptions: () => void;
  */
 export const resolvePatterns: (rootFolder: string, patterns: string[]) => Promise<string[]>;
 
+/**
+ * The `tape6.server` section — core-owned (`src/test-server.js` reads it);
+ * declared so driver siblings read it cast-free. Still a user-authored bag,
+ * hence the open index.
+ */
+export interface Tape6ServerConfig {
+  protocol?: 'h1' | 'h2';
+  plugins?: (string | {module: string; name?: string; prefix?: string})[];
+  remotePlugins?: boolean;
+  webAppPath?: string;
+  cert?: string;
+  key?: string;
+  [key: string]: any;
+}
+
 /** The `tape6` config bag: test-set patterns keyed by environment, plus the importmap. */
 export interface Tape6Config {
   tests?: string | string[];
   cli?: string | string[];
   browser?: string | string[];
   importmap?: {imports: Record<string, string>};
-  [key: string]: unknown;
+  server?: Tape6ServerConfig;
+  [key: string]: any;
 }
 
 /** Read `tape6.json`, else `package.json#tape6`, else the default patterns. */
@@ -74,19 +90,19 @@ export interface ArgOption {
   initialValue?: string | null;
   isValueRequired?: boolean;
   /** Custom handler; mutate `flags` directly. */
-  fn?: (flags: Record<string, unknown>, name: string, value: string) => void;
+  fn?: (flags: Record<string, any>, name: string, value: string) => void;
 }
 
 /** A bare function is shorthand for `{fn, isValueRequired: true}`. */
 export type ArgOptions = Record<
   string,
-  ArgOption | ((flags: Record<string, unknown>, name: string, value: string) => void)
+  ArgOption | ((flags: Record<string, any>, name: string, value: string) => void)
 >;
 
 /** Parse CLI args into files + flag values. CLI-only: in a browser returns an empty array. */
 export const processArgs: (argOptions: ArgOptions) => {
   files: string[];
-  flags: Record<string, unknown>;
+  flags: Record<string, any>;
 };
 
 export interface RunnerFlags {
@@ -107,7 +123,7 @@ export interface RunnerFlags {
   /** Consumed by the parent (`EventServer`) only; children ignore them. */
   graceTimeout?: number;
   workerTimeout?: number;
-  [key: string]: unknown;
+  [key: string]: any;
 }
 
 export interface RunnerOptions {
@@ -115,7 +131,7 @@ export interface RunnerOptions {
   parallel: number;
   files: string[];
   /** Raw parsed option values, keyed by canonical option name. */
-  optionFlags: Record<string, unknown>;
+  optionFlags: Record<string, any>;
 }
 
 /**

package/src/utils/config.js

@@ -339,7 +339,11 @@ export const initReporter = async (getReporter, setReporter, flags) => {
         runtime.getEnvVar('NODE_DISABLE_COLORS') ||
         runtime.getEnvVar('FORCE_COLOR') === '0'
       ),
-      customOptions = reporterType === 'tap' ? {useJson: true, hasColors} : {...flags, hasColors},
+      customOptions =
+        reporterType === 'tap'
+          ? // flat TAP stream: per-file ids restart, consumers need 1..N
+            {useJson: true, renumberAsserts: true, hasColors}
+          : {...flags, hasColors},
       customReporter = new CustomReporter(customOptions);
     setReporter(customReporter);
   }

package/src/utils/yamlFormatter.js

@@ -11,7 +11,9 @@ const repeatString = (n, string = ' ') => {
 
 const hasNewline = /\n/,
   hasColon = /:/,
-  forceQuotes = /^(?:@|`|\s|$|true$|false$|null$|.+\s$)/;
+  forceQuotes = /^(?:@|`|\s|$|true$|false$|null$|.+\s$)/,
+  // plain-scalar hazards: leading indicators, colon-space/end, comment intro, tabs
+  yamlUnsafe = /^[[\]{}#&*!|>'"%,]|^[-?:](?:\s|$)|:(?:\s|$)|\s#|\t/;
 
 const getDataEncoding = value => {
   switch (typeof value) {
@@ -21,7 +23,8 @@ const getDataEncoding = value => {
       if (!isNaN(value)) return {inline: true, string: '"' + value + '"'};
       {
         const encoded = JSON.stringify(value);
-        if (value.length + 2 === encoded.length) return {inline: true, string: value};
+        if (value.length + 2 === encoded.length && !yamlUnsafe.test(value))
+          return {inline: true, string: value};
         return {inline: true, string: encoded};
       }
     case 'boolean':
@@ -37,7 +40,7 @@ const getDataEncoding = value => {
       return {skip: true};
   }
   if (value === null) return {inline: true, string: 'null'};
-  if (value instanceof Date) return {inline: true, string: value.toUTCString()};
+  if (value instanceof Date) return {inline: true, string: JSON.stringify(value.toUTCString())};
   if (value instanceof Set || value instanceof Map) return {skip: true};
   if (Array.isArray(value) && !value.length) return {inline: true, string: '[]'};
   const keys = Object.keys(value);
@@ -50,6 +53,7 @@ const getKeyEncoding = key => {
   if (hasNewline.test(key)) return {string: key.split('\n')};
   const encoded = JSON.stringify(key);
   if (key.length + 2 === encoded.length) {
+    if (yamlUnsafe.test(key)) return {inline: true, string: encoded};
     if (hasColon.test(key)) return {string: key};
     return {inline: true, string: key};
   }