functionalscript 0.14.8 → 0.15.0

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

@@ -18,8 +18,8 @@ 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.2", "24.15.0"];
+    readonly others: readonly ["22.22.3", "24.15.0"];
 };
 export declare const wasmtime = "44.0.1";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260512.1";
+export declare const tsgo = "7.0.0-dev.20260515.1";

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

@@ -24,11 +24,11 @@ export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.1.0',
-    others: ['22.22.2', '24.15.0'],
+    others: ['22.22.3', '24.15.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '44.0.1';
 // 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.20260512.1';
+export const tsgo = '7.0.0-dev.20260515.1';

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

@@ -11,6 +11,7 @@ export declare const assert: (v: boolean, msg?: unknown) => asserts v;
 export declare const assertEq: <T>(a: T, b: T) => void;
 export type Module = {
     readonly default?: unknown;
+    readonly [k: string]: unknown;
 };
 export type ModuleMap = {
     readonly [k in string]: Module;

package/fs/dev/tf/module.f.js

@@ -93,6 +93,16 @@ export const test = (input) => {
             if (isTest(k)) {
                 log(`testing ${k}`);
                 [ts, state] = test('| ')(false)(v.default)([ts, state]);
+                // Non-default exports are walked as a sibling test group so
+                // a test file can spread its tests across multiple named
+                // exports (see issue 27 in `issues/README.md`). Skip exports
+                // that parseTestSet would treat as empty (constants, types,
+                // non-test helpers) to avoid noisy empty entries in output.
+                const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
+                    (typeof val === 'object' && val !== null))));
+                if (Object.keys(others).length !== 0) {
+                    [ts, state] = test('| ')(false)(others)([ts, state]);
+                }
             }
             return [ts, state];
         };

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

@@ -14,3 +14,8 @@ declare const _default: {
     };
 };
 export default _default;
+export declare const namedExportTest: () => void;
+export declare const namedExportGroup: {
+    nested: () => void;
+    throw: () => never;
+};

package/fs/dev/tf/test.f.js

@@ -20,3 +20,17 @@ export default {
         },
     },
 };
+// Non-default exports are walked as a sibling test group (see issue 27).
+export const namedExportTest = () => {
+    if (2 + 2 !== 4) {
+        throw 'arithmetic broken';
+    }
+};
+export const namedExportGroup = {
+    nested: () => {
+        if ('a' + 'b' !== 'ab') {
+            throw 'string concat broken';
+        }
+    },
+    throw: () => { throw 'expected to throw'; },
+};

package/fs/io/module.f.js

@@ -37,7 +37,7 @@ const collect = async (v) => {
 };
 export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }) => {
     const result = asyncRun({
-        all: async (effects) => await Promise.all(effects.map(result)),
+        all: async (...effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
         log: async (message) => log(message),
         fetch: async (url) => tc(async () => {
@@ -47,13 +47,13 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             }
             return toVec(new Uint8Array(await response.arrayBuffer()));
         }),
-        mkdir: param => tc(async () => { await mkdir(...param); }),
+        mkdir: (...p) => tc(async () => { await mkdir(...p); }),
         readFile: path => tc(async () => toVec(await readFile(path))),
-        readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+        readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
-        writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+        writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
         rm: path => tc(() => rm(path)),
-        exec: ([command, stdin]) => new Promise(resolve => {
+        exec: (command, stdin) => new Promise(resolve => {
             const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
             child.stdin?.end(stdin);
         }),
@@ -75,7 +75,7 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             const server = asNominal(createServer(nodeRl));
             return server;
         },
-        listen: async ([server, port]) => {
+        listen: async (server, port) => {
             const s = asBase(server);
             s.listen(port);
         },

package/fs/types/effects/mock/module.f.d.ts

@@ -5,7 +5,7 @@
  */
 import type { Effect, Operation, Pr } from "../module.f.ts";
 export type MemOperationMap<O extends Operation, S> = {
-    readonly [K in O[0]]: (state: S, payload: Pr<O, K>[0]) => readonly [S, Pr<O, K>[1]];
+    readonly [K in O[0]]: (state: S, ...payload: Pr<O, K>[0]) => readonly [S, Pr<O, K>[1]];
 };
 export type RunInstance<O extends Operation, S> = (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];
 export declare const run: <O extends Operation, S>(o: MemOperationMap<O, S>) => RunInstance<O, S>;

package/fs/types/effects/mock/module.f.js

@@ -9,7 +9,7 @@ export const run = (o) => state => effect => {
         }
         const [cmd, payload, cont] = value;
         const operation = o[cmd];
-        const [ns, m] = operation(s, payload);
+        const [ns, m] = operation(s, ...payload);
         s = ns;
         e = cont(m);
     }

package/fs/types/effects/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-export type Operation = readonly [string, (_: never) => unknown];
+export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;
     step: <Q extends Operation, R>(f: (p: T) => Effect<Q, R>) => Effect<O | Q, R>;
@@ -11,20 +11,18 @@ export type Effect<O extends Operation, T> = {
 export type Value<O extends Operation, T> = Pure<T> | Do<O, T>;
 export type Pure<T> = readonly [T];
 export type DoKPR<O extends Operation, T, K extends string, PR extends readonly [unknown, unknown]> = readonly [K, PR[0], (_: PR[1]) => Effect<O, T>];
-export type Pr<O extends Operation, K extends O[0]> = O extends readonly [K, (_: infer P) => infer R] ? readonly [P, R] : never;
+export type Pr<O extends Operation, K extends O[0]> = O extends readonly [K, (...args: infer P) => infer R] ? readonly [P, R] : never;
 export type DoK<O extends Operation, T, K extends O[0]> = DoKPR<O, T, K, Pr<O, K>>;
 export type Do<O extends Operation, T> = DoK<O, T, O[0]>;
 export declare const pure: <T>(v: T) => Effect<never, T>;
 export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, param: Pr<O, K>[0], cont: (input: Pr<O, K>[1]) => Effect<O, T>) => Effect<O, T>;
 export type Param<O extends Operation> = F<O>[0];
 export type Return<O extends Operation> = F<O>[1];
-export declare const do_: <O extends Operation>(cmd: O[0]) => (param: Param<O>) => Effect<O, Return<O>>;
-export declare const doRest: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
+export declare const do_: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
 export declare const begin: Effect<never, void>;
 export type ToAsyncOperationMap<O extends Operation> = {
-    readonly [K in O[0]]: (payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
+    readonly [K in O[0]]: (...payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
 };
 export type F<O extends Operation> = Pr<O, O[0]>;
-export type Func<O extends Operation> = (_: Param<O>) => Effect<O, Return<O>>;
-export type RestFunc<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;
+export type Func<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;
 export type ListEffect<O extends Operation, T> = Effect<O, readonly [T, ListEffect<O, T>] | undefined>;

package/fs/types/effects/module.f.js

@@ -11,6 +11,5 @@ export const doFull = (cmd, param, cont) => ({
     value: [cmd, param, cont],
     step: (f) => doFull(cmd, param, x => cont(x).step(f)),
 });
-export const do_ = (cmd) => (param) => doFull(cmd, param, pure);
-export const doRest = (cmd) => (...param) => do_(cmd)(param);
+export const do_ = (cmd) => (...param) => doFull(cmd, param, pure);
 export const begin = pure(undefined);

package/fs/types/effects/module.js

@@ -6,7 +6,7 @@ export const asyncRun = (map) => async (effect) => {
         }
         const [command, payload, continuation] = value;
         const operation = map[command];
-        const result = await operation(payload);
+        const result = await operation(...payload);
         effect = continuation(result);
     }
 };

package/fs/types/effects/node/module.f.d.ts

@@ -1,9 +1,9 @@
 import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
-import { type Effect, type Func, type Operation, type RestFunc, type ToAsyncOperationMap } from '../module.f.ts';
+import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
-export type All = ['all', <T>(_: readonly Effect<never, T>[]) => readonly T[]];
+export type All = ['all', <T>(...effects: Effect<never, T>[]) => readonly T[]];
 /**
  * To run the operation `O` should be known by the runner/engine.
  * This is the reason why we merge `O` with `All` in the resulted `Effect`.
@@ -13,15 +13,14 @@ export type All = ['all', <T>(_: readonly Effect<never, T>[]) => readonly T[]];
  */
 export declare const all: <O extends Operation, T>(...a: readonly Effect<O, T>[]) => Effect<O | All, readonly T[]>;
 export declare const both: <O0 extends Operation, T0>(a: Effect<O0, T0>) => <O1 extends Operation, T1>(b: Effect<O1, T1>) => Effect<O0 | O1 | All, readonly [T0, T1]>;
-export type Fetch = ['fetch', (_: string) => IoResult<Vec>];
+export type Fetch = ['fetch', (url: string) => IoResult<Vec>];
 export declare const fetch: Func<Fetch>;
 export type MakeDirectoryOptions = {
     readonly recursive: true;
 };
-export type MkdirParam = readonly [string, MakeDirectoryOptions?];
-export type Mkdir = readonly ['mkdir', (_: MkdirParam) => IoResult<void>];
-export declare const mkdir: RestFunc<Mkdir>;
-export type ReadFile = readonly ['readFile', (_: string) => IoResult<Vec>];
+export type Mkdir = readonly ['mkdir', (path: string, options?: MakeDirectoryOptions) => IoResult<void>];
+export declare const mkdir: Func<Mkdir>;
+export type ReadFile = readonly ['readFile', (path: string) => IoResult<Vec>];
 export declare const readFile: Func<ReadFile>;
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -35,25 +34,22 @@ export type Dirent = {
 export type ReaddirOptions = {
     readonly recursive?: true;
 };
-export type ReaddirParam = readonly [string, ReaddirOptions];
-export type Readdir = readonly ['readdir', (_: ReaddirParam) => IoResult<readonly Dirent[]>];
-export declare const readdir: RestFunc<Readdir>;
-export type WriteFileParam = readonly [string, Vec];
-export type WriteFile = readonly ['writeFile', (_: WriteFileParam) => IoResult<void>];
-export declare const writeFile: RestFunc<WriteFile>;
-export type Rm = readonly ['rm', (_: string) => IoResult<void>];
+export type Readdir = readonly ['readdir', (path: string, options: ReaddirOptions) => IoResult<readonly Dirent[]>];
+export declare const readdir: Func<Readdir>;
+export type WriteFile = readonly ['writeFile', (path: string, data: Vec) => IoResult<void>];
+export declare const writeFile: Func<WriteFile>;
+export type Rm = readonly ['rm', (path: string) => IoResult<void>];
 export declare const rm: Func<Rm>;
 export type ExecResult = {
     readonly stdout: string;
     readonly stderr: string;
 };
-export type ExecParam = readonly [string, string?];
-export type Exec = readonly ['exec', (_: ExecParam) => IoResult<ExecResult>];
-export declare const exec: RestFunc<Exec>;
+export type Exec = readonly ['exec', (command: string, stdin?: string) => IoResult<ExecResult>];
+export declare const exec: Func<Exec>;
 export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec;
-export type Error = ['error', (_: string) => void];
+export type Error = ['error', (message: string) => void];
 export declare const error: Func<Error>;
-export type Log = ['log', (_: string) => void];
+export type Log = ['log', (message: string) => void];
 export declare const log: Func<Log>;
 export type Console = Log | Error;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
@@ -72,10 +68,10 @@ export type ServerResponse = {
     readonly body: Vec;
 };
 export type RequestListener<O extends Operation> = (_: IncomingMessage) => Effect<O, ServerResponse>;
-export type CreateServer = ['createServer', (_: RequestListener<Operation>) => Server];
+export type CreateServer = ['createServer', (listener: RequestListener<Operation>) => Server];
 export declare const createServer: <O extends Operation>(listener: RequestListener<O>) => Effect<O | CreateServer, Server>;
-export type Listen = ['listen', (_: readonly [Server, number]) => void];
-export declare const listen: RestFunc<Listen>;
+export type Listen = ['listen', (server: Server, port: number) => void];
+export declare const listen: Func<Listen>;
 export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;

package/fs/types/effects/node/module.f.js

@@ -1,4 +1,4 @@
-import { doRest, do_ } from "../module.f.js";
+import { do_ } from "../module.f.js";
 const doAll = do_('all');
 /**
  * To run the operation `O` should be known by the runner/engine.
@@ -7,17 +7,17 @@ const doAll = do_('all');
  * @param a
  * @returns
  */
-export const all = (...a) => doAll(a);
+export const all = (...a) => doAll(...a);
 export const both = (a) => (b) => all(a, b);
 export const fetch = do_('fetch');
-export const mkdir = doRest('mkdir');
+export const mkdir = do_('mkdir');
 export const readFile = do_('readFile');
-export const readdir = doRest('readdir');
-export const writeFile = doRest('writeFile');
+export const readdir = do_('readdir');
+export const writeFile = do_('writeFile');
 export const rm = do_('rm');
-export const exec = doRest('exec');
+export const exec = do_('exec');
 export const error = do_('error');
 export const log = do_('log');
 export const createServer = do_('createServer');
-export const listen = doRest('listen');
+export const listen = do_('listen');
 export const forever = do_('forever');

package/fs/types/effects/node/test.f.js

@@ -24,7 +24,7 @@ export default {
             if (cmd !== 'readFile') {
                 throw cmd;
             }
-            if (p !== 'hello') {
+            if (p[0] !== 'hello') {
                 throw p;
             }
             e = cont(['ok', vec8(0x15n)]);

package/fs/types/effects/node/virtual/module.f.js

@@ -111,7 +111,7 @@ const rm = operation((dir, path) => {
 });
 const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name]}${payload}\n` }, undefined];
 const map = {
-    all: (state, a) => {
+    all: (state, ...a) => {
         let e = [];
         for (const i of a) {
             const [ns, ei] = virtual(state)(i);
@@ -126,11 +126,11 @@ const map = {
         const result = state.internet[url];
         return result === undefined ? [state, error('not found')] : [state, ok(result)];
     },
-    mkdir: (state, [path, p]) => mkdir(p !== undefined)(state, path),
+    mkdir: (state, path, p) => mkdir(p !== undefined)(state, path),
     readFile,
-    readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
-    writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
-    rm: (state, path) => rm(state, path),
+    readdir: (state, path, { recursive }) => readdir(path, recursive === true)(state, path),
+    writeFile: (state, path, payload) => writeFile(payload)(state, path),
+    rm,
     exec: todo,
     createServer: todo,
     listen: todo,

package/fs/types/rtti/module.f.d.ts

@@ -63,14 +63,10 @@ export type Or<T extends readonly Type[]> = () => readonly ['or', ...T];
 /**
  * Constructs a schema that validates a value matching any of the given schemas.
  *
- * The resulting `or` is normalized at construction time:
- * - nested `or` thunks are flattened into the outer union,
- * - any `unknown` variant collapses the whole union to `unknown`,
- * - primitive consts subsumed by a matching primitive thunk are dropped
- *   (e.g. `or(42, number)` → `or(number)`),
- * - duplicate variants are deduplicated via `Object.is`.
- *
- * See `issues/130-or-optimization.md`.
+ * `or` is intentionally a lazy, allocation-free constructor: it captures its
+ * arguments in a thunk and does no flattening, deduplication, subset analysis,
+ * or canonical-form work. All such algebra lives on the serializable data form
+ * — see `issues/143-rtti-data.md`.
  */
 export declare const or: <T extends readonly Type[]>(...types: T) => Or<T>;
 /** Constructs a schema that validates a value matching `T` or `undefined`. */

package/fs/types/rtti/module.f.js

@@ -19,81 +19,15 @@ const type1 = (key) => t => () => [key, t];
 export const array = type1('array');
 /** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
 export const record = type1('record');
-/** Reads the tag of a thunk variant, or returns `null` for a `Const`. */
-const variantTag = (t) => typeof t === 'function' ? t()[0] : null;
-const isPrim0 = includes(primitive0List);
-const flattenStep = ([visited, out], t) => {
-    if (typeof t === 'function' && !visited.has(t)) {
-        const nextVisited = new Set([...visited, t]);
-        const info = t();
-        if (info[0] === 'or') {
-            const [v, inner] = info.slice(1)
-                .reduce(flattenStep, [nextVisited, []]);
-            return [v, [...out, ...inner]];
-        }
-        return [nextVisited, [...out, t]];
-    }
-    return [visited, [...out, t]];
-};
-/**
- * Walks `types` and produces a flat list of `or` variants:
- *
- * - Variants whose thunk resolves to `['or', ...]` are inlined.
- * - Each thunk is resolved at most once; thunks reached a second time are
- *   kept as-is, so self-referential `or` schemas terminate.
- */
-const flattenOr = (types) => types.reduce(flattenStep, [new Set(), []])[1];
-const collectStep = ([u, p], t) => {
-    if (u) {
-        return [u, p];
-    }
-    const tag = variantTag(t);
-    if (tag === 'unknown') {
-        return [true, p];
-    }
-    return tag !== null && isPrim0(tag) ? [u, new Set([...p, tag])] : [u, p];
-};
-const dedupStep = ([primThunks, acc], t) => primThunks.has(typeof t) || acc.some(r => Object.is(r, t))
-    ? [primThunks, acc]
-    : [primThunks, [...acc, t]];
-/**
- * Drops variants that are trivially subsumed by another variant.
- *
- * Trivial subset rules handled here:
- * - any variant ⊆ `unknown` — if `unknown` is present, the entire union is
- *   `unknown`.
- * - a primitive const ⊆ its primitive type thunk — `42 ⊆ number`,
- *   `'hi' ⊆ string`, `true ⊆ boolean`, `7n ⊆ bigint`.
- *
- * `Object.is` is used for deduplication, so `NaN` collapses with itself and
- * `+0` and `-0` stay distinct — matching `constPrimitiveValidate`.
- *
- * Full structural subset (tuples/structs/`or`/recursive schemas) is left to
- * a future change — see goals 1 and 3 of issue 130.
- */
-const reduceOr = (types) => {
-    const flat = flattenOr(types);
-    const [hasUnknown, primThunks] = flat.reduce(collectStep, [false, new Set()]);
-    return hasUnknown
-        ? [unknown]
-        : flat.reduce(dedupStep, [primThunks, []])[1];
-};
 /**
  * Constructs a schema that validates a value matching any of the given schemas.
  *
- * The resulting `or` is normalized at construction time:
- * - nested `or` thunks are flattened into the outer union,
- * - any `unknown` variant collapses the whole union to `unknown`,
- * - primitive consts subsumed by a matching primitive thunk are dropped
- *   (e.g. `or(42, number)` → `or(number)`),
- * - duplicate variants are deduplicated via `Object.is`.
- *
- * See `issues/130-or-optimization.md`.
+ * `or` is intentionally a lazy, allocation-free constructor: it captures its
+ * arguments in a thunk and does no flattening, deduplication, subset analysis,
+ * or canonical-form work. All such algebra lives on the serializable data form
+ * — see `issues/143-rtti-data.md`.
  */
-export const or = (...types) => {
-    const reduced = reduceOr(types);
-    return (() => ['or', ...reduced]);
-};
+export const or = (...types) => () => ['or', ...types];
 /** Constructs a schema that validates a value matching `T` or `undefined`. */
 export const option = (t) => or(t, undefined);
 /** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */

package/fs/types/rtti/test.f.d.ts

@@ -2,33 +2,5 @@ declare const _default: {
     typeof: {
         [k: string]: (() => void)[];
     };
-    or: {
-        flatten: {
-            shallow: () => void;
-            deep: () => void;
-            manualOrThunk: () => void;
-            selfReferential: () => void;
-        };
-        unknownCollapse: {
-            withConst: () => void;
-            withThunk: () => void;
-            nested: () => void;
-        };
-        dropPrimitiveSubset: {
-            number: () => void;
-            boolean: () => void;
-            string: () => void;
-            bigint: () => void;
-            keepIfThunkAbsent: () => void;
-            mixed: () => void;
-        };
-        dedup: {
-            sameThunkReference: () => void;
-            samePrimitive: () => void;
-            nanCollapses: () => void;
-            signedZeroDistinct: () => void;
-        };
-        emptyStillNever: () => void;
-    };
 };
 export default _default;

package/fs/types/rtti/test.f.js

@@ -1,5 +1,3 @@
-import { boolean, number, string, bigint, unknown, or, never } from "./module.f.js";
-import { assertEq } from "../../dev/module.f.js";
 const tests = {
     undefined: [undefined],
     boolean: [true, false],
@@ -9,115 +7,10 @@ const tests = {
     object: [null, {}, []],
     function: [() => undefined]
 };
-const variantsOf = (t) => {
-    if (typeof t !== 'function') {
-        throw 'expected an or thunk';
-    }
-    const info = t();
-    if (info[0] !== 'or') {
-        throw `expected an or thunk, got ${info[0]}`;
-    }
-    return info.slice(1);
-};
 export default {
     typeof: Object.fromEntries(Object.entries(tests).map(([k, a]) => [k, a.map(v => () => {
             if (typeof v !== k) {
                 throw `typeof ${v} !== ${k}`;
             }
         })])),
-    or: {
-        flatten: {
-            shallow: () => {
-                const v = variantsOf(or(or(boolean, number), string));
-                assertEq(v.length, 3);
-                assertEq(v[0], boolean);
-                assertEq(v[1], number);
-                assertEq(v[2], string);
-            },
-            deep: () => {
-                assertEq(variantsOf(or(or(or(boolean, number), string), bigint)).length, 4);
-            },
-            manualOrThunk: () => {
-                // Manually-constructed `() => ['or', ...]` thunks should also flatten.
-                const inner = () => ['or', boolean, number];
-                assertEq(variantsOf(or(inner, string)).length, 3);
-            },
-            selfReferential: () => {
-                // A self-referential `or` thunk terminates: it is expanded once,
-                // then kept as-is on the second encounter (via the visited set).
-                const t = (() => ['or', boolean, t]);
-                // expansion: t -> [boolean, t]; t (second) kept as-is; number kept.
-                assertEq(variantsOf(or(t, number)).length, 3);
-            },
-        },
-        unknownCollapse: {
-            withConst: () => {
-                const v = variantsOf(or(unknown, 42));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-            withThunk: () => {
-                const v = variantsOf(or(number, unknown, string));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-            nested: () => {
-                // nested `or` whose flattening surfaces an `unknown`
-                const v = variantsOf(or(or(boolean, unknown), 42));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-        },
-        dropPrimitiveSubset: {
-            number: () => {
-                const v = variantsOf(or(42, number));
-                assertEq(v.length, 1);
-                assertEq(v[0], number);
-            },
-            boolean: () => {
-                const v = variantsOf(or(true, false, boolean));
-                assertEq(v.length, 1);
-                assertEq(v[0], boolean);
-            },
-            string: () => {
-                const v = variantsOf(or('hi', 'bye', string));
-                assertEq(v.length, 1);
-                assertEq(v[0], string);
-            },
-            bigint: () => {
-                const v = variantsOf(or(7n, bigint));
-                assertEq(v.length, 1);
-                assertEq(v[0], bigint);
-            },
-            keepIfThunkAbsent: () => {
-                // Without a matching primitive thunk, consts are kept.
-                assertEq(variantsOf(or(42, 'hello')).length, 2);
-            },
-            mixed: () => {
-                // `null`/`undefined` consts have no matching primitive thunk and remain.
-                assertEq(variantsOf(or(null, undefined, 42, number)).length, 3);
-            },
-        },
-        dedup: {
-            sameThunkReference: () => {
-                assertEq(variantsOf(or(boolean, boolean)).length, 1);
-            },
-            samePrimitive: () => {
-                assertEq(variantsOf(or(42, 42)).length, 1);
-            },
-            nanCollapses: () => {
-                // `Object.is(NaN, NaN)` is true, so duplicate `NaN` variants
-                // collapse — matching `constPrimitiveValidate` semantics.
-                assertEq(variantsOf(or(NaN, NaN)).length, 1);
-            },
-            signedZeroDistinct: () => {
-                // `Object.is(+0, -0)` is false, so they remain distinct.
-                assertEq(variantsOf(or(0, -0)).length, 2);
-            },
-        },
-        emptyStillNever: () => {
-            assertEq(variantsOf(or()).length, 0);
-            assertEq(variantsOf(never).length, 0);
-        },
-    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.14.8",
+  "version": "0.15.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -18,7 +18,7 @@
     "website": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "bin": {
     "fjs": "fs/fjs/module.js"