functionalscript 0.27.0 → 0.29.0

package/README.md

@@ -1,7 +1,6 @@
 # FunctionalScript
 
 [![NPM Version](https://img.shields.io/npm/v/functionalscript)](https://www.npmjs.com/package/functionalscript)
-[![JSR Version](https://img.shields.io/jsr/v/%40functionalscript/functionalscript)](https://jsr.io/@functionalscript/functionalscript)
 
 FunctionalScript is a safe, purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by

package/fs/cas/module.f.js

@@ -6,7 +6,7 @@
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { begin, forEachStep, pure } from "../effects/module.f.js";
+import { forEachStep, pure } from "../effects/module.f.js";
 import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { dispatch } from "../cli/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
@@ -25,23 +25,20 @@ const toPath = (key) => {
  * Creates a filesystem-backed key/value store under the provided root path.
  */
 export const fileKvStore = (path) => ({
-    read: (key) => begin
-        .step(() => readFile(toPath(key)))
+    read: (key) => readFile(toPath(key))
         .step(([status, data]) => pure(status === 'error' ? undefined : data)),
     write: (key, value) => {
         const p = toPath(key);
         const parts = parse(p);
         const dir = `${path}/${parts.slice(0, -1).join('/')}`;
         // TODO: error handling
-        return begin
-            .step(() => mkdir(dir, { recursive: true }))
+        return mkdir(dir, { recursive: true })
             .step(() => writeFile(`${path}/${p}`, value))
             .step(() => pure(undefined));
     },
     list: () => 
     // TODO: remove unwrap
-    begin
-        .step(() => readdir('.cas', { recursive: true }))
+    readdir('.cas', { recursive: true })
         .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
         ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name)
         : null)))),
@@ -55,8 +52,7 @@ export const cas = (sha2) => {
         read,
         write: (value) => {
             const hash = compute([value]);
-            return begin
-                .step(() => write(hash, value))
+            return write(hash, value)
                 .step(() => pure(hash));
         },
         list,
@@ -72,8 +68,7 @@ export const main = (options) => {
                 if (path === undefined || rest.length !== 0) {
                     return errorExit("'cas add' expects one parameter");
                 }
-                return begin
-                    .step(() => readFile(path))
+                return readFile(path)
                     .step(v => c.write(unwrap(v)))
                     .step(hash => log(vecToCBase32(hash)))
                     .step(() => pure(0));
@@ -90,13 +85,11 @@ export const main = (options) => {
                 if (hash === null) {
                     return errorExit(`invalid hash format: ${hashCBase32}`);
                 }
-                return begin
-                    .step(() => c.read(hash))
+                return c.read(hash)
                     .step(v => {
                     const result = v === undefined
                         ? errorExit(`no such hash: ${hashCBase32}`)
-                        : begin
-                            .step(() => writeFile(path, v))
+                        : writeFile(path, v)
                             .step(() => pure(0));
                     return result;
                 });
@@ -105,8 +98,7 @@ export const main = (options) => {
         {
             names: ['list'],
             description: 'List all stored content hashes',
-            handler: () => begin
-                .step(() => c.list())
+            handler: () => c.list()
                 .step(forEachStep(j => log(vecToCBase32(j))))
                 .step(() => pure(0)),
         },

package/fs/ci/bun/module.f.js

@@ -16,7 +16,7 @@ const installBun = installOnWindowsArm({
 });
 export const bunSteps = (extra) => (v, a) => clean([
     installBun(v)(a),
-    test({ run: 'bun install' }),
+    test({ run: 'bun install --frozen-lockfile' }),
     test({ run: 'bun test --timeout 20000' }),
     ...extra,
 ]);

package/fs/ci/deno/module.f.js

@@ -8,7 +8,7 @@ import { deno } from "../config/module.f.js";
 import { clean, install, test, uses } from "../common/module.f.js";
 export const denoSteps = (extra) => clean([
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
-    test({ run: 'deno install' }),
+    test({ run: 'deno install --frozen' }),
     test({ run: 'deno task test' }),
     ...extra,
 ]);

package/fs/ci/module.f.js

@@ -76,10 +76,7 @@ const defaultNodeExtra = ({ name, functionalscript }) => (o) => [
 ];
 const defaultEffect = (info) => ci({
     nodeExtra: defaultNodeExtra(info),
-    denoExtra: [
-        ...(info.functionalscript ? denoDemoCompile : []),
-        test({ run: 'deno publish --dry-run --allow-slow-types' }),
-    ],
+    denoExtra: info.functionalscript ? [...denoDemoCompile] : [],
     bunExtra: info.functionalscript ? bunDemoCompile : [],
 });
 export const main = () => readPackageInfo.step(defaultEffect);

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

@@ -1,4 +1,9 @@
-import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../effects/node/module.f.ts';
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
+import { type Access, type All, type Env, type Import, type Readdir } from '../effects/node/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
@@ -36,4 +41,3 @@ export type LoadModuleOperations = Access | Import | All | Readdir;
  * deterministic regardless of filesystem traversal order.
  */
 export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
-export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -3,15 +3,10 @@
  *
  * @module
  */
-import { updateVersion } from "./version/module.f.js";
-import { all, both, import_, readdir, readFile, writeFile } from "../effects/node/module.f.js";
+import { all, import_, readdir } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
-import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-import { begin, pure } from "../effects/module.f.js";
-import { parse as jsonParse } from "../json/module.f.js";
-import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
-import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
+import { pure } from "../effects/module.f.js";
 import { relativize, toPosix } from "../path/module.f.js";
 /**
  * Returns `true` if the file should be loaded for proof discovery.
@@ -29,8 +24,7 @@ export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
     s.endsWith('proof.mts') || s.endsWith('proof.mjs');
 const isSourceFile = (path) => path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs');
 const allFiles = (s, predicate) => {
-    const load = (p) => begin
-        .step(() => readdir(p, {}))
+    const load = (p) => readdir(p, {})
         .step(d => {
         let result = [];
         for (const i of unwrap(d)) {
@@ -86,22 +80,3 @@ export const loadModuleMap = (env) => {
         .map(([k, v]) => [relativize(prefix, k), v])
         .toSorted(([a], [b]) => strCmp(a)(b)))));
 };
-const denoJson = './deno.json';
-const parseDenoJson = rttiParse(record(rttiUnknown));
-const index2 = updateVersion
-    .step(() => readFile(denoJson))
-    .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') ||
-    v.endsWith('/module.ts') ||
-    v.endsWith('/all.test.ts'))
-    .step(files => {
-    const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
-    return pure(Object.fromEntries(exportsA));
-});
-const index3 = both(index2)(allFiles2aa)
-    .step(([jsr_json, exports]) => {
-    const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
-    return writeFile(denoJson, utf8(json));
-})
-    .step(() => pure(0));
-export const index4 = () => index3;

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

@@ -2,4 +2,8 @@ export declare const proof: {
     isValid: (() => void)[];
     tokenizer: (() => void)[];
     djs: (() => void)[];
+    operators: (() => void)[];
+    throw: {
+        parse: () => void;
+    };
 };

package/fs/djs/tokenizer-new/proof.f.js

@@ -1,7 +1,9 @@
 import { descentParser } from "../../bnf/data/module.f.js";
+import { backspace, ht, lf, ff, cr, quotationMark, solidus, reverseSolidus, digitRange, digit0, latinCapitalLetterA, latinSmallLetterA, latinSmallLetterB, latinSmallLetterF, latinSmallLetterN, latinSmallLetterR, latinSmallLetterT, latinSmallLetterU, range, } from "../../text/ascii/module.f.js";
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { contains } from "../../types/range/module.f.js";
 import { concat, filter, flat, flatMap, map, stateScan, toArray } from "../../types/list/module.f.js";
-import { jsGrammar } from "./module.f.js";
+import { jsGrammar, parse } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
 const descentParserCpOnly = (m, name, cp) => {
     const cpm = toArray(map(mapCodePoint)(cp));
@@ -45,16 +47,21 @@ const scanFunc = (input, state) => {
     }
     return [null, [state[0], concat(state[1])([input])]];
 };
+// All operator tag strings produced by the grammar's operator rule
+const operatorTags = new Set([
+    '.', '=>', '===', '==', '=', '!==', '!=', '!',
+    '>>>=', '>>>', '>>=', '>>', '>=', '>',
+    '<<<=', '<<<', '<<=', '<<', '<=', '<',
+    '+=', '++', '+', '-=', '--', '-',
+    '**=', '**', '*=', '*', '/=', '%=', '%',
+    '&&=', '&&', '&=', '&', '||=', '||', '|=', '|',
+    '^=', '^', '~', '??=', '??', '?.', '?',
+    '[', ']', '{', '}', '(', ')', ',', ':'
+]);
 const filterFunc = tk => {
     if (typeof tk === 'number')
         return true;
     switch (tk) {
-        case '{':
-        case '}':
-        case '[':
-        case ']':
-        case ':':
-        case ',':
         case 'number':
         case 'string':
         case '\n':
@@ -63,18 +70,40 @@ const filterFunc = tk => {
         case '\t':
             return true;
         default:
-            return false;
+            return operatorTags.has(tk);
     }
 };
+const rangeCapitalAF = range('AF');
+const stringDecodeScan = (cp, state) => {
+    switch (state.kind) {
+        case 'escape':
+            switch (cp) {
+                case quotationMark: return [[quotationMark], { kind: 'normal' }]; // \" → "
+                case reverseSolidus: return [[reverseSolidus], { kind: 'normal' }]; // \\ → \
+                case solidus: return [[solidus], { kind: 'normal' }]; // \/ → /
+                case latinSmallLetterB: return [[backspace], { kind: 'normal' }]; // \b → backspace (BS)
+                case latinSmallLetterF: return [[ff], { kind: 'normal' }]; // \f → form feed (FF)
+                case latinSmallLetterN: return [[lf], { kind: 'normal' }]; // \n → line feed (LF)
+                case latinSmallLetterR: return [[cr], { kind: 'normal' }]; // \r → carriage return (CR)
+                case latinSmallLetterT: return [[ht], { kind: 'normal' }]; // \t → horizontal tab (HT)
+                case latinSmallLetterU: return [null, { kind: 'unicode', acc: 0, count: 0 }]; // \u → start 4 hex digits
+                default: return [[cp], { kind: 'normal' }];
+            }
+        case 'unicode': {
+            // convert hex digit char to its numeric value: '0'-'9', 'A'-'F', 'a'-'f'
+            const digit = contains(digitRange)(cp) ? cp - digit0
+                : contains(rangeCapitalAF)(cp) ? cp - (latinCapitalLetterA - 10)
+                    : cp - (latinSmallLetterA - 10);
+            const acc = (state.acc << 4) | digit;
+            return state.count === 3 ? [[acc], { kind: 'normal' }] : [null, { kind: 'unicode', acc, count: state.count + 1 }];
+        }
+        default:
+            return cp === reverseSolidus ? [null, { kind: 'escape' }] : [[cp], { kind: 'normal' }];
+    }
+};
+const decodeJsonString = codePoints => String.fromCodePoint(...toArray(flat(stateScan(stringDecodeScan)({ kind: 'normal' })(codePoints.slice(1, -1)))));
 const toJsToken = tk => {
     switch (tk[0]) {
-        case '{':
-        case '}':
-        case '[':
-        case ']':
-        case ':':
-        case ',':
-            return { kind: tk[0] };
         case '\n':
         case '\r':
             return { kind: 'nl' };
@@ -82,9 +111,9 @@ const toJsToken = tk => {
         case '\t':
             return { kind: 'ws' };
         case 'string':
-            return { kind: 'string', value: String.fromCodePoint(...tk[1].slice(1, -1)) };
+            return { kind: 'string', value: decodeJsonString(tk[1]) };
         default:
-            return null;
+            return { kind: tk[0] };
     }
 };
 const getTokensFromAstRuleOrCodePoint = value => {
@@ -385,18 +414,24 @@ export const proof = {
                 throw result;
             }
         },
-        //     () => {
-        //         const result = tokenizeString('"\\\\"')
-        //         if (result !== '[{"kind":"string","value":"\\\\"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('"\\""')
-        //         if (result !== '[{"kind":"string","value":"\\""},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('"\\/"')
-        //         if (result !== '[{"kind":"string","value":"/"},{"kind":"eof"}]') { throw result }
-        //     },
+        () => {
+            const result = tokenizeString('"\\\\"');
+            if (result !== '[{"kind":"string","value":"\\\\"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('"\\""');
+            if (result !== '[{"kind":"string","value":"\\""},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('"\\/"');
+            if (result !== '[{"kind":"string","value":"/"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
         () => {
             const result = tokenizeString('"\\x"');
             if (result !== 'error') {
@@ -421,18 +456,24 @@ export const proof = {
                 throw result;
             }
         },
-        //     () => {
-        //         const result = tokenizeString('"\\b\\f\\n\\r\\t"')
-        //         if (result !== '[{"kind":"string","value":"\\b\\f\\n\\r\\t"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('"\\u1234"')
-        //         if (result !== '[{"kind":"string","value":"ሴ"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('"\\uaBcDEeFf"')
-        //         if (result !== '[{"kind":"string","value":"ꯍEeFf"},{"kind":"eof"}]') { throw result }
-        //     },
+        () => {
+            const result = tokenizeString('"\\b\\f\\n\\r\\t"');
+            if (result !== '[{"kind":"string","value":"\\b\\f\\n\\r\\t"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('"\\u1234"');
+            if (result !== '[{"kind":"string","value":"ሴ"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('"\\uaBcDEeFf"');
+            if (result !== '[{"kind":"string","value":"ꯍEeFf"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
         () => {
             const result = tokenizeString('"\\uEeFg"');
             if (result !== 'error') {
@@ -612,87 +653,88 @@ export const proof = {
         //         if (result !== 'error') { throw result }
         //     },
     ],
-    // operators:
-    // [
-    //     () => {
-    //         const result = tokenizeString('=')
-    //         if (result !== '[{"kind":"="},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('=a')
-    //         if (result !== '[{"kind":"="},{"kind":"id","value":"a"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('-')
-    //         if (result !== '[{"kind":"-"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('1*2')
-    //         if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"*"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('( )')
-    //         if (result !== '[{"kind":"("},{"kind":"ws"},{"kind":")"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('== != === !== > >= < <=')
-    //         if (result !== '[{"kind":"=="},{"kind":"ws"},{"kind":"!="},{"kind":"ws"},{"kind":"==="},{"kind":"ws"},{"kind":"!=="},{"kind":"ws"},{"kind":">"},{"kind":"ws"},{"kind":">="},{"kind":"ws"},{"kind":"<"},{"kind":"ws"},{"kind":"<="},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('+ - * / % ++ -- **')
-    //         if (result !== '[{"kind":"+"},{"kind":"ws"},{"kind":"-"},{"kind":"ws"},{"kind":"*"},{"kind":"ws"},{"kind":"/"},{"kind":"ws"},{"kind":"%"},{"kind":"ws"},{"kind":"++"},{"kind":"ws"},{"kind":"--"},{"kind":"ws"},{"kind":"**"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('= += -= *= /= %= **=')
-    //         if (result !== '[{"kind":"="},{"kind":"ws"},{"kind":"+="},{"kind":"ws"},{"kind":"-="},{"kind":"ws"},{"kind":"*="},{"kind":"ws"},{"kind":"/="},{"kind":"ws"},{"kind":"%="},{"kind":"ws"},{"kind":"**="},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('& | ^ ~ << >> >>>')
-    //         if (result !== '[{"kind":"&"},{"kind":"ws"},{"kind":"|"},{"kind":"ws"},{"kind":"^"},{"kind":"ws"},{"kind":"~"},{"kind":"ws"},{"kind":"<<"},{"kind":"ws"},{"kind":">>"},{"kind":"ws"},{"kind":">>>"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('&= |= ^= <<= >>= >>>=')
-    //         if (result !== '[{"kind":"&="},{"kind":"ws"},{"kind":"|="},{"kind":"ws"},{"kind":"^="},{"kind":"ws"},{"kind":"<<="},{"kind":"ws"},{"kind":">>="},{"kind":"ws"},{"kind":">>>="},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('&& || ! ??')
-    //         if (result !== '[{"kind":"&&"},{"kind":"ws"},{"kind":"||"},{"kind":"ws"},{"kind":"!"},{"kind":"ws"},{"kind":"??"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('&&= ||= ??=')
-    //         if (result !== '[{"kind":"&&="},{"kind":"ws"},{"kind":"||="},{"kind":"ws"},{"kind":"??="},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('? ?. . =>')
-    //         if (result !== '[{"kind":"?"},{"kind":"ws"},{"kind":"?."},{"kind":"ws"},{"kind":"."},{"kind":"ws"},{"kind":"=>"},{"kind":"eof"}]') { throw result }
-    //     },
-    // ],
-    // ws: [
-    //     () => {
-    //         const result = tokenizeString(' ')
-    //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('\t')
-    //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString(' \t')
-    //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('\n')
-    //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString('\r')
-    //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-    //     },
-    //     () => {
-    //         const result = tokenizeString(' \t\n\r ')
-    //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-    //     },
-    // ],
+    operators: [
+        () => {
+            const result = tokenizeString('=');
+            if (result !== '[{"kind":"="},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        //     () => {
+        //         const result = tokenizeString('=a')
+        //         if (result !== '[{"kind":"="},{"kind":"id","value":"a"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('-')
+        //         if (result !== '[{"kind":"-"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('1*2')
+        //         if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"*"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('( )')
+        //         if (result !== '[{"kind":"("},{"kind":"ws"},{"kind":")"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('== != === !== > >= < <=')
+        //         if (result !== '[{"kind":"=="},{"kind":"ws"},{"kind":"!="},{"kind":"ws"},{"kind":"==="},{"kind":"ws"},{"kind":"!=="},{"kind":"ws"},{"kind":">"},{"kind":"ws"},{"kind":">="},{"kind":"ws"},{"kind":"<"},{"kind":"ws"},{"kind":"<="},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('+ - * / % ++ -- **')
+        //         if (result !== '[{"kind":"+"},{"kind":"ws"},{"kind":"-"},{"kind":"ws"},{"kind":"*"},{"kind":"ws"},{"kind":"/"},{"kind":"ws"},{"kind":"%"},{"kind":"ws"},{"kind":"++"},{"kind":"ws"},{"kind":"--"},{"kind":"ws"},{"kind":"**"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('= += -= *= /= %= **=')
+        //         if (result !== '[{"kind":"="},{"kind":"ws"},{"kind":"+="},{"kind":"ws"},{"kind":"-="},{"kind":"ws"},{"kind":"*="},{"kind":"ws"},{"kind":"/="},{"kind":"ws"},{"kind":"%="},{"kind":"ws"},{"kind":"**="},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('& | ^ ~ << >> >>>')
+        //         if (result !== '[{"kind":"&"},{"kind":"ws"},{"kind":"|"},{"kind":"ws"},{"kind":"^"},{"kind":"ws"},{"kind":"~"},{"kind":"ws"},{"kind":"<<"},{"kind":"ws"},{"kind":">>"},{"kind":"ws"},{"kind":">>>"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('&= |= ^= <<= >>= >>>=')
+        //         if (result !== '[{"kind":"&="},{"kind":"ws"},{"kind":"|="},{"kind":"ws"},{"kind":"^="},{"kind":"ws"},{"kind":"<<="},{"kind":"ws"},{"kind":">>="},{"kind":"ws"},{"kind":">>>="},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('&& || ! ??')
+        //         if (result !== '[{"kind":"&&"},{"kind":"ws"},{"kind":"||"},{"kind":"ws"},{"kind":"!"},{"kind":"ws"},{"kind":"??"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('&&= ||= ??=')
+        //         if (result !== '[{"kind":"&&="},{"kind":"ws"},{"kind":"||="},{"kind":"ws"},{"kind":"??="},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('? ?. . =>')
+        //         if (result !== '[{"kind":"?"},{"kind":"ws"},{"kind":"?."},{"kind":"ws"},{"kind":"."},{"kind":"ws"},{"kind":"=>"},{"kind":"eof"}]') { throw result }
+        //     },
+        // ],
+        // ws: [
+        //     () => {
+        //         const result = tokenizeString(' ')
+        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('\t')
+        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString(' \t')
+        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('\n')
+        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString('\r')
+        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
+        //     },
+        //     () => {
+        //         const result = tokenizeString(' \t\n\r ')
+        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
+        //     },
+    ],
     // id: [
     //     () => {
     //         const result = tokenizeString('err')
@@ -909,6 +951,9 @@ export const proof = {
     //         if (result !== '[{"kind":"yield"},{"kind":"eof"}]') { throw result }
     //     },
     // ],
+    throw: {
+        parse: () => { parse(''); }
+    },
     // comments: [
     //     () => {
     //         const result = tokenizeString('//singleline comment')

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

@@ -20,7 +20,6 @@ export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, pa
 export type Param<O extends Operation> = F<O>[0];
 export type Return<O extends Operation> = F<O>[1];
 export declare const do_: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
-export declare const begin: Effect<never, void>;
 /**
  * Sequentially threads a state value through an effect for each item in `items`.
  *

package/fs/effects/module.f.js

@@ -13,7 +13,6 @@ export const doFull = (cmd, param, cont) => ({
     step: (f) => doFull(cmd, param, x => cont(x).step(f)),
 });
 export const do_ = (cmd) => (...param) => doFull(cmd, param, pure);
-export const begin = pure(undefined);
 /**
  * Sequentially threads a state value through an effect for each item in `items`.
  *

package/fs/effects/node/module.f.js

@@ -8,7 +8,7 @@
  * @module
  */
 import { utf8 } from "../../text/module.f.js";
-import { begin, do_, pure } from "../module.f.js";
+import { do_, pure } from "../module.f.js";
 const doAll = do_('all');
 /**
  * To run the operation `O` should be known by the runner/engine.
@@ -70,6 +70,4 @@ export const test = do_('test');
  * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
  * compose `error(s).step(() => pure(n))` directly.
  */
-export const errorExit = (s) => begin
-    .step(() => error(s))
-    .step(() => pure(1));
+export const errorExit = (s) => error(s).step(() => pure(1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -11,12 +11,11 @@
     "prepack": "tsc --NoEmit false",
     "test": "tsc && node ./fs/fjs/module.ts t",
     "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
-    "index": "node ./fs/fjs/module.ts r ./fs/dev/index/module.f.ts",
     "start": "node ./fs/fjs/module.ts",
     "ci-update": "node ./fs/fjs/module.ts ci",
-    "update": "npm install && npm run index && npm run ci-update",
+    "update": "npx npm-check-updates -u && npm install && deno install && bun install && npm run ci-update",
     "index-html": "node ./fs/fjs/module.ts r ./fs/website/module.f.ts",
-    "website": "npm run prepack &&npm run index-html"
+    "website": "npm run prepack && npm run index-html"
   },
   "engines": {
     "node": ">=24"
@@ -44,8 +43,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@playwright/test": "1",
-    "@types/node": "*",
-    "typescript": "*"
+    "@playwright/test": "1.60.0",
+    "@types/node": "25.9.2",
+    "typescript": "6.0.3"
   }
-}
+}

package/fs/dev/index/module.f.d.ts

@@ -1 +0,0 @@
-export declare const main: import("../../effects/node/module.f.ts").NodeProgram;

package/fs/dev/index/module.f.js

@@ -1,8 +0,0 @@
-/**
- * Entry point for the `index` developer program: re-exports `index4` from the
- * parent `dev` module as the default `NodeProgram`.
- *
- * @module
- */
-import { index4 } from "../module.f.js";
-export const main = index4;

package/fs/dev/version/module.f.d.ts

@@ -1,3 +0,0 @@
-import { type Effect } from '../../effects/module.f.ts';
-import { type All, type ReadFile, type WriteFile } from '../../effects/node/module.f.ts';
-export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;

package/fs/dev/version/module.f.js

@@ -1,33 +0,0 @@
-/**
- * Version management helpers for updating project package versions.
- *
- * @module
- */
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { begin, pure } from "../../effects/module.f.js";
-import { all, readFile, writeFile } from "../../effects/node/module.f.js";
-import { unwrap } from "../../types/result/module.f.js";
-import { validatePackageJson } from "../package_json/module.f.js";
-import { assert } from "../../asserts/module.f.js";
-const { parse, stringify } = JSON;
-const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = (name) => begin
-    .step(() => readFile(jsonFile(name)))
-    .step(v => pure(unwrap(validatePackageJson(parse(utf8ToString(unwrap(v)))))));
-const writeVersion = (version) => (name) => begin
-    .step(() => readJson(name))
-    .step((json) => writeFile(jsonFile(name), utf8(stringify({
-    ...json,
-    version,
-}, null, 2))));
-const version = (p) => {
-    assert(p.version !== undefined, 'package.json version is missing');
-    return p.version;
-};
-export const updateVersion = begin
-    .step(() => readJson('package'))
-    .step(p => {
-    const w = writeVersion(version(p));
-    return all(w('package'), w('deno'));
-})
-    .step(() => pure(0));

package/fs/dev/version/proof.f.d.ts

@@ -1,3 +0,0 @@
-export declare const proof: {
-    new: () => void;
-};

package/fs/dev/version/proof.f.js

@@ -1,100 +0,0 @@
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { isVec } from "../../types/bit_vec/module.f.js";
-import { all, writeFile } from "../../effects/node/module.f.js";
-import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
-import { updateVersion } from "./module.f.js";
-const version = '0.3.0';
-const x = {
-    'package.json': {
-        "name": "functionalscript",
-        version,
-        "description": "FunctionalScript is a functional subset of JavaScript",
-        "main": "module.f.cjs",
-        "scripts": {
-            "tsc": "tsc",
-            "test": "tsc && npm run test-only",
-            "version": "node ./nodejs/version/main.cjs",
-            "test-only": "node --trace-uncaught ./test.f.cjs"
-        },
-        "repository": {
-            "type": "git",
-            "url": "git+https://github.com/functionalscript/functionalscript.git"
-        },
-        "author": "NatFoam",
-        "license": "MIT",
-        "keywords": [
-            "lambda",
-            "functional-programming",
-            "closure",
-            "pure-functional",
-            "typescript",
-            "programming-language",
-            "lazy-evaluation"
-        ],
-        "bugs": {
-            "url": "https://github.com/functionalscript/functionalscript/issues"
-        },
-        "homepage": "https://github.com/functionalscript/functionalscript#readme",
-        "devDependencies": {
-            "@types/node": "^18.6.2",
-            "typescript": "^4.7.4"
-        }
-    },
-    "deno.json": {}
-};
-const e = '{\n' +
-    '  "name": "functionalscript",\n' +
-    `  "version": "${version}",\n` +
-    '  "description": "FunctionalScript is a functional subset of JavaScript",\n' +
-    '  "main": "module.f.cjs",\n' +
-    '  "scripts": {\n' +
-    '    "tsc": "tsc",\n' +
-    '    "test": "tsc && npm run test-only",\n' +
-    '    "version": "node ./nodejs/version/main.cjs",\n' +
-    '    "test-only": "node --trace-uncaught ./test.f.cjs"\n' +
-    '  },\n' +
-    '  "repository": {\n' +
-    '    "type": "git",\n' +
-    '    "url": "git+https://github.com/functionalscript/functionalscript.git"\n' +
-    '  },\n' +
-    '  "author": "NatFoam",\n' +
-    '  "license": "MIT",\n' +
-    '  "keywords": [\n' +
-    '    "lambda",\n' +
-    '    "functional-programming",\n' +
-    '    "closure",\n' +
-    '    "pure-functional",\n' +
-    '    "typescript",\n' +
-    '    "programming-language",\n' +
-    '    "lazy-evaluation"\n' +
-    '  ],\n' +
-    '  "bugs": {\n' +
-    '    "url": "https://github.com/functionalscript/functionalscript/issues"\n' +
-    '  },\n' +
-    '  "homepage": "https://github.com/functionalscript/functionalscript#readme",\n' +
-    '  "devDependencies": {\n' +
-    '    "@types/node": "^18.6.2",\n' +
-    '    "typescript": "^4.7.4"\n' +
-    '  }\n' +
-    '}';
-export const proof = {
-    new: () => {
-        const w = (name) => {
-            const fn = `${name}.json`;
-            return writeFile(fn, utf8(JSON.stringify(x[fn])));
-        };
-        const [state] = virtual(emptyState)(all(w('package'), w('deno')));
-        const [newState, result] = virtual(state)(updateVersion);
-        if (result !== 0) {
-            throw result;
-        }
-        const vec = newState.root['package.json'];
-        if (!isVec(vec)) {
-            throw vec;
-        }
-        const n = utf8ToString(vec);
-        if (n !== e) {
-            throw [n, e];
-        }
-    }
-};