functionalscript 0.32.3 → 0.33.0

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

@@ -1,11 +1,11 @@
 import { assertEq } from "../../../asserts/module.f.js";
-import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_ } from "../module.f.js";
-import { vec8 } from "../../../types/bit_vec/module.f.js";
+import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes } 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 root = { 'a.txt': [vec8(0x42n)] };
             const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
             assertEq(result[0], 'ok');
         },
@@ -27,7 +27,7 @@ export const proof = {
         assertEq(result[0], 'error');
     },
     readdirRecursive: () => {
-        const file = vec8(0x42n);
+        const file = [vec8(0x42n)];
         const sub = { 'file.txt': file };
         const outer = { 'sub': sub };
         const root = { 'mydir': outer };
@@ -65,7 +65,7 @@ export const proof = {
     },
     importNonModule: () => {
         // import_ on a Vec (not a JsModule) covers typeof entry !== 'function' branch
-        const root = { 'module.f.ts': vec8(0x42n) };
+        const root = { 'module.f.ts': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(import_('module.f.ts'));
         assertEq(result[0], 'error');
     },
@@ -76,4 +76,97 @@ export const proof = {
             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'));
+        assertEq(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'));
+        assertEq(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'));
+        assertEq(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'));
+        assertEq(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'));
+        assertEq(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'));
+        assertEq(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'));
+        assertEq(result[0], 'error');
+    },
+    readBytesNegativeSize: () => {
+        // readBytes with negative size should fail
+        const root = { 'file': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, -1));
+        assertEq(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));
+        assertEq(result[0], 'ok');
+    },
+    readBytesNegativeOffset: () => {
+        // readBytes with negative offset should fail
+        const root = { 'file': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(readBytes('file', -1, 1));
+        assertEq(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));
+        assertEq(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));
+        assertEq(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));
+        assertEq(result[0], 'ok');
+    },
+    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));
+        assertEq(result[0], 'ok');
+    },
 };

package/fs/emergent_testing/proof.f.js

@@ -1,8 +1,7 @@
-import { pure } from "../effects/module.f.js";
 import { log } from "../effects/node/module.f.js";
-import { emptyState } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, 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 { assert, assertEq } from "../asserts/module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from "./module.f.js";
 import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
@@ -13,16 +12,9 @@ const makeReporter = () => ({
     summary: (pass, fail, time) => writeEvent(['summary', pass, fail, time]),
     test: defaultTest,
 });
-const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
-    args: [],
+    ...defaultNodeProgramOptions,
     env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTIONS: 'true' } : {}) },
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: noopTestContext,
-    bunTestContext: noopTestContext,
-    playwrightTestContext: noopTestContext,
-    engine: 'node',
 });
 const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
 const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });

package/fs/fjs/module.f.js

@@ -5,12 +5,12 @@
  */
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
-import { commands as casCommands } from "../cas/module.f.js";
+import { commands as casCommands, fileCas } from "../cas/module.f.js";
 import { main as ciMain } from "../ci/module.f.js";
 import { import_ } from "../effects/node/module.f.js";
 import { dispatch } from "../cli/module.f.js";
 import { casMcpServer } from "../cas/mcp/module.f.js";
-import { cas, fileKvStore, toPath } from "../cas/module.f.js";
+import { toPath } from "../cas/module.f.js";
 import { sha256 } from "../crypto/sha2/module.f.js";
 import { join } from "../path/module.f.js";
 import { pure } from "../effects/module.f.js";
@@ -34,7 +34,7 @@ const commands = [
         names: ['mcp', 'm'],
         description: 'Run an MCP server over stdio exposing the CAS as tools',
         handler: ({ home }) => {
-            const c = cas(sha256)(fileKvStore(home));
+            const c = fileCas(sha256)(home);
             return casMcpServer(c, home, hash => join(home, toPath(hash))).step(() => pure(0));
         },
     },

package/fs/fjs/proof.f.js

@@ -1,17 +1,8 @@
 import { assert, assertEq } from "../asserts/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { main } from "./module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
 const appMain = ({ args }) => pure(args.length);
 export const proof = {

package/fs/js/tokenizer/module.f.d.ts

@@ -95,4 +95,9 @@ export type JsTokenWithMetadata = {
 type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
 export declare const isKeywordToken: (token: JsToken) => boolean;
 export declare const tokenize: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
+export declare const proof: {
+    throw: {
+        unionConflict: () => void;
+    };
+};
 export {};

package/fs/js/tokenizer/module.f.js

@@ -27,6 +27,7 @@ leftSquareBracket, reverseSolidus, rightSquareBracket, lowLine,
 latinSmallLetterRange, latinSmallLetterA, latinSmallLetterB, latinSmallLetterE, latinSmallLetterF, latinSmallLetterN, latinSmallLetterR, latinSmallLetterT, latinSmallLetterU, 
 //
 leftCurlyBracket, rightCurlyBracket, dollarSign } from "../../text/ascii/module.f.js";
+import { todo } from "../../asserts/module.f.js";
 const { fromCharCode } = String;
 const rangeOneNine = range('19');
 const rangeSetNewLine = [
@@ -519,3 +520,15 @@ export const tokenize = input => path => {
     const scan = scanTokenize({ state: { kind: 'initial' }, metadata: { path, line: 1, column: 1 } });
     return flat(scan(flat([input /*satisfies List<CharCodeOrEof>*/, [null]])));
 };
+export const proof = {
+    throw: {
+        // union throws when two distinct non-default handlers are merged for the same range;
+        // this path is unreachable through the public API (no overlapping ranges in practice).
+        unionConflict: () => {
+            const def = (_) => todo;
+            const a = (_) => todo;
+            const b = (_) => todo;
+            union(def)(a)(b);
+        }
+    }
+};

package/fs/json/serializer/module.f.js

@@ -4,7 +4,6 @@
  * @module
  */
 import { flat, reduce, empty } from "../../types/list/module.f.js";
-import {} from "../../types/object/module.f.js";
 import {} from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
 /**

package/fs/text/sgr/proof.f.js

@@ -1,15 +1,6 @@
 import { fgRed, reset, createConsoleText, backspace, csiWrite } from "./module.f.js";
-import { virtual, emptyState } from "../../effects/node/virtual/module.f.js";
-const makeOptions = (isTTY) => ({
-    args: [],
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY }, stderr: { isTTY } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+import { virtual, emptyState, defaultNodeProgramOptions } from "../../effects/node/virtual/module.f.js";
+const makeOptions = (isTTY) => ({ ...defaultNodeProgramOptions, std: { stdout: { isTTY }, stderr: { isTTY } } });
 export const proof = [
     () => {
         if (fgRed !== '\x1b[31m') {

package/fs/types/bigint/module.f.d.ts

@@ -156,24 +156,17 @@ export declare const xor: Reduce;
 export declare const divUp: (b: bigint) => Unary;
 export declare const roundUp: (b: bigint) => Unary;
 /**
- * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Converts a bit count to a byte count, rounding up — divides by `8`.
  *
- * @param e - The exponent (divisor = 2^e).
- * @returns A function that rounds a value up by the given power of two.
- */
-export declare const divUpE2: (e: bigint) => Unary;
-/**
- * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
- *
- * @param e - The exponent (multiple = 2^e).
- * @returns A function that rounds a value up to the nearest multiple of the given power of two.
- */
-export declare const roundUpE2: (e: bigint) => Unary;
-/**
- * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
+ * Domain: non-negative inputs (bit/byte counts). On negative inputs `divUp`
+ * truncates toward zero rather than flooring toward −∞, so the rounding
+ * direction is only meaningful for `v >= 0n`.
  */
 export declare const divUp8: Unary;
 /**
- * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8`.
+ *
+ * Domain: non-negative inputs (bit/byte counts). See `divUp8` for the
+ * truncate-vs-floor caveat on negative values.
  */
 export declare const roundUp8: Unary;

package/fs/types/bigint/module.f.js

@@ -234,30 +234,17 @@ export const roundUp = (b) => {
     return v => d(v) * b;
 };
 /**
- * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Converts a bit count to a byte count, rounding up — divides by `8`.
  *
- * @param e - The exponent (divisor = 2^e).
- * @returns A function that rounds a value up by the given power of two.
+ * Domain: non-negative inputs (bit/byte counts). On negative inputs `divUp`
+ * truncates toward zero rather than flooring toward −∞, so the rounding
+ * direction is only meaningful for `v >= 0n`.
  */
-export const divUpE2 = (e) => {
-    const m = mask(e);
-    return v => (v + m) >> e;
-};
+export const divUp8 = divUp(8n);
 /**
- * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8`.
  *
- * @param e - The exponent (multiple = 2^e).
- * @returns A function that rounds a value up to the nearest multiple of the given power of two.
- */
-export const roundUpE2 = (e) => {
-    const d = divUpE2(e);
-    return v => d(v) << e;
-};
-/**
- * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
- */
-export const divUp8 = divUpE2(3n);
-/**
- * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ * Domain: non-negative inputs (bit/byte counts). See `divUp8` for the
+ * truncate-vs-floor caveat on negative values.
  */
-export const roundUp8 = roundUpE2(3n);
+export const roundUp8 = roundUp(8n);

package/fs/types/bigint/proof.f.d.ts

@@ -29,8 +29,6 @@ export declare const proof: {
     combination3: () => void;
     divUp: () => void;
     roundUp: () => void;
-    divUpE2: () => void;
-    roundUpE2: () => void;
     divUp8: () => void;
     roundUp8: () => void;
     xor: () => void;

package/fs/types/bigint/proof.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUpE2, roundUpE2, divUp8, roundUp8 } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUp8, roundUp8 } from "./module.f.js";
 import { assertEq } from "../../asserts/module.f.js";
 import { min } from "../function/compare/module.f.js";
 const oldLog2 = (v) => {
@@ -463,32 +463,22 @@ export const proof = {
         assertEq(roundUp(8n)(15n), 16n);
         assertEq(roundUp(8n)(3n), 8n);
     },
-    divUpE2: () => {
-        assertEq(divUpE2(3n)(8n), 1n);
-        assertEq(divUpE2(3n)(15n), 2n);
-        assertEq(divUpE2(3n)(0n), 0n);
-        assertEq(divUpE2(3n)(8n), 1n);
-        assertEq(divUpE2(3n)(9n), 2n);
-    },
-    roundUpE2: () => {
-        assertEq(roundUpE2(3n)(8n), 8n);
-        assertEq(roundUpE2(3n)(15n), 16n);
-        assertEq(roundUpE2(3n)(3n), 8n);
-        assertEq(roundUpE2(3n)(0n), 0n);
-        assertEq(roundUpE2(3n)(8n), 8n);
-        assertEq(roundUpE2(3n)(9n), 16n);
-    },
     divUp8: () => {
         assertEq(divUp8(0n), 0n);
         assertEq(divUp8(1n), 1n);
         assertEq(divUp8(8n), 1n);
+        assertEq(divUp8(8n), 1n);
         assertEq(divUp8(9n), 2n);
+        assertEq(divUp8(15n), 2n);
     },
     roundUp8: () => {
         assertEq(roundUp8(0n), 0n);
         assertEq(roundUp8(1n), 8n);
+        assertEq(roundUp8(3n), 8n);
+        assertEq(roundUp8(8n), 8n);
         assertEq(roundUp8(8n), 8n);
         assertEq(roundUp8(9n), 16n);
+        assertEq(roundUp8(15n), 16n);
     },
     xor: () => {
         assertEq(xor(5n)(3n), 6n);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.32.3",
+  "version": "0.33.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -44,7 +44,7 @@
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
     "@playwright/test": "1.61.0",
-    "@types/node": "25.9.3",
+    "@types/node": "26.0.0",
     "typescript": "6.0.3"
   }
 }