functionalscript 0.40.0 → 0.42.0

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.40.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",