functionalscript 0.22.0 → 0.24.0

package/fs/text/sgr/module.f.d.ts

@@ -4,9 +4,8 @@
  *
  * @module
  */
-import type { Io, Writable } from "../../io/module.f.ts";
-import { type Write, type WriteConsoles, type NodeProgramOptions } from '../../types/effects/node/module.f.ts';
-import { type Effect } from '../../types/effects/module.f.ts';
+import { type Write, type WriteConsoles, type NodeProgramOptions } from '../../effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
 export declare const backspace: string;
 type End = 'm';
 type Csi = (code: number | string) => string;
@@ -45,20 +44,6 @@ export type WriteText = (text: string) => WriteText;
  */
 export declare const createConsoleText: (stdout: Stdout) => WriteText;
 export type CsiConsole = (s: string) => void;
-/**
- * Creates a TTY-aware console function. Appends `\n` to each string before writing.
- *
- * For TTY destinations, ANSI SGR sequences are preserved.
- * For non-TTY destinations, ANSI SGR sequences are stripped.
- *
- * @param io - Runtime IO bindings.
- * @returns A function that targets a writable stream.
- */
-export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => CsiConsole;
-/** Writes to process stdout using a TTY-aware CSI console. */
-export declare const stdio: (io: Io) => CsiConsole;
-/** Writes to process stderr using a TTY-aware CSI console. */
-export declare const stderr: (io: Io) => CsiConsole;
 /**
  * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.

package/fs/text/sgr/module.f.js

@@ -4,8 +4,10 @@
  *
  * @module
  */
-import { write } from "../../types/effects/node/module.f.js";
-import {} from "../../types/effects/module.f.js";
+// C0 control codes
+// https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
+import { write } from "../../effects/node/module.f.js";
+import {} from "../../effects/module.f.js";
 import { utf8 } from "../module.f.js";
 export const backspace = '\x08';
 const begin = '\x1b[';
@@ -50,23 +52,6 @@ export const createConsoleText = (stdout) => {
     return f('');
 };
 const str = (isTTY) => (s) => isTTY ? s : s.replace(/\x1b\[[0-9;]*m/g, '');
-/**
- * Creates a TTY-aware console function. Appends `\n` to each string before writing.
- *
- * For TTY destinations, ANSI SGR sequences are preserved.
- * For non-TTY destinations, ANSI SGR sequences are stripped.
- *
- * @param io - Runtime IO bindings.
- * @returns A function that targets a writable stream.
- */
-export const console = ({ fs: { writeSync } }) => (w) => {
-    const toStr = str(w.isTTY);
-    return (s) => writeSync(w.fd, toStr(s) + '\n');
-};
-/** Writes to process stdout using a TTY-aware CSI console. */
-export const stdio = (io) => console(io)(io.process.stdout);
-/** Writes to process stderr using a TTY-aware CSI console. */
-export const stderr = (io) => console(io)(io.process.stderr);
 /**
  * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.

package/fs/types/bigint/module.f.d.ts

@@ -13,7 +13,6 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
- * const m = min(3n)(13n) // 3n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
@@ -130,20 +129,6 @@ export declare const bitLength: (v: bigint) => bigint;
  * ```
  */
 export declare const mask: (len: bigint) => bigint;
-/**
- * Returns the smaller of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the smaller value.
- */
-export declare const min: (a: bigint) => (b: bigint) => bigint;
-/**
- * Returns the larger of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the larger value.
- */
-export declare const max: (a: bigint) => (b: bigint) => bigint;
 /**
  * Calculates the partial factorial `b!/a!`.
  *

package/fs/types/bigint/module.f.js

@@ -13,7 +13,6 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
- * const m = min(3n)(13n) // 3n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
@@ -174,20 +173,6 @@ export const bitLength = (v) => log2(abs(v)) + 1n;
  * ```
  */
 export const mask = (len) => (1n << len) - 1n;
-/**
- * Returns the smaller of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the smaller value.
- */
-export const min = (a) => (b) => a < b ? a : b;
-/**
- * Returns the larger of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the larger value.
- */
-export const max = (a) => (b) => a < b ? b : a;
 /**
  * Calculates the partial factorial `b!/a!`.
  *

package/fs/types/bigint/proof.f.js

@@ -1,4 +1,5 @@
-import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial, divUp, roundUp } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, divUp, roundUp } from "./module.f.js";
+import { min } from "../function/compare/module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;

package/fs/types/bit_vec/module.f.js

@@ -21,12 +21,12 @@
  *
  * @module
  */
-import { bitLength, divUp, mask, max, min, xor } from "../bigint/module.f.js";
+import { bitLength, divUp, mask, xor } from "../bigint/module.f.js";
 import { flip, identity } from "../function/module.f.js";
 import { fold, iterable, map } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
-import { cmp } from "../function/compare/module.f.js";
+import { cmp, max, min } from "../function/compare/module.f.js";
 /**
  * An empty vector of bits.
  */

package/fs/types/function/compare/module.f.d.ts

@@ -24,6 +24,18 @@ export type Cmp2<A, B> = [
     B
 ] extends [bigint, bigint] ? bigint : never;
 export declare const cmp: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => Sign;
+/**
+ * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `min(1)("a")`) at compile time.
+ */
+export declare const min: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
+/**
+ * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `max(1)("a")`) at compile time.
+ */
+export declare const max: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
 /**
  * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
  * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a

package/fs/types/function/compare/module.f.js

@@ -4,6 +4,18 @@ export const index5 = cmp => ([v0, v1]) => {
     return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
 };
 export const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+ * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `min(1)("a")`) at compile time.
+ */
+export const min = (a) => (b) => cmp(a)(b) < 0 ? a : b;
+/**
+ * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `max(1)("a")`) at compile time.
+ */
+export const max = (a) => (b) => cmp(a)(b) > 0 ? a : b;
 /**
  * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
  * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a

package/fs/types/function/compare/proof.f.js

@@ -1,4 +1,4 @@
-import { cmp } from "./module.f.js";
+import { cmp, min, max } from "./module.f.js";
 export const proof = () => {
     {
         const result = cmp(true)(false);
@@ -37,4 +37,34 @@ export const proof = () => {
         // const f = (a: string|number, b: string|number) => cmp(a)(b) // compilation error
         // const f = (a: number, b: string|number) => cmp(a)(b) // compilation error
     }
+    {
+        if (min(3)(5) !== 3) {
+            throw 'min(3)(5)';
+        }
+        if (min(7)(2) !== 2) {
+            throw 'min(7)(2)';
+        }
+        if (min(3n)(13n) !== 3n) {
+            throw 'min(3n)(13n)';
+        }
+        if (min("a")("b") !== "a") {
+            throw 'min("a")("b")';
+        }
+        // const _ = min(1)("a") // compilation error
+    }
+    {
+        if (max(3)(5) !== 5) {
+            throw 'max(3)(5)';
+        }
+        if (max(7)(2) !== 7) {
+            throw 'max(7)(2)';
+        }
+        if (max(3n)(13n) !== 13n) {
+            throw 'max(3n)(13n)';
+        }
+        if (max("a")("b") !== "b") {
+            throw 'max("a")("b")';
+        }
+        // const _ = max(1)("a") // compilation error
+    }
 };

package/fs/types/function/operator/module.f.d.ts

@@ -18,7 +18,5 @@ export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<
 export type Reduce<T> = Fold<T, T>;
 export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
 export declare const addition: Reduce<number>;
-export declare const min: Reduce<number>;
-export declare const max: Reduce<number>;
 export declare const increment: (b: number) => number;
 export declare const counter: () => (b: number) => number;

package/fs/types/function/operator/module.f.js

@@ -12,7 +12,5 @@ export const foldToScan = (fold) => (prior) => i => {
 };
 export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
 export const addition = a => b => a + b;
-export const min = a => b => a < b ? a : b;
-export const max = a => b => a > b ? a : b;
 export const increment = addition(1);
 export const counter = () => increment;

package/fs/types/function/operator/proof.f.d.ts

@@ -4,8 +4,6 @@ export declare const proof: {
     logicalNotTest: () => void;
     strictEqualTest: () => void;
     additionTest: () => void;
-    minTest: () => void;
-    maxTest: () => void;
     incrementTest: () => void;
     foldToScanTest: () => void;
     reduceToScanTest: () => void;

package/fs/types/function/operator/proof.f.js

@@ -1,4 +1,4 @@
-import { join, concat, logicalNot, strictEqual, addition, min, max, increment, foldToScan, reduceToScan, } from "./module.f.js";
+import { join, concat, logicalNot, strictEqual, addition, increment, foldToScan, reduceToScan, } from "./module.f.js";
 const joinTest = () => {
     const result = join(', ')('world')('hello');
     if (result !== 'hello, world') {
@@ -33,22 +33,6 @@ const additionTest = () => {
         throw result;
     }
 };
-const minTest = () => {
-    if (min(3)(5) !== 3) {
-        throw 'min(3)(5)';
-    }
-    if (min(7)(2) !== 2) {
-        throw 'min(7)(2)';
-    }
-};
-const maxTest = () => {
-    if (max(3)(5) !== 5) {
-        throw 'max(3)(5)';
-    }
-    if (max(7)(2) !== 7) {
-        throw 'max(7)(2)';
-    }
-};
 const incrementTest = () => {
     if (increment(4) !== 5) {
         throw 'increment(4)';
@@ -79,4 +63,4 @@ const reduceToScanTest = () => {
         throw v1;
     }
 };
-export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, minTest, maxTest, incrementTest, foldToScanTest, reduceToScanTest };
+export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, foldToScanTest, reduceToScanTest };

package/fs/types/number/module.f.js

@@ -5,11 +5,11 @@
  * @module
  */
 import { reduce } from "../list/module.f.js";
-import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
-import { cmp as uCmp } from "../function/compare/module.f.js";
+import { addition } from "../function/operator/module.f.js";
+import { cmp as uCmp, min as uMin, max as uMax } from "../function/compare/module.f.js";
 export const sum = reduce(addition)(0);
-export const min = reduce(minOp)(null);
-export const max = reduce(maxOp)(null);
+export const min = reduce((uMin))(null);
+export const max = reduce((uMax))(null);
 export const cmp = uCmp;
 const mo = [
     [0x5555_5555, 1],

package/fs/website/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type WriteFile } from '../types/effects/node/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
+import { type WriteFile } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
 declare const _default: () => Effect<WriteFile, number>;
 export default _default;

package/fs/website/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { htmlUtf8 } from "../html/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { writeFile } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
 const html = htmlUtf8()(['a',
     { href: 'https://github.com/functionalscript/functionalscript' },
     'GitHub Repository'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "type": "module",
   "files": [
     "**/*.js",

package/fs/emergent_testing/module.d.ts

@@ -1 +0,0 @@
-export declare const run: () => Promise<number>;

package/fs/emergent_testing/module.js

@@ -1,4 +0,0 @@
-import { io } from "../io/module.js";
-import { register } from "./module.f.js";
-import { runProgram } from "../io/module.f.js";
-export const run = () => runProgram(io)([])(register);

package/fs/io/module.d.ts

@@ -1,9 +0,0 @@
-import { type Io } from './module.f.ts';
-import type { Module, NodeProgram } from '../types/effects/node/module.f.ts';
-import { type Result } from '../types/result/module.f.ts';
-export declare const asyncImport: (v: string) => Promise<Module>;
-export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
-export declare const io: Io;
-export type NodeRun = (p: NodeProgram) => Promise<never>;
-declare const effectRun: NodeRun;
-export default effectRun;

package/fs/io/module.f.d.ts

@@ -1,134 +0,0 @@
-import { type Effect } from '../types/effects/module.f.ts';
-import { type Headers, type Module, type NodeOp, type Env, type SandboxResult, type NodeProgram, type WriteConsoles, type TestContext, type Engine } from '../types/effects/node/module.f.ts';
-import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type Result } from '../types/result/module.f.ts';
-/**
- * Represents a directory entry (file or directory) in the filesystem
- * @see https://nodejs.org/api/fs.html#class-fsdirent
- */
-export type Dirent = {
-    readonly name: string;
-    readonly parentPath: string;
-    readonly isDirectory: () => boolean;
-    readonly isFile: () => boolean;
-};
-export type RmOptions = {
-    readonly force?: boolean;
-    readonly recursive?: boolean;
-};
-export type MakeDirectoryOptions = {
-    readonly recursive?: boolean;
-};
-export type ReadDir = ((path: string, options: {
-    withFileTypes: true;
-}) => Promise<Dirent[]>) & ((path: string, options: {
-    recursive?: true;
-}) => Promise<readonly string[]>);
-/**
- * File system operations interface
- * @see https://nodejs.org/api/fs.html
- */
-export type Fs = {
-    readonly writeSync: (fd: number, s: string) => void;
-    readonly writeFileSync: (file: string, data: Uint8Array) => void;
-    readonly readFileSync: (path: string) => Uint8Array | null;
-    readonly promises: {
-        readonly readFile: (path: string) => Promise<Uint8Array>;
-        readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
-        readonly readdir: ReadDir;
-        readonly rm: (path: string, options?: RmOptions) => Promise<void>;
-        readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
-        readonly copyFile: (src: string, dest: string) => Promise<void>;
-        readonly access: (path: string) => Promise<void>;
-    };
-};
-/**
- * Console operations interface
- * @see https://nodejs.org/api/console.html
- */
-export type Console = {
-    readonly log: (...d: unknown[]) => void;
-    readonly error: (...d: unknown[]) => void;
-};
-/**
- * High-resolution time measurement interface
- * @see https://nodejs.org/api/perf_hooks.html#performance-now
- */
-export type Performance = {
-    readonly now: () => number;
-};
-export type Writable = {
-    readonly fd: number;
-    readonly isTTY: boolean;
-};
-/**
- * Node.js Process interface
- * @see https://nodejs.org/api/process.html
- */
-export type Process = {
-    readonly argv: string[];
-    readonly env: Env;
-    readonly exit: (code: number) => never;
-    readonly cwd: () => string;
-    readonly stdout: Writable;
-    readonly stderr: Writable;
-};
-export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
-export type Sandbox = <T>(f: () => T) => Promise<SandboxResult<T>>;
-export type Server = {
-    readonly listen: (port: number) => void;
-};
-export type Readable = AsyncIterable<Uint8Array>;
-export type IncomingMessage = Readable & {
-    readonly method: string;
-    readonly url: string;
-    readonly headers: Headers;
-};
-export type ServerResponse = {
-    readonly writeHead: (status: number, headers: Record<string, string>) => ServerResponse;
-    readonly end: (body: Uint8Array) => void;
-};
-export type RequestListener = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export type Http = {
-    readonly createServer: (_: RequestListener) => Server;
-};
-export type ChildProcess = {
-    readonly exec: (command: string, callback: (error: unknown, stdout: string, stderr: string) => void) => {
-        readonly stdin: null | {
-            readonly end: (data?: string) => void;
-        };
-    };
-};
-/**
- * Core IO operations interface providing access to system resources
- */
-export type Io = {
-    readonly console: Console;
-    readonly fs: Fs;
-    readonly process: Process;
-    readonly asyncImport: (s: string) => Promise<Module>;
-    readonly performance: Performance;
-    readonly fetch: (url: string) => Promise<Response>;
-    readonly tryCatch: TryCatch;
-    readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
-    readonly http: Http;
-    readonly childProcess: ChildProcess;
-    readonly now: () => number;
-    readonly sandbox: Sandbox;
-    readonly write: (stream: WriteConsoles, data: Vec) => Promise<void>;
-    readonly testContext: TestContext;
-    readonly bunTestContext: TestContext;
-    readonly playwrightTestContext: TestContext;
-    readonly engine: Engine;
-    readonly await: (p: unknown) => Promise<readonly [unknown]>;
-};
-export type App = (io: Io) => Promise<number>;
-export type Run = (f: App) => Promise<never>;
-/**
- * Runs a function and exits the process with the returned code
- * Handles errors by exiting with code 1
- */
-export declare const run: (io: Io) => Run;
-export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }: Io) => EffectToPromise;
-export declare const runProgram: (io: Io) => (args: readonly string[]) => (program: NodeProgram) => Promise<number>;

package/fs/io/module.f.js

@@ -1,113 +0,0 @@
-/**
- * Legacy `Io` interface and adapter (`fromIo`) bridging the old IO API to the
- * effect runner.
- *
- * @deprecated Use `fs/types/effects/node` (see issue
- * [i139](../../issues/README.md)).
- *
- * @module
- */
-import { normalize } from "../path/module.f.js";
-import {} from "../types/effects/module.f.js";
-import { asyncRun } from "../types/effects/module.js";
-import {} from "../types/effects/node/module.f.js";
-import { asBase, asNominal } from "../types/nominal/module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { fromVec, listToVec, toVec } from "../types/uint8array/module.f.js";
-/**
- * Runs a function and exits the process with the returned code
- * Handles errors by exiting with code 1
- */
-export const run = (io) => {
-    const exitCode = ([x, b]) => {
-        if (x === 'error') {
-            io.console.error(b);
-            return 1;
-        }
-        else {
-            return b;
-        }
-    };
-    return async (f) => io.process.exit(exitCode(await io.asyncTryCatch(() => f(io))));
-};
-const tc = async (f) => {
-    try {
-        return ok(await f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-const collect = async (v) => {
-    let result = [];
-    for await (const a of v) {
-        result = [...result, a];
-    }
-    return result;
-};
-export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
-    const result = asyncRun({
-        all: async (...effects) => await Promise.all(effects.map(result)),
-        fetch: async (url) => tc(async () => {
-            const response = await fetch(url);
-            if (!response.ok) {
-                throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
-            }
-            return toVec(new Uint8Array(await response.arrayBuffer()));
-        }),
-        mkdir: (...p) => tc(async () => { await mkdir(...p); }),
-        readFile: path => tc(async () => toVec(await readFile(path))),
-        readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
-            .map(v => ({
-            name: v.name,
-            parentPath: normalize(v.parentPath),
-            isFile: v.isFile()
-        }))),
-        writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
-        rm: path => tc(() => rm(path)),
-        access: path => tc(() => access(path)),
-        import: path => tc(() => asyncImport(path)),
-        exec: (command, stdin) => new Promise(resolve => {
-            const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
-            child.stdin?.end(stdin);
-        }),
-        createServer: async (requestListener) => {
-            const erl = requestListener;
-            const nodeRl = async (req, res) => {
-                const reqBody = await collect(req);
-                const { method, url, headers } = req;
-                const { status, headers: outHeaders, body: outBody } = await result(erl({
-                    method,
-                    url,
-                    headers,
-                    body: listToVec(reqBody)
-                }));
-                res
-                    .writeHead(status, outHeaders)
-                    .end(fromVec(outBody));
-            };
-            const server = asNominal(createServer(nodeRl));
-            return server;
-        },
-        listen: async (server, port) => {
-            const s = asBase(server);
-            s.listen(port);
-        },
-        forever: () => new Promise(() => { }),
-        now: async () => ioNow(),
-        sandbox,
-        await: awaitPromise,
-        write,
-        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
-    });
-    return result;
-};
-export const runProgram = (io) => {
-    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
-    const std = { stdout, stderr };
-    const f = fromIo(io);
-    return args => {
-        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
-        return program => f(program(options));
-    };
-};