functionalscript 0.23.0 → 0.25.0

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

@@ -0,0 +1,8 @@
+export declare const proof: {
+    assertPassesOnTrue: () => void;
+    assertThrowsDefaultMsg: () => void;
+    assertThrowsCustomMsg: () => void;
+    assertEqPassesOnEqual: () => void;
+    assertEqThrowsOnUnequal: () => void;
+    todoThrows: () => void;
+};

package/fs/asserts/proof.f.js

@@ -0,0 +1,51 @@
+import { assert, assertEq, todo } from "./module.f.js";
+const throws = (f, expected) => {
+    let caught = false;
+    try {
+        f();
+    }
+    catch (e) {
+        caught = true;
+        if (e !== expected) {
+            throw ['unexpected throw value', e];
+        }
+    }
+    if (!caught) {
+        throw 'expected function to throw but it did not';
+    }
+};
+export const proof = {
+    assertPassesOnTrue: () => {
+        assert(true);
+        assert(true, 'with message');
+    },
+    assertThrowsDefaultMsg: () => {
+        throws(() => assert(false), 'assertion failed');
+    },
+    assertThrowsCustomMsg: () => {
+        throws(() => assert(false, 'oops'), 'oops');
+    },
+    assertEqPassesOnEqual: () => {
+        assertEq(1, 1);
+        assertEq('x', 'x');
+    },
+    assertEqThrowsOnUnequal: () => {
+        let caught = false;
+        try {
+            assertEq(1, 2);
+        }
+        catch (e) {
+            caught = true;
+            const arr = e;
+            if (arr[0] !== 1 || arr[1] !== 2) {
+                throw ['wrong throw value', e];
+            }
+        }
+        if (!caught) {
+            throw 'expected assertEq to throw';
+        }
+    },
+    todoThrows: () => {
+        throws(() => todo(), 'not implemented');
+    },
+};

package/fs/bnf/data/proof.f.js

@@ -3,7 +3,7 @@ import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
+import { commaJoin0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
@@ -437,15 +437,10 @@ export const proof = {
         },
         () => {
             const ws = repeat0Plus(set(' \n\r\t'));
-            const commaJoin0Plus = ([open, close], a) => [
-                open,
-                ws,
-                join0Plus([a, ws], [',', ws]),
-                close,
-            ];
+            const cj = commaJoin0Plus(ws);
             const value = () => ({
-                object: commaJoin0Plus('{}', 'a'),
-                array: commaJoin0Plus('[]', 'a')
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
             });
             value.name; //bun will fail if no usage of name found
             const m = parser(value);
@@ -642,15 +637,10 @@ export const proof = {
         },
         () => {
             const ws = repeat0Plus(set(' \n\r\t'));
-            const commaJoin0Plus = ([open, close], a) => [
-                open,
-                ws,
-                join0Plus([a, ws], [',', ws]),
-                close,
-            ];
+            const cj = commaJoin0Plus(ws);
             const value = () => ({
-                object: commaJoin0Plus('{}', 'a'),
-                array: commaJoin0Plus('[]', 'a')
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
             });
             value.name; //bun will fail if no usage of name found
             const m = descentParser(value);

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

@@ -131,6 +131,16 @@ export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>
  * Repeats `some` zero or more times separated by `separator`.
  */
 export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
+/**
+ * A delimited, comma-separated list with whitespace between tokens:
+ * `open ws (item ws (',' ws item ws)*)? close`.
+ *
+ * `ws` is the per-grammar whitespace rule and is curried so callers can
+ * partially apply it once (`const cj = commaJoin0Plus(ws)`) before reusing
+ * the same combinator at multiple bracket pairs. The two-character string
+ * supplies the bracket pair via destructuring (e.g. `'[]'`, `'{}'`).
+ */
+export declare const commaJoin0Plus: (ws: Rule) => ([open, close]: string, item: Rule) => Sequence;
 export type Repeat<T> = readonly T[];
 /**
  * Repeats a rule a fixed number of times.

package/fs/bnf/module.f.js

@@ -151,6 +151,16 @@ export const join1Plus = (some, separator) => [some, repeat0Plus([separator, som
  * Repeats `some` zero or more times separated by `separator`.
  */
 export const join0Plus = (some, separator) => option(join1Plus(some, separator));
+/**
+ * A delimited, comma-separated list with whitespace between tokens:
+ * `open ws (item ws (',' ws item ws)*)? close`.
+ *
+ * `ws` is the per-grammar whitespace rule and is curried so callers can
+ * partially apply it once (`const cj = commaJoin0Plus(ws)`) before reusing
+ * the same combinator at multiple bracket pairs. The two-character string
+ * supplies the bracket pair via destructuring (e.g. `'[]'`, `'{}'`).
+ */
+export const commaJoin0Plus = (ws) => ([open, close], item) => [open, ws, join0Plus([item, ws], [',', ws]), close];
 /**
  * Repeats a rule a fixed number of times.
  */

package/fs/bnf/testlib.f.js

@@ -1,4 +1,4 @@
-import { join0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
+import { commaJoin0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
 export const classic = () => {
     // https://www.json.org/json-en.html
     const json = () => [element];
@@ -123,15 +123,10 @@ export const deterministic = () => {
         option([set('Ee'), option(set('+-')), digits])
     ];
     const ws = repeat0Plus(set(' \n\r\t'));
-    const commaJoin0Plus = ([open, close], a) => [
-        open,
-        ws,
-        join0Plus([a, ws], [',', ws]),
-        close,
-    ];
+    const cj = commaJoin0Plus(ws);
     const value = () => ({
-        array: commaJoin0Plus('[]', value),
-        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
+        array: cj('[]', value),
+        object: cj('{}', [string, ws, ':', ws, value]),
         string,
         number,
         true: 'true',

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

@@ -5,8 +5,8 @@
  */
 import { type Sha2 } from '../crypto/sha2/module.f.ts';
 import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
-import { type Fs, type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
+import { type Fs, type NodeOp } from '../effects/node/module.f.ts';
 export type KvStore<O extends Operation> = {
     /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;

package/fs/cas/module.f.js

@@ -6,8 +6,8 @@
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { begin, forEachStep, pure } from "../types/effects/module.f.js";
-import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { begin, forEachStep, pure } from "../effects/module.f.js";
+import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };

package/fs/cas/proof.f.js

@@ -1,9 +1,9 @@
 import { cas, main } from "./module.f.js";
 import { sha256 } from "../crypto/sha2/module.f.js";
 import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { run } from "../types/effects/mock/module.f.js";
-import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { run } from "../effects/mock/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 export const proof = {
     mainAdd: () => {
         const content = vec8(0x2an);

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

@@ -37,6 +37,7 @@ export declare const gitHubActionSchema: {
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+        readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
@@ -55,6 +56,7 @@ export declare const parseGitHubAction: import("../../types/rtti/parse/module.f.
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+        readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;

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

@@ -23,7 +23,10 @@ export const jobSchema = {
 export const jobsSchema = record(jobSchema);
 export const gitHubActionSchema = {
     name: string,
-    on: { pull_request: option({}) },
+    on: {
+        pull_request: option({}),
+        merge_group: option({})
+    },
     jobs: jobsSchema
 };
 export const parseGitHubAction = rttiParse(gitHubActionSchema);

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

@@ -28,7 +28,7 @@ export declare const node: {
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260604.1";
+export declare const tsgo = "7.0.0-dev.20260605.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";
@@ -37,5 +37,5 @@ export declare const actions: {
     readonly 'oven-sh/setup-bun': "v2";
     readonly 'bytecodealliance/actions/wasmtime/setup': "v1";
     readonly 'wasmerio/setup-wasmer': "v3.1";
-    readonly 'dtolnay/rust-toolchain': "1.95.0";
+    readonly 'dtolnay/rust-toolchain': "1.96.0";
 };

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

@@ -36,7 +36,7 @@ export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260604.1';
+export const tsgo = '7.0.0-dev.20260605.1';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.
@@ -57,5 +57,5 @@ export const actions = {
     // https://github.com/wasmerio/setup-wasmer
     'wasmerio/setup-wasmer': 'v3.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.95.0',
+    'dtolnay/rust-toolchain': '1.96.0',
 };

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

@@ -1,12 +1,11 @@
-import { type Effect } from '../types/effects/module.f.ts';
-import { type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';
 export type Setup = {
-    readonly rust: boolean;
     readonly nodeExtra: (os: Os) => readonly MetaStep[];
     readonly denoExtra: readonly MetaStep[];
     readonly bunExtra: readonly MetaStep[];
 };
-export declare const ci: ({ rust, nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
+export declare const ci: ({ nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
 declare const _default: () => Effect<NodeOp, number>;
 export default _default;

package/fs/ci/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { access, writeFile } from "../effects/node/module.f.js";
 import { images } from "./config/module.f.js";
 import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";
@@ -24,7 +24,8 @@ const job = (rust, nodeExtra, denoExtra, bunExtra) => (o) => (a) => {
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
-export const ci = ({ rust, nodeExtra, denoExtra, bunExtra }) => {
+export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').step(result => {
+    const rust = result[0] === 'ok';
     const jobs = {
         ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o), denoExtra, bunExtra)(o)))),
         ...nodeVersions,
@@ -32,15 +33,16 @@ export const ci = ({ rust, nodeExtra, denoExtra, bunExtra }) => {
     };
     const gha = {
         name: 'CI',
-        on: { pull_request: {} },
+        on: {
+            pull_request: {},
+            merge_group: {},
+        },
         jobs,
     };
-    return begin
-        .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
+    return writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
         .step(() => pure(0));
-};
+});
 const defaultEffect = ci({
-    rust: true,
     nodeExtra: o => [
         test({ run: 'npm pack' }),
         test({ run: `npm install -g ${findTgz(o)}` }),

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

@@ -17,8 +17,10 @@ export const basicNode = (version) => (extra) => clean([
     ...extra,
 ]);
 const basicTests = [
-    test({ run: 'npm t' }),
-    test({ run: 'npm run fst' }),
+    test({ run: 'npx tsc' }),
+    test({ run: 'npm test' }),
+    test({ run: 'node --test' }),
+    test({ run: 'npm run cov' }),
 ];
 export const nodeTests = (version) => (extra) => basicNode(version)([
     ...basicTests,

package/fs/ci/proof.f.js

@@ -1,19 +1,22 @@
 import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
-import { isVec } from "../types/bit_vec/module.f.js";
+import { empty as emptyVec, isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
-import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
-const githubState = {
+const makeState = (rust) => ({
     ...emptyState,
-    root: { '.github': { workflows: {} } },
-};
+    root: {
+        '.github': { workflows: {} },
+        ...(rust ? { 'Cargo.toml': emptyVec } : {}),
+    },
+});
 const run = (rust, nodeExtra = () => []) => {
-    const [state, result] = virtual(githubState)(ci({ rust, nodeExtra, denoExtra: [], bunExtra: [] }));
+    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra, denoExtra: [], bunExtra: [] }));
     assert(result === 0, result);
     const dotGithub = state.root['.github'];
     assert(typeof dotGithub === 'object', dotGithub);

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

@@ -9,47 +9,43 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         const r = bitLength - d;
         return (n) => n >> d | n << r;
     };
-    const bigSigma = ([a, b, c]) => {
+    const sigma = third => (a, b, c) => {
         const ra = rotr(a);
         const rb = rotr(b);
-        const rc = rotr(c);
-        return (x) => ra(x) ^ rb(x) ^ rc(x);
+        const rc = third(c);
+        return x => ra(x) ^ rb(x) ^ rc(x);
     };
-    const bigSigma0 = bigSigma(bs0);
-    const bigSigma1 = bigSigma(bs1);
-    const smallSigma = ([a, b, c]) => {
-        const ra = rotr(a);
-        const rb = rotr(b);
-        return (x) => ra(x) ^ rb(x) ^ (x >> c);
-    };
-    const smallSigma0 = smallSigma(ss0);
-    const smallSigma1 = smallSigma(ss1);
+    const bigSigma = sigma(rotr);
+    const smallSigma = sigma(c => x => x >> c);
+    const bigSigma0 = bigSigma(...bs0);
+    const bigSigma1 = bigSigma(...bs1);
+    const smallSigma0 = smallSigma(...ss0);
+    const smallSigma1 = smallSigma(...ss1);
     const ch = (x, y, z) => x & y ^ ~x & z;
     const maj = (x, y, z) => x & y ^ x & z ^ y & z;
     const m = mask(bitLength);
-    const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) & m;
-    const nextW = ([w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]) => {
-        w0 = wi([wE, w9, w1, w0]);
-        w1 = wi([wF, wA, w2, w1]);
-        w2 = wi([w0, wB, w3, w2]);
-        w3 = wi([w1, wC, w4, w3]);
-        w4 = wi([w2, wD, w5, w4]);
-        w5 = wi([w3, wE, w6, w5]);
-        w6 = wi([w4, wF, w7, w6]);
-        w7 = wi([w5, w0, w8, w7]);
-        w8 = wi([w6, w1, w9, w8]);
-        w9 = wi([w7, w2, wA, w9]);
-        wA = wi([w8, w3, wB, wA]);
-        wB = wi([w9, w4, wC, wB]);
-        wC = wi([wA, w5, wD, wC]);
-        wD = wi([wB, w6, wE, wD]);
-        wE = wi([wC, w7, wF, wE]);
-        wF = wi([wD, w8, w0, wF]);
+    const wi = (a0, a1, a2, a3) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) & m;
+    const nextW = (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF) => {
+        w0 = wi(wE, w9, w1, w0);
+        w1 = wi(wF, wA, w2, w1);
+        w2 = wi(w0, wB, w3, w2);
+        w3 = wi(w1, wC, w4, w3);
+        w4 = wi(w2, wD, w5, w4);
+        w5 = wi(w3, wE, w6, w5);
+        w6 = wi(w4, wF, w7, w6);
+        w7 = wi(w5, w0, w8, w7);
+        w8 = wi(w6, w1, w9, w8);
+        w9 = wi(w7, w2, wA, w9);
+        wA = wi(w8, w3, wB, wA);
+        wB = wi(w9, w4, wC, wB);
+        wC = wi(wA, w5, wD, wC);
+        wD = wi(wB, w6, wE, wD);
+        wE = wi(wC, w7, wF, wE);
+        wF = wi(wD, w8, w0, wF);
         return [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF];
     };
     const kLength = k.length;
-    const compressV16 = ([a0, b0, c0, d0, e0, f0, g0, h0]) => (data) => {
-        let w = data;
+    const compressV16 = (a0, b0, c0, d0, e0, f0, g0, h0) => w => {
         let a = a0;
         let b = b0;
         let c = c0;
@@ -77,7 +73,7 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
             if (i === kLength) {
                 break;
             }
-            w = nextW(w);
+            w = nextW(...w);
         }
         return [
             (a0 + a) & m,
@@ -90,10 +86,10 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
             (h0 + h) & m,
         ];
     };
-    const at = (u) => (i) => (u >> (i << logBitLen)) & m;
-    const compress = (i) => (u) => {
+    const at = u => i => (u >> (i << logBitLen)) & m;
+    const compress = i => u => {
         const a = at(u);
-        return compressV16(i)([
+        return compressV16(...i)([
             a(15n),
             a(14n),
             a(13n),

package/fs/crypto/vdf/module.f.d.ts

@@ -0,0 +1,21 @@
+import type { Nullable } from '../../types/nullable/module.f.ts';
+/** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
+export declare const p = 170082004324204494273811327264862981553264701145937538369570764779791492622392118654022654452947093285873855529044371650895045691292912712699015605832276411308653107069798639938826015099738961427172366594187783204437869906954750443653318078358839409699824714551430573905637228307966826784684174483831608534979n;
+/**
+ * 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;
+};
+/**
+ * Builds Sloth VDF operations over `modulus`.
+ */
+export declare const sloth_vdf: (modulus: bigint) => Sloth;
+/** Sloth VDF over {@link p}. */
+export declare const sloth: Sloth;

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

@@ -0,0 +1,57 @@
+/**
+ * Sloth verifiable delay function over a fixed 3072-bit safe prime.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { sloth } from './module.f.ts'
+ *
+ * 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.js";
+/** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
+export const p = 0xf2346eae06a233882814ff16f6a076d3b8f2161c5c92171c0b7b84eed4e9475bcce0c13bde34512afdf90f41ab9b86dcf834f85e04b27fadee712eed23a1d4e58cd1b09d9bfb10696d614f119179a40c49dc8762edc29e8115263913237e14718cbcd4dc6b35bace13f8cdb1b5156c50c47b4aaee0820c874e2864cb854367c3n;
+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`.
+ */
+export const sloth_vdf = (modulus) => {
+    const field = prime_field(modulus);
+    const { neg, pow2, reduce, quadRes } = field;
+    const root = modSqrt(field);
+    const squareLoop = (steps) => (value) => repeatSeq(steps)(pow2)(reduce(value));
+    const modSqrtLoop = (steps) => (value) => repeatSeq(steps)(root)(reduce(value));
+    const evalSteps = (steps) => (x) => steps < 0n ? null : modSqrtLoop(steps)(x);
+    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/fs/crypto/vdf/proof.f.d.ts

@@ -0,0 +1,32 @@
+export declare const proof: {
+    p: {
+        matchesField: () => void;
+    };
+    eval: {
+        steps100: () => void;
+        steps10: () => void;
+        steps6: () => void;
+        steps4: () => void;
+        zeroSteps: () => void;
+        negativeSteps: () => void;
+    };
+    verify: {
+        steps100: () => void;
+        steps10: () => void;
+        steps6: () => void;
+        steps4: () => void;
+        tampered: () => void;
+        wrongY: () => void;
+        zeroSteps: () => void;
+        negativeSteps: () => void;
+        invalidY: () => void;
+    };
+    modSqrt: {
+        roundTrip: () => void;
+        nonResidue: () => void;
+    };
+    quadRes: {
+        one: () => void;
+        nonResidue: () => void;
+    };
+};