functionalscript 0.36.0 → 0.38.0

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

@@ -34,3 +34,8 @@ export type djsResult = {
  * on a parse failure or circular dependency.
  */
 export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;
+export declare const proof: {
+    throw: {
+        mapDjsUnresolvedImport: () => Unknown;
+    };
+};

package/{fs → fjs}/djs/transpiler/module.f.js

@@ -3,17 +3,17 @@
  *
  * @module
  */
-import {} from "../module.f.js";
-import { error, ok } from "../../types/result/module.f.js";
-import { drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
-import { tokenize } from "../tokenizer/module.f.js";
-import { setReplace, at } from "../../types/ordered_map/module.f.js";
-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 { foldStep, pure } from "../../effects/module.f.js";
-import { readUtf8File } from "../../effects/node/module.f.js";
+import {} from '../module.f.js';
+import { error, ok } from '../../types/result/module.f.js';
+import { drop, map as listMap, toArray, includes } from '../../types/list/module.f.js';
+import { tokenize } from '../tokenizer/module.f.js';
+import { setReplace, at } from '../../types/ordered_map/module.f.js';
+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 { foldStep, pure } from '../../effects/module.f.js';
+import { readUtf8File } from '../../effects/node/module.f.js';
 const mapDjs = context => path => {
     const res = at(path)(context.complete);
     if (res === null) {
@@ -76,3 +76,13 @@ export const transpile = path => foldNextModuleOp(path)({ stack: null, complete:
     const result = at(path)(context.complete)?.djs;
     return pure(ok(result));
 });
+// ── Tests ────────────────────────────────────────────────────────────────────
+export const proof = {
+    throw: {
+        // `mapDjs` is only ever called with an import path that `foldNextModuleOp`
+        // has already resolved into `context.complete`, so the `res === null`
+        // guard is an internal-invariant check unreachable through `transpile`'s
+        // public API. Call it directly with an empty `complete` map to cover it.
+        mapDjsUnresolvedImport: () => mapDjs({ complete: null, stack: null, error: null })('missing.djs'),
+    },
+};

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

@@ -2,6 +2,9 @@ export declare const proof: {
     parse: () => void;
     parseWithSubModule: () => void;
     parseWithSubModules: () => void;
+    parseWithIdentifierKeys: () => void;
+    parseWithConstIdentifier: () => void;
+    parseWithUnaryMinusOperator: () => void;
     parseWithFileNotFoundError: () => void;
     parseWithCycleError: () => void;
 };

package/fjs/djs/transpiler/proof.f.js

@@ -0,0 +1,67 @@
+import { sort } from '../../types/object/module.f.js';
+import { transpile } from './module.f.js';
+import { stringifyAsTree } from '../serializer/module.f.js';
+import { virtual, emptyState } from '../../effects/node/virtual/module.f.js';
+import { utf8 } from '../../text/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+const run = (root) => (path) => {
+    const [_, result] = virtual({ ...emptyState, root })(transpile(path));
+    return result;
+};
+export const proof = {
+    parse: () => {
+        const result = run({ a: [utf8('export default 1')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '1');
+    },
+    parseWithSubModule: () => {
+        const result = run({ a: { b: [utf8('import c from "c"\nexport default c')], c: [utf8('export default 2')] } })('a/b');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '2');
+    },
+    parseWithSubModules: () => {
+        const result = run({
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import d from "d"\nexport default [0,d]')],
+            c: [utf8('import d from "d"\nexport default [1,d]')],
+            d: [utf8('export default 2')],
+        })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '[[0,2],[1,2],[0,2]]');
+    },
+    parseWithIdentifierKeys: () => {
+        const result = run({ a: [utf8('export default {a:1,b:2}')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '{"a":1,"b":2}');
+    },
+    parseWithConstIdentifier: () => {
+        const result = run({ a: [utf8('const a = 1\nconst b = a\nexport default {x:a,y:b}')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '{"x":1,"y":1}');
+    },
+    parseWithUnaryMinusOperator: () => {
+        const result = run({ a: [utf8('export default [-1,2,-3]')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '[-1,2,-3]');
+    },
+    parseWithFileNotFoundError: () => {
+        const result = run({ a: [utf8('import b from "b"\nexport default b')] })('a');
+        assert(result[0] === 'error', result);
+        assertEq(result[1].message, 'file not found', result);
+    },
+    parseWithCycleError: () => {
+        const result = run({
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import c from "c"\nexport default c')],
+            c: [utf8('import b from "b"\nexport default b')],
+        })('a');
+        assert(result[0] === 'error', result);
+        assertEq(result[1].message, 'circular dependency', result);
+    },
+};

package/{fs → fjs}/effects/memory/module.f.js

@@ -12,10 +12,10 @@
  *
  * @module
  */
-import { asBase as nominalAsBase, asNominal as nominalAsNominal } from "../../types/nominal/module.f.js";
-import { do_ } from "../module.f.js";
-export const asBase = (nominalAsBase);
-export const asNominal = (nominalAsNominal);
+import { asBase as nominalAsBase, asNominal as nominalAsNominal } from '../../types/nominal/module.f.js';
+import { do_ } from '../module.f.js';
+export const asBase = nominalAsBase;
+export const asNominal = nominalAsNominal;
 /** Creates a new typed memory slot with `value` as its initial contents. */
 export const create = do_('memCreate');
 /** Reads the current contents of a typed memory slot. */

package/{fs → fjs}/effects/memory/proof.f.js

@@ -1,6 +1,7 @@
-import { run } from "../mock/module.f.js";
-import { pure } from "../module.f.js";
-import { asBase, asNominal, create, read, write, } from "./module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { run } from '../mock/module.f.js';
+import { pure } from '../module.f.js';
+import { asBase, asNominal, create, read, write, } from './module.f.js';
 const initial = { next: 0, values: {} };
 const mock = {
     memCreate: value => state => {
@@ -14,9 +15,7 @@ const mock = {
     memRead: key => state => [state, state.values[asBase(key)]],
     memWrite: (key, value) => state => {
         const id = asBase(key);
-        if (!(id in state.values)) {
-            throw id;
-        }
+        assert(id in state.values, id);
         return [{
                 ...state,
                 values: { ...state.values, [id]: value },
@@ -27,12 +26,8 @@ const program = create(1).step(key => read(key).step(value => write(key, value +
 export const proof = {
     roundTrip: () => {
         const [state, result] = run(mock)(initial)(program);
-        if (result !== 42) {
-            throw result;
-        }
-        if (state.values.k0 !== 42) {
-            throw state;
-        }
+        assertEq(result, 42);
+        assertEq(state.values.k0, 42, state);
     },
     allocatesFreshKeys: () => {
         const effect = create('a').step(a => create('b').step(b => pure([
@@ -40,18 +35,10 @@ export const proof = {
             asBase(b),
         ])));
         const [state, [a, b]] = run(mock)(initial)(effect);
-        if (a !== 'k0') {
-            throw a;
-        }
-        if (b !== 'k1') {
-            throw b;
-        }
-        if (state.values.k0 !== 'a') {
-            throw state;
-        }
-        if (state.values.k1 !== 'b') {
-            throw state;
-        }
+        assertEq(a, 'k0');
+        assertEq(b, 'k1');
+        assertEq(state.values.k0, 'a', state);
+        assertEq(state.values.k1, 'b', state);
     },
     typeTest: () => {
         // const e = create(1).step(k => write(k, 'bad').step(() => read(k)))

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

@@ -10,7 +10,7 @@
  *
  * @module
  */
-import { fold } from "../types/list/module.f.js";
+import { fold } from '../types/list/module.f.js';
 export const pure = (v) => ({
     value: () => v,
     step: f => f(v)

package/{fs → fjs}/effects/node/memory/module.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { randomUUID } from 'node:crypto';
-import { asyncRun } from "../../module.js";
-import { asBase, asNominal } from "../../memory/module.f.js";
+import { asyncRun } from '../../module.js';
+import { asBase, asNominal } from '../../memory/module.f.js';
 const missingKey = (id) => new Error(`memory key not found: ${id}`);
 /**
  * Creates a stateful operation map backed by an immutable `Map` snapshot.

package/{fs → fjs}/effects/node/memory/proof.js

@@ -3,33 +3,26 @@
  *
  * @module
  */
-import { asyncRun } from "../../module.js";
-import { asNominal, create, read, write, } from "../../memory/module.f.js";
-import { memoryOperationMap, run } from "./module.js";
+import { asyncRun } from '../../module.js';
+import { asNominal, create, read, write, } from '../../memory/module.f.js';
+import { memoryOperationMap, run } from './module.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
 export const proof = {
     nodeInterpreter: async () => {
         const result = await run(create(1).step(key => write(key, 2).step(() => read(key))));
-        if (result !== 2) {
-            throw result;
-        }
+        assertEq(result, 2);
     },
     reusedOperationMapPersists: async () => {
         const runner = asyncRun(memoryOperationMap());
         const key = await runner(create(1));
         await runner(write(key, 2));
         const result = await runner(read(key));
-        if (result !== 2) {
-            throw result;
-        }
+        assertEq(result, 2);
     },
     missingKeyThrows: async () => {
         const key = asNominal('missing');
         const result = await run(read(key)).then(() => undefined, error => error);
-        if (!(result instanceof Error)) {
-            throw result;
-        }
-        if (result.message !== 'memory key not found: missing') {
-            throw result;
-        }
+        assert(result instanceof Error, result);
+        assertEq(result.message, 'memory key not found: missing', result);
     },
 };

package/{fs → fjs}/effects/node/module.d.ts

@@ -15,6 +15,6 @@ export declare const runEffect: (p: NodeProgram) => Promise<number>;
  * that control never returns to the caller — the process terminates.
  *
  * A `bin` script can simply
- * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ * `import { run } from '.../fjs/effects/node/module.js'; await run(main)`.
  */
 export declare const run: (p: NodeProgram) => Promise<never>;

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

@@ -218,7 +218,7 @@ export declare const sandbox: Func<Sandbox>;
  * If `p` is a real `Promise`, it is awaited and rejections propagate as
  * throws. If `p` is any other value it is returned as-is. Plain thenables
  * (objects with a `.then` method that are not `instanceof Promise`) are
- * treated as ordinary values — not awaited. See `fs/dev/tf/README.md`.
+ * treated as ordinary values — not awaited. See `fjs/dev/tf/README.md`.
  */
 export type Await = readonly ['await', (p: unknown) => readonly [unknown]];
 export declare const awaitIfPromise: (p: unknown) => Effect<Await, unknown>;

package/{fs → fjs}/effects/node/module.f.js

@@ -8,13 +8,13 @@
  *
  * @module
  */
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { toCodePointList } from "../../text/utf8/module.f.js";
-import { codePointListToString } from "../../text/utf16/module.f.js";
-import { reverse } from "../../types/list/module.f.js";
-import { length } from "../../types/bit_vec/module.f.js";
-import { ok, error as resultError, mapOk } from "../../types/result/module.f.js";
-import { do_, okStep, pure } from "../module.f.js";
+import { utf8, utf8ToString } from '../../text/module.f.js';
+import { toCodePointList } from '../../text/utf8/module.f.js';
+import { codePointListToString } from '../../text/utf16/module.f.js';
+import { reverse } from '../../types/list/module.f.js';
+import { length } from '../../types/bit_vec/module.f.js';
+import { ok, error as resultError, mapOk } from '../../types/result/module.f.js';
+import { do_, okStep, pure } from '../module.f.js';
 /**
  * True if `e` is a "file or directory does not exist" (`ENOENT`) error.
  *

package/{fs → fjs}/effects/node/module.js

@@ -12,8 +12,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  * `fetch`, …).
  *
  * There is deliberately no injectable IO seam here. Effectful programs are
- * tested against the in-memory interpreters in `fs/effects/mock` and
- * `fs/effects/node/virtual`, which interpret the same operations without
+ * tested against the in-memory interpreters in `fjs/effects/mock` and
+ * `fjs/effects/node/virtual`, which interpret the same operations without
  * touching the OS, so a handler-table indirection in this module would have
  * exactly one instance and no consumer — the handlers reference the Node
  * globals directly instead.
@@ -28,16 +28,16 @@ import os from 'node:os';
 import process from 'node:process';
 import { once } from 'node:events';
 import * as testContext from 'node:test';
-import { concat, normalize, toPosix } from "../../path/module.f.js";
-import {} from "../module.f.js";
-import { asyncRun } from "../module.js";
-import { memoryOperationMap } from "./memory/module.js";
-import {} from "./module.f.js";
-import { asBase, asNominal } from "../../types/nominal/module.f.js";
-import { error, ok } from "../../types/result/module.f.js";
-import { asyncTryCatch } from "../../types/result/module.js";
-import { fromVec, listToVec, toVec } from "../../types/uint8array/module.f.js";
-import { maxLengthBytes } from "../../types/bit_vec/module.f.js";
+import { concat, normalize, toPosix } from '../../path/module.f.js';
+import {} from '../module.f.js';
+import { asyncRun } from '../module.js';
+import { memoryOperationMap } from './memory/module.js';
+import {} from './module.f.js';
+import { asBase, asNominal } from '../../types/nominal/module.f.js';
+import { error, ok } from '../../types/result/module.f.js';
+import { asyncTryCatch } from '../../types/result/module.js';
+import { fromVec, listToVec, toVec } from '../../types/uint8array/module.f.js';
+import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
 /**
  * Narrowed structural view of `node:http`'s `createServer`. The official types
  * declare `method`/`url` optional and header values as
@@ -300,6 +300,6 @@ export const runEffect = program => runNodeEffect(program(options));
  * that control never returns to the caller — the process terminates.
  *
  * A `bin` script can simply
- * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ * `import { run } from '.../fjs/effects/node/module.js'; await run(main)`.
  */
 export const run = async (p) => process.exit(await runEffect(p));

package/{fs → fjs}/effects/node/proof.f.d.ts

@@ -63,5 +63,6 @@ export declare const proof: {
     };
     writeFromStream: {
         createExclusiveFails: () => void;
+        invalidBufferSize: () => void;
     };
 };