functionalscript 0.15.0 → 0.16.0

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

@@ -1,30 +1,63 @@
 import { images } from '../config/module.f.ts';
+import { type Ts } from '../../types/rtti/ts/module.f.ts';
 export declare const os: readonly ["ubuntu", "macos", "windows"];
 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];
-export type Step = {
-    readonly run?: string;
-    readonly uses?: string;
-    readonly with?: {
-        readonly [k: string]: string;
-    };
-};
-export type Job = {
-    readonly 'runs-on': Image;
-    readonly steps: readonly Step[];
+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]>;
 };
-export type Jobs = {
-    readonly [jobs: string]: Job;
+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]>;
+        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]>;
+    }>;
 };
-export type GitHubAction = {
-    readonly name: string;
+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]>;
+        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 gitHubActionSchema: {
+    readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
-        readonly pull_request?: {};
+        readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
-    readonly jobs: Jobs;
+    readonly jobs: 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]>;
+            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]>;
+        }>;
+    }>;
 };
+export type Step = Ts<typeof stepSchema>;
+export type Job = Ts<typeof jobSchema>;
+export type Jobs = Ts<typeof jobsSchema>;
+export type GitHubAction = Ts<typeof gitHubActionSchema>;
+export declare const parseGitHubAction: import("../../types/rtti/parse/module.f.ts").Parse<{
+    readonly name: import("../../types/rtti/module.f.ts").String;
+    readonly on: {
+        readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+    };
+    readonly jobs: 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]>;
+            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]>;
+        }>;
+    }>;
+}>;
 export type StepType = 'install' | 'test';
 export type MetaStep = {
     readonly type: StepType;
@@ -42,3 +75,4 @@ 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

@@ -1,6 +1,25 @@
 import { images, rust } from "../config/module.f.js";
+import { option, array, record, string } from "../../types/rtti/module.f.js";
+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 = {
+    run: option(string),
+    uses: option(string),
+    with: option(record(string))
+};
+const jobSchema = {
+    'runs-on': string,
+    steps: array(stepSchema)
+};
+const jobsSchema = record(jobSchema);
+const gitHubActionSchema = {
+    name: string,
+    on: { pull_request: option({}) },
+    jobs: jobsSchema
+};
+export const parseGitHubAction = rttiParse(gitHubActionSchema);
 export const install = (step) => ({ type: 'install', step });
 export const test = (step) => ({ type: 'test', step });
 export const clean = (steps) => [

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

@@ -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.20260515.1";
+export declare const tsgo = "7.0.0-dev.20260517.1";

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

@@ -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.20260515.1';
+export const tsgo = '7.0.0-dev.20260517.1';

package/fs/ci/module.f.js

@@ -51,7 +51,7 @@ const defaultEffect = ci({
     denoExtra: [
         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' }),
+        test({ run: 'deno publish --dry-run --allow-slow-types' }),
     ],
     bunExtra: [
         test({ run: 'bun ./fs/fjs/module.ts t' }),

package/fs/ci/test.f.js

@@ -1,9 +1,13 @@
 import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
-import { test } from "./common/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 = {
@@ -19,7 +23,7 @@ const run = (rust, nodeExtra = () => []) => {
     assert(workflows !== undefined && !isVec(workflows), workflows);
     const file = workflows['ci.yml'];
     assert(isVec(file), file);
-    return JSON.parse(utf8ToString(file));
+    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
 };
 export default {
     rust: () => {

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

@@ -17,6 +17,6 @@ export type ModuleMap = {
     readonly [k in string]: Module;
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
-export declare const allFiles2: (s: string) => Effect<Readdir | All, readonly string[]>;
+export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -5,10 +5,13 @@
  */
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
-import { all, both, readdir, readFile, writeFile } from "../types/effects/node/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";
 import { unwrap } from "../types/result/module.f.js";
 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";
 export const todo = () => { throw 'not implemented'; };
 export const assert = (v, msg = 'assertion failed') => {
     if (!v)
@@ -22,7 +25,7 @@ export const env = ({ process: { env } }) => a => {
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles2 = (s) => {
+export const allFiles = (s) => {
     const load = (p) => begin
         .step(() => readdir(p, {}))
         .step(d => {
@@ -49,28 +52,34 @@ export const allFiles2 = (s) => {
         .step(v => pure(v.flat()));
     return load(s);
 };
-const allFiles = (io) => (s) => fromIo(io)(allFiles2(s));
+const loadFile = (f) => {
+    const doImport = import_(f).step(r => pure([[f, unwrap(r)]]));
+    if (f.endsWith('.f.js')) {
+        return doImport;
+    }
+    if (f.endsWith('.f.ts')) {
+        return access(f.substring(0, f.length - 3) + '.js')
+            .step(r => r[0] === 'ok' ? pure([]) : doImport);
+    }
+    return pure([]);
+};
 export const loadModuleMap = async (io) => {
-    const { fs: { existsSync }, asyncImport } = io;
-    let map = [];
-    const initCwd = env(io)('INIT_CWD');
+    const { process: { env } } = io;
+    const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
-    for (const f of await allFiles(io)(s)) {
-        if (f.endsWith('.f.js') ||
-            (f.endsWith('.f.ts') && !existsSync(f.substring(0, f.length - 3) + '.js'))) {
-            const source = await asyncImport(f);
-            map = [...map, [f, source]];
-        }
-    }
-    return Object.fromEntries(map.toSorted(cmp));
+    const effect = allFiles(s)
+        .step(files => all(...files.map(loadFile)))
+        .step(entries => pure(Object.fromEntries(entries.flat().toSorted(cmp))));
+    return fromIo(io)(effect);
 };
 const denoJson = './deno.json';
+const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = begin
     .step(() => updateVersion)
     .step(() => readFile(denoJson))
-    .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))));
+    .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
 const allFiles2aa = begin
-    .step(() => allFiles2('.'))
+    .step(() => allFiles('.'))
     .step(files => {
     const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);

package/fs/fjs/module.f.js

@@ -9,7 +9,9 @@ import { main as testMain } from "../dev/tf/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
 export const main = async (io) => {
     const { error } = io.console;
-    const [command, ...rest] = io.process.argv.slice(2);
+    const { process, asyncImport } = io;
+    const { env } = process;
+    const [command, ...rest] = process.argv.slice(2);
     const eRun = fromIo(io);
     switch (command) {
         case 'test':
@@ -24,8 +26,8 @@ export const main = async (io) => {
         case 'run':
         case 'r':
             const [file, ...args] = rest;
-            const m = await io.asyncImport(file);
-            return eRun(m.default(args));
+            const m = await asyncImport(file);
+            return eRun(m.default(args, env));
         case undefined:
             error('Error: command is required');
             return Promise.resolve(1);

package/fs/io/module.d.ts

@@ -1,5 +1,5 @@
-import { type Io, type Module, type Run } from './module.f.ts';
-import type { NodeProgram } from '../types/effects/node/module.f.ts';
+import { type Io, type Run } from './module.f.ts';
+import type { Module, NodeProgram } from '../types/effects/node/module.f.ts';
 export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const io: Io;
 export declare const legacyRun: Run;

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

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, NodeOp } from '../types/effects/node/module.f.ts';
+import type { Headers, Module, NodeOp, Env } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -31,7 +31,6 @@ export type Fs = {
     readonly writeSync: (fd: number, s: string) => void;
     readonly writeFileSync: (file: string, data: Uint8Array) => void;
     readonly readFileSync: (path: string) => Uint8Array | null;
-    readonly existsSync: (path: string) => boolean;
     readonly promises: {
         readonly readFile: (path: string) => Promise<Uint8Array>;
         readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
@@ -39,6 +38,7 @@ export type Fs = {
         readonly rm: (path: string, options?: RmOptions) => Promise<void>;
         readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
         readonly copyFile: (src: string, dest: string) => Promise<void>;
+        readonly access: (path: string) => Promise<void>;
     };
 };
 /**
@@ -49,12 +49,6 @@ export type Console = {
     readonly log: (...d: unknown[]) => void;
     readonly error: (...d: unknown[]) => void;
 };
-/**
- * Represents an ES module with a default export
- */
-export type Module = {
-    readonly default: unknown;
-};
 /**
  * High-resolution time measurement interface
  * @see https://nodejs.org/api/perf_hooks.html#performance-now
@@ -118,12 +112,6 @@ export type Io = {
     readonly http: Http;
     readonly childProcess: ChildProcess;
 };
-/**
- * The environment variables.
- */
-export type Env = {
-    readonly [k: string]: string | undefined;
-};
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
 /**
@@ -132,4 +120,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }: Io) => EffectToPromise;

package/fs/io/module.f.js

@@ -35,7 +35,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }) => {
     const result = asyncRun({
         all: async (...effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
@@ -50,9 +50,15 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
         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 }))
-            .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
+            .map(v => ({
+            name: v.name,
+            parentPath: normalize(v.parentPath),
+            isFile: v.isFile()
+        }))),
         writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
         rm: path => tc(() => rm(path)),
+        access: path => tc(() => access(path)),
+        import: path => tc(() => asyncImport(path)),
         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);

package/fs/io/module.js

@@ -48,8 +48,8 @@ export const io = {
 export const legacyRun = run(io);
 export const ioRun = (io) => {
     const r = fromIo(io);
-    const { argv } = io.process;
-    return p => r(p(argv));
+    const { argv, env } = io.process;
+    return p => r(p(argv, env));
 };
 const effectRun = ioRun(io);
 export default effectRun;

package/fs/io/virtual/module.f.js

@@ -6,10 +6,9 @@ export const createVirtualIo = (files) => ({
         error: (..._d) => { }
     },
     fs: {
-        writeSync: (fd, s) => { },
+        writeSync: (_fd, _s) => { },
         writeFileSync: (_file, _data) => { },
         readFileSync: (path) => { return at(path)(files); },
-        existsSync: (path) => { return at(path)(files) !== null; },
         promises: {
             readdir: (_path) => Promise.resolve([]),
             readFile: (_path) => Promise.resolve(new Uint8Array()),
@@ -17,6 +16,7 @@ export const createVirtualIo = (files) => ({
             rm: (_path, _options) => Promise.resolve(),
             mkdir: (_path, _options) => Promise.resolve(undefined),
             copyFile: (_src, _dest) => Promise.resolve(),
+            access: (_path) => Promise.resolve(),
         }
     },
     process: {

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

@@ -46,7 +46,9 @@ export type ExecResult = {
 };
 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 Access = readonly ['access', (path: string) => IoResult<void>];
+export declare const access: Func<Access>;
+export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec | Access;
 export type Error = ['error', (message: string) => void];
 export declare const error: Func<Error>;
 export type Log = ['log', (message: string) => void];
@@ -75,7 +77,18 @@ export declare const listen: Func<Listen>;
 export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
-export type NodeOp = All | Fetch | Console | Fs | Http | Forever;
+export type Module = {
+    readonly default: unknown;
+};
+export type Import = ['import', (path: string) => IoResult<Module>];
+export declare const import_: Func<Import>;
+export type NodeOp = All | Fetch | Console | Fs | Http | Forever | Import;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
-export type NodeProgram = (argv: readonly string[]) => Effect<NodeOp, number>;
+/**
+ * The environment variables.
+ */
+export type Env = {
+    readonly [k: string]: string | undefined;
+};
+export type NodeProgram = (argv: readonly string[], env: Env) => Effect<NodeOp, number>;

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

@@ -16,8 +16,10 @@ export const readdir = do_('readdir');
 export const writeFile = do_('writeFile');
 export const rm = do_('rm');
 export const exec = do_('exec');
+export const access = do_('access');
 export const error = do_('error');
 export const log = do_('log');
 export const createServer = do_('createServer');
 export const listen = do_('listen');
 export const forever = do_('forever');
+export const import_ = do_('import');

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

@@ -94,6 +94,15 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
     };
     return ok(f(base, dir));
 });
+const access = readOperation((dir, path) => {
+    if (path.length === 0) {
+        return okVoid;
+    }
+    if (path.length !== 1) {
+        return error('no such file or directory');
+    }
+    return dir[path[0]] !== undefined ? okVoid : error('no such file or directory');
+});
 const rm = operation((dir, path) => {
     if (path.length !== 1) {
         return [dir, error('invalid path')];
@@ -130,6 +139,8 @@ const map = {
     readFile,
     readdir: (state, path, { recursive }) => readdir(path, recursive === true)(state, path),
     writeFile: (state, path, payload) => writeFile(payload)(state, path),
+    access,
+    import: todo,
     rm,
     exec: todo,
     createServer: todo,

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

@@ -0,0 +1,77 @@
+/**
+ * Shared kernel for RTTI consumers (`validate`, `parse`).
+ *
+ * Both consumers traverse the same schema shape and produce the same
+ * `Result<T, ValidationError>` outcome. Only the per-variant handling differs
+ * — `validate` keeps the original value, `parse` constructs a fresh one.
+ *
+ * This module hosts the parts that do not differ:
+ *
+ * - The error shape (`ValidationError`, `Path`) and path bookkeeping
+ *   (`verror`, `prependPath`).
+ * - Primitive checks (`primitive0Validate`, `constPrimitiveValidate`).
+ * - The `Validate<T>`/`Result<T>` signatures — `parse` uses the same shape.
+ * - `visit`: a visitor over the `Type` ADT. Callers supply a `Visitor<R>`
+ *   with one handler per variant; `visit(v)(rtti)` recognizes `rtti` and
+ *   calls the matching handler. Both consumers compose their top-level
+ *   function from a visitor.
+ *
+ * Keeping the kernel here also removes `parse`'s incidental dependency on
+ * `validate` and gives future schema-driven consumers (e.g. the data form
+ * sketched in [i143](../../../../issues/README.md)) a stable shared base.
+ *
+ * @module
+ */
+import type { Primitive, Unknown } from '../../../djs/module.f.ts';
+import { type Info0, type Primitive0, type Struct, type Tuple, type Type } from '../module.f.ts';
+import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
+import type { Ts } from '../ts/module.f.ts';
+/** A path to a sub-value within the validated structure. Each step is an object key or stringified array index. */
+export type Path = readonly string[];
+/** Detailed validation failure: the offending `path` plus a short `message`. */
+export type ValidationError = {
+    readonly path: Path;
+    readonly message: string;
+};
+/** Validation/parse result: either the typed value or a `ValidationError`. */
+export type Result<T extends Type> = CommonResult<Ts<T>, ValidationError>;
+/** A function that checks an unknown value against schema `T`. Shared by `validate` and `parse`. */
+export type Validate<T extends Type> = (value: Unknown) => Result<T>;
+/** Builds an error result with empty path and the given message. */
+export declare const verror: (message: string) => Error<ValidationError>;
+/** Prepends `key` to the error's path, used to build the path bottom-up. */
+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 `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>;
+/**
+ * One handler per `Type` variant. Both `validate` and `parse` provide a
+ * `Visitor<R>` where `R` is the per-variant output (e.g. a `Validate` function).
+ */
+export type Visitor<R> = {
+    readonly tuple: (rtti: Tuple) => R;
+    readonly struct: (rtti: Struct) => R;
+    readonly array: (item: Type) => R;
+    readonly record: (item: Type) => R;
+    readonly or: (variants: readonly Type[]) => R;
+    readonly constPrimitive: (p: Primitive) => R;
+    readonly primitive0: (tag: Primitive0) => R;
+    readonly unknown: () => R;
+};
+/**
+ * Visits a schema `Type` by dispatching to the matching handler in `v`.
+ *
+ * - `Thunk` schemas are evaluated once to read the `Info` descriptor, then
+ *   routed by tag (`'const'`, `'array'`, `'record'`, `'unknown'`, `'or'`,
+ *   or a `Tag0` primitive).
+ * - `Const` schemas (primitives, tuples, structs) are routed directly to
+ *   `tuple`, `struct`, or `constPrimitive`.
+ */
+export declare const visit: <R>(v: Visitor<R>) => (rtti: Type) => R;

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

@@ -0,0 +1,45 @@
+import {} from "../module.f.js";
+import { error, ok } from "../../result/module.f.js";
+import { isArray } from "../../array/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 });
+/** Validates a `Tag0` primitive schema using `typeof`. */
+export const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : verror('unexpected 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 visitConst = (v) => (c) => typeof c === 'object' && c !== null
+    ? (isArray(c) ? v.tuple(c) : v.struct(c))
+    : v.constPrimitive(c);
+/**
+ * Visits a schema `Type` by dispatching to the matching handler in `v`.
+ *
+ * - `Thunk` schemas are evaluated once to read the `Info` descriptor, then
+ *   routed by tag (`'const'`, `'array'`, `'record'`, `'unknown'`, `'or'`,
+ *   or a `Tag0` primitive).
+ * - `Const` schemas (primitives, tuples, structs) are routed directly to
+ *   `tuple`, `struct`, or `constPrimitive`.
+ */
+export const visit = (v) => (rtti) => {
+    if (typeof rtti === 'function') {
+        const [tag, ...value] = rtti();
+        switch (tag) {
+            case 'const': return visitConst(v)(value[0]);
+            case 'array': return v.array(value[0]);
+            case 'record': return v.record(value[0]);
+            case 'unknown': return v.unknown();
+            case 'or': return v.or(value);
+        }
+        return v.primitive0(tag);
+    }
+    return visitConst(v)(rtti);
+};

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

@@ -1,32 +1,8 @@
 import { type Type } from '../module.f.ts';
-import { type Result as ValidateResult, type Validate } from '../validate/module.f.ts';
-export type { Path, ValidationError } from '../validate/module.f.ts';
+import { type Result as CommonValidateResult, type Validate } from '../common/module.f.ts';
+export { type Path, type ValidationError } from '../common/module.f.ts';
 /** Parse result: either the freshly constructed typed value or a `ValidationError`. */
-export type Result<T extends Type> = ValidateResult<T>;
+export type Result<T extends Type> = CommonValidateResult<T>;
 /** A function that parses an unknown value into the schema `T`. */
 export type Parse<T extends Type> = Validate<T>;
-/**
- * Creates a parser function for the given RTTI schema.
- *
- * The returned function takes an unknown value and returns either
- * `['ok', newValue]` containing a freshly constructed value matching the schema,
- * or `['error', { path, message }]` describing the failure location.
- *
- * @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 `Parse<T>` function.
- *
- * @example
- * ```ts
- * const p = parse(array(number))
- * p([1, 2, 3])         // ['ok', [1, 2, 3]]   (a new array)
- * p([1, 'two'])        // ['error', { path: ['1'], message: 'unexpected value' }]
- *
- * // tuples are closed: extra elements are dropped
- * parse([number, number] as const)([1, 2, 3]) // ['ok', [1, 2]]
- *
- * // structs drop undeclared keys
- * parse({ a: number } as const)({ a: 1, b: 2 }) // ['ok', { a: 1 }]
- * ```
- */
 export declare const parse: <T extends Type>(rtti: T) => Parse<T>;

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

@@ -1,9 +1,10 @@
 import {} from "../module.f.js";
 import { ok } from "../../result/module.f.js";
-import { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../validate/module.f.js";
 import { isArray as commonIsArray } from "../../array/module.f.js";
 import { isObject as commonIsObject } from "../../object/module.f.js";
 import { find, map as listMap } from "../../list/module.f.js";
+import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+export {} from "../common/module.f.js";
 const indexedFirstError = (results) => {
     // TODO: findIndex breaks type inference,
     //       we should replace it with something else.
@@ -65,12 +66,6 @@ const structParse = (rtti) => value => {
         ? ok(Object.fromEntries(results.map(([k, r]) => [k, r[1]])))
         : prependPath(err[0], err[1]));
 };
-const constObjectParse = (rtti) => commonIsArray(rtti)
-    ? tupleParse(rtti)
-    : structParse(rtti);
-const constParse = (rtti) => typeof rtti === 'object' && rtti !== null
-    ? constObjectParse(rtti)
-    : constPrimitiveValidate(rtti);
 const findFirst = find(verror('no match'))((k) => k[0] === 'ok');
 const orParse = (rtti) => value => findFirst(listMap(t => parse(t)(value))(rtti));
 /**
@@ -97,17 +92,14 @@ const orParse = (rtti) => value => findFirst(listMap(t => parse(t)(value))(rtti)
  * parse({ a: number } as const)({ a: 1, b: 2 }) // ['ok', { a: 1 }]
  * ```
  */
-export const parse = (rtti) => {
-    if (typeof rtti === 'function') {
-        const [tag, ...value] = rtti();
-        switch (tag) {
-            case 'const': return constParse(value[0]);
-            case 'array': return arrayParse(value[0]);
-            case 'record': return recordParse(value[0]);
-            case 'unknown': return ok;
-            case 'or': return orParse(value);
-        }
-        return primitive0Validate(tag);
-    }
-    return constParse(rtti);
+const parseVisitor = {
+    tuple: tupleParse,
+    struct: structParse,
+    array: arrayParse,
+    record: recordParse,
+    or: orParse,
+    constPrimitive: constPrimitiveValidate,
+    primitive0: primitive0Validate,
+    unknown: () => ok,
 };
+export const parse = (rtti) => visit(parseVisitor)(rtti);

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

@@ -6,9 +6,7 @@ export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends
 /** Maps a `Const` schema to its TypeScript type. */
 export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends {
     readonly [k in string]: Type;
-} ? {
-    readonly [K in keyof T]: Ts<T[K]>;
-} : T;
+} ? StructTs<T> : T;
 /** Maps a `Tag1` and inner type to its TypeScript type. */
 export type Info1Ts<K extends Tag1, T extends Type> = K extends 'array' ? ArrayTs<T> : K extends 'record' ? RecordTs<T> : never;
 /** Maps an array schema `T` to `readonly Ts<T>[]`. */
@@ -19,10 +17,14 @@ export type RecordTs<T extends Type> = ReadonlyRecord<string, Ts<T>>;
 export type TupleTs<T extends Tuple> = {
     readonly [K in keyof T]: Ts<T[K]>;
 };
-/** Maps a struct schema to a readonly object of resolved types. */
-export type StructTs<T extends Struct> = {
-    readonly [K in keyof T]: Ts<T[K]>;
+type OptionalFields<T extends Struct> = {
+    readonly [K in keyof T as undefined extends Ts<T[K]> ? K : never]?: Ts<T[K]>;
+};
+type RequiredFields<T extends Struct> = {
+    readonly [K in keyof T as undefined extends Ts<T[K]> ? never : K]: Ts<T[K]>;
 };
+/** Maps a struct schema to a readonly object of resolved types, with optional fields for schemas that include `undefined`. */
+export type StructTs<T extends Struct> = (keyof OptionalFields<T> extends never ? unknown : OptionalFields<T>) & (keyof RequiredFields<T> extends never ? unknown : RequiredFields<T>);
 /**
  * Converts a schema `Type` to its corresponding TypeScript type.
  *
@@ -70,3 +72,4 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
  * ```
  */
 export declare const printer: (mut?: true) => (rtti: Type) => string;
+export {};

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

@@ -1,80 +1,4 @@
-/**
- * Runtime validation of unknown values against RTTI schemas.
- *
- * The main entry point is `validate(rtti)`, which takes a schema `Type` and returns
- * a `Validate<T>` function. When called with an unknown value, it returns a `Result`
- * that is either `['ok', typedValue]` or `['error', { path, message }]`.
- *
- * ## Error path
- *
- * On failure, the error carries a `path` pointing at the offending sub-value:
- * each step is the string property name (for structs/records) or the stringified
- * index (for tuples/arrays). The path is empty when the failure is at the root.
- *
- * ## Dispatch strategy
- *
- * - **`Thunk`** schemas are evaluated lazily: the thunk is called once to obtain an
- *   `Info` descriptor, then dispatched by tag:
- *   - `'const'` — delegates to `constValidate`
- *   - `'unknown'` — always succeeds (any DJS value is valid)
- *   - `Tag1` (`'array'`, `'record'`) — delegates to `containerValidate`
- *   - `Tag0` (`'boolean'`, `'number'`, `'string'`, `'bigint'`) — uses `typeof` check
- *   - `'or'` — tries each variant; reports `'no match'` at the current location if all fail
- * - **`Const`** schemas (primitives, tuples, structs) validate by exact equality or
- *   recursive field/element checking.
- *
- * ## Recursion safety
- *
- * For `array` and `record` schemas, the inner item validator is instantiated lazily —
- * only after confirming the container is non-empty. This prevents infinite recursion
- * when validating recursive schemas like `const list = () => ['array', list]`.
- *
- * @module
- */
-import type { Unknown } from '../../../djs/module.f.ts';
-import { type Info0, type Primitive0, type Type } from '../module.f.ts';
-import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
-import type { Ts } from '../ts/module.f.ts';
-import type { Primitive } from '../../../djs/module.f.ts';
-/** A path to a sub-value within the validated structure. Each step is an object key or stringified array index. */
-export type Path = readonly string[];
-/** Detailed validation failure: the offending `path` plus a short `message`. */
-export type ValidationError = {
-    readonly path: Path;
-    readonly message: string;
-};
-/** Validation result: either the typed value or a `ValidationError`. */
-export type Result<T extends Type> = CommonResult<Ts<T>, ValidationError>;
-/** A function that validates an unknown value against schema `T`. */
-export type Validate<T extends Type> = (value: Unknown) => Result<T>;
-/** Builds an error result with empty path and the given message. */
-export declare const verror: (message: string) => Error<ValidationError>;
-/** Prepends `key` to the error's path, used to build the path bottom-up. */
-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 `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.
- *
- * @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', { path, message }]`.
- *
- * @example
- * ```ts
- * const v = validate(array(number))
- * 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' }]
- * ```
- */
+import { type Type } from '../module.f.ts';
+import { type Validate } from '../common/module.f.ts';
+export { constPrimitiveValidate, prependPath, primitive0Validate, verror, type Path, type Result, type Validate, type ValidationError, } from '../common/module.f.ts';
 export declare const validate: <T extends Type>(rtti: T) => Validate<T>;

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

@@ -1,11 +1,9 @@
 import {} from "../module.f.js";
-import { error, ok } from "../../result/module.f.js";
+import { ok } from "../../result/module.f.js";
 import { isArray as commonIsArray } from "../../array/module.f.js";
 import { isObject as commonIsObject } from "../../object/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 });
+import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
@@ -35,8 +33,6 @@ 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.entries);
-/** Validates a `Tag0` primitive schema using `typeof`. */
-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
@@ -57,22 +53,6 @@ const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
 };
 const tupleValidate = constContainerValidate(isArray, (value, k) => value[Number(k)]);
 const structValidate = constContainerValidate(isObject, (value, k) => value[k]);
-const constObjectValidate = (rtti) => commonIsArray(rtti)
-    ? tupleValidate(rtti)
-    : structValidate(rtti);
-/**
- * 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
-    ? constObjectValidate(rtti)
-    : constPrimitiveValidate(rtti);
 const orValidate = (rtti) => {
     const all = rtti.map(r => validate(r));
     return value => {
@@ -101,17 +81,14 @@ const orValidate = (rtti) => {
  * v(['a'])             // ['error', { path: ['0'], message: 'unexpected value' }]
  * ```
  */
-export const validate = (rtti) => {
-    if (typeof rtti === 'function') {
-        const [tag, ...value] = rtti();
-        switch (tag) {
-            case 'const': return constValidate(value[0]);
-            case 'array': return arrayValidate(value[0]);
-            case 'record': return recordValidate(value[0]);
-            case 'unknown': return ok;
-            case 'or': return orValidate(value);
-        }
-        return primitive0Validate(tag);
-    }
-    return constValidate(rtti);
+const validateVisitor = {
+    tuple: tupleValidate,
+    struct: structValidate,
+    array: arrayValidate,
+    record: recordValidate,
+    or: orValidate,
+    constPrimitive: constPrimitiveValidate,
+    primitive0: primitive0Validate,
+    unknown: () => ok,
 };
+export const validate = (rtti) => visit(validateVisitor)(rtti);

package/package.json

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