functionalscript 0.13.1 → 0.14.1

package/{types → fs/types}/rtti/validate/module.f.js

@@ -1,41 +1,42 @@
-import { isTag1 } from "../module.f.js";
+import {} from "../module.f.js";
 import { error, ok } from "../../result/module.f.js";
 import { isArray as commonIsArray } from "../../array/module.f.js";
 import { isObject as commonIsObject } from "../../object/module.f.js";
-import { identity } from "../../function/module.f.js";
+/** Builds an error result with empty path and the given message. */
+export const verror = (message) => error({ path: [], message });
+/** Prepends `key` to the error's path, used to build the path bottom-up. */
+export const prependPath = (key, r) => error({ path: [key, ...r[1].path], message: r[1].message });
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
  * non-empty) to avoid infinite recursion with recursive schemas.
  */
-const containerValidate = (isContainer, getItems) => (item) => value => {
+const containerValidate = (isContainer, getEntries) => (item) => value => {
     if (!isContainer(value)) {
-        return error('unexpected value');
+        return verror('unexpected value');
     }
-    const items = getItems(value);
-    if (items.length === 0) {
+    const entries = getEntries(value);
+    if (entries.length === 0) {
         return ok(value);
     }
-    // Note: we shouldn't instantiate `itemValidate` until we make sure `items` is not empty.
+    // Note: we shouldn't instantiate `itemValidate` until we make sure `entries` is not empty.
     //       Otherwise, we can get infinite recursion on empty arrays and objects
     const itemValidate = validate(item);
-    for (const i of items) {
-        const r = itemValidate(i);
+    for (const [k, v] of entries) {
+        const r = itemValidate(v);
         if (r[0] === 'error') {
-            return r;
+            return prependPath(k, r);
         }
     }
     return ok(value);
 };
 const isArray = value => commonIsArray(value);
-const arrayValidate = containerValidate(isArray, identity);
+const arrayEntries = (value) => value.map((v, i) => [String(i), v]);
+const arrayValidate = containerValidate(isArray, arrayEntries);
 const isObject = value => commonIsObject(value);
-const recordValidate = containerValidate(isObject, Object.values);
-const tag1Validate = ([tag, item]) => tag === 'array'
-    ? arrayValidate(item)
-    : recordValidate(item);
+const recordValidate = containerValidate(isObject, Object.entries);
 /** Validates a `Tag0` primitive schema using `typeof`. */
-const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : error('unexpected value');
+export const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : verror('unexpected value');
 /**
  * Builds a validator for `Tuple` or `Struct` const schemas.
  * Iterates over the schema's entries and validates each corresponding
@@ -43,13 +44,13 @@ const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) :
  */
 const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
     if (!isContainer(value)) {
-        return error('unexpected value');
+        return verror('unexpected value');
     }
     for (const [k, v] of Object.entries(rtti)) {
         const item = getItem(value, k);
         const r = validate(v)(item);
         if (r[0] === 'error') {
-            return r;
+            return prependPath(k, r);
         }
     }
     return ok(value);
@@ -59,10 +60,16 @@ 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 (`===`). */
-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)
-    : error('unexpected value');
+    : verror('unexpected value');
 const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
     ? constObjectValidate(rtti)
     : constPrimitiveValidate(rtti);
@@ -75,7 +82,7 @@ const orValidate = (rtti) => {
                 return r;
             }
         }
-        return error('no match');
+        return verror('no match');
     };
 };
 /**
@@ -84,13 +91,14 @@ const orValidate = (rtti) => {
  * @param rtti - A schema `Type`: a `Thunk` for tag-based schemas, or a `Const`
  *   (primitive literal, tuple, or struct) for exact-value schemas.
  * @returns A `Validate<T>` function that checks an unknown value and returns
- *   `['ok', value]` or `['error', message]`.
+ *   `['ok', value]` or `['error', { path, message }]`.
  *
  * @example
  * ```ts
  * const v = validate(array(number))
- * v([1, 2, 3])   // ['ok', [1, 2, 3]]
- * v(['a', 'b'])  // ['error', 'unexpected value']
+ * v([1, 2, 3])         // ['ok', [1, 2, 3]]
+ * v([1, 'two'])        // ['error', { path: ['1'], message: 'unexpected value' }]
+ * v(['a'])             // ['error', { path: ['0'], message: 'unexpected value' }]
  * ```
  */
 export const validate = (rtti) => {

package/{types → 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;
@@ -86,6 +98,17 @@ declare const _default: {
         ok: () => void;
         error: () => void;
     };
+    path: {
+        rootMismatch: () => void;
+        arrayIndex: () => void;
+        recordKey: () => void;
+        nestedArray: () => void;
+        tupleIndex: () => void;
+        structKey: () => void;
+        deepStruct: () => void;
+        recursiveSchema: () => void;
+        orRoot: () => void;
+    };
     recursive: {
         arrayOfArrays: () => void;
         recordOfRecords: () => void;

package/{types → fs/types}/rtti/validate/test.f.js

@@ -6,6 +6,20 @@ const assertOk = ([k]) => { if (k !== 'ok') {
 const assertError = ([k]) => { if (k !== 'error') {
     throw 'expected error';
 } };
+const assertErrorPath = (expected) => (r) => {
+    if (r[0] !== 'error') {
+        throw 'expected error';
+    }
+    const e = r[1];
+    if (e.path.length !== expected.length) {
+        throw `path length ${e.path.length} != ${expected.length}`;
+    }
+    for (let i = 0; i < expected.length; i++) {
+        if (e.path[i] !== expected[i]) {
+            throw `path[${i}] ${e.path[i]} != ${expected[i]}`;
+        }
+    }
+};
 export default {
     boolean: {
         ok: () => {
@@ -77,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'));
@@ -207,6 +250,30 @@ export default {
             assertError(validate(t)('42'));
         },
     },
+    path: {
+        rootMismatch: () => assertErrorPath([])(validate(number)('not a number')),
+        arrayIndex: () => assertErrorPath(['1'])(validate(array(number))([1, 'two', 3])),
+        recordKey: () => {
+            const r = validate(record(number))({ a: 1, b: 'two', c: 3 });
+            // record iteration order matches Object.entries; 'b' is the failing key
+            assertErrorPath(['b'])(r);
+        },
+        nestedArray: () => assertErrorPath(['0', '1'])(validate(array(array(number)))([[1, 'x'], [2, 3]])),
+        tupleIndex: () => assertErrorPath(['1'])(validate([number, number])([1, 'two'])),
+        structKey: () => assertErrorPath(['b'])(validate({ a: number, b: number })({ a: 1, b: 'two' })),
+        deepStruct: () => {
+            const schema = { user: { name: string, age: number } };
+            const r = validate(schema)({ user: { name: 'A', age: 'old' } });
+            assertErrorPath(['user', 'age'])(r);
+        },
+        recursiveSchema: () => {
+            const list = () => ['array', list];
+            // [[[42]]] — innermost element 42 is a number, not an array
+            const r = validate(list)([[[42]]]);
+            assertErrorPath(['0', '0', '0'])(r);
+        },
+        orRoot: () => assertErrorPath([])(validate(or(number, string))(true)),
+    },
     recursive: {
         arrayOfArrays: () => {
             // self-referential schema: an array whose elements are also arrays of the same type

package/{types → fs/types}/uint8array/module.f.d.ts

@@ -1,5 +1,5 @@
-import { type Vec } from "../bit_vec/module.f.ts";
-import { type List } from "../list/module.f.ts";
+import { type Vec } from '../bit_vec/module.f.ts';
+import { type List } from '../list/module.f.ts';
 /**
  * Converts a Uint8Array into an MSB-first bit vector.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "type": "module",
   "files": [
     "**/*.js",
@@ -11,18 +11,18 @@
     "prepack": "tsc --NoEmit false",
     "test20": "npm run prepack && node --test",
     "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
-    "index": "node ./fjs/module.ts r ./dev/index/module.f.ts",
-    "fst": "node ./fjs/module.ts t",
-    "start": "node ./fjs/module.ts",
-    "ci-update": "node ./fjs/module.ts r ./ci/module.f.ts",
-    "update": "git clean -fdx && npm install && npm run index && npm run ci-update",
-    "website": "node --experimental-strip-types ./fjs/module.ts r ./website/module.f.ts"
+    "index": "node ./fs/fjs/module.ts r ./fs/dev/index/module.f.ts",
+    "fst": "node ./fs/fjs/module.ts t",
+    "start": "node ./fs/fjs/module.ts",
+    "ci-update": "node ./fs/fjs/module.ts r ./fs/ci/module.f.ts",
+    "update": "npm install && npm run index && npm run ci-update",
+    "website": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts"
   },
   "engines": {
     "node": ">=20"
   },
   "bin": {
-    "fjs": "fjs/module.js"
+    "fjs": "fs/fjs/module.js"
   },
   "repository": {
     "type": "git",

package/ci/module.f.js

@@ -1,183 +0,0 @@
-/**
- * Continuous integration helper commands for repository automation tasks.
- *
- * @module
- */
-import { utf8 } from "../text/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
-const os = ['ubuntu', 'macos', 'windows'];
-const architecture = ['intel', 'arm'];
-// https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
-const images = {
-    ubuntu: {
-        intel: 'ubuntu-24.04',
-        arm: 'ubuntu-24.04-arm'
-    },
-    macos: {
-        intel: 'macos-26-intel',
-        arm: 'macos-26'
-    },
-    windows: {
-        intel: 'windows-2025',
-        arm: 'windows-11-arm',
-    }
-};
-const install = (step) => ({ type: 'install', step });
-const test = (step) => ({ type: 'test', step });
-const installOnWindowsArm = ({ def, name, path }) => (v) => (a) => install(v === 'windows' && a === 'arm'
-    ? { run: `irm ${path}/install.ps1 | iex; "$env:USERPROFILE\\.${name}\\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append` }
-    : def);
-const installBun = installOnWindowsArm({
-    def: { uses: 'oven-sh/setup-bun@v1' },
-    name: 'bun',
-    path: 'bun.sh'
-});
-const installDeno = install({ uses: 'denoland/setup-deno@v2', with: { 'deno-version': '2' } });
-const cargoTest = (target, config) => {
-    const to = target ? ` --target ${target}` : '';
-    const co = config ? ` --config ${config}` : '';
-    const main = `cargo test${to}${co}`;
-    return [
-        test({ run: main }),
-        test({ run: `${main} --release` })
-    ];
-};
-const customTarget = (target) => [
-    { type: 'rust', target },
-    ...cargoTest(target)
-];
-const wasmTarget = (target) => [
-    ...customTarget(target),
-    ...cargoTest(target, '.cargo/config.wasmer.toml')
-];
-const clean = (steps) => [
-    ...steps,
-    test({ run: 'git reset --hard HEAD && git clean -fdx' })
-];
-const installNode = (version) => ({ uses: 'actions/setup-node@v6', with: { 'node-version': version } });
-const basicNode = (version) => (extra) => clean([
-    install(installNode(version)),
-    test({ run: 'npm ci' }),
-    ...extra,
-]);
-const node = (version) => (extra) => basicNode(version)([
-    test({ run: 'npm test' }),
-    test({ run: 'npm run fst' }),
-    ...extra,
-]);
-const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
-const playwrightVersion = '1.58.2';
-const playwrightAndVersion = `playwright@${playwrightVersion}`;
-const rustToolchain = '1.95.0';
-const toSteps = (m) => {
-    const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
-    const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');
-    const rust = m.find(v => v.type === 'rust') !== undefined;
-    const targets = m.flatMap(v => v.type === 'rust' && v.target !== undefined ? [v.target] : []).join(',');
-    return [
-        ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
-        ...(rust ? [{
-                uses: `dtolnay/rust-toolchain@${rustToolchain}`,
-                with: {
-                    components: 'rustfmt,clippy',
-                    targets
-                }
-            }] : []),
-        ...filter('install'),
-        { uses: 'actions/checkout@v5' },
-        ...filter('test'),
-    ];
-};
-const nodes = ['20', '22', '25'];
-const nodeTest = (v) => v === '20' ? 'run test20' : 'test';
-const nodeSteps = (v) => [
-    install(installNode(v)),
-    test({ run: 'npm ci' }),
-    test({ run: `npm ${nodeTest(v)}` }),
-];
-const ubuntu = (ms) => ({
-    'runs-on': 'ubuntu-24.04',
-    steps: toSteps(ms)
-});
-const nodeVersions = Object.fromEntries(nodes.map(v => [`node${v}`, ubuntu(nodeSteps(v))]));
-const defaultNodeVersion = '24';
-const playwright = ubuntu(basicNode(defaultNodeVersion)([
-    //install({ uses: 'actions/cache@v4', with: { path: '~/.cache/ms-playwright', key: `${images.ubuntu.intel}-${playwrightAndVersion}` } }),
-    install({ run: `npm install -g ${playwrightAndVersion}` }),
-    install({ run: 'playwright install --with-deps' }),
-    // we have to use `npx` to make sure that we respect `@playwright/test` version from
-    // the `package.json`.
-    ...['chromium', 'firefox', 'webkit'].map(browser => test({ run: `npx playwright test --browser=${browser}` })),
-]));
-const i686 = (a, v) => {
-    if (a === 'intel') {
-        switch (v) {
-            case 'windows': return customTarget('i686-pc-windows-msvc');
-            case 'ubuntu': return [
-                { type: 'apt-get', package: 'libc6-dev-i386' },
-                ...customTarget('i686-unknown-linux-gnu'),
-            ];
-        }
-    }
-    return [];
-};
-const job = (v) => (a) => {
-    const id = `${v}-${a}`;
-    const image = images[v][a];
-    const result = [
-        // Rust
-        test({ run: 'cargo fmt -- --check' }),
-        test({ run: 'cargo clippy -- -D warnings' }),
-        ...cargoTest(),
-        install({ uses: 'bytecodealliance/actions/wasmtime/setup@v1' }),
-        install({ uses: 'wasmerio/setup-wasmer@v1' }),
-        ...wasmTarget('wasm32-wasip1'),
-        ...wasmTarget('wasm32-wasip2'),
-        ...wasmTarget('wasm32-unknown-unknown'),
-        ...wasmTarget('wasm32-wasip1-threads'),
-        ...i686(a, v),
-        // Node.js
-        ...node(defaultNodeVersion)([
-            // TypeScript Preview
-            install({ run: 'npm install -g @typescript/native-preview' }),
-            test({ run: 'tsgo' }),
-            // publishing
-            test({ run: 'npm pack' }),
-            test({ run: `npm install -g ${findTgz(v)}` }),
-            test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
-            test({ run: 'fjs t' }),
-            test({ run: 'npm uninstall functionalscript -g' }),
-        ]),
-        // Deno
-        ...clean([
-            installDeno,
-            test({ run: 'deno install' }),
-            test({ run: 'deno task test' }),
-            test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
-            test({ run: 'deno task fjs t' }),
-            test({ run: 'deno publish --dry-run' }),
-        ]),
-        // Bun
-        ...clean([
-            installBun(v)(a),
-            test({ run: 'bun test --timeout 20000' }),
-            test({ run: 'bun ./fjs/module.ts t' }),
-        ]),
-    ];
-    return [id, { 'runs-on': image, steps: toSteps(result) }];
-};
-const jobs = {
-    ...Object.fromEntries(os.flatMap(v => architecture.map(job(v)))),
-    ...nodeVersions,
-    playwright,
-};
-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;

package/dev/tf/test.f.js

@@ -1,5 +0,0 @@
-export default {
-    throw: () => {
-        throw [() => { }, () => { }];
-    }
-};

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

@@ -1,3 +0,0 @@
-import { type Effect } from "../../types/effects/module.f.ts";
-import { type All, type ReadFile, type WriteFile } from "../../types/effects/node/module.f.ts";
-export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;