functionalscript 0.36.0 → 0.38.0

package/fs/bnf/proof.f.js

@@ -1,104 +0,0 @@
-import { classic, deterministic } from "./testlib.f.js";
-import { rangeEncode, str, set, range, commaJoin0Plus, isEmpty, oneEncode, repeat1Plus, } from "./module.f.js";
-export const proof = {
-    test: () => {
-        classic();
-        deterministic();
-    },
-    throw: {
-        rangeEncodeInvalid: [
-            () => { rangeEncode(-1, 0); },
-            () => { rangeEncode(0, -1); },
-            () => { rangeEncode(5, 3); },
-        ],
-        rangeInvalid: [
-            () => { range('a'); },
-            () => { range('abc'); },
-        ],
-    },
-    str: [
-        () => {
-            const result = str('a');
-            if (typeof result !== 'number') {
-                throw result;
-            }
-            if (result !== oneEncode(0x61)) {
-                throw result;
-            }
-        },
-        () => {
-            const result = str('ab');
-            if (!Array.isArray(result)) {
-                throw result;
-            }
-            if (result.length !== 2) {
-                throw result;
-            }
-        },
-    ],
-    set: () => {
-        const result = set('abc');
-        if (typeof result !== 'object' || result === null) {
-            throw result;
-        }
-        if (!('a' in result)) {
-            throw result;
-        }
-        if (!('b' in result)) {
-            throw result;
-        }
-        if (!('c' in result)) {
-            throw result;
-        }
-    },
-    commaJoin0Plus: () => {
-        const ws = '';
-        const item = 'x';
-        const result = commaJoin0Plus(ws)('[]', item);
-        if (!Array.isArray(result)) {
-            throw result;
-        }
-        if (result[0] !== '[') {
-            throw result;
-        }
-    },
-    isEmpty: [
-        () => { if (!isEmpty('')) {
-            throw 'empty string should be empty';
-        } },
-        () => { if (!isEmpty([])) {
-            throw 'empty array should be empty';
-        } },
-        () => { if (isEmpty('a')) {
-            throw 'non-empty string should not be empty';
-        } },
-        () => {
-            const f = () => '';
-            if (!isEmpty(f)) {
-                throw 'function returning empty string should be empty';
-            }
-        },
-    ],
-    repeat1Plus: [
-        () => {
-            const result = repeat1Plus('x');
-            if (result[0] !== 'x') {
-                throw result[0];
-            }
-            if (typeof result[1] !== 'function') {
-                throw 'expected repeat0Plus function';
-            }
-        },
-        () => {
-            const rule = 'ab';
-            const result = repeat1Plus(rule);
-            if (result[0] !== rule) {
-                throw result[0];
-            }
-            const inner = result[1]();
-            if (!('some' in inner) || !('none' in inner)) {
-                throw 'expected Option shape';
-            }
-        },
-    ],
-};

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

@@ -1,36 +0,0 @@
-import { type Effect } from '../../effects/module.f.ts';
-import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type Read, type Write } from '../../effects/node/module.f.ts';
-import { type McpConfig, type McpHandlers } from '../../mcp/module.f.ts';
-import { type FileCasOperation } from '../module.f.ts';
-/** Arguments for `cas_add`: content to store, with optional encoding type. */
-export declare const casAddArgs: {
-    readonly content: import("../../types/rtti/module.f.ts").String;
-    readonly type: import("../../types/rtti/module.f.ts").Or<["text", "base64", undefined]>;
-};
-/** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export declare const casGetArgs: {
-    readonly hash: import("../../types/rtti/module.f.ts").String;
-    readonly content: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
-};
-/** Arguments for `cas_list`: none. */
-export declare const casListArgs: {};
-/**
- * MCP handlers for `FileCas`.
- */
-export declare const casMcpHandlers: (home: string) => McpHandlers<FileCasOperation>;
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export declare const casConfig: McpConfig;
-/**
- * Runs the file CAS MCP server over stdio: allocates the session-state slot, builds
- * the `mcpStep` for `c`, and drives the read → parse → dispatch → write loop
- * until stdin EOF.
- */
-export declare const casMcpServer: (home: string) => Effect<Read | Write | MemOp | FileCasOperation, void>;
-export declare const proof: {
-    casMcpServer: () => void;
-    collectReadOverflow: () => void;
-};

package/fs/cas/mcp/module.f.js

@@ -1,249 +0,0 @@
-/**
- * MCP adapter for the content-addressable store.
- *
- * Maps `Cas<O>` operations onto MCP tools, so an agent that speaks MCP can
- * store a blob and get back its hash, fetch a blob by hash, and enumerate
- * what is stored — without shelling out to the `cas` CLI. The store itself
- * (`fs/cas/module.f.ts`) stays transport-agnostic; this is an additional
- * front end alongside the CLI `main`.
- *
- * ## Tools
- *
- * | Tool       | args                          | action           | result                              |
- * |------------|-------------------------------|------------------|-------------------------------------|
- * | `cas_add`  | `{ content, type? }`          | `c.write(...)`   | hash (cBase32)                      |
- * | `cas_get`  | `{ hash, content?: boolean }` | `c.read(key)`    | JSON `{length,mime_type,type[,content]}` |
- * | `cas_list` | `{}`                          | `c.list()`       | hashes, one per line                |
- *
- * ## `cas_add` input encoding
- *
- * The optional `type` field controls how `content` is interpreted:
- * - `'text'` (default, or omitted): `content` is a UTF-8 string stored as raw
- *   bytes. Most agent-generated content (scripts, JSON, prompts) can be stored
- *   without any encoding step.
- * - `'base64'`: `content` is RFC 4648 base64, decoded to bytes before storage.
- *   Use this for pre-encoded binary payloads.
- *
- * Inline content (either encoding) is capped at 128 KiB (`maxLength`). There is
- * no MCP route for larger content — the server never opens a local path named by
- * the client (see the invariant in `fs/cas/mcp/README.md`); large files go
- * through the `cas` CLI (`cas add <path>`) instead, run directly by the user.
- *
- * ## `cas_get` output
- *
- * Always returns a JSON object `{ length, mime_type, type[, url][, content] }`.
- * `type` is always present (`'text'` or `'base64'`). A single classifier — the
- * `fs/mime` detector state machine (length × magic-byte eliminator × UTF-8 DFA) —
- * produces the same three-way verdict on both paths, so there is no second,
- * divergent copy of the rules:
- *
- * 1. **Magic-byte hit** (PNG/JPEG/GIF/WebP/PDF/ZIP) → `type: 'base64'` with the
- *    detected `mime_type`.
- * 2. **Whole-blob-valid UTF-8** → `type: 'text'`, `mime_type: 'text/plain'`.
- * 3. **Fallback** → `type: 'base64'`, `mime_type: 'application/octet-stream'`.
- *
- * **Metadata-only (`content: false`, the default) is size-independent.** It folds
- * the read stream through `fs/mime` `detectStream` and never buffers the blob.
- * Because a single `Vec` caps at `maxLength` bits (128 KiB), the old
- * drain-into-one-`Vec` approach failed on any blob larger than one chunk even when
- * only metadata was asked for; streaming detection returns correct
- * `{ length, mime_type, type[, url] }` regardless of size.
- *
- * **`content: true`** first derives `{ length, mime_type, type }` with the same
- * size-independent `fs/mime` `detectStream` machine, then materializes the bytes
- * (via `collectRead`, bounded by `maxLength`) and encodes the inline payload by
- * `type` — a `fs/text/utf8` `fromVec` string for `text`, base64 for `base64`. A
- * blob larger than `maxLength` (128 KiB) cannot be buffered into one `Vec`, so it
- * is rejected here with a descriptive *"too large"* error (carrying the byte size
- * and `url`) rather than being misreported as absent; it should be fetched via
- * `url` or inspected with metadata-only `cas_get`.
- *
- * ## Encoding split: hashes vs. content
- *
- * `Cas<O>` deals in `Vec` (bit vectors); MCP models only `textContent` today.
- * **Hashes** travel as cBase32 (`fs/cbase32`) — the canonical CAS hash format,
- * shared with the CLI and the on-disk store layout. **Content** encoding is
- * determined at read time as described above.
- *
- * ## Error convention
- *
- * MCP draws a line the dispatcher already respects: *protocol* failures
- * (unknown method, malformed JSON-RPC params) are JSON-RPC errors handled by
- * `mcpStep`. *Tool* failures come back as a normal `tools/call` result with
- * `isError: true` and a text explanation, so the model can read and react:
- * - `type: 'base64'` with malformed content (base64 `decode` → `null`) → `isError`
- * - malformed `hash` (`cBase32ToVec` → `null`) → `isError`
- * - `cas_get` on an absent hash (`c.read` → `undefined`) → `isError`
- * - `cas_get` with `content: true` on a blob larger than `maxLength` → `isError`
- *   (distinct "too large" message, not "no such hash")
- * - unknown tool `name` → `isError`
- *
- * @module
- */
-import { string, option, or, boolean } from "../../types/rtti/module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { pure, decode } from "../../effects/module.f.js";
-import { create } from "../../effects/memory/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../../cbase32/module.f.js";
-import { decode as base64Decode, encode as base64Encode } from "../../base64/module.f.js";
-import { tryUtf8 } from "../../text/module.f.js";
-import { detectStream } from "../../mime/module.f.js";
-import { empty, length as bitVecLength, maxLength, maxLengthBytes, msb, vec } from "../../types/bit_vec/module.f.js";
-import { ok, error } from "../../types/result/module.f.js";
-import {} from "../../effects/node/module.f.js";
-import { stdioTransport } from "../../mcp/stdio/module.f.js";
-import { mcpStep, uninitializedState, toolEntry, fromRegistry, errorResult, } from "../../mcp/module.f.js";
-import { fileCas } from "../module.f.js";
-import { fromVec } from "../../text/utf8/module.f.js";
-import { identity } from "../../types/function/module.f.js";
-import { sha256 } from "../../crypto/sha2/module.f.js";
-import { nonEmpty, empty as elEmpty } from "../../effects/list/module.f.js";
-// ── Argument schemas (declared once, used for both inputSchema and validate) ─────
-/** Arguments for `cas_add`: content to store, with optional encoding type. */
-export const casAddArgs = {
-    content: string,
-    type: or('text', 'base64', undefined)
-};
-/** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export const casGetArgs = {
-    hash: string,
-    content: option(boolean)
-};
-/** Arguments for `cas_list`: none. */
-export const casListArgs = {};
-// ── Stream helper ────────────────────────────────────────────────────────────────
-/**
- * Drains a CAS read stream into a single `Vec`. Used only on the `content: true`
- * path, where the whole blob is needed for inline base64 / UTF-8 transfer; the
- * chunk stream is concatenated and an error item is surfaced as the result.
- * Metadata-only `cas_get` avoids this entirely via `fs/mime` `detectStream`,
- * which is why it is not bound by the `maxLength` ceiling below.
- */
-const collectRead = (stream) => {
-    const loop = (acc) => (s) => s.step((node) => {
-        if (node === undefined) {
-            return pure(ok(acc));
-        }
-        const { first, tail } = node;
-        const [t, v] = first;
-        if (t === 'error') {
-            return pure(first);
-        }
-        // A single `Vec` cannot exceed `maxLength` bits; concatenating past it would
-        // overflow the runtime's `bigint` constraint. Surface that as an error item
-        // so the tool reports a failure rather than crashing the process.
-        if (bitVecLength(acc) + bitVecLength(v) > maxLength) {
-            return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`));
-        }
-        return loop(msb.concat(acc)(v))(tail);
-    });
-    return loop(empty)(stream);
-};
-// ── Tool registry ──────────────────────────────────────────────────────────────
-const toJson = stringify(identity);
-/** Registry of all CAS tools. */
-const casToolRegistry = (home) => {
-    const c = fileCas(sha256)(home);
-    return [
-        toolEntry('cas_add', 'Store content and return its hash (cBase32). Pass type:"base64" for binary; omit or pass type:"text" for UTF-8 text (default). Inline content is capped at 128 KiB (131072 bytes) — larger content is rejected. For larger content, store the file with the `cas` CLI instead: run `npx functionalscript cas add <path>` yourself if you have shell access, or give the user that exact command to run — it prints the resulting hash on stdout.', casAddArgs, ({ type, content }) => {
-            // type:'text' or 'base64' — resolve content to Vec, store via c.write()
-            let x = type === 'base64'
-                ? base64Decode(content)
-                : tryUtf8(content);
-            return x === null
-                ? pure(errorResult('too large or malformed — for large content, run `npx functionalscript cas add <path>` (or have the user run it) instead'))
-                // The resolved content fits in one chunk; feed it as a single-item stream.
-                : c.write(nonEmpty(ok(x), elEmpty())).step(([tag, hash]) => pure(tag === 'error'
-                    ? errorResult('write')
-                    : okResult(vecToCBase32(hash))));
-        }),
-        toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mime_type,type[,url]} where type is "text" or "base64". Pass content:true to also include the inline content string, but content is capped at 128 KiB (131072 bytes) — a larger blob is rejected with an error. To download a blob, prefer the url field returned in the result instead of requesting inline content.', casGetArgs, r => {
-            const key = cBase32ToVec(r.hash);
-            if (key === null) {
-                return pure(errorResult(`invalid cBase32 hash: ${r.hash}`));
-            }
-            const url = c.url(key);
-            return detectStream(c.read(key)).step(([tag, detected]) => {
-                if (tag === 'error') {
-                    return pure(errorResult(`no such hash: ${r.hash}`));
-                }
-                const { length, mime_type, type } = detected;
-                const meta = { length: Number(length), mime_type, type, url };
-                if (r.content !== true) {
-                    // content:true path continues below; this is just the metadata step.
-                    return pure(okResult(toJson(meta)));
-                }
-                // A single `Vec` caps at `maxLength` bits (`maxLengthBytes` bytes), so
-                // a larger blob cannot be buffered for inline transfer. Report the
-                // size and point at the size-independent alternatives instead of
-                // misreporting an existing blob as `no such hash`.
-                if (length > maxLengthBytes) {
-                    return pure(errorResult(`blob too large to fetch inline (${length} bytes, limit ${maxLengthBytes} bytes); use the url field (${url}) or omit content for metadata`));
-                }
-                return collectRead(c.read(key)).step(([collectTag, value]) => {
-                    if (collectTag === 'error') {
-                        return pure(errorResult(`no such hash: ${r.hash}`));
-                    }
-                    if (type === 'text') {
-                        // `type: 'text'` means the detector validated `value` as UTF-8,
-                        // so `fromVec` is non-null here; guard defensively regardless.
-                        const str = fromVec(value);
-                        return pure(str === null
-                            ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                            : okResult(toJson({ ...meta, content: str })));
-                    }
-                    const blob = base64Encode(value);
-                    return pure(blob === null
-                        ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                        : okResult(toJson({ ...meta, content: blob })));
-                });
-            });
-        }),
-        toolEntry('cas_list', 'List all stored content hashes (cBase32), one per line.', casListArgs, () => c.list().step(hashes => pure(okResult(hashes.map(vecToCBase32).join('\n'))))),
-    ];
-};
-// ── Result helpers ──────────────────────────────────────────────────────────────
-/** A successful single-text-block tool result. */
-const okResult = (text) => ({ content: [{ type: 'text', text }] });
-// ── Handlers ────────────────────────────────────────────────────────────────────
-/**
- * MCP handlers for `FileCas`.
- */
-export const casMcpHandlers = (home) => fromRegistry(casToolRegistry(home));
-// ── Session configuration ───────────────────────────────────────────────────────
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export const casConfig = {
-    serverInfo: { name: 'functionalscript-cas', version: '0.30.0' },
-    capabilities: { tools: {} },
-    protocolVersion: '2024-11-05',
-};
-// ── Server ──────────────────────────────────────────────────────────────────────
-/**
- * Runs the file CAS MCP server over stdio: allocates the session-state slot, builds
- * the `mcpStep` for `c`, and drives the read → parse → dispatch → write loop
- * until stdin EOF.
- */
-export const casMcpServer = (home) => create(uninitializedState).step(key => stdioTransport(mcpStep(casConfig)(casMcpHandlers(home))(key)));
-// ── Tests ────────────────────────────────────────────────────────────────────
-export const proof = {
-    // casMcpServer is never called in integration tests because it drives a
-    // real stdio server; call it here to cover its Effect-building body.
-    casMcpServer: () => { casMcpServer('/'); },
-    // The overflow guard in collectRead (lines 125-126) is only reached when
-    // the running total of two stream chunks would exceed maxLength.  Feed a
-    // pure stream whose second chunk pushes it just over the limit so the
-    // error branch executes without any real I/O.
-    collectReadOverflow: () => {
-        const half = maxLength / 2n;
-        const v1 = vec(half)(0n);
-        const v2 = vec(half + 1n)(0n);
-        const stream = nonEmpty(ok(v1), nonEmpty(ok(v2), elEmpty()));
-        const d = decode(collectRead(stream));
-        if (!d.done || d.result[0] !== 'error') {
-            throw 'expected overflow error';
-        }
-    },
-};

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

@@ -1,43 +0,0 @@
-/**
- * Centralized version pins and OS images used by the CI generator: runner
- * images, tool versions (Bun, Deno, Playwright, Rust, Node, Wasmtime, Wasmer,
- * TSGO).
- *
- * @module
- */
-export declare const images: {
-    readonly ubuntu: {
-        readonly intel: "ubuntu-26.04";
-        readonly arm: "ubuntu-26.04-arm";
-    };
-    readonly macos: {
-        readonly intel: "macos-26-intel";
-        readonly arm: "macos-26";
-    };
-    readonly windows: {
-        readonly intel: "windows-2025";
-        readonly arm: "windows-11-arm";
-    };
-};
-export declare const functionalscript: "0.35.2";
-export declare const bun = "1.3.14";
-export declare const deno = "2.9.1";
-export declare const playwright = "1.61.1";
-export declare const node: {
-    readonly default: "26.4.0";
-    readonly node22: "22.23.1";
-    readonly node24: "24.18.0";
-};
-export declare const wasmtime = "46.0.1";
-export declare const wasmer = "7.2.0";
-export declare const tsgo = "7.0.0-dev.20260707.2";
-export declare const actions: {
-    readonly 'actions/checkout': "v7";
-    readonly 'actions/setup-node': "v6.4.0";
-    readonly 'actions/cache': "v6.1.0";
-    readonly 'denoland/setup-deno': "v2.0.5";
-    readonly 'oven-sh/setup-bun': "v2.2.0";
-    readonly 'bytecodealliance/actions/wasmtime/setup': "v1.1.3";
-    readonly 'wasmerio/setup-wasmer': "v3.1";
-    readonly 'dtolnay/rust-toolchain': "1.96.1";
-};

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

@@ -1,16 +0,0 @@
-/**
- * CI step builder for Deno: installs the pinned Deno version and runs the
- * FunctionalScript package smoke test plus Deno coverage in one canonical job.
- *
- * @module
- */
-import { deno } from "../config/module.f.js";
-import { clean, install, test, uses } from "../common/module.f.js";
-const denoTest = 'deno test --allow-read --allow-env --allow-sys';
-export const denoSteps = (version) => clean([
-    install(uses('denoland/setup-deno', { 'deno-version': deno })),
-    install({ run: `deno install -g -A npm:functionalscript@${version}` }),
-    test({ run: `deno run -A npm:functionalscript@${version} t` }),
-    test({ run: 'deno install --frozen' }),
-    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
-]);

package/fs/crypto/pow/proof.f.js

@@ -1,161 +0,0 @@
-import { utf8 } from "../../text/module.f.js";
-import { empty, uint } from "../../types/bit_vec/module.f.js";
-import { computeSync, sha224, sha256 } from "../sha2/module.f.js";
-import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from "./module.f.js";
-const p256 = sha256Pow;
-const p224 = pow(sha224);
-const sample = utf8('functionalscript pow proof');
-const emptyData = empty;
-/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
-const easyNBits = 0x207fffffn;
-/** Compact encoding for target `1` (`0x03000001`). */
-const hardNBits = 0x03000001n;
-/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
-const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
-/** Bitcoin block #0 header hash as big-endian uint256. */
-const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
-const expectNull = (nBits) => {
-    if (targetFromNBits(nBits) !== null) {
-        throw nBits;
-    }
-};
-export const proof = {
-    targetFromNBits: {
-        genesis: () => {
-            if (targetFromNBits(genesisNBits) !== genesisTarget) {
-                throw 'genesis target';
-            }
-        },
-        block0HashWithinGenesisTarget: () => {
-            if (block0Hash > genesisTarget) {
-                throw 'block0 hash exceeds genesis target';
-            }
-        },
-        exponent3: () => {
-            if (targetFromNBits(0x030000ffn) !== 0xffn) {
-                throw 'exponent 3';
-            }
-        },
-        exponent2: () => {
-            if (targetFromNBits(0x02008000n) !== 0x80n) {
-                throw 'exponent 2';
-            }
-        },
-        hardTargetOne: () => {
-            if (targetFromNBits(hardNBits) !== 1n) {
-                throw 'hard target';
-            }
-        },
-        zero: () => {
-            if (targetFromNBits(0n) !== 0n) {
-                throw 'zero nBits';
-            }
-        },
-        negative: () => {
-            expectNull(0x01800001n);
-        },
-        negativeHighMantissa: () => {
-            expectNull(0x22ffffffn);
-        },
-        overflowExponent: () => {
-            expectNull(0x23000001n);
-        },
-        exceeds256: () => {
-            expectNull(0x227fffffn);
-        },
-    },
-    meets: {
-        easy: () => {
-            if (!p256.meets(easyNBits)(sample)) {
-                throw 'easy nBits should pass';
-            }
-        },
-        hard: () => {
-            if (p256.meets(hardNBits)(sample)) {
-                throw 'target 1 should fail';
-            }
-        },
-        genesisFailsSample: () => {
-            if (p256.meets(genesisNBits)(sample)) {
-                throw 'genesis target too hard for sample';
-            }
-        },
-        zeroTargetRejectsSample: () => {
-            if (p256.meets(0n)(sample)) {
-                throw 'non-zero hash vs zero target';
-            }
-        },
-        invalidNBits: () => {
-            if (p256.meets(0x01800001n)(sample)) {
-                throw 'invalid nBits should not pass';
-            }
-        },
-        hashLeqTarget: () => {
-            const h = p256.hashInt(sample);
-            const target = targetFromNBits(easyNBits);
-            if (target === null) {
-                throw 'easy nBits decode';
-            }
-            if (h > target) {
-                throw 'hash above easy target';
-            }
-            if (!(h <= target)) {
-                throw 'hash <= target';
-            }
-        },
-    },
-    hashInt: {
-        sha256Sample: () => {
-            const digest = computeSync(sha256)([sample]);
-            if (p256.hashInt(sample) !== uint(digest)) {
-                throw 'sha256 sample';
-            }
-        },
-        sha256Empty: () => {
-            if (p256.hashInt(emptyData) !== sha256EmptyHash) {
-                throw 'sha256 empty constant';
-            }
-            const digest = computeSync(sha256)([emptyData]);
-            if (p256.hashInt(emptyData) !== uint(digest)) {
-                throw 'sha256 empty';
-            }
-        },
-        sha224: () => {
-            const digest = computeSync(sha224)([sample]);
-            if (p224.hashInt(sample) !== uint(digest)) {
-                throw 'sha224';
-            }
-        },
-        stable: () => {
-            if (p256.hashInt(sample) !== p256.hashInt(sample)) {
-                throw 'stable';
-            }
-        },
-    },
-    pow: {
-        sha256Pow: () => {
-            const built = pow(sha256);
-            if (sha256Pow.hashInt(sample) !== built.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (sha256Pow.meets(easyNBits)(sample) !== built.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-        bitcoinPow: () => {
-            if (bitcoinPow.hashInt(sample) !== sha256Pow.hashInt(sample)) {
-                throw 'bitcoinPow';
-            }
-        },
-        independentInstances: () => {
-            const a = pow(sha256);
-            const b = pow(sha256);
-            if (a.hashInt(sample) !== b.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (a.meets(easyNBits)(sample) !== b.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-    },
-};

package/fs/djs/examples/m.f.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "text";
-export default _default;

package/fs/djs/tokenizer/module.f.d.ts

@@ -1,12 +0,0 @@
-import { type List } from '../../types/list/module.f.ts';
-import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
-export type DjsToken = {
-    readonly kind: 'true' | 'false' | 'null' | 'undefined';
-} | {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
-} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken | jsTokenizer.CommentToken | jsTokenizer.EofToken;
-export type DjsTokenWithMetadata = {
-    readonly token: DjsToken;
-    readonly metadata: jsTokenizer.TokenMetadata;
-};
-export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;