functionalscript 0.26.0 → 0.28.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/config/module.f.d.ts

@@ -28,7 +28,7 @@ export declare const node: {
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260605.1";
+export declare const tsgo = "7.0.0-dev.20260606.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";

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

@@ -36,7 +36,7 @@ export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260605.1';
+export const tsgo = '7.0.0-dev.20260606.1';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.

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

@@ -3,9 +3,10 @@
  *
  * @module
  */
-import { utf8 } from "../text/module.f.js";
+import { utf8, utf8ToString } from "../text/module.f.js";
+import { validatePackageJsonText } from "../dev/package_json/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { access, writeFile } from "../effects/node/module.f.js";
+import { access, readFile, writeFile } from "../effects/node/module.f.js";
 import { images } from "./config/module.f.js";
 import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";
@@ -24,6 +25,20 @@ const job = (rust, nodeExtra, denoExtra, bunExtra) => (o) => (a) => {
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
+const functionalscriptPackageName = 'functionalscript';
+const fallbackPackageInfo = {
+    name: functionalscriptPackageName,
+    functionalscript: false,
+};
+const packageInfoFromPackageJson = ({ name }) => name !== undefined
+    ? { name, functionalscript: name === functionalscriptPackageName }
+    : fallbackPackageInfo;
+const packageInfoFromText = (text) => {
+    const result = validatePackageJsonText(text);
+    return result[0] === 'ok' ? packageInfoFromPackageJson(result[1]) : fallbackPackageInfo;
+};
+const readPackageInfo = readFile('package.json')
+    .step(result => pure(result[0] === 'ok' ? packageInfoFromText(utf8ToString(result[1])) : fallbackPackageInfo));
 export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').step(result => {
     const rust = result[0] === 'ok';
     const jobs = {
@@ -42,21 +57,26 @@ export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').s
     return writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
         .step(() => pure(0));
 });
-const defaultEffect = ci({
-    nodeExtra: o => [
-        test({ run: 'npm pack' }),
-        test({ run: `npm install -g ${findTgz(o)}` }),
-        test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
-        test({ run: 'fjs t' }),
-        test({ run: 'npm uninstall functionalscript -g' }),
-    ],
-    denoExtra: [
-        test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
-        test({ run: 'deno task fjs t' }),
-        test({ run: 'deno publish --dry-run --allow-slow-types' }),
-    ],
-    bunExtra: [
-        test({ run: 'bun ./fs/fjs/module.ts t' }),
-    ]
+const demoCompile = [
+    test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
+    test({ run: 'fjs t' }),
+];
+const denoDemoCompile = [
+    test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
+    test({ run: 'deno task fjs t' }),
+];
+const bunDemoCompile = [
+    test({ run: 'bun ./fs/fjs/module.ts t' }),
+];
+const defaultNodeExtra = ({ name, functionalscript }) => (o) => [
+    test({ run: 'npm pack' }),
+    test({ run: `npm install -g ${findTgz(o)}` }),
+    ...(functionalscript ? demoCompile : []),
+    test({ run: `npm uninstall ${name} -g` }),
+];
+const defaultEffect = (info) => ci({
+    nodeExtra: defaultNodeExtra(info),
+    denoExtra: info.functionalscript ? [...denoDemoCompile] : [],
+    bunExtra: info.functionalscript ? bunDemoCompile : [],
 });
-export const main = () => defaultEffect;
+export const main = () => readPackageInfo.step(defaultEffect);

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

@@ -5,4 +5,13 @@ export declare const proof: {
         allOs: () => void;
         osSpecific: () => void;
     };
+    defaultSetup: {
+        functionalscriptDemo: () => void;
+        otherPackageNoDemo: () => void;
+        uninstallPackageName: () => void;
+        malformedPackageJsonFallback: () => void;
+        missingPackageJsonFallback: () => void;
+        missingNameFallback: () => void;
+        nonObjectFallback: () => void;
+    };
 };

package/fs/ci/proof.f.js

@@ -1,5 +1,5 @@
-import { ci } from "./module.f.js";
-import { utf8ToString } from "../text/module.f.js";
+import { ci, main } from "./module.f.js";
+import { utf8, utf8ToString } from "../text/module.f.js";
 import { empty as emptyVec, isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
@@ -8,16 +8,15 @@ import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
-const makeState = (rust) => ({
+const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
         '.github': { workflows: {} },
+        ...(packageJson !== undefined ? { 'package.json': utf8(packageJson) } : {}),
         ...(rust ? { 'Cargo.toml': emptyVec } : {}),
     },
 });
-const run = (rust, nodeExtra = () => []) => {
-    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra, denoExtra: [], bunExtra: [] }));
-    assert(result === 0, result);
+const workflow = (state) => {
     const dotGithub = state.root['.github'];
     assert(typeof dotGithub === 'object', dotGithub);
     const workflows = dotGithub['workflows'];
@@ -26,6 +25,16 @@ const run = (rust, nodeExtra = () => []) => {
     assert(isVec(file), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
 };
+const run = (rust, nodeExtra = () => []) => {
+    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra, denoExtra: [], bunExtra: [] }));
+    assert(result === 0, result);
+    return workflow(state);
+};
+const runDefault = (packageJson) => {
+    const [state, result] = virtual(makeState(false, packageJson))(main());
+    assert(result === 0, result);
+    return workflow(state);
+};
 export const proof = {
     rust: () => {
         assert(hasRun('cargo')(run(true)), 'expected Rust steps');
@@ -52,4 +61,47 @@ export const proof = {
             }
         },
     },
+    defaultSetup: {
+        functionalscriptDemo: () => {
+            const gha = runDefault('{"name":"functionalscript"}');
+            assert(hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'expected fjs demo compile');
+            assert(hasRun('fjs t')(gha), 'expected fjs self-test');
+            assert(hasRun('deno task fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'expected deno demo compile');
+            assert(hasRun('deno task fjs t')(gha), 'expected deno self-test');
+            assert(hasRun('bun ./fs/fjs/module.ts t')(gha), 'expected bun self-test');
+        },
+        otherPackageNoDemo: () => {
+            const gha = runDefault('{"name":"other-package"}');
+            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
+            assert(!hasRun('fjs t')(gha), 'unexpected fjs self-test');
+            assert(!hasRun('deno task fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected deno demo compile');
+            assert(!hasRun('deno task fjs t')(gha), 'unexpected deno self-test');
+            assert(!hasRun('bun ./fs/fjs/module.ts t')(gha), 'unexpected bun self-test');
+        },
+        uninstallPackageName: () => {
+            const gha = runDefault('{"name":"other-package"}');
+            assert(hasRun('npm uninstall other-package -g')(gha), 'expected package-specific uninstall');
+            assert(!hasRun('npm uninstall functionalscript -g')(gha), 'unexpected functionalscript uninstall');
+        },
+        malformedPackageJsonFallback: () => {
+            const gha = runDefault('{');
+            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
+            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+        },
+        missingPackageJsonFallback: () => {
+            const gha = runDefault();
+            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
+            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+        },
+        missingNameFallback: () => {
+            const gha = runDefault('{"version":"1.0.0"}');
+            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
+            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+        },
+        nonObjectFallback: () => {
+            const gha = runDefault('[]');
+            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
+            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+        },
+    },
 };

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/dev/package_json/module.f.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationError } from '../../types/rtti/validate/module.f.ts';
+import type { Ts } from '../../types/rtti/ts/module.f.ts';
+import { type Result } from '../../types/result/module.f.ts';
+export declare const packageJsonSchema: {
+    readonly name: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly version: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly scripts: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+};
+export type PackageJson = Ts<typeof packageJsonSchema>;
+export type JsonTextError = string | ValidationError;
+export declare const validatePackageJson: import("../../types/rtti/common/module.f.ts").Validate<{
+    readonly name: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly version: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly scripts: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+}>;
+export declare const validatePackageJsonText: (text: string) => Result<PackageJson, JsonTextError>;

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

@@ -0,0 +1,21 @@
+import { parse as jsonParse } from "../../json/parser/module.f.js";
+import { tokenize as jsonTokenize } from "../../json/tokenizer/module.f.js";
+import { stringToList } from "../../text/utf16/module.f.js";
+import { option, record, string } from "../../types/rtti/module.f.js";
+import { validate as rttiValidate } from "../../types/rtti/validate/module.f.js";
+import { error, ok } from "../../types/result/module.f.js";
+export const packageJsonSchema = {
+    name: option(string),
+    version: option(string),
+    scripts: option(record(string)),
+};
+export const validatePackageJson = rttiValidate(packageJsonSchema);
+const parseJsonText = (text) => jsonParse(jsonTokenize(stringToList(text)));
+export const validatePackageJsonText = (text) => {
+    const [t, v] = parseJsonText(text);
+    if (t === 'error') {
+        return error(v);
+    }
+    const [t2, v2] = validatePackageJson(v);
+    return t2 === 'ok' ? ok(v2) : error(v2);
+};

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

@@ -0,0 +1,5 @@
+export declare const proof: {
+    parseMetadata: () => void;
+    malformedJson: () => void;
+    validatePreservesOriginalObject: () => void;
+};

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

@@ -0,0 +1,23 @@
+import { assert } from "../../asserts/module.f.js";
+import { unwrap } from "../../types/result/module.f.js";
+import { validatePackageJson, validatePackageJsonText, } from "./module.f.js";
+export const proof = {
+    parseMetadata: () => {
+        const result = unwrap(validatePackageJsonText('{"name":"x","version":"1.0.0","scripts":{"test":"node test.js"}}'));
+        assert(result.name === 'x', result);
+        assert(result.version === '1.0.0', result);
+        assert(result.scripts?.test === 'node test.js', result);
+    },
+    malformedJson: () => {
+        const result = validatePackageJsonText('{');
+        assert(result[0] === 'error', result);
+    },
+    validatePreservesOriginalObject: () => {
+        const object = { name: 'x', version: '1.0.0', private: true };
+        const metadata = unwrap(validatePackageJson(object));
+        assert(metadata.name === 'x', metadata);
+        assert(metadata.version === '1.0.0', metadata);
+        assert(Object.is(metadata, object), metadata);
+        assert(object.private === true, object);
+    },
+};

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.26.0",
+  "version": "0.28.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -11,10 +11,9 @@
     "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 && 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"
   },
@@ -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,27 +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";
-const { stringify, parse } = JSON;
-const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = (name) => begin
-    .step(() => readFile(jsonFile(name)))
-    .step(v => pure(parse(utf8ToString(unwrap(v)))));
-const writeVersion = (version) => (name) => begin
-    .step(() => readJson(name))
-    .step(json => writeFile(jsonFile(name), utf8(stringify({
-    ...json,
-    version,
-}, null, 2))));
-export const updateVersion = begin
-    .step(() => readJson('package'))
-    .step(p => {
-    const w = writeVersion(p.version);
-    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];
-        }
-    }
-};