functionalscript 0.17.0 → 0.19.0

package/fs/asn.1/module.f.js

@@ -5,19 +5,18 @@
  * @module
  */
 import { bitLength, max } from "../types/bigint/module.f.js";
-import { empty, isVec, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { identity } from "../types/function/module.f.js";
 import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
-const pop = msb.popFront;
+const { popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
-const concat = listToVec(msb);
 const classPcMask = 224n;
 const tagNumberMask = 31n;
 const parsedTagEncode = ([classPc, number]) => {
     const [firstByteNumber, rest] = number < tagNumberMask
         ? [number, empty]
         : [tagNumberMask, b128encode(number)];
-    return concat([vec8(classPc | firstByteNumber), rest]);
+    return listToVec([vec8(classPc | firstByteNumber), rest]);
 };
 const parsedTagDecode = (v) => {
     const [firstByte, rest] = pop8(v);
@@ -86,7 +85,7 @@ const lenEncode = (uint) => {
         return vec8(uint);
     }
     const { byteLen, v } = round8({ length: bitLength(uint), uint });
-    return concat([vec8(0x80n | byteLen), v]);
+    return listToVec([vec8(0x80n | byteLen), v]);
 };
 /**
  * Decodes the length field of an ASN.1 TLV and returns the length in bits and the remaining input.
@@ -104,7 +103,7 @@ const lenDecode = (v) => {
 export const encodeRaw = ([tag, value]) => {
     const tagVec = tagEncode(tag);
     const { byteLen, v } = round8(unpack(value));
-    return concat([tagVec, lenEncode(byteLen), v]);
+    return listToVec([tagVec, lenEncode(byteLen), v]);
 };
 /** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
 export const decodeRaw = (v) => {
@@ -139,7 +138,7 @@ export const decodeOctetString = (v) => v;
 export const encodeObjectIdentifier = (oid) => {
     const [first, second, ...rest] = oid;
     const firstByte = first * 40n + second;
-    return concat([vec8(firstByte), ...rest.map(b128encode)]);
+    return listToVec([vec8(firstByte), ...rest.map(b128encode)]);
 };
 /** Decodes an OBJECT IDENTIFIER value. */
 export const decodeObjectIdentifier = (v) => {
@@ -155,7 +154,7 @@ export const decodeObjectIdentifier = (v) => {
     }
     return result;
 };
-const genericEncodeSequence = (map) => (...records) => concat(map(records.map(encode)));
+const genericEncodeSequence = (map) => (...records) => listToVec(map(records.map(encode)));
 /** Encodes a SEQUENCE payload from ordered records. */
 export const encodeSequence = genericEncodeSequence(identity);
 /** Decodes a SEQUENCE payload into records. */

package/fs/asn.1/test.f.js

@@ -1,8 +1,7 @@
-import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+import { empty, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { asBase } from "../types/nominal/module.f.js";
 import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet } from "./module.f.js";
-const { concat, popFront: pop } = msb;
-const cat = listToVec(msb);
+const { concat, popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const check = (tag, v, rest) => {
     const s = encodeRaw([tag, v]);
@@ -244,19 +243,19 @@ export default {
     },
     encodeDecode: {
         integer: () => {
-            ch([integer, 0n], cat([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
-            ch([integer, 1n], cat([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
+            ch([integer, 0n], listToVec([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
+            ch([integer, 1n], listToVec([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
         },
         sequence: () => {
-            ch([constructedSequence, []], cat([vec8(BigInt(constructedSequence)), vec8(0n)]));
-            ch([constructedSequence, [[integer, 0n]]], cat([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
-            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], cat([
+            ch([constructedSequence, []], listToVec([vec8(BigInt(constructedSequence)), vec8(0n)]));
+            ch([constructedSequence, [[integer, 0n]]], listToVec([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
+            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], listToVec([
                 vec8(BigInt(constructedSequence)),
                 vec8(6n),
                 encode([integer, 1n]),
                 encode([integer, 2n])
             ]));
-            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], cat([
+            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], listToVec([
                 vec8(BigInt(constructedSequence)),
                 vec8(9n),
                 encode([octetString, vec8(0x23n)]),
@@ -265,7 +264,7 @@ export default {
             ]));
         },
         set: () => {
-            ch([constructedSet, [[integer, 2n], [integer, 1n]]], cat([
+            ch([constructedSet, [[integer, 2n], [integer, 1n]]], listToVec([
                 vec8(BigInt(constructedSet)),
                 vec8(6n),
                 encode([integer, 1n]),
@@ -276,7 +275,7 @@ export default {
     raw: [
         () => {
             const e = encodeRaw([0x00n, vec8(0x23n)]);
-            if (e !== cat([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
+            if (e !== listToVec([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
                 throw `encode: ${length(e)}: ${uint(e).toString(2)}`;
             }
             const [[tag, value], rest] = decodeRaw(e);
@@ -292,7 +291,7 @@ export default {
         },
         () => {
             const e = encodeRaw([0x1f20n, vec(16n)(0x1234n)]);
-            if (e !== cat([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
+            if (e !== listToVec([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
                 const l = length(e);
                 const u = uint(e);
                 throw `encode: ${l}: ${u.toString(16)}`;

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

@@ -12,12 +12,12 @@ export type Os = typeof os[number];
 export declare const architecture: readonly ["intel", "arm"];
 export type Architecture = typeof architecture[number];
 export type Image = typeof images[Os][Architecture];
-declare const stepSchema: {
+export declare const stepSchema: {
     readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
     readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
     readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
 };
-declare const jobSchema: {
+export declare const jobSchema: {
     readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
     readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
         readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
@@ -25,7 +25,7 @@ declare const jobSchema: {
         readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
     }>;
 };
-declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record", {
+export declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record", {
     readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
     readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
         readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
@@ -33,7 +33,7 @@ declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record",
         readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
     }>;
 }>;
-declare const gitHubActionSchema: {
+export declare const gitHubActionSchema: {
     readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
@@ -82,4 +82,3 @@ export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
 export declare const findTgz: (v: Os) => "(Get-ChildItem *.tgz).FullName" | "./*.tgz";
-export {};

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

@@ -11,17 +11,17 @@ import {} from "../../types/rtti/ts/module.f.js";
 import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
 export const os = ['ubuntu', 'macos', 'windows'];
 export const architecture = ['intel', 'arm'];
-const stepSchema = {
+export const stepSchema = {
     run: option(string),
     uses: option(string),
     with: option(record(string))
 };
-const jobSchema = {
+export const jobSchema = {
     'runs-on': string,
     steps: array(stepSchema)
 };
-const jobsSchema = record(jobSchema);
-const gitHubActionSchema = {
+export const jobsSchema = record(jobSchema);
+export const gitHubActionSchema = {
     name: string,
     on: { pull_request: option({}) },
     jobs: jobsSchema

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

@@ -20,13 +20,13 @@ export declare const images: {
     };
 };
 export declare const bun = "1.3.14";
-export declare const deno = "2.7.14";
+export declare const deno = "2.8.1";
 export declare const playwright = "1.60.0";
 export declare const rust = "1.95.0";
 export declare const node: {
-    readonly default: "26.1.0";
-    readonly others: readonly ["22.22.3", "24.15.0"];
+    readonly default: "26.2.0";
+    readonly others: readonly ["24.16.0"];
 };
-export declare const wasmtime = "44.0.1";
+export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260517.1";
+export declare const tsgo = "7.0.0-dev.20260527.1";

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

@@ -23,19 +23,19 @@ export const images = {
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.7.14';
+export const deno = '2.8.1';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
 // https://rust-lang.org/
 export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.1.0',
-    others: ['22.22.3', '24.15.0'],
+    default: '26.2.0',
+    others: ['24.16.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '44.0.1';
+export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260517.1';
+export const tsgo = '7.0.0-dev.20260527.1';

package/fs/ci/test.f.js

@@ -4,10 +4,8 @@ import { isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../dev/module.f.js";
 import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
-import {} from "../types/rtti/ts/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-// type Gha = Ts<typeof gitHubActionSchema>
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
 const githubState = {
@@ -18,9 +16,9 @@ const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(githubState)(ci({ rust, nodeExtra, denoExtra: [], bunExtra: [] }));
     assert(result === 0, result);
     const dotGithub = state.root['.github'];
-    assert(dotGithub !== undefined && !isVec(dotGithub), dotGithub);
+    assert(typeof dotGithub === 'object', dotGithub);
     const workflows = dotGithub['workflows'];
-    assert(workflows !== undefined && !isVec(workflows), workflows);
+    assert(typeof workflows === 'object', workflows);
     const file = workflows['ci.yml'];
     assert(isVec(file), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));

package/fs/crypto/sign/module.f.js

@@ -1,5 +1,5 @@
 import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
-import { empty, length, listToVec, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { empty, length, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
 import { computeSync } from "../sha2/module.f.js";
 // qlen to rlen
@@ -34,8 +34,8 @@ export const all = (q) => {
 export const fromCurve = (c) => all(c.nf.p);
 const x01 = vec8(0x01n);
 const x00 = vec8(0x00n);
-const ltov = listToVec(msb);
-export const concat = (...x) => ltov(x);
+const { listToVec } = msb;
+export const concat = (...x) => listToVec(x);
 /**
  * Computes deterministic ECDSA nonce `k` as described by RFC6979.
  */

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type Io } from '../io/module.f.ts';
+import type { Io } from '../io/module.f.ts';
 import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
 export declare const todo: () => never;
@@ -18,6 +18,6 @@ export type ModuleMap = {
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
 export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
-export declare const loadModuleMap2: (env: Env) => Effect<Access | Import | All | Readdir, ModuleMap>;
-export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
+export type LoadModuleOperations = Access | Import | All | Readdir;
+export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -1,9 +1,3 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
 import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
@@ -12,6 +6,7 @@ import { begin, pure } from "../types/effects/module.f.js";
 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)
@@ -63,14 +58,22 @@ const loadFile = (f) => {
     }
     return pure([]);
 };
-export const loadModuleMap2 = (env) => {
+const { fromEntries } = Object;
+export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
+    const prefix = s === '.' ? '' : s;
+    // TODO: there are multiple `all` effects here,
+    //       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)
         .step(files => all(...files.map(loadFile)))
-        .step(entries => pure(Object.fromEntries(entries.flat().toSorted(cmp))));
+        .step(entries => pure(fromEntries(entries
+        .flat()
+        .map(([k, v]) => [relativize(prefix, k), v])
+        .toSorted(cmp))));
 };
-export const loadModuleMap = async (io) => fromIo(io)(loadModuleMap2(io.process.env));
 const denoJson = './deno.json';
 const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = begin

package/fs/dev/tf/module.d.ts

@@ -1 +1 @@
-export declare const run: () => Promise<void>;
+export declare const run: () => Promise<number>;

package/fs/dev/tf/module.f.d.ts

@@ -1,8 +1,77 @@
-import type { Io } from '../../io/module.f.ts';
-import type { SandboxResult } from '../../types/effects/node/module.f.ts';
+import { type All, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../../types/effects/module.f.ts';
+import { type LoadModuleOperations, type ModuleMap } from '../module.f.ts';
 export declare const isTest: (s: string) => boolean;
-export type Test = () => unknown;
-export type TestSet = Test | readonly (readonly [string, unknown])[];
-export declare const parseTestSet: (sandbox: <R>(f: () => R) => SandboxResult<R>) => (throws: boolean) => (x: unknown) => TestSet;
-export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
-export declare const main: (io: Io) => Promise<number>;
+export type TestFn = () => unknown;
+export type TestEntry = {
+    readonly fn: TestFn;
+    readonly throws: boolean;
+};
+export type TestSet = TestEntry | readonly (readonly [string, unknown])[];
+export declare const parseTestSet: (throws: boolean, x: unknown) => TestSet;
+type TestAndPath = readonly [Path, TestEntry];
+/**
+ * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
+ * pairs, without running anything. Return-value sub-trees are not walked
+ * (that requires execution); only the static object/array/function structure
+ * is traversed.
+ */
+export declare const collectTests: (path: Path, throws: boolean, v: unknown) => readonly TestAndPath[];
+/**
+ * Receives semantic test-run events. Each method is the runner's notification
+ * of an event; the reporter decides how to render it (terminal, GitHub
+ * annotations, JSON, node `--test`, etc.). `path` is the chain of object keys
+ * leading to the current location; `null` marks a function-call boundary, e.g.
+ * `['outer', null, 'inner']` means `outer` was invoked and its return value
+ * contained `inner`.
+ */
+export type Reporter<O extends Operation> = {
+    readonly result: (file: string, path: Path, r: SandboxResult<unknown>) => Effect<O, void>;
+    readonly summary: (pass: number, fail: number, time: number) => Effect<O, void>;
+    readonly test: (file: string, path: Path, set: TestEntry) => Effect<O, SandboxResult<unknown>>;
+};
+export declare const registerModule: (ctx: TestContext, k: string, v: unknown) => Effect<Test | All, void>;
+export declare const runModuleMap: <O extends Operation>(reporter: Reporter<O>) => (moduleMap: ModuleMap) => Effect<O | All, number>;
+export declare const testAll: <O extends Operation>(reporter: Reporter<O>) => Program<O | All | LoadModuleOperations>;
+export declare const registerModuleMap: (ctx: TestContext, moduleMap: ModuleMap) => Effect<Test | All, void>;
+export type Path = readonly (string | null)[];
+export declare const isInteger: (s: string) => boolean;
+export declare const isIdentifier: (s: string) => boolean;
+/**
+ * Renders a key chain as a JS property-access expression: identifier keys use
+ * dot notation, integer keys use `[N]`, other strings use `["key"]`, and `null`
+ * emits `()` to mark a function-call boundary.
+ * E.g. `['math', 'add']` → `.math.add`, `['outer', null, 'inner']` → `.outer().inner`.
+ */
+export declare const fmtPath: (path: Path) => string;
+/**
+ * Formats a fully-qualified test identifier as a JS-like expression, e.g.
+ * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * Self-contained per line — suitable for parallel output and as a CLI filter argument.
+ */
+export declare const fmtImport: (file: string, path: Path) => string;
+/**
+ * Renders a key chain for terminal output: `| ` per level of depth, followed
+ * by the last segment formatted as a bare integer, a bare identifier, or a
+ * JSON-quoted string. E.g. `['math', 'add']` → `| | add`,
+ * `['a', '0']` → `| | 0`, `['x', 'hello world']` → `| | "hello world"`.
+ */
+export declare const fmtTerm: (path: Path) => string;
+/**
+ * Percent-encodes characters that GitHub workflow-command property values
+ * treat as separators (`%`, `:`, `,`) plus newlines.
+ * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+ */
+export declare const ghEscape: (s: string) => string;
+export declare const defaultTest: (file: string, path: Path, { fn, throws }: TestEntry) => Effect<Sandbox, SandboxResult<unknown>>;
+/**
+ * The terminal/GitHub reporter used by `fjs t`. Output goes through
+ * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
+ * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * annotations instead of colored lines. Exported as a factory so the
+ * GitHub format path can be exercised directly from tests.
+ */
+export declare const defaultReporter: (options: NodeProgramOptions) => Reporter<Write | Sandbox>;
+export declare const main: NodeProgram;
+export declare const register: NodeProgram;
+export {};