functionalscript 0.17.0 → 0.18.0

package/fs/ci/common/module.f.d.ts

@@ -12,12 +12,12 @@ export type Os = typeof os[number];
 export declare const architecture: readonly ["intel", "arm"];
 export type Architecture = typeof architecture[number];
 export type Image = typeof images[Os][Architecture];
-declare const stepSchema: {
+export declare const stepSchema: {
     readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
     readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
     readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
 };
-declare const jobSchema: {
+export declare const jobSchema: {
     readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
     readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
         readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
@@ -25,7 +25,7 @@ declare const jobSchema: {
         readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
     }>;
 };
-declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record", {
+export declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record", {
     readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
     readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
         readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
@@ -33,7 +33,7 @@ declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record",
         readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
     }>;
 }>;
-declare const gitHubActionSchema: {
+export declare const gitHubActionSchema: {
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
@@ -82,4 +82,3 @@ export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
 export declare const findTgz: (v: Os) => "(Get-ChildItem *.tgz).FullName" | "./*.tgz";
-export {};

package/fs/ci/common/module.f.js

@@ -11,17 +11,17 @@ import {} from "../../types/rtti/ts/module.f.js";
 import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
 export const os = ['ubuntu', 'macos', 'windows'];
 export const architecture = ['intel', 'arm'];
-const stepSchema = {
+export const stepSchema = {
     run: option(string),
     uses: option(string),
     with: option(record(string))
 };
-const jobSchema = {
+export const jobSchema = {
     'runs-on': string,
     steps: array(stepSchema)
 };
-const jobsSchema = record(jobSchema);
-const gitHubActionSchema = {
+export const jobsSchema = record(jobSchema);
+export const gitHubActionSchema = {
     name: string,
     on: { pull_request: option({}) },
     jobs: jobsSchema

package/fs/ci/config/module.f.d.ts

@@ -20,13 +20,13 @@ export declare const images: {
     };
 };
 export declare const bun = "1.3.14";
-export declare const deno = "2.7.14";
+export declare const deno = "2.8.0";
 export declare const playwright = "1.60.0";
 export declare const rust = "1.95.0";
 export declare const node: {
-    readonly default: "26.1.0";
-    readonly others: readonly ["22.22.3", "24.15.0"];
+    readonly default: "26.2.0";
+    readonly others: readonly ["22.22.3", "24.16.0"];
 };
 export declare const wasmtime = "44.0.1";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260517.1";
+export declare const tsgo = "7.0.0-dev.20260526.1";

package/fs/ci/config/module.f.js

@@ -23,19 +23,19 @@ export const images = {
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.7.14';
+export const deno = '2.8.0';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
 // https://rust-lang.org/
 export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.1.0',
-    others: ['22.22.3', '24.15.0'],
+    default: '26.2.0',
+    others: ['22.22.3', '24.16.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '44.0.1';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260517.1';
+export const tsgo = '7.0.0-dev.20260526.1';

package/fs/ci/test.f.js

@@ -4,10 +4,8 @@ import { isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../dev/module.f.js";
 import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
-import {} from "../types/rtti/ts/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-// type Gha = Ts<typeof gitHubActionSchema>
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
 const githubState = {
@@ -18,9 +16,9 @@ const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(githubState)(ci({ rust, nodeExtra, denoExtra: [], bunExtra: [] }));
     assert(result === 0, result);
     const dotGithub = state.root['.github'];
-    assert(dotGithub !== undefined && !isVec(dotGithub), dotGithub);
+    assert(typeof dotGithub === 'object', dotGithub);
     const workflows = dotGithub['workflows'];
-    assert(workflows !== undefined && !isVec(workflows), workflows);
+    assert(typeof workflows === 'object', workflows);
     const file = workflows['ci.yml'];
     assert(isVec(file), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type Io } from '../io/module.f.ts';
+import type { Io } from '../io/module.f.ts';
 import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
 export declare const todo: () => never;
@@ -18,6 +18,6 @@ export type ModuleMap = {
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
 export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
-export declare const loadModuleMap2: (env: Env) => Effect<Access | Import | All | Readdir, ModuleMap>;
-export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
+export type LoadModuleOperations = Access | Import | All | Readdir;
+export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -1,9 +1,3 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
 import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
@@ -12,6 +6,7 @@ import { begin, pure } from "../types/effects/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
+import { relativize } from "../path/module.f.js";
 export const todo = () => { throw 'not implemented'; };
 export const assert = (v, msg = 'assertion failed') => {
     if (!v)
@@ -63,14 +58,22 @@ const loadFile = (f) => {
     }
     return pure([]);
 };
-export const loadModuleMap2 = (env) => {
+const { fromEntries } = Object;
+export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
+    const prefix = s === '.' ? '' : s;
+    // TODO: there are multiple `all` effects here,
+    //       we should consider optimize them by ALIQ technique or something similar.
+    //       For example, we should be able to write it like `allFiles(s).flatMap(loadFile)`,
+    //       then an effect runner can batch all file loading operations together.
     return allFiles(s)
         .step(files => all(...files.map(loadFile)))
-        .step(entries => pure(Object.fromEntries(entries.flat().toSorted(cmp))));
+        .step(entries => pure(fromEntries(entries
+        .flat()
+        .map(([k, v]) => [relativize(prefix, k), v])
+        .toSorted(cmp))));
 };
-export const loadModuleMap = async (io) => fromIo(io)(loadModuleMap2(io.process.env));
 const denoJson = './deno.json';
 const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = begin

package/fs/dev/tf/module.d.ts

@@ -1 +1,2 @@
+export declare const run3: () => Promise<void>;
 export declare const run: () => Promise<void>;

package/fs/dev/tf/module.f.d.ts

@@ -1,8 +1,72 @@
-import type { Io } from '../../io/module.f.ts';
-import type { SandboxResult } from '../../types/effects/node/module.f.ts';
+import { type All, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Write } from '../../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../../types/effects/module.f.ts';
+import { type LoadModuleOperations, type ModuleMap } from '../module.f.ts';
 export declare const isTest: (s: string) => boolean;
 export type Test = () => unknown;
-export type TestSet = Test | readonly (readonly [string, unknown])[];
-export declare const parseTestSet: (sandbox: <R>(f: () => R) => SandboxResult<R>) => (throws: boolean) => (x: unknown) => TestSet;
-export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
-export declare const main: (io: Io) => Promise<number>;
+export type TestEntry = {
+    readonly fn: Test;
+    readonly throws: boolean;
+};
+export type TestSet = TestEntry | readonly (readonly [string, unknown])[];
+export declare const parseTestSet: (throws: boolean, x: unknown) => TestSet;
+/**
+ * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
+ * pairs, without running anything. Return-value sub-trees are not walked
+ * (that requires execution); only the static object/array/function structure
+ * is traversed.
+ */
+export declare const collectTests: (path: Path, throws: boolean, v: unknown) => readonly (readonly [Path, TestEntry])[];
+/**
+ * Receives semantic test-run events. Each method is the runner's notification
+ * of an event; the reporter decides how to render it (terminal, GitHub
+ * annotations, JSON, node `--test`, etc.). `path` is the chain of object keys
+ * leading to the current location; `null` marks a function-call boundary, e.g.
+ * `['outer', null, 'inner']` means `outer` was invoked and its return value
+ * contained `inner`.
+ */
+export type Reporter<O extends Operation> = {
+    readonly result: (file: string, path: Path, r: SandboxResult<unknown>) => Effect<O, void>;
+    readonly summary: (pass: number, fail: number, time: number) => Effect<O, void>;
+    readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>>;
+};
+export declare const runModuleMap: <O extends Operation>(reporter: Reporter<O>) => (moduleMap: ModuleMap) => Effect<O | All, number>;
+export declare const test: <O extends Operation>(reporter: Reporter<O>) => Program<O | All | LoadModuleOperations>;
+export type Path = readonly (string | null)[];
+export declare const isInteger: (s: string) => boolean;
+export declare const isIdentifier: (s: string) => boolean;
+/**
+ * Renders a key chain as a JS property-access expression: identifier keys use
+ * dot notation, integer keys use `[N]`, other strings use `["key"]`, and `null`
+ * emits `()` to mark a function-call boundary.
+ * E.g. `['math', 'add']` → `.math.add`, `['outer', null, 'inner']` → `.outer().inner`.
+ */
+export declare const fmtPath: (path: Path) => string;
+/**
+ * Formats a fully-qualified test identifier as a JS-like expression, e.g.
+ * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * Self-contained per line — suitable for parallel output and as a CLI filter argument.
+ */
+export declare const fmtImport: (file: string, path: Path) => string;
+/**
+ * Renders a key chain for terminal output: `| ` per level of depth, followed
+ * by the last segment formatted as a bare integer, a bare identifier, or a
+ * JSON-quoted string. E.g. `['math', 'add']` → `| | add`,
+ * `['a', '0']` → `| | 0`, `['x', 'hello world']` → `| | "hello world"`.
+ */
+export declare const fmtTerm: (path: Path) => string;
+/**
+ * Percent-encodes characters that GitHub workflow-command property values
+ * treat as separators (`%`, `:`, `,`) plus newlines.
+ * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+ */
+export declare const ghEscape: (s: string) => string;
+export declare const defaultTest: (file: string, path: Path, { fn, throws }: TestEntry) => Effect<Sandbox, SandboxResult<unknown>>;
+/**
+ * The terminal/GitHub reporter used by `fjs t`. Output goes through
+ * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
+ * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * annotations instead of colored lines. Exported as a factory so the
+ * GitHub format path can be exercised directly from tests.
+ */
+export declare const defaultReporter: (options: NodeProgramOptions) => Reporter<Write | Sandbox>;
+export declare const main: NodeProgram;

package/fs/dev/tf/module.f.js

@@ -3,9 +3,11 @@
  *
  * @module
  */
-import { fold } from "../../types/list/module.f.js";
-import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
-import { env, loadModuleMap } from "../module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
+import { all, sandbox } from "../../types/effects/node/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { loadModuleMap } from "../module.f.js";
+import { invert } from "../../types/result/module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
@@ -18,24 +20,12 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (sandbox) => (throws) => (x) => {
+export const parseTestSet = (throws, x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
-                const xt = x;
-                if (!throws && xt.name !== 'throw') {
-                    return xt;
-                }
-                // Pass-on-throw: the test passes if it throws. Triggered when the
-                // enclosing tree node is named 'throw' (so any function reference
-                // works, not only inline ones whose inferred name is 'throw').
-                return () => {
-                    const { result: [tag, value] } = sandbox(xt);
-                    if (tag === 'ok') {
-                        throw value;
-                    }
-                    return value;
-                };
+                const fn = x;
+                return { fn, throws: throws || fn.name === 'throw' };
             }
             break;
         }
@@ -48,77 +38,135 @@ export const parseTestSet = (sandbox) => (throws) => (x) => {
     }
     return [];
 };
-const test = async (io) => {
-    const moduleMap = await loadModuleMap(io);
-    const log = stdio(io);
-    const error = stderr(io);
-    const { sandbox } = io;
-    const env_ = env(io);
-    const isGitHub = env_('GITHUB_ACTION') !== undefined;
-    const parse = parseTestSet(sandbox);
-    const f = ([k, v]) => {
-        const test = i => throws => v => ts => {
-            const next = test(`${i}| `);
-            const set = parse(throws)(v);
-            if (typeof set === 'function') {
-                const { result: [s, r], duration: delta } = sandbox(set);
-                if (s !== 'ok') {
-                    ts = addFail(delta)(ts);
-                    if (isGitHub) {
-                        // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                        error(`::error file=${k},line=1,title=${i}()::${r}`);
-                    }
-                    else {
-                        error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
-                        error(`${fgRed}${r}${reset}`);
+/**
+ * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
+ * pairs, without running anything. Return-value sub-trees are not walked
+ * (that requires execution); only the static object/array/function structure
+ * is traversed.
+ */
+export const collectTests = (path, throws, v) => {
+    const set = parseTestSet(throws, v);
+    if (set instanceof Array) {
+        return set.flatMap(([ck, cv]) => collectTests([...path, ck], throws || ck === 'throw', cv));
+    }
+    return [[path, set]];
+};
+const mergeState = (a, b) => ({ time: a.time + b.time, pass: a.pass + b.pass, fail: a.fail + b.fail });
+const zero = { time: 0, pass: 0, fail: 0 };
+const runModule = ({ result, test }) => (k, v) => (ts) => {
+    const walk = (path, throws, v) => {
+        const effects = collectTests(path, throws, v)
+            .map(([testPath, set]) => test(k, testPath, set)
+            .step(sr => {
+            const { result: [s, r], duration } = sr;
+            return result(k, testPath, sr)
+                .step(() => {
+                if (s === 'ok') {
+                    if (set.throws) {
+                        return pure(addPass(duration)(zero));
                     }
+                    // Walk return-value sub-tree; null marks the call boundary so
+                    // paths render as e.g. `outer().inner`. throws resets to false.
+                    return walk([...testPath, null], false, r)
+                        .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
                 }
-                else {
-                    ts = addPass(delta)(ts);
-                    log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                    // The result of a function is walked as a fresh sub-tree;
-                    // the parent's `throws` flag does not propagate into it.
-                    ts = next(false)(r)(ts);
-                }
-            }
-            else {
-                const f = ([k, v]) => ts => {
-                    log(`${i}${k}:`);
-                    ts = next(throws || k === 'throw')(v)(ts);
-                    return ts;
-                };
-                ts = fold(f)(ts)(set);
-            }
-            return ts;
-        };
-        return ts => {
-            if (isTest(k)) {
-                log(`testing ${k}`);
-                ts = test('| ')(false)(v.default)(ts);
-                // Non-default exports are walked as a sibling test group so
-                // a test file can spread its tests across multiple named
-                // exports (see issue 27 in `issues/README.md`). Skip exports
-                // that parseTestSet would treat as empty (constants, types,
-                // non-test helpers) to avoid noisy empty entries in output.
-                const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
-                    (typeof val === 'object' && val !== null))));
-                if (Object.keys(others).length !== 0) {
-                    ts = test('| ')(false)(others)(ts);
-                }
-            }
-            return ts;
-        };
+                return pure(addFail(duration)(zero));
+            });
+        }));
+        return all(...effects)
+            .step(states => pure(states.reduce(mergeState, zero)));
     };
-    let ts = { time: 0, pass: 0, fail: 0 };
-    ts = fold(f)(ts)(Object.entries(moduleMap));
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
-    log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
-    return ts.fail !== 0 ? 1 : 0;
+    return walk([], false, v)
+        .step(delta => pure(mergeState(ts, delta)));
+};
+const { entries } = Object;
+export const runModuleMap = (reporter) => (moduleMap) => {
+    const { summary } = reporter;
+    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+    return modules.reduce((acc, [k, v]) => acc.step(runModule(reporter)(k, v)), pure({ time: 0, pass: 0, fail: 0 }))
+        .step(ts => summary(ts.pass, ts.fail, ts.time)
+        .step(() => pure(ts.fail !== 0 ? 1 : 0)));
 };
-export const anyLog = (f) => (s) => (state) => {
-    f(s);
-    return state;
+export const test = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
+const isDigit = (c) => c >= '0' && c <= '9';
+export const isInteger = (s) => s.length > 0 && [...s].every(isDigit) && (s === '0' || s[0] !== '0');
+export const isIdentifier = (s) => s.length > 0 && isAlpha(s[0]) && [...s.slice(1)].every(c => isAlpha(c) || isDigit(c));
+const fmtKey = (k) => k === null ? '()'
+    : isInteger(k) ? `[${k}]`
+        : isIdentifier(k) ? `.${k}`
+            : `[${JSON.stringify(k)}]`;
+/**
+ * Renders a key chain as a JS property-access expression: identifier keys use
+ * dot notation, integer keys use `[N]`, other strings use `["key"]`, and `null`
+ * emits `()` to mark a function-call boundary.
+ * E.g. `['math', 'add']` → `.math.add`, `['outer', null, 'inner']` → `.outer().inner`.
+ */
+export const fmtPath = (path) => path.reduce((acc, k) => acc + fmtKey(k), '');
+/**
+ * Formats a fully-qualified test identifier as a JS-like expression, e.g.
+ * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * Self-contained per line — suitable for parallel output and as a CLI filter argument.
+ */
+export const fmtImport = (file, path) => `import(${JSON.stringify(file)})${fmtPath(path)}()`;
+/**
+ * Renders a key chain for terminal output: `| ` per level of depth, followed
+ * by the last segment formatted as a bare integer, a bare identifier, or a
+ * JSON-quoted string. E.g. `['math', 'add']` → `| | add`,
+ * `['a', '0']` → `| | 0`, `['x', 'hello world']` → `| | "hello world"`.
+ */
+export const fmtTerm = (path) => {
+    const keys = path.flatMap(k => k !== null ? [k] : []);
+    const indent = '| '.repeat(keys.length);
+    if (keys.length === 0) {
+        return `${indent}()`;
+    }
+    const last = keys[keys.length - 1];
+    return `${indent}${isInteger(last) || isIdentifier(last) ? last : JSON.stringify(last)}`;
+};
+/**
+ * Percent-encodes characters that GitHub workflow-command property values
+ * treat as separators (`%`, `:`, `,`) plus newlines.
+ * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+ */
+export const ghEscape = (s) => s.replaceAll('%', '%25')
+    .replaceAll(':', '%3A')
+    .replaceAll(',', '%2C')
+    .replaceAll('\r', '%0D')
+    .replaceAll('\n', '%0A');
+export const defaultTest = (file, path, { fn, throws }) => sandbox(fn)
+    .step(r => pure(throws ? { ...r, result: invert(r.result) } : r));
+const fmtResultLine = (file, path, color, label, duration) => `${fmtImport(file, path)}: ${color}${label}${reset}, ${timeFormat(duration)}`;
+/**
+ * The terminal/GitHub reporter used by `fjs t`. Output goes through
+ * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
+ * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * annotations instead of colored lines. Exported as a factory so the
+ * GitHub format path can be exercised directly from tests.
+ */
+export const defaultReporter = (options) => {
+    const write = csiWrite(options);
+    const line = (w) => {
+        const x = write(w);
+        return (s) => x(s + '\n');
+    };
+    const csiLog = line('stdout');
+    const csiError = line('stderr');
+    const isGitHub = options.env['GITHUB_ACTION'] !== undefined;
+    return {
+        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+        result: (file, path, { result: [s, v], duration }) => s === 'ok'
+            ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration))
+            : isGitHub
+                ? csiError(`::error file=${file},line=1,title=${ghEscape(fmtImport(file, path))}::${ghEscape(String(v))}`)
+                : csiError(fmtResultLine(file, path, fgRed, 'error', duration))
+                    .step(() => csiError(`${fgRed}${v}${reset}`)),
+        summary: (pass, fail, time) => {
+            const fgFail = fail === 0 ? fgGreen : fgRed;
+            return csiLog(`${bold}Number of tests: pass: ${fgGreen}${pass}${reset}${bold}, fail: ${fgFail}${fail}${reset}${bold}, total: ${pass + fail}${reset}`)
+                .step(() => csiLog(`${bold}Time: ${timeFormat(time)}${reset}`));
+        },
+        test: defaultTest,
+    };
 };
-export const main = test;
+export const main = options => test(defaultReporter(options))(options);

package/fs/dev/tf/module.js

@@ -1,9 +1,12 @@
-import { io } from "../../io/module.js";
-import { loadModuleMap2 } from "../module.f.js";
-import { isTest, parseTestSet } from "./module.f.js";
+import { io, tryCatch } from "../../io/module.js";
+import { loadModuleMap } from "../module.f.js";
+import { fmtImport, isTest, parseTestSet, runModuleMap } from "./module.f.js";
 import * as nodeTest from 'node:test';
 import { asyncImport } from "../../io/module.js";
 import { fromIo } from "../../io/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { asyncRun } from "../../types/effects/module.js";
+import {} from "../../types/effects/node/module.f.js";
 const isBun = typeof Bun !== 'undefined';
 const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
@@ -16,7 +19,6 @@ const createPlaywrightFramework = async () => {
 const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
-const parse = parseTestSet(io.sandbox);
 const scanModule = (x) => async (subTestRunner) => {
     let subTests = [x];
     while (true) {
@@ -27,28 +29,75 @@ const scanModule = (x) => async (subTestRunner) => {
         subTests = rest;
         //
         const [name, value, throws] = first;
-        const set = parse(throws)(value);
-        if (typeof set === 'function') {
-            await subTestRunner(name, () => {
-                const r = set();
-                // The result of a function is walked as a fresh sub-tree;
-                // the parent's `throws` flag does not propagate into it.
-                subTests = [...subTests, [`${name}()`, r, false]];
-            });
-        }
-        else {
+        const set = parseTestSet(throws, value);
+        if (set instanceof Array) {
             for (const [j, y] of set) {
                 const pr = `${name}/${j}`;
                 subTests = [...subTests, [pr, y, throws || j === 'throw']];
             }
         }
+        else {
+            await subTestRunner(name, () => {
+                if (set.throws) {
+                    let threw = false;
+                    try {
+                        set.fn();
+                    }
+                    catch (_) {
+                        threw = true;
+                    }
+                    if (!threw) {
+                        throw new Error(`${name}() expected to throw`);
+                    }
+                }
+                else {
+                    const r = set.fn();
+                    // The result of a function is walked as a fresh sub-tree;
+                    // the parent's `throws` flag does not propagate into it.
+                    subTests = [...subTests, [`${name}()`, r, false]];
+                }
+            });
+        }
     }
 };
+const noOp = () => pure(undefined);
+const reporter = {
+    result: noOp,
+    summary: noOp,
+    test: (file, path, { throws, fn }) => {
+        nodeTest.test(fmtImport(file, path), async (_t) => {
+            const [s, r] = tryCatch(fn);
+            if (throws === (s === 'ok')) {
+                throw r;
+            }
+            if (!throws) {
+                // TODO: add subtests
+            }
+        });
+        return pure({
+            result: ['ok', undefined],
+            duration: 0,
+        });
+    }
+};
+const map = {
+    // TODO: we use the same algorithm twice. Refactor by creating a `createAll(map)`
+    // helper that takes a `map` and returns an `all` function that runs effects
+    // according to the map. There could be a problem with circular dependencies,
+    // but we can use a lazy function `() => ToAsyncOperationMap<All>` instead od `map`.
+    all: async (...effects) => Promise.all(effects.map(asyncRun(map))),
+};
+export const run3 = async () => {
+    const fio = fromIo(io);
+    const moduleMap = await fio(loadModuleMap(io.process.env));
+    const runner = runModuleMap(reporter)(moduleMap);
+    await asyncRun(map)(runner);
+};
 export const run = async () => {
-    const x = await fromIo(io)(loadModuleMap2(io.process.env));
-    for (const [i, v] of Object.entries(x)) {
+    const moduleMap = await fromIo(io)(loadModuleMap(io.process.env));
+    for (const [i, v] of Object.entries(moduleMap)) {
         if (isTest(i)) {
-            framework(i, scanModule(['', v.default, false]));
+            framework(i, scanModule(['', v, false]));
         }
     }
 };