functionalscript 0.43.1 → 0.44.0

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

@@ -1,440 +0,0 @@
-/**
- * Virtual Node-effect operations for filesystem and process tests.
- *
- * @module
- */
-import { todo } from '../../../asserts/module.f.js';
-import { isProperPrefix, join, parse } from '../../../path/module.f.js';
-import { utf8ToString } from '../../../text/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';
-export const emptyState = {
-    stdout: '',
-    stderr: '',
-    stdin: [],
-    root: {},
-    internet: {},
-    epochNs: 0,
-    memoryNext: 0,
-    memoryValues: {},
-    randomNext: 0,
-};
-const operation = (op) => {
-    const f = (dir, path) => {
-        if (path.length === 0) {
-            return op(dir, path);
-        }
-        const [first, ...rest] = path;
-        const subDir = dir[first];
-        if (typeof subDir !== 'object' || Array.isArray(subDir)) {
-            return op(dir, path);
-        }
-        const [newSubDir, r] = f(subDir, rest);
-        return [{ ...dir, [first]: newSubDir }, r];
-    };
-    return (path) => (state) => {
-        const [root, result] = f(state.root, parse(path));
-        return [{ ...state, root }, result];
-    };
-};
-const readOperation = (op) => operation((dir, path) => [dir, op(dir, path)]);
-const okVoid = ok(undefined);
-const mkdir = (recursive) => operation((dir, path) => {
-    let d = {};
-    let i = path.length;
-    if (i > 1 && !recursive) {
-        return [dir, error('non-recursive')];
-    }
-    while (i > 0) {
-        i -= 1;
-        d = { [path[i]]: d };
-    }
-    dir = { ...dir, ...d };
-    return [dir, okVoid];
-});
-/** Absent-path error mirroring Node's `ENOENT`, so `isNotFound` recognizes it. */
-const enoent = error({ code: 'ENOENT' });
-const readFile = readOperation((dir, path) => {
-    if (path.length !== 1) {
-        return enoent;
-    }
-    const file = dir[path[0]];
-    if (typeof file === 'function') {
-        throw new Error(`'${path[0]}' is a JsModule; readFile not supported`);
-    }
-    if (file === undefined) {
-        return enoent;
-    }
-    if (!Array.isArray(file)) {
-        return error(`'${path[0]}' is not a 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) {
-        return error('no such file');
-    }
-    const entry = dir[path[0]];
-    if (typeof entry !== 'function') {
-        return error(`'${path[0]}' is not a JsModule`);
-    }
-    return ok(entry());
-});
-const writeFileError = error('invalid file');
-const writeFile = (payload) => operation((dir, path) => {
-    if (path.length !== 1) {
-        return [dir, writeFileError];
-    }
-    const [name] = path;
-    const file = dir[name];
-    if (file !== undefined && !Array.isArray(file)) {
-        return [dir, writeFileError];
-    }
-    dir = { ...dir, [name]: [payload] };
-    return [dir, okVoid];
-});
-const invalidPath = error('invalid path');
-const { entries } = Object;
-const readdir = (base, recursive) => readOperation((dir, path) => {
-    if (path.length !== 0) {
-        return invalidPath;
-    }
-    const f = (parentPath, d) => {
-        let result = [];
-        for (const [name, content] of entries(d)) {
-            if (content === undefined) {
-                continue;
-            }
-            const isFile = Array.isArray(content) || typeof content !== 'object';
-            result = [...result, { name, parentPath, isFile }];
-            if (!isFile && recursive) {
-                result = [...result, ...f(join(parentPath, name), content)];
-            }
-        }
-        return result;
-    };
-    return ok(f(base, dir));
-});
-const access = readOperation((dir, path) => {
-    if (path.length === 0) {
-        return okVoid;
-    }
-    if (path.length !== 1) {
-        return enoent;
-    }
-    return dir[path[0]] !== undefined ? okVoid : enoent;
-});
-const rm = operation((dir, path) => {
-    if (path.length !== 1) {
-        return [dir, error('invalid path')];
-    }
-    const [name] = path;
-    const entry = dir[name];
-    if (entry === undefined) {
-        return [dir, error('no such file')];
-    }
-    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 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);
-/** Total byte size of a chunk-list file (each chunk is byte-aligned). */
-const fileSizeBytes = (chunks) => chunks.reduce((acc, c) => acc + Number(length(c) / 8n), 0);
-/** Absent-path error for an already-existing exclusive create, mirroring `EEXIST`. */
-const eexist = error({ code: 'EEXIST' });
-const createExclusive = operation((dir, path) => {
-    if (path.length !== 1) {
-        return [dir, invalidPath];
-    }
-    const [name] = path;
-    // O_EXCL: fail if the name is already taken; otherwise create an empty file.
-    if (dir[name] !== undefined) {
-        return [dir, eexist];
-    }
-    return [{ ...dir, [name]: [] }, okVoid];
-});
-// The lock-free upload only ever writes sequentially at the current end of the
-// staging file (`offset === size`), so the virtual model implements that append
-// case exactly: it never creates (a missing file is `ENOENT`), never overwrites
-// existing bytes, and never leaves a hole — matching the effect's contract for
-// the one access pattern its callers use.
-const writeBytesOp = (path, offset, data) => operation((dir, p) => {
-    if (p.length !== 1) {
-        return [dir, enoent];
-    }
-    const [name] = p;
-    const file = dir[name];
-    if (file === undefined) {
-        return [dir, enoent];
-    } // writeBytes never creates
-    if (!Array.isArray(file)) {
-        return [dir, error(`'${name}' is not a file`)];
-    }
-    if (!Number.isInteger(offset) || offset < 0) {
-        return [dir, error(`Offset ${offset} is invalid`)];
-    }
-    const chunks = file;
-    if (offset !== fileSizeBytes(chunks)) {
-        return [dir, error(`writeBytes offset ${offset} must equal the file size (append-only)`)];
-    }
-    return [{ ...dir, [name]: [...chunks, data] }, okVoid];
-})(path);
-const statOp = readOperation((dir, path) => {
-    if (path.length !== 1) {
-        return enoent;
-    }
-    const file = dir[path[0]];
-    if (file === undefined) {
-        return enoent;
-    }
-    if (!Array.isArray(file)) {
-        return error(`'${path[0]}' is not a file`);
-    }
-    return ok({ size: fileSizeBytes(file) });
-});
-const map = {
-    all: (...a) => state => {
-        let e = [];
-        for (const i of a) {
-            const [ns, ei] = virtual(state)(i);
-            state = ns;
-            e = [...e, ei];
-        }
-        return [state, e];
-    },
-    memCreate: value => state => {
-        const id = `mem${state.memoryNext}`;
-        const key = asNominal(id);
-        return [{
-                ...state,
-                memoryNext: state.memoryNext + 1,
-                memoryValues: { ...state.memoryValues, [id]: value },
-            }, key];
-    },
-    memRead: key => state => [state, state.memoryValues[asBase(key)]],
-    memWrite: (key, value) => state => {
-        const id = asBase(key);
-        return [{
-                ...state,
-                memoryValues: { ...state.memoryValues, [id]: value },
-            }, undefined];
-    },
-    fetch: url => state => {
-        const result = state.internet[url];
-        return result === undefined ? [state, error('not found')] : [state, ok(result)];
-    },
-    mkdir: (path, p) => mkdir(p !== undefined)(path),
-    readFile,
-    readdir: (path, { recursive }) => readdir(path, recursive === true)(path),
-    writeFile: (path, payload) => writeFile(payload)(path),
-    access,
-    import: import_,
-    rm,
-    rename,
-    readBytes: readBytesOp,
-    createExclusive,
-    writeBytes: writeBytesOp,
-    stat: statOp,
-    randomInt: () => state => [{ ...state, randomNext: state.randomNext + 1 }, state.randomNext],
-    exec: todo,
-    createServer: todo,
-    listen: todo,
-    forever: todo,
-    now: () => state => [state, state.epochNs],
-    // Virtual sandbox is a pass-through: the fixture's test function is
-    // expected to return a `SandboxResult` directly (encoding pass/fail and a
-    // chosen duration), so the handler invokes it without try/catch or clock
-    // reads. This makes test outcomes deterministic — fixtures dictate the
-    // result instead of the runner measuring real execution. A genuine
-    // exception in a fixture propagates loudly as a bug in the fixture.
-    // See: issues/156-tf-virtual-tests.md
-    sandbox: f => state => [state, f()],
-    await: p => state => [state, [p]],
-    test: todo,
-    write: (stream, data) => state => {
-        const s = utf8ToString(data);
-        return [{ ...state, [stream]: `${state[stream]}${s}` }, undefined];
-    },
-    read: () => state => {
-        const [first, ...rest] = state.stdin;
-        return state.stdin.length === 0
-            ? [state, null]
-            : [{ ...state, stdin: rest }, first];
-    },
-};
-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,
-    engine: 'node',
-    inlineTestContext: false,
-};

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

@@ -1,33 +0,0 @@
-export declare const proof: {
-    rm: {
-        success: () => void;
-        notFound: () => void;
-        isDirectory: () => void;
-    };
-    writeFileOnDirectory: () => void;
-    readdirRecursive: () => void;
-    accessNestedPathThroughFile: () => void;
-    readFileIntoDir: () => void;
-    awaitNonPromise: () => void;
-    fetchNotFound: () => void;
-    importNestedPath: () => void;
-    importNonModule: () => void;
-    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;
-    writeBytesWrongOffset: () => void;
-    largeFileReadBytes: () => void;
-};

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

@@ -1,186 +0,0 @@
-import { assert, assertEq } from '../../../asserts/module.f.js';
-import { access, awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes, writeBytes } from '../module.f.js';
-import { maxLengthBytes, vec, vec8 } from '../../../types/bit_vec/module.f.js';
-import { emptyState, virtual } from './module.f.js';
-export const proof = {
-    rm: {
-        success: () => {
-            const root = { 'a.txt': [vec8(0x42n)] };
-            const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
-            assert(result[0] === 'ok');
-        },
-        notFound: () => {
-            const [, result] = virtual(emptyState)(rm('notexist.txt'));
-            assert(result[0] === 'error');
-        },
-        isDirectory: () => {
-            const inner = {};
-            const root = { 'mydir': inner };
-            const [, result] = virtual({ ...emptyState, root })(rm('mydir'));
-            assert(result[0] === 'error');
-        },
-    },
-    writeFileOnDirectory: () => {
-        const inner = {};
-        const root = { 'mydir': inner };
-        const [, result] = virtual({ ...emptyState, root })(writeFile('mydir', vec8(0x42n)));
-        assert(result[0] === 'error');
-    },
-    readdirRecursive: () => {
-        const file = [vec8(0x42n)];
-        const sub = { 'file.txt': file };
-        const outer = { 'sub': sub };
-        const root = { 'mydir': outer };
-        const [, result] = virtual({ ...emptyState, root })(readdir('mydir', { recursive: true }));
-        assert(result[0] === 'ok');
-        assert(result[0] === 'ok', result);
-        assertEq(result[1].length, 2);
-    },
-    accessNestedPathThroughFile: () => {
-        // 'a/b/c' where 'a' is a file: the operation wrapper's "not a directory"
-        // fallback passes the full remaining path through unchanged, covering the
-        // path.length !== 1 branch of the access op (only path.length === 0 was
-        // otherwise exercised).
-        const root = { 'a': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(access('a/b/c'));
-        assert(result[0] === 'error');
-    },
-    readFileIntoDir: () => {
-        // 'a/b' where both 'a' and 'b' are directories
-        // hits path.length === 0 in operation's f and path.length !== 1 in readFile op
-        const inner = {};
-        const outer = { 'b': inner };
-        const root = { 'a': outer };
-        const [, result] = virtual({ ...emptyState, root })(readFile('a/b'));
-        assert(result[0] === 'error');
-    },
-    awaitNonPromise: () => {
-        // a non-promise value passes through the virtual `await` handler as-is
-        const [, result] = virtual(emptyState)(awaitIfPromise(42));
-        assertEq(result, 42);
-    },
-    fetchNotFound: () => {
-        // covers the `result === undefined` branch of the `fetch` handler
-        const [, result] = virtual(emptyState)(fetch('https://example.com/missing'));
-        assert(result[0] === 'error');
-    },
-    importNestedPath: () => {
-        // import_ on a path whose parent does not exist covers the
-        // path.length !== 1 branch of the import_ op
-        const [, result] = virtual(emptyState)(import_('a/b'));
-        assert(result[0] === 'error');
-    },
-    importNonModule: () => {
-        // import_ on a Vec (not a JsModule) covers typeof entry !== 'function' branch
-        const root = { 'module.f.ts': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(import_('module.f.ts'));
-        assert(result[0] === 'error');
-    },
-    throw: {
-        readFileOnJsModule: () => {
-            // readFile on a JsModule path covers typeof file === 'function' branch
-            const root = { 'a.f.ts': (() => ({})) };
-            virtual({ ...emptyState, root })(readFile('a.f.ts'));
-        },
-    },
-    renameSamePath: () => {
-        // rename('a', 'a') should succeed as a no-op, not reject
-        const root = { 'a': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(rename('a', 'a'));
-        assert(result[0] === 'ok');
-    },
-    renameIntoOwnSubtree: () => {
-        // rename('a', 'a/b') should fail (dst inside src's subtree)
-        const root = { 'a': { 'b': [vec8(0x42n)] } };
-        const [, result] = virtual({ ...emptyState, root })(rename('a', 'a/b'));
-        assert(result[0] === 'error');
-    },
-    renameOntoOwnAncestor: () => {
-        // rename('a/b', 'a') should fail (src inside dst's subtree)
-        const root = { 'a': { 'b': [vec8(0x42n)] } };
-        const [, result] = virtual({ ...emptyState, root })(rename('a/b', 'a'));
-        assert(result[0] === 'error');
-    },
-    renameNonEmptyDirOverEmptyDir: () => {
-        // rename a directory onto an empty directory should succeed
-        const root = { 'src': { 'file': [vec8(0x42n)] }, 'dst': {} };
-        const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assert(result[0] === 'ok');
-    },
-    renameEmptyDirOverNonEmptyDir: () => {
-        // rename an empty directory onto a non-empty directory should fail
-        const root = { 'src': {}, 'dst': { 'file': [vec8(0x42n)] } };
-        const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assert(result[0] === 'error');
-    },
-    renameFileOntoDirectory: () => {
-        // rename a file to a path that is already an existing directory should fail
-        const root = { 'myfile': [vec8(0x42n)], 'mydir': {} };
-        const [, result] = virtual({ ...emptyState, root })(rename('myfile', 'mydir'));
-        assert(result[0] === 'error');
-    },
-    readFileTooLarge: () => {
-        // a file stored as two max-size chunks exceeds the limit; readFile must return an error
-        const chunk0 = vec(maxLengthBytes * 8n)(0n);
-        const chunk1 = vec(1n)(1n);
-        const root = { 'big': [chunk0, chunk1] };
-        const [, result] = virtual({ ...emptyState, root })(readFile('big'));
-        assert(result[0] === 'error');
-    },
-    readBytesNegativeSize: () => {
-        // readBytes with negative size should fail
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, -1));
-        assert(result[0] === 'error');
-    },
-    readBytesZeroSize: () => {
-        // readBytes with zero size should succeed and return empty vec
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 0));
-        assert(result[0] === 'ok');
-    },
-    readBytesNegativeOffset: () => {
-        // readBytes with negative offset should fail
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('file', -1, 1));
-        assert(result[0] === 'error');
-    },
-    readBytesFractionalSize: () => {
-        // readBytes with fractional size should fail rather than throw RangeError
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 1.5));
-        assert(result[0] === 'error');
-    },
-    readBytesFractionalOffset: () => {
-        // readBytes with fractional offset should fail rather than throw RangeError
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0.5, 1));
-        assert(result[0] === 'error');
-    },
-    readBytesAcrossChunkBoundary: () => {
-        // Two 128 KiB chunks; read 2 bytes spanning the boundary (last byte of chunk 0, first of chunk 1).
-        const chunkSize = Number(maxLengthBytes);
-        const chunk0 = vec(maxLengthBytes * 8n)(0xaan);
-        const chunk1 = vec(maxLengthBytes * 8n)(0xbbn);
-        const root = { 'big': [chunk0, chunk1] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('big', chunkSize - 1, 2));
-        assert(result[0] === 'ok');
-    },
-    writeBytesWrongOffset: () => {
-        // writeBytes is append-only; an offset that doesn't match the current
-        // file size must fail rather than silently create a hole.
-        const root = { 'file': [vec8(0x42n)] };
-        const [, result] = virtual({ ...emptyState, root })(writeBytes('file', 5, vec8(0x43n)));
-        assert(result[0] === 'error');
-    },
-    largeFileReadBytes: () => {
-        // A file stored as two 128 KiB chunks is larger than maxLengthBytes.
-        // readBytes within the second chunk (offset = 128 KiB, size = 1) should succeed.
-        const chunkSize = Number(maxLengthBytes);
-        const chunk0 = vec(maxLengthBytes * 8n)(0n);
-        const chunk1 = vec(maxLengthBytes * 8n)(0xffn);
-        const root = { 'large': [chunk0, chunk1] };
-        const [, result] = virtual({ ...emptyState, root })(readBytes('large', chunkSize, 1));
-        assert(result[0] === 'ok');
-    },
-};