functionalscript 0.30.0 → 0.31.1

package/fs/cbase32/module.f.js

@@ -4,32 +4,11 @@
  * @module
  */
 import { msb, lsb, length, vec, empty } from "../types/bit_vec/module.f.js";
+import { baseN } from "../base_n/module.f.js";
 //                         0123456789abcdef
 const m = '0123456789abcdefghjkmnpqrstvwxyz';
-const { popFront, concat } = msb;
+const { concat } = msb;
 const popBack1 = lsb.popFront(1n);
-const popFront5 = popFront(5n);
-export const vec5xToCBase32 = (v) => {
-    let result = '';
-    while (true) {
-        const len = length(v);
-        if (len === 0n) {
-            break;
-        }
-        const [r, rest] = popFront5(v);
-        result += m[Number(r)];
-        v = rest;
-    }
-    return result;
-};
-export const vecToCBase32 = (v) => {
-    const len = length(v);
-    const extraLen = 5n - len % 5n;
-    const last = 1n << (extraLen - 1n);
-    const padded = concat(v)(vec(extraLen)(last));
-    return vec5xToCBase32(padded);
-};
-const vec5 = vec(5n);
 const normalizeChar = (c) => {
     const lower = c.toLowerCase();
     switch (lower) {
@@ -47,30 +26,30 @@ const normalizeChar = (c) => {
         }
     }
 };
-const toCrockfordIndex = (c) => m.indexOf(normalizeChar(c));
-export const cBase32ToVec5x = (s) => {
-    let result = empty;
-    for (const c of s) {
-        const index = toCrockfordIndex(c);
-        if (index < 0) {
-            return null;
-        }
-        const v = vec5(BigInt(index));
-        result = concat(result)(v);
-    }
-    return result;
+const codec = baseN(5n, m, normalizeChar);
+export const vec5xToCBase32 = codec.vecToString;
+export const cBase32ToVec5x = codec.stringToVec;
+export const vecToCBase32 = (v) => {
+    const len = length(v);
+    const extraLen = 5n - len % 5n;
+    const last = 1n << (extraLen - 1n);
+    const padded = concat(v)(vec(extraLen)(last));
+    return vec5xToCBase32(padded);
 };
 export const cBase32ToVec = (s) => {
     let v = cBase32ToVec5x(s);
-    if (v === null || v === empty) {
+    if (v === null) {
         return null;
     }
-    // TODO: replace with a function that computes trailing zeros.
-    while (true) {
-        const [last, v0] = popBack1(v);
-        v = v0;
+    // Strip the padding: trailing zeros up to and including the sentinel `1` bit.
+    // A string with no sentinel — only zero symbols (`0`/`o`), or empty — exhausts
+    // to `empty` and is rejected as `null` rather than looping forever.
+    while (v !== empty) {
+        const [last, rest] = popBack1(v);
+        v = rest;
         if (last === 1n) {
             return v;
         }
     }
+    return null;
 };

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

@@ -3,4 +3,5 @@ export declare const proof: {
     roundtrip: () => void;
     unalignedBits: () => void;
     caseInsensitive: () => void;
+    unterminated: () => void;
 };

package/fs/cbase32/proof.f.js

@@ -70,5 +70,20 @@ export const proof = {
         if (cBase32ToVec5x("u") !== null) {
             throw 'should error on invalid character';
         }
+    },
+    unterminated: () => {
+        // No sentinel `1` bit → invalid; must return null, not loop forever.
+        if (cBase32ToVec("") !== null) {
+            throw 'empty must be null';
+        }
+        if (cBase32ToVec("0") !== null) {
+            throw 'single zero symbol must be null';
+        }
+        if (cBase32ToVec("00") !== null) {
+            throw 'all-zero symbols must be null';
+        }
+        if (cBase32ToVec("o") !== null) {
+            throw 'o (maps to 0) must be null';
+        }
     }
 };

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

@@ -19,18 +19,18 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
-export declare const functionalscript: "0.29.1";
+export declare const functionalscript: "0.30.0";
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.2";
-export declare const playwright = "1.60.0";
+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.2";
+    readonly node22: "22.22.3";
     readonly node24: "24.16.0";
 };
-export declare const wasmtime = "45.0.0";
+export declare const wasmtime = "45.0.2";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260606.1";
+export declare const tsgo = "7.0.0-dev.20260615.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";

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

@@ -24,25 +24,25 @@ 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.29.1';
+export const functionalscript = '0.30.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.2';
+export const deno = '2.8.3';
 // https://www.npmjs.com/package/playwright
-export const playwright = '1.60.0';
+export const playwright = '1.61.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.3.0',
-    node22: '22.22.2',
+    node22: '22.22.3',
     node24: '24.16.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '45.0.0';
+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.20260606.1';
+export const tsgo = '7.0.0-dev.20260615.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

@@ -6,11 +6,11 @@
  */
 import { deno } from "../config/module.f.js";
 import { clean, install, test, uses } from "../common/module.f.js";
-const denoTest = 'deno test --allow-read --allow-env';
+const denoTest = 'deno test --allow-read --allow-env --allow-sys';
 export const denoSteps = (version) => clean([
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
     install({ run: `deno install -g -A npm:functionalscript@${version}` }),
-    test({ run: 'deno install --frozen' }),
     test({ run: `deno run -A npm:functionalscript@${version} t` }),
+    test({ run: 'deno install --frozen' }),
     test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
 ]);

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

@@ -1,3 +1,8 @@
+/**
+ * Continuous integration helper commands for repository automation tasks.
+ *
+ * @module
+ */
 import { type Effect } from '../effects/module.f.ts';
 import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';

package/fs/ci/module.f.js

@@ -3,9 +3,8 @@
  *
  * @module
  */
-import { utf8 } from "../text/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { access, writeFile } from "../effects/node/module.f.js";
+import { access, writeUtf8File } from "../effects/node/module.f.js";
 import { functionalscript, images } from "./config/module.f.js";
 import { architecture, os, toSteps, ubuntuArm } from "./common/module.f.js";
 import { rustPlatformSteps, rustWasmSteps } from "./rust/module.f.js";
@@ -47,7 +46,7 @@ export const ci = ({ nodeExtra }) => access('Cargo.toml').step(result => {
         },
         jobs,
     };
-    return writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
+    return writeUtf8File('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '))
         .step(() => pure(0));
 });
 export const main = () => ci({ nodeExtra: () => [] });

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

@@ -12,4 +12,5 @@ export declare const proof: {
         configuredPackageVersion: () => void;
         missingPackageJson: () => void;
     };
+    ubuntu: () => void;
 };

package/fs/ci/proof.f.js

@@ -2,12 +2,13 @@ import { ci, main } from "./module.f.js";
 import { functionalscript } from "./config/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 { test, ubuntu, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
 import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 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)));
+import { definedValues } from "../types/object/module.f.js";
+const hasRun = (cmd) => (gha) => definedValues(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, packageJson) => ({
     ...emptyState,
@@ -115,7 +116,7 @@ export const proof = {
             assert(hasRun(`deno install -g -A npm:functionalscript@${functionalscript}`)(gha), 'expected configured-version deno install cache');
             assert(hasRun('deno install --frozen')(gha), 'expected deno lock install');
             assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
-            assert(hasRun("deno test --allow-read --allow-env --coverage && deno coverage --include='.*module\\.f\\.ts'")(gha), 'expected limited-permission deno coverage');
+            assert(hasRun("deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='.*module\\.f\\.ts'")(gha), 'expected limited-permission deno coverage');
             assert(hasRun(`bun install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version bun cache');
             assert(hasRun('bun install --frozen-lockfile')(gha), 'expected bun lock install');
             assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected configured-version bun install');
@@ -125,4 +126,9 @@ export const proof = {
             assert(hasRun(`npm install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version install');
         },
     },
+    ubuntu: () => {
+        const job = ubuntu([test({ run: 'echo hi' })]);
+        assert(job['runs-on'] !== undefined, 'expected runs-on');
+        assert(job.steps.length > 0, 'expected steps');
+    },
 };

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

@@ -1,9 +1,11 @@
 import { type NodeOp, type NodeProgramOptions, type Write } from '../effects/node/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
+type Handler<O extends NodeOp> = (options: NodeProgramOptions) => Effect<O, number>;
 export type Command<O extends NodeOp> = {
     readonly names: readonly string[];
     readonly description: string;
-    readonly handler: (options: NodeProgramOptions) => Effect<O, number>;
+    readonly handler: Handler<O> | Commands<O>;
 };
 export type Commands<O extends NodeOp> = readonly Command<O>[];
 export declare const dispatch: <O extends NodeOp>(commands: Commands<O>) => (options: NodeProgramOptions) => Effect<O | Write, number>;
+export {};

package/fs/cli/module.f.js

@@ -1,24 +1,34 @@
 import { errorExit, log } from "../effects/node/module.f.js";
 import { pure } from "../effects/module.f.js";
+import { at, fromEntries } from "../types/object/module.f.js";
 const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' };
 export const dispatch = (commands) => (options) => {
     const [cmd, ...rest] = options.args;
     const rows = [...commands, helpMeta];
-    const nameCol = rows.map(c => c.names.join(', '));
-    const width = Math.max(...nameCol.map(s => s.length));
-    const helpText = ['Available commands:', ...rows.map((c, i) => `  ${nameCol[i].padEnd(width)}  ${c.description}`)].join('\n');
-    const helpCommand = {
-        ...helpMeta,
-        handler: () => log(helpText).step(() => pure(0)),
-    };
-    const allCommands = [...commands, helpCommand];
-    const map = Object.fromEntries(allCommands.flatMap(c => c.names.map(n => [n, c])));
+    const nameCol = rows.map(({ names }) => names.join(', '));
+    const width = Math.max(...nameCol.map(({ length }) => length));
+    const helpText = [
+        'Available commands:',
+        ...rows.map(({ description }, i) => `  ${nameCol[i].padEnd(width)}  ${description}`)
+    ].join('\n');
+    const map = fromEntries(commands.flatMap(c => c.names.map(n => [n, c])));
     if (cmd === undefined) {
         return errorExit(`Error: command is required.\n${helpText}`);
     }
-    const found = map[cmd];
-    if (found === undefined) {
+    if (helpMeta.names.includes(cmd)) {
+        const [target] = rest;
+        if (target !== undefined) {
+            const targetCmd = at(target)(map);
+            if (targetCmd !== null && typeof targetCmd.handler !== 'function') {
+                return dispatch(targetCmd.handler)({ ...options, args: ['help'] });
+            }
+        }
+        return log(helpText).step(() => pure(0));
+    }
+    const found = at(cmd)(map);
+    if (found === null) {
         return errorExit(`Error: unknown command "${cmd}".\n${helpText}`);
     }
-    return found.handler({ ...options, args: rest });
+    const { handler } = found;
+    return (typeof handler === 'function' ? handler : dispatch(handler))({ ...options, args: rest });
 };

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

@@ -6,4 +6,9 @@ export declare const proof: {
     help: () => void;
     errorIncludesAvailable: () => void;
     handlerReceivesRemainingArgs: () => void;
+    nestedCommands: () => void;
+    nestedHelp: () => void;
+    prototypeNameIsUnknownCommand: () => void;
+    helpPrototypeSafe: () => void;
+    helpWithTarget: () => void;
 };

package/fs/cli/proof.f.js

@@ -5,6 +5,7 @@ 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 () => { } },
@@ -83,4 +84,79 @@ export const proof = {
             throw ['unexpected args', captured];
         }
     },
+    nestedCommands: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(42),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [, code] = run(outer)(['sub', 'ping']);
+        if (code !== 42) {
+            throw ['expected 42', code];
+        }
+    },
+    nestedHelp: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(0),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [state, code] = run(outer)(['sub', 'help']);
+        if (code !== 0) {
+            throw ['expected exit 0', code];
+        }
+        if (!state.stdout.includes('ping')) {
+            throw 'expected inner command in help';
+        }
+    },
+    prototypeNameIsUnknownCommand: () => {
+        const [state, code] = run(echoCommands)(['toString']);
+        if (code !== 1) {
+            throw ['expected exit 1 for prototype-name command', code];
+        }
+        if (!state.stderr.includes('unknown command')) {
+            throw 'expected unknown-command error in stderr';
+        }
+    },
+    helpPrototypeSafe: () => {
+        const [state, code] = run(echoCommands)(['help', 'toString']);
+        if (code !== 0) {
+            throw ['expected exit 0, not a throw', code];
+        }
+        if (!state.stdout.includes('echo')) {
+            throw 'expected top-level help for unknown target';
+        }
+    },
+    helpWithTarget: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(0),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [state, code] = run(outer)(['help', 'sub']);
+        if (code !== 0) {
+            throw ['expected exit 0', code];
+        }
+        if (!state.stdout.includes('ping')) {
+            throw 'expected inner command in help';
+        }
+        if (state.stdout.includes('Subcommand group')) {
+            throw 'expected inner help, not outer';
+        }
+    },
 };

package/fs/crypto/hmac/proof.f.d.ts

@@ -3,4 +3,5 @@ export declare const proof: {
     sha256: () => void;
     sha384: () => void;
     sha512: () => void;
+    longKey: () => void;
 };

package/fs/crypto/hmac/proof.f.js

@@ -1,3 +1,4 @@
+import { assertEq } from "../../asserts/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
@@ -28,5 +29,12 @@ export const proof = {
         if (r !== vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an)) {
             throw r;
         }
+    },
+    // RFC 4231 Test Case 6: key (131 bytes of 0xaa = 1048 bits) exceeds SHA-256 block size (512 bits),
+    // so the key is first compressed via the hash function before use.
+    longKey: () => {
+        const key = vec(1048n)(BigInt('0x' + 'aa'.repeat(131)));
+        const r = hmac(sha256)(key)(utf8('Test Using Larger Than Block-Size Key - Hash Key First'));
+        assertEq(uint(r), 0x60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54n);
     }
 };

package/fs/crypto/secp/proof.f.d.ts

@@ -4,4 +4,5 @@ export declare const proof: {
     poker: () => {
         [k: string]: () => void;
     };
+    nullPointOps: () => void;
 };

package/fs/crypto/secp/proof.f.js

@@ -1,3 +1,4 @@
+import { assert } from "../../asserts/module.f.js";
 import { prime_field } from "../../types/prime_field/module.f.js";
 import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from "./module.f.js";
 const poker = (param) => () => {
@@ -131,5 +132,14 @@ export const proof = {
             //secp256r1,
         };
         return Object.fromEntries(Object.entries(c).map(([k, v]) => [k, poker(v)]));
+    },
+    // Cover null (point at infinity) branches in neg, add, and eq.
+    nullPointOps: () => {
+        const c = secp256k1;
+        assert(c.neg(null) === null);
+        assert(eq(null)(null));
+        assert(!eq(null)(c.g));
+        assert(!eq(c.g)(null));
+        assert(eq(c.add(c.g)(null))(c.g));
     }
 };

package/fs/crypto/sign/module.f.js

@@ -1,10 +1,7 @@
-import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
+import { bitLength, divUp8, roundUp8 } from "../../types/bigint/module.f.js";
 import { empty, length, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
 import { computeSync } from "../sha2/module.f.js";
-// qlen to rlen
-const roundUp8 = roundUp(8n);
-const divUp8 = divUp(8n);
 /**
  * Builds RFC6979 helper conversions for a subgroup order.
  *

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

@@ -4,14 +4,13 @@
  * @module
  */
 import { type Access, type All, type Env, type Import, type Readdir } from '../effects/node/module.f.ts';
+import type { StringMap } from '../types/object/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
-export type ModuleMap = {
-    readonly [k in string]: Module;
-};
+export type ModuleMap = StringMap<string, Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -41,3 +40,6 @@ 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 proof: {
+    isSourceFile: () => void;
+};

package/fs/dev/module.f.js

@@ -7,7 +7,8 @@ import { all, import_, readdir } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { relativize, toPosix } from "../path/module.f.js";
+import { join, relativize, toPosix } from "../path/module.f.js";
+import { assert } from "../asserts/module.f.js";
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -32,7 +33,7 @@ const allFiles = (s, predicate) => {
             if (name.startsWith('.')) {
                 continue;
             }
-            const file = `${p}/${name}`;
+            const file = join(p, name);
             if (!i.isFile) {
                 if (name === 'node_modules') {
                     continue;
@@ -80,3 +81,13 @@ export const loadModuleMap = (env) => {
         .map(([k, v]) => [relativize(prefix, k), v])
         .toSorted(([a], [b]) => strCmp(a)(b)))));
 };
+export const proof = {
+    isSourceFile: () => {
+        assert(isSourceFile('module.js'));
+        assert(isSourceFile('module.ts'));
+        assert(isSourceFile('module.mts'));
+        assert(isSourceFile('module.mjs'));
+        assert(!isSourceFile('readme.md'));
+        assert(!isSourceFile('module.json'));
+    },
+};

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

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

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

@@ -12,6 +12,11 @@ export const proof = {
         const result = validatePackageJsonText('{');
         assert(result[0] === 'error', result);
     },
+    validationError: () => {
+        // valid JSON but `name` is a number, not a string — validation should fail
+        const result = validatePackageJsonText('{"name": 42}');
+        assert(result[0] === 'error', result);
+    },
     validatePreservesOriginalObject: () => {
         const object = { name: 'x', version: '1.0.0', private: true };
         const metadata = unwrap(validatePackageJson(object));

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

@@ -1,4 +1,5 @@
 export declare const proof: {
+    shouldLoad: () => void;
     shouldPass: () => {
         then: () => undefined;
     };

package/fs/dev/proof.f.js

@@ -1,5 +1,16 @@
-import { todo } from "../asserts/module.f.js";
+import { assert, todo } from "../asserts/module.f.js";
+import { shouldLoad } from "./module.f.js";
 export const proof = {
+    shouldLoad: () => {
+        assert(shouldLoad('foo.f.ts'));
+        assert(shouldLoad('bar.f.js'));
+        assert(shouldLoad('proof.ts'));
+        assert(shouldLoad('proof.js'));
+        assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.mjs'));
+        assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('readme.md'));
+    },
     shouldPass: () => ({
         then: () => undefined
     }),

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

@@ -9,7 +9,7 @@ export type AstConst = Primitive | AstModuleRef | AstArray | AstObject;
 export type AstModuleRef = ['aref' | 'cref', number];
 export type AstArray = ['array', readonly AstConst[]];
 export type AstObject = {
-    readonly [k in string]: AstConst;
+    readonly [k in string]?: AstConst;
 };
 export type AstBody = readonly AstConst[];
 export declare const run: (body: AstBody) => (args: Array) => Unknown;

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

@@ -4,4 +4,9 @@ export declare const proof: {
     testAref: () => void;
     testArray: () => void;
     testObj: () => void;
+    testBool: () => void;
+    testStr: () => void;
+    testNull: () => void;
+    testBigint: () => void;
+    testUndefined: () => void;
 };

package/fs/djs/ast/proof.f.js

@@ -1,6 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 export const proof = {
     test: () => {
         const djs = run([1])([]);
@@ -37,4 +38,20 @@ export const proof = {
             throw result;
         }
     },
+    testBool: () => {
+        assertEq(stringifyAsTree(sort)(run([true])([])), 'true');
+        assertEq(stringifyAsTree(sort)(run([false])([])), 'false');
+    },
+    testStr: () => {
+        assertEq(stringifyAsTree(sort)(run(['hello'])([])), '"hello"');
+    },
+    testNull: () => {
+        assertEq(stringifyAsTree(sort)(run([null])([])), 'null');
+    },
+    testBigint: () => {
+        assertEq(stringifyAsTree(sort)(run([42n])([])), '42n');
+    },
+    testUndefined: () => {
+        assertEq(stringifyAsTree(sort)(run([undefined])([])), 'undefined');
+    },
 };

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

@@ -7,7 +7,7 @@ import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 import { type WriteFile, type ReadFile, type Write } from '../effects/node/module.f.ts';
 export type Object = {
-    readonly [k in string]: Unknown;
+    readonly [k in string]?: Unknown;
 };
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;