functionalscript 0.14.0 → 0.14.2

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

@@ -12,9 +12,9 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
-export declare const bun = "1.3.13";
+export declare const bun = "1.3.14";
 export declare const deno = "2.7.14";
-export declare const playwright = "1.59.1";
+export declare const playwright = "1.60.0";
 export declare const rust = "1.95.0";
 export declare const node: {
     readonly default: "26.1.0";
@@ -22,4 +22,4 @@ export declare const node: {
 };
 export declare const wasmtime = "44.0.1";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260508.1";
+export declare const tsgo = "7.0.0-dev.20260512.1";

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

@@ -14,11 +14,11 @@ export const images = {
     }
 };
 // https://bun.sh/
-export const bun = '1.3.13';
+export const bun = '1.3.14';
 // https://deno.com/
 export const deno = '2.7.14';
 // https://www.npmjs.com/package/playwright
-export const playwright = '1.59.1';
+export const playwright = '1.60.0';
 // https://rust-lang.org/
 export const rust = '1.95.0';
 // https://nodejs.org/en/download
@@ -31,4 +31,4 @@ 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.20260508.1';
+export const tsgo = '7.0.0-dev.20260512.1';

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

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
 import { type NodeOp } from '../types/effects/node/module.f.ts';
-export declare const effect: Effect<NodeOp, number>;
+export declare const ci: (rust: boolean) => Effect<NodeOp, number>;
 declare const _default: () => Effect<NodeOp, number>;
 export default _default;

package/fs/ci/module.f.js

@@ -13,28 +13,31 @@ import { nodeMainSteps, nodeVersions } from "./node/module.f.js";
 import { playwrightJob } from "./playwright/module.f.js";
 import { bunSteps } from "./bun/module.f.js";
 import { denoSteps } from "./deno/module.f.js";
-const job = (v) => (a) => {
-    const id = `${v}-${a}`;
-    const image = images[v][a];
+const job = (rust) => (o) => (a) => {
+    const id = `${o}-${a}`;
+    const image = images[o][a];
     const result = [
-        ...rustSteps(a, v),
-        ...nodeMainSteps(v),
+        ...(rust ? rustSteps(o, a) : []),
+        ...nodeMainSteps(o),
         ...denoSteps,
-        ...bunSteps(v, a),
+        ...bunSteps(o, a),
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
-const jobs = {
-    ...Object.fromEntries(os.flatMap(v => architecture.map(job(v)))),
-    ...nodeVersions,
-    playwright: playwrightJob,
+export const ci = (rust) => {
+    const jobs = {
+        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust)(o)))),
+        ...nodeVersions,
+        playwright: playwrightJob,
+    };
+    const gha = {
+        name: 'CI',
+        on: { pull_request: {} },
+        jobs,
+    };
+    return begin
+        .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
+        .step(() => pure(0));
 };
-const gha = {
-    name: 'CI',
-    on: { pull_request: {} },
-    jobs,
-};
-export const effect = begin
-    .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
-    .step(() => pure(0));
-export default () => effect;
+const defaultEffect = ci(true);
+export default () => defaultEffect;

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

@@ -1,2 +1,2 @@
 import { type Architecture, type MetaStep, type Os } from '../common/module.f.ts';
-export declare const rustSteps: (a: Architecture, v: Os) => readonly MetaStep[];
+export declare const rustSteps: (v: Os, a: Architecture) => readonly MetaStep[];

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

@@ -29,7 +29,7 @@ const i686 = (a, v) => {
     }
     return [];
 };
-export const rustSteps = (a, v) => [
+export const rustSteps = (v, a) => [
     test({ run: 'cargo fmt -- --check' }),
     test({ run: 'cargo clippy -- -D warnings' }),
     ...cargoTest(),

package/fs/ci/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    rust: () => void;
+    noRust: () => void;
+};
+export default _default;

package/fs/ci/test.f.js

@@ -0,0 +1,40 @@
+import { ci } from "./module.f.js";
+import { utf8ToString } from "../text/module.f.js";
+import { isVec } from "../types/bit_vec/module.f.js";
+import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+const hasCargo = (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes('cargo')));
+const githubState = {
+    ...emptyState,
+    root: { '.github': { workflows: {} } },
+};
+const run = (rust) => {
+    const [state, result] = virtual(githubState)(ci(rust));
+    if (result !== 0) {
+        throw result;
+    }
+    const dotGithub = state.root['.github'];
+    if (dotGithub === undefined || isVec(dotGithub)) {
+        throw dotGithub;
+    }
+    const workflows = dotGithub['workflows'];
+    if (workflows === undefined || isVec(workflows)) {
+        throw workflows;
+    }
+    const file = workflows['ci.yml'];
+    if (!isVec(file)) {
+        throw file;
+    }
+    return JSON.parse(utf8ToString(file));
+};
+export default {
+    rust: () => {
+        if (!hasCargo(run(true))) {
+            throw 'expected Rust steps';
+        }
+    },
+    noRust: () => {
+        if (hasCargo(run(false))) {
+            throw 'unexpected Rust steps';
+        }
+    },
+};

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

@@ -1,54 +1,3 @@
-import { io } from "../../io/module.js";
-import { loadModuleMap } from "../module.f.js";
-import { isTest, parseTestSet } from "./module.f.js";
-import * as nodeTest from 'node:test';
-const isBun = typeof Bun !== 'undefined';
-const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
-const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
-// Bun doesn't support nested tests yet.
-const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrightFramework = async () => {
-    const pwTest = (await import('@playwright/test')).test;
-    return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
-};
-const framework = isPlaywright ? await createPlaywrightFramework() :
-    isBun ? createBunFramework(nodeTest) :
-        createFramework(nodeTest);
-const parse = parseTestSet(io.tryCatch);
-const scanModule = (x) => async (subTestRunner) => {
-    let subTests = [x];
-    while (true) {
-        const [first, ...rest] = subTests;
-        if (first === undefined) {
-            break;
-        }
-        subTests = rest;
-        //
-        const [name, value, throws] = first;
-        const set = parse(throws)(value);
-        if (typeof set === 'function') {
-            await subTestRunner(name, () => {
-                const r = set();
-                // The result of a function is walked as a fresh sub-tree;
-                // the parent's `throws` flag does not propagate into it.
-                subTests = [...subTests, [`${name}()`, r, false]];
-            });
-        }
-        else {
-            for (const [j, y] of set) {
-                const pr = `${name}/${j}`;
-                subTests = [...subTests, [pr, y, throws || j === 'throw']];
-            }
-        }
-    }
-};
-const run = async () => {
-    const x = await loadModuleMap(io);
-    for (const [i, v] of Object.entries(x)) {
-        if (isTest(i)) {
-            framework(i, scanModule(['', v.default, false]));
-        }
-    }
-};
+import { run } from "./module.js";
 // we need `await` for Playwright.
 await run();

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

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

package/fs/dev/tf/module.js

@@ -0,0 +1,52 @@
+import { io } from "../../io/module.js";
+import { loadModuleMap } from "../module.f.js";
+import { isTest, parseTestSet } from "./module.f.js";
+import * as nodeTest from 'node:test';
+const isBun = typeof Bun !== 'undefined';
+const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
+const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
+// Bun doesn't support nested tests yet.
+const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
+const createPlaywrightFramework = async () => {
+    const pwTest = (await import('@playwright/test')).test;
+    return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
+};
+const framework = isPlaywright ? await createPlaywrightFramework() :
+    isBun ? createBunFramework(nodeTest) :
+        createFramework(nodeTest);
+const parse = parseTestSet(io.tryCatch);
+const scanModule = (x) => async (subTestRunner) => {
+    let subTests = [x];
+    while (true) {
+        const [first, ...rest] = subTests;
+        if (first === undefined) {
+            break;
+        }
+        subTests = rest;
+        //
+        const [name, value, throws] = first;
+        const set = parse(throws)(value);
+        if (typeof set === 'function') {
+            await subTestRunner(name, () => {
+                const r = set();
+                // The result of a function is walked as a fresh sub-tree;
+                // the parent's `throws` flag does not propagate into it.
+                subTests = [...subTests, [`${name}()`, r, false]];
+            });
+        }
+        else {
+            for (const [j, y] of set) {
+                const pr = `${name}/${j}`;
+                subTests = [...subTests, [pr, y, throws || j === 'throw']];
+            }
+        }
+    }
+};
+export const run = async () => {
+    const x = await loadModuleMap(io);
+    for (const [i, v] of Object.entries(x)) {
+        if (isTest(i)) {
+            framework(i, scanModule(['', v.default, false]));
+        }
+    }
+};

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

@@ -60,7 +60,18 @@ export type Record<T extends Type> = Type1<'record', T>;
 export declare const record: MakeType1<'record'>;
 /** Schema type for a union of types `T`. */
 export type Or<T extends readonly Type[]> = () => readonly ['or', ...T];
-/** Constructs a schema that validates a value matching any of the given schemas. */
+/**
+ * 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`.
+ */
 export declare const or: <T extends readonly Type[]>(...types: T) => Or<T>;
 /** Constructs a schema that validates a value matching `T` or `undefined`. */
 export declare const option: <T extends Type>(t: T) => Or<readonly [T, undefined]>;

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

@@ -19,8 +19,81 @@ 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');
-/** Constructs a schema that validates a value matching any of the given schemas. */
-export const or = (...types) => () => ['or', ...types];
+/** 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`.
+ */
+export const or = (...types) => {
+    const reduced = reduceOr(types);
+    return (() => ['or', ...reduced]);
+};
 /** 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/parse/test.f.d.ts

@@ -31,6 +31,18 @@ declare const _default: {
             ok: () => void;
             error: () => void;
         };
+        nan: {
+            ok: () => void;
+            error: () => void;
+        };
+        infinity: {
+            ok: () => void;
+            error: () => void;
+        };
+        signedZero: {
+            distinct: () => void;
+            self: () => void;
+        };
         string: {
             ok: () => void;
             error: () => void;

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

@@ -120,6 +120,35 @@ export default {
             ok: () => assertOk(parse(42)(42)),
             error: () => assertError(parse(42)(43)),
         },
+        nan: {
+            ok: () => assertOk(parse(NaN)(NaN)),
+            error: () => {
+                assertError(parse(NaN)(0));
+                assertError(parse(0)(NaN));
+                assertError(parse(42)(NaN));
+            },
+        },
+        infinity: {
+            ok: () => {
+                assertOk(parse(Infinity)(Infinity));
+                assertOk(parse(-Infinity)(-Infinity));
+            },
+            error: () => {
+                assertError(parse(Infinity)(-Infinity));
+                assertError(parse(Infinity)(0));
+            },
+        },
+        signedZero: {
+            // `Object.is` distinguishes +0 and -0; `===` treats them equal.
+            distinct: () => {
+                assertError(parse(0)(-0));
+                assertError(parse(-0)(0));
+            },
+            self: () => {
+                assertOk(parse(0)(0));
+                assertOk(parse(-0)(-0));
+            },
+        },
         string: {
             ok: () => assertOk(parse('hello')('hello')),
             error: () => assertError(parse('hello')('world')),

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

@@ -2,5 +2,33 @@ 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,3 +1,5 @@
+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],
@@ -7,16 +9,115 @@ const tests = {
     object: [null, {}, []],
     function: [() => undefined]
 };
-const assertOk = ([k]) => { if (k !== 'ok') {
-    throw 'expected ok';
-} };
-const assertError = ([k]) => { if (k !== 'error') {
-    throw 'expected error';
-} };
+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/fs/types/rtti/validate/module.f.d.ts

@@ -53,7 +53,13 @@ export declare const verror: (message: string) => Error<ValidationError>;
 export declare const prependPath: (key: string, r: Error<ValidationError>) => Error<ValidationError>;
 /** Validates a `Tag0` primitive schema using `typeof`. */
 export declare const primitive0Validate: <K extends Primitive0, T extends Info0<K>>(tag: K) => Validate<T>;
-/** Validates a primitive `Const` schema using strict equality (`===`). */
+/**
+ * Validates a primitive `Const` schema using `Object.is` (SameValue).
+ *
+ * `Object.is` is used instead of `===` so that:
+ * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
+ * - `+0` and `-0` are treated as distinct const values.
+ */
 export declare const constPrimitiveValidate: <T extends Primitive>(rtti: T) => Validate<T>;
 /**
  * Creates a validator function for the given RTTI schema.

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

@@ -60,8 +60,14 @@ const structValidate = constContainerValidate(isObject, (value, k) => value[k]);
 const constObjectValidate = (rtti) => commonIsArray(rtti)
     ? tupleValidate(rtti)
     : structValidate(rtti);
-/** Validates a primitive `Const` schema using strict equality (`===`). */
-export const constPrimitiveValidate = (rtti) => value => rtti === value
+/**
+ * Validates a primitive `Const` schema using `Object.is` (SameValue).
+ *
+ * `Object.is` is used instead of `===` so that:
+ * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
+ * - `+0` and `-0` are treated as distinct const values.
+ */
+export const constPrimitiveValidate = (rtti) => value => Object.is(rtti, value)
     ? ok(value)
     : verror('unexpected value');
 const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null

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

@@ -31,6 +31,18 @@ declare const _default: {
             ok: () => void;
             error: () => void;
         };
+        nan: {
+            ok: () => void;
+            error: () => void;
+        };
+        infinity: {
+            ok: () => void;
+            error: () => void;
+        };
+        signedZero: {
+            distinct: () => void;
+            self: () => void;
+        };
         string: {
             ok: () => void;
             error: () => void;

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

@@ -91,6 +91,35 @@ export default {
             },
             error: () => assertError(validate(42)(43)),
         },
+        nan: {
+            ok: () => assertOk(validate(NaN)(NaN)),
+            error: () => {
+                assertError(validate(NaN)(0));
+                assertError(validate(0)(NaN));
+                assertError(validate(42)(NaN));
+            },
+        },
+        infinity: {
+            ok: () => {
+                assertOk(validate(Infinity)(Infinity));
+                assertOk(validate(-Infinity)(-Infinity));
+            },
+            error: () => {
+                assertError(validate(Infinity)(-Infinity));
+                assertError(validate(Infinity)(0));
+            },
+        },
+        signedZero: {
+            // `Object.is` distinguishes +0 and -0; `===` treats them equal.
+            distinct: () => {
+                assertError(validate(0)(-0));
+                assertError(validate(-0)(0));
+            },
+            self: () => {
+                assertOk(validate(0)(0));
+                assertOk(validate(-0)(-0));
+            },
+        },
         string: {
             ok: () => {
                 assertOk(validate('hello')('hello'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "files": [
     "**/*.js",