functionalscript 0.17.0 → 0.19.0

package/fs/io/module.js

@@ -10,12 +10,72 @@ import http from 'node:http';
 import childProcess from 'node:child_process';
 import fs from 'node:fs';
 import process from 'node:process';
-import { fromIo, run } from "./module.f.js";
 import { concat } from "../path/module.f.js";
+import { once } from 'node:events';
+import { fromIo, runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
+import { fromVec } from "../types/uint8array/module.f.js";
+import * as testContext from 'node:test';
+const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
+const pwTest = isPlaywright
+    ? (await import('@playwright/test')).test
+    : undefined;
+const inlineTest = async (name, { expectFailure }, fn) => {
+    if (expectFailure) {
+        try {
+            await fn(inlineContext);
+        }
+        catch {
+            return;
+        }
+        throw new Error(`expected to throw: ${name}`);
+    }
+    else {
+        await fn(inlineContext);
+    }
+};
+const inlineContext = { test: inlineTest };
+const bunTestContext = {
+    test: (name, opts, fn) => testContext.test(name, () => inlineTest(name, opts, fn))
+};
+const playwrightTestContext = {
+    test: (name, opts, fn) => pwTest(name, () => inlineTest(name, opts, fn))
+};
 const prefix = 'file:///';
 const { now } = Date;
+/** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
+const streams = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+};
+/**
+ * Writes `data` to `stream` respecting Node.js backpressure.
+ *
+ * `stream.write()` returns `false` when the internal buffer is full; the data
+ * is already buffered at that point (no retry needed) but the caller must not
+ * issue more writes until the `'drain'` event fires. Waiting here throttles the
+ * producer to the speed of the OS consumer, preventing unbounded memory growth
+ * when many large messages arrive faster than they can be flushed.
+ *
+ * When the buffer is not full `write()` returns `true` and we return
+ * immediately, so large computations with occasional prints never stall.
+ *
+ * @see {@link https://nodejs.org/api/stream.html#writablewritechunk}
+ */
+const writeAll = async (stream, data) => {
+    if (!stream.write(data)) {
+        await once(stream, 'drain');
+    }
+};
 export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
+export const tryCatch = f => {
+    try {
+        return ok(f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
 export const io = {
     console,
     fs,
@@ -27,14 +87,7 @@ export const io = {
     },
     performance,
     fetch,
-    tryCatch: f => {
-        try {
-            return ok(f());
-        }
-        catch (e) {
-            return error(e);
-        }
-    },
+    tryCatch,
     asyncTryCatch: async (f) => {
         try {
             return ok(await f());
@@ -61,13 +114,11 @@ export const io = {
         }
         return { result, duration: after - before };
     },
+    write: (stream, data) => writeAll(streams[stream], fromVec(data)),
+    testContext,
+    bunTestContext,
+    playwrightTestContext,
+    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
 };
-export const legacyRun = run(io);
-export const ioRun = (io) => {
-    const r = fromIo(io);
-    const { argv, env } = io.process;
-    const options = { args: argv.slice(2), env };
-    return p => r(p(options));
-};
-const effectRun = ioRun(io);
+const effectRun = runProgram(io)(io.process.argv.slice(2));
 export default effectRun;

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

@@ -20,3 +20,9 @@ export declare const normalize: Unary<string, string>;
  * Concatenates two path fragments and returns a normalized path.
  */
 export declare const concat: Reduce<string>;
+/**
+ * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
+ * if it does not start with `base` or `base` is empty.
+ * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
+ */
+export declare const relativize: (base: string, path: string) => string;

package/fs/path/module.f.js

@@ -46,3 +46,9 @@ export const concat = a => b => {
     const s = stringConcat([a, '/', b]);
     return normalize(s);
 };
+/**
+ * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
+ * if it does not start with `base` or `base` is empty.
+ * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
+ */
+export const relativize = (base, path) => base !== '' && path.startsWith(base) ? `.${path.slice(base.length)}` : path;

package/fs/path/test.f.d.ts

@@ -1,5 +1,3 @@
-declare const _default: {
-    normalize: (() => void)[];
-    concat: (() => void)[];
-};
-export default _default;
+export declare const normalizeTest: (() => void)[];
+export declare const concatTest: (() => void)[];
+export declare const relativizeTest: (() => void)[];

package/fs/path/test.f.js

@@ -1,49 +1,67 @@
-import { concat, normalize } from "./module.f.js";
-export default {
-    normalize: [
-        () => {
-            const norm = normalize("dir/file.json");
-            if (norm !== "dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("dir//file.json");
-            if (norm !== "dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("../../dir/file.json");
-            if (norm !== "../../dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("../../dir/../file.json");
-            if (norm !== "../../file.json") {
-                throw norm;
-            }
-        },
-    ],
-    concat: [
-        () => {
-            const c = concat("a")("b");
-            if (c !== "a/b") {
-                throw c;
-            }
-        },
-        () => {
-            const c = concat("a///b/")("c");
-            if (c !== "a/b/c") {
-                throw c;
-            }
-        },
-        () => {
-            const c = concat("a/../b/..")("c");
-            if (c !== "c") {
-                throw c;
-            }
-        },
-    ]
-};
+import { concat, normalize, relativize } from "./module.f.js";
+export const normalizeTest = [
+    () => {
+        const norm = normalize("dir/file.json");
+        if (norm !== "dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("dir//file.json");
+        if (norm !== "dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("../../dir/file.json");
+        if (norm !== "../../dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("../../dir/../file.json");
+        if (norm !== "../../file.json") {
+            throw norm;
+        }
+    },
+];
+export const concatTest = [
+    () => {
+        const c = concat("a")("b");
+        if (c !== "a/b") {
+            throw c;
+        }
+    },
+    () => {
+        const c = concat("a///b/")("c");
+        if (c !== "a/b/c") {
+            throw c;
+        }
+    },
+    () => {
+        const c = concat("a/../b/..")("c");
+        if (c !== "c") {
+            throw c;
+        }
+    },
+];
+export const relativizeTest = [
+    () => {
+        const r = relativize('/repo', '/repo/fs/a.ts');
+        if (r !== './fs/a.ts') {
+            throw r;
+        }
+    },
+    () => {
+        const r = relativize('/repo', '/other/a.ts');
+        if (r !== '/other/a.ts') {
+            throw r;
+        }
+    },
+    () => {
+        const r = relativize('', './fs/a.ts');
+        if (r !== './fs/a.ts') {
+            throw r;
+        }
+    },
+];

package/fs/sul/id/module.f.js

@@ -6,7 +6,7 @@
  * @module
  */
 import { toArray } from "../../types/list/module.f.js";
-import { length, listToVec, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
+import { length, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
 import { assertEq } from "../../dev/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 import { secp256r1 } from "../../crypto/secp/module.f.js";
@@ -77,9 +77,8 @@ export const isHash = (v) => asBase(v) >> hashPrefixOffset === 1n;
 export const hashId = (hash) => asNominal(hashPrefix | hash);
 const hash2 = base32.compress(iv);
 const vecX20 = vec(0x20n);
-const ltv = listToVec(msb);
-const hashMerge = (a, b) => hashId(uint(ltv(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
-const { concat } = msb;
+const { concat, listToVec } = msb;
+const hashMerge = (a, b) => hashId(uint(listToVec(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
 export const compress = (a, b) => {
     if (isHash(a) || isHash(b)) {
         return hashMerge(a, b);

package/fs/sul/level/literal/module.f.js

@@ -5,7 +5,7 @@
  * @module
  */
 import { log2 } from "../../../types/bigint/module.f.js";
-import { listToVec, msb, vec } from "../../../types/bit_vec/module.f.js";
+import { msb, vec } from "../../../types/bit_vec/module.f.js";
 import { strictEqual } from "../../../types/function/operator/module.f.js";
 import { equal, map } from "../../../types/list/module.f.js";
 import { join } from "../../../types/string/module.f.js";
@@ -73,12 +73,12 @@ export const pipelineStep = (bit, [l1s, l2s, l3s]) => {
     const [l3Out, newL3s] = l3.encode(l2Out, l3s);
     return [l3Out, [newL1s, newL2s, newL3s]];
 };
-const concat = listToVec(msb);
 const vec1 = vec(1n);
+const { listToVec } = msb;
 const literalToVec = (prior, e) => {
     const m = map(prior);
     const { decode } = level(e);
-    return literal => concat(m(decode(literal)));
+    return literal => listToVec(m(decode(literal)));
 };
 /** Decodes a level-1 symbol to its canonical MSB bit vector. */
 export const literal1ToVec = literalToVec(vec1, 0n);

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

@@ -5,6 +5,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';
 export declare const backspace: string;
 type End = 'm';
 type Csi = (code: number | string) => string;
@@ -44,7 +46,7 @@ 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.
+ * 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.
@@ -57,4 +59,10 @@ export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => Cs
 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.
+ * Does NOT append `\n` — callers are responsible for line termination.
+ */
+export declare const csiWrite: ({ std }: NodeProgramOptions) => (stream: WriteConsoles) => (s: string) => Effect<Write, void>;
 export {};

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

@@ -4,6 +4,9 @@
  *
  * @module
  */
+import { write } from "../../types/effects/node/module.f.js";
+import {} from "../../types/effects/module.f.js";
+import { utf8 } from "../module.f.js";
 export const backspace = '\x08';
 const begin = '\x1b[';
 /**
@@ -46,8 +49,9 @@ 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.
+ * 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.
@@ -56,12 +60,19 @@ export const createConsoleText = (stdout) => {
  * @returns A function that targets a writable stream.
  */
 export const console = ({ fs: { writeSync } }) => (w) => {
-    const { isTTY } = w;
-    return isTTY
-        ? (s) => writeSync(w.fd, s + '\n')
-        : (s) => writeSync(w.fd, s.replace(/\x1b\[[0-9;]*m/g, '') + '\n');
+    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.
+ * Does NOT append `\n` — callers are responsible for line termination.
+ */
+export const csiWrite = ({ std }) => (stream) => {
+    const toStr = str(std[stream].isTTY);
+    return (s) => write(stream, utf8(toStr(s)));
+};

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

@@ -1,8 +1,23 @@
-import { fgRed } from "./module.f.js";
+import { fgRed, createConsoleText, backspace } from "./module.f.js";
 export default [
     () => {
         if (fgRed !== '\x1b[31m') {
             throw new Error('Test failed: sgr(0)');
         }
+    },
+    () => {
+        const output = [];
+        const stdout = { write: (s) => { output.push(s); } };
+        const writer1 = createConsoleText(stdout);
+        const writer2 = writer1('hello');
+        if (output[0] !== 'hello') {
+            throw output[0];
+        }
+        // replacing 'hello' (len=5) with 'hi' (len=2): suffixLength=3
+        writer2('hi');
+        const expected = backspace.repeat(5) + 'hi' + ' '.repeat(3) + backspace.repeat(3);
+        if (output[1] !== expected) {
+            throw output[1];
+        }
     }
 ];

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

@@ -146,6 +146,15 @@ export type BitOrder = {
      * ```
      */
     readonly concat: Reduce;
+    /**
+     * Folds a list of vectors into a single vector in this bit order.
+     *
+     * Unlike `concat`, which joins exactly two vectors, this joins a whole list.
+     *
+     * @returns The concatenation of every vector in the list, or `empty` when the
+     * list is empty.
+     */
+    readonly listToVec: (list: List<Vec>) => Vec;
     /**
      * Computes the bitwise exclusive OR of two vectors after normalizing their lengths.
      *
@@ -219,10 +228,6 @@ export declare const chunkList: (bo: BitOrder) => (n: bigint) => (v: Vec) => Thu
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export declare const u8List: (bo: BitOrder) => (v: Vec) => Thunk<number>;
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => Vec;
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

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

@@ -127,14 +127,16 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
             return [uint, pack(u)];
         };
     };
+    const concat = a => b => {
+        const au = unpack(a);
+        const bu = unpack(b);
+        return pack(unpackConcat(au)(bu));
+    };
     return {
         front,
         removeFront,
-        concat: a => b => {
-            const au = unpack(a);
-            const bu = unpack(b);
-            return pack(unpackConcat(au)(bu));
-        },
+        concat,
+        listToVec: fold(flip(concat))(empty),
         xor: op(norm)(xor),
         unpackPopFront,
         popFront,
@@ -301,10 +303,6 @@ const vecToU8 = ({ unpackSplit }) => {
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export const u8List = (bo) => (v) => map(vecToU8(bo))(chunkList(bo)(8n)(v));
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export const listToVec = ({ concat }) => fold(flip(concat))(empty);
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

package/fs/types/btree/remove/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
 export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;

package/fs/types/btree/remove/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold, concat, next } from "../../list/module.f.js";
 import { map } from "../../nullable/module.f.js";
@@ -163,7 +169,6 @@ export const nodeRemove = (c) => (node) => {
         return first;
     }
     const { first: tf, tail: tt } = tailR;
-    const result = reduce(initReduce(tf)(first))(tt);
-    return result.length === 1 ? result[0] : result;
+    return collapseRoot(reduce(initReduce(tf)(first))(tt));
 };
 export const remove = c => map(nodeRemove(c));

package/fs/types/btree/set/module.f.d.ts

@@ -3,6 +3,6 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

package/fs/types/btree/set/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold } from "../../list/module.f.js";
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]];
@@ -114,7 +120,6 @@ const nodeSet = (c) => (g) => (node) => {
             }
         }
     };
-    const r = reduceBranch(f())(tail);
-    return r.length === 1 ? r[0] : r;
+    return collapseRoot(reduceBranch(f())(tail));
 };
 export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree);

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

@@ -12,3 +12,4 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
+export declare const collapseRoot: <T>(b: Branch1<T> | Branch3<T> | Branch5<T>) => TNode<T>;

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

@@ -1 +1 @@
-export {};
+export const collapseRoot = b => b.length === 1 ? b[0] : b;

package/fs/types/effects/node/module.f.d.ts

@@ -1,12 +1,3 @@
-/**
- * Node.js effect operations: filesystem (`mkdir`, `readFile`, `readdir`,
- * `writeFile`, `rm`, `access`), networking (`fetch`, `createServer`, `listen`),
- * subprocess `exec`, console (`log`, `error`), `import_`, `now`, `sandbox`, `forever`,
- * and `all`/`both` parallelism; defines the `NodeOp`/`NodeProgram` types used
- * by the Node runner.
- *
- * @module
- */
 import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
@@ -58,11 +49,6 @@ export declare const exec: Func<Exec>;
 export type Access = readonly ['access', (path: string) => IoResult<void>];
 export declare const access: Func<Access>;
 export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec | Access;
-export type Error = ['error', (message: string) => void];
-export declare const error: Func<Error>;
-export type Log = ['log', (message: string) => void];
-export declare const log: Func<Log>;
-export type Console = Log | Error;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
 export type Headers = {
     readonly [k in string]: string;
@@ -87,10 +73,18 @@ export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
 export type Module = {
-    readonly default: unknown;
+    readonly [k in string]: unknown;
 };
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
+export type WriteConsoles = 'stdout' | 'stderr';
+export type Write = readonly ['write', (stream: WriteConsoles, data: Vec) => void];
+export declare const write: Func<Write>;
+export type Console = (s: string) => Effect<Write, void>;
+/** Writes a line to `stdout`. Replaces the retired `Log` effect. */
+export declare const log: Console;
+/** Writes a line to `stderr`. Replaces the retired `Error` effect. */
+export declare const error: Console;
 export type Now = readonly ['now', () => number];
 export declare const now: Func<Now>;
 export type SandboxResult<T> = {
@@ -122,7 +116,15 @@ export type Sandbox = readonly ['sandbox', <T>(f: () => T) => SandboxResult<T>];
  * @see {@link SandboxResult}
  */
 export declare const sandbox: Func<Sandbox>;
-export type NodeOp = All | Fetch | Console | Fs | Http | Forever | Import | Now | Sandbox;
+export type TestFn = (name: string, options: {
+    readonly expectFailure: boolean;
+}, fn: (t: TestContext) => Promise<void>) => Promise<void>;
+export type TestContext = {
+    readonly test: TestFn;
+};
+export type Test = readonly ['test', (ctx: TestContext, name: string, expectFailure: boolean, test: (t: TestContext) => Effect<Test | All, void>) => void];
+export declare const test: Func<Test>;
+export type NodeOp = All | Fetch | Fs | Http | Forever | Import | Now | Sandbox | Write | Test;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
@@ -131,8 +133,19 @@ export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 export type Env = {
     readonly [k: string]: string | undefined;
 };
+export type Engine = 'node' | 'bun' | 'playwright';
 export type NodeProgramOptions = {
     readonly args: readonly string[];
     readonly env: Env;
+    readonly std: {
+        readonly [k in WriteConsoles]: {
+            readonly isTTY: boolean;
+        };
+    };
+    readonly testContext: TestContext;
+    readonly bunTestContext: TestContext;
+    readonly playwrightTestContext: TestContext;
+    readonly engine: Engine;
 };
-export type NodeProgram = (options: NodeProgramOptions) => Effect<NodeOp, number>;
+export type Program<O extends Operation> = (options: NodeProgramOptions) => Effect<O, number>;
+export type NodeProgram = Program<NodeOp>;

package/fs/types/effects/node/module.f.js

@@ -1,3 +1,13 @@
+/**
+ * Node.js effect operations: filesystem (`mkdir`, `readFile`, `readdir`,
+ * `writeFile`, `rm`, `access`), networking (`fetch`, `createServer`, `listen`),
+ * subprocess `exec`, `log`/`error` (wrappers over `write`), `import_`, `now`,
+ * `sandbox`, `forever`, and `all`/`both` parallelism; defines the
+ * `NodeOp`/`NodeProgram` types used by the Node runner.
+ *
+ * @module
+ */
+import { utf8 } from "../../../text/module.f.js";
 import { do_ } from "../module.f.js";
 const doAll = do_('all');
 /**
@@ -17,12 +27,20 @@ export const writeFile = do_('writeFile');
 export const rm = do_('rm');
 export const exec = do_('exec');
 export const access = do_('access');
-export const error = do_('error');
-export const log = do_('log');
 export const createServer = do_('createServer');
 export const listen = do_('listen');
 export const forever = do_('forever');
 export const import_ = do_('import');
+export const write = do_('write');
+/**
+ * Encodes `s + '\n'` as UTF-8 and emits a `Write` effect to `stream`.
+ * Shared implementation for `log` and `error`.
+ */
+const writeString = (stream) => (s) => write(stream, utf8(s + '\n'));
+/** Writes a line to `stdout`. Replaces the retired `Log` effect. */
+export const log = writeString('stdout');
+/** Writes a line to `stderr`. Replaces the retired `Error` effect. */
+export const error = writeString('stderr');
 export const now = do_('now');
 /**
  * Runs a plain synchronous function in an isolated, measured environment.
@@ -43,3 +61,4 @@ export const now = do_('now');
  * @see {@link SandboxResult}
  */
 export const sandbox = do_('sandbox');
+export const test = do_('test');