functionalscript 0.41.0 → 0.43.0

package/fjs/media/module.f.js

@@ -1,13 +1,72 @@
 import { fromVec } from '../text/utf8/module.f.js';
 import { detectVec } from './type/module.f.js';
-import { decodeText as decodeRevisionText, mediaType as revisionMediaType } from './revision/module.f.js';
-import { assertNotNullish } from '../asserts/module.f.js';
+import { parse } from './json/module.f.js';
+import { assert, assertNotNullish } from '../asserts/module.f.js';
+import { validate } from '../types/rtti/validate/module.f.js';
+/** The default refinement: structural validation alone decides the match. */
+const always = () => true;
+/** Structural validation followed by the dialect's own refinement. */
+const matchWith = (v) => (extraValidate) => (u) => {
+    const [tag, value] = v(u);
+    return tag === 'ok' && extraValidate(value);
+};
+/**
+ * Registers a dialect for detection: its rtti schema, plus whatever rtti can't
+ * say about it.
+ *
+ * The dialect name is read out of the schema's own `dialect` member — that
+ * member is a string const in a dialect schema, which is what makes the schema
+ * self-discriminating, so a separate name alongside it would be a second copy
+ * that can disagree with the first. It follows that no registration can claim
+ * one dialect while validating another's blobs. The media type is likewise
+ * derived rather than supplied: `application/${dialect}+json`, the mechanical
+ * derivation `fjs/media/revision/README.md` documents.
+ *
+ * `extraValidate` runs *after* structural validation, on the dialect's own
+ * decoded type, and closes the gap rtti leaves — "this string is
+ * cbase32-decodable", "this number is a non-negative safe integer". It returns
+ * `boolean`, so it has no error channel and nothing to report but yes or no,
+ * and it never sees the raw bytes: parsing and the schema walk stay with the
+ * detector. Omitting it gets classification (what a blob claims to be and
+ * structurally looks like); supplying it gets detection as strict as the
+ * dialect's own decoder.
+ *
+ * **The name is neither grammar-checked nor allowlisted.** A schema saying
+ * `dialect: 'foo'` yields `application/foo+json`, and that is intended:
+ * `vnd.fjs.*` is this repo's convention for its *own* formats, not a constraint
+ * on what a caller may detect — another vendor's `vnd.*` blob, or a widely used
+ * name not under `vnd.` at all, is a legitimate thing to register. The name is
+ * not attacker-controlled either: it comes from a schema a programmer wrote and
+ * passed here, never from the blob being classified, so no untrusted string
+ * reaches `mime_type` along this path. (A detector that read the name *out of*
+ * a blob would need the RFC 6838 grammar check and an allowlist; this one does
+ * not.) Registering a name that is not a valid RFC 6838 restricted-name yields
+ * a malformed media type in the registrant's own results, and nowhere else.
+ *
+ * The constraint is `Struct` — every member must be a real rtti `Type`, which
+ * is what rejects a member like `() => 42` at compile time (rtti would read it
+ * as a thunk and `match` would *throw* on the first blob rather than return
+ * `false`). TypeScript cannot also require a direct string `dialect` member
+ * under that constraint, so that half is asserted here instead: loudly, once,
+ * when the entry is constructed. A thunk-form `dialect`
+ * (`() => ['const', 'x']`) is a perfectly valid rtti schema, it just is not
+ * registerable — write the string directly, as `revisionSchema` does.
+ */
+export const dialectEntry = (type, extraValidate = always) => {
+    const { dialect } = type;
+    assert(typeof dialect === 'string', 'dialectEntry: schema has no direct string `dialect` member');
+    return { dialect, match: matchWith(validate(type))(extraValidate) };
+};
 /**
- * Classifies a whole buffered `Vec`, the same three-way `{ length, mime_type,
- * type }` shape as `fjs/media/type` `detectVec`, but with dialect-tagged JSON
- * recognized ahead of the plain `text/plain` fallback.
+ * Classifies a whole buffered `Vec` against `dialects`, returning the same
+ * three-way `{ length, mime_type, type }` shape as `fjs/media/type`
+ * `detectVec`, but with dialect-tagged JSON recognized ahead of the plain
+ * `text/plain` fallback. The first entry whose `match` accepts the parsed value
+ * wins; entries that overlap are the registrant's own business, since matching
+ * `dialect` as an exact literal already makes structural validation reject
+ * every other dialect's blob.
  */
-export const detect = (bytes) => {
+export const detect = (dialects) => (bytes) => {
     const base = detectVec(bytes);
     // Only whole-blob-valid UTF-8 text can possibly be JSON; a magic-byte hit
     // or binary fallback is never a dialect match.
@@ -18,6 +77,12 @@ export const detect = (bytes) => {
     // whole-blob-valid UTF-8 — the same two conditions `fromVec` checks, via the
     // same decoder — so `fromVec` cannot return `null` here.
     const text = assertNotNullish(fromVec(bytes), 'detect: type text implies fromVec succeeds');
-    const [tag] = decodeRevisionText(text);
-    return tag === 'ok' ? { ...base, mime_type: revisionMediaType } : base;
+    const [tag, value] = parse(text);
+    if (tag === 'error') {
+        return base;
+    }
+    const matched = dialects.find(({ match }) => match(value));
+    return matched === undefined
+        ? base
+        : { ...base, mime_type: `application/${matched.dialect}+json` };
 };

package/fjs/media/proof.f.d.ts

@@ -1,9 +1,19 @@
+import { type DialectEntry } from './module.f.ts';
 export declare const proof: {
     validRevision: () => void;
     keyOrderIndependent: () => void;
     invalidRevisionFallsThrough: () => void;
+    nonHashSnapshotFallsThrough: () => void;
+    secondDialect: () => void;
+    nonVndDialectName: () => void;
+    firstMatchWins: () => void;
+    noDialects: () => void;
     ordinaryJsonFallsThrough: () => void;
     plainTextFallsThrough: () => void;
     binaryFallsThrough: () => void;
     largeNonJsonWithinBound: () => void;
+    throw: {
+        thunkDialectMember: () => DialectEntry;
+        noDialectMember: () => DialectEntry;
+    };
 };

package/fjs/media/proof.f.js

@@ -1,14 +1,37 @@
 import { assertEq } from '../asserts/module.f.js';
 import { msb, u8ListToVec, repeat, vec8 } from '../types/bit_vec/module.f.js';
-import { detect } from './module.f.js';
-import { dialect } from './revision/module.f.js';
+import { detect, dialectEntry } from './module.f.js';
+import { dialect, revisionDialect } from './revision/module.f.js';
+import { number, string } from '../types/rtti/module.f.js';
 // All test strings here are ASCII, so char code === UTF-8 byte value.
 const utf8Bytes = (s) => u8ListToVec(msb)([...s].map(c => c.charCodeAt(0)));
 const revisionJson = `{"dialect":"${dialect}","subject":"8","parents":[],"snapshot":"8","generation":0}`;
+const dialects = [revisionDialect];
+const detectRevision = detect(dialects);
+/**
+ * A second dialect following the same `vnd.fjs.<name>` convention, registered
+ * with no refinement: structure alone decides the match.
+ */
+const noteSchema = {
+    dialect: 'vnd.fjs.note',
+    text: string,
+};
+const noteDialect = dialectEntry(noteSchema);
+/** A dialect name outside `vnd.fjs.*` — registerable, and detected as itself. */
+const gadgetSchema = {
+    dialect: 'application.gadget',
+    size: number,
+};
+const gadgetDialect = dialectEntry(gadgetSchema);
+/**
+ * `DialectEntry` is deliberately not opaque, so overlapping entries — which a
+ * self-discriminating schema can't produce on its own — can be stated directly.
+ */
+const anyEntry = (name) => ({ dialect: name, match: () => true });
 export const proof = {
     // A valid revision blob is recognized and reported under its derived media type.
     validRevision: () => {
-        const m = detect(utf8Bytes(revisionJson));
+        const m = detectRevision(utf8Bytes(revisionJson));
         assertEq(m.type, 'text');
         assertEq(m.mime_type, 'application/vnd.fjs.revision+json');
     },
@@ -16,7 +39,7 @@ export const proof = {
     // not first must still be detected.
     keyOrderIndependent: () => {
         const text = `{"parents":[],"subject":"8","dialect":"${dialect}","snapshot":"8","generation":0}`;
-        const m = detect(utf8Bytes(text));
+        const m = detectRevision(utf8Bytes(text));
         assertEq(m.mime_type, 'application/vnd.fjs.revision+json');
     },
     // A revision missing a required field (here `snapshot` and `generation`)
@@ -24,25 +47,63 @@ export const proof = {
     // classification.
     invalidRevisionFallsThrough: () => {
         const text = `{"dialect":"${dialect}","subject":"8","parents":["8","r"]}`;
-        const m = detect(utf8Bytes(text));
+        const m = detectRevision(utf8Bytes(text));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+    // The `extraValidate` path: structurally a revision, but `snapshot` is not
+    // a cbase32 hash, so `revisionDialect`'s refinement rejects it and the
+    // verdict stays `text/plain` — exactly what `decodeText` would say.
+    nonHashSnapshotFallsThrough: () => {
+        const text = `{"dialect":"${dialect}","subject":"8","parents":[],"snapshot":"not a hash","generation":0}`;
+        const m = detectRevision(utf8Bytes(text));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+    // A second dialect, registered by the caller, is recognized alongside the
+    // first — and an entry with no refinement matches on structure alone.
+    secondDialect: () => {
+        const d = detect([revisionDialect, noteDialect]);
+        assertEq(d(utf8Bytes('{"dialect":"vnd.fjs.note","text":"hi"}')).mime_type, 'application/vnd.fjs.note+json');
+        assertEq(d(utf8Bytes(revisionJson)).mime_type, 'application/vnd.fjs.revision+json');
+        // Same tag, wrong shape: no entry matches.
+        assertEq(d(utf8Bytes('{"dialect":"vnd.fjs.note","text":42}')).mime_type, 'text/plain');
+    },
+    // The name is neither grammar-checked nor allowlisted: a dialect outside
+    // `vnd.fjs.*` yields its own derived media type.
+    nonVndDialectName: () => {
+        const m = detect([gadgetDialect])(utf8Bytes('{"dialect":"application.gadget","size":3}'));
+        assertEq(m.mime_type, 'application/application.gadget+json');
+    },
+    // Entries are tried in order and the first match wins.
+    firstMatchWins: () => {
+        const bytes = utf8Bytes('{}');
+        assertEq(detect([anyEntry('vnd.fjs.a'), anyEntry('vnd.fjs.b')])(bytes).mime_type, 'application/vnd.fjs.a+json');
+        assertEq(detect([anyEntry('vnd.fjs.b'), anyEntry('vnd.fjs.a')])(bytes).mime_type, 'application/vnd.fjs.b+json');
+    },
+    // An empty registry recognizes nothing; every blob keeps the
+    // `fjs/media/type` verdict.
+    noDialects: () => {
+        const m = detect([])(utf8Bytes(revisionJson));
         assertEq(m.type, 'text');
         assertEq(m.mime_type, 'text/plain');
     },
     // Ordinary JSON with no `dialect` field at all falls through unchanged.
     ordinaryJsonFallsThrough: () => {
-        const m = detect(utf8Bytes('{"hello":"world"}'));
+        const m = detectRevision(utf8Bytes('{"hello":"world"}'));
         assertEq(m.type, 'text');
         assertEq(m.mime_type, 'text/plain');
     },
-    // Plain (non-JSON) text is unaffected.
+    // Plain (non-JSON) text is unaffected: the parse fails and the
+    // `fjs/media/type` verdict stands.
     plainTextFallsThrough: () => {
-        const m = detect(utf8Bytes('hello'));
+        const m = detectRevision(utf8Bytes('hello'));
         assertEq(m.type, 'text');
         assertEq(m.mime_type, 'text/plain');
     },
     // Binary content (magic-byte hit) is unaffected by dialect detection.
     binaryFallsThrough: () => {
-        const m = detect(u8ListToVec(msb)([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+        const m = detectRevision(u8ListToVec(msb)([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
         assertEq(m.type, 'base64');
         assertEq(m.mime_type, 'image/png');
     },
@@ -51,8 +112,16 @@ export const proof = {
     // non-JSON content within that bound.
     largeNonJsonWithinBound: () => {
         const a = repeat(1000n)(vec8(0x61n)); // 1,000 bytes of 'a'
-        const m = detect(a);
+        const m = detectRevision(a);
         assertEq(m.type, 'text');
         assertEq(m.mime_type, 'text/plain');
     },
+    throw: {
+        // The `dialect` member must be a direct string const. A thunk-form one
+        // is a valid rtti schema but is not registerable, and `dialectEntry`
+        // says so at registration rather than per blob.
+        thunkDialectMember: () => dialectEntry({ dialect: string }),
+        // A schema with no `dialect` member at all is likewise refused.
+        noDialectMember: () => dialectEntry({ text: string }),
+    },
 };

package/fjs/media/revision/module.f.d.ts

@@ -1,7 +1,8 @@
 import { type ValidationError } from '../../types/rtti/validate/module.f.ts';
 import type { Ts } from '../../types/rtti/ts/module.f.ts';
-import type { Unknown } from '../json/module.f.ts';
+import { type Unknown } from '../json/module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
+import { type DialectEntry } from '../module.f.ts';
 /**
  * Format tag: names the dialect of this BLOB. The media type it is served
  * with is derived mechanically: `application/` + `dialect` + `+json`.
@@ -76,3 +77,10 @@ export declare const validate: (value: Unknown) => Result<Revision, RevisionErro
  * satisfies the schema is a revision, regardless of key order or whitespace.
  */
 export declare const decodeText: (text: string) => Result<Revision, RevisionError>;
+/**
+ * This dialect as a registry entry for `fjs/media`'s `detect`. It carries the
+ * semantic checks too, so a blob is detected as `vnd.fjs.revision` exactly when
+ * {@link decodeText} would accept it — a structurally valid revision whose
+ * `snapshot` is not a cbase32 hash is not one.
+ */
+export declare const revisionDialect: DialectEntry;

package/fjs/media/revision/module.f.js

@@ -16,11 +16,10 @@
  */
 import { array, number, option, string } from '../../types/rtti/module.f.js';
 import { validate as rttiValidate } from '../../types/rtti/validate/module.f.js';
-import { parse as jsonParse } from '../json/parser/module.f.js';
-import { tokenize as jsonTokenize } from '../json/tokenizer/module.f.js';
-import { stringToList } from '../../text/utf16/module.f.js';
+import { parse as parseJson } from '../json/module.f.js';
 import { cBase32ToVec } from '../../basen/cbase32/module.f.js';
 import { error, ok } from '../../types/result/module.f.js';
+import { dialectEntry } from '../module.f.js';
 /**
  * Format tag: names the dialect of this BLOB. The media type it is served
  * with is derived mechanically: `application/` + `dialect` + `+json`.
@@ -106,8 +105,6 @@ export const validate = (value) => {
     }
     return checkReferences(v);
 };
-/** Parses `text` as JSON without relying on `JSON.parse` (the shared `fjs/media/json` parser/tokenizer). */
-const parseJson = (text) => jsonParse(jsonTokenize(stringToList(text)));
 /**
  * Decodes `text` as a `revision` BLOB: JSON-parses it, then validates it per
  * {@link validate}. Detection is semantic, not syntactic — any JSON that
@@ -120,3 +117,15 @@ export const decodeText = (text) => {
     }
     return validate(v);
 };
+/** {@link checkReferences} as the `boolean` refinement a {@link DialectEntry} takes. */
+const isValidRevision = (r) => {
+    const [tag] = checkReferences(r);
+    return tag === 'ok';
+};
+/**
+ * This dialect as a registry entry for `fjs/media`'s `detect`. It carries the
+ * semantic checks too, so a blob is detected as `vnd.fjs.revision` exactly when
+ * {@link decodeText} would accept it — a structurally valid revision whose
+ * `snapshot` is not a cbase32 hash is not one.
+ */
+export const revisionDialect = dialectEntry(revisionSchema, isValidRevision);

package/fjs/protocol/mcp/stdio/module.f.js

@@ -32,10 +32,7 @@
 import { pure, step } from '../../../effects/module.f.js';
 import { readLine, write } from '../../../effects/node/module.f.js';
 import { tryUtf8 } from '../../../text/module.f.js';
-import { stringToList } from '../../../text/utf16/module.f.js';
-import { stringify } from '../../../media/json/module.f.js';
-import { tokenize } from '../../../media/json/tokenizer/module.f.js';
-import { parse } from '../../../media/json/parser/module.f.js';
+import { parse, stringify } from '../../../media/json/module.f.js';
 import { sort } from '../../../types/object/module.f.js';
 import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.js';
 import { error, ok } from '../../../types/result/module.f.js';
@@ -61,7 +58,7 @@ export const stdioTransport = (handler) => step(readLine('stdin'), line => line
     ? pure(undefined)
     : handleLine(handler)(line));
 const handleLine = (handler) => (line) => {
-    const [t, value] = parse(tokenize(stringToList(line)));
+    const [t, value] = parse(line);
     return step(t === 'error'
         ? writeResponse(parseErrorResponse)
         : step(handler(value), resp => resp === null

package/fjs/text/utf16/module.f.d.ts

@@ -135,3 +135,27 @@ export declare const listToString: (input: List<U16>) => string;
  * ```
  */
 export declare const codePointListToString: (input: List<CodePoint>) => string;
+/**
+ * Converts a single Unicode code point to a string — the scalar counterpart of
+ * {@link codePointListToString}, for callers that hold one code point rather
+ * than a list of them and would otherwise wrap it in a single-element list.
+ *
+ * Input outside the assignable range — a surrogate, a value above
+ * `0x10FFFF`, or a negative one — is truncated to its low 16 bits and encoded
+ * as that code unit, rather than rejected. This matches
+ * {@link codePointListToString}, which reports malformed input through the
+ * decoder's `errorMask` on the way *in* rather than through a failure on the
+ * way out.
+ *
+ * @param codePoint - A Unicode code point (`CodePoint`).
+ * @returns The one- or two-code-unit string encoding it.
+ *
+ * @example
+ *
+ * ```ts
+ * codePointToString(0x48)      // 'H'
+ * codePointToString(0x1F600)   // the 😀 surrogate pair
+ * codePointToString(0x110000)  // '\u0000' — out of range, low 16 bits kept
+ * ```
+ */
+export declare const codePointToString: (codePoint: CodePoint) => string;

package/fjs/text/utf16/module.f.js

@@ -285,3 +285,27 @@ export const listToString = fn(map(String.fromCharCode))
  * ```
  */
 export const codePointListToString = (input) => listToString(fromCodePointList(input));
+/**
+ * Converts a single Unicode code point to a string — the scalar counterpart of
+ * {@link codePointListToString}, for callers that hold one code point rather
+ * than a list of them and would otherwise wrap it in a single-element list.
+ *
+ * Input outside the assignable range — a surrogate, a value above
+ * `0x10FFFF`, or a negative one — is truncated to its low 16 bits and encoded
+ * as that code unit, rather than rejected. This matches
+ * {@link codePointListToString}, which reports malformed input through the
+ * decoder's `errorMask` on the way *in* rather than through a failure on the
+ * way out.
+ *
+ * @param codePoint - A Unicode code point (`CodePoint`).
+ * @returns The one- or two-code-unit string encoding it.
+ *
+ * @example
+ *
+ * ```ts
+ * codePointToString(0x48)      // 'H'
+ * codePointToString(0x1F600)   // the 😀 surrogate pair
+ * codePointToString(0x110000)  // '\u0000' — out of range, low 16 bits kept
+ * ```
+ */
+export const codePointToString = (codePoint) => String.fromCharCode(...codePointToUtf16(codePoint));

package/fjs/text/utf16/proof.f.d.ts

@@ -6,4 +6,5 @@ export declare const proof: {
     listToString: (() => void)[];
     stringToCodePointList: (() => void)[];
     codePointListToString: (() => void)[];
+    codePointToString: (() => void)[];
 };

package/fjs/text/utf16/proof.f.js

@@ -1,4 +1,4 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from './module.f.js';
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString, codePointToString } from './module.f.js';
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../../types/object/module.f.js';
 import { toArray } from '../../types/list/module.f.js';
@@ -131,5 +131,14 @@ export const proof = {
             const codePoints = [0x48, 0x65, 0x6C, 0x6C, 0x6F];
             const outputString = codePointListToString(codePoints);
         }
+    ],
+    codePointToString: [
+        () => { assertEq(codePointToString(0x48), 'H'); },
+        // supplementary plane: one code point, two code units
+        () => { assertEq(codePointToString(0x1f600), '😀'); },
+        // a surrogate is not a code point; it round-trips as its own code unit
+        () => { assertEq(codePointToString(0xd800), '\ud800'); },
+        // above the maximum code point, the low 16 bits are kept
+        () => { assertEq(codePointToString(0x110000), '\u0000'); },
     ]
 };

package/fjs/types/object/module.f.d.ts

@@ -1,12 +1,35 @@
 import { type List } from '../list/module.f.ts';
 import { type Nullable } from '../nullable/module.f.ts';
 import { type OrderedMap } from '../ordered_map/module.f.ts';
-export type Map<T> = StringMap<string, T>;
+/** A record over the keys of `K`, each value possibly missing at runtime. */
+export type OptionalMap<K extends string, T> = {
+    readonly [k in K]?: T;
+};
+/**
+ * A record over the keys of `K`, each value required.
+ *
+ * `K` has to be a finite union of string literals: `RequiredMap<string, T>` is
+ * `never`, because no object can carry every string as a key. Use `StringMap<T>`
+ * for an open key set — its values are optional, which is what such a key set
+ * means at runtime.
+ *
+ * There is no known way to ask TypeScript whether `K` is finite, so the guard
+ * approximates it with `string extends K`, which holds exactly when `K` is
+ * `string`. Other infinite key sets are not caught: a template literal such as
+ * `x-${string}` yields a template index signature instead of `never`, and its
+ * reads are typed `T` while the runtime value is `undefined`. Keep `K` a union
+ * of string literals.
+ */
+export type RequiredMap<K extends string, T> = string extends K ? never : {
+    readonly [k in K]: T;
+};
+/** A record with an open key set. Every value can be missing at runtime. */
+export type StringMap<T> = OptionalMap<string, T>;
 export type Entry<T> = readonly [string, T];
-export declare const at: (name: string) => <T>(object: Map<T>) => Nullable<Exclude<T, undefined>>;
+export declare const at: (name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
-export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
+export declare const fromEntries: <T>(e: List<Entry<T>>) => StringMap<T>;
+export declare const fromMap: <T>(m: OrderedMap<T>) => StringMap<T>;
 /**
  * A set of objects with a single key.
  *
@@ -14,7 +37,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (StringMap<P, V> & Partial<StringMap<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (RequiredMap<P, V> & OptionalMap<Exclude<K, P>, never>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -24,13 +47,8 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends StringMap<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends StringMap<never>> = keyof T extends NotUnion<keyof T> ? T : never;
 export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
 /** Returns only the defined (non-undefined) values of a partial record. */
-export declare const definedValues: <T>(map: StringMap<string, Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
-export type StringMap<K extends string, T> = string extends K ? {
-    readonly [k in string]?: T;
-} : {
-    readonly [k in K]: T;
-};
-export declare const definedEntries: <T>(cmd: StringMap<string, Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];
+export declare const definedValues: <T>(map: StringMap<Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
+export declare const definedEntries: <T>(cmd: StringMap<Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];

package/fjs/types/object/module.f.js

@@ -1,7 +1,8 @@
 /**
- * Plain-object helpers and types: `Map<T>`/`Entry<T>` shapes, safe property
- * lookup via `at`, conversions between entries and `OrderedMap`, and the
- * `OneKey`/`SingleProperty`/`NotUnion` utility types.
+ * Plain-object helpers and types: the `OptionalMap`/`RequiredMap`/`StringMap`
+ * record shapes and `Entry<T>`, safe property lookup via `at`, conversions
+ * between entries and `OrderedMap`, and the `OneKey`/`SingleProperty`/`NotUnion`
+ * utility types.
  *
  * @module
  */

package/fjs/types/object/proof.f.d.ts

@@ -1,18 +1,4 @@
-import type { StringMap } from './module.f.ts';
-type E<A, B> = A extends B ? B extends A ? true : false : false;
-type _InfiniteIsOptional = E<StringMap<string, bigint>, {
-    readonly [k in string]?: bigint;
-}>;
-type _FiniteIsRequired = E<StringMap<'a' | 'b', bigint>, {
-    readonly a: bigint;
-    readonly b: bigint;
-}>;
 export declare const proof: {
-    stringMap: {
-        infiniteIsOptional: _InfiniteIsOptional;
-        finiteIsRequired: _FiniteIsRequired;
-    };
     ctor: () => void;
     property: () => void;
 };
-export {};

package/fjs/types/object/proof.f.js

@@ -1,10 +1,6 @@
 import { at } from './module.f.js';
 import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
-    stringMap: {
-        infiniteIsOptional: true,
-        finiteIsRequired: true,
-    },
     ctor: () => {
         const a = {};
         const value = at('constructor')(a);

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

@@ -74,11 +74,11 @@ export type Visitor<R> = {
 /** Type guard narrowing `Unknown` to a specific container type `C`. */
 export type IsContainer<C extends Unknown> = (value: Unknown) => value is C;
 /** Maps a `Tag1` to its runtime container type. */
-export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<string, Unknown>;
+export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<Unknown>;
 /** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
 export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
 /** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
-export declare const isObject: IsContainer<StringMap<string, Unknown>>;
+export declare const isObject: IsContainer<StringMap<Unknown>>;
 /**
  * Runs `item` over each `[key, value]` entry, bailing out with the first
  * error, path-prefixed with that entry's key. On success, folds each item's

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

@@ -6,7 +6,7 @@ export type Const = null | boolean | number | string | undefined | bigint | {
 } | readonly Type[];
 export type ConstObject = Struct | Tuple;
 /** A struct schema: plain object whose values are nested `Type`s. */
-export type Struct = StringMap<string, Type>;
+export type Struct = StringMap<Type>;
 /** A tuple schema: readonly array whose elements are nested `Type`s. */
 export type Tuple = readonly Type[];
 declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];

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

@@ -31,7 +31,7 @@ export type Object = {
 /** Maps a `Tag0` to its TypeScript type. */
 export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'string' ? string : T extends 'bigint' ? bigint : T extends 'unknown' ? Unknown : never;
 /** Maps a `Const` schema to its TypeScript type. */
-export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<string, Type> ? StructTs<T> : T;
+export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<Type> ? 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>[]`. */

package/fjs/types/rtti/validate/proof.f.d.ts

@@ -113,4 +113,6 @@ export declare const proof: {
         arrayOfArrays: () => void;
         recordOfRecords: () => void;
     };
+    funcParam: () => () => void;
+    funcObj: () => () => void;
 };

package/fjs/types/rtti/validate/proof.f.js

@@ -288,4 +288,62 @@ export const proof = {
             assertError(v({ a: 42 }));
         },
     },
+    funcParam: () => {
+        const paramSet0 = ['hello', bigint];
+        const paramSet1 = ['goodbye', string, 43];
+        const paramSet01 = or(paramSet0, paramSet1);
+        const v0 = validate(paramSet0);
+        const v1 = validate(paramSet1);
+        const func = (f0, f1) => (...args) => {
+            {
+                const [t, r] = v0(args);
+                if (t === 'ok') {
+                    return f0(...r);
+                }
+            }
+            {
+                const [t, r] = v1(args);
+                if (t === 'ok') {
+                    return f1(...r);
+                }
+            }
+            throw 'unreachable: args did not match any parameter set';
+        };
+        const f0 = (a, b) => 42;
+        const f1 = (a, b, c) => 13;
+        const x = func(f0, f1);
+        return () => {
+            assertEq(x('hello', 42n), 42);
+            assertEq(x('goodbye', 'world', 43), 13);
+        };
+    },
+    funcObj: () => {
+        const param0 = { a: 'hello', b: bigint };
+        const param1 = { a: 'goodbye', b: string, c: 43 };
+        const param01 = or(param0, param1);
+        const v0 = validate(param0);
+        const v1 = validate(param1);
+        const func = (f0, f1) => (args) => {
+            {
+                const [t, r] = v0(args);
+                if (t === 'ok') {
+                    return f0(r);
+                }
+            }
+            {
+                const [t, r] = v1(args);
+                if (t === 'ok') {
+                    return f1(r);
+                }
+            }
+            throw 'unreachable: args did not match any parameter set';
+        };
+        const f0 = (args) => Number(args.b) + args.a.length;
+        const f1 = (args) => args.c;
+        const x = func(f0, f1);
+        return () => {
+            assertEq(x({ a: 'hello', b: 42n }), 47);
+            assertEq(x({ a: 'goodbye', b: 'world', c: 43 }), 43);
+        };
+    }
 };