tape-six 1.1.0 → 1.1.2

package/README.md

@@ -236,6 +236,8 @@ See [set-up tests](https://github.com/uhop/tape-six/wiki/Set-up-tests) for detai
 
 The most recent releases:
 
+- 1.1.2 _Updated dependencies._
+- 1.1.1 _Technical re-release with the missing `index.d.ts` file._
 - 1.1.0 _Added TypeScript support._
 - 1.0.4 _Bugfix for platform-specific tests, old platforms, minor updates to accommodate Deno 2, updated dev deps._
 - 1.0.3 _Minor update to accommodate changes in Bun and updated dev deps._

package/bin/tape6-bun.js

@@ -2,11 +2,10 @@
 
 import {fileURLToPath} from 'node:url';
 
-import {resolveTests, resolvePatterns} from '../src/utils/config.js';
+import {resolveTests, resolvePatterns, getReporter as getReporterType} from '../src/utils/config.js';
 
 import {getReporter, setReporter} from '../src/test.js';
 import State, {StopTest} from '../src/State.js';
-import TapReporter from '../src/TapReporter.js';
 import {selectTimer} from '../src/utils/timer.js';
 
 import TestWorker from '../src/bun/TestWorker.js';
@@ -88,25 +87,22 @@ const config = () => {
   if (!parallel) parallel = globalThis.navigator?.hardwareConcurrency || 1;
 };
 
+const reporters = {
+  jsonl: 'JSONLReporter.js',
+  tap: 'TapReporter.js',
+  tty: 'TTYReporter.js'
+};
+
 const init = async () => {
-  let reporter = getReporter();
-  if (!reporter) {
-    if (Bun.env.TAPE6_JSONL) {
-      const JSONLReporter = (await import('../src/JSONLReporter.js')).default,
-        jsonlReporter = new JSONLReporter(options);
-      reporter = jsonlReporter.report.bind(jsonlReporter);
-    } else if (!Bun.env.TAPE6_TAP) {
-      const TTYReporter = (await import('../src/TTYReporter.js')).default,
-        ttyReporter = new TTYReporter(options);
-      ttyReporter.testCounter = -2;
-      ttyReporter.technicalDepth = 1;
-      reporter = ttyReporter.report.bind(ttyReporter);
-    }
-    if (!reporter) {
-      const tapReporter = new TapReporter({useJson: true, hasColors: !options.monochrome});
-      reporter = tapReporter.report.bind(tapReporter);
-    }
-    setReporter(reporter);
+  const currentReporter = getReporter();
+  if (!currentReporter) {
+    const reporterType = getReporterType(),
+      reporterFile = reporters[reporterType] || reporters.tty,
+      CustomReporter = (await import('../src/' + reporterFile)).default,
+      customOptions =
+        reporterType === 'tap' ? {useJson: true, hasColors: !options.monochrome} : options,
+      customReporter = new CustomReporter(customOptions);
+    setReporter(customReporter.report.bind(customReporter));
   }
 
   if (files.length) {

package/bin/tape6-deno.js

@@ -2,11 +2,10 @@
 
 import {fileURLToPath} from 'node:url';
 
-import {resolveTests, resolvePatterns} from '../src/utils/config.js';
+import {resolveTests, resolvePatterns, getReporter as getReporterType} from '../src/utils/config.js';
 
 import {getReporter, setReporter} from '../src/test.js';
 import State, {StopTest} from '../src/State.js';
-import TapReporter from '../src/TapReporter.js';
 import {selectTimer} from '../src/utils/timer.js';
 
 import TestWorker from '../src/deno/TestWorker.js';
@@ -88,25 +87,22 @@ const config = () => {
   if (!parallel) parallel = globalThis.navigator?.hardwareConcurrency || 1;
 };
 
+const reporters = {
+  jsonl: 'JSONLReporter.js',
+  tap: 'TapReporter.js',
+  tty: 'TTYReporter.js'
+};
+
 const init = async () => {
-  let reporter = getReporter();
-  if (!reporter) {
-    if (Deno.env.get('TAPE6_JSONL')) {
-      const JSONLReporter = (await import('../src/JSONLReporter.js')).default,
-        jsonlReporter = new JSONLReporter(options);
-      reporter = jsonlReporter.report.bind(jsonlReporter);
-    } else if (!Deno.env.get('TAPE6_TAP')) {
-      const TTYReporter = (await import('../src/TTYReporter.js')).default,
-        ttyReporter = new TTYReporter(options);
-      ttyReporter.testCounter = -2;
-      ttyReporter.technicalDepth = 1;
-      reporter = ttyReporter.report.bind(ttyReporter);
-    }
-    if (!reporter) {
-      const tapReporter = new TapReporter({useJson: true, hasColors: !options.monochrome});
-      reporter = tapReporter.report.bind(tapReporter);
-    }
-    setReporter(reporter);
+  const currentReporter = getReporter();
+  if (!currentReporter) {
+    const reporterType = getReporterType(),
+      reporterFile = reporters[reporterType] || reporters.tty,
+      CustomReporter = (await import('../src/' + reporterFile)).default,
+      customOptions =
+        reporterType === 'tap' ? {useJson: true, hasColors: !options.monochrome} : options,
+      customReporter = new CustomReporter(customOptions);
+    setReporter(customReporter.report.bind(customReporter));
   }
 
   if (files.length) {

package/bin/tape6-node.js

@@ -3,11 +3,14 @@
 import process from 'node:process';
 import {fileURLToPath} from 'node:url';
 
-import {resolveTests, resolvePatterns} from '../src/utils/config.js';
+import {
+  resolveTests,
+  resolvePatterns,
+  getReporter as getReporterType
+} from '../src/utils/config.js';
 
 import {getReporter, setReporter} from '../src/test.js';
 import State, {StopTest} from '../src/State.js';
-import TapReporter from '../src/TapReporter.js';
 import {selectTimer} from '../src/utils/timer.js';
 
 import TestWorker from '../src/node/TestWorker.js';
@@ -89,25 +92,22 @@ const config = () => {
   if (!parallel) parallel = globalThis.navigator?.hardwareConcurrency || 1;
 };
 
+const reporters = {
+  jsonl: 'JSONLReporter.js',
+  tap: 'TapReporter.js',
+  tty: 'TTYReporter.js'
+};
+
 const init = async () => {
-  let reporter = getReporter();
-  if (!reporter) {
-    if (process.env.TAPE6_JSONL) {
-      const JSONLReporter = (await import('../src/JSONLReporter.js')).default,
-        jsonlReporter = new JSONLReporter(options);
-      reporter = jsonlReporter.report.bind(jsonlReporter);
-    } else if (!process.env.TAPE6_TAP) {
-      const TTYReporter = (await import('../src/TTYReporter.js')).default,
-        ttyReporter = new TTYReporter(options);
-      ttyReporter.testCounter = -2;
-      ttyReporter.technicalDepth = 1;
-      reporter = ttyReporter.report.bind(ttyReporter);
-    }
-    if (!reporter) {
-      const tapReporter = new TapReporter({useJson: true, hasColors: !options.monochrome});
-      reporter = tapReporter.report.bind(tapReporter);
-    }
-    setReporter(reporter);
+  const currentReporter = getReporter();
+  if (!currentReporter) {
+    const reporterType = getReporterType(),
+      reporterFile = reporters[reporterType] || reporters.tty,
+      CustomReporter = (await import('../src/' + reporterFile)).default,
+      customOptions =
+        reporterType === 'tap' ? {useJson: true, hasColors: !options.monochrome} : options,
+      customReporter = new CustomReporter(customOptions);
+    setReporter(customReporter.report.bind(customReporter));
   }
 
   if (files.length) {

package/bin/tape6-runner.js

@@ -3,16 +3,17 @@
 import process from 'node:process';
 import {fileURLToPath} from 'node:url';
 
-const requestedRuntime = {
+const runtimeFiles = {
   node: 'tape6-node.js',
   deno: 'tape6-deno.js',
   bun: 'tape6-bun.js',
   server: 'tape6-server.js',
   runner: 'tape6-runner.js',
   main: 'tape6.js'
-}[process.argv[2]];
+};
+const requestedRuntime = runtimeFiles[process.argv[2]] || runtimeFiles.main;
 
-const runtime = requestedRuntime || 'tape6.js',
+const runtime = requestedRuntime,
   url = new URL('./' + runtime, import.meta.url),
   fileName = url.protocol === 'file:' ? fileURLToPath(url) : url.href;
 

package/bin/tape6.js

@@ -11,11 +11,11 @@ if (process.argv.includes('--self')) {
     console.log(self);
   }
 } else {
-  if (typeof Deno == 'object') {
+  if (typeof Deno == 'object' && Deno?.version) {
     await import('./tape6-deno.js');
-  } else if (typeof Bun == 'object') {
+  } else if (typeof Bun == 'object' && Bun?.version) {
     await import('./tape6-bun.js');
-  } else if (typeof process == 'object' && process.versions?.node) {
+  } else if (typeof process == 'object' && process?.versions?.node) {
     await import('./tape6-node.js');
   } else {
     throw new Error('tape6 is not supported in this environment');

package/index.d.ts

@@ -0,0 +1,714 @@
+/**
+ * Test options
+ */
+export declare interface TestOptions {
+  /**
+   * The name of the test
+   */
+  name?: string;
+
+  /**
+   * The test function
+   */
+  testFn?:
+    | ((t: Test) => void | Promise<void>)
+    | ((t: Test, resolve: () => void, reject: (error: unknown) => void) => void);
+
+  /**
+   * Skips the test. The test will not be run.
+   */
+  skip?: boolean;
+
+  /**
+   * Marks the test as a TODO. The test can fail or pass and does not count towards the test suite's result.
+   */
+  todo?: boolean;
+
+  /**
+   * The timeout for the test in milliseconds. If the test takes longer than this, it will be stopped.
+   * If not specified, no timeout is used for the test.
+   */
+  timeout?: number;
+}
+
+/**
+ * Test interface
+ */
+export declare interface Test {
+  /**
+   * A symbol that can be used to match any value.
+   */
+  any: Symbol;
+
+  /**
+   * A symbol that can be used to match any value. An alias of `any`.
+   */
+  _: Symbol;
+
+  /**
+   * Plans the number of assertions that will be run. Unused.
+   * @param n - The number of assertions
+   */
+  plan(n: number): void;
+
+  /**
+   * Adds a comment to the test. It is shown in the output, but does not affect the test result.
+   * @param msg - The comment message
+   */
+  comment(msg: string): void;
+
+  /**
+   * Skips the test. The test will not be run.
+   * @param args - Optional arguments. The last string argument can be a message.
+   */
+  skipTest(...args: any[]): void;
+
+  /**
+   * Stops the test suite. No more tests will be run.
+   * @param msg - Optional message to display
+   */
+  bailOut(msg?: string): void;
+
+  // lifted from `test()`
+
+  /**
+   * Creates a new embedded test with the given name and function.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  test(name: string, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given function.
+   * @param fn - The test function
+   */
+  test(fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given options.
+   */
+  test(options: TestOptions): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given options and function.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  test(options: TestOptions, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Skips the test. The test will not be run.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  skip(name: string, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Skips the test. The test will not be run.
+   * @param fn - The test function
+   */
+  skip(fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Skips the test. The test will not be run.
+   * @param options - The test options
+   */
+  skip(options: TestOptions): Promise<void>;
+
+  /**
+   * Skips the test. The test will not be run.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  skip(options: TestOptions, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given name and function.
+   * It is a TODO test, which can fail or pass and does not count towards the test suite's result.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  todo(name: string, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given function.
+   * It is a TODO test, which can fail or pass and does not count towards the test suite's result.
+   * @param fn - The test function
+   */
+  todo(fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given options.
+   * It is a TODO test, which can fail or pass and does not count towards the test suite's result.
+   * @param options - The test options
+   */
+  todo(options: TestOptions): Promise<void>;
+
+  /**
+   * Creates a new embedded test with the given name and function.
+   * It is a TODO test, which can fail or pass and does not count towards the test suite's result.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  todo(options: TestOptions, fn: (t: Test) => void | Promise<void>): Promise<void>;
+
+  /**
+   * Runs non-asynchronous callback-based test.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  asPromise(
+    name: string,
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+
+  /**
+   * Runs non-asynchronous callback-based test.
+   * @param fn - The test function
+   */
+  asPromise(
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+
+  /**
+   * Runs non-asynchronous callback-based test.
+   * @param options - The test options
+   */
+  asPromise(options: TestOptions): Promise<void>;
+
+  /**
+   * Runs non-asynchronous callback-based test.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  asPromise(
+    options: TestOptions,
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+
+  // asserts
+
+  /**
+   * Asserts that the test passed.
+   * @param msg - Optional message to display if the assertion fails
+   */
+  pass(msg?: string): void;
+
+  /**
+   * Asserts that the test failed.
+   * @param msg - Optional message to display if the assertion fails
+   */
+  fail(msg?: string): void;
+
+  /**
+   * Asserts that `value` is truthy.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  ok(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `value` is not truthy.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  notOk(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `error` is an error and fails the test.
+   * @param error - The error to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  error(error: Error | null | unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is strictly equal to `expected`. Uses `===` comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  strictEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not strictly equal to `expected`. Uses `!==` comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notStrictEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is loosely equal to `expected`. Uses `==` comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  looseEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not loosely equal to `expected`. Uses `!=` comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notLooseEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Uses strict comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  deepEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Uses strict comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notDeepEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Uses loose comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  deepLooseEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Uses loose comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notDeepLooseEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `fn` throws an error.
+   * @param fn - The function to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  throws(fn: () => void, message?: string): void;
+
+  /**
+   * Asserts that `fn` does not throw an error.
+   * @param fn - The function to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotThrow(fn: () => void, message?: string): void;
+
+  /**
+   * Asserts that `string` matches the regular expression `regexp`.
+   * @param string - The string to test
+   * @param regexp - The regular expression to test against
+   * @param message - Optional message to display if the assertion fails
+   */
+  matchString(string: string, regexp: RegExp, message?: string): void;
+
+  /**
+   * Asserts that `string` does not match the regular expression `regexp`.
+   * @param string - The string to test
+   * @param regexp - The regular expression to test against
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotMatchString(string: string, regexp: RegExp, message?: string): void;
+
+  /**
+   * Asserts that `actual` matches `expected`. This is a structural object comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  match(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` does not match `expected`. This is a structural object comparison.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotMatch(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `promise` is rejected.
+   * @param promise - The promise to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  rejects(promise: Promise<unknown>, message?: string): Promise<void>;
+
+  /**
+   * Asserts that `promise` is resolved.
+   * @param promise - The promise to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  resolves(promise: Promise<unknown>, message?: string): Promise<void>;
+
+  // aliases
+
+  /**
+   * Asserts that `value` is truthy. Alias of `ok`.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  true(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `value` is truthy. Alias of `ok`.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  assert(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `value` is falsy. Alias of `notOk`.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  false(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `value` is not truthy. Alias of `notOk`.
+   * @param value - The value to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  notok(value: unknown, message?: string): void;
+
+  /**
+   * Asserts that `error` is an error and fails the test. Alias of `error`.
+   * @param error - The error to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  ifError(error: Error | null | unknown, message?: string): void;
+
+  /**
+   * Asserts that `error` is an error and fails the test. Alias of `error`.
+   * @param error - The error to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  ifErr(error: Error | null | unknown, message?: string): void;
+
+  /**
+   * Asserts that `error` is an error and fails the test. Alias of `error`.
+   * @param error - The error to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  iferror(error: Error | null | unknown, message?: string): void;
+
+  /**
+   * Asserts that `a` is strictly equal to `b`. Alias of `strictEqual`.
+   * @param a - The first value
+   * @param b - The second value
+   * @param message - Optional message to display if the assertion fails
+   */
+  is(a: unknown, b: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Alias of `strictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  equal(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is strictly equal to `expected`. Alias of `strictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  equals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is strictly equal to `expected`. Alias of `strictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is strictly equal to `expected`. Alias of `strictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  strictEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  not(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isNotEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isUnequal(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notStrictEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not equal to `expected`. Alias of `notStrictEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isNot(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is loosely equal to `expected`. Alias of `looseEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  looseEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not loosely equal to `expected`. Alias of `notLooseEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notLooseEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Alias of `deepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  same(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Alias of `deepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  deepEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is deeply equal to `expected`. Alias of `deepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isEquivalent(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notSame(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notDeepEquals(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notEquivalent(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  notDeeply(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isNotDeepEqual(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `actual` is not deeply equal to `expected`. Alias of `notDeepEqual`.
+   * @param actual - The actual value
+   * @param expected - The expected value
+   * @param message - Optional message to display if the assertion fails
+   */
+  isNotEquivalent(actual: unknown, expected: unknown, message?: string): void;
+
+  /**
+   * Asserts that `promise` is rejected. Alias of `rejects`.
+   * @param promise - The promise to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotResolve(promise: Promise<unknown>, message?: string): Promise<void>;
+
+  /**
+   * Asserts that `promise` is resolved. Alias of `resolves`.
+   * @param promise - The promise to test
+   * @param message - Optional message to display if the assertion fails
+   */
+  doesNotReject(promise: Promise<unknown>, message?: string): Promise<void>;
+}
+
+export declare interface Test {
+  /**
+   * Creates a new test with the given name and function.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  (name: string, fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test with the given function.
+   * @param fn - The test function
+   */
+  (fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test with the given options.
+   * @param options - The test options
+   */
+  (options: TestOptions): void;
+  /**
+   * Creates a new test with the given options and function.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  (options: TestOptions, fn: (t: Test) => void | Promise<void>): void;
+
+  /**
+   * Creates a new test that will be skipped.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  skip(name: string, fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test that will be skipped.
+   * @param fn - The test function
+   */
+  skip(fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test that will be skipped.
+   * @param options - The test options
+   */
+  skip(options: TestOptions): void;
+  /**
+   * Creates a new test that will be skipped.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  skip(options: TestOptions, fn: (t: Test) => void | Promise<void>): void;
+
+  /**
+   * Creates a new test that will be TODO.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  todo(name: string, fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test that will be TODO.
+   * @param fn - The test function
+   */
+  todo(fn: (t: Test) => void | Promise<void>): void;
+  /**
+   * Creates a new test that will be TODO.
+   * @param options - The test options
+   */
+  todo(options: TestOptions): void;
+  /**
+   * Creates a new test that will be TODO.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  todo(options: TestOptions, fn: (t: Test) => void | Promise<void>): void;
+
+  /**
+   * Creates a new test that will be run as a promise.
+   * Usually used for asynchronous tests that are based on callbacks.
+   * @param name - The name of the test
+   * @param fn - The test function
+   */
+  asPromise(
+    name: string,
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+  /**
+   * Creates a new test that will be run as a promise.
+   * Usually used for asynchronous tests that are based on callbacks.
+   * @param fn - The test function
+   */
+  asPromise(
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+  /**
+   * Creates a new test that will be run as a promise.
+   * Usually used for asynchronous tests that are based on callbacks.
+   * @param options - The test options
+   */
+  asPromise(options: TestOptions): Promise<void>;
+  /**
+   * Creates a new test that will be run as a promise.
+   * Usually used for asynchronous tests that are based on callbacks.
+   * @param options - The test options
+   * @param fn - The test function
+   */
+  asPromise(
+    options: TestOptions,
+    fn: (t: Test, resolve: () => void, reject: (error: unknown) => void) => void
+  ): Promise<void>;
+}
+
+declare const test: Test;
+
+export default test;

package/index.js

@@ -1,3 +1,5 @@
+// @ts-self-types="./index.d.ts"
+
 import {
   test,
   getTests,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "TAP the test harness for the modern JavaScript (ES6).",
   "type": "module",
   "main": "index.js",
@@ -54,7 +54,7 @@
   },
   "homepage": "https://github.com/uhop/tape-six#readme",
   "files": [
-    "index.js",
+    "index.*",
     "bin",
     "web-app",
     "src"
@@ -71,8 +71,8 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^22.13.10",
-    "puppeteer": "^24.4.0",
-    "typescript": "^5.8.2"
+    "@types/node": "^25.0.3",
+    "puppeteer": "^24.34.0",
+    "typescript": "^5.9.3"
   }
 }

package/src/TTYReporter.js

@@ -76,7 +76,40 @@ class TTYReporter {
     this.failure = this.paint(failureStyle, reset);
     this.skipped = this.paint(skippedStyle, reset);
 
-    this.output.isTTY && this.out('');
+    // watching for console output
+
+    this.consoleWasUsed = false;
+    this.consoleLastNewLine = false;
+    this.consoleSkipChecks = false;
+
+    while (this.output.isTTY) {
+      this.out('');
+
+      const isCurrentTTY = this.output === process.stdout || this.output === process.stderr;
+      if (!isCurrentTTY) break;
+
+      const oldStdoutWrite = process.stdout.write;
+      process.stdout.write = process.stderr.write = (chunk, ...args) => {
+        if (!this.consoleSkipChecks && chunk) {
+          this.consoleWasUsed = true;
+          const text = chunk.toString();
+          this.consoleLastNewLine = text[text.length - 1] === '\n';
+        }
+        return oldStdoutWrite.call(process.stdout, chunk, ...args);
+      };
+
+      const oldStderrWrite = process.stderr.write;
+      process.stderr.write = (chunk, ...args) => {
+        if (!this.consoleSkipChecks && chunk) {
+          this.consoleWasUsed = true;
+          const text = chunk.toString();
+          this.consoleLastNewLine = text[text.length - 1] === '\n';
+        }
+        return oldStderrWrite.call(process.stderr, chunk, ...args);
+      };
+
+      break;
+    }
   }
   paint(prefix, suffix = '\x1B[39m') {
     return this.hasColors ? text => join(prefix, text, suffix) : text => text;
@@ -100,9 +133,22 @@ class TTYReporter {
     return this;
   }
   report(event) {
+    this.consoleSkipChecks = true;
+    try {
+      this.reportInternal(event);
+    } finally {
+      this.consoleSkipChecks = false;
+    }
+  }
+  reportInternal(event) {
     if (this.output.isTTY) {
-      this.output.moveCursor(0, -1);
-      this.output.clearLine(0);
+      if (this.consoleWasUsed) {
+        if (!this.consoleLastNewLine) this.output.write('\n');
+        this.consoleWasUsed = this.consoleLastNewLine = false;
+      } else {
+        this.output.moveCursor(0, -1);
+        this.output.clearLine(0);
+      }
     }
     let text;
     switch (event.type) {

package/src/utils/config.js

@@ -64,3 +64,32 @@ export const resolveTests = async (rootFolder, type, traceFn) => {
   // resolve patterns
   return resolvePatterns(rootFolder, patterns);
 };
+
+export const runtime = {name: 'unknown', env: null};
+
+if (typeof Deno == 'object' && Deno?.version) {
+  runtime.name = 'deno';
+  runtime.env = Deno.env;
+} else if (typeof Bun == 'object' && Bun?.version) {
+  runtime.name = 'bun';
+  runtime.env = Bun.env;
+} else if (typeof process == 'object' && process?.versions?.node) {
+  runtime.name = 'node';
+  runtime.env = process.env;
+} else if (typeof window == 'object' && window?.document) {
+  runtime.name = 'browser';
+}
+
+export const getReporter = () => {
+  if (!runtime.env) return null;
+  if (runtime.env.TAPE6_REPORTER) return runtime.env.TAPE6_REPORTER;
+  if (runtime.env.TAPE6_JSONL) return 'jsonl';
+  if (runtime.env.TAPE6_TAP) return 'tap';
+  return 'tty';
+};
+
+export const getRunner = () => {
+  if (!runtime.env) return null;
+  if (runtime.env.TAPE6_RUNNER) return runtime.env.TAPE6_RUNNER;
+  return 'thread';
+};