functionalscript 0.14.8 → 0.16.0

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,24 @@ 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 Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec;
-export type Error = ['error', (_: string) => void];
+export type Exec = readonly ['exec', (command: string, stdin?: string) => IoResult<ExecResult>];
+export declare const exec: Func<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', (_: 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,14 +70,25 @@ 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>;
-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

@@ -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,19 @@ 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 access = do_('access');
 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');
+export const import_ = do_('import');

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

@@ -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')];
@@ -111,7 +120,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 +135,13 @@ 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),
+    access,
+    import: todo,
+    rm,
     exec: todo,
     createServer: todo,
     listen: 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/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/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/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;