functionalscript 0.32.4 → 0.33.0

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, length, maxLengthBytes, msb, vec } 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";
@@ -28,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);
@@ -67,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) {
@@ -90,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');
@@ -109,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)];
@@ -137,7 +148,7 @@ 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;
@@ -158,7 +169,7 @@ const extractEntity = (dir, path) => {
     }
     const [first, ...rest] = path;
     const sub = dir[first];
-    if (sub === undefined || isVec(sub) || typeof sub === 'function') {
+    if (sub === undefined || Array.isArray(sub) || typeof sub === 'function') {
         return [dir, enoent];
     }
     const [newSub, result] = extractEntity(sub, rest);
@@ -175,8 +186,8 @@ const insertEntityAt = (dir, path, entity) => {
         const [name] = path;
         const existing = dir[name];
         if (existing !== undefined) {
-            const entityIsDir = typeof entity === 'object';
-            const existingIsDir = typeof existing === 'object';
+            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`)];
             }
@@ -198,7 +209,7 @@ const insertEntityAt = (dir, path, entity) => {
     if (sub === undefined) {
         return [dir, enoent];
     }
-    if (isVec(sub) || typeof sub === 'function') {
+    if (Array.isArray(sub) || typeof sub === 'function') {
         return [dir, error('not a directory')];
     }
     const [newSub, result] = insertEntityAt(sub, rest, entity);
@@ -238,7 +249,7 @@ const readBytesOp = (path, offset, size) => readOperation((dir, p) => {
     if (file === undefined) {
         return enoent;
     }
-    if (!isVec(file)) {
+    if (!Array.isArray(file)) {
         return error(`'${p[0]}' is not a file`);
     }
     if (!Number.isInteger(offset)) {
@@ -256,11 +267,28 @@ const readBytesOp = (path, offset, size) => readOperation((dir, p) => {
     if (BigInt(size) > maxLengthBytes) {
         return error(`Chunk size ${size} exceeds maximum allowed size of ${maxLengthBytes} bytes`);
     }
-    const offsetBits = BigInt(offset) * 8n;
-    const sizeBits = BigInt(size) * 8n;
-    const remaining = msb.removeFront(offsetBits)(file);
-    const actualSizeBits = sizeBits < length(remaining) ? sizeBits : length(remaining);
-    return ok(vec(actualSizeBits)(msb.front(actualSizeBits)(remaining)));
+    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 => {
@@ -330,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

@@ -19,9 +19,13 @@ export declare const proof: {
     renameOntoOwnAncestor: () => void;
     renameNonEmptyDirOverEmptyDir: () => void;
     renameEmptyDirOverNonEmptyDir: () => void;
+    renameFileOntoDirectory: () => void;
+    readFileTooLarge: () => void;
     readBytesNegativeSize: () => void;
     readBytesZeroSize: () => void;
     readBytesNegativeOffset: () => void;
     readBytesFractionalSize: () => void;
     readBytesFractionalOffset: () => void;
+    readBytesAcrossChunkBoundary: () => void;
+    largeFileReadBytes: () => void;
 };

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_, rename, readBytes } from "../module.f.js";
-import { vec8 } from "../../../types/bit_vec/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');
     },
@@ -78,62 +78,95 @@ export const proof = {
     },
     renameSamePath: () => {
         // rename('a', 'a') should succeed as a no-op, not reject
-        const root = { 'a': vec8(0x42n) };
+        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 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 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 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 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 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 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 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 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 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.4",
+  "version": "0.33.0",
   "type": "module",
   "files": [
     "**/*.js",