functionalscript 0.37.0 → 0.38.0

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.38.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",

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/crypto/pow/proof.f.js

@@ -1,161 +0,0 @@
-import { utf8 } from '../../text/module.f.js';
-import { empty, uint } from '../../types/bit_vec/module.f.js';
-import { computeSync, sha224, sha256 } from '../sha2/module.f.js';
-import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from './module.f.js';
-const p256 = sha256Pow;
-const p224 = pow(sha224);
-const sample = utf8('functionalscript pow proof');
-const emptyData = empty;
-/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
-const easyNBits = 0x207fffffn;
-/** Compact encoding for target `1` (`0x03000001`). */
-const hardNBits = 0x03000001n;
-/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
-const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
-/** Bitcoin block #0 header hash as big-endian uint256. */
-const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
-const expectNull = (nBits) => {
-    if (targetFromNBits(nBits) !== null) {
-        throw nBits;
-    }
-};
-export const proof = {
-    targetFromNBits: {
-        genesis: () => {
-            if (targetFromNBits(genesisNBits) !== genesisTarget) {
-                throw 'genesis target';
-            }
-        },
-        block0HashWithinGenesisTarget: () => {
-            if (block0Hash > genesisTarget) {
-                throw 'block0 hash exceeds genesis target';
-            }
-        },
-        exponent3: () => {
-            if (targetFromNBits(0x030000ffn) !== 0xffn) {
-                throw 'exponent 3';
-            }
-        },
-        exponent2: () => {
-            if (targetFromNBits(0x02008000n) !== 0x80n) {
-                throw 'exponent 2';
-            }
-        },
-        hardTargetOne: () => {
-            if (targetFromNBits(hardNBits) !== 1n) {
-                throw 'hard target';
-            }
-        },
-        zero: () => {
-            if (targetFromNBits(0n) !== 0n) {
-                throw 'zero nBits';
-            }
-        },
-        negative: () => {
-            expectNull(0x01800001n);
-        },
-        negativeHighMantissa: () => {
-            expectNull(0x22ffffffn);
-        },
-        overflowExponent: () => {
-            expectNull(0x23000001n);
-        },
-        exceeds256: () => {
-            expectNull(0x227fffffn);
-        },
-    },
-    meets: {
-        easy: () => {
-            if (!p256.meets(easyNBits)(sample)) {
-                throw 'easy nBits should pass';
-            }
-        },
-        hard: () => {
-            if (p256.meets(hardNBits)(sample)) {
-                throw 'target 1 should fail';
-            }
-        },
-        genesisFailsSample: () => {
-            if (p256.meets(genesisNBits)(sample)) {
-                throw 'genesis target too hard for sample';
-            }
-        },
-        zeroTargetRejectsSample: () => {
-            if (p256.meets(0n)(sample)) {
-                throw 'non-zero hash vs zero target';
-            }
-        },
-        invalidNBits: () => {
-            if (p256.meets(0x01800001n)(sample)) {
-                throw 'invalid nBits should not pass';
-            }
-        },
-        hashLeqTarget: () => {
-            const h = p256.hashInt(sample);
-            const target = targetFromNBits(easyNBits);
-            if (target === null) {
-                throw 'easy nBits decode';
-            }
-            if (h > target) {
-                throw 'hash above easy target';
-            }
-            if (!(h <= target)) {
-                throw 'hash <= target';
-            }
-        },
-    },
-    hashInt: {
-        sha256Sample: () => {
-            const digest = computeSync(sha256)([sample]);
-            if (p256.hashInt(sample) !== uint(digest)) {
-                throw 'sha256 sample';
-            }
-        },
-        sha256Empty: () => {
-            if (p256.hashInt(emptyData) !== sha256EmptyHash) {
-                throw 'sha256 empty constant';
-            }
-            const digest = computeSync(sha256)([emptyData]);
-            if (p256.hashInt(emptyData) !== uint(digest)) {
-                throw 'sha256 empty';
-            }
-        },
-        sha224: () => {
-            const digest = computeSync(sha224)([sample]);
-            if (p224.hashInt(sample) !== uint(digest)) {
-                throw 'sha224';
-            }
-        },
-        stable: () => {
-            if (p256.hashInt(sample) !== p256.hashInt(sample)) {
-                throw 'stable';
-            }
-        },
-    },
-    pow: {
-        sha256Pow: () => {
-            const built = pow(sha256);
-            if (sha256Pow.hashInt(sample) !== built.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (sha256Pow.meets(easyNBits)(sample) !== built.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-        bitcoinPow: () => {
-            if (bitcoinPow.hashInt(sample) !== sha256Pow.hashInt(sample)) {
-                throw 'bitcoinPow';
-            }
-        },
-        independentInstances: () => {
-            const a = pow(sha256);
-            const b = pow(sha256);
-            if (a.hashInt(sample) !== b.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (a.meets(easyNBits)(sample) !== b.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-    },
-};

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

@@ -1,12 +0,0 @@
-import { type List } from '../../types/list/module.f.ts';
-import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
-export type DjsToken = {
-    readonly kind: 'true' | 'false' | 'null' | 'undefined';
-} | {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
-} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken | jsTokenizer.CommentToken | jsTokenizer.EofToken;
-export type DjsTokenWithMetadata = {
-    readonly token: DjsToken;
-    readonly metadata: jsTokenizer.TokenMetadata;
-};
-export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;

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

@@ -1,62 +0,0 @@
-import { empty, flat, map, stateScan } from '../../types/list/module.f.js';
-import { multiply } from '../../types/bigfloat/module.f.js';
-import * as jsTokenizer from '../../js/tokenizer/module.f.js';
-const mapToken = input => {
-    switch (input.kind) {
-        case 'id':
-        case 'bigint':
-        case '{':
-        case '}':
-        case ':':
-        case ',':
-        case '[':
-        case ']':
-        case '.':
-        case '=':
-        case 'true':
-        case 'false':
-        case 'null':
-        case 'string':
-        case 'number':
-        case 'ws':
-        case 'nl':
-        case 'undefined':
-        case '//':
-        case '/*':
-        case 'eof':
-        case 'error': return [input];
-        default: return jsTokenizer.isKeywordToken(input) ? [{ kind: 'id', value: input.kind }] : [{ kind: 'error', message: 'invalid token' }];
-    }
-};
-const parseDefaultState = input => {
-    switch (input.kind) {
-        case 'eof': return [[{ kind: 'eof' }], { kind: 'def' }];
-        case '-': return [empty, { kind: '-' }];
-        default: return [mapToken(input), { kind: 'def' }];
-    }
-};
-const parseMinusState = input => {
-    switch (input.kind) {
-        case 'eof': return [[{ kind: 'error', message: 'invalid token' }, { kind: 'eof' }], { kind: 'def' }];
-        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }];
-        case 'bigint': return [[{ kind: 'bigint', value: -1n * input.value }], { kind: 'def' }];
-        case 'number': return [[{ kind: 'number', bf: multiply(input.bf)(-1n), value: `-${input.value}` }], { kind: 'def' }];
-        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input) }, { kind: 'def' }];
-    }
-};
-const scanToken = (input, state) => {
-    switch (state.kind) {
-        case '-': return parseMinusState(input);
-        default: return parseDefaultState(input);
-    }
-};
-const mapTokenWithMetadata = metadata => token => { return { token, metadata }; };
-const scanTokenWithMetadata = (input, state) => {
-    const [djsTokens, newState] = scanToken(input.token, state);
-    const djsTokensWithMetadata = map(mapTokenWithMetadata(input.metadata))(djsTokens);
-    return [djsTokensWithMetadata, newState];
-};
-export const tokenize = input => path => {
-    const jsTokens = jsTokenizer.tokenize(input)(path);
-    return flat(stateScan(scanTokenWithMetadata)({ kind: 'def' })(jsTokens));
-};

package/fs/djs/tokenizer/proof.f.d.ts

@@ -1,7 +0,0 @@
-export declare const proof: {
-    djs: (() => void)[];
-    id: (() => void)[];
-    keywords: (() => void)[];
-    comments: (() => void)[];
-    metadata: (() => void)[];
-};