functionalscript 0.32.4 → 0.33.0

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

@@ -11,4 +11,7 @@ export declare const proof: {
     repeat: (() => void)[];
     repeatParser: (() => void)[];
     example: () => void;
+    throw: {
+        ambiguousVariantDispatch: () => void;
+    };
 };

package/fs/bnf/data/proof.f.js

@@ -763,5 +763,12 @@ export const proof = {
                 'digit': 'digit',
             }
         };
+    },
+    throw: {
+        ambiguousVariantDispatch: () => {
+            // Two alternatives covering the same code point — dispatch merge throws.
+            const conflictRule = { 'a': range('AA'), 'b': range('AA') };
+            dispatchMap(toData(conflictRule)[0]);
+        }
     }
 };

package/fs/cas/mcp/module.f.js

@@ -112,7 +112,9 @@ const casToolRegistry = (c, home, toUrl) => {
             }
             return x.step(value => typeof value === 'string'
                 ? pure(errorResult(value))
-                : c.write(value).step(hash => pure(okResult(vecToCBase32(hash)))));
+                : c.write(value).step(hash => pure(hash === undefined
+                    ? errorResult('write')
+                    : okResult(vecToCBase32(hash)))));
         }),
         toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mime_type,type[,url]} where type is "text" or "base64". Pass content:true to also include the inline content string.', casGetArgs, r => {
             const key = cBase32ToVec(r.hash);

package/fs/cas/mcp/proof.f.js

@@ -5,9 +5,9 @@ import { asBase, asNominal, create, read, write } from "../../effects/memory/mod
 import { msb, u8ListToVec, vec8 } from "../../types/bit_vec/module.f.js";
 import { vecToCBase32 } from "../../cbase32/module.f.js";
 import { encode as base64Encode } from "../../base64/module.f.js";
-import { sha256 } from "../../crypto/sha2/module.f.js";
+import { computeSync, sha256 } from "../../crypto/sha2/module.f.js";
 import { utf8 } from "../../text/module.f.js";
-import { cas, fileKvStore } from "../module.f.js";
+import { fileCas } from "../module.f.js";
 import { mcpStep, uninitializedState, } from "../../mcp/module.f.js";
 import {} from "../../effects/node/module.f.js";
 import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
@@ -34,9 +34,14 @@ const mock = {
     randomInt: () => _ => { throw new Error('randomInt not supported in memory mock'); },
 };
 const runMem = (effect) => run(mock)(initialTestState)(effect)[1];
-const memKvStore = (mapKey) => ({
+const memCas = (mapKey) => ({
     read: (key) => read(mapKey).step(m => pure(m[vecToCBase32(key)]?.[1])),
-    write: (key, value) => read(mapKey).step(m => write(mapKey, { ...m, [vecToCBase32(key)]: [key, value] })),
+    write: (value) => {
+        const key = computeSync(sha256)([value]);
+        return read(mapKey)
+            .step(m => write(mapKey, { ...m, [vecToCBase32(key)]: [key, value] }))
+            .step(() => pure(key));
+    },
     list: () => read(mapKey).step(m => pure(Object.values(m).map(([k]) => k))),
 });
 // ── Session driver ──────────────────────────────────────────────────────────────
@@ -49,7 +54,7 @@ const feed = (step) => (msgs) => {
 };
 // Runs a full session over a fresh in-memory CAS, returning all responses.
 const runSession = (msgs, home = '/home/user') => runMem(create({}).step(mapKey => create(uninitializedState).step(sessionKey => {
-    const c = cas(sha256)(memKvStore(mapKey));
+    const c = memCas(mapKey);
     const step = mcpStep(casConfig)(casMcpHandlers(c, home))(sessionKey);
     return feed(step)(msgs);
 })));
@@ -58,7 +63,7 @@ const runSession = (msgs, home = '/home/user') => runMem(create({}).step(mapKey
 // the same filesystem-backed CAS.
 const runSessionVirtual = (root, home = '/home/user') => (msgs) => {
     const effect = create(uninitializedState).step(sessionKey => {
-        const c = cas(sha256)(fileKvStore(home));
+        const c = fileCas(sha256)(home);
         const step = mcpStep(casConfig)(casMcpHandlers(c, home))(sessionKey);
         return feed(step)(msgs);
     });
@@ -218,7 +223,7 @@ export const proof = {
     // cas_add with type:'url' streams a file from /home/user/cas_upload/ into CAS.
     addUrlStoresFileAndReturnsHash: () => {
         const fileContent = utf8('hello from file');
-        const root = { 'home': { 'user': { 'cas_upload': { 'hello.txt': fileContent } } } };
+        const root = { 'home': { 'user': { 'cas_upload': { 'hello.txt': [fileContent] } } } };
         const [addUrlResp] = runSessionVirtual(root)([
             init, initialized,
             call(2, 'cas_add', { content: '/home/user/cas_upload/hello.txt', type: 'url' }),
@@ -228,7 +233,7 @@ export const proof = {
     },
     addUrlRoundTrips: () => {
         const fileContent = utf8('round-trip content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'rt.txt': fileContent } } } };
+        const root = { 'home': { 'user': { 'cas_upload': { 'rt.txt': [fileContent] } } } };
         // First pass: add to get the hash (deterministic for same content).
         const [addResp] = runSessionVirtual(root)([
             init, initialized,
@@ -256,7 +261,7 @@ export const proof = {
     // cas_get without content:true returns only metadata.
     getMetaReturnsLengthAndMimeType: () => {
         const fileContent = utf8('text content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'f': fileContent } } } };
+        const root = { 'home': { 'user': { 'cas_upload': { 'f': [fileContent] } } } };
         // First pass: add to get the hash.
         const [addResp] = runSessionVirtual(root)([
             init, initialized,
@@ -321,7 +326,7 @@ export const proof = {
     // cas_add type:'url' with a subdirectory path flattens slashes to '-' in staging.
     addUrlFromSubdirectorySucceeds: () => {
         const fileContent = utf8('nested file content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'subdir': { 'file.txt': fileContent } } } } };
+        const root = { 'home': { 'user': { 'cas_upload': { 'subdir': { 'file.txt': [fileContent] } } } } };
         const [resp] = runSessionVirtual(root)([
             init, initialized,
             call(2, 'cas_add', { content: '/home/user/cas_upload/subdir/file.txt', type: 'url' }),
@@ -332,7 +337,7 @@ export const proof = {
     // cas_add with type:'url' accepts paths within /home/user/cas_upload/
     addUrlFromApprovedDirectorySucceeds: () => {
         const fileContent = utf8('approved file');
-        const root = { 'home': { 'user': { 'cas_upload': { 'test.txt': fileContent } } } };
+        const root = { 'home': { 'user': { 'cas_upload': { 'test.txt': [fileContent] } } } };
         const [resp] = runSessionVirtual(root)([
             init, initialized,
             call(2, 'cas_add', { content: '/home/user/cas_upload/test.txt', type: 'url' }),

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

@@ -9,40 +9,26 @@ import { type Effect, type Operation } from '../effects/module.f.ts';
 import { type Access, type All, type IoResult, type Mkdir, type NodeProgramOptions, type RandomInt, type Read, type ReadBytes, type Readdir, type ReadFile, type Rename, type Write, type WriteFile } from '../effects/node/module.f.ts';
 import { type Commands } from '../cli/module.f.ts';
 import type { MemOp } from '../effects/memory/module.f.ts';
-export type KvStore<O extends Operation> = {
-    /** Reads a value by key; returns `undefined` when the key does not exist. */
-    readonly read: (key: Vec) => Effect<O, Vec | undefined>;
-    /** Writes a key/value pair to the underlying storage. */
-    readonly write: (key: Vec, value: Vec) => Effect<O, void>;
-    /** Lists all keys available in the store. */
-    readonly list: () => Effect<O, readonly Vec[]>;
-};
-/** A key/value tuple where index `0` is the key and index `1` is the value. */
-export type Kv = readonly [Vec, Vec];
 /** Converts a content key to its sharded relative CAS file path. */
 export declare const toPath: (key: Vec) => string;
-export type FileKvStoreOperation = ReadFile | Mkdir | WriteFile | Access | Readdir;
-/**
- * Creates a filesystem-backed key/value store under the provided root path.
- */
-export declare const fileKvStore: (path: string) => KvStore<FileKvStoreOperation>;
+export type FileCasOperation = ReadFile | Mkdir | WriteFile | Access | Readdir;
 export type Cas<O extends Operation> = {
     /** Reads content by hash; returns `undefined` when not found. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
     /** Stores content and returns its computed hash. */
-    readonly write: (value: Vec) => Effect<O, Vec>;
+    readonly write: (value: Vec) => Effect<O, Vec | undefined>;
     /** Lists all stored content hashes. */
     readonly list: () => Effect<O, readonly Vec[]>;
 };
 /**
  * Builds a content-addressable storage facade from a SHA-2 implementation.
  */
-export declare const cas: (sha2: Sha2) => <O extends Operation>(_: KvStore<O>) => Cas<O>;
+export declare const fileCas: (sha2: Sha2) => (path: string) => Cas<FileCasOperation>;
 /**
  * Move-hash-move upload pipeline: moves `fileName` from `~/cas_upload/` to a
  * random staging path, stream-hashes it, then renames it to its final CAS shard
  * path. Returns `ok(hash)` on success or `error(reason)` on any I/O failure.
  */
 export declare const casUpload: (home: string) => (fileName: string) => Effect<Mkdir | Rename | RandomInt | ReadBytes, IoResult<Vec>>;
-export declare const commands: Commands<FileKvStoreOperation | Write | All | MemOp | Read>;
-export declare const main: (options: NodeProgramOptions) => Effect<All | Read | Write | FileKvStoreOperation | MemOp, number>;
+export declare const commands: Commands<FileCasOperation | Write | All | MemOp | Read>;
+export declare const main: (options: NodeProgramOptions) => Effect<All | Read | Write | FileCasOperation | MemOp, number>;

package/fs/cas/module.f.js

@@ -10,11 +10,9 @@ import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
 import { foldStep, forEachStep, pure } from "../effects/module.f.js";
 import { access, errorExit, isNotFound, log, mkdir, randomInt, readBytes, readdir, readFile, rename, writeFile } from "../effects/node/module.f.js";
 import { dispatch } from "../cli/module.f.js";
-import { casMcpServer } from "./mcp/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { error, ok, unwrap } from "../types/result/module.f.js";
 import { splitAt } from "../types/string/module.f.js";
-const o = { withFileTypes: true };
 const split2 = splitAt(2);
 const prefix = '.cas';
 /** Converts a content key to its sharded relative CAS file path. */
@@ -24,57 +22,46 @@ export const toPath = (key) => {
     const [b, c] = split2(bc);
     return join(prefix, a, b, c);
 };
-/**
- * Creates a filesystem-backed key/value store under the provided root path.
- */
-export const fileKvStore = (path) => {
-    const storePrefix = join(path, prefix);
-    const normalizedStorePrefix = normalize(storePrefix);
-    return {
-        // TODO: extend the interface with `Result<Vec, unknown>` instead of `Vec|undefined`.
-        read: (key) => readFile(join(path, toPath(key))).step(([t, v]) => pure(t === 'ok' ? v : undefined)),
-        write: (key, value) => {
-            const p = toPath(key);
-            const parts = parse(p);
-            const dir = join(path, ...parts.slice(0, -1));
-            // TODO: error handling
-            return mkdir(dir, { recursive: true })
-                .step(() => writeFile(join(path, p), value))
-                .step(() => pure(undefined));
-        },
-        list: () => 
-        // A fresh store has no `.cas` directory yet. Treat *only* that case as an
-        // empty store, mirroring how `read` maps a missing file to `undefined`.
-        // A `.cas` that exists but cannot be read (permissions, corruption) is a
-        // genuine storage error and is surfaced, not masked as "no hashes".
-        access(storePrefix).step(a => {
-            if (a[0] === 'error') {
-                if (isNotFound(a[1])) {
-                    return pure([]);
-                }
-                throw a[1];
-            }
-            return readdir(storePrefix, { recursive: true })
-                .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
-                ? cBase32ToVec(normalize(parentPath).substring(normalizedStorePrefix.length).replaceAll('/', '') + name)
-                : null))));
-        }),
-    };
-};
 /**
  * Builds a content-addressable storage facade from a SHA-2 implementation.
  */
-export const cas = (sha2) => {
+export const fileCas = (sha2) => {
     const compute = computeSync(sha2);
-    return ({ read, write, list }) => ({
-        read,
-        write: (value) => {
-            const hash = compute([value]);
-            return write(hash, value)
-                .step(() => pure(hash));
-        },
-        list,
-    });
+    return (path) => {
+        const storePrefix = join(path, prefix);
+        const normalizedStorePrefix = normalize(storePrefix);
+        return {
+            // TODO: extend the interface with `Result<Vec, unknown>` instead of `Vec|undefined`.
+            read: (key) => readFile(join(path, toPath(key))).step(([t, v]) => pure(t === 'ok' ? v : undefined)),
+            write: (value) => {
+                const hash = compute([value]);
+                const p = toPath(hash);
+                const parts = parse(p);
+                const dir = join(path, ...parts.slice(0, -1));
+                // TODO: error handling
+                return mkdir(dir, { recursive: true })
+                    .step(() => writeFile(join(path, p), value))
+                    .step(([t]) => pure(t === 'ok' ? hash : undefined));
+            },
+            list: () => 
+            // A fresh store has no `.cas` directory yet. Treat *only* that case as an
+            // empty store, mirroring how `read` maps a missing file to `undefined`.
+            // A `.cas` that exists but cannot be read (permissions, corruption) is a
+            // genuine storage error and is surfaced, not masked as "no hashes".
+            access(storePrefix).step(a => {
+                if (a[0] === 'error') {
+                    if (isNotFound(a[1])) {
+                        return pure([]);
+                    }
+                    throw a[1];
+                }
+                return readdir(storePrefix, { recursive: true })
+                    .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
+                    ? cBase32ToVec(normalize(parentPath).substring(normalizedStorePrefix.length).replaceAll('/', '') + name)
+                    : null))));
+            }),
+        };
+    };
 };
 /** Maximum chunk size for streaming reads: the largest `Vec` the runtime allows. */
 const CHUNK_BYTES = Number(maxLengthBytes);
@@ -141,11 +128,12 @@ export const commands = [
             if (path === undefined || rest.length !== 0) {
                 return errorExit("'cas add' expects one parameter");
             }
-            const c = cas(sha256)(fileKvStore(home));
+            const c = fileCas(sha256)(home);
             return readFile(path)
                 .step(v => c.write(unwrap(v)))
-                .step(hash => log(vecToCBase32(hash)))
-                .step(() => pure(0));
+                .step(hash => hash === undefined
+                ? pure(1)
+                : log(vecToCBase32(hash)).step(() => pure(0)));
         },
     },
     {
@@ -159,7 +147,7 @@ export const commands = [
             if (hash === null) {
                 return errorExit(`invalid hash format: ${hashCBase32}`);
             }
-            const c = cas(sha256)(fileKvStore(home));
+            const c = fileCas(sha256)(home);
             return c.read(hash)
                 .step(v => {
                 const result = v === undefined
@@ -174,7 +162,7 @@ export const commands = [
         names: ['list'],
         description: 'List all stored content hashes',
         handler: ({ home }) => {
-            const c = cas(sha256)(fileKvStore(home));
+            const c = fileCas(sha256)(home);
             return c.list()
                 .step(forEachStep(j => log(vecToCBase32(j))))
                 .step(() => pure(0));

package/fs/cas/proof.f.js

@@ -1,25 +1,17 @@
-import { cas, commands } from "./module.f.js";
-import { sha256 } from "../crypto/sha2/module.f.js";
+import { commands } from "./module.f.js";
+import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
 import { pure } from "../effects/module.f.js";
 import { run } from "../effects/mock/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { dispatch } from "../cli/module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+import { assert } from "../asserts/module.f.js";
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const main = dispatch(commands);
 export const proof = {
     mainAdd: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode !== 0) {
             throw ['expected exit 0', exitCode];
@@ -39,7 +31,7 @@ export const proof = {
     },
     mainGetFound: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode1 !== 0) {
             throw ['expected add exit 0', exitCode1];
@@ -53,7 +45,7 @@ export const proof = {
     mainGetNotFound: () => {
         // valid cBase32 hash that has not been stored
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         const hashStr = state1.stdout.trim();
         // use an empty store so the hash is not found
@@ -85,7 +77,7 @@ export const proof = {
     },
     mainList: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         const [, exitCode] = virtual(state1)(main(makeOptions(['list'])));
         if (exitCode !== 0) {
@@ -106,7 +98,7 @@ export const proof = {
     mainListCorruptStore: () => {
         // `.cas` exists but is a file, not a directory: a real storage error
         // that must surface, not be masked as an empty list.
-        const state = { ...emptyState, root: { '.cas': vec8(0x2an) } };
+        const state = { ...emptyState, root: { '.cas': [vec8(0x2an)] } };
         let threw = false;
         try {
             virtual(state)(main(makeOptions(['list'])));
@@ -137,26 +129,25 @@ export const proof = {
         }
     },
     casWrite: () => {
-        const store = {
+        const c = {
             read: (_key) => pure(undefined),
-            write: (_key, _value) => pure(undefined),
+            write: (value) => pure(computeSync(sha256)([value])),
             list: () => pure([]),
         };
-        const c = cas(sha256)(store);
         const [, hash] = run({})(undefined)(c.write(empty));
         // sha256 of empty input produces a 256-bit hash
+        assert(hash !== undefined);
         if (length(hash) !== 256n) {
             throw ['expected 256-bit hash', length(hash)];
         }
     },
     casReadPassthrough: () => {
         const stored = empty;
-        const store = {
+        const c = {
             read: (_key) => pure(stored),
-            write: (_key, _value) => pure(undefined),
+            write: (value) => pure(computeSync(sha256)([value])),
             list: () => pure([stored]),
         };
-        const c = cas(sha256)(store);
         const [, readResult] = run({})(undefined)(c.read(empty));
         if (readResult !== stored) {
             throw ['read should pass through', readResult];

package/fs/ci/config/module.f.d.ts

@@ -19,20 +19,20 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
-export declare const functionalscript: "0.30.0";
+export declare const functionalscript: "0.32.4";
 export declare const bun = "1.3.14";
 export declare const deno = "2.8.3";
 export declare const playwright = "1.61.0";
 export declare const node: {
-    readonly default: "26.3.0";
-    readonly node22: "22.22.3";
-    readonly node24: "24.16.0";
+    readonly default: "26.3.1";
+    readonly node22: "22.23.0";
+    readonly node24: "24.17.0";
 };
 export declare const wasmtime = "45.0.2";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260615.1";
+export declare const tsgo = "7.0.0-dev.20260620.1";
 export declare const actions: {
-    readonly 'actions/checkout': "v6";
+    readonly 'actions/checkout': "v7";
     readonly 'actions/setup-node': "v6";
     readonly 'actions/cache': "v5";
     readonly 'denoland/setup-deno': "v2";

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

@@ -24,7 +24,7 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version. A separate maintenance job advances this pin.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.30.0';
+export const functionalscript = '0.32.4';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
@@ -33,23 +33,23 @@ export const deno = '2.8.3';
 export const playwright = '1.61.0';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.3.0',
-    node22: '22.22.3',
-    node24: '24.16.0',
+    default: '26.3.1',
+    node22: '22.23.0',
+    node24: '24.17.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '45.0.2';
 // 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.20260615.1';
+export const tsgo = '7.0.0-dev.20260620.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]}` ``.
 // Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
 export const actions = {
     // https://github.com/marketplace/actions/checkout
-    'actions/checkout': 'v6',
+    'actions/checkout': 'v7',
     // https://github.com/marketplace/actions/setup-node-js-environment
     'actions/setup-node': 'v6',
     // https://github.com/marketplace/actions/cache

package/fs/ci/proof.f.js

@@ -14,18 +14,20 @@ const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
         '.github': { workflows: {} },
-        ...(packageJson !== undefined ? { 'package.json': utf8(packageJson) } : {}),
-        ...(rust ? { 'Cargo.toml': emptyVec } : {}),
+        ...(packageJson !== undefined ? { 'package.json': [utf8(packageJson)] } : {}),
+        ...(rust ? { 'Cargo.toml': [emptyVec] } : {}),
     },
 });
 const workflow = (state) => {
     const dotGithub = state.root['.github'];
-    assert(typeof dotGithub === 'object', dotGithub);
+    assert(typeof dotGithub === 'object' && !Array.isArray(dotGithub), dotGithub);
     const workflows = dotGithub['workflows'];
-    assert(typeof workflows === 'object', workflows);
+    assert(typeof workflows === 'object' && !Array.isArray(workflows), workflows);
     const file = workflows['ci.yml'];
-    assert(isVec(file), file);
-    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
+    if (!Array.isArray(file) || file.length === 0) {
+        throw file;
+    }
+    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file[0]))));
 };
 const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));

package/fs/cli/proof.f.js

@@ -1,17 +1,7 @@
 import { pure } from "../effects/module.f.js";
-import {} from "../effects/node/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { dispatch } from "./module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const echoCommands = [
     {
         names: ['echo', 'e'],

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

@@ -6,13 +6,8 @@
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
-import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
-export type ParseContext = {
-    readonly complete: OrderedMap<Result<AstModule, string>>;
-    readonly stack: List<string>;
-};
 export type ParseError = {
     readonly message: string;
     readonly metadata: TokenMetadata | null;

package/fs/djs/proof.f.js

@@ -1,13 +1,12 @@
 import { compile } from "./module.f.js";
 import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
-import { isVec } from "../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {
     const file = root[path];
-    if (!isVec(file)) {
+    if (!Array.isArray(file) || file.length === 0) {
         throw `${path} is not a file`;
     }
-    return utf8ToString(file);
+    return utf8ToString(file[0]);
 };
 export const proof = {
     tooFewArgs: {
@@ -31,7 +30,7 @@ export const proof = {
         },
     },
     success: () => {
-        const root = { 'input.f.js': utf8('export default 42') };
+        const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;
@@ -42,7 +41,7 @@ export const proof = {
         }
     },
     jsonOutput: () => {
-        const root = { 'input.f.js': utf8('export default 42') };
+        const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.json']));
         if (code !== 0) {
             throw code;
@@ -62,7 +61,7 @@ export const proof = {
         }
     },
     parseError: () => {
-        const root = { 'bad.f.js': utf8('export default @') };
+        const root = { 'bad.f.js': [utf8('export default @')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['bad.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;

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

@@ -8,9 +8,7 @@ import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export declare const undefinedSerialize: string[];
 type RefCounter = readonly [number, number];
-type Entry = ObjectEntry<Unknown>;
-type Entries = List<Entry>;
-type MapEntries = (entries: Entries) => Entries;
+type MapEntries = (entries: List<ObjectEntry<Unknown>>) => List<ObjectEntry<Unknown>>;
 type Refs = ReadonlyMap<Unknown, RefCounter>;
 export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
 export declare const stringify: (sort: MapEntries) => (djs: Unknown) => string;

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

@@ -20,7 +20,8 @@ export const jsGrammar = () => {
             escape: [
                 '\\',
                 {
-                    ...set('"\\/bfnrt'),
+                    ...set('"\\bfnrt'),
+                    solidus: '/',
                     u: [
                         'u',
                         ...repeat(4)({

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

@@ -3,6 +3,7 @@ export declare const proof: {
     tokenizer: (() => void)[];
     djs: (() => void)[];
     operators: (() => void)[];
+    ws: (() => void)[];
     throw: {
         parse: () => void;
     };