functionalscript 0.43.1 → 0.44.0

package/fjs/crypto/vdf/proof.f.js

@@ -1,94 +0,0 @@
-import { sloth, p } from './module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
-// `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
-// https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
-// https://github.com/jose-compu/dignity.js/blob/main/src/security/sloth-vdf.js
-const sampleX = 123456789n;
-const largeX = 12345678901234567890n;
-const smallX = 42n;
-const nonResidue = 2n;
-const sampleY = 72412151236937799598582816305571618206681207952550127764586725290711141789888684237028784568532880529360450375677852568362636821341317217048062977639333459511661887862128325859969604061461913896412260750881385045152117694320409864730924775539555636460819549547999218170813228857928921642957426089461925313163n;
-const smallY = 145151597037272685697451525487035431973338817762329243361437778785747534269376083577375382484815474368317818719265551745910148543423765263685177263740373969289084400977118144482329577335929842301331443392042760708529572252015473334998752211959790788326970269713683808382892472572910797612141527200051803670965n;
-const y6 = 116287514643100261336025249676072556421566393377742705567032370320583145555855278910304225489766306768040386612082033279417845047304479679877515174322332386599890348932893235091525789175564701751964775040887336849457197662999383850490808701700264064812615988837073981567599117932005435532913423970502774287312n;
-const y4 = 64401150265223443694244964595084197237814157534040219819342647664782563317539559768554855806938965782018778040933157632467146168153951260465261118025222264314070274636967492909984790708532033331622332323767105919809000393624013423095812833452440384602112677364631962445309757177309466319657219548312354433189n;
-export const proof = {
-    p: {
-        matchesField: () => {
-            assertEq(sloth.p, p, [sloth.p, p]);
-        },
-    },
-    eval: {
-        steps100: () => {
-            const y = evalVdf(100n)(sampleX);
-            assertEq(y, sampleY, [y, sampleY]);
-        },
-        steps10: () => {
-            const y = evalVdf(10n)(smallX);
-            assertEq(y, smallY, [y, smallY]);
-        },
-        steps6: () => {
-            const y = evalVdf(6n)(largeX);
-            assertEq(y, y6, [y, y6]);
-        },
-        steps4: () => {
-            const y = evalVdf(4n)(smallX);
-            assertEq(y, y4, [y, y4]);
-        },
-        zeroSteps: () => {
-            const y = evalVdf(0n)(sampleX);
-            assertEq(y, sampleX % p, [y, sampleX % p]);
-        },
-        negativeSteps: () => {
-            const y = evalVdf(-1n)(sampleX);
-            assertEq(y, null);
-        },
-    },
-    verify: {
-        steps100: () => {
-            assert(verify(100n)(sampleX)(sampleY), false);
-        },
-        steps10: () => {
-            assert(verify(10n)(smallX)(smallY), false);
-        },
-        steps6: () => {
-            assert(verify(6n)(largeX)(y6), false);
-        },
-        steps4: () => {
-            assert(verify(4n)(smallX)(y4), false);
-        },
-        tampered: () => {
-            assert(!(verify(4n)(smallX)((y4 + 1n) % p)), (y4 + 1n) % p);
-        },
-        wrongY: () => {
-            assert(!(verify(100n)(sampleX)(sampleY + 1n)), sampleY + 1n);
-        },
-        zeroSteps: () => {
-            assert(verify(0n)(sampleX)(sampleX % p), [sampleX % p]);
-        },
-        negativeSteps: () => {
-            assert(!(verify(-1n)(sampleX)(sampleY)), sampleY);
-        },
-        invalidY: () => {
-            assert(!(verify(100n)(sampleX)(0n)), 0n);
-        },
-    },
-    modSqrt: {
-        roundTrip: () => {
-            const x = 999n;
-            assert(verify(1n)(x)(modSqrt(x)), modSqrt(x));
-        },
-        nonResidue: () => {
-            assert(!(quadRes(nonResidue)), nonResidue);
-            assert(verify(1n)(nonResidue)(modSqrt(nonResidue)), modSqrt(nonResidue));
-        },
-    },
-    quadRes: {
-        one: () => {
-            assert(quadRes(1n), 1n);
-        },
-        nonResidue: () => {
-            assert(!(quadRes(nonResidue)), nonResidue);
-        },
-    },
-};

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

@@ -1,57 +0,0 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-import { type Access, type All, type Env, type Import, type Readdir } from '../effects/node/module.f.ts';
-import type { 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 = StringMap<Module>;
-/**
- * Returns `true` if the file should be loaded for proof discovery.
- *
- * 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 declare const shouldLoad: (s: string) => boolean;
-/** The effect operations required to discover and load a module map. */
-export type LoadModuleOperations = Access | Import | All | Readdir;
-/**
- * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
- * `predicate`, imports them, and returns a map from relative path to module
- * exports.
- *
- * The `predicate` is propagated into `allFiles` so that non-matching files
- * are excluded before any `import()` is attempted — no wasted I/O.
- * The default matches all JS/TS source files (`.js`, `.ts`, `.mts`, `.mjs`).
- * `loadFile`'s own guards (`.f.js`, `.f.ts`, `shouldLoad`) still apply on
- * top; the predicate only controls which files are discovered.
- *
- * The result is sorted by path key using `string.cmp` so the order is
- * deterministic regardless of filesystem traversal order.
- */
-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

@@ -1,135 +0,0 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-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, step } from '../effects/module.f.js';
-import { join, relativize, toPosix } from '../path/module.f.js';
-import { assert, assertEq } from '../asserts/module.f.js';
-import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
-/**
- * Returns `true` if the file should be loaded for proof discovery.
- *
- * 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.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) => {
-        const x0 = step(readdir(p, {}), d => {
-            let result = [];
-            for (const i of unwrap(d)) {
-                const { name } = i;
-                if (name.startsWith('.')) {
-                    continue;
-                }
-                const file = join(p, name);
-                if (!i.isFile) {
-                    if (name === 'node_modules') {
-                        continue;
-                    }
-                    result = [...result, load(file)];
-                    continue;
-                }
-                if (predicate(file)) {
-                    result = [...result, pure([file])];
-                }
-            }
-            return all(...result);
-        });
-        return step(x0, v => pure(v.flat()));
-    };
-    return load(s);
-};
-const loadFile = (f) => step(import_(f), r => pure([[f, unwrap(r)]]));
-const { fromEntries } = Object;
-/**
- * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
- * `predicate`, imports them, and returns a map from relative path to module
- * exports.
- *
- * The `predicate` is propagated into `allFiles` so that non-matching files
- * are excluded before any `import()` is attempted — no wasted I/O.
- * The default matches all JS/TS source files (`.js`, `.ts`, `.mts`, `.mjs`).
- * `loadFile`'s own guards (`.f.js`, `.f.ts`, `shouldLoad`) still apply on
- * top; the predicate only controls which files are discovered.
- *
- * The result is sorted by path key using `string.cmp` so the order is
- * deterministic regardless of filesystem traversal order.
- */
-export const loadModuleMap = (env) => {
-    const initCwd = env['INIT_CWD'];
-    const s = initCwd === undefined ? '.' : toPosix(initCwd);
-    const prefix = s === '.' ? '' : s;
-    // TODO: there are multiple `all` effects here,
-    //       we should consider optimizing them by ALIQ technique or something similar.
-    //       For example, we should be able to write it like `allFiles(s).flatMap(loadFile)`,
-    //       then an effect runner can batch all file loading operations together.
-    const x0 = step(allFiles(s, shouldLoad), files => all(...files.map(loadFile)));
-    return step(x0, entries => pure(fromEntries(entries
-        .flat()
-        .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'));
-    },
-    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.
-        const root = {
-            'node_modules': { 'pkg.f.ts': [] },
-            'a.f.ts': [],
-        };
-        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.d.ts

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

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

@@ -1,24 +0,0 @@
-/**
- * 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';
-export const packageJsonSchema = {
-    name: option(string),
-    version: option(string),
-    scripts: option(record(string)),
-};
-export const validatePackageJson = rttiValidate(packageJsonSchema);
-export const validatePackageJsonText = (text) => {
-    const [t, v] = parseJsonText(text);
-    if (t === 'error') {
-        return error(v);
-    }
-    const [t2, v2] = validatePackageJson(v);
-    return t2 === 'ok' ? ok(v2) : error(v2);
-};

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

@@ -1,28 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { unwrap } from '../../types/result/module.f.js';
-import { validatePackageJson, validatePackageJsonText, } from './module.f.js';
-export const proof = {
-    parseMetadata: () => {
-        const result = unwrap(validatePackageJsonText('{"name":"x","version":"1.0.0","scripts":{"test":"node test.js"}}'));
-        assertEq(result.name, 'x', result);
-        assertEq(result.version, '1.0.0', result);
-        assertEq(result.scripts?.test, 'node test.js', result);
-    },
-    malformedJson: () => {
-        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));
-        assertEq(metadata.name, 'x', metadata);
-        assertEq(metadata.version, '1.0.0', metadata);
-        assert(Object.is(metadata, object), metadata);
-        assertEq(object.private, true, object);
-    },
-};

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

@@ -1,13 +0,0 @@
-export declare const proof: {
-    shouldLoad: () => void;
-    shouldPass: () => {
-        then: () => undefined;
-    };
-    ctor: () => void;
-    ctorEmpty: () => void;
-    ctorUndefined: () => void;
-    number: () => void;
-    properties: () => void;
-    getOwnPropertyDescriptor: () => void;
-    throw: () => void;
-};

package/fjs/dev/proof.f.js

@@ -1,77 +0,0 @@
-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.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: () => ({
-        then: () => undefined
-    }),
-    ctor: () => {
-        const c = (() => { })['constructor'];
-        const f = c('return 5');
-        const result = f();
-        assertEq(result, 5, 'function');
-    },
-    ctorEmpty: () => {
-        /** @type {any} */
-        const o = {};
-        const c = o['constructor'];
-        // console.log(c)
-        // console.log(c(()=>{}))
-    },
-    ctorUndefined: () => {
-        /** @type {any} */
-        const o = {
-            constructor: undefined
-        };
-        const c = o['constructor'];
-        //console.log(c)
-    },
-    number: () => {
-        /** @type {any} */
-        const b = '42';
-        const r = Number(b);
-        //console.log(r)
-    },
-    properties: () => {
-        /** @type {any} */
-        const o = {};
-        //const c = o['constructor']
-        //const c = o['__proto__']
-        //const c = o['__defineGetter__']
-        //const c = o['__defineSetter__']
-        //const c = o['__lookupGetter__']
-        //const c = o['__lookupSetter__']
-        //const c = o['hasOwnProperty']
-        //const c = o['isPrototypeOf']
-        //const c = o['propertyIsEnumerable']
-        //const c = o['toString']
-        const c = o['valueOf'];
-        //console.log(c)
-    },
-    getOwnPropertyDescriptor: () => {
-        const x = { 'a': 12 };
-        const c = Object.getOwnPropertyDescriptor(x, 'constructor');
-        const a = Object.getOwnPropertyDescriptor(x, 'a');
-    },
-    throw: () => {
-        todo();
-    },
-};

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

@@ -1,11 +0,0 @@
-/**
- * Synchronizes local development configuration generated from canonical repository files.
- *
- * @module
- */
-import { type Effect } from '../../effects/module.f.ts';
-import { type Mkdir, type NodeProgram, type ReadFile, type WriteFile } from '../../effects/node/module.f.ts';
-/** Regenerates VS Code's local MCP configuration from the canonical Copilot configuration. */
-export declare const syncMcp: () => Effect<Mkdir | ReadFile | WriteFile, void>;
-/** Runs all local development configuration generators. */
-export declare const main: NodeProgram;

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

@@ -1,20 +0,0 @@
-/**
- * Synchronizes local development configuration generated from canonical repository files.
- *
- * @module
- */
-import { history, historyStep, mapStep, step } from '../../effects/module.f.js';
-import { mkdir, readUtf8File, writeUtf8File } from '../../effects/node/module.f.js';
-import { unwrap } from '../../types/result/module.f.js';
-const source = '.copilot/mcp.json';
-const targetDirectory = '.vscode';
-const target = '.vscode/mcp.json';
-/** Regenerates VS Code's local MCP configuration from the canonical Copilot configuration. */
-export const syncMcp = () => {
-    const sourceText = history(mapStep(readUtf8File(source), unwrap));
-    const targetDirectoryReady = historyStep(sourceText, () => mapStep(mkdir(targetDirectory, { recursive: true }), unwrap));
-    const targetWritten = step(targetDirectoryReady, ([, text]) => writeUtf8File(target, text));
-    return mapStep(targetWritten, unwrap);
-};
-/** Runs all local development configuration generators. */
-export const main = () => mapStep(syncMcp(), () => 0);

package/fjs/dev/update/proof.f.d.ts

@@ -1,7 +0,0 @@
-export declare const proof: {
-    syncMcp: () => void;
-    main: () => void;
-    throw: {
-        missingSource: () => readonly [import("../../effects/node/virtual/module.f.ts").State, void];
-    };
-};

package/fjs/dev/update/proof.f.js

@@ -1,35 +0,0 @@
-/**
- * Proofs for local development configuration generation.
- *
- * @module
- */
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { utf8 } from '../../text/module.f.js';
-import { readUtf8File } from '../../effects/node/module.f.js';
-import { defaultNodeProgramOptions, emptyState, virtual } from '../../effects/node/virtual/module.f.js';
-import { main, syncMcp } from './module.f.js';
-import { step } from '../../effects/module.f.js';
-const mcp = '{"servers":{}}';
-const initial = {
-    ...emptyState,
-    root: {
-        '.copilot': {
-            'mcp.json': [utf8(mcp)],
-        },
-    },
-};
-export const proof = {
-    syncMcp: () => {
-        const generatedMcp = step(syncMcp(), () => readUtf8File('.vscode/mcp.json'));
-        const [, [tag, result]] = virtual(initial)(generatedMcp);
-        assert(tag === 'ok', result);
-        assertEq(result, mcp);
-    },
-    main: () => {
-        const [, result] = virtual(initial)(main(defaultNodeProgramOptions));
-        assertEq(result, 0);
-    },
-    throw: {
-        missingSource: () => virtual(emptyState)(syncMcp()),
-    },
-};

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

@@ -1,62 +0,0 @@
-/**
- * AST types and helpers for the DJS representation.
- *
- * @module
- */
-import type { Primitive, Array, Unknown } from '../module.f.ts';
-/**
- * A parsed DJS module: its imported module specifiers, in source order, and
- * its body.
- *
- * The specifier list indexes `['aref', i]`.
- */
-export type AstModule = [readonly string[], AstBody];
-/** A value in a module body: a primitive, a reference, an array, or an object. */
-export type AstConst = Primitive | AstModuleRef | AstArray | AstObject;
-/**
- * A reference to a value defined outside this `AstConst`.
- *
- * - `['aref', i]` — the `i`-th argument of the body, i.e. the `i`-th imported
- *   module of the enclosing `AstModule`.
- * - `['cref', i]` — the `i`-th entry of the enclosing `AstBody`.
- *
- * Both indices are absolute and zero-based, **not** offsets from the
- * referencing entry: in the body `[a, b, ['cref', 0]]` the reference resolves
- * to `a`, not to the nearest preceding entry `b`.
- *
- * A `cref` index must be smaller than the index of the entry holding it —
- * `run` evaluates a body left to right, so a reference to the current or a
- * later entry is unsatisfiable. It is not rejected: it resolves to the most
- * recently evaluated entry instead.
- */
-export type AstModuleRef = ['aref' | 'cref', number];
-/** An array value; its elements are evaluated in order. */
-export type AstArray = ['array', readonly AstConst[]];
-/** An object value, keyed by property name. */
-export type AstObject = {
-    readonly [k in string]?: AstConst;
-};
-/**
- * The constants of a module body, in declaration order. The **last** entry is
- * the value the module yields; the preceding entries exist to be named by
- * `['cref', i]`.
- *
- * A body describes the function
- *
- * ```js
- * (...args) => { const c0 = ...; const c1 = ...; return <last> }
- * ```
- *
- * where `args` are the imported modules.
- */
-export type AstBody = readonly AstConst[];
-/**
- * Evaluates a module body against its imported modules and returns the value
- * the module yields — the last entry of the body.
- *
- * Entries are evaluated left to right, so a `cref` resolves to an already
- * evaluated entry. A reference is shared, not copied: two properties holding
- * the same `['cref', i]` deserialize to the same object, which is what lets a
- * DJS module denote a graph rather than a tree.
- */
-export declare const run: (body: AstBody) => (args: Array) => Unknown;

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

@@ -1,61 +0,0 @@
-import { concat, fold, last, map, take, toArray } from '../../types/list/module.f.js';
-import { fromEntries } from '../../types/object/module.f.js';
-const { entries } = Object;
-const foldOp = ast => state => {
-    const djs = toDjs(state)(ast);
-    return { ...state, consts: concat(state.consts)([djs]) };
-};
-const foldAstObjectOp = entry => state => {
-    const e = concat(state.entries)([[entry[0], (toDjs(state.runState)(entry[1]))]]);
-    return { ...state, entries: e };
-};
-const toDjs = state => ast => {
-    switch (typeof ast) {
-        case 'boolean':
-        case 'number':
-        case 'string':
-        case 'bigint': {
-            return ast;
-        }
-        default: {
-            if (ast === null) {
-                return ast;
-            }
-            if (ast === undefined) {
-                return ast;
-            }
-            if (ast instanceof Array) {
-                switch (ast[0]) {
-                    case 'aref': {
-                        return state.args[ast[1]];
-                    }
-                    case 'cref': {
-                        return last(null)(take(ast[1] + 1)(state.consts));
-                    }
-                    case 'array': {
-                        return toArray(map(toDjs(state))(ast[1]));
-                    }
-                }
-            }
-            const e = fold(foldAstObjectOp)({ runState: state, entries: null })(entries(ast)).entries;
-            return fromEntries(e);
-        }
-    }
-};
-/**
- * Evaluates a module body against its imported modules and returns the value
- * the module yields — the last entry of the body.
- *
- * Entries are evaluated left to right, so a `cref` resolves to an already
- * evaluated entry. A reference is shared, not copied: two properties holding
- * the same `['cref', i]` deserialize to the same object, which is what lets a
- * DJS module denote a graph rather than a tree.
- */
-export const run = body => args => {
-    const state = fold(foldOp)({ body, args, consts: null })(body);
-    return last(null)(state.consts);
-};
-// for functions
-// export const astBodyToAstConst
-//     :(body: AstBody) => (args: AstArray) => AstConst
-//     = body => args => todo()