functionalscript 0.32.3 → 0.33.0

package/fs/effects/node/module.js

@@ -22,6 +22,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  */
 import http from 'node:http';
 import childProcess from 'node:child_process';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import process from 'node:process';
@@ -58,7 +59,7 @@ const collect = async (v) => {
     }
     return result;
 };
-const { mkdir, readFile, readdir, writeFile, rm, access, stat } = fs.promises;
+const { mkdir, open, readFile, readdir, rename, writeFile, rm, access, stat } = fs.promises;
 const { exec } = childProcess;
 const maxFileSizeBytes = Number(maxLengthBytes);
 const prefix = 'file:///';
@@ -179,6 +180,25 @@ const runNodeEffect = asyncRun({
     }))),
     writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
     rm: path => tc(() => rm(path)),
+    rename: (src, dst) => tc(() => rename(src, dst)),
+    readBytes: (path, offset, size) => tc(async () => {
+        if (offset < 0) {
+            throw new Error(`Offset ${offset} is negative`);
+        }
+        if (size > maxFileSizeBytes) {
+            throw new Error(`Chunk size ${size} exceeds maximum allowed size of ${maxFileSizeBytes} bytes`);
+        }
+        const fh = await open(path, 'r');
+        try {
+            const buffer = Buffer.alloc(size);
+            const { bytesRead } = await fh.read(buffer, 0, size, offset);
+            return toVec(buffer.subarray(0, bytesRead));
+        }
+        finally {
+            await fh.close();
+        }
+    }),
+    randomInt: async () => crypto.randomInt(2 ** 32),
     access: path => tc(() => access(path)),
     import: path => tc(() => asyncImport(path)),
     exec: (command, stdin) => new Promise(resolve => {

package/fs/effects/node/proof.f.d.ts

@@ -46,4 +46,19 @@ export declare const proof: {
         createAndRead: () => void;
         createAndWrite: () => void;
     };
+    rename: {
+        fileOverFile: () => void;
+        nestedRename: () => void;
+        dirOverFile: () => void;
+        missingSource: () => void;
+    };
+    readBytes: {
+        simple: () => void;
+        withOffset: () => void;
+        oversizeChunk: () => void;
+        missingFile: () => void;
+    };
+    randomInt: {
+        increments: () => void;
+    };
 };

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

@@ -1,7 +1,7 @@
 import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { decode, pure } from "../module.f.js";
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File } from "./module.f.js";
+import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt } from "./module.f.js";
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export const proof = {
@@ -51,7 +51,7 @@ export const proof = {
                 throw result;
             }
             const a = state.root.a;
-            if (a === undefined || isVec(a)) {
+            if (a === undefined || Array.isArray(a)) {
                 throw a;
             }
         },
@@ -61,11 +61,11 @@ export const proof = {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object') {
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
                 throw state.root;
             }
             const cache = tmp.cache;
-            if (typeof cache !== 'object') {
+            if (typeof cache !== 'object' || Array.isArray(cache)) {
                 throw tmp;
             }
         },
@@ -84,7 +84,7 @@ export const proof = {
             const initial = {
                 ...emptyState,
                 root: {
-                    hello: vec8(0x2an),
+                    hello: [vec8(0x2an)],
                 },
             };
             const [state, [t, result]] = virtual(initial)(readFile('hello'));
@@ -104,7 +104,7 @@ export const proof = {
         nested: () => {
             const [_, [tag, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } }
+                root: { tmp: { cache: [vec8(0x15n)] } }
             })(readFile('tmp/cache'));
             if (tag === 'error') {
                 throw result;
@@ -133,7 +133,7 @@ export const proof = {
             const initial = {
                 ...emptyState,
                 root: {
-                    smallFile: vec8(0x2an),
+                    smallFile: [vec8(0x2an)],
                 },
             };
             const [_, [t, result]] = virtual(initial)(readFile('smallFile'));
@@ -149,7 +149,7 @@ export const proof = {
         ok: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { hello: utf8('Hello, world!') },
+                root: { hello: [utf8('Hello, world!')] },
             })(readUtf8File('hello'));
             if (t !== 'ok') {
                 throw result;
@@ -170,9 +170,9 @@ export const proof = {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    file: vec8(0x2an),
+                    file: [vec8(0x2an)],
                     dir: {
-                        a: empty
+                        a: [empty]
                     },
                 },
             })(readdir('', { recursive: true }));
@@ -192,9 +192,9 @@ export const proof = {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    file: vec8(0x2an),
+                    file: [vec8(0x2an)],
                     dir: {
-                        a: empty
+                        a: [empty]
                     },
                 },
             })(readdir('', {}));
@@ -216,7 +216,7 @@ export const proof = {
         nested: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } }
+                root: { tmp: { cache: [vec8(0x15n)] } }
             })(readdir('tmp', { recursive: true }));
             if (t !== 'ok') {
                 throw result;
@@ -249,10 +249,10 @@ export const proof = {
                 throw result;
             }
             const file = state.root.hello;
-            if (!isVec(file)) {
+            if (!Array.isArray(file)) {
                 throw file;
             }
-            if (uint(file) !== 0x2an) {
+            if (uint(file[0]) !== 0x2an) {
                 throw file;
             }
         },
@@ -260,17 +260,17 @@ export const proof = {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    hello: vec8(0x15n),
+                    hello: [vec8(0x15n)],
                 },
             })(writeFile('hello', vec8(0x2an)));
             if (t !== 'ok') {
                 throw result;
             }
             const file = state.root.hello;
-            if (!isVec(file)) {
+            if (!Array.isArray(file)) {
                 throw file;
             }
-            if (uint(file) !== 0x2an) {
+            if (uint(file[0]) !== 0x2an) {
                 throw file;
             }
         },
@@ -300,7 +300,7 @@ export const proof = {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (tmp === undefined || isVec(tmp)) {
+            if (tmp === undefined || Array.isArray(tmp)) {
                 throw tmp;
             }
         },
@@ -311,10 +311,10 @@ export const proof = {
             throw result;
         }
         const file = state.root.hello;
-        if (!isVec(file)) {
+        if (!Array.isArray(file)) {
             throw file;
         }
-        if (utf8ToString(file) !== 'Hello, world!') {
+        if (utf8ToString(file[0]) !== 'Hello, world!') {
             throw file;
         }
     },
@@ -322,7 +322,7 @@ export const proof = {
         one: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { hello: vec8(0x2an) },
+                root: { hello: [vec8(0x2an)] },
             })(rm('hello'));
             if (t !== 'ok') {
                 throw result;
@@ -334,13 +334,13 @@ export const proof = {
         nested: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } },
+                root: { tmp: { cache: [vec8(0x15n)] } },
             })(rm('tmp/cache'));
             if (t !== 'ok') {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object') {
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
                 throw state.root;
             }
             if (tmp.cache !== undefined) {
@@ -376,8 +376,8 @@ export const proof = {
         const [_, results] = virtual({
             ...emptyState,
             root: {
-                a: vec8(0x2an),
-                b: vec8(0x15n),
+                a: [vec8(0x2an)],
+                b: [vec8(0x15n)],
             },
         })(both(readFile('a'))(readFile('b')));
         if (results[0][0] !== 'ok') {
@@ -442,4 +442,115 @@ export const proof = {
             }
         },
     },
+    rename: {
+        fileOverFile: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { src: [vec8(0x2an)], dst: [vec8(0x15n)] },
+            })(rename('src', 'dst'));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (state.root.src !== undefined) {
+                throw state.root;
+            }
+            if (!Array.isArray(state.root.dst)) {
+                throw state.root;
+            }
+            if (uint(state.root.dst[0]) !== 0x2an) {
+                throw state.root;
+            }
+        },
+        nestedRename: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { tmp: { src: [vec8(0x2an)] } },
+            })(rename('tmp/src', 'tmp/dst'));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const tmp = state.root.tmp;
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
+                throw state.root;
+            }
+            if (tmp.src !== undefined) {
+                throw tmp;
+            }
+        },
+        dirOverFile: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { src: {}, dst: [vec8(0x15n)] },
+            })(rename('src', 'dst'));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (!Array.isArray(state.root.dst)) {
+                throw state.root;
+            }
+        },
+        missingSource: () => {
+            const [_, [t, result]] = virtual(emptyState)(rename('missing', 'dst'));
+            if (t !== 'error') {
+                throw result;
+            }
+        },
+    },
+    readBytes: {
+        simple: () => {
+            const [_, [t, result]] = virtual({
+                ...emptyState,
+                root: { file: [vec8(0xabn)] },
+            })(readBytes('file', 0, 1));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (!isVec(result)) {
+                throw result;
+            }
+        },
+        withOffset: () => {
+            const [_, [t, result]] = virtual({
+                ...emptyState,
+                root: { file: [vec8(0xabn), vec8(0xcdn)] },
+            })(readBytes('file', 1, 1));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (!isVec(result)) {
+                throw result;
+            }
+        },
+        oversizeChunk: () => {
+            const [_, [t, result]] = virtual({
+                ...emptyState,
+                root: { file: [vec8(0x2an)] },
+            })(readBytes('file', 0, Number(2n ** 32n)));
+            if (t !== 'error') {
+                throw result;
+            }
+        },
+        missingFile: () => {
+            const [_, [t, result]] = virtual(emptyState)(readBytes('missing', 0, 4));
+            if (t !== 'error') {
+                throw result;
+            }
+        },
+    },
+    randomInt: {
+        increments: () => {
+            const [state1, r1] = virtual(emptyState)(randomInt());
+            if (r1 !== 0) {
+                throw r1;
+            }
+            const [state2, r2] = virtual(state1)(randomInt());
+            if (r2 !== 1) {
+                throw r2;
+            }
+            const [_, r3] = virtual(state2)(randomInt());
+            if (r3 !== 2) {
+                throw r3;
+            }
+        },
+    },
 };

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

@@ -1,6 +1,6 @@
 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';
+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
@@ -10,7 +10,7 @@ import type { Module, NodeOp } from '../module.f.ts';
  * each import for closures/state.
  */
 export type JsModule = () => Module;
-export type Entity = Vec | Dir | JsModule;
+export type Entity = readonly Vec[] | Dir | JsModule;
 export type Dir = {
     readonly [name in string]?: Entity;
 };
@@ -28,6 +28,22 @@ export type State = {
     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;

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

@@ -6,7 +6,7 @@
 import { todo } from "../../../asserts/module.f.js";
 import { join, parse } from "../../../path/module.f.js";
 import { utf8ToString } from "../../../text/module.f.js";
-import { isVec } from "../../../types/bit_vec/module.f.js";
+import { empty, length, maxLengthBytes, msb, vec } from "../../../types/bit_vec/module.f.js";
 import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
 import { asBase, asNominal } from "../../memory/module.f.js";
@@ -19,6 +19,7 @@ export const emptyState = {
     epochNs: 0,
     memoryNext: 0,
     memoryValues: {},
+    randomNext: 0,
 };
 const operation = (op) => {
     const f = (dir, path) => {
@@ -27,7 +28,7 @@ const operation = (op) => {
         }
         const [first, ...rest] = path;
         const subDir = dir[first];
-        if (typeof subDir !== 'object') {
+        if (typeof subDir !== 'object' || Array.isArray(subDir)) {
             return op(dir, path);
         }
         const [newSubDir, r] = f(subDir, rest);
@@ -66,11 +67,23 @@ const readFile = readOperation((dir, path) => {
     if (file === undefined) {
         return enoent;
     }
-    // exists but is a directory — a real error, not a missing path
-    if (!isVec(file)) {
+    if (!Array.isArray(file)) {
         return error(`'${path[0]}' is not a file`);
     }
-    return ok(file);
+    const chunks = file;
+    const capBits = maxLengthBytes * 8n;
+    let result = empty;
+    for (const chunk of chunks) {
+        const chunkLen = length(chunk);
+        if (chunkLen === 0n) {
+            continue;
+        }
+        if (length(result) + chunkLen > capBits) {
+            return error(`File size exceeds maximum allowed size of ${maxLengthBytes} bytes`);
+        }
+        result = msb.concat(result)(chunk);
+    }
+    return ok(result);
 });
 const import_ = readOperation((dir, path) => {
     if (path.length !== 1) {
@@ -89,11 +102,10 @@ const writeFile = (payload) => operation((dir, path) => {
     }
     const [name] = path;
     const file = dir[name];
-    // fail if the file is a directory
-    if (file !== undefined && !isVec(file)) {
+    if (file !== undefined && !Array.isArray(file)) {
         return [dir, writeFileError];
     }
-    dir = { ...dir, [name]: payload };
+    dir = { ...dir, [name]: [payload] };
     return [dir, okVoid];
 });
 const invalidPath = error('invalid path');
@@ -108,7 +120,7 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
             if (content === undefined) {
                 continue;
             }
-            const isFile = typeof content !== 'object';
+            const isFile = Array.isArray(content) || typeof content !== 'object';
             result = [...result, { name, parentPath, isFile }];
             if (!isFile && recursive) {
                 result = [...result, ...f(join(parentPath, name), content)];
@@ -136,12 +148,148 @@ const rm = operation((dir, path) => {
     if (entry === undefined) {
         return [dir, error('no such file')];
     }
-    if (typeof entry === 'object') {
+    if (!Array.isArray(entry) && typeof entry === 'object') {
         return [dir, error('is a directory')];
     }
     const { [name]: _, ...rest } = dir;
     return [rest, okVoid];
 });
+const extractEntity = (dir, path) => {
+    if (path.length === 0) {
+        return [dir, error('cannot extract root')];
+    }
+    if (path.length === 1) {
+        const [name] = path;
+        const entry = dir[name];
+        if (entry === undefined) {
+            return [dir, enoent];
+        }
+        const { [name]: _, ...rest } = dir;
+        return [rest, ok(entry)];
+    }
+    const [first, ...rest] = path;
+    const sub = dir[first];
+    if (sub === undefined || Array.isArray(sub) || typeof sub === 'function') {
+        return [dir, enoent];
+    }
+    const [newSub, result] = extractEntity(sub, rest);
+    if (result[0] === 'error') {
+        return [dir, result];
+    }
+    return [{ ...dir, [first]: newSub }, result];
+};
+const insertEntityAt = (dir, path, entity) => {
+    if (path.length === 0) {
+        return [dir, error('cannot insert at root')];
+    }
+    if (path.length === 1) {
+        const [name] = path;
+        const existing = dir[name];
+        if (existing !== undefined) {
+            const entityIsDir = !Array.isArray(entity) && typeof entity === 'object';
+            const existingIsDir = !Array.isArray(existing) && typeof existing === 'object';
+            if (entityIsDir && !existingIsDir) {
+                return [dir, error(`cannot overwrite file '${name}' with a directory`)];
+            }
+            if (!entityIsDir && existingIsDir) {
+                return [dir, error(`'${name}' is a directory`)];
+            }
+            if (entityIsDir && existingIsDir) {
+                const existingDir = existing;
+                const hasContent = Object.values(existingDir).some(v => v !== undefined);
+                if (hasContent) {
+                    return [dir, error(`cannot overwrite non-empty directory '${name}'`)];
+                }
+            }
+        }
+        return [{ ...dir, [name]: entity }, okVoid];
+    }
+    const [first, ...rest] = path;
+    const sub = dir[first];
+    if (sub === undefined) {
+        return [dir, enoent];
+    }
+    if (Array.isArray(sub) || typeof sub === 'function') {
+        return [dir, error('not a directory')];
+    }
+    const [newSub, result] = insertEntityAt(sub, rest, entity);
+    if (result[0] === 'error') {
+        return [dir, result];
+    }
+    return [{ ...dir, [first]: newSub }, result];
+};
+const isProperPrefix = (prefix, path) => prefix.length < path.length && prefix.every((seg, i) => seg === path[i]);
+const rename = (src, dst) => (state) => {
+    const srcParsed = parse(src);
+    const dstParsed = parse(dst);
+    // extract source first to report ENOENT if it's missing, before checking subtree guards
+    const [srcRoot, srcResult] = extractEntity(state.root, srcParsed);
+    if (srcResult[0] === 'error') {
+        return [state, srcResult];
+    }
+    // now that source exists, reject if dst is strictly inside src's subtree (rename into own descendant)
+    // or if src is strictly inside dst's subtree (rename onto own ancestor)
+    if (isProperPrefix(srcParsed, dstParsed) || isProperPrefix(dstParsed, srcParsed)) {
+        return [state, error('cannot rename a directory into its own subtree or onto an ancestor')];
+    }
+    const [dstRoot, dstResult] = insertEntityAt(srcRoot, dstParsed, srcResult[1]);
+    if (dstResult[0] === 'error') {
+        return [state, dstResult];
+    }
+    return [{ ...state, root: dstRoot }, okVoid];
+};
+const readBytesOp = (path, offset, size) => readOperation((dir, p) => {
+    if (p.length !== 1) {
+        return enoent;
+    }
+    const file = dir[p[0]];
+    if (typeof file === 'function') {
+        throw new Error(`'${p[0]}' is a JsModule; readBytes not supported`);
+    }
+    if (file === undefined) {
+        return enoent;
+    }
+    if (!Array.isArray(file)) {
+        return error(`'${p[0]}' is not a file`);
+    }
+    if (!Number.isInteger(offset)) {
+        return error(`Offset ${offset} is not an integer`);
+    }
+    if (!Number.isInteger(size)) {
+        return error(`Chunk size ${size} is not an integer`);
+    }
+    if (offset < 0) {
+        return error(`Offset ${offset} is negative`);
+    }
+    if (size < 0) {
+        return error(`Chunk size ${size} is negative`);
+    }
+    if (BigInt(size) > maxLengthBytes) {
+        return error(`Chunk size ${size} exceeds maximum allowed size of ${maxLengthBytes} bytes`);
+    }
+    const chunks = file;
+    let toSkip = BigInt(offset) * 8n;
+    let toRead = BigInt(size) * 8n;
+    let result = empty;
+    for (const chunk of chunks) {
+        if (toRead === 0n) {
+            break;
+        }
+        const chunkBits = length(chunk);
+        if (toSkip >= chunkBits) {
+            toSkip -= chunkBits;
+            continue;
+        }
+        const skipInChunk = toSkip;
+        const availableBits = chunkBits - skipInChunk;
+        const takeBits = availableBits <= toRead ? availableBits : toRead;
+        const taken = vec(takeBits)(msb.front(takeBits)(msb.removeFront(skipInChunk)(chunk)));
+        result = msb.concat(result)(taken);
+        toSkip = 0n;
+        toRead -= takeBits;
+    }
+    return ok(result);
+})(path);
 const map = {
     all: (...a) => state => {
         let e = [];
@@ -180,6 +328,9 @@ const map = {
     access,
     import: import_,
     rm,
+    rename,
+    readBytes: readBytesOp,
+    randomInt: () => state => [{ ...state, randomNext: state.randomNext + 1 }, state.randomNext],
     exec: todo,
     createServer: todo,
     listen: todo,
@@ -207,3 +358,27 @@ const map = {
     },
 };
 export const virtual = run(map);
+const testContext = { test: todo };
+/**
+ * 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 const defaultNodeProgramOptions = {
+    args: [],
+    env: {},
+    home: '.',
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext,
+    bunTestContext: testContext,
+    playwrightTestContext: testContext,
+    engine: 'node',
+};

package/fs/effects/node/virtual/proof.f.d.ts

@@ -14,4 +14,18 @@ export declare const proof: {
     throw: {
         readFileOnJsModule: () => void;
     };
+    renameSamePath: () => void;
+    renameIntoOwnSubtree: () => void;
+    renameOntoOwnAncestor: () => void;
+    renameNonEmptyDirOverEmptyDir: () => void;
+    renameEmptyDirOverNonEmptyDir: () => void;
+    renameFileOntoDirectory: () => void;
+    readFileTooLarge: () => void;
+    readBytesNegativeSize: () => void;
+    readBytesZeroSize: () => void;
+    readBytesNegativeOffset: () => void;
+    readBytesFractionalSize: () => void;
+    readBytesFractionalOffset: () => void;
+    readBytesAcrossChunkBoundary: () => void;
+    largeFileReadBytes: () => void;
 };