functionalscript 0.19.0 → 0.20.0

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

@@ -1,14 +1,20 @@
 /**
  * Test-framework helpers for running and reporting FunctionalScript tests.
  *
+ * Two parallel execution paths:
+ * - `runModule` / `Reporter<O>` — self-hosted Effects runner used by `fjs t`;
+ *   sandboxes each leaf call individually and accumulates `TestState`.
+ * - `registerModule` / `TestContext` — registers tests with an external
+ *   framework (Node `--test`, Bun, Playwright) at import time; the framework
+ *   owns scheduling and pass/fail counting.
+ *
  * @module
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
-import { all, sandbox, test } from "../../types/effects/node/module.f.js";
-import { pure, do_ } from "../../types/effects/module.f.js";
-import { loadModuleMap } from "../module.f.js";
+import { all, awaitIfPromise, sandbox, test } from "../../types/effects/node/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { loadModuleMap, shouldLoad } 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 });
 const timeFormat = (a) => {
@@ -20,6 +26,14 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
+/**
+ * Converts an arbitrary JS value into a `TestSet`.
+ *
+ * - Zero-argument functions become a `TestEntry`; the `throws` flag is set if
+ *   `throws` is already `true` or the function's `.name === 'throw'`.
+ * - Non-null objects become an array of `[key, value]` pairs to recurse into.
+ * - All other values (including functions with parameters) produce an empty array.
+ */
 export const parseTestSet = (throws, x) => {
     switch (typeof x) {
         case 'function': {
@@ -51,19 +65,28 @@ export const collectTests = (path, throws, v) => {
     }
     return [[path, set]];
 };
+/**
+ * Registers all tests reachable from module export `v` (keyed by `k`) with
+ * the given `TestContext`.
+ *
+ * Unlike `runModule`, which sandboxes only the leaf function, `registerModule`
+ * lets the external framework own scheduling: each registered test callback
+ * calls `fn`, then recursively registers any sub-trees returned by the function.
+ * This is the correct model for Node `--test`, Bun, and Playwright, where tests
+ * must be declared upfront and the framework drives execution.
+ */
 export const registerModule = (ctx, k, v) => {
-    const registerOne = (ctx, [path, { fn, throws }]) => test(ctx, fmtImport(k, path), throws, (t) => {
+    const registerOne = (ctx, [path, { fn, throws }]) => test(ctx, fmtImport(k, path), throws, (t) => awaitIfPromise(fn())
+        .step(resolved => {
         if (throws) {
-            fn();
             return pure(undefined);
         }
-        const r = fn();
-        const sub = collectTests([...path, null], false, r);
+        const sub = collectTests([...path, null], false, resolved);
         if (sub.length === 0) {
             return pure(undefined);
         }
         return all(...sub.map(e => registerOne(t, e))).step(() => pure(undefined));
-    });
+    }));
     const tests = collectTests([], false, v);
     if (tests.length === 0) {
         return pure(undefined);
@@ -99,16 +122,33 @@ const runModule = ({ result, test }) => (k, v) => (ts) => {
         .step(delta => pure(mergeState(ts, delta)));
 };
 const { entries } = Object;
+/**
+ * Runs all test modules in `moduleMap` whose names pass `isTest`, accumulates
+ * pass/fail/time via `reporter`, and returns an exit code (0 = all passed,
+ * 1 = at least one failure).
+ */
 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 }))
+    const modules = entries(moduleMap)
+        .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
+    return all(...modules.map(([k, v]) => runModule(reporter)(k, v)(zero)))
+        .step(m => pure(m.reduce(mergeState, zero)))
         .step(ts => summary(ts.pass, ts.fail, ts.time)
         .step(() => pure(ts.fail !== 0 ? 1 : 0)));
 };
+/**
+ * Discovers all test modules via `loadModuleMap`, then runs them through
+ * `runModuleMap`. The composed effect is a `NodeProgram` entry point for the
+ * `fjs t` test runner.
+ */
 export const testAll = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
-export const registerModuleMap = (ctx, moduleMap) => {
-    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+/**
+ * Registers all modules in `moduleMap` that export a `proof` property with
+ * `ctx`. Delegates to `registerModule` for each matching entry.
+ */
+const registerModuleMap = (ctx) => (moduleMap) => {
+    const modules = entries(moduleMap)
+        .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
     if (modules.length === 0) {
         return pure(undefined);
     }
@@ -116,7 +156,9 @@ export const registerModuleMap = (ctx, moduleMap) => {
 };
 const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
 const isDigit = (c) => c >= '0' && c <= '9';
+/** Returns `true` if `s` is a non-negative decimal integer without a leading zero. */
 export const isInteger = (s) => s.length > 0 && [...s].every(isDigit) && (s === '0' || s[0] !== '0');
+/** Returns `true` if `s` is a valid JS identifier (ASCII subset: `[A-Za-z_$][A-Za-z0-9_$]*`). */
 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}]`
@@ -131,10 +173,10 @@ const fmtKey = (k) => k === null ? '()'
 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()`.
+ * `import("./math.proof.f.ts").add()` or `import("./a.proof.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)}()`;
+export const fmtImport = (file, path) => `import(${JSON.stringify(file)}).proof${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
@@ -160,6 +202,10 @@ export const ghEscape = (s) => s.replaceAll('%', '%25')
     .replaceAll(',', '%2C')
     .replaceAll('\r', '%0D')
     .replaceAll('\n', '%0A');
+/**
+ * Default `Reporter.test` implementation: sandboxes `fn` once and inverts the
+ * result when `throws` is `true` (caught error → pass, clean return → fail).
+ */
 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)}`;
@@ -195,9 +241,20 @@ export const defaultReporter = (options) => {
         test: defaultTest,
     };
 };
+/** The `fjs t` entry point: runs all tests using `defaultReporter`. */
 export const main = options => testAll(defaultReporter(options))(options);
-export const register = o => loadModuleMap(o.env)
-    .step(m => registerModuleMap(o.engine === 'bun' ? o.bunTestContext :
-    o.engine === 'playwright' ? o.playwrightTestContext :
-        o.testContext, m))
-    .step(() => pure(0));
+/**
+ * Entry point for external test frameworks (Node `--test`, Bun, Playwright).
+ *
+ * Discovers test modules via `loadModuleMap`, then registers each with the
+ * framework-appropriate `TestContext` selected from `NodeProgramOptions`
+ * based on the detected `engine`.
+ */
+export const register = o => {
+    const r = registerModuleMap(o.engine === 'bun' ? o.bunTestContext :
+        o.engine === 'playwright' ? o.playwrightTestContext :
+            o.testContext);
+    return loadModuleMap(o.env)
+        .step(r)
+        .step(() => pure(0));
+};

package/fs/dev/tf/{test.f.d.ts → proof.f.d.ts}

@@ -15,8 +15,34 @@ export declare const githubReporterOutput: () => void;
 export declare const helpers: {
     isInteger: () => void;
     isIdentifier: () => void;
+    shouldLoad: () => void;
     fmtImport: () => void;
     fmtPath: () => void;
     fmtTerm: () => void;
     ghEscape: () => void;
 };
+export declare const proof: {
+    flat: () => void;
+    nested: () => void;
+    throwKey: () => void;
+    throwKeyFail: () => void;
+    mixedPassFail: () => void;
+    returnValueSubTree: () => void;
+    arrayKeys: () => void;
+    nonTestFilesSkipped: () => void;
+    multipleFiles: () => void;
+    throwByFunctionName: () => void;
+    namedExports: () => void;
+    defaultReporterOutput: () => void;
+    defaultReporterFailOutput: () => void;
+    githubReporterOutput: () => void;
+    helpers: {
+        isInteger: () => void;
+        isIdentifier: () => void;
+        shouldLoad: () => void;
+        fmtImport: () => void;
+        fmtPath: () => void;
+        fmtTerm: () => void;
+        ghEscape: () => void;
+    };
+};

package/fs/dev/tf/{test.f.js → proof.f.js}

@@ -3,6 +3,7 @@ import { emptyState } from "../../types/effects/node/virtual/module.f.js";
 import { virtual } from "../../types/effects/node/virtual/module.f.js";
 import { assert, assertEq, todo } from "../module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
+import { shouldLoad } from "../module.f.js";
 const makeReporter = () => {
     const events = [];
     const reporter = {
@@ -42,7 +43,7 @@ const runMain = (dir, github = false) => {
 // flat object: two passing tests
 export const flat = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ a: ok0, b: ok1 }),
+        'a.proof.f.ts': () => ({ proof: { a: ok0, b: ok1 } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -56,7 +57,7 @@ export const flat = () => {
 // nested object: leaf tests carry the full path including the sub-tree key
 export const nested = () => {
     const [events, exit] = run({
-        'n.test.f.ts': () => ({ math: { add: ok0, sub: ok0 } }),
+        'n.proof.f.ts': () => ({ proof: { math: { add: ok0, sub: ok0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1, e2] = events;
@@ -70,7 +71,7 @@ export const nested = () => {
 // throw key: tests inside 'throw' pass on error result
 export const throwKey = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: fail0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: fail0 } } }),
     });
     assertEq(exit, 0);
     const [e0, e1] = events;
@@ -83,7 +84,7 @@ export const throwKey = () => {
 // throw key fails when test does not throw (returns ok in throw context)
 export const throwKeyFail = () => {
     const [events, exit] = run({
-        't.test.f.ts': () => ({ throw: { a: ok0 } }),
+        't.proof.f.ts': () => ({ proof: { throw: { a: ok0 } } }),
     });
     assertEq(exit, 1);
     const [e0, e1] = events;
@@ -95,7 +96,7 @@ export const throwKeyFail = () => {
 // mixed pass/fail updates summary counts
 export const mixedPassFail = () => {
     const [events, exit] = run({
-        'm.test.f.ts': () => ({ good: ok0, bad: fail0 }),
+        'm.proof.f.ts': () => ({ proof: { good: ok0, bad: fail0 } }),
     });
     assertEq(exit, 1);
     const summary = events[events.length - 1];
@@ -108,11 +109,13 @@ export const mixedPassFail = () => {
 export const returnValueSubTree = () => {
     const inner = () => ({ result: ['ok', undefined], duration: 0 });
     const [events, exit] = run({
-        'r.test.f.ts': () => ({
-            outer: () => ({
-                result: ['ok', { inner }],
-                duration: 0,
-            }),
+        'r.proof.f.ts': () => ({
+            proof: {
+                outer: () => ({
+                    result: ['ok', { inner }],
+                    duration: 0,
+                }),
+            }
         }),
     });
     // outer passes, then inner (from return value) also passes
@@ -126,7 +129,7 @@ export const returnValueSubTree = () => {
 // integer-indexed array keys appear as numeric path segments
 export const arrayKeys = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ arr: [ok0, ok0] }),
+        'a.proof.f.ts': () => ({ proof: { arr: [ok0, ok0] } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
@@ -134,22 +137,24 @@ export const arrayKeys = () => {
     assertEq(passEvents[0][2][1], '0');
     assertEq(passEvents[1][2][1], '1');
 };
-// non-test files are skipped (only files ending in test.f.ts/js are loaded)
+// non-proof files are skipped: plain `.ts` is not loaded; `.f.ts` without
+// a `proof` export is loaded but produces no events
 export const nonTestFilesSkipped = () => {
     const [events, exit] = run({
-        'helper.ts': () => ({ a: ok0 }),
-        'b.test.f.ts': () => ({ x: ok0 }),
+        'helper.ts': () => ({ a: ok0 }), // not loaded (plain .ts)
+        'module.f.ts': () => ({ someExport: ok0 }), // loaded, no proof → skipped
+        'b.proof.f.ts': () => ({ proof: { x: ok0 } }), // loaded, has proof → runs
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
     assertEq(results.length, 1);
-    assertEq(results[0][1], './b.test.f.ts');
+    assertEq(results[0][1], './b.proof.f.ts');
 };
 // multiple test files each produce result events
 export const multipleFiles = () => {
     const [events, exit] = run({
-        'a.test.f.ts': () => ({ x: ok0 }),
-        'b.test.f.ts': () => ({ y: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
+        'b.proof.f.ts': () => ({ proof: { y: ok0 } }),
     });
     assertEq(exit, 0);
     const results = events.filter(e => e[0] === 'result');
@@ -164,51 +169,51 @@ export const throwByFunctionName = () => {
     // const named = ({ throw: () => fail0() }).throw
     const x = { throw: () => fail0() };
     const [events, exit] = run({
-        't.test.f.ts': () => ({ here: x.throw }),
+        't.proof.f.ts': () => ({ proof: { here: x.throw } }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
     assertEq(passEvents.length, 1);
     assertEq(passEvents[0][2][0], 'here');
 };
-// every module export — `default` and named — becomes a top-level path segment
+// only the `proof` export is used; other module properties are ignored
 export const namedExports = () => {
     const [events, exit] = run({
-        'e.test.f.ts': () => ({ default: ok0, helper: ok0 }),
+        'e.proof.f.ts': () => ({ proof: { a: ok0, b: ok0 }, other: ok0 }),
     });
     assertEq(exit, 0);
     const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2);
-    assertEq(passEvents[0][2][0], 'default');
-    assertEq(passEvents[1][2][0], 'helper');
+    assertEq(passEvents.length, 2); // `other` is ignored
+    assertEq(passEvents[0][2][0], 'a');
+    assertEq(passEvents[1][2][0], 'b');
 };
 // the default (non-GitHub) reporter formats module/pass/summary lines on stdout
 export const defaultReporterOutput = () => {
     const [stdout, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ x: ok0 }),
+        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
     });
     assertEq(exit, 0);
     assertEq(stderr, '');
-    assertEq(stdout, 'import("./a.test.f.ts").x(): ok, 0.0000 ms\n'
+    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 0.0000 ms\n'
         + 'Number of tests: pass: 1, fail: 0, total: 1\n'
         + 'Time: 0.0000 ms\n');
 };
 // a failure on the non-GitHub reporter writes the error to stderr, not stdout
 export const defaultReporterFailOutput = () => {
     const [, stderr, exit] = runMain({
-        'a.test.f.ts': () => ({ bad: fail0 }),
+        'a.proof.f.ts': () => ({ proof: { bad: fail0 } }),
     });
     assertEq(exit, 1);
-    assertEq(stderr, 'import("./a.test.f.ts").bad(): error, 0.0000 ms\noops\n');
+    assertEq(stderr, 'import("./a.proof.f.ts").proof.bad(): error, 0.0000 ms\noops\n');
 };
 // the GitHub reporter emits an `::error` annotation with a percent-encoded
 // title (the JSON path) and message
 export const githubReporterOutput = () => {
     const [, stderr, exit] = runMain({
-        's.test.f.ts': () => ({ 'a:b,c%d': fail0 }),
+        's.proof.f.ts': () => ({ proof: { 'a:b,c%d': fail0 } }),
     }, true);
     assertEq(exit, 1);
-    assertEq(stderr, '::error file=./s.test.f.ts,line=1,title=import("./s.test.f.ts")["a%3Ab%2Cc%25d"]()::oops\n');
+    assertEq(stderr, '::error file=./s.proof.f.ts,line=1,title=import("./s.proof.f.ts").proof["a%3Ab%2Cc%25d"]()::oops\n');
 };
 // direct unit tests for the pure path-format helpers
 export const helpers = {
@@ -229,12 +234,32 @@ export const helpers = {
         assert(!isIdentifier('1a'));
         assert(!isIdentifier('a-b'));
     },
+    shouldLoad: () => {
+        // all .f.ts / .f.js — FS modules are safe to bulk-load
+        assert(shouldLoad('module.f.ts'));
+        assert(shouldLoad('module.f.js'));
+        assert(shouldLoad('a.proof.f.ts'));
+        assert(shouldLoad('dir/module.f.ts'));
+        // vanilla opt-in by filename
+        assert(shouldLoad('proof.ts'));
+        assert(shouldLoad('proof.js'));
+        assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.mjs'));
+        assert(shouldLoad('math.proof.ts'));
+        assert(shouldLoad('math.proof.js'));
+        assert(shouldLoad('math.proof.mts'));
+        assert(shouldLoad('dir/math.proof.ts'));
+        // non-FS, non-proof vanilla files are not loaded
+        assert(!shouldLoad('helper.ts'));
+        assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('proof.tsx'));
+    },
     fmtImport: () => {
-        assertEq(fmtImport('./a.test.f.ts', []), 'import("./a.test.f.ts")()');
-        assertEq(fmtImport('./a.test.f.ts', ['math', 'add']), 'import("./a.test.f.ts").math.add()');
-        assertEq(fmtImport('./a.test.f.ts', ['users', '3']), 'import("./a.test.f.ts").users[3]()');
-        assertEq(fmtImport('./a.test.f.ts', ['x', 'hello world']), 'import("./a.test.f.ts").x["hello world"]()');
-        assertEq(fmtImport('./a.test.f.ts', ['outer', null, 'inner']), 'import("./a.test.f.ts").outer().inner()');
+        assertEq(fmtImport('./a.proof.f.ts', []), 'import("./a.proof.f.ts").proof()');
+        assertEq(fmtImport('./a.proof.f.ts', ['math', 'add']), 'import("./a.proof.f.ts").proof.math.add()');
+        assertEq(fmtImport('./a.proof.f.ts', ['users', '3']), 'import("./a.proof.f.ts").proof.users[3]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['x', 'hello world']), 'import("./a.proof.f.ts").proof.x["hello world"]()');
+        assertEq(fmtImport('./a.proof.f.ts', ['outer', null, 'inner']), 'import("./a.proof.f.ts").proof.outer().inner()');
     },
     fmtPath: () => {
         assertEq(fmtPath([]), '');
@@ -257,3 +282,20 @@ export const helpers = {
         assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
     },
 };
+export const proof = {
+    flat,
+    nested,
+    throwKey,
+    throwKeyFail,
+    mixedPassFail,
+    returnValueSubTree,
+    arrayKeys,
+    nonTestFilesSkipped,
+    multipleFiles,
+    throwByFunctionName,
+    namedExports,
+    defaultReporterOutput,
+    defaultReporterFailOutput,
+    githubReporterOutput,
+    helpers
+};

package/fs/dev/tf/scenarios/async-subtests.fail.d.ts

@@ -0,0 +1,4 @@
+export declare const withSubtests: () => Promise<{
+    sub1: () => void;
+    sub2: () => never;
+}>;

package/fs/dev/tf/scenarios/async-subtests.fail.js

@@ -0,0 +1,7 @@
+export const withSubtests = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    return {
+        sub1: () => { },
+        sub2: () => { throw 'sub-test failure'; },
+    };
+};

package/fs/dev/tf/scenarios/async-subtests.pass.d.ts

@@ -0,0 +1,4 @@
+export declare const withSubtests: () => Promise<{
+    sub1: () => void;
+    sub2: () => void;
+}>;

package/fs/dev/tf/scenarios/async-subtests.pass.js

@@ -0,0 +1,7 @@
+export const withSubtests = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    return {
+        sub1: () => { },
+        sub2: () => { },
+    };
+};

package/fs/dev/tf/scenarios/async.fail.d.ts

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

package/fs/dev/tf/scenarios/async.fail.js

@@ -0,0 +1,4 @@
+export const sleep_fail = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    throw 'async failure';
+};

package/fs/dev/tf/scenarios/async.pass.d.ts

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

package/fs/dev/tf/scenarios/async.pass.js

@@ -0,0 +1,3 @@
+export const sleep = async () => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+};

package/fs/dev/tf/scenarios/thenable.pass.d.ts

@@ -0,0 +1,3 @@
+export declare const thenableResolves: () => {
+    then(resolve: (v: undefined) => void): void;
+};

package/fs/dev/tf/scenarios/thenable.pass.js

@@ -0,0 +1,9 @@
+// A test that returns a thenable (Promise-like object, not a real Promise).
+// Per FunctionalScript convention, thenables are treated as plain values —
+// not awaited. Both sandbox (fjs) and registerModule (node/bun/deno/playwright)
+// must exit 0: the thenable object is walked as a sub-tree whose only key
+// `then` is a function with parameters, so no leaf tests are found and the
+// test trivially passes.
+export const thenableResolves = () => ({
+    then(resolve) { resolve(undefined); }
+});

package/fs/dev/tf/scenarios/thenable2.pass.f.d.ts

@@ -0,0 +1,3 @@
+export declare const shouldPass: () => {
+    then: () => string;
+};

package/fs/dev/tf/scenarios/thenable2.pass.f.js

@@ -0,0 +1,3 @@
+export const shouldPass = () => ({
+    then: () => 'ok'
+});

package/fs/dev/version/proof.f.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    new: () => void;
+};

package/fs/dev/version/{test.f.js → proof.f.js}

@@ -77,7 +77,7 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default {
+export const proof = {
     new: () => {
         const w = (name) => {
             const fn = `${name}.json`;

package/fs/djs/ast/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     test: () => void;
     testCref: () => void;
     testAref: () => void;
     testArray: () => void;
     testObj: () => void;
 };
-export default _default;

package/fs/djs/ast/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-export default {
+export const proof = {
     test: () => {
         const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);

package/fs/djs/parser/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     valid: (() => void)[];
     invalid: (() => void)[];
     errorMetadata: (() => void)[];
@@ -11,4 +11,3 @@ declare const _default: {
     invalidWithArgs: (() => void)[];
     comments: (() => void)[];
 };
-export default _default;

package/fs/djs/parser/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ import { stringifyAsTree } from "../serializer/module.f.js";
 import { stringify } from "../../json/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s))(''));
 const stringifyDjsModule = stringifyAsTree(sort);
-export default {
+export const proof = {
     valid: [
         () => {
             const tokenList = tokenizeString('export default null');

package/fs/djs/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     tooFewArgs: {
         noArgs: () => void;
         oneArg: () => void;
@@ -8,4 +8,3 @@ declare const _default: {
     fileNotFound: () => void;
     parseError: () => void;
 };
-export default _default;

package/fs/djs/{test.f.js → proof.f.js}

@@ -9,7 +9,7 @@ const readOutput = (root, path) => {
     }
     return utf8ToString(file);
 };
-export default {
+export const proof = {
     tooFewArgs: {
         noArgs: () => {
             const [state, code] = virtual(emptyState)(compile([]));

package/fs/djs/serializer/module.f.d.ts

@@ -7,11 +7,11 @@ import type { Unknown } from '../module.f.ts';
 import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export declare const undefinedSerialize: string[];
-type RefCounter = [number, number, boolean];
+type RefCounter = readonly [number, number];
 type Entry = ObjectEntry<Unknown>;
 type Entries = List<Entry>;
 type MapEntries = (entries: Entries) => Entries;
-type Refs = Map<Unknown, RefCounter>;
+type Refs = ReadonlyMap<Unknown, RefCounter>;
 export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
 export declare const stringify: (sort: MapEntries) => (djs: Unknown) => string;
 export declare const stringifyAsTree: (mapEntries: MapEntries) => (value: Unknown) => string;