functionalscript 0.43.1 → 0.44.0

package/fjs/module.f.mjs

@@ -0,0 +1,60 @@
+/**
+ * FunctionalScript compiler entry points and command handlers.
+ *
+ * @module
+ */
+import { compile } from './djs/module.f.mjs'
+import { main as testMain } from './emergent_testing/module.f.mjs'
+import { commands as casCommands } from './cas/cli/module.f.mjs'
+import { main as ciMain } from './ci/module.f.mjs'
+import { import_ } from './effects/node/module.f.mjs'
+/** @import { NodeOp, NodeProgram } from './effects/node/types.ts' */
+import { dispatch } from './cli/module.f.mjs'
+/** @import { Commands } from './cli/types.ts' */
+import { casMcpServer } from './mcp/module.f.mjs'
+import { pure, step } from './effects/module.f.mjs'
+import { unwrap } from './types/result/module.f.mjs'
+
+/** @type {Commands<NodeOp>} */
+const commands = [
+    {
+        names: ['test', 't'],
+        description: 'Run the FunctionalScript test suite',
+        handler: testMain,
+    },
+    {
+        names: ['compile', 'c'],
+        description: 'Compile a FunctionalScript module to JavaScript',
+        handler: ({ args }) => compile(args),
+    },
+    {
+        names: ['cas', 's'],
+        description: 'Content-addressable storage operations',
+        handler: casCommands,
+    },
+    {
+        names: ['mcp', 'm'],
+        description: 'Run an MCP server over stdio exposing the CAS and Evo (subjects/heads) as tools',
+        handler: ({ home }) => step(
+            casMcpServer(home),
+            () => pure(0)),
+    },
+    {
+        names: ['ci', 'i'],
+        description: 'Generate the GitHub Actions CI workflow',
+        handler: ciMain,
+    },
+    {
+        names: ['run', 'r'],
+        description: 'Run a FunctionalScript module as a NodeProgram',
+        handler: options => {
+            const [file, ...args] = options.args
+            return step(
+                import_(file),
+                x => (/** @type {NodeProgram} */ (unwrap(x).main))({ ...options, args }))
+        },
+    },
+]
+
+/** @type {NodeProgram} */
+export const main = dispatch(commands)

package/fjs/module.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { main } from './module.f.mjs'
+import { run } from './effects/node/module.mjs'
+
+await run(main)

package/fjs/nanvm/module.f.d.mts

@@ -0,0 +1,54 @@
+/**
+ * The single source of truth for `nanvm-lib` operator behaviour.
+ *
+ * This module is pure data: it names every operator case once, with the
+ * arguments and the expected result written as ordinary JavaScript values.
+ * Two consumers read it, so a new case is written once and checked twice:
+ *
+ * - [`proof.f.mjs`](./proof.f.mjs) runs each case through the native
+ *   JavaScript operators, proving that the expectations describe JavaScript.
+ * - [`rust/module.f.mjs`](./rust/module.f.mjs) prints each case as Rust,
+ *   producing `nanvm-lib/tests/test/generated.rs`, which runs the same case
+ *   against `nanvm-lib`.
+ *
+ * Cases `nanvm-lib` does not implement yet carry a `rust` reason and are
+ * emitted as commented-out `TODO`s instead of being silently dropped — the
+ * gaps between the two implementations are part of the data.
+ *
+ * @module
+ *
+ * @import { Case, Data, Special, Value } from './types.ts'
+ *
+ * @example
+ *
+ * ```js
+ * import { data } from './module.f.mjs'
+ *
+ * data.groups.length // 4
+ * ```
+ */
+import type { Data, Special } from './types.ts';
+/**
+ * A function value.
+ *
+ * Every operator here coerces a function through `ToPrimitive`, which never
+ * inspects it, so which function it is does not matter.
+ *
+ * @type {Special}
+ */
+export declare const functionValue: Special;
+/**
+ * The case must throw. Valid only as a case's `expected`.
+ *
+ * @type {Special}
+ */
+export declare const throws: Special;
+/**
+ * One of the `eq` `shared` values, so the same object reaches both sides of a
+ * comparison.
+ *
+ * @type {(name: string) => Special}
+ */
+export declare const ref: (name: string) => Special;
+/** @type {Data} */
+export declare const data: Data;

package/fjs/nanvm/module.f.mjs

@@ -0,0 +1,240 @@
+/**
+ * The single source of truth for `nanvm-lib` operator behaviour.
+ *
+ * This module is pure data: it names every operator case once, with the
+ * arguments and the expected result written as ordinary JavaScript values.
+ * Two consumers read it, so a new case is written once and checked twice:
+ *
+ * - [`proof.f.mjs`](./proof.f.mjs) runs each case through the native
+ *   JavaScript operators, proving that the expectations describe JavaScript.
+ * - [`rust/module.f.mjs`](./rust/module.f.mjs) prints each case as Rust,
+ *   producing `nanvm-lib/tests/test/generated.rs`, which runs the same case
+ *   against `nanvm-lib`.
+ *
+ * Cases `nanvm-lib` does not implement yet carry a `rust` reason and are
+ * emitted as commented-out `TODO`s instead of being silently dropped — the
+ * gaps between the two implementations are part of the data.
+ *
+ * @module
+ *
+ * @import { Case, Data, Special, Value } from './types.ts'
+ *
+ * @example
+ *
+ * ```js
+ * import { data } from './module.f.mjs'
+ *
+ * data.groups.length // 4
+ * ```
+ */
+
+/**
+ * A function value.
+ *
+ * Every operator here coerces a function through `ToPrimitive`, which never
+ * inspects it, so which function it is does not matter.
+ *
+ * @type {Special}
+ */
+export const functionValue = () => ['function']
+
+/**
+ * The case must throw. Valid only as a case's `expected`.
+ *
+ * @type {Special}
+ */
+export const throws = () => ['throw']
+
+/**
+ * One of the `eq` `shared` values, so the same object reaches both sides of a
+ * comparison.
+ *
+ * @type {(name: string) => Special}
+ */
+export const ref = name => () => ['ref', name]
+
+/**
+ * `+n` and `-n` share their whole argument space: both coerce with `ToNumber`
+ * and differ only in the sign of the result. Listing the arguments once keeps
+ * the two groups from drifting apart.
+ *
+ * @type {(negate: boolean) => readonly Case[]}
+ */
+const numberCoercionCases = negate => {
+    /** @type {(v: number) => number} */
+    const result = v => negate ? -v : v
+    return [
+        { name: 'null', args: [null], expected: result(0) },
+        { name: 'undefined', args: [undefined], expected: NaN },
+        { name: 'booleanFalse', args: [false], expected: result(0) },
+        { name: 'booleanTrue', args: [true], expected: result(1) },
+        { name: 'numberZero', args: [0], expected: result(0) },
+        { name: 'numberPositive', args: [2.3], expected: result(2.3) },
+        { name: 'numberNegative', args: [-2.3], expected: result(-2.3) },
+        { name: 'numberLarge', args: [-239], expected: result(-239) },
+        { name: 'numberInfinity', args: [Infinity], expected: result(Infinity) },
+        { name: 'numberNegativeInfinity', args: [-Infinity], expected: result(-Infinity) },
+        { name: 'numberNan', args: [NaN], expected: NaN },
+        { name: 'stringEmpty', args: [''], expected: result(0) },
+        { name: 'stringZero', args: ['0'], expected: result(0) },
+        { name: 'stringNumber', args: ['2.3'], expected: result(2.3) },
+        { name: 'stringExponent', args: ['2.3e2'], expected: result(230) },
+        { name: 'stringNotANumber', args: ['a'], expected: NaN },
+        { name: 'arrayEmpty', args: [[]], expected: result(0) },
+        { name: 'arrayNumber', args: [[2.3]], expected: result(2.3) },
+        { name: 'arrayNegativeNumber', args: [[-0.3]], expected: result(-0.3) },
+        { name: 'arrayString', args: [['-2.3']], expected: result(-2.3) },
+        { name: 'arrayPositiveString', args: [['0.3']], expected: result(0.3) },
+        { name: 'arrayNull', args: [[null]], expected: result(0) },
+        { name: 'arrayPair', args: [[null, null]], expected: NaN },
+        { name: 'objectEmpty', args: [{}], expected: NaN },
+        { name: 'function', args: [functionValue], expected: NaN },
+    ]
+}
+
+/**
+ * `*` between a number and a bigint throws, so the pairs below never mix the
+ * two except in the case that proves it. Every pair is checked in both orders
+ * — see `commutative`.
+ *
+ * @type {readonly Case[]}
+ */
+const mulCases = [
+    { name: 'nullByNull', args: [null, null], expected: 0 },
+    { name: 'nullByZero', args: [null, 0], expected: 0 },
+    { name: 'undefinedByZero', args: [undefined, 0], expected: NaN },
+    { name: 'trueByZero', args: [true, 0], expected: 0 },
+    { name: 'trueByOne', args: [true, 1], expected: 1 },
+    { name: 'trueByTen', args: [true, 10], expected: 10 },
+    { name: 'falseByZero', args: [false, 0], expected: 0 },
+    { name: 'falseByOne', args: [false, 1], expected: 0 },
+    { name: 'falseByTen', args: [false, 10], expected: 0 },
+    { name: 'zeroByZero', args: [0, 0], expected: 0 },
+    { name: 'zeroByOne', args: [0, 1], expected: 0 },
+    { name: 'oneByOne', args: [1, 1], expected: 1 },
+    { name: 'oneByMinusOne', args: [1, -1], expected: -1 },
+    { name: 'oneByTen', args: [1, 10], expected: 10 },
+    { name: 'minusOneByTen', args: [-1, 10], expected: -10 },
+    { name: 'tenByTen', args: [10, 10], expected: 100 },
+    { name: 'minusTenByTen', args: [-10, 10], expected: -100 },
+    { name: 'bigZeroByZero', args: [0n, 0n], expected: 0n },
+    { name: 'bigZeroByOne', args: [0n, 1n], expected: 0n },
+    { name: 'bigOneByOne', args: [1n, 1n], expected: 1n },
+    { name: 'bigOneByMinusOne', args: [1n, -1n], expected: -1n },
+    { name: 'bigOneByTen', args: [1n, 10n], expected: 10n },
+    { name: 'bigMinusOneByTen', args: [-1n, 10n], expected: -10n },
+    { name: 'bigTenByTen', args: [10n, 10n], expected: 100n },
+    { name: 'bigMinusTenByTen', args: [-10n, 10n], expected: -100n },
+    { name: 'emptyStringByOne', args: ['', 1], expected: 0 },
+    { name: 'stringTenByOne', args: ['10', 1], expected: 10 },
+    { name: 'stringLetterByOne', args: ['a', 1], expected: NaN },
+    { name: 'stringBigintByOne', args: ['1n', 1], expected: NaN },
+    { name: 'emptyArrayByOne', args: [[], 1], expected: 0 },
+    { name: 'arrayTenByOne', args: [[10], 1], expected: 10 },
+    { name: 'arrayStringTenByOne', args: [['10'], 1], expected: 10 },
+    { name: 'arrayPairByOne', args: [[0, 0], 1], expected: NaN },
+    { name: 'emptyObjectByOne', args: [{}, 1], expected: NaN },
+    { name: 'numberByBigint', args: [1, 1n], expected: throws },
+]
+
+const hexadecimalBigint =
+    'nanvm-lib prints bigints in hexadecimal; see nanvm-lib/todo/bigint-decimal-string-coercion.md'
+
+/**
+ * `String(x)`.
+ *
+ * A function's string form is its source text, which no two engines have to
+ * agree on, so it is not shared data — [`proof.f.mjs`](./proof.f.mjs) checks
+ * the JavaScript side separately.
+ *
+ * @type {readonly Case[]}
+ */
+const stringCoercionCases = [
+    { name: 'number', args: [123], expected: '123' },
+    { name: 'negativeNumber', args: [-456], expected: '-456' },
+    { name: 'zero', args: [0], expected: '0' },
+    { name: 'negativeZero', args: [-0], expected: '0' },
+    { name: 'infinity', args: [Infinity], expected: 'Infinity' },
+    { name: 'negativeInfinity', args: [-Infinity], expected: '-Infinity' },
+    { name: 'nan', args: [NaN], expected: 'NaN' },
+    { name: 'booleanTrue', args: [true], expected: 'true' },
+    { name: 'booleanFalse', args: [false], expected: 'false' },
+    { name: 'null', args: [null], expected: 'null' },
+    { name: 'undefined', args: [undefined], expected: 'undefined' },
+    { name: 'string', args: ['already'], expected: 'already' },
+    { name: 'bigint', args: [123n], expected: '123', rust: hexadecimalBigint },
+    { name: 'negativeBigint', args: [-456n], expected: '-456', rust: hexadecimalBigint },
+    { name: 'emptyArray', args: [[]], expected: '' },
+    { name: 'singletonArray', args: [[1]], expected: '1' },
+    { name: 'array', args: [[1, 2, 3]], expected: '1,2,3' },
+    { name: 'nestedArray', args: [[1, [2, 3], 4]], expected: '1,2,3,4' },
+    { name: 'arrayWithNullish', args: [[null, undefined, 1]], expected: ',,1' },
+    { name: 'emptyObject', args: [{}], expected: '[object Object]' },
+    { name: 'object', args: [{ a: 1 }], expected: '[object Object]' },
+]
+
+/** @type {Data} */
+export const data = {
+    eq: {
+        shared: {
+            emptyArray: [],
+            stringArray: ['0'],
+            object: { '0': '0' },
+        },
+        cases: [
+            { name: 'nullByNull', a: null, b: null, eq: true },
+            { name: 'undefinedByUndefined', a: undefined, b: undefined, eq: true },
+            { name: 'nullByUndefined', a: null, b: undefined, eq: false },
+            { name: 'trueByTrue', a: true, b: true, eq: true },
+            { name: 'falseByFalse', a: false, b: false, eq: true },
+            { name: 'trueByFalse', a: true, b: false, eq: false },
+            { name: 'falseByUndefined', a: false, b: undefined, eq: false },
+            { name: 'falseByNull', a: false, b: null, eq: false },
+            { name: 'numberBySameNumber', a: 2.3, b: 2.3, eq: true },
+            { name: 'numberByOtherNumber', a: 2.3, b: -5.4, eq: false },
+            { name: 'nanByNan', a: NaN, b: NaN, eq: false },
+            { name: 'zeroByNegativeZero', a: 0, b: -0, eq: true },
+            { name: 'infinityByInfinity', a: Infinity, b: Infinity, eq: true },
+            {
+                name: 'negativeInfinityByNegativeInfinity',
+                a: -Infinity,
+                b: -Infinity,
+                eq: true,
+            },
+            { name: 'infinityByNegativeInfinity', a: Infinity, b: -Infinity, eq: false },
+            { name: 'undefinedByNan', a: undefined, b: NaN, eq: false },
+            { name: 'undefinedByZero', a: undefined, b: 0, eq: false },
+            { name: 'stringBySameString', a: 'hello', b: 'hello', eq: true },
+            { name: 'stringByOtherString', a: 'hello', b: 'world', eq: false },
+            { name: 'zeroByStringZero', a: 0, b: '0', eq: false },
+            { name: 'bigintBySameBigint', a: 12n, b: 12n, eq: true },
+            { name: 'bigintByNegatedBigint', a: 12n, b: -12n, eq: false },
+            { name: 'bigintByOtherBigint', a: 12n, b: 13n, eq: false },
+            { name: 'twelveByStringTwelve', a: 12n, b: '12', eq: false },
+            { name: 'arrayByItself', a: ref('emptyArray'), b: ref('emptyArray'), eq: true },
+            { name: 'arrayByEqualArray', a: [], b: [], eq: false },
+            { name: 'stringArrayByItself', a: ref('stringArray'), b: ref('stringArray'), eq: true },
+            { name: 'objectByItself', a: ref('object'), b: ref('object'), eq: true },
+            { name: 'objectByEqualObject', a: ref('object'), b: { '0': '0' }, eq: false },
+        ],
+    },
+    groups: [
+        {
+            op: 'unaryPlus',
+            cases: [
+                ...numberCoercionCases(false),
+                { name: 'bigint', args: [0n], expected: throws },
+            ],
+        },
+        {
+            op: 'unaryMinus',
+            cases: [
+                ...numberCoercionCases(true),
+                { name: 'bigintPositive', args: [1n], expected: -1n },
+                { name: 'bigintNegative', args: [-1n], expected: 1n },
+            ],
+        },
+        { op: 'mul', commutative: true, cases: mulCases },
+        { op: 'stringCoercion', cases: stringCoercionCases },
+    ],
+}

package/fjs/nanvm/proof.f.d.mts

@@ -0,0 +1,41 @@
+/**
+ * The JavaScript reference for `nanvm-lib`'s operators.
+ *
+ * Every case in [`module.f.mjs`](./module.f.mjs) is run through the native
+ * JavaScript operators here, so the shared data is proven to describe
+ * JavaScript before `nanvm-lib/tests/test/generated.rs` holds `nanvm-lib` to
+ * it. This module contains no test cases of its own beyond the `jsOnly`
+ * section at the end — adding a case means editing the data.
+ *
+ * @module
+ *
+ * @import { Case, EqCase, Op, Struct, Value } from './types.ts'
+ */
+export declare const proof: {
+    eq: {
+        [k: string]: () => void;
+    };
+    jsOnly: {
+        /**
+         * `Object.is` distinguishes `0` from `-0` where `===` does not; the whole
+         * corpus relies on that, so it is checked directly.
+         */
+        negativeZero: () => void;
+        /** A function's string form is engine-specific — only its type is fixed. */
+        functionToString: () => void;
+        /**
+         * `ToPrimitive` consults a `toString` method. `nanvm-lib` has no object
+         * methods yet, so these cases cannot be shared; see
+         * `nanvm-lib/todo/mvp-roadmap.md`.
+         */
+        toStringMethod: () => void;
+        throw: {
+            toStringThrows: () => string;
+            toStringNotAFunction: () => string;
+            toStringNotPrimitive: () => string;
+            /** `throws` describes a case's outcome; it is not a value to build. */
+            throwsIsNotAValue: () => unknown;
+            unknownRef: () => unknown;
+        };
+    };
+};

package/fjs/nanvm/proof.f.mjs

@@ -0,0 +1,173 @@
+/**
+ * The JavaScript reference for `nanvm-lib`'s operators.
+ *
+ * Every case in [`module.f.mjs`](./module.f.mjs) is run through the native
+ * JavaScript operators here, so the shared data is proven to describe
+ * JavaScript before `nanvm-lib/tests/test/generated.rs` holds `nanvm-lib` to
+ * it. This module contains no test cases of its own beyond the `jsOnly`
+ * section at the end — adding a case means editing the data.
+ *
+ * @module
+ *
+ * @import { Case, EqCase, Op, Struct, Value } from './types.ts'
+ */
+
+import { assert, assertEq } from '../asserts/module.f.mjs'
+import { data } from './module.f.mjs'
+
+const { entries, fromEntries, hasOwn, is } = Object
+
+/**
+ * Builds the JavaScript value a `Value` describes.
+ *
+ * `resolve` supplies the *already built* object a `ref` names — rebuilding it
+ * per reference would hand each side of a comparison its own object, which is
+ * exactly what a `ref` exists to avoid.
+ *
+ * @type {(resolve: (name: string) => unknown) => (v: Value) => unknown}
+ */
+const build = resolve => v => {
+    if (v === null) { return null }
+    if (typeof v === 'function') {
+        const info = v()
+        switch (info[0]) {
+            case 'function': { return () => 5 }
+            case 'ref': { return resolve(info[1]) }
+            case 'throw': { throw ['`throws` is not a value', info] }
+        }
+    }
+    if (Array.isArray(v)) { return v.map(build(resolve)) }
+    if (typeof v === 'object') {
+        return fromEntries(entries(v).map(([k, p]) => [k, build(resolve)(p)]))
+    }
+    return v
+}
+
+/** Cases outside the `eq` group share nothing, so a `ref` is a mistake there. */
+const value = build(name => { throw ['unknown shared value', name] })
+
+/**
+ * Applies an operator to already-built arguments.
+ *
+ * The `any` casts are the point of the exercise: these operators are being
+ * applied to operand types TypeScript rejects (`{} * 1`, `-[]`), which is
+ * exactly the coercion behaviour under test.
+ *
+ * @type {(op: Op) => (args: readonly unknown[]) => unknown}
+ */
+const apply = op => args => {
+    const [a, b] = /** @type {readonly any[]} */(args)
+    switch (op) {
+        case 'unaryPlus': { return +a }
+        case 'unaryMinus': { return -a }
+        case 'mul': { return a * b }
+        case 'stringCoercion': { return String(a) }
+    }
+}
+
+/** `true` when a case's `expected` is `throws` rather than a value. */
+const isThrows = (/** @type {Value} */ expected) =>
+    typeof expected === 'function' && expected()[0] === 'throw'
+
+/**
+ * Every argument order a case is checked in: one, or both for a commutative
+ * operator. The Rust printer applies the same rule.
+ *
+ * @type {(commutative: boolean) => (c: Case) => readonly (readonly[string, readonly Value[]])[]}
+ */
+const orders = commutative => c => commutative
+    ? [[c.name, c.args], [`${c.name}Swapped`, c.args.toReversed()]]
+    : [[c.name, c.args]]
+
+/**
+ * The leaf tests of one group, keyed by case name.
+ *
+ * Throwing cases go under a nested `throw` key — the framework's structural
+ * way of declaring that a test is expected to throw. A throwing leaf stops at
+ * its first exception, which is why each argument order is its own leaf.
+ *
+ * @type {(op: Op) => (commutative: boolean) => (cases: readonly Case[]) => object}
+ */
+const group = op => commutative => cases => {
+    /** @type {(c: Case) => readonly (readonly[string, () => void])[]} */
+    const leaves = c => {
+        const { expected } = c
+        /** @type {(args: readonly Value[]) => () => void} */
+        const fn = isThrows(expected)
+            ? args => () => { apply(op)(args.map(value)) }
+            : args => () => {
+                // `Object.is` rather than `===`, so `NaN` matches `NaN` and
+                // `0` does not match `-0`; the Rust side compares the same way.
+                const result = apply(op)(args.map(value))
+                const e = value(expected)
+                assert(is(result, e), [result, 'is not', e])
+            }
+        return orders(commutative)(c).map(([name, args]) => [name, fn(args)])
+    }
+    const ok = cases.filter(c => !isThrows(c.expected)).flatMap(leaves)
+    const bad = cases.filter(c => isThrows(c.expected)).flatMap(leaves)
+    return bad.length === 0
+        ? fromEntries(ok)
+        : { ...fromEntries(ok), throw: fromEntries(bad) }
+}
+
+const eqProof = (() => {
+    const { shared, cases } = data.eq
+    // Built once, so two `ref`s to the same name really are the same object.
+    const built = fromEntries(entries(shared).map(([k, v]) => [k, value(v)]))
+    const operand = build(name => {
+        assert(hasOwn(built, name), ['unknown shared value', name])
+        return built[name]
+    })
+    /** @type {(c: EqCase) => readonly[string, () => void]} */
+    const leaf = c => [c.name, () => {
+        const a = /** @type {any} */(operand(c.a))
+        const b = /** @type {any} */(operand(c.b))
+        assertEq(a === b, c.eq, [a, c.eq ? '===' : '!==', b])
+        assertEq(b === a, c.eq)
+    }]
+    return fromEntries(cases.map(leaf))
+})()
+
+/**
+ * Behaviour that is real JavaScript but has no `nanvm-lib` counterpart to
+ * share data with, so it stays here instead of in `module.f.mjs`.
+ */
+const jsOnly = {
+    /**
+     * `Object.is` distinguishes `0` from `-0` where `===` does not; the whole
+     * corpus relies on that, so it is checked directly.
+     */
+    negativeZero: () => {
+        assert(is(-0, -0))
+        assert(!is(0, -0))
+        assert(is(NaN, NaN))
+    },
+    /** A function's string form is engine-specific — only its type is fixed. */
+    functionToString: () => {
+        assertEq(typeof String(() => 5), 'string')
+    },
+    /**
+     * `ToPrimitive` consults a `toString` method. `nanvm-lib` has no object
+     * methods yet, so these cases cannot be shared; see
+     * `nanvm-lib/todo/mvp-roadmap.md`.
+     */
+    toStringMethod: () => {
+        assertEq(String({ toString: () => 'custom string' }), 'custom string')
+    },
+    throw: {
+        toStringThrows: () => String({ toString: () => { throw 'Custom error' } }),
+        toStringNotAFunction: () => String(/** @type {any} */({ toString: 'hello' })),
+        toStringNotPrimitive: () => String({ toString: () => [] }),
+        /** `throws` describes a case's outcome; it is not a value to build. */
+        throwsIsNotAValue: () => value(() => ['throw']),
+        unknownRef: () => value(() => ['ref', 'nope']),
+    },
+}
+
+export const proof = {
+    eq: eqProof,
+    ...fromEntries(data.groups.map(
+        g => [g.op, group(g.op)(g.commutative === true)(g.cases)])),
+    jsOnly,
+}

package/fjs/nanvm/rust/module.f.d.mts

@@ -0,0 +1,54 @@
+/**
+ * Prints the shared operator test data as Rust.
+ *
+ * The output is `nanvm-lib/tests/test/generated.rs`: one statement per case,
+ * calling the hand-written helpers in `nanvm-lib/tests/test/harness.rs`. Only
+ * the helpers are written by hand — a new operator case is added to
+ * [`../module.f.mjs`](../module.f.mjs) and appears on both the JavaScript and
+ * the Rust side at once.
+ *
+ * Literal syntax comes from [`fjs/media/rust`](../../media/rust/module.f.mjs);
+ * what is specific to this module is the `nanvm-lib` API the statements target.
+ *
+ * Every emitted function carries `#[rustfmt::skip]`: the line layout here is
+ * one statement per case, and `cargo fmt -- --check` runs in CI, so the
+ * printer would otherwise have to reproduce rustfmt's wrapping exactly.
+ *
+ * @module
+ *
+ * @import { Case, Data, Eq, Group, Op, Value } from '../types.ts'
+ *
+ * @example
+ *
+ * ```js
+ * import { generate } from './module.f.mjs'
+ * import { data } from '../module.f.mjs'
+ *
+ * generate(data) // the contents of `nanvm-lib/tests/test/generated.rs`
+ * ```
+ */
+import type { Data, Op, Value } from '../types.ts';
+/**
+ * Where this printer's output goes, relative to the repository root.
+ *
+ * `tests/test/` rather than `tests/`: cargo turns every `tests/*.rs` into its
+ * own test target, so a generated file directly in `tests/` would be built as
+ * a second, harness-less crate. Inside `tests/test/` it is an ordinary
+ * submodule of the `tests/test/main.rs` target.
+ */
+export declare const directory = "nanvm-lib/tests/test";
+/** @type {string} */
+export declare const path: string;
+/**
+ * A Rust expression of type `Any<A>`.
+ *
+ * Every use site fixes `A`, so no expression needs a turbofish: the harness
+ * helpers take `Any<A>` arguments and the shared `let` bindings are annotated.
+ *
+ * @type {(v: Value) => string}
+ */
+export declare const valueExpr: (v: Value) => string;
+/** @type {(op: Op) => (args: readonly string[]) => string} */
+export declare const call: (op: Op) => (args: readonly string[]) => string;
+/** @type {(data: Data) => string} */
+export declare const generate: (data: Data) => string;