functionalscript 0.43.1 → 0.44.0

package/fjs/effects/node/proof.f.js

@@ -1,409 +0,0 @@
-import { empty, isVec, uint, vec, vec8 } from "../../types/bit_vec/module.f.js";
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { match, pure, step } from "../module.f.js";
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream, usesInlineTestContext, versionLessThan } from "./module.f.js";
-import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
-import { empty as listEmpty, nonEmpty as listNonEmpty } from "../list/module.f.js";
-import { emptyState, virtual } from "./virtual/module.f.js";
-import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
-import { ok } from '../../types/result/module.f.js';
-// Answers the one command the `map` proof below drives. Routing the loop
-// through `match` keeps the `Pure`/`Do` layout out of this module: the map key
-// is the command assertion, and `MatchResult` types the continuation.
-const readHello = match({
-    readFile: path => {
-        assertEq(path, 'hello');
-        return ok(vec8(0x15n));
-    },
-});
-export const proof = {
-    externalTestContext: () => {
-        assert(usesInlineTestContext('node', 'v22.20.0'));
-        assert(usesInlineTestContext('node', '25.99.99'));
-        assert(!usesInlineTestContext('node', '26.0.0'));
-        assert(!usesInlineTestContext('node', '26.1.0'));
-        assert(!usesInlineTestContext('node'));
-        assert(usesInlineTestContext('bun'));
-        assert(!usesInlineTestContext('deno', '22.0.0'));
-        assert(versionLessThan('25.99.99', '26.0.0'));
-        assert(versionLessThan('26.0.0', '26.1.0'));
-        assert(versionLessThan('26.1.0', '26.1.1'));
-        assert(!versionLessThan('26.1.1', '26.1.1'));
-    },
-    map: () => {
-        const e = step(readFile('hello'), ([k, v]) => {
-            assert(k !== 'error', v);
-            return pure(uint(v) * 2n);
-        });
-        //
-        let r = readHello(e);
-        while (r[0] === 'cont') {
-            r = readHello(r[2](r[1]));
-        }
-        assertEq(r[1], 0x2an);
-    },
-    fetch: () => {
-        const [_, [t, result]] = virtual({
-            ...emptyState,
-            internet: {
-                'https://example.com/data': vec8(0x2an),
-            },
-        })(fetch('https://example.com/data'));
-        assert(t !== 'error', result);
-        assert(isVec(result), result);
-        assertEq(uint(result), 0x2an, result);
-    },
-    mkdir: {
-        one: () => {
-            const [state, [t, result]] = virtual(emptyState)(mkdir('a'));
-            assert(t !== 'error', result);
-            const a = state.root.a;
-            assert(!(a === undefined || Array.isArray(a)), a);
-        },
-        rec: () => {
-            const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache', { recursive: true }));
-            assert(t === 'ok', result);
-            const tmp = state.root.tmp;
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
-            const cache = tmp.cache;
-            assert(!(typeof cache !== 'object' || Array.isArray(cache)), tmp);
-        },
-        nonRec: () => {
-            const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache'));
-            assert(t === 'error', result);
-            assertEq(state.root.tmp, undefined);
-        }
-    },
-    readFile: {
-        one: () => {
-            const initial = {
-                ...emptyState,
-                root: {
-                    hello: [vec8(0x2an)],
-                },
-            };
-            const [state, [t, result]] = virtual(initial)(readFile('hello'));
-            assert(t !== 'error', result);
-            assert(isVec(result), result);
-            assertEq(uint(result), 0x2an, result);
-            assert(state.root.hello !== undefined, state.root);
-        },
-        nested: () => {
-            const [_, [tag, result]] = virtual({
-                ...emptyState,
-                root: { tmp: { cache: [vec8(0x15n)] } }
-            })(readFile('tmp/cache'));
-            assert(tag !== 'error', result);
-            assertEq(uint(result), 0x15n, result);
-        },
-        noSuchFile: () => {
-            const [_, [t, result]] = virtual(emptyState)(readFile('hello'));
-            assert(t === 'error', result);
-        },
-        nestedPath: () => {
-            const [_, [t, result]] = virtual(emptyState)(readFile('tmp/cache'));
-            assert(t === 'error', result);
-            if (result.code !== 'ENOENT') {
-                throw result;
-            }
-        },
-        withinLimit: () => {
-            // Test with a small file well within the 131,072 byte limit
-            const initial = {
-                ...emptyState,
-                root: {
-                    smallFile: [vec8(0x2an)],
-                },
-            };
-            const [_, [t, result]] = virtual(initial)(readFile('smallFile'));
-            assert(t !== 'error', result);
-            assert(isVec(result), result);
-        }
-    },
-    readUtf8File: {
-        ok: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: { hello: [utf8('Hello, world!')] },
-            })(readUtf8File('hello'));
-            assert(t === 'ok', result);
-            assertEq(result, 'Hello, world!');
-        },
-        noSuchFile: () => {
-            const [_, [t, result]] = virtual(emptyState)(readUtf8File('hello'));
-            assert(t === 'error', result);
-        },
-    },
-    readdir: {
-        one: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: {
-                    file: [vec8(0x2an)],
-                    dir: {
-                        a: [empty]
-                    },
-                },
-            })(readdir('', { recursive: true }));
-            assert(t === 'ok', result);
-            const file = result.find(x => x.name === 'file');
-            if (file === undefined || file.parentPath !== '' || !file.isFile) {
-                throw `file: ${file}`;
-            }
-            const dirA = result.find(x => x.name === 'a');
-            if (dirA === undefined || dirA.parentPath !== '/dir') {
-                throw `dirA: ${dirA?.parentPath}`;
-            }
-        },
-        nonRecursive: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: {
-                    file: [vec8(0x2an)],
-                    dir: {
-                        a: [empty]
-                    },
-                },
-            })(readdir('', {}));
-            assert(t === 'ok', result);
-            assertEq(result.length, 2, result);
-            assertNotNullish(result.find(x => x.name === 'file'));
-            assertNotNullish(result.find(x => x.name === 'dir'));
-        },
-        nested: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: { tmp: { cache: [vec8(0x15n)] } }
-            })(readdir('tmp', { recursive: true }));
-            assert(t === 'ok', result);
-            assertEq(result.length, 1, result);
-            const [r0] = result;
-            assertEq(r0.name, 'cache', r0);
-            assertEq(r0.parentPath, 'tmp', r0);
-        },
-        noSuchDir: () => {
-            const [_, [t, result]] = virtual(emptyState)(readdir('tmp', { recursive: true }));
-            assert(t === 'error', result);
-            assertEq(result, 'invalid path');
-        },
-    },
-    writeFile: {
-        one: () => {
-            const [state, [t, result]] = virtual(emptyState)(writeFile('hello', vec8(0x2an)));
-            assert(t === 'ok', result);
-            const file = state.root.hello;
-            assert(Array.isArray(file), file);
-            assertEq(uint(file[0]), 0x2an, file);
-        },
-        overwrite: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: {
-                    hello: [vec8(0x15n)],
-                },
-            })(writeFile('hello', vec8(0x2an)));
-            assert(t === 'ok', result);
-            const file = state.root.hello;
-            assert(Array.isArray(file), file);
-            assertEq(uint(file[0]), 0x2an, file);
-        },
-        nestedPath: () => {
-            const [state, [t, result]] = virtual(emptyState)(writeFile('tmp/cache', vec8(0x2an)));
-            assert(t === 'error', result);
-            assertEq(result, 'invalid file');
-            assertEq(state.root.tmp, undefined, state.root);
-        },
-        directory: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: {
-                    tmp: {},
-                },
-            })(writeFile('tmp', vec8(0x2an)));
-            assert(t === 'error', result);
-            assertEq(result, 'invalid file');
-            const tmp = state.root.tmp;
-            assert(!(tmp === undefined || Array.isArray(tmp)), tmp);
-        },
-    },
-    writeUtf8File: () => {
-        const [state, [t, result]] = virtual(emptyState)(writeUtf8File('hello', 'Hello, world!'));
-        assert(t === 'ok', result);
-        const file = state.root.hello;
-        assert(Array.isArray(file), file);
-        assertEq(utf8ToString(file[0]), 'Hello, world!', file);
-    },
-    rm: {
-        one: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { hello: [vec8(0x2an)] },
-            })(rm('hello'));
-            assert(t === 'ok', result);
-            assertEq(state.root.hello, undefined, state.root);
-        },
-        nested: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { tmp: { cache: [vec8(0x15n)] } },
-            })(rm('tmp/cache'));
-            assert(t === 'ok', result);
-            const tmp = state.root.tmp;
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
-            assertEq(tmp.cache, undefined, tmp);
-        },
-        noSuchFile: () => {
-            const [_, [t, result]] = virtual(emptyState)(rm('hello'));
-            assert(t === 'error', result);
-            assertEq(result, 'no such file');
-        },
-        isDirectory: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { tmp: {} },
-            })(rm('tmp'));
-            assert(t === 'error', result);
-            assertEq(result, 'invalid path');
-            assert(state.root.tmp !== undefined, state.root);
-        },
-    },
-    both: () => {
-        const [_, results] = virtual({
-            ...emptyState,
-            root: {
-                a: [vec8(0x2an)],
-                b: [vec8(0x15n)],
-            },
-        })(both(readFile('a'))(readFile('b')));
-        assert(results[0][0] === 'ok', results[0]);
-        assert(results[1][0] === 'ok', results[1]);
-        assertEq(uint(results[0][1]), 0x2an, results[0][1]);
-        assertEq(uint(results[1][1]), 0x15n, results[1][1]);
-    },
-    now: () => {
-        const [_, result] = virtual({ ...emptyState, epochNs: 1_000_000 })(now());
-        assertEq(result, 1_000_000);
-    },
-    sandbox: {
-        // Virtual `sandbox` is now a pass-through: the function is expected
-        // to return a `SandboxResult` directly. Fixtures dictate the result
-        // (and `duration`) instead of the runner measuring.
-        ok: () => {
-            const [_, { result, duration }] = virtual(emptyState)(sandbox(() => ({ result: ['ok', 42], duration: 0 })));
-            assert(result[0] === 'ok', result);
-            assertEq(result[1], 42);
-            assertEq(duration, 0);
-        },
-        error: () => {
-            const err = new Error('fail');
-            const [_, { result }] = virtual(emptyState)(sandbox(() => ({ result: ['error', err], duration: 0 })));
-            assert(result[0] === 'error', result);
-            assertEq(result[1], err);
-        },
-    },
-    memory: {
-        createAndRead: () => {
-            const effect = step(memCreate(42), key => memRead(key));
-            const [_, value] = virtual(emptyState)(effect);
-            assertEq(value, 42);
-        },
-        createAndWrite: () => {
-            const effect = step(memCreate(1), key => step(memWrite(key, 99), () => memRead(key)));
-            const [_, value] = virtual(emptyState)(effect);
-            assertEq(value, 99);
-        },
-    },
-    rename: {
-        fileOverFile: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { src: [vec8(0x2an)], dst: [vec8(0x15n)] },
-            })(rename('src', 'dst'));
-            assert(t === 'ok', result);
-            assertEq(state.root.src, undefined, state.root);
-            assert(Array.isArray(state.root.dst), state.root);
-            assertEq(uint(state.root.dst[0]), 0x2an, state.root);
-        },
-        nestedRename: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { tmp: { src: [vec8(0x2an)] } },
-            })(rename('tmp/src', 'tmp/dst'));
-            assert(t === 'ok', result);
-            const tmp = state.root.tmp;
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
-            assertEq(tmp.src, undefined, tmp);
-        },
-        dirOverFile: () => {
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { src: {}, dst: [vec8(0x15n)] },
-            })(rename('src', 'dst'));
-            assert(t === 'error', result);
-            assert(Array.isArray(state.root.dst), state.root);
-        },
-        missingSource: () => {
-            const [_, [t, result]] = virtual(emptyState)(rename('missing', 'dst'));
-            assert(t === 'error', result);
-        },
-    },
-    readBytes: {
-        simple: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: { file: [vec8(0xabn)] },
-            })(readBytes('file', 0, 1));
-            assert(t === 'ok', result);
-            assert(isVec(result), result);
-        },
-        withOffset: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: { file: [vec8(0xabn), vec8(0xcdn)] },
-            })(readBytes('file', 1, 1));
-            assert(t === 'ok', result);
-            assert(isVec(result), result);
-        },
-        oversizeChunk: () => {
-            const [_, [t, result]] = virtual({
-                ...emptyState,
-                root: { file: [vec8(0x2an)] },
-            })(readBytes('file', 0, Number(2n ** 32n)));
-            assert(t === 'error', result);
-        },
-        missingFile: () => {
-            const [_, [t, result]] = virtual(emptyState)(readBytes('missing', 0, 4));
-            assert(t === 'error', result);
-        },
-    },
-    randomInt: {
-        increments: () => {
-            const [state1, r1] = virtual(emptyState)(randomInt());
-            assertEq(r1, 0);
-            const [state2, r2] = virtual(state1)(randomInt());
-            assertEq(r2, 1);
-            const [_, r3] = virtual(state2)(randomInt());
-            assertEq(r3, 2);
-        },
-    },
-    writeFromStream: {
-        createExclusiveFails: () => {
-            // The destination already exists, so `createExclusive` fails (EEXIST) and
-            // the error propagates without ever touching `writeBytes`.
-            const [state, [t, result]] = virtual({
-                ...emptyState,
-                root: { hello: [vec8(0x2an)] },
-            })(writeFromStream('hello', listEmpty()));
-            assert(t === 'error', result);
-            const file = state.root.hello;
-            assert(!(!Array.isArray(file) || uint(file[0]) !== 0x2an), file);
-        },
-        invalidBufferSize: () => {
-            // A chunk whose bit length isn't a multiple of 8 trips the
-            // byte-alignment guard before `writeBytes` is ever called.
-            const [_, [t, result]] = virtual(emptyState)(writeFromStream('hello', listNonEmpty(['ok', vec(4n)(10n)], listEmpty())));
-            assert(t === 'error', result);
-            assertEq(result, 'invalid buffer size');
-        },
-    },
-};

package/fjs/effects/node/virtual/module.f.d.ts

@@ -1,49 +0,0 @@
-import { type Vec } from '../../../types/bit_vec/module.f.ts';
-import { type RunInstance } from '../../mock/module.f.ts';
-import type { Module, NodeOp, NodeProgramOptions } from '../module.f.ts';
-/**
- * In-memory JS module entry. When `import_` is called on the path, the
- * function is invoked and its return value is the module value (with a
- * `default` export and optional named exports). Using a function (not a
- * plain value) lets the entry be distinguished from `Vec`/`Dir` at runtime
- * via `typeof === 'function'`, and lets the fixture compute the module on
- * each import for closures/state.
- */
-export type JsModule = () => Module;
-export type Entity = readonly Vec[] | Dir | JsModule;
-export type Dir = {
-    readonly [name in string]?: Entity;
-};
-export type State = {
-    stdout: string;
-    stderr: string;
-    /** Remaining stdin bytes; each `read` pops the first, `null` at EOF. */
-    stdin: readonly number[];
-    root: Dir;
-    internet: {
-        readonly [url: string]: Vec;
-    };
-    epochNs: number;
-    memoryNext: number;
-    memoryValues: {
-        readonly [key: string]: unknown;
-    };
-    /** Monotonically increasing counter returned by `randomInt`; starts at 0. */
-    randomNext: number;
-};
-export declare const emptyState: State;
-export declare const virtual: RunInstance<NodeOp, State>;
-/**
- * Safe, inert defaults for every {@link NodeProgramOptions} field, intended for
- * proof files that need to call a program without owning the full literal.
- *
- * Proofs spread-override only what their test cares about:
- *
- * ```ts
- * const opts: NodeProgramOptions = { ...defaultNodeProgramOptions, args }
- * ```
- *
- * Future additions to `NodeProgramOptions` only need a default added here,
- * keeping unrelated proof files from churning.
- */
-export declare const defaultNodeProgramOptions: NodeProgramOptions;