functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/types/uint8array/module.f.js

@@ -2,30 +2,30 @@
  * Conversions between `Uint8Array` values and bit vectors.
  *
  * @deprecated FunctionalScript represents byte data as `bigint`-based bit
- * vectors (`Vec` from `fs/types/bit_vec`). Use `utf8`/`utf8ToString` from
- * `fs/text` for string encoding, and the `bit_vec` module directly for raw
+ * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fjs/text` for string encoding, and the `bit_vec` module directly for raw
  * byte manipulation. `Uint8Array` interop belongs at Node.js boundaries only
  * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
  */
+import { assert, assertNotNullish } from '../../asserts/module.f.js';
 import { utf8, utf8ToString } from '../../text/module.f.js';
-import { maxLengthBytes, msb, u8List, u8ListToVec } from '../bit_vec/module.f.js';
+import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.js';
 import { compose } from '../function/module.f.js';
 import { flat, fromArrayLike, iterable, map } from '../list/module.f.js';
 const u8ListToVecMsb = u8ListToVec(msb);
+const tryU8ListToVecMsb = tryU8ListToVec(msb);
 const u8ListMsb = u8List(msb);
 /**
  * Converts a Uint8Array into an MSB-first bit vector.
  */
 export const toVec = (input) => {
-    if (input.length > maxLengthBytes) {
-        throw "the array is too big";
-    }
+    assert(input.length <= maxLengthBytes, "the array is too big");
     return u8ListToVecMsb(fromArrayLike(input));
 };
 const m = map(fromArrayLike);
-export const listToVec = (input) => u8ListToVecMsb(flat(m(input)));
+export const listToVec = (input) => assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big");
 /**
  * Converts an MSB-first bit vector into a Uint8Array.
  */

package/{fs → fjs}/types/uint8array/proof.f.d.ts

@@ -10,5 +10,8 @@ export declare const proof: {
     utf8RoundTrip: () => void;
     listToVec: () => void;
     maxLength: () => import("../bit_vec/module.f.ts").Vec;
-    throw: () => import("../bit_vec/module.f.ts").Vec;
+    throw: {
+        toVec: () => import("../bit_vec/module.f.ts").Vec;
+        listToVec: () => import("../bit_vec/module.f.ts").Vec;
+    };
 };

package/{fs → fjs}/types/uint8array/proof.f.js

@@ -2,15 +2,12 @@ import { maxLength, maxLengthBytes, vec } from '../bit_vec/module.f.js';
 import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from './module.f.js';
 import { strictEqual } from '../function/operator/module.f.js';
 import { equal, fromArrayLike } from '../list/module.f.js';
+import { assert } from '../../asserts/module.f.js';
 const assertEq = (a, b) => {
-    if (a !== b) {
-        throw [a, b];
-    }
+    assert(a === b, [a, b]);
 };
 const assertArrayEq = (a, b) => {
-    if (!equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b))) {
-        throw [a, b];
-    }
+    assert(equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b)), [a, b]);
 };
 export const proof = {
     empty: () => {
@@ -60,5 +57,8 @@ export const proof = {
         assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
     },
     maxLength: () => toVec(new Uint8Array(Number(maxLengthBytes))),
-    throw: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+    throw: {
+        toVec: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+        listToVec: () => listToVec([new Uint8Array(Number(maxLengthBytes)), Uint8Array.from([0])]),
+    },
 };

package/{fs → fjs}/website/module.f.js

@@ -5,11 +5,10 @@
  */
 import { htmlUtf8 } from '../media/html/module.f.js';
 import { writeFile } from '../effects/node/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 const html = htmlUtf8()(['a',
     { href: 'https://github.com/functionalscript/functionalscript' },
     'GitHub Repository'
 ]);
-const program = writeFile('index.html', html)
-    .step(() => pure(0));
+const program = step(writeFile('index.html', html), () => pure(0));
 export const main = () => program;

package/{fs → fjs}/website/proof.f.js

@@ -1,16 +1,13 @@
 import { main } from './module.f.js';
 import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
-import { assert } from '../asserts/module.f.js';
+import { assertEq, assertNotNullish } from '../asserts/module.f.js';
 export const proof = {
     main: () => {
-        const program = main();
-        if (program === undefined) {
-            throw 'expected a program effect';
-        }
+        assertNotNullish(main(), 'expected a program effect');
     },
     run: () => {
         const state = { ...emptyState, root: { '.github': { workflows: {} } } };
         const [_, result] = virtual(state)(main());
-        assert(result === 0, result);
+        assertEq(result, 0);
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,19 +9,19 @@
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
     "prepack": "tsc --NoEmit false",
-    "test": "tsc && node ./fs/module.ts t",
+    "test": "tsc && node ./fjs/module.ts t",
     "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
-    "start": "node ./fs/module.ts",
-    "ci-update": "node ./fs/module.ts ci",
+    "start": "node ./fjs/module.ts",
+    "ci-update": "node ./fjs/module.ts ci",
     "update": "npx npm-check-updates -u && npm install && deno install && bun install && npm run ci-update",
-    "index-html": "node ./fs/module.ts r ./fs/website/module.f.ts",
+    "index-html": "node ./fjs/module.ts r ./fjs/website/module.f.ts",
     "website": "npm run prepack && npm run index-html"
   },
   "engines": {
     "node": ">=22"
   },
   "bin": {
-    "fjs": "fs/module.js"
+    "fjs": "fjs/module.js"
   },
   "repository": {
     "type": "git",
@@ -43,8 +43,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@playwright/test": "1.61.1",
-    "@types/node": "26.1.1",
+    "@playwright/test": "1.62.0",
+    "@types/node": "26.1.2",
     "typescript": "7.0.2"
   }
 }

package/fs/asserts/module.f.d.ts

@@ -1,4 +0,0 @@
-export declare const todo: () => never;
-export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
-export type Assert<T extends true> = T;

package/fs/asserts/module.f.js

@@ -1,9 +0,0 @@
-export const todo = () => { throw 'not implemented'; };
-export const assert = (v, msg = 'assertion failed') => {
-    if (!v)
-        throw msg;
-};
-export const assertEq = (...x) => {
-    const [a, b] = x;
-    assert(a === b, x);
-};

package/fs/asserts/proof.f.d.ts

@@ -1,8 +0,0 @@
-export declare const proof: {
-    assertPassesOnTrue: () => void;
-    assertThrowsDefaultMsg: () => void;
-    assertThrowsCustomMsg: () => void;
-    assertEqPassesOnEqual: () => void;
-    assertEqThrowsOnUnequal: () => void;
-    todoThrows: () => void;
-};

package/fs/asserts/proof.f.js

@@ -1,51 +0,0 @@
-import { assert, assertEq, todo } from './module.f.js';
-const throws = (f, expected) => {
-    let caught = false;
-    try {
-        f();
-    }
-    catch (e) {
-        caught = true;
-        if (e !== expected) {
-            throw ['unexpected throw value', e];
-        }
-    }
-    if (!caught) {
-        throw 'expected function to throw but it did not';
-    }
-};
-export const proof = {
-    assertPassesOnTrue: () => {
-        assert(true);
-        assert(true, 'with message');
-    },
-    assertThrowsDefaultMsg: () => {
-        throws(() => assert(false), 'assertion failed');
-    },
-    assertThrowsCustomMsg: () => {
-        throws(() => assert(false, 'oops'), 'oops');
-    },
-    assertEqPassesOnEqual: () => {
-        assertEq(1, 1);
-        assertEq('x', 'x');
-    },
-    assertEqThrowsOnUnequal: () => {
-        let caught = false;
-        try {
-            assertEq(1, 2);
-        }
-        catch (e) {
-            caught = true;
-            const arr = e;
-            if (arr[0] !== 1 || arr[1] !== 2) {
-                throw ['wrong throw value', e];
-            }
-        }
-        if (!caught) {
-            throw 'expected assertEq to throw';
-        }
-    },
-    todoThrows: () => {
-        throws(() => todo(), 'not implemented');
-    },
-};

package/fs/bnf/data/module.f.d.ts

@@ -1,30 +0,0 @@
-import { type Rule as FRule } from '../module.f.ts';
-import { type StringMap } from '../../types/object/module.f.ts';
-/**
- * Encoded terminal range value used by BNF data rules.
- *
- * The same as the functional TerminalRange.
- */
-export type TerminalRange = number;
-/**
- * Ordered list of grammar rule names.
- */
-export type Sequence = readonly string[];
-/** A variant of rule names. */
-export type Variant = StringMap<string, string>;
-/**
- * Grammar rule definition.
- *
- * It can be one of:
- * - a tagged variant map,
- * - a sequence of referenced rule names,
- * - an encoded terminal range.
- */
-export type Rule = Variant | Sequence | TerminalRange;
-/** The full grammar */
-export type RuleSet = Readonly<Record<string, Rule>>;
-/**
- * Converts a functional grammar rule into serializable BNF data and returns
- * the generated rule set with the entry rule identifier.
- */
-export declare const toData: (fr: FRule) => readonly [RuleSet, string];

package/fs/bnf/descent/module.f.js

@@ -1,119 +0,0 @@
-/**
- * Recursive descent matcher backend over the BNF data {@link RuleSet}.
- *
- * Built from the serializable IR in `fs/bnf/data`, this is a sibling of the
- * LL(1) dispatch builder (`fs/bnf/ll1`). It walks the grammar by recursive
- * descent and preserves per-code-point metadata, producing a metadata-aware
- * AST ({@link AstRuleMeta}). It also exposes {@link createEmptyTagMap}, which
- * records whether each rule can match the empty input.
- *
- * @module
- */
-import {} from '../../text/utf16/module.f.js';
-import { rangeDecode } from '../module.f.js';
-import { contains as rangeContains } from '../../types/range/module.f.js';
-import { definedEntries } from '../../types/object/module.f.js';
-import { toData } from '../data/module.f.js';
-import {} from '../module.f.js';
-const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
-    if (name in map) {
-        return [ruleSet, map, map[name]];
-    }
-    const rule = ruleSet[name];
-    if (typeof rule === 'number') {
-        return [ruleSet, { ...map, [name]: false }, false];
-    }
-    else if (rule instanceof Array) {
-        map = { ...map, [name]: true };
-        let emptyTag = rule.length == 0;
-        for (const item of rule) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (emptyTag === false) {
-                emptyTag = itemEmptyTag !== false;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-    else {
-        map = { ...map, [name]: true };
-        const entries = definedEntries(rule);
-        let emptyTag = false;
-        for (const [tag, item] of entries) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (itemEmptyTag !== false) {
-                emptyTag = tag;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-};
-/**
- * Creates a map that describes whether each rule can consume empty input and,
- * for tagged variants, which tag represents the empty match.
- */
-export const createEmptyTagMap = (data) => {
-    return emptyTagMapAdd(data[0])({})(data[1])[1];
-};
-/**
- * Creates a recursive descent parser that preserves metadata for each consumed
- * code point.
- */
-export const descentParser = (fr) => {
-    const data = toData(fr);
-    const emptyTagMap = createEmptyTagMap(data);
-    const getEmptyTag = (name) => {
-        const res = emptyTagMap[name];
-        return res === false ? undefined : res;
-    };
-    const f = (name, tag, cp, idx) => {
-        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
-        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
-        const rule = data[0][name];
-        if (typeof rule === 'number') {
-            const emptyTag = getEmptyTag(name);
-            if (idx >= cp.length) {
-                return emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
-            }
-            const cpi = cp[idx];
-            const range = rangeDecode(rule);
-            if (rangeContains(range)(cpi[0])) {
-                return mrSuccess(tag, [cpi], idx + 1);
-            }
-            return mrFail(emptyTag, [], idx);
-        }
-        else if (rule instanceof Array) {
-            let seq = [];
-            let tidx = idx;
-            for (const item of rule) {
-                const m = f(item, undefined, cp, tidx);
-                const [astRule, success, nidx] = m;
-                tidx = nidx;
-                if (success === false) {
-                    return mrFail(tag, [], idx);
-                }
-                seq = [...seq, astRule];
-            }
-            return mrSuccess(tag, seq, tidx);
-        }
-        else {
-            const entries = definedEntries(rule);
-            const emptyTag = getEmptyTag(name);
-            let emptyResult = mrFail(emptyTag, [], idx);
-            for (const [tag, item] of entries) {
-                const m = f(item, tag, cp, idx);
-                if (m[1]) {
-                    if (idx !== m[2])
-                        return m;
-                    emptyResult = m;
-                }
-            }
-            return emptyResult;
-        }
-    };
-    const match = (name, cp) => {
-        return f(name, undefined, cp, 0);
-    };
-    return match;
-};

package/fs/bnf/proof.f.js

@@ -1,104 +0,0 @@
-import { classic, deterministic } from './testlib.f.js';
-import { rangeEncode, str, set, range, commaJoin0Plus, isEmpty, oneEncode, repeat1Plus, } from './module.f.js';
-export const proof = {
-    test: () => {
-        classic();
-        deterministic();
-    },
-    throw: {
-        rangeEncodeInvalid: [
-            () => { rangeEncode(-1, 0); },
-            () => { rangeEncode(0, -1); },
-            () => { rangeEncode(5, 3); },
-        ],
-        rangeInvalid: [
-            () => { range('a'); },
-            () => { range('abc'); },
-        ],
-    },
-    str: [
-        () => {
-            const result = str('a');
-            if (typeof result !== 'number') {
-                throw result;
-            }
-            if (result !== oneEncode(0x61)) {
-                throw result;
-            }
-        },
-        () => {
-            const result = str('ab');
-            if (!Array.isArray(result)) {
-                throw result;
-            }
-            if (result.length !== 2) {
-                throw result;
-            }
-        },
-    ],
-    set: () => {
-        const result = set('abc');
-        if (typeof result !== 'object' || result === null) {
-            throw result;
-        }
-        if (!('a' in result)) {
-            throw result;
-        }
-        if (!('b' in result)) {
-            throw result;
-        }
-        if (!('c' in result)) {
-            throw result;
-        }
-    },
-    commaJoin0Plus: () => {
-        const ws = '';
-        const item = 'x';
-        const result = commaJoin0Plus(ws)('[]', item);
-        if (!Array.isArray(result)) {
-            throw result;
-        }
-        if (result[0] !== '[') {
-            throw result;
-        }
-    },
-    isEmpty: [
-        () => { if (!isEmpty('')) {
-            throw 'empty string should be empty';
-        } },
-        () => { if (!isEmpty([])) {
-            throw 'empty array should be empty';
-        } },
-        () => { if (isEmpty('a')) {
-            throw 'non-empty string should not be empty';
-        } },
-        () => {
-            const f = () => '';
-            if (!isEmpty(f)) {
-                throw 'function returning empty string should be empty';
-            }
-        },
-    ],
-    repeat1Plus: [
-        () => {
-            const result = repeat1Plus('x');
-            if (result[0] !== 'x') {
-                throw result[0];
-            }
-            if (typeof result[1] !== 'function') {
-                throw 'expected repeat0Plus function';
-            }
-        },
-        () => {
-            const rule = 'ab';
-            const result = repeat1Plus(rule);
-            if (result[0] !== rule) {
-                throw result[0];
-            }
-            const inner = result[1]();
-            if (!('some' in inner) || !('none' in inner)) {
-                throw 'expected Option shape';
-            }
-        },
-    ],
-};

package/fs/cas/mcp/module.f.d.ts

@@ -1,36 +0,0 @@
-import { type Effect } from '../../effects/module.f.ts';
-import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type Read, type Write } from '../../effects/node/module.f.ts';
-import { type McpConfig, type McpHandlers } from '../../mcp/module.f.ts';
-import { type FileCasOperation } from '../module.f.ts';
-/** Arguments for `cas_add`: content to store, with optional encoding type. */
-export declare const casAddArgs: {
-    readonly content: import("../../types/rtti/module.f.ts").String;
-    readonly type: import("../../types/rtti/module.f.ts").Or<["text", "base64", undefined]>;
-};
-/** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export declare const casGetArgs: {
-    readonly hash: import("../../types/rtti/module.f.ts").String;
-    readonly content: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
-};
-/** Arguments for `cas_list`: none. */
-export declare const casListArgs: {};
-/**
- * MCP handlers for `FileCas`.
- */
-export declare const casMcpHandlers: (home: string) => McpHandlers<FileCasOperation>;
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export declare const casConfig: McpConfig;
-/**
- * Runs the file CAS MCP server over stdio: allocates the session-state slot, builds
- * the `mcpStep` for `c`, and drives the read → parse → dispatch → write loop
- * until stdin EOF.
- */
-export declare const casMcpServer: (home: string) => Effect<Read | Write | MemOp | FileCasOperation, void>;
-export declare const proof: {
-    casMcpServer: () => void;
-    collectReadOverflow: () => void;
-};

package/fs/cas/proof.f.d.ts

@@ -1,20 +0,0 @@
-import { type FileCasOperation } from './module.f.ts';
-import { type Effect } from '../effects/module.f.ts';
-import { type ReadFile, type WriteFile, type Rm, type Mkdir } from '../effects/node/module.f.ts';
-type TestOp = FileCasOperation | WriteFile | ReadFile | Rm | Mkdir;
-declare const testAddBigFile: () => Effect<TestOp, void>;
-declare const testAddAndGetBigFile: () => Effect<TestOp, void>;
-export declare const proof: {
-    addBigFile: typeof testAddBigFile;
-    addAndGetBigFile: typeof testAddAndGetBigFile;
-    casWriteRead: () => void;
-    casReadMissingShard: () => void;
-    casWriteMultiChunk: () => void;
-    casWriteDedup: () => void;
-    casWriteErrorItemAborts: () => void;
-    casWriteReadExceedsMaxLength: () => void;
-    casWriteGcReclaimsExpired: () => void;
-    casUploadSuccess: () => void;
-    casUploadFailureKeepsSource: () => void;
-};
-export {};