functionalscript 0.40.0 → 0.42.0

package/fjs/cas/evo/module.f.d.ts

@@ -17,7 +17,10 @@
  * subject (see [`fjs/media/revision/README.md`](../../media/revision/README.md)).
  * `Cache` therefore tracks, per subject, every revision hash seen and every
  * hash referenced as somebody's parent; heads are the set difference between
- * the two, computed at read time ({@link headsOf}). Storing both sets rather
+ * the two, computed at read time ({@link headsOf}). Alongside them it records
+ * which of the seen revisions are `archived`, so {@link Evo.list} can classify
+ * a subject as active or archived from its heads' flags
+ * ({@link subjectListed}) without touching the store. Storing both sets rather
  * than a running head list is what makes folding revisions truly order
  * independent: `cas.list()` (used by {@link buildCache} to scan an existing
  * store) returns hashes in hash order, not revision ancestry, so a child can
@@ -97,14 +100,22 @@ export type RevisionData = {
     readonly generation?: number | undefined;
 };
 /**
- * Per-subject bookkeeping: every revision hash seen for the subject, and
- * every hash any of those revisions names as a parent. See the module doc
- * for why both sets are kept (rather than a running head list) and
- * {@link headsOf} for how heads are derived from them.
+ * Per-subject bookkeeping: every revision hash seen for the subject, every
+ * hash any of those revisions names as a parent, and which of the seen
+ * revisions are `archived`. See the module doc for why the first two sets are
+ * kept (rather than a running head list), {@link headsOf} for how heads are
+ * derived from them, and {@link subjectListed} for how `archived` classifies a
+ * subject once its heads are known.
+ *
+ * `archived` is keyed by revision hash, not by subject, for the same reason
+ * heads are computed at read time: which revisions are heads is only known
+ * once the whole store has been folded in, so a per-subject archived flag
+ * would have to be revised every time a later fold changes the head set.
  */
 export type SubjectState = {
     readonly hashes: readonly Hash[];
     readonly parents: readonly Hash[];
+    readonly archived: readonly Hash[];
 };
 /** In-memory index: subject → its {@link SubjectState}. */
 export type Cache = {
@@ -182,8 +193,17 @@ export declare const addRevision: <O extends Operation>(cas: Cas<O>) => (cacheKe
 export declare const readRevision: <O extends Operation>(cas: Cas<O>) => (hash: Hash) => Effect<O, Result<RevisionData, string>>;
 /** The Evo API described in `fjs/cas/evo/README.md`, bound to a `Cas<O>` and its cache slot. */
 export type Evo<O extends Operation> = {
-    /** Returns every subject with at least one stored revision. */
-    readonly list: () => Effect<MemOp, readonly Subject[]>;
+    /**
+     * Returns the subjects matching a status filter: the active ones by
+     * default, the archived ones when `archived` is `true`. A subject's status
+     * is derived from its current heads — see {@link subjectListed}, which
+     * also explains why a subject with no current heads is in neither result.
+     *
+     * There is deliberately no all-subjects mode: nothing needs one yet, and
+     * adding it later is a compatible extension of this parameter, while
+     * removing it would not be.
+     */
+    readonly list: (archived?: true) => Effect<MemOp, readonly Subject[]>;
     /** Returns the current head hashes of `subject` (empty if unknown). */
     readonly head: (subject: Subject) => Effect<MemOp, readonly Hash[]>;
     /** Adds a new head; see {@link addRevision}. */

package/fjs/cas/evo/module.f.js

@@ -17,7 +17,10 @@
  * subject (see [`fjs/media/revision/README.md`](../../media/revision/README.md)).
  * `Cache` therefore tracks, per subject, every revision hash seen and every
  * hash referenced as somebody's parent; heads are the set difference between
- * the two, computed at read time ({@link headsOf}). Storing both sets rather
+ * the two, computed at read time ({@link headsOf}). Alongside them it records
+ * which of the seen revisions are `archived`, so {@link Evo.list} can classify
+ * a subject as active or archived from its heads' flags
+ * ({@link subjectListed}) without touching the store. Storing both sets rather
  * than a running head list is what makes folding revisions truly order
  * independent: `cas.list()` (used by {@link buildCache} to scan an existing
  * store) returns hashes in hash order, not revision ancestry, so a child can
@@ -58,7 +61,7 @@ import { isNotFound } from '../../effects/node/module.f.js';
 export const emptyCache = { bySubject: {} };
 /** Canonical JSON encoder for a `Revision` — key order carries no meaning for detection. */
 const toJson = stringify(identity);
-const emptySubjectState = { hashes: [], parents: [] };
+const emptySubjectState = { hashes: [], parents: [], archived: [] };
 /** Adds every item of `items` to `set` that isn't already there, preserving `set`'s existing order. */
 const union = (set) => (items) => items.reduce((acc, h) => acc.includes(h) ? acc : [...acc, h], set);
 /**
@@ -76,12 +79,37 @@ const union = (set) => (items) => items.reduce((acc, h) => acc.includes(h) ? acc
 const canonicalHash = (h) => vecToCBase32(unwrap(cBase32ToVec(h)));
 /** A subject's current heads: revision hashes seen that no other revision of the same subject names as a parent. */
 const headsOf = (state) => state.hashes.filter(h => !state.parents.includes(h));
+/**
+ * Whether a subject in `state` belongs in {@link Evo.list}'s result for the
+ * given `archived` filter — the subject-level status derived from its
+ * revision-level `archived` flags:
+ *
+ * - **active** — at least one current head is not archived. This is the
+ *   default result set (`archived` omitted).
+ * - **archived** — the subject has at least one current head and every one of
+ *   them is archived (`archived: true`).
+ *
+ * Concurrent heads can disagree, and the two rules resolve that the same way:
+ * one unarchived head keeps the whole subject active, because a subject is
+ * only done evolving when nothing left to build on remains. A subject with no
+ * current heads is neither active nor archived and appears in no result — the
+ * status is a statement about heads, and there is nothing to state. That case
+ * needs the explicit `heads.length` test only in the archived branch, since
+ * "every head is archived" is vacuously true of no heads at all.
+ */
+const subjectListed = (archived) => (state) => {
+    const heads = headsOf(state);
+    const unarchived = heads.filter(h => !state.archived.includes(h));
+    return archived === undefined
+        ? unarchived.length !== 0
+        : heads.length !== 0 && unarchived.length === 0;
+};
 /**
  * Folds one more stored revision into `cache`: `hash` joins its subject's
- * `hashes` set, and `revision.parents` (canonicalized, see
- * {@link canonicalHash}) join its `parents` set. Order independent (see the
- * module doc) — used both for a full-store scan and for a single
- * incremental `add`.
+ * `hashes` set, `revision.parents` (canonicalized, see {@link canonicalHash})
+ * join its `parents` set, and `hash` also joins the `archived` set when the
+ * revision carries `archived: true`. Order independent (see the module doc) —
+ * used both for a full-store scan and for a single incremental `add`.
  *
  * Looks `revision.subject` up via {@link at} (own-property only), not plain
  * bracket indexing: a subject is an arbitrary caller-supplied string
@@ -96,6 +124,7 @@ const addRevisionToCache = (hash, revision) => (cache) => {
     const state = {
         hashes: union(existing.hashes)([hash]),
         parents: union(existing.parents)(revision.parents.map(canonicalHash)),
+        archived: union(existing.archived)(revision.archived === undefined ? [] : [hash]),
     };
     return { bySubject: { ...cache.bySubject, [revision.subject]: state } };
 };
@@ -407,9 +436,13 @@ export const readRevision = (cas) => (hash) => {
 };
 /** Builds the {@link Evo} API over `cas`, backed by the cache at `cacheKey` (see {@link initEvo}). */
 export const evo = (cas) => (cacheKey) => ({
-    list: () => eff(read(cacheKey))
-        .step(cache => pure(definedEntries(cache.bySubject).map(([subject]) => subject)))
-        .value,
+    list: archived => {
+        const listed = subjectListed(archived);
+        return eff(read(cacheKey))
+            .step(cache => pure(definedEntries(cache.bySubject)
+            .flatMap(([subject, state]) => listed(state) ? [subject] : [])))
+            .value;
+    },
     head: subject => eff(read(cacheKey))
         .step(cache => {
         const state = at(subject)(cache.bySubject);

package/fjs/cas/evo/proof.f.d.ts

@@ -9,6 +9,10 @@ export declare const proof: {
     buildCacheOrderIndependentWhenChildScannedBeforeParent: () => void;
     buildCacheCanonicalizesNonCanonicalParentHashes: () => void;
     addRevisionBuildsHeadsAcrossChainAndFork: () => void;
+    listPartitionsSubjectsByHeadArchivedFlag: () => void;
+    listTreatsDisagreeingHeadsAsActive: () => void;
+    listIgnoresArchivedRevisionsThatAreNoLongerHeads: () => void;
+    listExcludesSubjectWithNoCurrentHeads: () => void;
     addRevisionIdempotentOnDuplicateContent: () => void;
     addRevisionCanonicalizesParentSpellingBeforeSerializing: () => void;
     addRevisionResolvesSubjectFromSingleParent: () => void;

package/fjs/cas/evo/proof.f.js

@@ -183,6 +183,87 @@ export const proof = {
         assertEq(subjects.length, 1);
         assertEq(subjects[0], 'doc');
     },
+    // `list()` and `list(true)` partition subjects by the archived flags of
+    // their current heads: a lone root revision carrying `archived: true`
+    // makes its subject archived, one without it leaves the subject active,
+    // and neither subject appears in the other's result.
+    listPartitionsSubjectsByHeadArchivedFlag: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const [state1, live] = virtual(state0)(e.add({ parents: [], subject: 'live', snapshot: vecToCBase32(vec8(0x40n)) }));
+        assert(live[0] === 'ok', ['expected the active add to succeed', live]);
+        const [state2, gone] = virtual(state1)(e.add({ parents: [], subject: 'gone', snapshot: vecToCBase32(vec8(0x41n)), archived: true }));
+        assert(gone[0] === 'ok', ['expected the archived add to succeed', gone]);
+        const [state3, active] = virtual(state2)(e.list());
+        assertEq(active.length, 1);
+        assertEq(active[0], 'live');
+        const [, archived] = virtual(state3)(e.list(true));
+        assertEq(archived.length, 1);
+        assertEq(archived[0], 'gone');
+    },
+    // Concurrent heads can disagree about `archived`. One unarchived head
+    // keeps the whole subject active — there is still a head left to build on
+    // — so the subject stays out of the archived-only result.
+    listTreatsDisagreeingHeadsAsActive: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const [state1, root] = virtual(state0)(e.add({ parents: [], subject: 'doc', snapshot: vecToCBase32(vec8(0x42n)) }));
+        assert(root[0] === 'ok', ['expected root ok', root]);
+        // The two children differ only in `archived`, which is enough to make
+        // them distinct blobs, hence two concurrent heads of one root.
+        const [state2, kept] = virtual(state1)(e.add({ parents: [root[1]], subject: 'doc' }));
+        assert(kept[0] === 'ok', ['expected the unarchived child ok', kept]);
+        const [state3, dropped] = virtual(state2)(e.add({ parents: [root[1]], subject: 'doc', archived: true }));
+        assert(dropped[0] === 'ok', ['expected the archived child ok', dropped]);
+        const [state4, heads] = virtual(state3)(e.head('doc'));
+        assertEq(heads.length, 2);
+        const [state5, active] = virtual(state4)(e.list());
+        assertEq(active.length, 1);
+        assertEq(active[0], 'doc');
+        const [, archived] = virtual(state5)(e.list(true));
+        assertEq(archived.length, 0);
+    },
+    // `archived` is a property of a revision, not of a subject: a subject
+    // archived at one revision is active again as soon as an unarchived child
+    // demotes that revision out of the head set.
+    listIgnoresArchivedRevisionsThatAreNoLongerHeads: () => {
+        const c = fileCas(sha256)(home);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
+        const e = evo(c)(cacheKey);
+        const [state1, root] = virtual(state0)(e.add({ parents: [], subject: 'doc', snapshot: vecToCBase32(vec8(0x45n)), archived: true }));
+        assert(root[0] === 'ok', ['expected the archived root ok', root]);
+        const [state2, revived] = virtual(state1)(e.add({ parents: [root[1]], subject: 'doc' }));
+        assert(revived[0] === 'ok', ['expected the unarchived child ok', revived]);
+        const [state3, active] = virtual(state2)(e.list());
+        assertEq(active.length, 1);
+        assertEq(active[0], 'doc');
+        const [, archived] = virtual(state3)(e.list(true));
+        assertEq(archived.length, 0);
+    },
+    // A subject can end up with no current head at all, and a status is a
+    // statement about heads — so such a subject is neither active nor
+    // archived and belongs to neither result. Nothing verifies that a stored
+    // blob actually hashes to the key it sits under, so a hand-crafted or
+    // corrupt store can present a revision naming its own hash as its parent;
+    // `fixedCas` reproduces exactly that, which a real `fileCas` cannot.
+    listExcludesSubjectWithNoCurrentHeads: () => {
+        const selfHash = vec8(0x43n);
+        const snapshotHash = vecToCBase32(vec8(0x44n));
+        const text = `{"dialect":"${revisionDialect}","subject":"doc","parents":["${vecToCBase32(selfHash)}"],"snapshot":"${snapshotHash}","generation":1}`;
+        const bytes = tryUtf8(text);
+        assert(bytes !== null, 'expected the sample revision text to encode as UTF-8');
+        const cas = fixedCas([[selfHash, bytes]]);
+        const [state0, cacheKey] = virtual(emptyState)(initEvo(cas));
+        const e = evo(cas)(cacheKey);
+        const [state1, heads] = virtual(state0)(e.head('doc'));
+        assertEq(heads.length, 0);
+        const [state2, active] = virtual(state1)(e.list());
+        assertEq(active.length, 0);
+        const [, archived] = virtual(state2)(e.list(true));
+        assertEq(archived.length, 0);
+    },
     // Adding the exact same revision twice yields the same (deduplicated)
     // content hash and must not duplicate the head entry.
     addRevisionIdempotentOnDuplicateContent: () => {

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

@@ -18,19 +18,19 @@ export declare const images: {
         readonly arm: 'windows-11-arm';
     };
 };
-export declare const functionalscript: '0.38.0';
+export declare const functionalscript: '0.41.0';
 export declare const bun = "1.3.14";
 export declare const deno = "2.9.4";
 export declare const node: {
-    readonly default: '26.5.1';
-    readonly node22: '22.23.1';
+    readonly default: '26.6.0';
+    readonly node22: '22.23.2';
     readonly node24: '24.18.0';
 };
 export declare const nixpkgs: {
     readonly ref: 'nixos-26.05';
-    readonly commit: '21ea275a7c46aef9d4d6ddc962e6d562e9d94183';
+    readonly commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555';
 };
-export declare const wasmtime = "47.0.2";
+export declare const wasmtime = "47.0.3";
 export declare const wasmer = "7.2.1";
 export declare const actions: {
     readonly 'actions/checkout': 'v7.0.1';

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

@@ -23,7 +23,7 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.38.0';
+export const functionalscript = '0.41.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
@@ -36,8 +36,8 @@ export const deno = '2.9.4';
 // it offers rather than the latest release.
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.5.1',
-    node22: '22.23.1',
+    default: '26.6.0',
+    node22: '22.23.2',
     node24: '24.18.0',
 };
 // Official Nixpkgs snapshot used by the generated CI flakes. `ref` is the
@@ -47,10 +47,10 @@ export const node = {
 // https://channels.nixos.org/nixos-26.05/git-revision
 export const nixpkgs = {
     ref: 'nixos-26.05',
-    commit: '21ea275a7c46aef9d4d6ddc962e6d562e9d94183',
+    commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '47.0.2';
+export const wasmtime = '47.0.3';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.2.1';
 // GitHub Action versions used by CI step builders. The key is the action

package/fjs/ci/deno/module.f.d.ts

@@ -1,2 +1,10 @@
 import { type MetaStep } from '../common/module.f.ts';
+/**
+ * The regular expression selecting FunctionalScript implementation modules for
+ * Deno coverage. Both authored extensions are included so a module migrated
+ * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
+ * the `--test-coverage-include` list in `package.json` and to the `cov` task in
+ * `deno.json`.
+ */
+export declare const coverageInclude: '.*module\\.f\\.(ts|mjs)';
 export declare const denoSteps: (version: string) => readonly MetaStep[];

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

@@ -7,6 +7,14 @@
 import { deno } from '../config/module.f.js';
 import { install, test, uses } from '../common/module.f.js';
 const denoTest = 'deno test --allow-read --allow-env --allow-sys';
+/**
+ * The regular expression selecting FunctionalScript implementation modules for
+ * Deno coverage. Both authored extensions are included so a module migrated
+ * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
+ * the `--test-coverage-include` list in `package.json` and to the `cov` task in
+ * `deno.json`.
+ */
+export const coverageInclude = '.*module\\.f\\.(ts|mjs)';
 export const denoSteps = (version) => [
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
     // We need --minimum-dependency-age=0 for functionalscript because we would like to use
@@ -16,5 +24,5 @@ export const denoSteps = (version) => [
     install({ run: `deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${version}` }),
     test({ run: `deno run -A --minimum-dependency-age=0 npm:functionalscript@${version} t` }),
     test({ run: 'deno install --frozen' }),
-    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
+    test({ run: `${denoTest} --coverage && deno coverage --include='${coverageInclude}'` }),
 ];

package/fjs/ci/deno/proof.f.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    coverageInclude: () => void;
+    coverageStep: () => void;
+    installsPinnedVersion: () => void;
+};

package/fjs/ci/deno/proof.f.js

@@ -0,0 +1,26 @@
+import { coverageInclude, denoSteps } from './module.f.js';
+import { toSteps } from '../common/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+const coverageRuns = (version) => toSteps(denoSteps(version))
+    .flatMap(s => s.run !== undefined && s.run.includes('deno coverage') ? [s.run] : []);
+export const proof = {
+    // A regression guard: dropping either authored implementation extension
+    // from the Deno coverage filter silently removes those modules from the
+    // CI coverage report while CI still passes.
+    coverageInclude: () => {
+        assertEq(coverageInclude, '.*module\\.f\\.(ts|mjs)');
+    },
+    coverageStep: () => {
+        const runs = coverageRuns('0.0.0');
+        assertEq(runs.length, 1);
+        const [run] = runs;
+        assert(run !== undefined);
+        assert(run.includes(`deno coverage --include='${coverageInclude}'`));
+    },
+    installsPinnedVersion: () => {
+        const runs = toSteps(denoSteps('1.2.3'))
+            .flatMap(s => s.run !== undefined && s.run.includes('npm:functionalscript@') ? [s.run] : []);
+        assertEq(runs.length, 2);
+        assert(runs.every(r => r.includes('npm:functionalscript@1.2.3')));
+    },
+};

package/fjs/ci/node/proof.f.d.ts

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

package/fjs/ci/node/proof.f.js

@@ -0,0 +1,17 @@
+import { basicNode } from './module.f.js';
+import { test } from '../common/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    basicNode: () => {
+        const extra = [test({ run: 'echo extra' })];
+        const steps = basicNode('22.0.0')(extra);
+        assertEq(steps.length, 3);
+        const [setupNode, npmCi, extraStep] = steps;
+        assertEq(setupNode.type, 'install');
+        assertEq(setupNode.type === 'install' ? setupNode.step.uses : undefined, 'actions/setup-node@v7.0.0');
+        assertEq(setupNode.type === 'install' ? setupNode.step.with?.['node-version'] : undefined, '22.0.0');
+        assertEq(npmCi.type, 'test');
+        assertEq(npmCi.type === 'test' ? npmCi.step.run : undefined, 'npm ci');
+        assertEq(extraStep, extra[0]);
+    },
+};

package/fjs/ci/proof.f.js

@@ -1,6 +1,7 @@
 import { ci, main } from './module.f.js';
 import { functionalscript, node } from './config/module.f.js';
 import { nodeNixJobs } from './node/module.f.js';
+import { coverageInclude } from './deno/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, ubuntu, parseGitHubAction } from './common/module.f.js';
@@ -33,7 +34,7 @@ const text = (dir, name) => {
 const path = (dir, names) => names.reduce(subDir, dir);
 const workflow = (state) => {
     const workflows = path(state.root, ['.github', 'workflows']);
-    return unwrap(parseGitHubAction(jsonParse(text(workflows, 'ci.yml'))));
+    return unwrap(parseGitHubAction(unwrap(jsonParse(text(workflows, 'ci.yml')))));
 };
 const flake = (state, id) => text(path(state.root, ['nix', 'generated', id]), 'flake.nix');
 const run = (rust, nodeExtra = () => []) => {
@@ -132,7 +133,7 @@ export const proof = {
             assert(hasRun(`deno install -g -A --minimum-dependency-age=0 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 --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
-            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(`deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='${coverageInclude}'`)(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');

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

@@ -14,10 +14,19 @@ export type ModuleMap = StringMap<string, Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
- * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
- * construction — they have no import side effects. For vanilla TS/JS the
- * load gate stays opt-in by filename: any file ending in `proof.ts`,
- * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ * Two symmetrical rules, each covering all four TS/JS module extensions:
+ *
+ * - **FunctionalScript modules** — anything ending in `.f.ts`, `.f.mts`,
+ *   `.f.js`, or `.f.mjs`. They are safe to bulk-load by construction, since
+ *   they have no import side effects, so the whole module is loaded and its
+ *   internal `proof` export (if any) is discovered. `.f.ts` and `.f.mjs` are
+ *   the authored extensions; `.f.js` is generated from `.f.ts`.
+ * - **Impure JavaScript/TypeScript proofs** — anything ending in `proof.ts`,
+ *   `proof.mts`, `proof.js`, or `proof.mjs`. Outside FunctionalScript a module
+ *   may have import side effects, so the load gate stays opt-in by filename.
+ *
+ * A `proof.f.mts` / `proof.f.mjs` matches the FunctionalScript rule by its
+ * `.f.` infix, not the vanilla proof rule.
  *
  * Whether a loaded module actually _contains_ a proof is determined at
  * runtime by checking for an exported `proof` property.
@@ -42,5 +51,7 @@ export type LoadModuleOperations = Access | Import | All | Readdir;
 export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
 export declare const proof: {
     isSourceFile: () => void;
+    allFilesFindsFunctionalScript: () => void;
     allFilesSkipsNodeModules: () => void;
+    loadModuleMapDefaultsToCwdWhenInitCwdUnset: () => void;
 };

package/fjs/dev/module.f.js

@@ -13,17 +13,27 @@ import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
- * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
- * construction — they have no import side effects. For vanilla TS/JS the
- * load gate stays opt-in by filename: any file ending in `proof.ts`,
- * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ * Two symmetrical rules, each covering all four TS/JS module extensions:
+ *
+ * - **FunctionalScript modules** — anything ending in `.f.ts`, `.f.mts`,
+ *   `.f.js`, or `.f.mjs`. They are safe to bulk-load by construction, since
+ *   they have no import side effects, so the whole module is loaded and its
+ *   internal `proof` export (if any) is discovered. `.f.ts` and `.f.mjs` are
+ *   the authored extensions; `.f.js` is generated from `.f.ts`.
+ * - **Impure JavaScript/TypeScript proofs** — anything ending in `proof.ts`,
+ *   `proof.mts`, `proof.js`, or `proof.mjs`. Outside FunctionalScript a module
+ *   may have import side effects, so the load gate stays opt-in by filename.
+ *
+ * A `proof.f.mts` / `proof.f.mjs` matches the FunctionalScript rule by its
+ * `.f.` infix, not the vanilla proof rule.
  *
  * Whether a loaded module actually _contains_ a proof is determined at
  * runtime by checking for an exported `proof` property.
  */
-export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
-    s.endsWith('proof.ts') || s.endsWith('proof.js') ||
-    s.endsWith('proof.mts') || s.endsWith('proof.mjs');
+export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.mts') ||
+    s.endsWith('.f.js') || s.endsWith('.f.mjs') ||
+    s.endsWith('proof.ts') || s.endsWith('proof.mts') ||
+    s.endsWith('proof.js') || 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) => {
@@ -91,6 +101,19 @@ export const proof = {
         assert(!isSourceFile('readme.md'));
         assert(!isSourceFile('module.json'));
     },
+    allFilesFindsFunctionalScript: () => {
+        // Every FunctionalScript extension is discovered, so a module migrated
+        // from `.f.ts` to `.f.mjs` keeps its proofs. An ordinary `.mjs` is
+        // still skipped.
+        const root = {
+            'a.f.ts': [],
+            'b.f.mjs': [],
+            'c.f.mts': [],
+            'd.mjs': [],
+        };
+        const [, result] = virtual({ ...emptyState, root })(allFiles('.', shouldLoad));
+        assertEq(result.join(','), './a.f.ts,./b.f.mjs,./c.f.mts');
+    },
     allFilesSkipsNodeModules: () => {
         // `node_modules` is skipped without descending into it, even though
         // it contains a file that would otherwise match the predicate.
@@ -101,4 +124,12 @@ export const proof = {
         const [, result] = virtual({ ...emptyState, root })(allFiles('.', shouldLoad));
         assertEq(result.join(','), './a.f.ts');
     },
+    loadModuleMapDefaultsToCwdWhenInitCwdUnset: () => {
+        // With no `INIT_CWD` (e.g. `fjs t` invoked outside `npm run`), `env`
+        // lookup returns `undefined` and discovery falls back to `.`, so
+        // every path keeps its own `./`-prefix instead of having one stripped.
+        const root = { 'a.f.ts': () => ({}) };
+        const [, result] = virtual({ ...emptyState, root })(loadModuleMap({}));
+        assertEq(Object.keys(result).join(','), './a.f.ts');
+    },
 };

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

@@ -1,6 +1,10 @@
-import { parse as jsonParse } from '../../media/json/parser/module.f.js';
-import { tokenize as jsonTokenize } from '../../media/json/tokenizer/module.f.js';
-import { stringToList } from '../../text/utf16/module.f.js';
+/**
+ * Helpers for reading package.json-style metadata without losing unrelated
+ * fields before write-back.
+ *
+ * @module
+ */
+import { parse as parseJsonText } from '../../media/json/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';
@@ -10,7 +14,6 @@ export const packageJsonSchema = {
     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') {

package/fjs/dev/proof.f.js

@@ -2,13 +2,22 @@ import { assert, assertEq, todo } from '../asserts/module.f.js';
 import { shouldLoad } from './module.f.js';
 export const proof = {
     shouldLoad: () => {
+        // Every FunctionalScript extension is loaded whatever the file name.
         assert(shouldLoad('foo.f.ts'));
+        assert(shouldLoad('foo.f.mts'));
         assert(shouldLoad('bar.f.js'));
+        assert(shouldLoad('module.f.mjs'));
+        assert(shouldLoad('proof.f.mts'));
+        assert(shouldLoad('proof.f.mjs'));
+        // Every impure JS/TS extension is loaded only under the `proof` name.
         assert(shouldLoad('proof.ts'));
-        assert(shouldLoad('proof.js'));
         assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.js'));
         assert(shouldLoad('proof.mjs'));
         assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('module.mts'));
+        assert(!shouldLoad('module.js'));
+        assert(!shouldLoad('module.mjs'));
         assert(!shouldLoad('readme.md'));
     },
     shouldPass: () => ({

package/fjs/djs/parser/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { error, ok } from '../../types/result/module.f.js';
-import { fold, first, drop, toArray, length, concat } from '../../types/list/module.f.js';
+import { fold, next, toArray, length, concat } from '../../types/list/module.f.js';
 import { setReplace, at } from '../../types/ordered_map/module.f.js';
 import { fromMap } from '../../types/object/module.f.js';
 import { assertEq } from '../../asserts/module.f.js';
@@ -164,9 +164,19 @@ const startArray = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
     return { ...state, valueState: '[', top: ['array', null], stack: newStack };
 };
+// Pops the enclosing container off `stack`. `next` is forced here rather than
+// left as a `drop(1)` thunk: the stack is written only by startArray/startObject,
+// always as a literal cons, and a lazy pop leaves one unforced thunk per closed
+// container — a chain that overflows the call stack when it is finally forced.
+const popStack = state => {
+    const ne = next(state.stack);
+    return ne === null
+        ? { ...state, valueState: '', top: null, stack: null }
+        : { ...state, valueState: '', top: ne.first, stack: ne.tail };
+};
 const endArray = state => {
     const top = state.top;
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    const newState = popStack(state);
     if (top !== null && top[0] === 'array') {
         const array = ['array', toArray(top[1])];
         return pushValue(newState)(array);
@@ -179,7 +189,7 @@ const startObject = state => {
 };
 const endObject = state => {
     const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    const newState = popStack(state);
     return pushValue(newState)(obj);
 };
 const tokenToValue = token => {

package/fjs/djs/parser/proof.f.d.ts

@@ -10,4 +10,5 @@ export declare const proof: {
     validWithArgs: (() => void)[];
     invalidWithArgs: (() => void)[];
     comments: (() => void)[];
+    containerStackCost: (() => void)[];
 };