tape-six-proc 1.2.1 → 1.2.3

package/README.md

@@ -4,24 +4,93 @@
 [npm-url]: https://npmjs.org/package/tape-six-proc
 
 `tape-six-proc` is a helper for [tape-six](https://www.npmjs.com/package/tape-six)
-to run tests in separate processes.
+to run tests in separate processes. It works with Node, Deno, and Bun,
+and supports TypeScript natively without transpilation.
+
+## Why?
+
+The standard `tape6` runner uses worker threads. `tape6-proc` spawns each test file
+in its own subprocess instead, providing full process isolation. This prevents shared
+state leaks and is useful when tests need a clean environment. TypeScript test files
+(`.ts`) are run natively by modern Node, Deno, and Bun — no transpilation needed.
+
+## Install
+
+```bash
+npm i -D tape-six-proc
+```
+
+## Quick start
+
+1. Write tests using [tape-six](https://www.npmjs.com/package/tape-six):
+
+```js
+import test from 'tape-six';
+
+test('example', t => {
+  t.ok(true, 'truthy');
+  t.equal(1 + 1, 2, 'math works');
+});
+```
+
+2. Configure tests in `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-proc --flags FO"
+  },
+  "tape6": {
+    "tests": ["/tests/test-*.*js"]
+  }
+}
+```
+
+3. Run:
+
+```bash
+npm test
+```
+
+## Cross-runtime usage
+
+```json
+{
+  "scripts": {
+    "test": "tape6-proc --flags FO",
+    "test:bun": "bun run `tape6-proc --self` --flags FO",
+    "test:deno": "deno run -A `tape6-proc --self` --flags FO -r -A"
+  }
+}
+```
 
 ## Docs
 
 The documentation can be found in the [wiki](https://github.com/uhop/tape-six-proc/wiki).
 `tape-six` has its own [wiki](https://github.com/uhop/tape-six/wiki).
 
-`tape-six-proc` uses the same test configuration as `tape-six`. The utility `test6-proc`
+`tape-six-proc` uses the same test configuration as `tape-six`. The utility `tape6-proc`
 has the same usage as `tape6`.
 
 ### Command-line utilities
 
 - [tape6-proc](https://github.com/uhop/tape-six-proc/wiki/Utility-%E2%80%90-tape6-proc) — the main utility of this package to run tests in different environments.
 
+## AI agents
+
+If you are an AI coding agent, see [AGENTS.md](./AGENTS.md) for project conventions, commands, and architecture.
+
+LLM-friendly documentation is available:
+
+- [llms.txt](./llms.txt) — concise reference.
+- [llms-full.txt](./llms-full.txt) — full reference with architecture details.
+
 ## Release notes
 
 The most recent releases:
 
+- 1.2.3 _Updated dependencies, cleaned up docs, added AI-friendly links and TS info._
+- 1.2.2 _Synchronized the implementation with `tape-six` 1.7.0._
 - 1.2.1 _Synchronized the implementation with `tape-six` 1.5.1._
 - 1.2.0 _Updated dependencies and synchronized the implementation with `tape-six` 1.5.0._
 - 1.1.6 _Updated dependencies._

package/bin/tape6-proc-node.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 
-'use strict';
-
 import process from 'node:process';
 import os from 'node:os';
 import {fileURLToPath} from 'node:url';
 
-import {resolveTests, resolvePatterns} from 'tape-six/utils/config.js';
+import {
+  getReporterFileName,
+  getReporterType,
+  resolveTests,
+  resolvePatterns,
+  runtime
+} from 'tape-six/utils/config.js';
 
 import {getReporter, setReporter} from 'tape-six/test.js';
-import TapReporter from 'tape-six/reporters/TapReporter.js';
 import {selectTimer} from 'tape-six/utils/timer.js';
 
 import TestWorker from '../src/TestWorker.js';
@@ -53,7 +56,7 @@ const config = () => {
     const arg = process.argv[i];
     if (arg == '-f' || arg == '--flags') {
       if (++i < process.argv.length) {
-        flags = process.argv[i];
+        flags += process.argv[i];
       }
       continue;
     }
@@ -111,31 +114,26 @@ const config = () => {
 };
 
 const init = async () => {
-  let reporter = getReporter();
-  if (!reporter) {
-    if (process.env.TAPE6_JSONL) {
-      const {JSONLReporter} = await import('tape-six/reporters/JSONLReporter.js');
-      reporter = new JSONLReporter(options);
-    } else if (!process.env.TAPE6_TAP) {
-      const {TTYReporter} = await import('tape-six/reporters/TTYReporter.js');
-      reporter = new TTYReporter(options);
-    }
-    if (!reporter) {
-      reporter = new TapReporter({useJson: true});
-    }
-    setReporter(reporter);
+  const currentReporter = getReporter();
+  if (!currentReporter) {
+    const reporterType = getReporterType(),
+      reporterFile = getReporterFileName(reporterType),
+      CustomReporter = (await import('tape-six/reporters/' + reporterFile)).default,
+      hasColors = !(
+        options.monochrome ||
+        process.env.NO_COLOR ||
+        process.env.NODE_DISABLE_COLORS ||
+        process.env.FORCE_COLOR === '0'
+      ),
+      customOptions = reporterType === 'tap' ? {useJson: true, hasColors} : {...options, hasColors},
+      customReporter = new CustomReporter(customOptions);
+    setReporter(customReporter);
   }
 
   if (files.length) {
     files = await resolvePatterns(rootFolder, files);
   } else {
-    let type = 'node';
-    if (typeof Deno == 'object') {
-      type = 'deno';
-    } else if (typeof Bun == 'object') {
-      type = 'bun';
-    }
-    files = await resolveTests(rootFolder, type);
+    files = await resolveTests(rootFolder, runtime.name);
   }
 };
 
@@ -148,10 +146,15 @@ const main = async () => {
     console.error('UNHANDLED ERROR:', origin, error)
   );
 
+  if (!files.length) {
+    console.log('No files found.');
+    process.exit(1);
+  }
+
   const reporter = getReporter(),
     worker = new TestWorker(reporter, parallel, options);
 
-  reporter.report({type: 'test', test: 0, name: ''});
+  reporter.report({type: 'test', test: 0});
 
   await new Promise(resolve => {
     worker.done = () => resolve();

package/llms-full.txt

@@ -0,0 +1,236 @@
+# tape-six-proc
+
+> A helper for [tape-six](https://github.com/uhop/tape-six) that runs test files in separate processes (subprocesses) instead of worker threads. Works with Node, Deno, and Bun. Supports TypeScript natively without transpilation. The npm package name is `tape-six-proc` and the CLI command is `tape6-proc`.
+
+- Process isolation: each test file runs in its own subprocess
+- Cross-runtime: Node, Deno, and Bun with the same test files
+- TypeScript without transpilation: runs `.ts` test files natively on modern Node, Deno, and Bun
+- Drop-in replacement for `tape6` (worker-thread runner)
+- Same configuration format as `tape-six`
+- Parallel execution with configurable concurrency
+- TAP, TTY (colored), and JSONL output formats
+
+## Install
+
+```bash
+npm i -D tape-six-proc
+```
+
+## Quick start
+
+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 via processes:
+
+```bash
+tape6-proc --flags FO
+```
+
+## CLI: tape6-proc
+
+Runs test files in parallel, each in its own subprocess.
+
+```bash
+tape6-proc [--flags FLAGS] [--par N] [--runFileArgs ARGS] [tests...]
+```
+
+### Options
+
+- `--flags FLAGS` (`-f`) — output control flags (see Supported flags below).
+- `--par N` (`-p`) — number of parallel processes. Default: all CPU cores (via `os.availableParallelism()` or `navigator.hardwareConcurrency`).
+- `--runFileArgs ARGS` (`-r`) — extra arguments passed to the spawned interpreter. Can be specified multiple times. Mainly used for Deno permissions.
+- `--self` — prints the absolute path to `tape6-proc.js` and exits. Used in cross-runtime scripts.
+- Positional arguments: test file glob patterns. If none given, reads from configuration.
+
+### Examples
+
+```bash
+# Run all configured tests
+tape6-proc --flags FO
+
+# Run specific test files
+tape6-proc tests/test-foo.js tests/test-bar.js
+
+# Limit parallelism
+tape6-proc --par 4 --flags FO
+
+# Pass Deno permissions to spawned processes
+tape6-proc -r --allow-read -r --allow-env --flags FO
+```
+
+## Cross-runtime usage
+
+`tape6-proc` is a Node CLI by default. For Bun and Deno, use the `--self` flag to get the script path:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-proc --flags FO",
+    "test:node": "tape6-proc --flags FO",
+    "test:bun": "bun run `tape6-proc --self` --flags FO",
+    "test:deno": "deno run -A `tape6-proc --self` --flags FO -r -A"
+  }
+}
+```
+
+### Deno permissions
+
+Deno requires explicit permissions. Use `-r` (alias for `--runFileArgs`) to pass them to each spawned test process:
+
+```bash
+# All permissions
+deno run -A `tape6-proc --self` -r -A
+
+# Fine-grained permissions
+deno run -A `tape6-proc --self` -r --allow-read -r --allow-env
+```
+
+Note: the first `-A` is for the `tape6-proc` process itself; the `-r` flags are forwarded to spawned test processes.
+
+## 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-proc --flags FO
+TAPE6_FLAGS=FO node tests/test-example.js
+```
+
+## Configuration
+
+Configuration is read from `tape6.json` or the `"tape6"` section of `package.json` (same format as `tape-six`):
+
+```json
+{
+  "tape6": {
+    "tests": ["/tests/test-*.*js"],
+    "cli": ["/tests/test-*.cjs"]
+  }
+}
+```
+
+Environment-specific subsections (`node`, `deno`, `bun`) are supported. The runner auto-detects the current runtime and uses the appropriate subsection.
+
+## Environment variables
+
+- `TAPE6_FLAGS` — flags string (combined with `--flags` CLI argument).
+- `TAPE6_PAR` — number of parallel processes (overridden by `--par`).
+- `TAPE6_TAP` — force TAP reporter (any non-empty value).
+- `TAPE6_JSONL` — force JSONL reporter (any non-empty value).
+- `TAPE6_TEST` — set by the runner: unique ID for each spawned test process.
+- `TAPE6_TEST_FILE_NAME` — set by the runner: file name of the current test.
+- `TAPE6_JSONL_PREFIX` — set by the runner: UUID prefix for JSONL lines in stdout.
+
+## Architecture
+
+### Entry point
+
+`bin/tape6-proc.js` is the CLI entry point:
+
+- With `--self`: prints its own absolute path and exits.
+- Otherwise: delegates to `bin/tape6-proc-node.js`.
+
+### Main CLI (`bin/tape6-proc-node.js`)
+
+1. Parses CLI arguments (`--flags`, `--par`, `--runFileArgs`, positional test patterns).
+2. Selects reporter: TTY (default for terminals), TAP, or JSONL (based on environment variables).
+3. Resolves test files from configuration or CLI patterns using `tape-six/utils/config.js`.
+4. Creates a `TestWorker` instance and executes all test files.
+5. Reports final results and exits with code 0 (success) or 1 (failures).
+
+### TestWorker (`src/TestWorker.js`)
+
+Extends `EventServer` from `tape-six`. Manages parallel subprocess execution:
+
+- **`constructor(reporter, numberOfTasks, options)`** — initializes with a reporter, concurrency limit, and options. Generates a UUID prefix for JSONL parsing.
+- **`makeTask(fileName)`** — spawns a child process for a test file using `dollar-shell`. Sets up stream pipelines for stdout and stderr. Returns a task ID.
+- **`destroyTask(id)`** — cleans up a completed task.
+- **`getConcurrency()`** — static method, returns available CPU cores.
+
+### Stream pipeline
+
+Each spawned process has two stream pipelines:
+
+**stdout pipeline:**
+```
+process.stdout → TextDecoderStream → lines → parse-prefixed-jsonl → report
+```
+
+- `lines` (`src/streams/lines.js`): TransformStream that splits text into individual lines.
+- `parse-prefixed-jsonl` (`src/streams/parse-prefixed-jsonl.js`): TransformStream that recognizes lines starting with the UUID prefix, parses them as JSON, and passes through non-prefixed lines as `{type: 'stdout', name: line}` objects.
+
+**stderr pipeline:**
+```
+process.stderr → TextDecoderStream → lines → wrap-lines → report
+```
+
+- `wrap-lines` (`src/streams/wrap-lines.js`): TransformStream that wraps each line as `{type: 'stderr', name: line}`.
+
+### Process lifecycle
+
+1. Process is spawned with environment variables: `TAPE6_FLAGS`, `TAPE6_TEST`, `TAPE6_TEST_FILE_NAME`, `TAPE6_JSONL=Y`, `TAPE6_JSONL_PREFIX`.
+2. The test file runs and outputs JSONL-prefixed lines to stdout.
+3. After the process exits, `TestWorker` checks exit code and signal.
+4. Non-zero exit codes are reported as errors with a `{type: 'terminated'}` event.
+5. The task is closed and the next queued test file starts.
+
+## Dependencies
+
+- **`tape-six`** — the core test library. Imports: `State.js`, `utils/EventServer.js`, `utils/makeDeferred.js`, `utils/config.js`, `test.js`, reporters (`TapReporter`, `TTYReporter`, `JSONLReporter`), `utils/timer.js`.
+- **`dollar-shell`** — cross-runtime process spawning. Imports: `spawn`, `currentExecPath`, `runFileArgs`.
+
+## Writing tests
+
+Tests are standard `tape-six` tests. See the [tape-six documentation](https://github.com/uhop/tape-six/wiki) for the full API.
+
+```js
+import test from 'tape-six';
+
+test('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');
+});
+```
+
+Test files should be directly executable: `node tests/test-foo.js` or `node tests/test-foo.ts`
+
+## Links
+
+- Docs: https://github.com/uhop/tape-six-proc/wiki
+- npm: https://www.npmjs.com/package/tape-six-proc
+- tape-six: https://github.com/uhop/tape-six
+- tape-six LLM reference: https://github.com/uhop/tape-six/blob/master/llms.txt

package/llms.txt

@@ -0,0 +1,107 @@
+# tape-six-proc
+
+> Helper for [tape-six](https://github.com/uhop/tape-six) that runs test files in separate processes instead of worker threads. Works with Node, Deno, and Bun. Supports TypeScript natively without transpilation.
+
+## Install
+
+```bash
+npm i -D tape-six-proc
+```
+
+## Quick start
+
+1. Write tests using `tape-six`:
+
+```js
+import test from 'tape-six';
+
+test('my test', async t => {
+  t.ok(true, 'truthy value');
+  t.equal(1 + 1, 2, 'addition works');
+});
+```
+
+2. Configure tests in `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "tape6-proc --flags FO"
+  },
+  "tape6": {
+    "tests": ["/tests/test-*.*js"]
+  }
+}
+```
+
+3. Run: `npm test`
+
+## Why use tape-six-proc?
+
+- **Process isolation** — each test file runs in its own subprocess, preventing shared state leaks.
+- **Cross-runtime** — works with Node, Deno, and Bun using the same test files.
+- **TypeScript without transpilation** — runs `.ts` test files natively on modern Node, Deno, and Bun.
+- **Drop-in replacement** — uses the same configuration and test format as `tape6` (worker-thread runner).
+
+## CLI: tape6-proc
+
+```bash
+tape6-proc [--flags FLAGS] [--par N] [--runFileArgs ARGS] [tests...]
+```
+
+### Options
+
+- `--flags FLAGS` (`-f`) — output control flags (same as tape6: F=failures only, T=time, B=banner, D=data, O=fail once, N=assert number, M=monochrome, C=don't capture console, H=hide streams).
+- `--par N` (`-p`) — number of parallel processes (default: all CPU cores).
+- `--runFileArgs ARGS` (`-r`) — extra arguments passed to the spawned interpreter. Can be used multiple times. Mainly for Deno permissions.
+- `--self` — prints the path to `tape6-proc.js` (for cross-runtime scripts).
+- No arguments: runs tests from configuration.
+
+### Cross-runtime usage
+
+```json
+{
+  "scripts": {
+    "test": "tape6-proc --flags FO",
+    "test:bun": "bun run `tape6-proc --self` --flags FO",
+    "test:deno": "deno run -A `tape6-proc --self` --flags FO -r -A"
+  }
+}
+```
+
+### Deno permissions
+
+Use `--runFileArgs` (`-r`) to pass permissions to spawned test processes:
+
+```bash
+deno run -A `tape6-proc --self` -r --allow-read -r --allow-env
+```
+
+## Configuration
+
+Same as `tape-six`. Reads from `tape6.json` or the `"tape6"` section of `package.json`:
+
+```json
+{
+  "tape6": {
+    "tests": ["/tests/test-*.*js"]
+  }
+}
+```
+
+Environment-specific subsections: `node`, `deno`, `bun`.
+
+## Environment variables
+
+- `TAPE6_FLAGS` — flags string.
+- `TAPE6_PAR` — number of parallel processes.
+- `TAPE6_TAP` — force TAP reporter.
+- `TAPE6_JSONL` — force JSONL reporter.
+- `TAPE6_TEST_FILE_NAME` — set by the runner to identify the current test file.
+
+## Links
+
+- Docs: https://github.com/uhop/tape-six-proc/wiki
+- npm: https://www.npmjs.com/package/tape-six-proc
+- tape-six: https://github.com/uhop/tape-six
+- Full LLM reference: https://github.com/uhop/tape-six-proc/blob/master/llms-full.txt

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tape-six-proc",
-  "version": "1.2.1",
-  "description": "Helper for TAP the test harness for the modern JavaScript (ES6) to run tests in separate processes.",
+  "version": "1.2.3",
+  "description": "Helper for tape-six to run tests in separate processes. Works with Node, Deno, and Bun. Supports TypeScript without transpilation.",
   "type": "module",
   "bin": {
     "tape6-proc": "bin/tape6-proc.js"
@@ -9,16 +9,28 @@
   "scripts": {
     "lint": "prettier --check .",
     "lint:fix": "prettier --write .",
-    "test": "node ./bin/tape6-proc.js",
-    "test:bun": "bun run ./bin/tape6-proc.js",
-    "test:deno": "deno run -A ./bin/tape6-proc.js -r --allow-read -r --allow-env"
+    "test": "node ./bin/tape6-proc.js --flags FO",
+    "test:bun": "bun run ./bin/tape6-proc.js --flags FO",
+    "test:deno": "deno run -A ./bin/tape6-proc.js -r --allow-read -r --allow-env --flags FO"
   },
   "keywords": [
     "tap",
     "test",
     "harness",
     "assert",
-    "process"
+    "process",
+    "unit-test",
+    "testing",
+    "test-runner",
+    "esm",
+    "es-modules",
+    "deno",
+    "bun",
+    "nodejs",
+    "cross-runtime",
+    "subprocess",
+    "isolated-process",
+    "typescript"
   ],
   "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com)",
   "funding": "https://github.com/sponsors/uhop",
@@ -31,13 +43,25 @@
     "url": "https://github.com/uhop/tape-six-proc/issues"
   },
   "homepage": "https://github.com/uhop/tape-six-proc#readme",
+  "github": "http://github.com/uhop/tape-six-proc",
+  "llms": "https://raw.githubusercontent.com/uhop/tape-six-proc/master/llms.txt",
+  "llmsFull": "https://raw.githubusercontent.com/uhop/tape-six-proc/master/llms-full.txt",
+  "files": [
+    "bin",
+    "src",
+    "llms.txt",
+    "llms-full.txt"
+  ],
   "dependencies": {
-    "dollar-shell": "^1.1.7",
-    "tape-six": "^1.5.1"
+    "dollar-shell": "^1.1.9",
+    "tape-six": "^1.7.2"
   },
   "tape6": {
     "tests": [
       "/tests/test-*.*js"
     ]
+  },
+  "devDependencies": {
+    "chai": "^6.2.2"
   }
 }

package/src/TestWorker.js

@@ -8,7 +8,7 @@ import {spawn, currentExecPath, runFileArgs} from 'dollar-shell';
 
 import {isStopTest} from 'tape-six/State.js';
 import EventServer from 'tape-six/utils/EventServer.js';
-import getDeferred from 'tape-six/utils/getDeferred.js';
+import makeDeferred from 'tape-six/utils/makeDeferred.js';
 
 import lines from './streams/lines.js';
 import parse from './streams/parse-prefixed-jsonl.js';
@@ -44,7 +44,7 @@ export default class TestWorker extends EventServer {
       );
     this.idToWorker[id] = worker;
     const self = this;
-    const stdoutDeferred = getDeferred();
+    const stdoutDeferred = makeDeferred();
     worker.stdout
       .pipeThrough(new TextDecoderStream())
       .pipeThrough(lines())
@@ -66,7 +66,7 @@ export default class TestWorker extends EventServer {
           }
         })
       );
-    const stderrDeferred = getDeferred();
+    const stderrDeferred = makeDeferred();
     worker.stderr
       .pipeThrough(new TextDecoderStream())
       .pipeThrough(lines())

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_style = space
-indent_size = 2

package/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: uhop
-buy_me_a_coffee: uhop

package/.github/workflows/codeql.yml

@@ -1,76 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: 'CodeQL'
-
-on:
-  push:
-    branches: ['master']
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: ['master']
-  schedule:
-    - cron: '29 23 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: ['javascript']
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby', 'swift' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      # Initializes the CodeQL tools for scanning.
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: ${{ matrix.language }}
-          # If you wish to specify custom queries, you can do so here or in a config file.
-          # By default, queries listed here will override any specified in a config file.
-          # Prefix the list here with "+" to use these queries and those in the config file.
-
-          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-          # queries: security-extended,security-and-quality
-
-      # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-      # If this step fails, then you should remove it and run the build manually (see below)
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
-
-      # ℹ️ Command-line programs to run using the OS shell.
-      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-      #   If the Autobuild fails above, remove it and uncomment the following three lines.
-      #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-      # - run: |
-      #     echo "Run, Build Application using script"
-      #     ./location_of_script_within_repo/buildscript.sh
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
-        with:
-          category: '/language:${{matrix.language}}'

package/.github/workflows/tests.yml

@@ -1,32 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: ['*']
-  pull_request:
-    branches: [master]
-
-jobs:
-  tests:
-    name: Node.js ${{matrix.node-version}} on ${{matrix.os}}
-    runs-on: ${{matrix.os}}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-        node-version: [20, 22, 24, 25]
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{matrix.node-version}}
-      - run: |
-          npm ci
-          npm run build --if-present
-          npm test

package/.github/workflows/windows.yml

@@ -1,28 +0,0 @@
-name: Windows
-
-on:
-  workflow_dispatch:
-    inputs:
-      node-version:
-        description: 'Node.js version to run tests'
-        required: true
-        default: 25
-        type: number
-
-jobs:
-  tests:
-    name: Node.js ${{inputs.node-version}} (special test)
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{inputs.node-version}}
-      - run: |
-          npm ci
-          npm run build --if-present
-          npm test
-          node tests/test-sample.js

package/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "wiki"]
-	path = wiki
-	url = git@github.com:uhop/tape-six-proc.wiki

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "printWidth": 100,
-  "singleQuote": true,
-  "bracketSpacing": false,
-  "arrowParens": "avoid",
-  "trailingComma": "none"
-}

package/tests/manual/test-bad-exit.js

@@ -1,7 +0,0 @@
-import test from 'tape-six';
-import process from 'node:process';
-
-test('bad exit', t => {
-  t.pass();
-  process.exit(1);
-});

package/tests/manual/test-bad-import.js

@@ -1,7 +0,0 @@
-import test from 'tape-six';
-
-import x from 'bad-import';
-
-test('non-working test', t => {
-  t.ok(typeof x === 'object');
-});

package/tests/manual/test-bad-signal.js

@@ -1,7 +0,0 @@
-import test from 'tape-six';
-import process from 'node:process';
-
-test('bad signal', t => {
-  t.pass();
-  process.kill(process.pid, 'SIGKILL');
-});

package/tests/test-console.js

@@ -1,12 +0,0 @@
-import test from 'tape-six';
-
-test('console test', t => {
-  console.log('#1');
-  t.pass();
-  console.log('#2');
-  console.error('error #1');
-  console.log('#2a');
-  t.ok(1 < 2);
-  console.log('#3');
-  console.error('error #2');
-});

package/wiki/Home.md

@@ -1,30 +0,0 @@
-<!-- markdownlint-disable-next-line first-line-heading -->
-
-`tape-six-proc` is a helper for [tape-six](https://www.npmjs.com/package/tape-six)
-to run tests in separate processes.
-
-Please consult the [tape-six wiki](https://github.com/uhop/tape-six/wiki) for more information.
-
-# How to use
-
-1. Install `tape-six-proc` in your project: `npm i -D tape-six-proc`.
-2. Write tests.
-3. Configure your tests: [set-up tests](https://github.com/uhop/tape-six/wiki/Set-up-tests).
-4. Run tests: `npm test`.
-
-# Available utilities
-
-Test files are directly executable with `node` or `deno` or `bun` or in a browser.
-[tape-six](https://www.npmjs.com/package/tape-six) helps to organize tests. This package
-provides a utility to run tests in isolated processes:
-
-- [tape6-proc](./Utility-‐-tape6‐proc) to run tests in separate processes.
-
-# Formalities
-
-The project is distributed under the 3-clause BSD license.
-
-Other pertinent information:
-
-- [Release notes](./Release-notes).
-- [Working on this project](./Working-on-this-project).

package/wiki/Release-notes.md

@@ -1,20 +0,0 @@
-# The current version: 1.x
-
-- 1.2.1 _Synchronized the implementation with `tape-six` 1.5.1._
-- 1.2.0 _Updated dependencies and synchronized the implementation with `tape-six` 1.5.0._
-- 1.1.6 _Updated dependencies._
-- 1.1.5 _Updated dependencies._
-- 1.1.4 _Updated dependencies._
-- 1.1.3 _Updated dependencies._
-- 1.1.2 _Fixed bug with Deno (spawned process can end before processing streams (stdout/stderr))._
-- 1.1.1 _Updated dependencies._
-- 1.1.0 _Added support for stdout/stderr and `tape-six` 1.3.4._
-- 1.0.2 _Fixed concurrency detection. Updated dependencies._
-- 1.0.1 _Updated dependencies._
-- 1.0.0 _The first official release._
-
-# The previous releases
-
-- 0.12.1 _Updated dependencies, which included fixes for Deno._
-- 0.12.0 _Initial release._
-- 1.1.3 _Updated dependencies._

package/wiki/Utility-/342/200/220-tape6/342/200/220proc.md

@@ -1,69 +0,0 @@
-<!-- markdownlint-disable-next-line first-line-heading -->
-
-The main utility of the package is `tape6-proc`.
-
-# Usage
-
-Assuming that the tests are properly configured (see [Set-up tests](https://github.com/uhop/tape-six/wiki/Set-up-tests)),
-it can be invoked without arguments:
-
-```bash
-npx tape6-proc
-```
-
-`tape6-proc` is modelled after [tape6](https://github.com/uhop/tape-six/wiki/Utility-%E2%80%90-tape6)
-and can be used the same way.
-
-# Configuring `tape6-proc`
-
-`tape6-proc` supports the same configuration as [tape6](https://github.com/uhop/tape-six/wiki/Utility-%E2%80%90-tape6).
-
-Additionally it supports the following flags:
-
-- `--runFileArgs ARGS` &mdash; sets the arguments to pass to the interpreter running test files.
-  - Shortcut: `-r ARGS`.
-  - This flag can be used multiple times.
-
-This flag is used mostly with Deno to supply additional arguments to the test file. On Deno and Bun these arguments will follow the `run` command.
-
-For example, we want to add `-A` (`--allow-all` permissions) to run a test file:
-
-```bash
-deno run -A `npx tape6-proc --self` --runFileArgs -A
-```
-
-We can use it multiple times to supply several arguments, e.g., fine grained permissions:
-
-```bash
-deno run -A `npx tape6-proc --self` -r --allow-read -r --allow-env
-```
-
-# Implementation details
-
-Technically, `tape6-proc` is an executable command-line utility, which is set to be executed with
-the current Node. If you want to use it in different environments, you can use the `--self` flag:
-
-Example of `package.json`:
-
-```jsonc
-{
-  "scripts": {
-    "test": "tape6-proc --flags FO",
-    "test:node": "tape6-proc --flags FO",
-    "test:bun": "bun run `npx tape6-proc --self` --flags FO",
-    "test:deno": "deno run -A `npx tape6-proc --self` --flags FO -r -A"
-  }
-}
-```
-
-With scripts like above you can test your project in different environments:
-
-```bash
-npm test
-npm run test:bun
-npm run test:deno
-```
-
-## Test environment
-
-All environments spawn child processes to run tests using [dollar-shell](https://www.npmjs.com/package/dollar-shell).

package/wiki/Working-on-this-project.md

@@ -1,23 +0,0 @@
-<!-- markdownlint-disable-next-line first-line-heading -->
-
-This project uses git submodules, so the correct way to get it is:
-
-```bash
-git clone --recursive git@github.com:uhop/tape-six-proc.git
-cd tape-six-proc
-```
-
-For older versions of `git`:
-
-```bash
-git clone git@github.com:uhop/tape-six-proc.git
-cd tape-six-proc
-git submodule update --init --recursive
-```
-
-Don't forget to install dependencies and run a build:
-
-```bash
-npm install
-npm run build
-```