functionalscript 0.23.0 → 0.25.0

package/fs/crypto/vdf/proof.f.js

@@ -0,0 +1,135 @@
+import { sloth, p } from "./module.f.js";
+const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
+// `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
+// https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
+// https://github.com/jose-compu/dignity.js/blob/main/src/security/sloth-vdf.js
+const sampleX = 123456789n;
+const largeX = 12345678901234567890n;
+const smallX = 42n;
+const nonResidue = 2n;
+const sampleY = 72412151236937799598582816305571618206681207952550127764586725290711141789888684237028784568532880529360450375677852568362636821341317217048062977639333459511661887862128325859969604061461913896412260750881385045152117694320409864730924775539555636460819549547999218170813228857928921642957426089461925313163n;
+const smallY = 145151597037272685697451525487035431973338817762329243361437778785747534269376083577375382484815474368317818719265551745910148543423765263685177263740373969289084400977118144482329577335929842301331443392042760708529572252015473334998752211959790788326970269713683808382892472572910797612141527200051803670965n;
+const y6 = 116287514643100261336025249676072556421566393377742705567032370320583145555855278910304225489766306768040386612082033279417845047304479679877515174322332386599890348932893235091525789175564701751964775040887336849457197662999383850490808701700264064812615988837073981567599117932005435532913423970502774287312n;
+const y4 = 64401150265223443694244964595084197237814157534040219819342647664782563317539559768554855806938965782018778040933157632467146168153951260465261118025222264314070274636967492909984790708532033331622332323767105919809000393624013423095812833452440384602112677364631962445309757177309466319657219548312354433189n;
+export const proof = {
+    p: {
+        matchesField: () => {
+            if (sloth.p !== p) {
+                throw [sloth.p, p];
+            }
+        },
+    },
+    eval: {
+        steps100: () => {
+            const y = evalVdf(100n)(sampleX);
+            if (y !== sampleY) {
+                throw [y, sampleY];
+            }
+        },
+        steps10: () => {
+            const y = evalVdf(10n)(smallX);
+            if (y !== smallY) {
+                throw [y, smallY];
+            }
+        },
+        steps6: () => {
+            const y = evalVdf(6n)(largeX);
+            if (y !== y6) {
+                throw [y, y6];
+            }
+        },
+        steps4: () => {
+            const y = evalVdf(4n)(smallX);
+            if (y !== y4) {
+                throw [y, y4];
+            }
+        },
+        zeroSteps: () => {
+            const y = evalVdf(0n)(sampleX);
+            if (y !== sampleX % p) {
+                throw [y, sampleX % p];
+            }
+        },
+        negativeSteps: () => {
+            const y = evalVdf(-1n)(sampleX);
+            if (y !== null) {
+                throw y;
+            }
+        },
+    },
+    verify: {
+        steps100: () => {
+            if (!verify(100n)(sampleX)(sampleY)) {
+                throw false;
+            }
+        },
+        steps10: () => {
+            if (!verify(10n)(smallX)(smallY)) {
+                throw false;
+            }
+        },
+        steps6: () => {
+            if (!verify(6n)(largeX)(y6)) {
+                throw false;
+            }
+        },
+        steps4: () => {
+            if (!verify(4n)(smallX)(y4)) {
+                throw false;
+            }
+        },
+        tampered: () => {
+            if (verify(4n)(smallX)((y4 + 1n) % p)) {
+                throw (y4 + 1n) % p;
+            }
+        },
+        wrongY: () => {
+            if (verify(100n)(sampleX)(sampleY + 1n)) {
+                throw sampleY + 1n;
+            }
+        },
+        zeroSteps: () => {
+            if (!verify(0n)(sampleX)(sampleX % p)) {
+                throw [sampleX % p];
+            }
+        },
+        negativeSteps: () => {
+            if (verify(-1n)(sampleX)(sampleY)) {
+                throw sampleY;
+            }
+        },
+        invalidY: () => {
+            if (verify(100n)(sampleX)(0n)) {
+                throw 0n;
+            }
+        },
+    },
+    modSqrt: {
+        roundTrip: () => {
+            const x = 999n;
+            if (!verify(1n)(x)(modSqrt(x))) {
+                throw modSqrt(x);
+            }
+        },
+        nonResidue: () => {
+            if (quadRes(nonResidue)) {
+                throw nonResidue;
+            }
+            if (!verify(1n)(nonResidue)(modSqrt(nonResidue))) {
+                throw modSqrt(nonResidue);
+            }
+        },
+    },
+    quadRes: {
+        one: () => {
+            if (!quadRes(1n)) {
+                throw 1n;
+            }
+        },
+        nonResidue: () => {
+            if (quadRes(nonResidue)) {
+                throw nonResidue;
+            }
+        },
+    },
+};

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

@@ -1,11 +1,5 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-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';
+import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
@@ -13,7 +7,6 @@ export type Module = {
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
-export declare const env: (io: Io) => (v: string) => string | undefined;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/fs/dev/module.f.js

@@ -1,19 +1,18 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
 import { updateVersion } from "./version/module.f.js";
-import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { all, both, import_, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../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, toPosix } from "../path/module.f.js";
-export const env = ({ process: { env } }) => a => {
-    const r = Object.getOwnPropertyDescriptor(env, a);
-    return r === undefined ? undefined :
-        typeof r.get === 'function' ? r.get() :
-            r.value;
-};
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -92,7 +91,9 @@ const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = updateVersion
     .step(() => readFile(denoJson))
     .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'))
+const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') ||
+    v.endsWith('/module.ts') ||
+    v.endsWith('/all.test.ts'))
     .step(files => {
     const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
     return pure(Object.fromEntries(exportsA));

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

@@ -9,5 +9,4 @@ export declare const proof: {
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
     throw: () => void;
-    env: () => void;
 };

package/fs/dev/proof.f.js

@@ -1,5 +1,4 @@
 import { todo } from "../asserts/module.f.js";
-import { env } from "./module.f.js";
 export const proof = {
     shouldPass: () => ({
         then: () => undefined
@@ -57,24 +56,4 @@ export const proof = {
     throw: () => {
         todo();
     },
-    env: () => {
-        const mockIo = { process: { env: { MY_VAR: 'hello' } } };
-        // missing key → undefined
-        const r1 = env(mockIo)('MISSING');
-        if (r1 !== undefined) {
-            throw r1;
-        }
-        // regular value property → returns value
-        const r2 = env(mockIo)('MY_VAR');
-        if (r2 !== 'hello') {
-            throw r2;
-        }
-        // getter property → calls get()
-        const envWithGetter = Object.defineProperty({}, 'GETTER_VAR', { get: () => 'from-getter', enumerable: true, configurable: true });
-        const mockIo2 = { process: { env: envWithGetter } };
-        const r3 = env(mockIo2)('GETTER_VAR');
-        if (r3 !== 'from-getter') {
-            throw r3;
-        }
-    }
 };

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

@@ -1,3 +1,3 @@
-import { type Effect } from '../../types/effects/module.f.ts';
-import { type All, type ReadFile, type WriteFile } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
+import { type All, type ReadFile, type WriteFile } from '../../effects/node/module.f.ts';
 export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;

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

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { begin, pure } from "../../types/effects/module.f.js";
-import { all, readFile, writeFile } from "../../types/effects/node/module.f.js";
+import { begin, pure } from "../../effects/module.f.js";
+import { all, readFile, writeFile } from "../../effects/node/module.f.js";
 import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;

package/fs/dev/version/proof.f.js

@@ -1,7 +1,7 @@
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { isVec } from "../../types/bit_vec/module.f.js";
-import { all, writeFile } from "../../types/effects/node/module.f.js";
-import { emptyState, virtual } from "../../types/effects/node/virtual/module.f.js";
+import { all, writeFile } from "../../effects/node/module.f.js";
+import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
 import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {

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

@@ -4,8 +4,8 @@
  * @module
  */
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
-import { type WriteFile, type ReadFile, type Write } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type WriteFile, type ReadFile, type Write } from '../effects/node/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
 };

package/fs/djs/module.f.js

@@ -1,8 +1,8 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { writeFile, error, } from "../types/effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { writeFile, error, } from "../effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
 export const compile = args => {
     if (args.length < 2) {

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

@@ -7,11 +7,9 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-import type { Fs } from '../../io/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
 export type ParseContext = {
-    readonly fs: Fs;
     readonly complete: OrderedMap<Result<AstModule, string>>;
     readonly stack: List<string>;
 };

package/fs/djs/proof.f.js

@@ -1,5 +1,5 @@
 import { compile } from "./module.f.js";
-import { virtual, emptyState } from "../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {

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

@@ -8,8 +8,8 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import { type ParseError } from '../parser/module.f.ts';
-import { type Effect } from '../../types/effects/module.f.ts';
-import { type ReadFile } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
+import { type ReadFile } from '../../effects/node/module.f.ts';
 /**
  * State threaded through the recursive transpilation of a DJS module graph.
  *

package/fs/djs/transpiler/module.f.js

@@ -12,8 +12,8 @@ import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
-import { foldStep, pure } from "../../types/effects/module.f.js";
-import { readFile } from "../../types/effects/node/module.f.js";
+import { foldStep, pure } from "../../effects/module.f.js";
+import { readFile } from "../../effects/node/module.f.js";
 import { utf8ToString } from "../../text/module.f.js";
 const mapDjs = context => path => {
     const res = at(path)(context.complete);

package/fs/djs/transpiler/proof.f.js

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-import { virtual, emptyState } from "../../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../../effects/node/virtual/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));

package/fs/{types/effects → effects}/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type List } from '../list/module.f.ts';
+import { type List } from '../types/list/module.f.ts';
 export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;

package/fs/{types/effects → effects}/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { fold } from "../list/module.f.js";
+import { fold } from "../types/list/module.f.js";
 export const pure = (v) => ({
     value: [v],
     step: f => f(v)

package/fs/{io → effects/node}/module.d.ts

@@ -1,10 +1,4 @@
-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>;
+import { type NodeProgram } from './module.f.ts';
 /**
  * Runs a `NodeProgram` against the real Node `io` and process arguments,
  * resolving to its exit code **without** terminating the process.
@@ -12,7 +6,7 @@ export type NodeRun = (p: NodeProgram) => Promise<never>;
  * Use this when the caller must stay alive afterwards — e.g. when proofs are
  * registered under an external test runner (Node `--test`, Bun, Playwright)
  * that owns the process lifecycle. For a standalone CLI entry point that should
- * exit with the program's code, use the default {@link run} export instead.
+ * exit with the program's code, use {@link run} instead.
  */
 export declare const runEffect: (p: NodeProgram) => Promise<number>;
 /**
@@ -20,8 +14,7 @@ export declare const runEffect: (p: NodeProgram) => Promise<number>;
  * `process.exit` with its exit code. The `Promise<never>` return type reflects
  * that control never returns to the caller — the process terminates.
  *
- * This is the default export so a `bin` script can simply
- * `import run from '.../io/module.js'; run(main)`.
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
  */
-declare const run: NodeRun;
-export default run;
+export declare const run: (p: NodeProgram) => Promise<never>;

package/fs/{types/effects → effects}/node/module.f.d.ts

@@ -1,6 +1,6 @@
-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';
+import type { Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nominal } from '../../types/nominal/module.f.ts';
+import type { Result } from '../../types/result/module.f.ts';
 import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
 export type All = ['all', <T>(...effects: Effect<never, T>[]) => readonly T[]];

package/fs/{types/effects → effects}/node/module.f.js

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import { utf8 } from "../../../text/module.f.js";
+import { utf8 } from "../../text/module.f.js";
 import { begin, do_, pure } from "../module.f.js";
 const doAll = do_('all');
 /**

package/fs/{io → effects/node}/module.js

@@ -10,12 +10,97 @@ import http from 'node:http';
 import childProcess from 'node:child_process';
 import fs from 'node:fs';
 import process from 'node:process';
-import { concat } from "../path/module.f.js";
 import { once } from 'node:events';
-import { 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';
+import { concat } from "../../path/module.f.js";
+import { normalize } from "../../path/module.f.js";
+import {} from "../module.f.js";
+import { asyncRun } from "../module.js";
+import {} from "./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";
+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;
+};
+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;
+};
+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));
+    };
+};
 const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
 const pwTest = isPlaywright
     ? (await import('@playwright/test')).test
@@ -66,8 +151,8 @@ const writeAll = async (stream, data) => {
         await once(stream, 'drain');
     }
 };
-export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
-export const tryCatch = f => {
+const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
+const tryCatch = f => {
     try {
         return ok(f());
     }
@@ -76,7 +161,7 @@ export const tryCatch = f => {
     }
 };
 const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
-export const io = {
+const io = {
     console,
     fs,
     process,
@@ -132,7 +217,7 @@ export const io = {
  * Use this when the caller must stay alive afterwards — e.g. when proofs are
  * registered under an external test runner (Node `--test`, Bun, Playwright)
  * that owns the process lifecycle. For a standalone CLI entry point that should
- * exit with the program's code, use the default {@link run} export instead.
+ * exit with the program's code, use {@link run} instead.
  */
 export const runEffect = runProgram(io)(io.process.argv.slice(2));
 /**
@@ -140,8 +225,7 @@ export const runEffect = runProgram(io)(io.process.argv.slice(2));
  * `process.exit` with its exit code. The `Promise<never>` return type reflects
  * that control never returns to the caller — the process terminates.
  *
- * This is the default export so a `bin` script can simply
- * `import run from '.../io/module.js'; run(main)`.
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
  */
-const run = async (p) => process.exit(await runEffect(p));
-export default run;
+export const run = async (p) => process.exit(await runEffect(p));

package/fs/{types/effects → effects}/node/proof.f.js

@@ -1,4 +1,4 @@
-import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
+import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
 import { pure } from "../module.f.js";
 import { fetch, mkdir, now, readdir, readFile, rm, sandbox, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";

package/fs/{types/effects → effects}/node/virtual/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type Vec } from '../../../bit_vec/module.f.ts';
+import { type Vec } from '../../../types/bit_vec/module.f.ts';
 import { type RunInstance } from '../../mock/module.f.ts';
 import type { Module, NodeOp } from '../module.f.ts';
 /**

package/fs/{types/effects → effects}/node/virtual/module.f.js

@@ -3,11 +3,11 @@
  *
  * @module
  */
-import { assert, todo } from "../../../../asserts/module.f.js";
-import { parse } from "../../../../path/module.f.js";
-import { utf8ToString } from "../../../../text/module.f.js";
-import { isVec } from "../../../bit_vec/module.f.js";
-import { error, ok } from "../../../result/module.f.js";
+import { todo } from "../../../asserts/module.f.js";
+import { parse } from "../../../path/module.f.js";
+import { utf8ToString } from "../../../text/module.f.js";
+import { isVec } from "../../../types/bit_vec/module.f.js";
+import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
 export const emptyState = {
     stdout: '',

package/fs/emergent_testing/all.test.d.ts

@@ -1 +1 @@
-import './module.ts';
+export {};

package/fs/emergent_testing/all.test.js

@@ -1,3 +1,4 @@
-import "./module.js";
+import { runEffect } from "../effects/node/module.js";
+import { register } from "./module.f.js";
 // we need `await` for Playwright.
-// await run()
+await runEffect(register);

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

@@ -1,5 +1,5 @@
-import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../types/effects/node/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
+import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
 import { type LoadModuleOperations, type ModuleMap } from '../dev/module.f.ts';
 /** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;

package/fs/emergent_testing/module.f.js

@@ -11,8 +11,8 @@
  * @module
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/module.f.js";
-import { all, awaitIfPromise, sandbox, test } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { all, awaitIfPromise, sandbox, test } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
 import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
 import { invert } from "../types/result/module.f.js";
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });

package/fs/emergent_testing/proof.f.js

@@ -1,9 +1,9 @@
-import { pure } from "../types/effects/module.f.js";
-import { emptyState } from "../types/effects/node/virtual/module.f.js";
-import { virtual } from "../types/effects/node/virtual/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { emptyState } from "../effects/node/virtual/module.f.js";
+import { virtual } from "../effects/node/virtual/module.f.js";
 import { assert, assertEq, todo } from "../asserts/module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, defaultTest, } from "./module.f.js";
-import { run as mockRun } from "../types/effects/mock/module.f.js";
+import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
 const makeReporter = () => {
     const events = [];

package/fs/emergent_testing/scenarios/all.d.ts

@@ -1 +1 @@
-import '../module.ts';
+import '../all.test.ts';