functionalscript 0.18.0 → 0.20.0

package/fs/djs/serializer/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     stringify: ({
         testPrimitives: () => void;
         testArray: () => void;
@@ -22,4 +22,3 @@ declare const _default: {
         stringify: () => void;
     })[];
 };
-export default _default;

package/fs/djs/serializer/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { setProperty } from "../../json/module.f.js";
-export default {
+export const proof = {
     stringify: [
         {
             testPrimitives: () => {
@@ -12,15 +12,15 @@ export default {
                     throw refs.size;
                 }
                 const refsBigInt = stringifyAsTree(sort)(refs.get(3n));
-                if (refsBigInt !== '[0,1,false]') {
+                if (refsBigInt !== '[0,1]') {
                     throw refsBigInt;
                 }
                 const refsString = stringifyAsTree(sort)(refs.get("str"));
-                if (refsString !== '[1,1,false]') {
+                if (refsString !== '[1,1]') {
                     throw refsString;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[2,1,false]') {
+                if (refsRoot !== '[2,1]') {
                     throw refsRoot;
                 }
                 if (refs.get(null) !== undefined) {
@@ -35,11 +35,11 @@ export default {
                     throw refs.size;
                 }
                 const refsArray = stringifyAsTree(sort)(refs.get(array));
-                if (refsArray !== '[0,3,false]') {
+                if (refsArray !== '[0,3]') {
                     throw refsArray;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1,false]') {
+                if (refsRoot !== '[1,1]') {
                     throw refsRoot;
                 }
             },
@@ -51,11 +51,11 @@ export default {
                     throw refs.size;
                 }
                 const refsObj = stringifyAsTree(sort)(refs.get(obj));
-                if (refsObj !== '[0,2,false]') {
+                if (refsObj !== '[0,2]') {
                     throw refsObj;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1,false]') {
+                if (refsRoot !== '[1,1]') {
                     throw refsRoot;
                 }
             },

package/fs/djs/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     djs: (() => void)[];
     id: (() => void)[];
     keywords: (() => void)[];
     comments: (() => void)[];
     metadata: (() => void)[];
 };
-export default _default;

package/fs/djs/tokenizer/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => { return tokenWithMetada.token; };
-export default {
+export const proof = {
     djs: [
         () => {
             const result = stringify(tokenizeString(''));

package/fs/djs/tokenizer-new/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     isValid: (() => void)[];
     tokenizer: (() => void)[];
     djs: (() => void)[];
 };
-export default _default;

package/fs/djs/tokenizer-new/{test.f.js → proof.f.js}

@@ -108,7 +108,7 @@ const getTokensFromAstRule = ast => {
         return [token];
     return { first: token, tail: getTokensFromAstSequence(ast.sequence) };
 };
-export default {
+export const proof = {
     isValid: [() => {
             const m = descentParser(jsGrammar());
             const expect = (s, expected) => {

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

@@ -10,12 +10,27 @@ import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import { type ParseError } from '../parser/module.f.ts';
 import { type Effect } from '../../types/effects/module.f.ts';
 import { type ReadFile } from '../../types/effects/node/module.f.ts';
+/**
+ * State threaded through the recursive transpilation of a DJS module graph.
+ *
+ * - `complete`: modules that have been fully parsed and evaluated, keyed by path.
+ * - `stack`: import chain currently being resolved (used to detect circular dependencies).
+ * - `error`: the first parse error encountered, or `null` while everything is clean.
+ */
 export type ParseContext = {
     readonly complete: OrderedMap<djsResult>;
     readonly stack: List<string>;
     readonly error: ParseError | null;
 };
+/** The evaluated DJS value produced for one successfully transpiled module. */
 export type djsResult = {
     djs: Unknown;
 };
+/**
+ * Transpiles a DJS module graph rooted at `path` into a single `Unknown` value.
+ *
+ * Reads each file via the `ReadFile` effect, resolves imports recursively, and
+ * evaluates the AST. Returns `['ok', value]` on success, or `['error', ParseError]`
+ * on a parse failure or circular dependency.
+ */
 export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;

package/fs/djs/transpiler/module.f.js

@@ -12,7 +12,7 @@ import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
-import { pure } from "../../types/effects/module.f.js";
+import { foldStep, pure } from "../../types/effects/module.f.js";
 import { readFile } from "../../types/effects/node/module.f.js";
 import { utf8ToString } from "../../text/module.f.js";
 const mapDjs = context => path => {
@@ -35,7 +35,8 @@ const transpileWithImports = path => parseModuleResult => context => {
         const pathsCombine = listMap(pathConcat(dir))(parseModuleResult[1][0]);
         const pathsArray = toArray(pathsCombine);
         const contextWithStack = { ...context, stack: { first: path, tail: context.stack } };
-        return pathsArray.reduce((acc, p) => acc.step(ctx => foldNextModuleOp(p)(ctx)), pure(contextWithStack)).step(contextWithImports => {
+        return foldStep(foldNextModuleOp)(contextWithStack)(pathsArray)
+            .step(contextWithImports => {
             if (contextWithImports.error !== null) {
                 return pure(contextWithImports);
             }
@@ -62,6 +63,13 @@ const foldNextModuleOp = path => context => {
     }
     return parseModule(path).step(parseModuleResult => transpileWithImports(path)(parseModuleResult)(context));
 };
+/**
+ * Transpiles a DJS module graph rooted at `path` into a single `Unknown` value.
+ *
+ * Reads each file via the `ReadFile` effect, resolves imports recursively, and
+ * evaluates the AST. Returns `['ok', value]` on success, or `['error', ParseError]`
+ * on a parse failure or circular dependency.
+ */
 export const transpile = path => foldNextModuleOp(path)({ stack: null, complete: null, error: null }).step((context) => {
     if (context.error !== null) {
         return pure(error(context.error));

package/fs/djs/transpiler/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     parse: () => void;
     parseWithSubModule: () => void;
     parseWithSubModules: () => void;
     parseWithFileNotFoundError: () => void;
     parseWithCycleError: () => void;
 };
-export default _default;

package/fs/djs/transpiler/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));
     return result;
 };
-export default {
+export const proof = {
     parse: () => {
         const result = run({ a: utf8('export default 1') })('a');
         if (result[0] === 'error') {

package/fs/fsc/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     a: () => void;
     fn: () => void;
     f1: () => void;
@@ -6,4 +6,3 @@ declare const _default: {
     f3: () => void;
     f4: () => void;
 };
-export default _default;

package/fs/fsc/{test.f.js → proof.f.js}

@@ -11,7 +11,7 @@ const fn = (f, name) => ({ [name]: f }[name]);
 const withName = (name) => 
 // translated into one command: define a `function [name]() { return undefined }`
 Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
-export default {
+export const proof = {
     a: () => {
         const x = f('1');
         if (x !== '["1"]') {

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

@@ -0,0 +1,4 @@
+export declare const proof: {
+    dfa: () => void;
+    run: (() => void)[];
+};

package/fs/fsm/{test.f.js → proof.f.js}

@@ -28,7 +28,7 @@ const buildDfa = () => {
     ];
     return dfa(grammar);
 };
-export default {
+export const proof = {
     dfa: () => {
         const dfa = buildDfa();
         const entries = Object.entries(dfa);

package/fs/html/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     empty: () => void;
     empty2: () => void;
     void: () => void;
@@ -13,4 +13,3 @@ declare const _default: {
         noRaw: () => void;
     };
 };
-export default _default;

package/fs/html/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { htmlToString } from "./module.f.js";
-export default {
+export const proof = {
     empty: () => {
         const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {

package/fs/io/module.d.ts

@@ -4,6 +4,6 @@ import { type Result } from '../types/result/module.f.ts';
 export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
 export declare const io: Io;
-export type NodeRun = (p: NodeProgram) => Promise<number>;
+export type NodeRun = (p: NodeProgram) => Promise<never>;
 declare const effectRun: NodeRun;
 export default effectRun;

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

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, Module, NodeOp, Env, SandboxResult, NodeProgram, WriteConsoles } from '../types/effects/node/module.f.ts';
+import { type Headers, type Module, type NodeOp, type Env, type SandboxResult, type NodeProgram, type WriteConsoles, type TestContext, type Engine } from '../types/effects/node/module.f.ts';
 import type { Vec } from '../types/bit_vec/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
@@ -74,7 +74,7 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
-export type Sandbox = <T>(f: () => T) => SandboxResult<T>;
+export type Sandbox = <T>(f: () => T) => Promise<SandboxResult<T>>;
 export type Server = {
     readonly listen: (port: number) => void;
 };
@@ -116,6 +116,11 @@ export type Io = {
     readonly now: () => number;
     readonly sandbox: Sandbox;
     readonly write: (stream: WriteConsoles, data: Vec) => Promise<void>;
+    readonly testContext: TestContext;
+    readonly bunTestContext: TestContext;
+    readonly playwrightTestContext: TestContext;
+    readonly engine: Engine;
+    readonly await: (p: unknown) => Promise<readonly [unknown]>;
 };
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
@@ -125,5 +130,5 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }: Io) => EffectToPromise;
+export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }: Io) => EffectToPromise;
 export declare const runProgram: (io: Io) => (args: readonly string[]) => (program: NodeProgram) => Promise<number>;

package/fs/io/module.f.js

@@ -10,6 +10,7 @@
 import { normalize } from "../path/module.f.js";
 import {} from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
+import {} from "../types/effects/node/module.f.js";
 import { asBase, asNominal } from "../types/nominal/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, listToVec, toVec } from "../types/uint8array/module.f.js";
@@ -44,7 +45,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }) => {
+export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
     const result = asyncRun({
         all: async (...effects) => await Promise.all(effects.map(result)),
         fetch: async (url) => tc(async () => {
@@ -94,20 +95,19 @@ export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile,
         },
         forever: () => new Promise(() => { }),
         now: async () => ioNow(),
-        sandbox: async (f) => ioSandbox(f),
-        write: ioWrite,
+        sandbox,
+        await: awaitPromise,
+        write,
+        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
     });
     return result;
 };
 export const runProgram = (io) => {
-    const { process: { env, stdout, stderr } } = io;
+    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
+    const std = { stdout, stderr };
     const f = fromIo(io);
-    return (args) => (program) => f(program({
-        args,
-        env,
-        std: {
-            stdout: { isTTY: stdout.isTTY },
-            stderr: { isTTY: stderr.isTTY },
-        },
-    }));
+    return args => {
+        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
+        return program => f(program(options));
+    };
 };

package/fs/io/module.js

@@ -12,9 +12,34 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { concat } from "../path/module.f.js";
 import { once } from 'node:events';
-import { fromIo, runProgram } from "./module.f.js";
+import { runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec } from "../types/uint8array/module.f.js";
+import * as testContext from 'node:test';
+const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
+const pwTest = isPlaywright
+    ? (await import('@playwright/test')).test
+    : undefined;
+const inlineTest = async (name, { expectFailure }, fn) => {
+    if (expectFailure) {
+        try {
+            await fn(inlineContext);
+        }
+        catch {
+            return;
+        }
+        throw new Error(`expected to throw: ${name}`);
+    }
+    else {
+        await fn(inlineContext);
+    }
+};
+const inlineContext = { test: inlineTest };
+const wrapInlineTest = (register) => ({
+    test: (name, opts, fn) => register(name, () => inlineTest(name, opts, fn))
+});
+const bunTestContext = wrapInlineTest(testContext.test);
+const playwrightTestContext = wrapInlineTest(pwTest);
 const prefix = 'file:///';
 const { now } = Date;
 /** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
@@ -50,6 +75,7 @@ export const tryCatch = f => {
         return error(e);
     }
 };
+const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
 export const io = {
     console,
     fs,
@@ -73,14 +99,18 @@ export const io = {
     http,
     childProcess,
     now,
-    sandbox: (f) => {
+    sandbox: async (f) => {
         let result;
         let after;
         const before = performance.now();
         try {
-            const value = f();
+            let p = f();
             after = performance.now();
-            result = ok(value);
+            if (p instanceof Promise) {
+                p = await p;
+                after = performance.now();
+            }
+            result = ok(p);
         }
         catch (e) {
             after = performance.now();
@@ -89,6 +119,14 @@ export const io = {
         return { result, duration: after - before };
     },
     write: (stream, data) => writeAll(streams[stream], fromVec(data)),
+    await: awaitPromise,
+    testContext,
+    bunTestContext,
+    playwrightTestContext,
+    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
+};
+const effectRun = async (p) => {
+    const code = await runProgram(io)(io.process.argv.slice(2))(p);
+    return process.exit(code);
 };
-const effectRun = runProgram(io)(io.process.argv.slice(2));
 export default effectRun;

package/fs/js/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     djs: (() => void)[];
     operators: (() => void)[];
     ws: (() => void)[];
@@ -7,4 +7,3 @@ declare const _default: {
     comments: (() => void)[];
     metadata: (() => void)[];
 };
-export default _default;

package/fs/js/tokenizer/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => tokenWithMetada.token;
-export default {
+export const proof = {
     djs: [
         () => {
             const result = stringify(tokenizeString(''));

package/fs/json/parser/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,4 @@
-declare const _default: {
+export declare const proof: {
     valid: (() => void)[];
     invalid: (() => void)[];
 };
-export default _default;

package/fs/json/parser/{test.f.js → proof.f.js}

@@ -6,7 +6,7 @@ import { sort } from "../../types/object/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s)));
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     valid: [
         () => {
             const tokenList = tokenizeString('null');

package/fs/json/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     setProperty: () => void;
     stringify: {
         sort: () => void;
         identity: () => void;
     }[];
 };
-export default _default;

package/fs/json/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { setProperty, stringify } from "./module.f.js";
 import { sort } from "../types/object/module.f.js";
 import { identity } from "../types/function/module.f.js";
-export default {
+export const proof = {
     setProperty: () => {
         if (setProperty("Hello")([])({}) !== "Hello") {
             throw 'error';

package/fs/json/serializer/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     arrayWrap: (() => void)[];
     objectWrap: (() => void)[];
     stringSerialize: (() => void)[];
     numberSerialize: (() => void)[];
     boolSerialize: (() => void)[];
 };
-export default _default;

package/fs/json/serializer/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
-export default {
+export const proof = {
     arrayWrap: [
         () => {
             const result = JSON.stringify(toArray(arrayWrap(null)));

package/fs/json/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     json: (() => void)[];
     id: (() => void)[];
     keywords: (() => void)[];
 };
-export default _default;

package/fs/json/tokenizer/{test.f.js → proof.f.js}

@@ -5,7 +5,7 @@ import { sort } from "../../types/object/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s)));
 const stringify = stringifyAsTree(sort);
-export default {
+export const proof = {
     json: [
         () => {
             const result = stringify(tokenizeString(''));

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

@@ -0,0 +1,5 @@
+export declare const proof: {
+    normalizeTest: (() => void)[];
+    concatTest: (() => void)[];
+    relativizeTest: (() => void)[];
+};

package/fs/path/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { concat, normalize, relativize } from "./module.f.js";
-export const normalizeTest = [
+const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
         if (norm !== "dir/file.json") {
@@ -25,7 +25,7 @@ export const normalizeTest = [
         }
     },
 ];
-export const concatTest = [
+const concatTest = [
     () => {
         const c = concat("a")("b");
         if (c !== "a/b") {
@@ -45,7 +45,7 @@ export const concatTest = [
         }
     },
 ];
-export const relativizeTest = [
+const relativizeTest = [
     () => {
         const r = relativize('/repo', '/repo/fs/a.ts');
         if (r !== './fs/a.ts') {
@@ -65,3 +65,4 @@ export const relativizeTest = [
         }
     },
 ];
+export const proof = { normalizeTest, concatTest, relativizeTest };

package/fs/sul/id/module.f.js

@@ -6,7 +6,7 @@
  * @module
  */
 import { toArray } from "../../types/list/module.f.js";
-import { length, listToVec, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
+import { length, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
 import { assertEq } from "../../dev/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 import { secp256r1 } from "../../crypto/secp/module.f.js";
@@ -77,9 +77,8 @@ export const isHash = (v) => asBase(v) >> hashPrefixOffset === 1n;
 export const hashId = (hash) => asNominal(hashPrefix | hash);
 const hash2 = base32.compress(iv);
 const vecX20 = vec(0x20n);
-const ltv = listToVec(msb);
-const hashMerge = (a, b) => hashId(uint(ltv(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
-const { concat } = msb;
+const { concat, listToVec } = msb;
+const hashMerge = (a, b) => hashId(uint(listToVec(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
 export const compress = (a, b) => {
     if (isHash(a) || isHash(b)) {
         return hashMerge(a, b);

package/fs/sul/id/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     inline_00_00: () => void;
     inline_00_01: () => void;
     inline_01_00: () => void;
@@ -18,4 +18,3 @@ declare const _default: {
     hash_merge_b_sensitivity: () => void;
     hash_merge_shift: () => void;
 };
-export default _default;

package/fs/sul/id/{test.f.js → proof.f.js}

@@ -15,7 +15,7 @@ const hFE = hashId(mask(0xffn) - 1n);
 assertEq(asBase(level3Id(0n)), 0n);
 assertEq(asBase(hashId(0n)), 1n << 0xffn);
 assertEq(asBase(hFF), mask(0x100n));
-export default {
+export const proof = {
     // Two level-3 literals whose combined bit vectors fit inline (≤ 253 bits)
     inline_00_00: () => assertEq(compress(level3Id(0x00n), level3Id(0x00n)), rawId(vec(16n)(0x0000n))),
     inline_00_01: () => assertEq(compress(level3Id(0x00n), level3Id(0x01n)), rawId(vec(16n)(0x0001n))),

package/fs/sul/level/hash/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     min_equal: () => void;
     min_greater: () => void;
     intermediate_undefined: () => void;
@@ -11,4 +11,3 @@ declare const _default: {
     isSymbol_terminal_only: () => void;
     isSymbol_min_word: () => void;
 };
-export default _default;

package/fs/sul/level/hash/{test.f.js → proof.f.js}

@@ -24,7 +24,7 @@ const verifyStorage = (storage) => {
 };
 const s0 = level3Id(0n);
 const s1 = level3Id(1n);
-export default {
+export const proof = {
     // Minimum word [s0, t] with t == s0
     min_equal: () => {
         const [out, storage] = runWord([s0, s0]);