functionalscript 0.41.0 → 0.42.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/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);
+        };
+    }
 };

package/nanvm-lib/tests/proof.f.d.ts

@@ -88,6 +88,15 @@ export declare const proof: {
         };
         function: () => void;
     };
+    mul: () => {
+        nullish: () => void;
+        boolean: () => void;
+        number: () => void;
+        bigint: () => void;
+        string: () => void;
+        array: () => void;
+        object: () => void;
+    };
     stringCoercion: {
         number: () => void;
         bool: () => void;

package/nanvm-lib/tests/proof.f.js

@@ -1,18 +1,19 @@
+import { assert } from '../../fjs/asserts/module.f.js';
 const { is } = Object;
 const ois = (a) => (b) => {
-    if (is(a, b)) { }
-    else {
-        throw [a, 'is', b];
-    }
+    assert(is(a, b), [a, 'is', b]);
 };
 const { isNaN } = Number;
 const nanRes = (op) => (n) => {
     const result = op(n);
-    if (!isNaN(result)) {
-        throw result;
-    }
+    assert(isNaN(result), result);
 };
 const stringCoercion = String;
+const multiply = (a) => (b) => a * b;
+const multiplyEq = (a) => (b) => (expected) => {
+    ois(multiply(a)(b))(expected);
+    ois(multiply(b)(a))(expected);
+};
 export const proof = {
     eq: () => {
         const e = (a) => (b) => {
@@ -174,6 +175,56 @@ export const proof = {
             function: () => nan(op(() => { }))
         };
     },
+    mul: () => {
+        return {
+            nullish: () => {
+                multiplyEq(null)(null)(0);
+                multiplyEq(null)(0)(0);
+                multiplyEq(undefined)(0)(NaN);
+            },
+            boolean: () => {
+                multiplyEq(true)(0)(0);
+                multiplyEq(true)(1)(1);
+                multiplyEq(true)(10)(10);
+                multiplyEq(false)(0)(0);
+                multiplyEq(false)(1)(0);
+                multiplyEq(false)(10)(0);
+            },
+            number: () => {
+                multiplyEq(0)(0)(0);
+                multiplyEq(0)(1)(0);
+                multiplyEq(1)(1)(1);
+                multiplyEq(1)(-1)(-1);
+                multiplyEq(1)(10)(10);
+                multiplyEq(-1)(10)(-10);
+                multiplyEq(10)(10)(100);
+                multiplyEq(-10)(10)(-100);
+            },
+            bigint: () => {
+                multiplyEq(0n)(0n)(0n);
+                multiplyEq(0n)(1n)(0n);
+                multiplyEq(1n)(1n)(1n);
+                multiplyEq(1n)(-1n)(-1n);
+                multiplyEq(1n)(10n)(10n);
+                multiplyEq(-1n)(10n)(-10n);
+                multiplyEq(10n)(10n)(100n);
+                multiplyEq(-10n)(10n)(-100n);
+            },
+            string: () => {
+                multiplyEq('')(1)(0);
+                multiplyEq('10')(1)(10);
+                multiplyEq('a')(1)(NaN);
+                multiplyEq('1n')(1)(NaN);
+            },
+            array: () => {
+                multiplyEq([])(1)(0);
+                multiplyEq([10])(1)(10);
+                multiplyEq(['10'])(1)(10);
+                multiplyEq([0, 0])(1)(NaN);
+            },
+            object: () => multiplyEq({})(1)(NaN)
+        };
+    },
     stringCoercion: {
         number: () => {
             if (stringCoercion(123) !== '123') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -10,7 +10,7 @@
   "scripts": {
     "prepack": "tsc --NoEmit false",
     "test": "tsc && node ./fjs/module.ts t",
-    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
+    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts --test-coverage-include=**/module.f.mjs",
     "start": "node ./fjs/module.ts",
     "ci-update": "node ./fjs/module.ts ci",
     "dev-update": "node ./fjs/module.ts r ./fjs/dev/update/module.f.ts",