functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/bnf/descent/proof.f.js

@@ -1,9 +1,10 @@
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-import { commaJoin0Plus, option, range, repeat0Plus, set } from "../module.f.js";
-import { deterministic } from "../testlib.f.js";
-import { toData } from "../data/module.f.js";
-import { createEmptyTagMap, descentParser } from "./module.f.js";
+import { stringToCodePointList } from '../../text/utf16/module.f.js';
+import { map, toArray } from '../../types/list/module.f.js';
+import { commaJoin0Plus, option, range, repeat0Plus, set } from '../module.f.js';
+import { deterministic } from '../testlib.f.js';
+import { emptyTagMap, toData } from '../data/module.f.js';
+import { descentParser } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const mapCodePoint = (cp) => [cp, undefined];
 const descentParserCpOnly = (m, name, cp) => {
     const cpm = toArray(map(mapCodePoint)(cp));
@@ -14,34 +15,34 @@ export const proof = {
         () => {
             const stringRule = 'true';
             const data = toData(stringRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"0":false,"1":false,"2":false,"3":false,"":false}') {
+            if (result !== '{}') {
                 throw result;
             }
         },
         () => {
             const terminalRangeRule = range('AF');
             const data = toData(terminalRangeRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"":false}') {
+            if (result !== '{}') {
                 throw result;
             }
         },
         () => {
             const varintRule = { true: 'true', false: 'false' };
             const data = toData(varintRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":false,"6":false,"7":false,"8":false,"9":false,"":false}') {
+            if (result !== '{}') {
                 throw result;
             }
         },
         () => {
             const emptyRule = '';
             const data = toData(emptyRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
             if (result !== '{"":true}') {
                 throw result;
@@ -51,27 +52,27 @@ export const proof = {
             const emptyRule = '';
             const varintRule = { true: 'true', e: emptyRule };
             const data = toData(varintRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"":"e"}') {
+            if (result !== '{"5":true,"":"e"}') {
                 throw result;
             }
         },
         () => {
             const repeatRule = repeat0Plus(option('a'));
             const data = toData(repeatRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"0":"none","1":false,"2":false,"3":true,"r":"none","":true}') {
+            if (result !== '{"0":"none","3":true,"":true,"r":"none"}') {
                 throw result;
             }
         },
         () => {
             const repeatRule = repeat0Plus(set(' \n\r\t'));
             const data = toData(repeatRule);
-            const emptyTags = createEmptyTagMap(data);
+            const emptyTags = emptyTagMap(data[0]);
             const result = JSON.stringify(emptyTags);
-            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"r":"none","":true}') {
+            if (result !== '{"5":true,"r":"none"}') {
                 throw result;
             }
         }
@@ -151,6 +152,15 @@ export const proof = {
                 throw result;
             }
         },
+        () => {
+            const emptyVariantRule = {};
+            const m = descentParser(emptyVariantRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
         () => {
             const stringRule = 'AB';
             const m = descentParser(stringRule);
@@ -214,9 +224,7 @@ export const proof = {
                 const cp = toArray(stringToCodePointList(s));
                 const mr = descentParserCpOnly(m, '', cp);
                 const success = mr[1] && mr[2] === cp.length;
-                if (success !== expected) {
-                    throw mr;
-                }
+                assertEq(success, expected, mr);
             };
             expect('a', true);
             expect('', true);
@@ -236,9 +244,7 @@ export const proof = {
                 const cp = toArray(stringToCodePointList(s));
                 const mr = descentParserCpOnly(m, 'value', cp);
                 const success = mr[1] && mr[2] === cp.length;
-                if (success !== expected) {
-                    throw mr;
-                }
+                assertEq(success, expected, mr);
             };
             expect('', false);
             expect('[]', true);
@@ -252,9 +258,7 @@ export const proof = {
                 const cp = toArray(stringToCodePointList(s));
                 const mr = descentParserCpOnly(m, '', cp);
                 const success = mr[1] && mr[2] === cp.length;
-                if (success !== expected) {
-                    throw mr;
-                }
+                assertEq(success, expected, mr);
             };
             expect('   true   ', true);
             expect('   tr2ue   ', false);
@@ -278,6 +282,33 @@ export const proof = {
             expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
         }
     ],
+    // Regression for the stack-recursive matcher bug: the matcher used to recurse
+    // natively once per grammar step, so match depth grew with input length and these
+    // inputs threw "RangeError: Maximum call stack size exceeded" at a few thousand
+    // code points. The explicit-frame-stack matcher handles them in O(1) JS call stack.
+    longInput: [
+        () => {
+            // long right-recursive repetition: one repeat0Plus chain across the whole input
+            const rule = repeat0Plus(set(' \n\r\t'));
+            const name = toData(rule)[1];
+            const m = descentParser(rule);
+            const cp = toArray(stringToCodePointList(' '.repeat(10000)));
+            const [, ok, idx] = descentParserCpOnly(m, name, cp);
+            assertEq(ok, true);
+            assertEq(idx, 10000);
+        },
+        () => {
+            // deep non-repetition nesting: 5000 bracket levels in the JSON-like test
+            // grammar — a shape that repetition-specific fixes (a `repeat` primitive)
+            // would not cover
+            const m = descentParser(deterministic());
+            const n = 5000;
+            const cp = toArray(stringToCodePointList('['.repeat(n) + ']'.repeat(n)));
+            const [, ok, idx] = descentParserCpOnly(m, '', cp);
+            assertEq(ok, true);
+            assertEq(idx, n * 2);
+        },
+    ],
     descentParserWithMeta: [
         () => {
             const emptyRule = '';

package/{fs → fjs}/bnf/ll1/module.f.d.ts

@@ -1,20 +1,20 @@
 /**
  * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
  *
- * Built from the serializable IR in `fs/bnf/data`, this is one member of the
+ * Built from the serializable IR in `fjs/bnf/data`, this is one member of the
  * family of automaton builders that consume a {@link RuleSet}: it compiles the
  * grammar into a predictive {@link dispatchMap} and matches input into an AST
  * ({@link MatchResult}). It throws at build time (`can not merge …`) when the
- * grammar is not LL(1) — a first/first conflict.
+ * grammar is not LL(1) — a first/first conflict. Nullability is looked up from
+ * {@link emptyTagMap} in `fjs/bnf/data` rather than re-derived here.
  *
  * @module
  */
 import { type CodePoint } from '../../text/utf16/module.f.ts';
 import { type RangeMapArray } from '../../types/range_map/module.f.ts';
 import { type StringMap } from '../../types/object/module.f.ts';
-import { type RuleSet } from '../data/module.f.ts';
+import { type EmptyTag, type RuleSet } from '../data/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
-type EmptyTag = string | true | undefined;
 type DispatchRule = {
     readonly emptyTag: EmptyTag;
     readonly rangeMap: Dispatch;

package/{fs → fjs}/bnf/ll1/module.f.js

@@ -1,23 +1,24 @@
 /**
  * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
  *
- * Built from the serializable IR in `fs/bnf/data`, this is one member of the
+ * Built from the serializable IR in `fjs/bnf/data`, this is one member of the
  * family of automaton builders that consume a {@link RuleSet}: it compiles the
  * grammar into a predictive {@link dispatchMap} and matches input into an AST
  * ({@link MatchResult}). It throws at build time (`can not merge …`) when the
- * grammar is not LL(1) — a first/first conflict.
+ * grammar is not LL(1) — a first/first conflict. Nullability is looked up from
+ * {@link emptyTagMap} in `fjs/bnf/data` rather than re-derived here.
  *
  * @module
  */
-import {} from "../../text/utf16/module.f.js";
-import { strictEqual } from "../../types/function/operator/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { rangeMap } from "../../types/range_map/module.f.js";
-import { contains, set } from "../../types/string_set/module.f.js";
-import { rangeDecode } from "../module.f.js";
-import { definedEntries } from "../../types/object/module.f.js";
-import { toData } from "../data/module.f.js";
-import {} from "../module.f.js";
+import {} from '../../text/utf16/module.f.js';
+import { strictEqual } from '../../types/function/operator/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
+import { rangeMap } from '../../types/range_map/module.f.js';
+import { contains, set } from '../../types/string_set/module.f.js';
+import { rangeDecode } from '../module.f.js';
+import { definedEntries } from '../../types/object/module.f.js';
+import { emptyTagMap, toData } from '../data/module.f.js';
+import {} from '../module.f.js';
 const dispatchOp = rangeMap({
     union: a => b => {
         if (a === null) {
@@ -35,6 +36,7 @@ const dispatchOp = rangeMap({
  * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
  */
 export const dispatchMap = (ruleSet) => {
+    const nullMap = emptyTagMap(ruleSet);
     const addRuleToDispatch = (dr, name) => {
         if (dr === null)
             return null;
@@ -70,7 +72,7 @@ export const dispatchMap = (ruleSet) => {
                     if (emptyTag === true) {
                         result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
                         result = toArray(dispatchOp.merge(result)(dr.rangeMap));
-                        emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                        emptyTag = nullMap[item] !== undefined ? true : undefined;
                     }
                     else {
                         result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
@@ -87,7 +89,7 @@ export const dispatchMap = (ruleSet) => {
             for (const [tag, item] of entries) {
                 dm = dispatchRule(dm, item, newCurrent);
                 const dr = dm[item];
-                if (dr.emptyTag !== undefined) {
+                if (nullMap[item] !== undefined) {
                     emptyTag = tag;
                 }
                 else {

package/{fs → fjs}/bnf/ll1/proof.f.d.ts

@@ -6,4 +6,5 @@ export declare const proof: {
     throw: {
         ambiguousVariantDispatch: () => void;
     };
+    cyclicNullability: () => void;
 };

package/{fs → fjs}/bnf/ll1/proof.f.js

@@ -1,9 +1,10 @@
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { commaJoin0Plus, option, range, repeat0Plus, set } from "../module.f.js";
-import { deterministic } from "../testlib.f.js";
-import { toData } from "../data/module.f.js";
-import { dispatchMap, parser, parserRuleSet } from "./module.f.js";
+import { stringToCodePointList } from '../../text/utf16/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
+import { commaJoin0Plus, option, range, repeat0Plus, set } from '../module.f.js';
+import { deterministic } from '../testlib.f.js';
+import { toData } from '../data/module.f.js';
+import { dispatchMap, parser, parserRuleSet } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     dispatch: [
         () => {
@@ -238,9 +239,7 @@ export const proof = {
             const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
             const expect = (s, success) => {
                 const mr = m('', toArray(stringToCodePointList(s)));
-                if (isSuccess(mr) !== success) {
-                    throw mr;
-                }
+                assertEq(isSuccess(mr), success, mr);
             };
             expect('a', true);
             expect('', true);
@@ -259,9 +258,7 @@ export const proof = {
             const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
             const expect = (s, success) => {
                 const mr = m('value', toArray(stringToCodePointList(s)));
-                if (isSuccess(mr) !== success) {
-                    throw mr;
-                }
+                assertEq(isSuccess(mr), success, mr);
             };
             expect('', false);
             expect('[]', true);
@@ -274,9 +271,7 @@ export const proof = {
             const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
             const expect = (s, success) => {
                 const mr = m('', toArray(stringToCodePointList(s)));
-                if (isSuccess(mr) !== success) {
-                    throw mr;
-                }
+                assertEq(isSuccess(mr), success, mr);
             };
             expect('   true   ', true);
             expect('   tr2ue   ', false);
@@ -354,5 +349,27 @@ export const proof = {
             const conflictRule = { 'a': range('AA'), 'b': range('AA') };
             dispatchMap(toData(conflictRule)[0]);
         }
-    }
+    },
+    // Regression: `emptyTagMap` must stay correct for cyclic rule references.
+    // A naive single-pass, memoized derivation that marks a rule nullable as
+    // a placeholder *before* recursing into its own children (to break the
+    // cycle) over-approximates nullability here, and made `dispatchMap`
+    // falsely report a first/first conflict for this grammar even though it
+    // has none — `value` only ever nests inside brackets or is the literal
+    // `a`, and `ws` is genuinely optional on both sides of it.
+    cyclicNullability: () => {
+        const ws = option(' ');
+        const value = () => ({ array: ['[', value, ']'], leaf: 'a' });
+        const m = parser([ws, value, ws]); // must not throw 'can not merge'
+        const expect = (s, success) => {
+            const mr = m('', toArray(stringToCodePointList(s)));
+            assertEq(mr[1] && mr[2]?.length === 0, success, mr);
+        };
+        expect('a', true);
+        expect(' a ', true);
+        expect('[a]', true);
+        expect('[[a]]', true);
+        expect(' [[a]] ', true);
+        expect('b', false);
+    },
 };

package/{fs → fjs}/bnf/module.f.d.ts

@@ -6,6 +6,21 @@ import { type Array2 } from '../types/array/module.f.ts';
  * For example: 0xBBBBBB_EEEEEE
  * - 0xBBBBBB is the first symbol (24 bits)
  * - 0xEEEEEE is the last symbol (24 bits)
+ *
+ * 24 bits per half, not 26 (the most `float64`'s 52-bit safe-integer mantissa
+ * could fit two of): 24 is divisible by 4, so each half is exactly 6 hex
+ * digits, and the packed pair reads as a plain `0xYYYYYY_ZZZZZZ` literal with
+ * no partial hex digit at either boundary. 26 bits would still be safe to
+ * store but wouldn't align to hex nibbles, making the packed literal harder
+ * to read and split by eye.
+ *
+ * Not 16 bits (32 bits total) either, even though a 32-bit pair would fit in
+ * a JS bitwise operator's native 32-bit range (JS `|`/`&`/`<<`/etc. operate on
+ * 32-bit ints, whereas the 48-bit pair used here, and even a 52-bit one,
+ * would need converting to `BigInt` for bitwise operations). 16 bits per
+ * symbol can't hold a full Unicode code point: the max scalar value `0x10FFFF`
+ * needs 21 bits, well past `0xFFFF`. So the bitwise-op convenience of 16 loses
+ * to the requirement of representing every Unicode code point in one half.
  */
 export type TerminalRange = number;
 /**
@@ -16,10 +31,6 @@ export declare const fullRange: TerminalRange;
  * Unicode scalar value range packed into a single {@link TerminalRange}.
  */
 export declare const unicodeRange: TerminalRange;
-/**
- * Maximal non-Unicode symbol encoded as a string value.
- */
-export declare const max: string;
 /**
  * Maximal Unicode code point encoded as a string value.
  */
@@ -48,7 +59,10 @@ export declare const rangeEncode: (a: number, b: number) => TerminalRange;
  */
 export declare const oneEncode: (a: number) => TerminalRange;
 /**
- * End-of-file marker represented as one code point beyond Unicode range.
+ * End-of-file marker: `mask`, the single largest value the 24-bit symbol
+ * space can hold (the top of `fullRange`). Deliberately outside Unicode
+ * (`unicodeRange` tops out at `0x10FFFF`) so it can never collide with a
+ * real code point.
  */
 export declare const eof: TerminalRange;
 /**

package/{fs → fjs}/bnf/module.f.js

@@ -6,10 +6,12 @@
  *
  * @module
  */
-import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
-import { definedValues } from "../types/object/module.f.js";
-import { isArray2 } from "../types/array/module.f.js";
-import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
+import { codePointListToString, stringToCodePointList } from '../text/utf16/module.f.js';
+import { definedValues } from '../types/object/module.f.js';
+import { isArray2 } from '../types/array/module.f.js';
+import { map, toArray, repeat as listRepeat } from '../types/list/module.f.js';
+import { contains } from '../types/range/module.f.js';
+import { assert } from '../asserts/module.f.js';
 /**
  * Full 24-bit symbol range packed into a single {@link TerminalRange}.
  */
@@ -18,10 +20,6 @@ export const fullRange = 0x000000_FFFFFF;
  * Unicode scalar value range packed into a single {@link TerminalRange}.
  */
 export const unicodeRange = 0x000000_10FFFF;
-/**
- * Maximal non-Unicode symbol encoded as a string value.
- */
-export const max = codePointListToString([0xFFFFFF]);
 /**
  * Maximal Unicode code point encoded as a string value.
  */
@@ -34,11 +32,9 @@ const { fromCodePoint } = String;
  */
 const offset = 24;
 const mask = (1 << offset) - 1;
-const isValid = (r) => r >= 0 && r <= mask;
+const isValid = contains(0, mask);
 export const rangeEncode = (a, b) => {
-    if (!isValid(a) || !isValid(b) || a > b) {
-        throw `Invalid range ${a} ${b}.`;
-    }
+    assert(isValid(a) && isValid(b) && a <= b);
     return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
 };
 /**
@@ -46,13 +42,16 @@ export const rangeEncode = (a, b) => {
  */
 export const oneEncode = (a) => rangeEncode(a, a);
 /**
- * End-of-file marker represented as one code point beyond Unicode range.
+ * End-of-file marker: `mask`, the single largest value the 24-bit symbol
+ * space can hold (the top of `fullRange`). Deliberately outside Unicode
+ * (`unicodeRange` tops out at `0x10FFFF`) so it can never collide with a
+ * real code point.
  */
-export const eof = oneEncode(0x110000);
+export const eof = oneEncode(mask);
 /**
  * Decodes a packed range into `[start, end]` symbols.
  */
-export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), Number(BigInt(r) & BigInt(mask))];
+export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), r & mask];
 const mapOneEncode = map(oneEncode);
 export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
 /**

package/fjs/bnf/proof.f.js

@@ -0,0 +1,69 @@
+import { assert, assertEq } from '../asserts/module.f.js';
+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');
+            assertEq(typeof result, 'number', result);
+            assertEq(result, oneEncode(0x61));
+        },
+        () => {
+            const result = str('ab');
+            assert(Array.isArray(result), result);
+            assertEq(result.length, 2, result);
+        },
+    ],
+    set: () => {
+        const result = set('abc');
+        assert(!(typeof result !== 'object' || result === null), result);
+        assert('a' in result, result);
+        assert('b' in result, result);
+        assert('c' in result, result);
+    },
+    commaJoin0Plus: () => {
+        const ws = '';
+        const item = 'x';
+        const result = commaJoin0Plus(ws)('[]', item);
+        assert(Array.isArray(result), result);
+        assert(result[0] === '[', result);
+    },
+    isEmpty: [
+        () => { assert(isEmpty(''), 'empty string should be empty'); },
+        () => { assert(isEmpty([]), 'empty array should be empty'); },
+        () => { assert(!(isEmpty('a')), 'non-empty string should not be empty'); },
+        () => {
+            const f = () => '';
+            assert(isEmpty(f), 'function returning empty string should be empty');
+        },
+    ],
+    repeat1Plus: [
+        () => {
+            const result = repeat1Plus('x');
+            assert(result[0] === 'x');
+            assertEq(typeof result[1], 'function', 'expected repeat0Plus function');
+        },
+        () => {
+            const rule = 'ab';
+            const result = repeat1Plus(rule);
+            assertEq(result[0], rule);
+            const inner = result[1]();
+            assert(!(!('some' in inner) || !('none' in inner)), 'expected Option shape');
+        },
+    ],
+};

package/{fs → fjs}/bnf/testlib.f.js

@@ -1,4 +1,4 @@
-import { commaJoin0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
+import { commaJoin0Plus, none, option, range, remove, repeat, repeat0Plus, set, unicodeMax } from './module.f.js';
 export const classic = () => {
     // https://www.json.org/json-en.html
     const json = () => [element];
@@ -93,7 +93,7 @@ export const deterministic = () => {
     const string = [
         '"',
         repeat0Plus({
-            ...remove(range(` ${max}`), set('"\\')),
+            ...remove(range(` ${unicodeMax}`), set('"\\')),
             escape: [
                 '\\',
                 {

package/{fs → fjs}/cas/cli/module.f.js

@@ -3,13 +3,13 @@
  *
  * @module
  */
-import { sha256 } from "../../crypto/sha2/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../../cbase32/module.f.js";
-import { forEachStep, pure } from "../../effects/module.f.js";
-import { errorExit, log, writeFromStream } from "../../effects/node/module.f.js";
-import { dispatch } from "../../cli/module.f.js";
-import {} from "../../effects/memory/module.f.js";
-import { casAddFile, fileCas } from "../module.f.js";
+import { sha256 } from '../../crypto/sha2/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
+import { forEachStep, pure } from '../../effects/module.f.js';
+import { errorExit, log, writeFromStream } from '../../effects/node/module.f.js';
+import { dispatch } from '../../cli/module.f.js';
+import {} from '../../effects/memory/module.f.js';
+import { casAddFile, fileCas } from '../module.f.js';
 export const commands = [
     {
         names: ['add'],

package/{fs → fjs}/cas/cli/proof.f.d.ts

@@ -2,13 +2,16 @@ export declare const proof: {
     mainAdd: () => void;
     mainAddGetBig: () => void;
     mainAddWrongArgs: () => void;
+    mainAddMissingFile: () => void;
     mainGetFound: () => void;
     mainGetNotFound: () => void;
     mainGetWrongArgs: () => void;
     mainGetInvalidHash: () => void;
     mainList: () => void;
     mainListEmptyStore: () => void;
-    mainListCorruptStore: () => void;
     mainNoCmd: () => void;
     mainUnknownCmd: () => void;
+    throw: {
+        mainListCorruptStore: () => readonly [import("../../effects/node/virtual/module.f.ts").State, number];
+    };
 };