command-stream 0.4.0 → 0.5.0

package/README.md

@@ -1,5 +1,6 @@
 [![npm](https://img.shields.io/npm/v/command-stream.svg)](https://npmjs.com/command-stream)
 [![License](https://img.shields.io/badge/license-Unlicense-blue.svg)](https://github.com/link-foundation/command-stream/blob/main/LICENSE)
+[![GitHub stars](https://img.shields.io/github/stars/link-foundation/command-stream?style=social)](https://github.com/link-foundation/command-stream/stargazers)
 
 [![Open in Gitpod](https://img.shields.io/badge/Gitpod-ready--to--code-f29718?logo=gitpod)](https://gitpod.io/#https://github.com/link-foundation/command-stream)
 [![Open in GitHub Codespaces](https://img.shields.io/badge/GitHub%20Codespaces-Open-181717?logo=github)](https://github.com/codespaces/new?hide_repo_select=true&ref=main&repo=link-foundation/command-stream)
@@ -26,39 +27,48 @@ A modern $ shell utility library with streaming, async iteration, and EventEmitt
 
 ## Comparison with Other Libraries
 
-| Feature | [command-stream](https://github.com/link-foundation/command-stream) | [Bun.$](https://bun.sh/docs/runtime/shell) | [execa](https://github.com/sindresorhus/execa) | [zx](https://github.com/google/zx) | [ShellJS](https://github.com/shelljs/shelljs) | [cross-spawn](https://github.com/moxystudio/node-cross-spawn) |
+| Feature | [**command-stream**](https://github.com/link-foundation/command-stream) | [**execa**](https://github.com/sindresorhus/execa) | [**cross-spawn**](https://github.com/moxystudio/node-cross-spawn) | [**Bun.$**](https://github.com/oven-sh/bun) | [**ShellJS**](https://github.com/shelljs/shelljs) | [**zx**](https://github.com/google/zx) |
 |---------|----------------|-------|-------|-----|-------|-------|
-| **Runtime Support** | ✅ Bun + Node.js | 🟡 Bun only | ✅ Node.js | ✅ Node.js | ✅ Node.js | ✅ Node.js |
-| **Template Literals** | ✅ `` $`cmd` `` | ✅ `` $`cmd` `` | ✅ `` $`cmd` `` | ✅ `` $`cmd` `` | ❌ Function calls | ❌ Function calls |
-| **Real-time Streaming** | ✅ Live output | ❌ Buffer only | 🟡 Limited | ❌ Buffer only | ❌ Buffer only | ❌ Buffer only |
-| **Synchronous Execution** | ✅ `.sync()` with events | ❌ No | ✅ `execaSync` | ❌ No | ✅ Sync by default | ✅ `spawnSync` |
+| **📦 NPM Package** | [![npm](https://img.shields.io/npm/v/command-stream.svg)](https://www.npmjs.com/package/command-stream) | [![npm](https://img.shields.io/npm/v/execa.svg)](https://www.npmjs.com/package/execa) | [![npm](https://img.shields.io/npm/v/cross-spawn.svg)](https://www.npmjs.com/package/cross-spawn) | N/A (Built-in) | [![npm](https://img.shields.io/npm/v/shelljs.svg)](https://www.npmjs.com/package/shelljs) | [![npm](https://img.shields.io/npm/v/zx.svg)](https://www.npmjs.com/package/zx) |
+| **⭐ GitHub Stars** | [**⭐ 2** (Please ⭐ us!)](https://github.com/link-foundation/command-stream) | [⭐ 7,264](https://github.com/sindresorhus/execa) | [⭐ 1,149](https://github.com/moxystudio/node-cross-spawn) | [⭐ 80,169](https://github.com/oven-sh/bun) (Full Runtime) | [⭐ 14,375](https://github.com/shelljs/shelljs) | [⭐ 44,569](https://github.com/google/zx) |
+| **📊 Monthly Downloads** | **893** (New project!) | **381M** | **409M** | N/A (Built-in) | **35M** | **4.2M** |
+| **📈 Total Downloads** | **Growing** | **6B+** | **5.4B** | N/A (Built-in) | **596M** | **37M** |
+| **Runtime Support** | ✅ Bun + Node.js | ✅ Node.js | ✅ Node.js | 🟡 Bun only | ✅ Node.js | ✅ Node.js |
+| **Template Literals** | ✅ `` $`cmd` `` | ✅ `` $`cmd` `` | ❌ Function calls | ✅ `` $`cmd` `` | ❌ Function calls | ✅ `` $`cmd` `` |
+| **Real-time Streaming** | ✅ Live output | 🟡 Limited | ❌ Buffer only | ❌ Buffer only | ❌ Buffer only | ❌ Buffer only |
+| **Synchronous Execution** | ✅ `.sync()` with events | ✅ `execaSync` | ✅ `spawnSync` | ❌ No | ✅ Sync by default | ❌ No |
 | **Async Iteration** | ✅ `for await (chunk of $.stream())` | ❌ No | ❌ No | ❌ No | ❌ No | ❌ No |
-| **EventEmitter Pattern** | ✅ `.on('data', ...)` | ❌ No | 🟡 Limited events | ❌ No | ❌ No | 🟡 Child process events |
+| **EventEmitter Pattern** | ✅ `.on('data', ...)` | 🟡 Limited events | 🟡 Child process events | ❌ No | ❌ No | ❌ No |
 | **Mixed Patterns** | ✅ Events + await/sync | ❌ No | ❌ No | ❌ No | ❌ No | ❌ No |
-| **Bun.$ Compatibility** | ✅ `.text()` method support | ✅ Native API | ❌ No | ❌ No | ❌ No | ❌ No |
-| **Shell Injection Protection** | ✅ Auto-quoting | ✅ Built-in | ✅ Safe by default | ✅ Safe by default | 🟡 Manual escaping | ✅ Safe by default |
-| **Cross-platform** | ✅ macOS/Linux/Windows | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ✅ **Specialized** cross-platform |
-| **Performance** | ⚡ Fast (Bun optimized) | ⚡ Very fast | 🐌 Moderate | 🐌 Slow | 🐌 Moderate | ⚡ Fast |
+| **Bun.$ Compatibility** | ✅ `.text()` method support | ❌ No | ❌ No | ✅ Native API | ❌ No | ❌ No |
+| **Shell Injection Protection** | ✅ Auto-quoting | ✅ Safe by default | ✅ Safe by default | ✅ Built-in | 🟡 Manual escaping | ✅ Safe by default |
+| **Cross-platform** | ✅ macOS/Linux/Windows | ✅ Yes | ✅ **Specialized** cross-platform | ✅ Yes | ✅ Yes | ✅ Yes |
+| **Performance** | ⚡ Fast (Bun optimized) | 🐌 Moderate | ⚡ Fast | ⚡ Very fast | 🐌 Moderate | 🐌 Slow |
 | **Memory Efficiency** | ✅ Streaming prevents buildup | 🟡 Buffers in memory | 🟡 Buffers in memory | 🟡 Buffers in memory | 🟡 Buffers in memory | 🟡 Buffers in memory |
-| **Error Handling** | ✅ Configurable (`set -e`/`set +e`, non-zero OK by default) | ✅ Throws on error | ✅ Throws on error | ✅ Throws on error | ✅ Configurable | ❌ Basic (exit codes) |
+| **Error Handling** | ✅ Configurable (`set -e`/`set +e`, non-zero OK by default) | ✅ Throws on error | ❌ Basic (exit codes) | ✅ Throws on error | ✅ Configurable | ✅ Throws on error |
 | **Shell Settings** | ✅ `set -e`/`set +e` equivalent | ❌ No | ❌ No | ❌ No | 🟡 Limited (`set()`) | ❌ No |
-| **Stdout Support** | ✅ Real-time streaming + events | ✅ Shell redirection + buffered | ✅ Node.js streams + interleaved | ✅ Readable streams + `.pipe.stdout` | ✅ Direct output | ✅ Inherited/buffered |
-| **Stderr Support** | ✅ Real-time streaming + events | ✅ Redirection + `.quiet()` access | ✅ Streams + interleaved output | ✅ Readable streams + `.pipe.stderr` | ✅ Error output | ✅ Inherited/buffered |
-| **Stdin Support** | ✅ string/Buffer/inherit/ignore | ✅ Pipe operations | ✅ Input/output streams | ✅ Basic stdin | 🟡 Basic | ✅ Full stdio support |
-| **Built-in Commands** | ✅ **18 commands**: cat, ls, mkdir, rm, mv, cp, touch, basename, dirname, seq, yes + all Bun.$ commands | ✅ echo, cd, etc. | ❌ Uses system | ❌ Uses system | ✅ **20+ commands**: cat, ls, mkdir, rm, mv, cp, etc. | ❌ Uses system |
-| **Virtual Commands Engine** | ✅ **Revolutionary**: Register JavaScript functions as shell commands with full pipeline support | ❌ No extensibility | ❌ No custom commands | ❌ No custom commands | ❌ No custom commands | ❌ No custom commands |
-| **Pipeline/Piping Support** | ✅ **Advanced**: System + Built-ins + Virtual + Mixed + `.pipe()` method | ✅ Standard shell piping | ✅ Programmatic `.pipe()` + multi-destination | ✅ Shell piping + `.pipe()` method | ✅ Shell piping + `.to()` method | ❌ No piping |
-| **Bundle Size** | 📦 **~20KB gzipped** | 🎯 0KB (built-in) | 📦 ~400KB+ (packagephobia) | 📦 ~50KB+ (estimated) | 📦 ~15KB gzipped | 📦 ~2KB gzipped |
-| **Signal Handling** | ✅ **Advanced SIGINT/SIGTERM forwarding** with cleanup | 🟡 Basic | 🟡 Basic | 🟡 Basic | 🟡 Basic | ✅ **Excellent** cross-platform |
-| **Process Management** | ✅ **Robust child process lifecycle** with proper termination | ❌ Basic | ✅ Good | 🟡 Limited | 🟡 Limited | ✅ **Excellent** spawn wrapper |
-| **Debug Tracing** | ✅ **Comprehensive VERBOSE logging** for CI/debugging | ❌ No | 🟡 Limited | ❌ No | 🟡 Basic | ❌ No |
-| **Test Coverage** | ✅ **410 tests, 909 assertions** | 🟡 Good coverage | ✅ Excellent | 🟡 Good | ✅ Good | ✅ Good |
-| **CI Reliability** | ✅ **Platform-specific handling** (macOS/Ubuntu) | 🟡 Basic | ✅ Good | 🟡 Basic | ✅ Good | ✅ **Excellent** |
-| **Documentation** | ✅ **Comprehensive examples + guides** | ✅ Good | ✅ Excellent | 🟡 Limited | ✅ Good | 🟡 Basic |
-| **TypeScript** | 🔄 Coming soon | ✅ Built-in | ✅ Full support | ✅ Full support | 🟡 Community types | ✅ Built-in |
-| **License** | ✅ **Unlicense (Public Domain)** | 🟡 MIT (+ LGPL dependencies) | 🟡 MIT | 🟡 Apache 2.0 | 🟡 BSD-3-Clause | 🟡 MIT |
-
-**📊 Popularity (Weekly Downloads 2024):** [cross-spawn](https://www.npmjs.com/package/cross-spawn): 102M+ • [execa](https://www.npmjs.com/package/execa): 98M+ • [ShellJS](https://www.npmjs.com/package/shelljs): 9M+ • [zx](https://www.npmjs.com/package/zx): Growing fast
+| **Stdout Support** | ✅ Real-time streaming + events | ✅ Node.js streams + interleaved | ✅ Inherited/buffered | ✅ Shell redirection + buffered | ✅ Direct output | ✅ Readable streams + `.pipe.stdout` |
+| **Stderr Support** | ✅ Real-time streaming + events | ✅ Streams + interleaved output | ✅ Inherited/buffered | ✅ Redirection + `.quiet()` access | ✅ Error output | ✅ Readable streams + `.pipe.stderr` |
+| **Stdin Support** | ✅ string/Buffer/inherit/ignore | ✅ Input/output streams | ✅ Full stdio support | ✅ Pipe operations | 🟡 Basic | ✅ Basic stdin |
+| **Built-in Commands** | ✅ **18 commands**: cat, ls, mkdir, rm, mv, cp, touch, basename, dirname, seq, yes + all Bun.$ commands | ❌ Uses system | ❌ Uses system | ✅ echo, cd, etc. | ✅ **20+ commands**: cat, ls, mkdir, rm, mv, cp, etc. | ❌ Uses system |
+| **Virtual Commands Engine** | ✅ **Revolutionary**: Register JavaScript functions as shell commands with full pipeline support | ❌ No custom commands | ❌ No custom commands | ❌ No extensibility | ❌ No custom commands | ❌ No custom commands |
+| **Pipeline/Piping Support** | ✅ **Advanced**: System + Built-ins + Virtual + Mixed + `.pipe()` method | ✅ Programmatic `.pipe()` + multi-destination | ❌ No piping | ✅ Standard shell piping | ✅ Shell piping + `.to()` method | ✅ Shell piping + `.pipe()` method |
+| **Bundle Size** | 📦 **~20KB gzipped** | 📦 ~400KB+ (packagephobia) | 📦 ~2KB gzipped | 🎯 0KB (built-in) | 📦 ~15KB gzipped | 📦 ~50KB+ (estimated) |
+| **Signal Handling** | ✅ **Advanced SIGINT/SIGTERM forwarding** with cleanup | 🟡 Basic | ✅ **Excellent** cross-platform | 🟡 Basic | 🟡 Basic | 🟡 Basic |
+| **Process Management** | ✅ **Robust child process lifecycle** with proper termination | ✅ Good | ✅ **Excellent** spawn wrapper | ❌ Basic | 🟡 Limited | 🟡 Limited |
+| **Debug Tracing** | ✅ **Comprehensive VERBOSE logging** for CI/debugging | 🟡 Limited | ❌ No | ❌ No | 🟡 Basic | ❌ No |
+| **Test Coverage** | ✅ **410 tests, 909 assertions** | ✅ Excellent | ✅ Good | 🟡 Good coverage | ✅ Good | 🟡 Good |
+| **CI Reliability** | ✅ **Platform-specific handling** (macOS/Ubuntu) | ✅ Good | ✅ **Excellent** | 🟡 Basic | ✅ Good | 🟡 Basic |
+| **Documentation** | ✅ **Comprehensive examples + guides** | ✅ Excellent | 🟡 Basic | ✅ Good | ✅ Good | 🟡 Limited |
+| **TypeScript** | 🔄 Coming soon | ✅ Full support | ✅ Built-in | ✅ Built-in | 🟡 Community types | ✅ Full support |
+| **License** | ✅ **Unlicense (Public Domain)** | 🟡 MIT | 🟡 MIT | 🟡 MIT (+ LGPL dependencies) | 🟡 BSD-3-Clause | 🟡 Apache 2.0 |
+
+**📊 Popularity & Adoption:** 
+- **⭐ GitHub Stars:** [Bun: 80,169](https://github.com/oven-sh/bun) • [zx: 44,569](https://github.com/google/zx) • [ShellJS: 14,375](https://github.com/shelljs/shelljs) • [execa: 7,264](https://github.com/sindresorhus/execa) • [cross-spawn: 1,149](https://github.com/moxystudio/node-cross-spawn) • [**command-stream: 2 ⭐ us!**](https://github.com/link-foundation/command-stream)
+- **📈 Total Downloads:** [execa: 6B+](https://www.npmjs.com/package/execa) • [cross-spawn: 5.4B](https://www.npmjs.com/package/cross-spawn) • [ShellJS: 596M](https://www.npmjs.com/package/shelljs) • [zx: 37M](https://www.npmjs.com/package/zx) • [command-stream: Growing](https://www.npmjs.com/package/command-stream)
+- **📊 Monthly Downloads:** [cross-spawn: 409M](https://www.npmjs.com/package/cross-spawn) • [execa: 381M](https://www.npmjs.com/package/execa) • [ShellJS: 35M](https://www.npmjs.com/package/shelljs) • [zx: 4.2M](https://www.npmjs.com/package/zx) • [command-stream: 893 (growing!)](https://www.npmjs.com/package/command-stream)
+
+**⭐ Help Us Grow!** If command-stream's **revolutionary virtual commands** and **advanced streaming capabilities** help your project, [**please star us on GitHub**](https://github.com/link-foundation/command-stream) to help the project grow!
 
 ### Why Choose command-stream?
 
@@ -291,6 +301,83 @@ syncCmd.on('end', result => {
 const syncResult = syncCmd.sync();
 ```
 
+### Streaming Interfaces
+
+Advanced streaming interfaces for fine-grained process control:
+
+```javascript
+import { $ } from 'command-stream';
+
+// 🎯 STDIN CONTROL: Send data to interactive commands (real-time)
+const grepCmd = $`grep "important"`;
+const stdin = await grepCmd.streams.stdin; // Available immediately
+
+stdin.write('ignore this line\n');
+stdin.write('important message\n');
+stdin.write('skip this too\n');
+stdin.end();
+
+const result = await grepCmd;
+console.log(result.stdout); // "important message\n"
+
+// 🔧 BINARY DATA: Access raw buffers (after command finishes)
+const cmd = $`echo "Hello World"`;
+const buffer = await cmd.buffers.stdout; // Complete snapshot
+console.log(buffer.length); // 12
+
+// 📝 TEXT DATA: Access as strings (after command finishes)
+const textCmd = $`echo "Hello World"`;
+const text = await textCmd.strings.stdout; // Complete snapshot
+console.log(text.trim()); // "Hello World"
+
+// ⚡ PROCESS CONTROL: Kill commands that ignore stdin
+const pingCmd = $`ping google.com`;
+
+// Some commands ignore stdin input
+const pingStdin = await pingCmd.streams.stdin;
+if (pingStdin) {
+  pingStdin.write('q\n'); // ping ignores this
+}
+
+// Use kill() for forceful termination
+setTimeout(() => pingCmd.kill(), 2000);
+const pingResult = await pingCmd;
+console.log('Ping stopped with code:', pingResult.code); // 143 (SIGTERM)
+
+// 🔄 MIXED STDOUT/STDERR: Handle both streams (complete snapshots)
+const mixedCmd = $`sh -c 'echo "out" && echo "err" >&2'`;
+const [stdout, stderr] = await Promise.all([
+  mixedCmd.strings.stdout, // Available after finish
+  mixedCmd.strings.stderr  // Available after finish
+]);
+console.log('Out:', stdout.trim()); // "out"  
+console.log('Err:', stderr.trim()); // "err"
+
+// 🏃‍♂️ AUTO-START: Streams auto-start processes when accessed
+const cmd = $`echo "test"`;
+console.log('Started?', cmd.started); // false
+
+const output = await cmd.streams.stdout; // Auto-starts, immediate access
+console.log('Started?', cmd.started); // true
+
+// 🔙 BACKWARD COMPATIBLE: Traditional await still works
+const traditional = await $`echo "still works"`;
+console.log(traditional.stdout); // "still works\n"
+```
+
+**Key Features:**
+- `command.streams.stdin/stdout/stderr` - Direct access to Node.js streams  
+- `command.buffers.stdin/stdout/stderr` - Binary data as Buffer objects
+- `command.strings.stdin/stdout/stderr` - Text data as strings
+- `command.kill()` - Forceful process termination
+- **Auto-start behavior:** Process starts only when accessing stream properties
+- **Perfect for:** Interactive commands (grep, sort, bc), data processing, real-time control
+- **Network commands (ping, wget) ignore stdin** → Use `kill()` method instead
+
+**🚀 Streams vs Buffers/Strings:**
+- **`streams.*`** - Available **immediately** when command starts, for real-time interaction
+- **`buffers.*` & `strings.*`** - Complete **snapshots** available only **after** command finishes
+
 ### Shell Replacement (.sh → .mjs)
 
 Replace bash scripts with JavaScript while keeping shell semantics:
@@ -367,7 +454,7 @@ Create custom commands that work seamlessly alongside built-ins:
 import { $, register, unregister, listCommands } from 'command-stream';
 
 // Register a custom command
-register('greet', async (args, stdin) => {
+register('greet', async ({ args, stdin }) => {
   const name = args[0] || 'World';
   return { stdout: `Hello, ${name}!\n`, code: 0 };
 });
@@ -377,7 +464,7 @@ await $`greet Alice`;                    // → "Hello, Alice!"
 await $`echo "Bob" | greet`;             // → "Hello, Bob!"
 
 // Streaming virtual commands with async generators
-register('countdown', async function* (args) {
+register('countdown', async function* ({ args }) {
   const start = parseInt(args[0] || 5);
   for (let i = start; i >= 0; i--) {
     yield `${i}\n`;
@@ -414,7 +501,7 @@ await execa('node', ['script.js']);  // execa: separate processes
 await $`node script.js`;             // zx: shell commands only
 
 // ✅ command-stream: JavaScript functions AS shell commands  
-register('deploy', async (args) => {
+register('deploy', async ({ args }) => {
   const env = args[0] || 'staging';
   await deployToEnvironment(env);
   return { stdout: `Deployed to ${env}!\n`, code: 0 };
@@ -450,11 +537,11 @@ await $`seq 1 5 | cat > numbers.txt`;
 await $`git log --oneline | head -n 5`;
 
 // 🚀 UNIQUE: Virtual command piping
-register('uppercase', async (args, stdin) => {
+register('uppercase', async ({ args, stdin }) => {
   return { stdout: stdin.toUpperCase(), code: 0 };
 });
 
-register('reverse', async (args, stdin) => {
+register('reverse', async ({ args, stdin }) => {
   return { stdout: stdin.split('').reverse().join(''), code: 0 };
 });
 
@@ -482,12 +569,12 @@ import { $, register } from 'command-stream';
 const result = await $`echo "hello"`.pipe($`echo "World: $(cat)"`);
 
 // 🌟 Virtual command chaining
-register('add-prefix', async (args, stdin) => {
+register('add-prefix', async ({ args, stdin }) => {
   const prefix = args[0] || 'PREFIX:';
   return { stdout: `${prefix} ${stdin.trim()}\n`, code: 0 };
 });
 
-register('add-suffix', async (args, stdin) => {
+register('add-suffix', async ({ args, stdin }) => {
   const suffix = args[0] || 'SUFFIX';
   return { stdout: `${stdin.trim()} ${suffix}\n`, code: 0 };
 });
@@ -512,7 +599,7 @@ try {
 }
 
 // ✅ Complex data processing
-register('json-parse', async (args, stdin) => {
+register('json-parse', async ({ args, stdin }) => {
   try {
     const data = JSON.parse(stdin);
     return { stdout: JSON.stringify(data, null, 2), code: 0 };
@@ -521,7 +608,7 @@ register('json-parse', async (args, stdin) => {
   }
 });
 
-register('extract-field', async (args, stdin) => {
+register('extract-field', async ({ args, stdin }) => {
   const field = args[0];
   try {
     const data = JSON.parse(stdin);
@@ -778,9 +865,9 @@ Control and extend the command system with custom JavaScript functions:
 import { $, register } from 'command-stream';
 
 // ✅ Cancellation support with AbortController
-register('cancellable', async function* (args, stdin, options) {
+register('cancellable', async function* ({ args, stdin, abortSignal }) {
   for (let i = 0; i < 10; i++) {
-    if (options.signal?.aborted) {
+    if (abortSignal?.aborted) {
       break; // Proper cancellation handling
     }
     yield `Count: ${i}\n`;
@@ -789,22 +876,28 @@ register('cancellable', async function* (args, stdin, options) {
 });
 
 // ✅ Access to all process options
-register('debug-info', async (args, stdin, options) => {
+// All original options (built-in + custom) are available in the 'options' object
+// Common options like cwd, env are also available at top level for convenience
+// Runtime additions: isCancelled function, abortSignal
+register('debug-info', async ({ args, stdin, cwd, env, options, isCancelled }) => {
   return {
     stdout: JSON.stringify({
       args,
-      cwd: options.cwd,
-      env: Object.keys(options.env || {}),
-      stdinLength: stdin.length,
-      mirror: options.mirror,
-      capture: options.capture
+      cwd,  // Available at top level for convenience
+      env: Object.keys(env || {}),  // Available at top level for convenience
+      stdinLength: stdin?.length || 0,
+      allOptions: options,  // All original options (built-in + custom)
+      mirror: options.mirror,  // Built-in option from options object
+      capture: options.capture,  // Built-in option from options object
+      customOption: options.customOption || 'not provided',  // Custom option
+      isCancelledAvailable: typeof isCancelled === 'function'
     }, null, 2),
     code: 0
   };
 });
 
 // ✅ Error handling and non-zero exit codes
-register('maybe-fail', async (args) => {
+register('maybe-fail', async ({ args }) => {
   if (Math.random() > 0.5) {
     return {
       stdout: 'Success!\n',
@@ -818,13 +911,27 @@ register('maybe-fail', async (args) => {
     };
   }
 });
+
+// ✅ Example: User options flow through to virtual commands
+register('show-options', async ({ args, stdin, options, cwd }) => {
+  return {
+    stdout: `Custom: ${options.customValue || 'none'}, CWD: ${cwd || options.cwd || 'default'}\n`,
+    code: 0
+  };
+});
+
+// Usage example showing options passed to virtual command:
+const result = await $({ customValue: 'hello world', cwd: '/tmp' })`show-options`;
+console.log(result.stdout); // Output: Custom: hello world, CWD: /tmp
 ```
 
 #### Handler Function Signature
 
 ```javascript
 // Regular async function
-async function handler(args, stdin, options) {
+async function handler({ args, stdin, abortSignal, cwd, env, options, isCancelled }) {
+  // All original options available in 'options': options.mirror, options.capture, options.customValue, etc.
+  // Common options like cwd, env also available at top level for convenience
   return {
     code: 0,           // Exit code (number)
     stdout: "output",  // Standard output (string)
@@ -833,10 +940,13 @@ async function handler(args, stdin, options) {
 }
 
 // Async generator for streaming
-async function* streamingHandler(args, stdin, options) {
+async function streamingHandler({ args, stdin, abortSignal, cwd, env, options, isCancelled }) {
+  // Access both built-in and custom options from 'options' object
+  if (options.customFlag) {
+    yield "custom behavior\n";
+  }
   yield "chunk1\n";
   yield "chunk2\n";
-  // Each yield sends a chunk in real-time
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "command-stream",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Modern $ shell utility library with streaming, async iteration, and EventEmitter support, optimized for Bun runtime",
   "type": "module",
   "main": "src/$.mjs",

package/src/$.mjs

@@ -513,6 +513,14 @@ class StreamEmitter {
     return this;
   }
 
+  once(event, listener) {
+    const onceWrapper = (...args) => {
+      this.off(event, onceWrapper);
+      listener(...args);
+    };
+    return this.on(event, onceWrapper);
+  }
+
   emit(event, ...args) {
     const eventListeners = this.listeners.get(event);
     trace('StreamEmitter', () => `Emitting event | ${JSON.stringify({ 
@@ -521,7 +529,9 @@ class StreamEmitter {
       listenerCount: eventListeners?.length || 0 
     })}`);
     if (eventListeners) {
-      for (const listener of eventListeners) {
+      // Create a copy to avoid issues if listeners modify the array
+      const listenersToCall = [...eventListeners];
+      for (const listener of listenersToCall) {
         listener(...args);
       }
     }
@@ -655,6 +665,281 @@ class ProcessRunner extends StreamEmitter {
     return this.child ? this.child.stdin : null;
   }
 
+  // Issue #33: New streaming interfaces
+  _autoStartIfNeeded(reason) {
+    if (!this.started && !this.finished) {
+      trace('ProcessRunner', () => `Auto-starting process due to ${reason}`);
+      this.start({ mode: 'async', stdin: 'pipe', stdout: 'pipe', stderr: 'pipe' });
+    }
+  }
+
+  get streams() {
+    const self = this;
+    return {
+      get stdin() {
+        trace('ProcessRunner.streams', () => `stdin access | ${JSON.stringify({
+          hasChild: !!self.child,
+          hasStdin: !!(self.child && self.child.stdin),
+          started: self.started,
+          finished: self.finished,
+          hasPromise: !!self.promise,
+          command: self.spec?.command?.slice(0, 50)
+        }, null, 2)}`);
+        
+        self._autoStartIfNeeded('streams.stdin access');
+        
+        // Streams are available immediately after spawn, or null if not piped
+        // Return the stream directly if available, otherwise ensure process starts
+        if (self.child && self.child.stdin) {
+          trace('ProcessRunner.streams', () => 'stdin: returning existing stream');
+          return self.child.stdin;
+        }
+        if (self.finished) {
+          trace('ProcessRunner.streams', () => 'stdin: process finished, returning null');
+          return null;
+        }
+        
+        // For virtual commands, there's no child process
+        // Exception: virtual commands with stdin: "pipe" will fallback to real commands
+        const isVirtualCommand = self._virtualGenerator || (self.spec && self.spec.command && virtualCommands.has(self.spec.command.split(' ')[0]));
+        const willFallbackToReal = isVirtualCommand && self.options.stdin === 'pipe';
+        
+        if (isVirtualCommand && !willFallbackToReal) {
+          trace('ProcessRunner.streams', () => 'stdin: virtual command, returning null');
+          return null;
+        }
+        
+        // If not started, start it and wait for child to be created (not for completion!)
+        if (!self.started) {
+          trace('ProcessRunner.streams', () => 'stdin: not started, starting and waiting for child');
+          // Start the process
+          self._startAsync();
+          // Wait for child to be created using async iteration
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stdin) {
+                resolve(self.child.stdin);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                // Use setImmediate to check again in next event loop iteration
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        // Process is starting - wait for child to appear
+        if (self.promise && !self.child) {
+          trace('ProcessRunner.streams', () => 'stdin: process starting, waiting for child');
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stdin) {
+                resolve(self.child.stdin);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        trace('ProcessRunner.streams', () => 'stdin: returning null (no conditions met)');
+        return null;
+      },
+      get stdout() {
+        trace('ProcessRunner.streams', () => `stdout access | ${JSON.stringify({
+          hasChild: !!self.child,
+          hasStdout: !!(self.child && self.child.stdout),
+          started: self.started,
+          finished: self.finished,
+          hasPromise: !!self.promise,
+          command: self.spec?.command?.slice(0, 50)
+        }, null, 2)}`);
+        
+        self._autoStartIfNeeded('streams.stdout access');
+        
+        if (self.child && self.child.stdout) {
+          trace('ProcessRunner.streams', () => 'stdout: returning existing stream');
+          return self.child.stdout;
+        }
+        if (self.finished) {
+          trace('ProcessRunner.streams', () => 'stdout: process finished, returning null');
+          return null;
+        }
+        
+        // For virtual commands, there's no child process
+        if (self._virtualGenerator || (self.spec && self.spec.command && virtualCommands.has(self.spec.command.split(' ')[0]))) {
+          trace('ProcessRunner.streams', () => 'stdout: virtual command, returning null');
+          return null;
+        }
+        
+        if (!self.started) {
+          trace('ProcessRunner.streams', () => 'stdout: not started, starting and waiting for child');
+          self._startAsync();
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stdout) {
+                resolve(self.child.stdout);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        if (self.promise && !self.child) {
+          trace('ProcessRunner.streams', () => 'stdout: process starting, waiting for child');
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stdout) {
+                resolve(self.child.stdout);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        trace('ProcessRunner.streams', () => 'stdout: returning null (no conditions met)');
+        return null;
+      },
+      get stderr() {
+        trace('ProcessRunner.streams', () => `stderr access | ${JSON.stringify({
+          hasChild: !!self.child,
+          hasStderr: !!(self.child && self.child.stderr),
+          started: self.started,
+          finished: self.finished,
+          hasPromise: !!self.promise,
+          command: self.spec?.command?.slice(0, 50)
+        }, null, 2)}`);
+        
+        self._autoStartIfNeeded('streams.stderr access');
+        
+        if (self.child && self.child.stderr) {
+          trace('ProcessRunner.streams', () => 'stderr: returning existing stream');
+          return self.child.stderr;
+        }
+        if (self.finished) {
+          trace('ProcessRunner.streams', () => 'stderr: process finished, returning null');
+          return null;
+        }
+        
+        // For virtual commands, there's no child process
+        if (self._virtualGenerator || (self.spec && self.spec.command && virtualCommands.has(self.spec.command.split(' ')[0]))) {
+          trace('ProcessRunner.streams', () => 'stderr: virtual command, returning null');
+          return null;
+        }
+        
+        if (!self.started) {
+          trace('ProcessRunner.streams', () => 'stderr: not started, starting and waiting for child');
+          self._startAsync();
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stderr) {
+                resolve(self.child.stderr);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        if (self.promise && !self.child) {
+          trace('ProcessRunner.streams', () => 'stderr: process starting, waiting for child');
+          return new Promise((resolve) => {
+            const checkForChild = () => {
+              if (self.child && self.child.stderr) {
+                resolve(self.child.stderr);
+              } else if (self.finished || self._virtualGenerator) {
+                resolve(null);
+              } else {
+                setImmediate(checkForChild);
+              }
+            };
+            setImmediate(checkForChild);
+          });
+        }
+        
+        trace('ProcessRunner.streams', () => 'stderr: returning null (no conditions met)');
+        return null;
+      }
+    };
+  }
+
+  get buffers() {
+    const self = this;
+    return {
+      get stdin() {
+        self._autoStartIfNeeded('buffers.stdin access');
+        if (self.finished && self.result) {
+          return Buffer.from(self.result.stdin || '', 'utf8');
+        }
+        // Return promise if not finished
+        return self.then ? self.then(result => Buffer.from(result.stdin || '', 'utf8')) : Promise.resolve(Buffer.alloc(0));
+      },
+      get stdout() {
+        self._autoStartIfNeeded('buffers.stdout access');
+        if (self.finished && self.result) {
+          return Buffer.from(self.result.stdout || '', 'utf8');
+        }
+        // Return promise if not finished
+        return self.then ? self.then(result => Buffer.from(result.stdout || '', 'utf8')) : Promise.resolve(Buffer.alloc(0));
+      },
+      get stderr() {
+        self._autoStartIfNeeded('buffers.stderr access');
+        if (self.finished && self.result) {
+          return Buffer.from(self.result.stderr || '', 'utf8');
+        }
+        // Return promise if not finished
+        return self.then ? self.then(result => Buffer.from(result.stderr || '', 'utf8')) : Promise.resolve(Buffer.alloc(0));
+      }
+    };
+  }
+
+  get strings() {
+    const self = this;
+    return {
+      get stdin() {
+        self._autoStartIfNeeded('strings.stdin access');
+        if (self.finished && self.result) {
+          return self.result.stdin || '';
+        }
+        // Return promise if not finished
+        return self.then ? self.then(result => result.stdin || '') : Promise.resolve('');
+      },
+      get stdout() {
+        self._autoStartIfNeeded('strings.stdout access');
+        if (self.finished && self.result) {
+          return self.result.stdout || '';
+        }
+        // Return promise if not finished
+        return self.then ? self.then(result => result.stdout || '') : Promise.resolve('');
+      },
+      get stderr() {
+        self._autoStartIfNeeded('strings.stderr access');
+        if (self.finished && self.result) {
+          return self.result.stderr || '';
+        }
+        // Return promise if not finished  
+        return self.then ? self.then(result => result.stderr || '') : Promise.resolve('');
+      }
+    };
+  }
+
+
   // Centralized method to properly finish a process with correct event emission order
   finish(result) {
     trace('ProcessRunner', () => `finish() called | ${JSON.stringify({
@@ -814,14 +1099,15 @@ class ProcessRunner extends StreamEmitter {
           writer.close().catch(() => { }); // Ignore close errors
         }
 
-        setTimeout(() => {
+        // Use setImmediate for deferred termination instead of setTimeout
+        setImmediate(() => {
           if (this.child && !this.finished) {
             trace('ProcessRunner', () => 'Terminating child process after parent stream closure');
             if (typeof this.child.kill === 'function') {
               this.child.kill('SIGTERM');
             }
           }
-        }, 100);
+        });
 
       } catch (error) {
         trace('ProcessRunner', () => `Error during graceful shutdown | ${JSON.stringify({ error: error.message }, null, 2)}`);
@@ -939,7 +1225,14 @@ class ProcessRunner extends StreamEmitter {
   start(options = {}) {
     const mode = options.mode || 'async';
 
-    trace('ProcessRunner', () => `start ENTER | ${JSON.stringify({ mode, options, started: this.started }, null, 2)}`);
+    trace('ProcessRunner', () => `start ENTER | ${JSON.stringify({ 
+      mode, 
+      options, 
+      started: this.started,
+      hasPromise: !!this.promise,
+      hasChild: !!this.child,
+      command: this.spec?.command?.slice(0, 50)
+    }, null, 2)}`);
 
     // Merge new options with existing options before starting
     if (Object.keys(options).length > 0 && !this.started) {
@@ -1115,16 +1408,17 @@ class ProcessRunner extends StreamEmitter {
             commandCount: parsed.commands?.length
           }, null, 2)}`);
           return await this._runPipeline(parsed.commands);
-        } else if (parsed.type === 'simple' && virtualCommandsEnabled && virtualCommands.has(parsed.cmd)) {
+        } else if (parsed.type === 'simple' && virtualCommandsEnabled && virtualCommands.has(parsed.cmd) && !this.options._bypassVirtual) {
           // For built-in virtual commands that have real counterparts (like sleep),
           // skip the virtual version when custom stdin is provided to ensure proper process handling
           const hasCustomStdin = this.options.stdin && 
                                  this.options.stdin !== 'inherit' && 
                                  this.options.stdin !== 'ignore';
           
-          // List of built-in virtual commands that should fallback to real commands with custom stdin
-          const builtinCommands = ['sleep', 'echo', 'pwd', 'true', 'false', 'yes', 'cat', 'ls', 'which'];
-          const shouldBypassVirtual = hasCustomStdin && builtinCommands.includes(parsed.cmd);
+          // Only bypass for commands that truly need real process behavior with custom stdin
+          // Most commands like 'echo' work fine with virtual implementations even with stdin
+          const commandsThatNeedRealStdin = ['sleep', 'cat']; // Only these really need real processes for stdin
+          const shouldBypassVirtual = hasCustomStdin && commandsThatNeedRealStdin.includes(parsed.cmd);
           
           if (shouldBypassVirtual) {
             trace('ProcessRunner', () => `Bypassing built-in virtual command due to custom stdin | ${JSON.stringify({
@@ -1380,6 +1674,10 @@ class ProcessRunner extends StreamEmitter {
         this.child.stdin.end();
         trace('ProcessRunner', () => `stdin: Child stdin closed successfully`);
       }
+    } else if (stdin === 'pipe') {
+      trace('ProcessRunner', () => `stdin: Using pipe mode - leaving stdin open for manual control`);
+      // Leave stdin open for manual writing via streams.stdin
+      stdinPumpPromise = Promise.resolve();
     } else if (typeof stdin === 'string' || Buffer.isBuffer(stdin)) {
       const buf = Buffer.isBuffer(stdin) ? stdin : Buffer.from(stdin);
       trace('ProcessRunner', () => `stdin: Writing buffer to child | ${JSON.stringify({
@@ -1675,7 +1973,23 @@ class ProcessRunner extends StreamEmitter {
     try {
       // Prepare stdin
       let stdinData = '';
-      if (this.options.stdin && typeof this.options.stdin === 'string') {
+      
+      // Special handling for streaming mode (stdin: "pipe")
+      if (this.options.stdin === 'pipe') {
+        // For streaming interfaces, virtual commands should fallback to real commands
+        // because virtual commands don't support true streaming
+        trace('ProcessRunner', () => `Virtual command fallback for streaming | ${JSON.stringify({ cmd }, null, 2)}`);
+        
+        // Create a new ProcessRunner for the real command with properly merged options
+        // Preserve main options but use appropriate stdin for the real command
+        const modifiedOptions = { 
+          ...this.options, 
+          stdin: 'pipe', // Keep pipe but ensure it doesn't trigger virtual command fallback
+          _bypassVirtual: true // Flag to prevent virtual command recursion
+        };
+        const realRunner = new ProcessRunner({ mode: 'shell', command: originalCommand || cmd }, modifiedOptions);
+        return await realRunner._doStartAsync();
+      } else if (this.options.stdin && typeof this.options.stdin === 'string') {
         stdinData = this.options.stdin;
       } else if (this.options.stdin && Buffer.isBuffer(this.options.stdin)) {
         stdinData = this.options.stdin.toString('utf8');
@@ -1698,22 +2012,28 @@ class ProcessRunner extends StreamEmitter {
         const chunks = [];
 
         const commandOptions = {
-          ...this.options,
-          isCancelled: () => this._cancelled,
-          signal: this._abortController?.signal
+          // Commonly used options at top level for convenience
+          cwd: this.options.cwd,
+          env: this.options.env,
+          // All original options (built-in + custom) in options object
+          options: this.options,
+          isCancelled: () => this._cancelled
         };
         
         trace('ProcessRunner', () => `_runVirtual signal details | ${JSON.stringify({
           cmd,
           hasAbortController: !!this._abortController,
           signalAborted: this._abortController?.signal?.aborted,
-          signalExists: !!commandOptions.signal,
-          commandOptionsSignalAborted: commandOptions.signal?.aborted,
           optionsSignalExists: !!this.options.signal,
           optionsSignalAborted: this.options.signal?.aborted
         }, null, 2)}`);
 
-        const generator = handler({ args: argValues, stdin: stdinData, ...commandOptions });
+        const generator = handler({ 
+          args: argValues, 
+          stdin: stdinData, 
+          abortSignal: this._abortController?.signal,
+          ...commandOptions 
+        });
         this._virtualGenerator = generator;
 
         const cancelPromise = new Promise(resolve => {
@@ -1802,22 +2122,28 @@ class ProcessRunner extends StreamEmitter {
       } else {
         // Regular async function - race with abort signal
         const commandOptions = {
-          ...this.options,
-          isCancelled: () => this._cancelled,
-          signal: this._abortController?.signal
+          // Commonly used options at top level for convenience
+          cwd: this.options.cwd,
+          env: this.options.env,
+          // All original options (built-in + custom) in options object
+          options: this.options,
+          isCancelled: () => this._cancelled
         };
         
         trace('ProcessRunner', () => `_runVirtual signal details (non-generator) | ${JSON.stringify({
           cmd,
           hasAbortController: !!this._abortController,
           signalAborted: this._abortController?.signal?.aborted,
-          signalExists: !!commandOptions.signal,
-          commandOptionsSignalAborted: commandOptions.signal?.aborted,
           optionsSignalExists: !!this.options.signal,
           optionsSignalAborted: this.options.signal?.aborted
         }, null, 2)}`);
         
-        const handlerPromise = handler({ args: argValues, stdin: stdinData, ...commandOptions });
+        const handlerPromise = handler({ 
+          args: argValues, 
+          stdin: stdinData, 
+          abortSignal: this._abortController?.signal,
+          ...commandOptions 
+        });
         
         // Create an abort promise that rejects when cancelled
         const abortPromise = new Promise((_, reject) => {

package/src/commands/$.cat.mjs

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function cat({ args, stdin, cwd, isCancelled, signal }) {
+export default async function cat({ args, stdin, cwd, isCancelled, abortSignal }) {
   if (args.length === 0) {
     // Read from stdin if no files specified
     if (stdin !== undefined && stdin !== '') {
@@ -14,7 +14,7 @@ export default async function cat({ args, stdin, cwd, isCancelled, signal }) {
     const outputs = [];
     for (const file of args) {
       // Check for cancellation before processing each file
-      if (isCancelled?.() || signal?.aborted) {
+      if (isCancelled?.() || abortSignal?.aborted) {
         trace('VirtualCommand', () => `cat: cancelled while processing files`);
         return { code: 130, stdout: '', stderr: '' }; // SIGINT exit code
       }

package/src/commands/$.sleep.mjs

@@ -1,11 +1,11 @@
 import { trace } from '../$.utils.mjs';
 
-export default async function sleep({ args, signal, isCancelled }) {
+export default async function sleep({ args, abortSignal, isCancelled }) {
   const seconds = parseFloat(args[0] || 0);
   trace('VirtualCommand', () => `sleep: starting | ${JSON.stringify({ 
     seconds,
-    hasSignal: !!signal,
-    signalAborted: signal?.aborted,
+    hasSignal: !!abortSignal,
+    signalAborted: abortSignal?.aborted,
     hasIsCancelled: !!isCancelled
   }, null, 2)}`);
   
@@ -18,30 +18,30 @@ export default async function sleep({ args, signal, isCancelled }) {
     await new Promise((resolve, reject) => {
       const timeoutId = setTimeout(resolve, seconds * 1000);
       
-      // Handle cancellation via signal
-      if (signal) {
+      // Handle cancellation via abort signal
+      if (abortSignal) {
         trace('VirtualCommand', () => `sleep: setting up abort signal listener | ${JSON.stringify({
-          signalAborted: signal.aborted
+          signalAborted: abortSignal.aborted
         }, null, 2)}`);
         
-        signal.addEventListener('abort', () => {
+        abortSignal.addEventListener('abort', () => {
           trace('VirtualCommand', () => `sleep: abort signal received | ${JSON.stringify({
             seconds,
-            signalAborted: signal.aborted
+            signalAborted: abortSignal.aborted
           }, null, 2)}`);
           clearTimeout(timeoutId);
           reject(new Error('Sleep cancelled'));
         });
         
         // Check if already aborted
-        if (signal.aborted) {
+        if (abortSignal.aborted) {
           trace('VirtualCommand', () => `sleep: signal already aborted | ${JSON.stringify({ seconds }, null, 2)}`);
           clearTimeout(timeoutId);
           reject(new Error('Sleep cancelled'));
           return;
         }
       } else {
-        trace('VirtualCommand', () => `sleep: no signal provided | ${JSON.stringify({ seconds }, null, 2)}`);
+        trace('VirtualCommand', () => `sleep: no abort signal provided | ${JSON.stringify({ seconds }, null, 2)}`);
       }
       
       // Also check isCancelled periodically for quicker response

package/src/commands/$.yes.mjs

@@ -1,11 +1,11 @@
 import { trace } from '../$.utils.mjs';
 
-export default async function* yes({ args, stdin, isCancelled, signal, ...rest }) {
+export default async function* yes({ args, stdin, isCancelled, abortSignal, ...rest }) {
   const output = args.length > 0 ? args.join(' ') : 'y';
   trace('VirtualCommand', () => `yes: starting infinite generator | ${JSON.stringify({ 
     output,
     hasIsCancelled: !!isCancelled,
-    hasSignal: !!signal
+    hasAbortSignal: !!abortSignal
   }, null, 2)}`);
 
   let iteration = 0;
@@ -14,12 +14,12 @@ export default async function* yes({ args, stdin, isCancelled, signal, ...rest }
   while (!isCancelled?.() && iteration < MAX_ITERATIONS) {
     trace('VirtualCommand', () => `yes: iteration ${iteration} starting | ${JSON.stringify({
       isCancelled: isCancelled?.(),
-      signalAborted: signal?.aborted
+      abortSignalAborted: abortSignal?.aborted
     }, null, 2)}`);
     
     // Check for abort signal
-    if (signal?.aborted) {
-      trace('VirtualCommand', () => `yes: aborted via signal | ${JSON.stringify({ iteration }, null, 2)}`);
+    if (abortSignal?.aborted) {
+      trace('VirtualCommand', () => `yes: aborted via abort signal | ${JSON.stringify({ iteration }, null, 2)}`);
       break;
     }
 
@@ -43,6 +43,6 @@ export default async function* yes({ args, stdin, isCancelled, signal, ...rest }
   trace('VirtualCommand', () => `yes: generator completed | ${JSON.stringify({ 
     iteration,
     wasCancelled: isCancelled?.(),
-    wasAborted: signal?.aborted
+    wasAborted: abortSignal?.aborted
   }, null, 2)}`);
 }