functionalscript 0.19.0 → 0.21.0

package/fs/dev/module.f.js

@@ -1,5 +1,6 @@
 import { updateVersion } from "./version/module.f.js";
 import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { cmp as strCmp } from "../types/string/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 import { begin, pure } from "../types/effects/module.f.js";
@@ -7,20 +8,28 @@ import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
 import { relativize } from "../path/module.f.js";
-export const todo = () => { throw 'not implemented'; };
-export const assert = (v, msg = 'assertion failed') => {
-    if (!v)
-        throw msg;
-};
-export const assertEq = (a, b) => assert(a === b, [a, b]);
-const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
     const r = Object.getOwnPropertyDescriptor(env, a);
     return r === undefined ? undefined :
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles = (s) => {
+/**
+ * Returns `true` if the file should be loaded for proof discovery.
+ *
+ * All FunctionalScript modules (`.f.ts` / `.f.js`) are safe to bulk-load by
+ * construction — they have no import side effects. For vanilla TS/JS the
+ * load gate stays opt-in by filename: any file ending in `proof.ts`,
+ * `proof.js`, `proof.mts`, or `proof.mjs` is included.
+ *
+ * Whether a loaded module actually _contains_ a proof is determined at
+ * runtime by checking for an exported `proof` property.
+ */
+export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
+    s.endsWith('proof.ts') || s.endsWith('proof.js') ||
+    s.endsWith('proof.mts') || s.endsWith('proof.mjs');
+const isSourceFile = (path) => path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs');
+const allFiles = (s, predicate) => {
     const load = (p) => begin
         .step(() => readdir(p, {}))
         .step(d => {
@@ -38,7 +47,7 @@ export const allFiles = (s) => {
                 result = [...result, load(file)];
                 continue;
             }
-            if (name.endsWith('.js') || name.endsWith('.ts')) {
+            if (predicate(file)) {
                 result = [...result, pure([file])];
             }
         }
@@ -47,18 +56,22 @@ export const allFiles = (s) => {
         .step(v => pure(v.flat()));
     return load(s);
 };
-const loadFile = (f) => {
-    const doImport = import_(f).step(r => pure([[f, unwrap(r)]]));
-    if (f.endsWith('.f.js')) {
-        return doImport;
-    }
-    if (f.endsWith('.f.ts')) {
-        return access(f.substring(0, f.length - 3) + '.js')
-            .step(r => r[0] === 'ok' ? pure([]) : doImport);
-    }
-    return pure([]);
-};
+const loadFile = (f) => import_(f).step(r => pure([[f, unwrap(r)]]));
 const { fromEntries } = Object;
+/**
+ * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
+ * `predicate`, imports them, and returns a map from relative path to module
+ * exports.
+ *
+ * The `predicate` is propagated into `allFiles` so that non-matching files
+ * are excluded before any `import()` is attempted — no wasted I/O.
+ * The default matches all JS/TS source files (`.js`, `.ts`, `.mts`, `.mjs`).
+ * `loadFile`'s own guards (`.f.js`, `.f.ts`, `shouldLoad`) still apply on
+ * top; the predicate only controls which files are discovered.
+ *
+ * The result is sorted by path key using `string.cmp` so the order is
+ * deterministic regardless of filesystem traversal order.
+ */
 export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
@@ -67,24 +80,21 @@ export const loadModuleMap = (env) => {
     //       we should consider optimize them by ALIQ technique or something similar.
     //       For example, we should be able to write it like `allFiles(s).flatMap(loadFile)`,
     //       then an effect runner can batch all file loading operations together.
-    return allFiles(s)
+    return allFiles(s, shouldLoad)
         .step(files => all(...files.map(loadFile)))
         .step(entries => pure(fromEntries(entries
         .flat()
         .map(([k, v]) => [relativize(prefix, k), v])
-        .toSorted(cmp))));
+        .toSorted(([a], [b]) => strCmp(a)(b)))));
 };
 const denoJson = './deno.json';
 const parseDenoJson = rttiParse(record(rttiUnknown));
-const index2 = begin
-    .step(() => updateVersion)
+const index2 = updateVersion
     .step(() => readFile(denoJson))
     .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = begin
-    .step(() => allFiles('.'))
+const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'))
     .step(files => {
-    const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
-    const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
+    const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
     return pure(Object.fromEntries(exportsA));
 });
 const index3 = both(index2)(allFiles2aa)

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

@@ -1,4 +1,7 @@
-declare const _default: {
+export declare const proof: {
+    shouldPass: () => {
+        then: () => undefined;
+    };
     ctor: () => void;
     ctorEmpty: () => void;
     ctorUndefined: () => void;
@@ -6,5 +9,5 @@ declare const _default: {
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
     throw: () => void;
+    env: () => void;
 };
-export default _default;

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

@@ -1,5 +1,9 @@
-import { todo } from "./module.f.js";
-export default {
+import { todo } from "../asserts/module.f.js";
+import { env } from "./module.f.js";
+export const proof = {
+    shouldPass: () => ({
+        then: () => undefined
+    }),
     ctor: () => {
         const c = (() => { })['constructor'];
         const f = c('return 5');
@@ -52,5 +56,25 @@ export default {
     },
     throw: () => {
         todo();
+    },
+    env: () => {
+        const mockIo = { process: { env: { MY_VAR: 'hello' } } };
+        // missing key → undefined
+        const r1 = env(mockIo)('MISSING');
+        if (r1 !== undefined) {
+            throw r1;
+        }
+        // regular value property → returns value
+        const r2 = env(mockIo)('MY_VAR');
+        if (r2 !== 'hello') {
+            throw r2;
+        }
+        // getter property → calls get()
+        const envWithGetter = Object.defineProperty({}, 'GETTER_VAR', { get: () => 'from-getter', enumerable: true, configurable: true });
+        const mockIo2 = { process: { env: envWithGetter } };
+        const r3 = env(mockIo2)('GETTER_VAR');
+        if (r3 !== 'from-getter') {
+            throw r3;
+        }
     }
 };

package/fs/dev/version/proof.f.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    new: () => void;
+};

package/fs/dev/version/{test.f.js → proof.f.js}

@@ -77,7 +77,7 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default {
+export const proof = {
     new: () => {
         const w = (name) => {
             const fn = `${name}.json`;

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

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     test: () => void;
     testCref: () => void;
     testAref: () => void;
     testArray: () => void;
     testObj: () => void;
 };
-export default _default;

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

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-export default {
+export const proof = {
     test: () => {
         const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);

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

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

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

@@ -7,7 +7,7 @@ import { stringifyAsTree } from "../serializer/module.f.js";
 import { stringify } from "../../json/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s))(''));
 const stringifyDjsModule = stringifyAsTree(sort);
-export default {
+export const proof = {
     valid: [
         () => {
             const tokenList = tokenizeString('export default null');

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

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     tooFewArgs: {
         noArgs: () => void;
         oneArg: () => void;
@@ -8,4 +8,3 @@ declare const _default: {
     fileNotFound: () => void;
     parseError: () => void;
 };
-export default _default;

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

@@ -9,7 +9,7 @@ const readOutput = (root, path) => {
     }
     return utf8ToString(file);
 };
-export default {
+export const proof = {
     tooFewArgs: {
         noArgs: () => {
             const [state, code] = virtual(emptyState)(compile([]));

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

@@ -7,11 +7,11 @@ import type { Unknown } from '../module.f.ts';
 import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export declare const undefinedSerialize: string[];
-type RefCounter = [number, number, boolean];
+type RefCounter = readonly [number, number];
 type Entry = ObjectEntry<Unknown>;
 type Entries = List<Entry>;
 type MapEntries = (entries: Entries) => Entries;
-type Refs = Map<Unknown, RefCounter>;
+type Refs = ReadonlyMap<Unknown, RefCounter>;
 export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
 export declare const stringify: (sort: MapEntries) => (djs: Unknown) => string;
 export declare const stringifyAsTree: (mapEntries: MapEntries) => (value: Unknown) => string;

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

@@ -7,88 +7,47 @@ import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
 import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "../../json/serializer/module.f.js";
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
-const getConstantsOp = djs => state => {
-    switch (typeof djs) {
-        case 'boolean': {
-            return state;
-        }
-        case 'number':
-        case 'string':
-        case 'bigint': {
-            return getConstantSelf(djs)(state);
-        }
-        default: {
-            if (djs === null) {
-                return state;
-            }
-            if (djs === undefined) {
-                return state;
-            }
-            if (djs instanceof Array) {
-                return getConstantSelf(djs)(fold(getConstantsOp)(state)(djs));
-            }
-            return getConstantSelf(djs)(fold(getConstantsOp)(state)(map(entryValue)(entries(djs))));
+const getConstants = refs => {
+    const checkSelf = djs => state => {
+        const refCounter = refs.get(djs);
+        if (refCounter !== undefined && refCounter[1] > 1 && !state.added.has(djs)) {
+            return {
+                added: new Set([...state.added, djs]),
+                consts: { head: state.consts, tail: [djs] }
+            };
         }
-    }
-};
-const getConstantSelf = djs => state => {
-    const refs = state.refs;
-    const refCounter = refs.get(djs);
-    if (refCounter !== undefined && refCounter[1] > 1 && !refCounter[2]) {
-        refCounter[2] = true;
-        refs.set(djs, refCounter);
-        return { refs, consts: { head: state.consts, tail: [djs] } };
-    }
-    return state;
-};
-const getConstants = djs => refs => {
-    return getConstantsOp(djs)(refs);
-};
-const entryValue = kv => kv[1];
-export const serializeWithoutConst = sort => {
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn(entries)
-        .map(sort)
-        .map(mapPropertySerialize)
-        .map(objectWrap)
-        .result;
-    const f = value => {
-        switch (typeof value) {
+        return state;
+    };
+    const op = djs => state => {
+        switch (typeof djs) {
             case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
+                return state;
             }
+            case 'number':
+            case 'string':
             case 'bigint': {
-                return [bigintSerialize(value)];
+                return checkSelf(djs)(state);
             }
             default: {
-                if (value === null) {
-                    return nullSerialize;
+                if (djs === null) {
+                    return state;
                 }
-                if (value === undefined) {
-                    return undefinedSerialize;
+                if (djs === undefined) {
+                    return state;
                 }
-                if (value instanceof Array) {
-                    return arraySerialize(value);
+                if (djs instanceof Array) {
+                    return checkSelf(djs)(fold(op)(state)(djs));
                 }
-                return objectSerialize(value);
+                return checkSelf(djs)(fold(op)(state)(map(entryValue)(entries(djs))));
             }
         }
     };
-    const arraySerialize = compose(map(f))(arrayWrap);
-    return f;
+    const init = { added: new Set(), consts: [] };
+    return djs => op(djs)(init).consts;
 };
-const serializeWithConst = sort => refs => root => {
+const entryValue = kv => kv[1];
+const noRef = () => null;
+const buildSerialize = refLookup => sort => {
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
@@ -101,11 +60,9 @@ const serializeWithConst = sort => refs => root => {
         .map(objectWrap)
         .result;
     const f = value => {
-        if (value !== root) {
-            const refCounter = refs.get(value);
-            if (refCounter !== undefined && refCounter[1] > 1) {
-                return [`c${refCounter[0]}`];
-            }
+        const ref = refLookup(value);
+        if (ref !== null) {
+            return ref;
         }
         switch (typeof value) {
             case 'boolean': {
@@ -137,6 +94,17 @@ const serializeWithConst = sort => refs => root => {
     const arraySerialize = compose(map(f))(arrayWrap);
     return f;
 };
+export const serializeWithoutConst = buildSerialize(noRef);
+const serializeWithConst = sort => refs => root => buildSerialize(value => {
+    if (value === root) {
+        return null;
+    }
+    const refCounter = refs.get(value);
+    if (refCounter !== undefined && refCounter[1] > 1) {
+        return [`c${refCounter[0]}`];
+    }
+    return null;
+})(sort);
 const countRefsOp = djs => refs => {
     switch (typeof djs) {
         case 'boolean':
@@ -167,14 +135,14 @@ const countRefsOp = djs => refs => {
 };
 const addRef = djs => refs => {
     const refCounter = refs.get(djs);
-    if (refCounter === undefined) {
-        return refs.set(djs, [refs.size, 1, false]);
-    }
-    return refs.set(djs, [refCounter[0], refCounter[1] + 1, false]);
+    const newCounter = refCounter === undefined
+        ? [refs.size, 1]
+        : [refCounter[0], refCounter[1] + 1];
+    return new Map([...refs, [djs, newCounter]]);
 };
 export const stringify = sort => djs => {
     const refs = countRefs(djs);
-    const consts = getConstants(djs)({ refs, consts: [] }).consts;
+    const consts = getConstants(refs)(djs);
     const constSerialize = entry => {
         const refCounter = refs.get(entry);
         if (refCounter === undefined) {

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/module.f.js

@@ -5,7 +5,7 @@
  */
 import { descentParser } from "../../bnf/data/module.f.js";
 import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
-import { todo } from "../../dev/module.f.js";
+import { todo } from "../../asserts/module.f.js";
 export const parse = (input) => {
     const m = descentParser(jsGrammar());
     return todo();

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') {