functionalscript 0.43.0 → 0.44.0

package/fjs/crypto/vdf/module.f.mjs

@@ -0,0 +1,84 @@
+/**
+ * Sloth verifiable delay function over a fixed 3072-bit safe prime.
+ *
+ * See `./types.ts` for the `Sloth` type-level API.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { sloth } from './module.f.mjs'
+ *
+ * const steps = 4n
+ * const x = 42n
+ * const y = sloth.eval(steps)(x)
+ * if (y === null || !sloth.verify(steps)(x)(y)) { throw y }
+ * ```
+ */
+import { modSqrt, prime_field } from '../../types/prime_field/module.f.mjs'
+/** @import { PrimeField } from '../../types/prime_field/types.ts' */
+/** @import { Nullable } from '../../types/nullable/types.ts' */
+/** @import { Unary } from '../../types/bigint/types.ts' */
+/** @import { Sloth } from './types.ts' */
+
+/** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
+export const p =
+    0xf2346eae06a23388_2814ff16f6a076d3_b8f2161c5c92171c_0b7b84eed4e9475b_cce0c13bde34512a_fdf90f41ab9b86dc_f834f85e04b27fad_ee712eed23a1d4e5_8cd1b09d9bfb1069_6d614f119179a40c_49dc8762edc29e81_15263913237e1471_8cbcd4dc6b35bace_13f8cdb1b5156c50_c47b4aaee0820c87_4e2864cb854367c3n
+
+/** @type {(steps: bigint) => (f: Unary) => (value: bigint) => bigint} */
+const repeatSeq = steps => f => value => {
+    let v = value
+    let i = 0n
+    while (i < steps) {
+        v = f(v)
+        i = i + 1n
+    }
+    return v
+}
+
+/**
+ * Builds Sloth VDF operations over `modulus`.
+ *
+ * @type {(modulus: bigint) => Sloth}
+ */
+export const sloth_vdf = modulus => {
+    /** @type {PrimeField} */
+    const field = prime_field(modulus)
+    const { neg, pow2, reduce, quadRes } = field
+    const root = modSqrt(field)
+
+    /** @type {(steps: bigint) => (value: bigint) => bigint} */
+    const squareLoop = steps => value =>
+        repeatSeq(steps)(pow2)(reduce(value))
+
+    /** @type {(steps: bigint) => (value: bigint) => bigint} */
+    const modSqrtLoop = steps => value =>
+        repeatSeq(steps)(root)(reduce(value))
+
+    /** @type {(steps: bigint) => (x: bigint) => Nullable<bigint>} */
+    const evalSteps = steps => x =>
+        steps < 0n ? null : modSqrtLoop(steps)(x)
+
+    /** @type {(steps: bigint) => (x: bigint) => (y: bigint) => boolean} */
+    const verifySteps = steps => x => y => {
+        if (steps < 0n) {
+            return false
+        }
+        const input = reduce(x)
+        const squared = squareLoop(steps)(y)
+        const value = quadRes(squared) ? squared : neg(squared)
+        return input === value || neg(input) === value
+    }
+
+    return {
+        p: modulus,
+        quadRes,
+        modSqrt: root,
+        eval: evalSteps,
+        verify: verifySteps,
+    }
+}
+
+/** Sloth VDF over {@link p}. */
+export const sloth = sloth_vdf(p)

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

@@ -0,0 +1,106 @@
+import { sloth, p } from './module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+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/crypto/vdf/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Types for the Sloth verifiable delay function.
+ *
+ * @module
+ */
+import type { Nullable } from '../../types/nullable/types.ts';
+/**
+ * Sloth VDF over prime `modulus` (`p ≡ 3 (mod 4)`).
+ */
+export type Sloth = {
+    readonly p: bigint;
+    readonly quadRes: (x: bigint) => boolean;
+    readonly modSqrt: (x: bigint) => bigint;
+    /** Sequential Sloth permutation; `null` when `steps < 0`. */
+    readonly eval: (steps: bigint) => (x: bigint) => Nullable<bigint>;
+    /** Fast verification of {@link Sloth.eval}; `false` when `steps < 0`. */
+    readonly verify: (steps: bigint) => (x: bigint) => (y: bigint) => boolean;
+};

package/fjs/crypto/vdf/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for the Sloth verifiable delay function.
+ *
+ * @module
+ */
+export {};

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

@@ -0,0 +1,56 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
+import type { Env } from '../effects/node/types.ts';
+import type { Effect } from '../effects/types.ts';
+import type { ModuleMap, LoadModuleOperations } from './types.ts';
+/** @import { Dir } from '../effects/node/virtual/types.ts' */
+/** @import { Module, ModuleMap, LoadModuleOperations } from './types.ts' */
+/**
+ * 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.
+ *
+ * @type {(s: string) => boolean}
+ */
+export declare const shouldLoad: (s: string) => boolean;
+/**
+ * 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.
+ *
+ * @type {(env: Env) => Effect<LoadModuleOperations, ModuleMap>}
+ */
+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.mjs

@@ -0,0 +1,170 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
+
+import { all, import_, readdir } from '../effects/node/module.f.mjs'
+/** @import { Access, All, Env, Import, Readdir } from '../effects/node/types.ts' */
+import { cmp as strCmp } from '../types/string/module.f.mjs'
+import { unwrap } from '../types/result/module.f.mjs'
+import { pure, step } from '../effects/module.f.mjs'
+/** @import { Effect } from '../effects/types.ts' */
+import { join, relativize, toPosix } from '../path/module.f.mjs'
+import { assert, assertEq } from '../asserts/module.f.mjs'
+import { emptyState, virtual } from '../effects/node/virtual/module.f.mjs'
+/** @import { Dir } from '../effects/node/virtual/types.ts' */
+/** @import { Module, ModuleMap, LoadModuleOperations } from './types.ts' */
+
+/**
+ * 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.
+ *
+ * @type {(s: string) => boolean}
+ */
+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')
+
+/** @type {(path: string) => boolean} */
+const isSourceFile = path =>
+    path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs')
+
+/** @type {(s: string, predicate: (path: string) => boolean) => Effect<Readdir | All, readonly string[]>} */
+const allFiles = (s, predicate) => {
+    /** @type {(p: string) => Effect<Readdir | All, readonly string[]>} */
+    const load = p => {
+        const x0 = step(
+            readdir(p, {}),
+            d => {
+                /** @type {readonly Effect<Readdir | All, readonly string[]>[]} */
+                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)
+}
+
+/** @type {(f: string) => Effect<Access | Import, readonly (readonly [string, Module])[]>} */
+const loadFile = f =>
+    step(
+        import_(f),
+        r => pure([/** @type {const} */ ([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.
+ *
+ * @type {(env: Env) => Effect<LoadModuleOperations, ModuleMap>}
+ */
+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]) => /** @type {const} */ ([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.
+        /** @type {Dir} */
+        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.
+        /** @type {Dir} */
+        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.
+        /** @type {Dir} */
+        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.mts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for reading package.json-style metadata without losing unrelated
+ * fields before write-back.
+ *
+ * @module
+ *
+ * @import { ValidationError } from '../../types/rtti/common/types.ts'
+ * @import { Ts } from '../../types/rtti/ts/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ */
+import type { ValidationError } from '../../types/rtti/common/types.ts';
+import type { Ts } from '../../types/rtti/ts/types.ts';
+import type { Result } from '../../types/result/types.ts';
+export declare const packageJsonSchema: {
+    readonly name: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts")._Type0<"string">, undefined]>;
+    readonly version: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts")._Type0<"string">, undefined]>;
+    readonly scripts: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Type1<"record", import("../../types/rtti/types.ts")._Type0<"string">>, undefined]>;
+};
+export type PackageJson = Ts<typeof packageJsonSchema>;
+export type JsonTextError = string | ValidationError;
+/** @typedef {Ts<typeof packageJsonSchema>} PackageJson */
+/** @typedef {string | ValidationError} JsonTextError */
+export declare const validatePackageJson: import("../../types/rtti/common/types.ts").Validate<{
+    readonly name: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts")._Type0<"string">, undefined]>;
+    readonly version: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts")._Type0<"string">, undefined]>;
+    readonly scripts: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Type1<"record", import("../../types/rtti/types.ts")._Type0<"string">>, undefined]>;
+}>;
+/**
+ * @param {string} text
+ * @returns {Result<PackageJson, JsonTextError>}
+ */
+export declare const validatePackageJsonText: (text: string) => Result<PackageJson, JsonTextError>;

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

@@ -0,0 +1,37 @@
+/**
+ * Helpers for reading package.json-style metadata without losing unrelated
+ * fields before write-back.
+ *
+ * @module
+ *
+ * @import { ValidationError } from '../../types/rtti/common/types.ts'
+ * @import { Ts } from '../../types/rtti/ts/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ */
+
+import { parse as parseJsonText } from '../../media/json/module.f.mjs'
+import { option, record, string } from '../../types/rtti/module.f.mjs'
+import { validate as rttiValidate } from '../../types/rtti/validate/module.f.mjs'
+import { error, ok } from '../../types/result/module.f.mjs'
+
+export const packageJsonSchema = /** @type {const} */ ({
+    name: option(string),
+    version: option(string),
+    scripts: option(record(string)),
+})
+
+/** @typedef {Ts<typeof packageJsonSchema>} PackageJson */
+/** @typedef {string | ValidationError} JsonTextError */
+
+export const validatePackageJson = rttiValidate(packageJsonSchema)
+
+/**
+ * @param {string} text
+ * @returns {Result<PackageJson, JsonTextError>}
+ */
+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.mjs

@@ -0,0 +1,32 @@
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { unwrap } from '../../types/result/module.f.mjs'
+import {
+    validatePackageJson,
+    validatePackageJsonText,
+} from './module.f.mjs'
+
+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 = /** @type {const} */ ({ 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.mts

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

package/fjs/dev/proof.f.mjs

@@ -0,0 +1,78 @@
+import { assert, assertEq, todo } from '../asserts/module.f.mjs'
+import { shouldLoad } from './module.f.mjs'
+
+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/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Types for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
+import type { StringMap } from '../types/object/types.ts';
+import type { Access, All, Import, Readdir } from '../effects/node/types.ts';
+export type Module = {
+    readonly proof?: unknown;
+    readonly [k: string]: unknown;
+};
+export type ModuleMap = StringMap<Module>;
+/** The effect operations required to discover and load a module map. */
+export type LoadModuleOperations = Access | Import | All | Readdir;

package/fjs/dev/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
+export {};