functionalscript 0.9.2 → 0.9.3

package/bnf/data/test.f.d.ts

@@ -1,4 +1,6 @@
 declare const _default: {
+    rangeDecode: () => void;
+    rangeEncode: () => void;
     toData: (() => void)[];
     emptyTags: (() => void)[];
     variantTest: () => void;

package/bnf/data/test.f.js

@@ -3,7 +3,7 @@ import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, option, range, repeat0Plus, set } from "../module.f.js";
+import { join0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
@@ -12,6 +12,34 @@ const descentParserCpOnly = (m, name, cp) => {
     return m(name, cpm);
 };
 export default {
+    rangeDecode: () => {
+        const decoded1 = stringify(sort)(rangeDecode(0x000079_000087));
+        if (decoded1 !== '[121,135]') {
+            throw decoded1;
+        }
+        const decoded2 = stringify(sort)(rangeDecode(0x000080_000087));
+        if (decoded2 !== '[128,135]') {
+            throw decoded2;
+        }
+        const decoded3 = stringify(sort)(rangeDecode(0x10FFFF_10FFFF));
+        if (decoded3 !== '[1114111,1114111]') {
+            throw decoded3;
+        }
+    },
+    rangeEncode: () => {
+        const encoded1 = oneEncode(0x79);
+        if (encoded1 !== 0x000079_000079) {
+            throw encoded1;
+        }
+        const encoded2 = oneEncode(0x80);
+        if (encoded2 !== 0x000080_000080) {
+            throw encoded2;
+        }
+        const encoded3 = oneEncode(0x10FFFF);
+        if (encoded3 !== 0x10FFFF_10FFFF) {
+            throw encoded3;
+        }
+    },
     toData: [
         () => {
             const c = toData(classic());
@@ -281,7 +309,16 @@ export default {
             }
         },
         () => {
-            const terminalRangeRule = range('AF');
+            const terminalRangeRule = 0x000079_000087;
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = 0x000080_000087; //broken range
             const m = parser(terminalRangeRule);
             const mr = m("", [64]);
             const result = JSON.stringify(mr);

package/bnf/module.f.d.ts

@@ -9,7 +9,6 @@ import { type Array2 } from '../types/array/module.f.ts';
 export type TerminalRange = number;
 export declare const fullRange: TerminalRange;
 export declare const unicodeRange: TerminalRange;
-export declare const eof = 1114112;
 /** A sequence of rules. */
 export type Sequence = readonly Rule[];
 /** A variant */
@@ -22,6 +21,7 @@ export type Rule = DataRule | LazyRule;
 export declare const max: string;
 export declare const rangeEncode: (a: number, b: number) => TerminalRange;
 export declare const oneEncode: (a: number) => TerminalRange;
+export declare const eof: TerminalRange;
 export declare const rangeDecode: (r: number) => Array2<number>;
 export declare const toSequence: (s: string) => readonly TerminalRange[];
 export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;

package/bnf/module.f.js

@@ -3,7 +3,6 @@ import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
 export const fullRange = 0x000000_FFFFFF;
 export const unicodeRange = 0x000000_10FFFF;
-export const eof = 0x110000;
 // Internals:
 const { fromEntries, values } = Object;
 const { fromCodePoint } = String;
@@ -18,10 +17,11 @@ export const rangeEncode = (a, b) => {
     if (!isValid(a) || !isValid(b) || a > b) {
         throw `Invalid range ${a} ${b}.`;
     }
-    return (a << offset) | b;
+    return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
 };
 export const oneEncode = (a) => rangeEncode(a, a);
-export const rangeDecode = (r) => [r >> offset, r & mask];
+export const eof = oneEncode(0x110000);
+export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), Number(BigInt(r) & BigInt(mask))];
 const mapOneEncode = map(oneEncode);
 export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
 export const str = (s) => {

package/ci/module.f.js

@@ -73,9 +73,7 @@ const toSteps = (m) => {
     return [
         ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
         ...(rust ? [{
-                // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
-                // See https://github.com/sergey-shandar/wasmtime-crash
-                uses: 'dtolnay/rust-toolchain@1.93.0',
+                uses: 'dtolnay/rust-toolchain@1.93.1',
                 with: {
                     components: 'rustfmt,clippy',
                     targets

package/crypto/hmac/test.f.js

@@ -1,5 +1,5 @@
 import { utf8 } from "../../text/module.f.js";
-import { length, uint, vec } from "../../types/bit_vec/module.f.js";
+import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { hmac } from "./module.f.js";
 export default {

package/crypto/sign/test.f.js

@@ -1,7 +1,7 @@
 import { utf8 } from "../../text/module.f.js";
 import { empty, msb, repeat, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
-import { curve, secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
+import { secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
 import { computeSync, sha224, sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { all, concat, computeK, fromCurve, sign } from "./module.f.js";
 const sample = utf8("sample");

package/dev/tf/all.test.js

@@ -7,11 +7,11 @@ const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
 // Bun doesn't support nested tests yet.
 const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrihtFramework = async () => {
+const createPlaywrightFramework = async () => {
     const pwTest = (await import('@playwright/test')).test;
     return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
 };
-const framework = isPlaywright ? await createPlaywrihtFramework() :
+const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
 const parse = parseTestSet(io.tryCatch);

package/dev/tf/module.f.js

@@ -1,4 +1,4 @@
-import { entries, fold } from "../../types/list/module.f.js";
+import { fold } from "../../types/list/module.f.js";
 import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
 import { env, loadModuleMap } from "../module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
@@ -58,7 +58,7 @@ export const test = (input) => {
                     if (isGitHub) {
                         // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
                         // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                        error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
+                        error(`::error file=${k},line=1,title=${i}()::${r}`);
                     }
                     else {
                         error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);

package/djs/parser-new/module.f.js

@@ -134,7 +134,6 @@ export const jsGrammar = () => {
             ]
         }
     ];
-    const endOfFile = oneEncode(eof);
     const token = {
         number,
         string,
@@ -143,7 +142,7 @@ export const jsGrammar = () => {
         operator,
         ws,
         newLine,
-        //endOfFile
+        eof
     };
     const tokens = repeat0Plus(token);
     return tokens;

package/djs/parser-new/test.f.js

@@ -15,9 +15,10 @@ export default {
                 const mr = descentParserCpOnly(m, '', cp);
                 const success = mr[1] && mr[2] === cp.length;
                 if (success !== expected) {
-                    throw mr;
+                    throw JSON.stringify([s, mr]);
                 }
             };
+            expect('"', false);
             expect('   true   ', true);
             expect('   tr2ue   ', true);
             expect('   2true   ', true);

package/io/module.f.d.ts

@@ -104,4 +104,4 @@ export type Run = (f: App) => Promise<never>;
  * Handles errors by exiting with code 1
  */
 export declare const run: (io: Io) => Run;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;

package/io/module.f.js

@@ -26,9 +26,16 @@ const tc = async (f) => {
         return error(e);
     }
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }) => asyncRun({
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => asyncRun({
     error: async (message) => error(message),
     log: async (message) => log(message),
+    fetch: async (url) => tc(async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
+        }
+        return toVec(new Uint8Array(await response.arrayBuffer()));
+    }),
     mkdir: param => tc(async () => { await mkdir(...param); }),
     readFile: path => tc(async () => toVec(await readFile(path))),
     readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))

package/package.json

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

package/text/utf8/module.f.d.ts

@@ -9,7 +9,7 @@ export type U8 = number;
  */
 export type I32 = number;
 /**
- * Represents an unsigend 8-bit type - U8 or the end-of-file indicator.
+ * Represents an unsigned 8-bit type - U8 or the end-of-file indicator.
  * The U8 represents the byte itself, and null indicates that reading does not return anything else.
  */
 export type ByteOrEof = U8 | null;

package/types/asn.1/module.f.d.ts

@@ -0,0 +1,62 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+/** ASN.1 tag number. */
+type Tag = bigint;
+/** ASN.1 universal BOOLEAN tag. */
+export declare const boolean = 1n;
+/** ASN.1 universal INTEGER tag. */
+export declare const integer = 2n;
+/** ASN.1 universal OCTET STRING tag. */
+export declare const octetString = 4n;
+/** ASN.1 universal OBJECT IDENTIFIER tag. */
+export declare const objectIdentifier = 6n;
+export declare const constructedSequence = 48n;
+export declare const constructedSet = 49n;
+/** Raw ASN.1 TLV tuple. */
+export type Raw = readonly [Tag, Vec];
+/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
+export declare const encodeRaw: ([tag, value]: Raw) => Vec;
+/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
+export declare const decodeRaw: (v: Vec) => readonly [Raw, Vec];
+/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
+export declare const encodeBoolean: (b: boolean) => Vec;
+/** Decodes an ASN.1 BOOLEAN value. */
+export declare const decodeBoolean: (v: Vec) => boolean;
+/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
+export declare const encodeInteger: (uint: bigint) => Vec;
+/** Decodes an ASN.1 INTEGER encoded in two's complement. */
+export declare const decodeInteger: (v: Vec) => bigint;
+/** Encodes an OCTET STRING value. */
+export declare const encodeOctetString: (v: Vec) => Vec;
+/** Decodes an OCTET STRING value. */
+export declare const decodeOctetString: (v: Vec) => Vec;
+/** ASN.1 OBJECT IDENTIFIER components. */
+export type ObjectIdentifier = readonly bigint[];
+/** Encodes an OBJECT IDENTIFIER value. */
+export declare const encodeObjectIdentifier: (oid: ObjectIdentifier) => Vec;
+/** Decodes an OBJECT IDENTIFIER value. */
+export declare const decodeObjectIdentifier: (v: Vec) => ObjectIdentifier;
+/** ASN.1 ordered collection of records. */
+export type Sequence = readonly Record[];
+/** Encodes a SEQUENCE payload from ordered records. */
+export declare const encodeSequence: (...records: Sequence) => Vec;
+/** Decodes a SEQUENCE payload into records. */
+export declare const decodeSequence: (v: Vec) => Sequence;
+/** ASN.1 SET represented as a sequence of records. */
+export type Set = Sequence;
+/** Encodes a SET payload with canonical byte ordering. */
+export declare const encodeSet: (...records: Sequence) => Vec;
+/** Decodes a SET payload. */
+export declare const decodeSet: (v: Vec) => Sequence;
+/** Supported ASN.1 record variants. */
+export type SupportedRecord = readonly [typeof boolean, boolean] | readonly [typeof integer, bigint] | readonly [typeof octetString, Vec] | readonly [typeof objectIdentifier, ObjectIdentifier] | readonly [typeof constructedSequence, Sequence] | readonly [typeof constructedSet, Set];
+/**
+ * For unsupported tags, we just store the raw value including the tag and length,
+ * so that it can be re-encoded without loss of information.
+ */
+export type UnsupportedRecord = Vec;
+export type Record = SupportedRecord | UnsupportedRecord;
+/** Encodes a supported ASN.1 record as TLV. */
+export declare const encode: (record: Record) => Vec;
+/** Decodes one supported ASN.1 record and returns the remaining input. */
+export declare const decode: (v: Vec) => readonly [Record, Vec];
+export {};

package/types/asn.1/module.f.js

@@ -0,0 +1,276 @@
+import { bitLength, max } from "../bigint/module.f.js";
+import { empty, isVec, length, listToVec, msb, msbCmp, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
+import { identity } from "../function/module.f.js";
+import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
+const pop = msb.popFront;
+const pop8 = pop(8n);
+const concat = listToVec(msb);
+const classPcMask = 224n;
+const tagNumberMask = 31n;
+const parsedTagEncode = ([classPc, number]) => {
+    const [firstByteNumber, rest] = number < tagNumberMask
+        ? [number, empty]
+        : [tagNumberMask, b128encode(number)];
+    return concat([vec8(classPc | firstByteNumber), rest]);
+};
+const parsedTagDecode = (v) => {
+    const [firstByte, rest] = pop8(v);
+    const classPc = (firstByte & classPcMask);
+    const firstByteNumber = firstByte & tagNumberMask;
+    const [number, rest1] = firstByteNumber < tagNumberMask
+        ? [firstByteNumber, rest]
+        : b128decode(rest);
+    return [[classPc, number], rest1];
+};
+const tagEncode = (tag) => vec(max((bitLength(tag) + 7n) >> 3n)(1n) << 3n)(tag);
+const tagDecode = (v) => {
+    const [parsedTag, rest] = parsedTagDecode(v);
+    return [uint(parsedTagEncode(parsedTag)), rest];
+};
+//
+const eoc = 0x00n;
+/** ASN.1 universal BOOLEAN tag. */
+export const boolean = 0x01n;
+/** ASN.1 universal INTEGER tag. */
+export const integer = 0x02n;
+const bitString = 0x03n;
+/** ASN.1 universal OCTET STRING tag. */
+export const octetString = 0x04n;
+const null_ = 0x05;
+/** ASN.1 universal OBJECT IDENTIFIER tag. */
+export const objectIdentifier = 0x06n;
+const objectDescriptor = 0x07;
+const external = 0x08;
+const real = 0x09;
+const enumerated = 0x0A;
+const embeddedPdv = 0x0B;
+const utf8string = 0x0C;
+const relativeOid = 0x0D;
+const time = 0x0E;
+const sequence = 0x10;
+const set = 0x11;
+const numericString = 0x12;
+const printableString = 0x13;
+const t61String = 0x14;
+const videotexString = 0x15;
+const ia5String = 0x16;
+const utcTime = 0x17;
+const generalizedTime = 0x18;
+const graphicString = 0x19;
+const visibleString = 0x1A;
+const generalString = 0x1B;
+const universalString = 0x1C;
+const characterString = 0x1D;
+const bmpString = 0x1E;
+const date = 0x1F;
+const timeOfDay = 0x20;
+const dateTime = 0x21;
+const duration = 0x22;
+const oidIri = 0x23;
+const relativeOidIri = 0x24;
+const constructed = 0x20;
+export const constructedSequence = 0x30n; // constructed | sequence
+export const constructedSet = 0x31n; // constructed | set
+const round8 = ({ length, uint }) => {
+    const byteLen = (length + 7n) >> 3n;
+    return { byteLen, v: vec(byteLen << 3n)(uint) };
+};
+const lenEncode = (uint) => {
+    if (uint < 0x80n) {
+        return vec8(uint);
+    }
+    const { byteLen, v } = round8({ length: bitLength(uint), uint });
+    return concat([vec8(0x80n | byteLen), v]);
+};
+/**
+ * Decodes the length field of an ASN.1 TLV and returns the length in bits and the remaining input.
+ *
+ * @param v - The input bit vector starting with the length field.
+ * @returns A tuple containing the length in bits and the remaining input after the length field.
+ */
+const lenDecode = (v) => {
+    const firstAndRest = pop8(v);
+    const [first, rest1] = firstAndRest;
+    const [byteLen, rest2] = first < 0x80n ? firstAndRest : pop((first & 0x7fn) << 3n)(rest1);
+    return [byteLen << 3n, rest2];
+};
+/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
+export const encodeRaw = ([tag, value]) => {
+    const tagVec = tagEncode(tag);
+    const { byteLen, v } = round8(unpack(value));
+    return concat([tagVec, lenEncode(byteLen), v]);
+};
+/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
+export const decodeRaw = (v) => {
+    const [tag, v1] = tagDecode(v);
+    const [len, v2] = lenDecode(v1);
+    const [result, next] = pop(len)(v2);
+    return [[tag, vec(len)(result)], next];
+};
+// boolean
+/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
+export const encodeBoolean = (b) => vec8(b ? 0xffn : 0x00n);
+/** Decodes an ASN.1 BOOLEAN value. */
+export const decodeBoolean = (v) => uint(v) !== 0n;
+// integer (two's compliment)
+/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
+export const encodeInteger = (uint) => {
+    const offset = uint < 0n ? 1n : 0n;
+    return round8({ length: bitLength(uint + offset) + 1n, uint }).v;
+};
+/** Decodes an ASN.1 INTEGER encoded in two's complement. */
+export const decodeInteger = (v) => {
+    const { length, uint } = unpack(v);
+    const sign = uint >> (length - 1n);
+    return sign === 0n ? uint : uint - (1n << length);
+};
+// octet string
+/** Encodes an OCTET STRING value. */
+export const encodeOctetString = (v) => v;
+/** Decodes an OCTET STRING value. */
+export const decodeOctetString = (v) => v;
+/** Encodes an OBJECT IDENTIFIER value. */
+export const encodeObjectIdentifier = (oid) => {
+    const [first, second, ...rest] = oid;
+    const firstByte = first * 40n + second;
+    return concat([vec8(firstByte), ...rest.map(b128encode)]);
+};
+/** Decodes an OBJECT IDENTIFIER value. */
+export const decodeObjectIdentifier = (v) => {
+    const [firstByte, rest] = pop8(v);
+    const first = firstByte / 40n;
+    const second = firstByte % 40n;
+    let result = [first, second];
+    let tail = rest;
+    while (length(tail) > 0n) {
+        const [value, next] = b128decode(tail);
+        result = [...result, value];
+        tail = next;
+    }
+    return result;
+};
+const genericEncodeSequence = (map) => (...records) => concat(map(records.map(encode)));
+/** Encodes a SEQUENCE payload from ordered records. */
+export const encodeSequence = genericEncodeSequence(identity);
+/** Decodes a SEQUENCE payload into records. */
+export const decodeSequence = (v) => {
+    let result = [];
+    while (length(v) !== 0n) {
+        const [record, rest] = decode(v);
+        result = [...result, record];
+        v = rest;
+    }
+    return result;
+};
+/** Encodes a SET payload with canonical byte ordering. */
+export const encodeSet = genericEncodeSequence(v => v.toSorted((a, b) => msbCmp(a)(b)));
+/** Decodes a SET payload. */
+export const decodeSet = decodeSequence;
+// encode
+const recordToRaw = ([tag, value]) => {
+    switch (tag) {
+        case boolean: return encodeBoolean(value);
+        case integer: return encodeInteger(value);
+        case octetString: return encodeOctetString(value);
+        case objectIdentifier: return encodeObjectIdentifier(value);
+        case constructedSequence: return encodeSequence(...value);
+        case constructedSet: return encodeSet(...value);
+    }
+};
+/** Encodes a supported ASN.1 record as TLV. */
+export const encode = (record) => isVec(record) ? record : encodeRaw([record[0], recordToRaw(record)]);
+// decode
+const rawToRecord = (raw) => {
+    const [tag, value] = raw;
+    switch (tag) {
+        case boolean: return [boolean, decodeBoolean(value)];
+        case integer: return [integer, decodeInteger(value)];
+        case octetString: return [octetString, decodeOctetString(value)];
+        case objectIdentifier: return [objectIdentifier, decodeObjectIdentifier(value)];
+        case constructedSequence: return [constructedSequence, decodeSequence(value)];
+        case constructedSet: return [constructedSet, decodeSet(value)];
+        default: return encodeRaw(raw);
+    }
+};
+/** Decodes one supported ASN.1 record and returns the remaining input. */
+export const decode = (v) => {
+    const [raw, rest] = decodeRaw(v);
+    return [rawToRecord(raw), rest];
+};
+/*
+TimeStampReq ::= SEQUENCE {
+    version        INTEGER { v1(1) },               // [x]
+    messageImprint MessageImprint,
+    reqPolicy      TSAPolicyId OPTIONAL,
+    nonce          INTEGER OPTIONAL,                // [X]
+    certReq        BOOLEAN DEFAULT FALSE,           // [X]
+    extensions     [0] IMPLICIT Extensions OPTIONAL // [X]
+}
+
+MessageImprint ::= SEQUENCE {
+    hashAlgorithm  AlgorithmIdentifier,
+    hashedMessage  OCTET STRING         // [X]
+}
+
+TSAPolicyId ::= OBJECT IDENTIFIER // [X]
+*/
+/*
+TimeStampResp ::= SEQUENCE {
+    status          PKIStatusInfo,
+    timeStampToken  TimeStampToken OPTIONAL
+}
+
+PKIStatusInfo ::= SEQUENCE {
+    status        PKIStatus,
+    statusString  PKIFreeText OPTIONAL,
+    failInfo      PKIFailureInfo OPTIONAL
+}
+
+PKIStatus ::= INTEGER {         // [X]
+    granted                (0),
+    grantedWithMods        (1),
+    rejection              (2),
+    waiting                (3),
+    revocationWarning      (4),
+    revocationNotification (5)
+}
+
+TimeStampToken ::= ContentInfo
+
+ContentInfo ::= SEQUENCE {
+    contentType ContentType,
+    content     [0] EXPLICIT ANY DEFINED BY contentType
+}
+
+ContentType ::= OBJECT IDENTIFIER
+
+SignedData ::= SEQUENCE {
+    version          CMSVersion,
+    digestAlgorithms SET OF DigestAlgorithmIdentifier,            // [X]
+    encapContentInfo EncapsulatedContentInfo,
+    certificates     [0] IMPLICIT CertificateSet OPTIONAL,
+    crls             [1] IMPLICIT RevocationInfoChoices OPTIONAL,
+    signerInfos      SET OF SignerInfo                            // [X]
+}
+
+EncapsulatedContentInfo ::= SEQUENCE {
+    eContentType ContentType,
+    eContent     [0] EXPLICIT OCTET STRING OPTIONAL
+}
+
+TSTInfo ::= SEQUENCE  {
+    version        INTEGER  { v1(1) },
+    policy         TSAPolicyId,
+    messageImprint MessageImprint,
+    serialNumber   INTEGER,
+    genTime        GeneralizedTime,
+    accuracy       Accuracy OPTIONAL,
+    ordering       BOOLEAN DEFAULT FALSE,
+    nonce          INTEGER OPTIONAL,
+    tsa            [0] GeneralName OPTIONAL,
+    extensions     [1] IMPLICIT Extensions OPTIONAL
+}
+
+Bits:  8 7   | 6    | 5 4 3 2 1
+       Class | P/C  | Tag number
+*/

package/types/asn.1/test.f.d.ts

@@ -0,0 +1,44 @@
+declare const _default: {
+    encodeSmall: () => void;
+    encode7F: () => void;
+    encode80: () => void;
+    encodeFF: () => void;
+    encode103: () => void;
+    ed: ((() => void) | {
+        x80: () => void;
+        x100: () => void;
+        x1000: () => void;
+        x10000: () => void;
+        x20000: () => void;
+        x40000: () => void;
+        x80000: () => void;
+        xC0000: () => void;
+        xE0000: () => void;
+        xF0000: () => void;
+        xFFF00: () => void;
+        xFFF80: () => void;
+        xFFFC0: () => void;
+        xFFFD0: () => void;
+    })[];
+    integerValue: {
+        zero: () => void;
+        one: () => void;
+        minusOne: () => void;
+        x7F: () => void;
+        x80: () => void;
+        xFF: () => void;
+        nx7F: () => void;
+        nx80: () => void;
+        nx81: () => void;
+        nx7FFF: () => void;
+        nx8000: () => void;
+        nx8001: () => void;
+    };
+    encodeDecode: {
+        integer: () => void;
+        sequence: () => void;
+        set: () => void;
+    };
+    raw: (() => void)[];
+};
+export default _default;

package/types/asn.1/test.f.js

@@ -0,0 +1,312 @@
+import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
+import { asBase } from "../nominal/module.f.js";
+import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet } from "./module.f.js";
+const { concat, popFront: pop } = msb;
+const cat = listToVec(msb);
+const pop8 = pop(8n);
+const check = (tag, v, rest) => {
+    const s = encodeRaw([tag, v]);
+    const [[t0, v0], r] = decodeRaw(concat(s)(rest));
+    if (t0 !== tag) {
+        throw `t0: ${t0}`;
+    }
+    if (v0 !== v) {
+        throw `v0: ${asBase(v0)}`;
+    }
+    if (r !== rest) {
+        throw `r: ${asBase(r)}`;
+    }
+};
+const integerValueCheck = (i, v) => {
+    const v0 = encodeInteger(i);
+    if (v !== v0) {
+        throw `encode: ${asBase(v)}, ${asBase(v0)}`;
+    }
+    const i0 = decodeInteger(v);
+    if (i !== i0) {
+        throw [i, i0];
+    }
+};
+const ch0 = (r, v, rest) => {
+    const [r0, rest0] = decode(concat(v)(rest));
+    if (rest0 !== rest) {
+        throw `rest: ${asBase(rest0)}`;
+    }
+    const v0 = encode(r);
+    const v1 = encode(r0);
+    if (v !== v0) {
+        throw `encode: ${asBase(v)}, ${asBase(v0)}`;
+    }
+    if (v !== v1) {
+        throw `encode: ${asBase(v)}, ${asBase(v1)}`;
+    }
+};
+const ch = (r, v) => {
+    ch0(r, v, empty);
+    ch0(r, v, vec8(0x23n));
+    ch0(r, v, vec(16n)(0x2345n));
+};
+export default {
+    encodeSmall: () => {
+        const v = vec8(0x13n);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 24n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [len, x2] = pop8(x1);
+        if (len !== 1n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x2);
+        if (intLen !== 8n) {
+            throw intLen;
+        }
+        if (uint !== 0x13n) {
+            throw uint;
+        }
+    },
+    encode7F: () => {
+        const valueLen = 0x7fn << 3n;
+        const value = 0x1234n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 0x81n << 3n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [len, x2] = pop8(x1);
+        if (len !== 0x7fn) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x2);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encode80: () => {
+        const valueLen = 0x80n << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 0x83n << 3n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x81n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop8(x2);
+        if (len !== 0x80n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encodeFF: () => {
+        const valueLen = 0xffn << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== valueLen + (3n << 3n)) {
+            throw `lx: ${lx}`;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x81n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop8(x2);
+        if (len !== 0xffn) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encode103: () => {
+        const valueLen = 0x103n << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== valueLen + (4n << 3n)) {
+            throw `lx: ${lx}`;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x82n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop(16n)(x2);
+        if (len !== 0x103n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    ed: [
+        () => {
+            const tag = integer;
+            const v = vec(0x10n)(0x8234n);
+            if (asBase(v) !== 0x8234n) {
+                throw asBase(v).toString(16);
+            }
+            check(integer, v, empty);
+        },
+        {
+            x80: () => check(integer, vec(0x80n)(0x8234n), empty),
+            x100: () => check(integer, vec(0x100n)(0x8234n), vec8(0x23n)),
+            x1000: () => check(integer, vec(0x1000n)(0x8234n), vec8(0x23n)),
+            x10000: () => check(integer, vec(0x10000n)(0x8234n), vec8(0x23n)),
+            x20000: () => check(integer, vec(0x20000n)(0x8234n), vec8(0x23n)),
+            x40000: () => check(integer, vec(0x40000n)(0x8234n), empty),
+            x80000: () => check(integer, vec(0x80000n)(0x8234n), empty),
+            xC0000: () => check(integer, vec(0xc0000n)(0x8234n), empty),
+            xE0000: () => check(integer, vec(0xe0000n)(0x8234n), empty),
+            xF0000: () => check(integer, vec(0xf0000n)(0x8234n), empty),
+            xFFF00: () => check(integer, vec(0xfff00n)(0x8234n), empty),
+            xFFF80: () => check(integer, vec(0xfff80n)(0x8234n), empty),
+            xFFFC0: () => check(integer, vec(0xfffc0n)(0x8234n), empty),
+            xFFFD0: () => check(integer, vec(0xfffd0n)(0x8234n), empty),
+            //// fail on Bun because it has a smaller limit for BigInt
+            //xFFFD8: () => check(integer, vec(0xF_FFD8n)(0x8234n), empty),
+            //xFFFE0: () => check(integer, vec(0xF_FFE0n)(0x8234n), empty),
+            //e100000: () => check(integer, vec(0x10_0000n)(0x8234n), empty),
+            //x100000: () => check(integer, vec(0x10_0000n)(0x8234n), vec8(0x23n)),
+            //x1000000: () => check(integer, vec(0x100_0000n)(0x8234n), vec8(0x23n)),
+            //x10000000: () => check(integer, vec(0x1000_0000n)(0x8234n), vec8(0x23n)),
+            //x20000000: () => check(integer, vec(0x2000_0000n)(0x8234n), vec8(0x23n)),
+            //x30000000: () => check(integer, vec(0x3000_0000n)(0x8234n), vec8(0x23n)),
+            //x38000000: () => check(integer, vec(0x3800_0000n)(0x8234n), vec8(0x23n)),
+            //x3C000000: () => check(integer, vec(0x3800_0000n)(0x8234n), vec8(0x23n)),
+            //x3E000000: () => check(integer, vec(0x3E00_0000n)(0x8234n), vec8(0x23n)),
+            //x3F000000: () => check(integer, vec(0x3F00_0000n)(0x8234n), vec8(0x23n)),
+            //x3F800000: () => check(integer, vec(0x3F80_0000n)(0x8234n), vec8(0x23n)),
+            //x3FFFFFC0: () => check(integer, vec(0x3FFF_FFC0n)(0x8234n), vec8(0x23n)),
+            //e3FFFFFC8: () => check(integer, vec(0x3FFF_FFC8n)(0x8234n), empty),
+            //// fail on Node
+            //x3FFFFFC8: () => check(integer, vec(0x3FFF_FFC1n)(0x8234n), vec8(0x23n)),
+            //x40000000: () => check(integer, vec(0x4000_0000n)(0x8234n), vec8(0x23n)),
+            // check(integer, vec(0x1_0000_0000n)(0x8234n), vec8(0x23n))
+        },
+    ],
+    integerValue: {
+        zero: () => integerValueCheck(0n, vec8(0n)),
+        one: () => integerValueCheck(1n, vec8(1n)),
+        minusOne: () => integerValueCheck(-1n, vec8(0xffn)),
+        x7F: () => integerValueCheck(0x7fn, vec8(0x7fn)),
+        x80: () => integerValueCheck(0x80n, vec(16n)(0x80n)),
+        xFF: () => integerValueCheck(0xffn, vec(16n)(0xffn)),
+        nx7F: () => integerValueCheck(-0x7fn, vec8(0x81n)),
+        nx80: () => integerValueCheck(-0x80n, vec8(0x80n)),
+        nx81: () => integerValueCheck(-0x81n, vec(16n)(0xff7fn)),
+        nx7FFF: () => integerValueCheck(-0x7fffn, vec(16n)(0x8001n)),
+        nx8000: () => integerValueCheck(-0x8000n, vec(16n)(0x8000n)),
+        nx8001: () => integerValueCheck(-0x8001n, vec(24n)(0xff7fffn)),
+    },
+    encodeDecode: {
+        integer: () => {
+            ch([integer, 0n], cat([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
+            ch([integer, 1n], cat([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
+        },
+        sequence: () => {
+            ch([constructedSequence, []], cat([vec8(BigInt(constructedSequence)), vec8(0n)]));
+            ch([constructedSequence, [[integer, 0n]]], cat([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
+            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], cat([
+                vec8(BigInt(constructedSequence)),
+                vec8(6n),
+                encode([integer, 1n]),
+                encode([integer, 2n])
+            ]));
+            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], cat([
+                vec8(BigInt(constructedSequence)),
+                vec8(9n),
+                encode([octetString, vec8(0x23n)]),
+                encode([boolean, true]),
+                encode([boolean, false]),
+            ]));
+        },
+        set: () => {
+            ch([constructedSet, [[integer, 2n], [integer, 1n]]], cat([
+                vec8(BigInt(constructedSet)),
+                vec8(6n),
+                encode([integer, 1n]),
+                encode([integer, 2n])
+            ]));
+        },
+    },
+    raw: [
+        () => {
+            const e = encodeRaw([0x00n, vec8(0x23n)]);
+            if (e !== cat([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
+                throw `encode: ${length(e)}: ${uint(e).toString(2)}`;
+            }
+            const [[tag, value], rest] = decodeRaw(e);
+            if (rest !== empty) {
+                throw `rest: ${asBase(rest)}`;
+            }
+            if (tag !== 0x00n) {
+                throw `tag: ${tag}`;
+            }
+            if (value !== vec8(0x23n)) {
+                throw `value: ${asBase(value)}`;
+            }
+        },
+        () => {
+            const e = encodeRaw([0x1f20n, vec(16n)(0x1234n)]);
+            if (e !== cat([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
+                const l = length(e);
+                const u = uint(e);
+                throw `encode: ${l}: ${u.toString(16)}`;
+            }
+            const [[tag, value], rest] = decodeRaw(e);
+            if (rest !== empty) {
+                throw `rest: ${asBase(rest)}`;
+            }
+            if (tag !== 0x1f20n) {
+                throw `tag: ${tag}`;
+            }
+            if (value !== vec(16n)(0x1234n)) {
+                throw `value: ${asBase(value)}`;
+            }
+        }
+    ]
+};

package/types/base128/module.f.d.ts

@@ -0,0 +1,15 @@
+import { type Vec } from '../bit_vec/module.f.ts';
+/**
+ * Encodes a bigint into an MSB Base128 vector.
+ *
+ * @param uint The bigint to encode.
+ * @returns The encoded MSB Base128 vector.
+ */
+export declare const encode: (uint: bigint) => Vec;
+/**
+ * Decodes an MSB Base128 vector into a bigint.
+ *
+ * @param v The MSB Base128 vector to decode.
+ * @returns A tuple containing the decoded bigint and the remaining vector.
+ */
+export declare const decode: (v: Vec) => readonly [bigint, Vec];

package/types/base128/module.f.js

@@ -0,0 +1,38 @@
+import { vec8, msb, empty } from "../bit_vec/module.f.js";
+const { concat, popFront } = msb;
+const pop8 = popFront(8n);
+/**
+ * Encodes a bigint into an MSB Base128 vector.
+ *
+ * @param uint The bigint to encode.
+ * @returns The encoded MSB Base128 vector.
+ */
+export const encode = (uint) => {
+    let result = empty;
+    while (true) {
+        const item = uint & 0x7fn;
+        const flag = result === empty ? 0n : 0x80n;
+        result = concat(vec8(flag | item))(result);
+        uint >>= 7n;
+        if (uint === 0n) {
+            return result;
+        }
+    }
+};
+/**
+ * Decodes an MSB Base128 vector into a bigint.
+ *
+ * @param v The MSB Base128 vector to decode.
+ * @returns A tuple containing the decoded bigint and the remaining vector.
+ */
+export const decode = (v) => {
+    let result = 0n;
+    while (true) {
+        const [byte, rest] = pop8(v);
+        result = (result << 7n) | (byte & 0x7fn);
+        if (byte < 0x80n) {
+            return [result, rest];
+        }
+        v = rest;
+    }
+};

package/types/base128/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/types/base128/test.f.js

@@ -0,0 +1,26 @@
+import { empty, vec, vec8 } from "../bit_vec/module.f.js";
+import { asBase } from "../nominal/module.f.js";
+import { encode, decode } from "./module.f.js";
+const test = (a, b) => {
+    const encoded = encode(a);
+    if (encoded !== b) {
+        throw `encoded: ${asBase(encoded).toString(16)}, expected: ${asBase(b).toString(16)}`;
+    }
+    const [decoded, rest] = decode(b);
+    if (decoded !== a) {
+        throw `decoded: ${decoded.toString(16)}, expected: ${a.toString(16)}`;
+    }
+    if (rest !== empty) {
+        throw `rest: ${asBase(rest).toString(16)}, expected: ${asBase(empty).toString(16)}`;
+    }
+};
+export default () => {
+    test(0n, vec8(0n));
+    test(1n, vec8(1n));
+    test(0x7fn, vec8(0x7fn));
+    test(0x80n, vec(16n)(0x8100n));
+    test(0x81n, vec(16n)(0x8101n));
+    test(0x82n, vec(16n)(0x8102n));
+    test(0x3fffn, vec(16n)(0xff7fn));
+    test(0x4000n, vec(24n)(0x818000n));
+};

package/types/bit_vec/module.f.d.ts

@@ -1,6 +1,7 @@
-import type { Fold, Reduce as OpReduce } from "../function/operator/module.f.ts";
-import { type List, type Thunk } from "../list/module.f.ts";
-import { type Nominal } from "../nominal/module.f.ts";
+import type { Fold, Reduce as OpReduce } from '../function/operator/module.f.ts';
+import { type List, type Thunk } from '../list/module.f.ts';
+import { type Nominal } from '../nominal/module.f.ts';
+import { type Sign } from '../function/compare/module.f.ts';
 /**
  * A vector of bits represented as a signed `bigint`.
  */
@@ -186,3 +187,13 @@ export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => V
  */
 export declare const repeat: Fold<bigint, Vec>;
 export declare const isVec: <T>(v: Vec | T) => v is Vec;
+/**
+ * Lexically compares two vectors based on their unsigned integer values,
+ * normalizing them to the same length. If the values are equal,
+ * the shorter vector is considered smaller.
+ *
+ * a < b => -1
+ * a > b => 1
+ * a === b => 0
+ */
+export declare const msbCmp: (av: Vec) => (bv: Vec) => Sign;

package/types/bit_vec/module.f.js

@@ -21,11 +21,12 @@
  *
  * @module
  */
-import { abs, bitLength, mask, max, xor } from "../bigint/module.f.js";
+import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
 import { fold } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
+import { cmp } from "../function/compare/module.f.js";
 /**
  * An empty vector of bits.
  */
@@ -55,7 +56,7 @@ export const vec = (len) => {
     const lastBit = 1n << last;
     return ui => {
         // normalize `u`
-        const u = m & abs(ui);
+        const u = m & ui;
         //
         const sign = u >> last;
         const x = sign !== 0n ? u : -(u ^ lastBit);
@@ -203,3 +204,21 @@ export const listToVec = ({ concat }) => fold(flip(concat))(empty);
  */
 export const repeat = mRepeat({ identity: empty, operation: lsb.concat });
 export const isVec = (v) => typeof v === 'bigint';
+/**
+ * Lexically compares two vectors based on their unsigned integer values,
+ * normalizing them to the same length. If the values are equal,
+ * the shorter vector is considered smaller.
+ *
+ * a < b => -1
+ * a > b => 1
+ * a === b => 0
+ */
+export const msbCmp = (av) => (bv) => {
+    const au = unpack(av);
+    const bu = unpack(bv);
+    const al = au.length;
+    const bl = bu.length;
+    const { a, b } = msbNorm(au)(bu)(min(al)(bl));
+    const result = cmp(a)(b);
+    return result !== 0 ? result : cmp(al)(bl);
+};

package/types/bit_vec/test.f.d.ts

@@ -37,5 +37,6 @@ declare const _default: {
     lsbXor: () => void;
     msbXor: () => void;
     repeat: () => void;
+    msbCmp: () => void;
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,6 @@
-import { abs, mask } from "../bigint/module.f.js";
+import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8 } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp } from "./module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
 // 0x9 = 0b1001 = 1 + 8
@@ -347,16 +347,16 @@ export default {
             const v = vec(len)(ui);
             const x = asBase(v);
             if (x !== raw) {
-                throw x;
+                throw `x: ${x}, raw: ${raw}`;
             }
             const len2 = length(v);
             if (len2 !== len) {
                 throw len2;
             }
             const u = uint(v);
-            const mui = mask(len) & abs(ui);
+            const mui = mask(len) & ui;
             if (u !== mui) {
-                throw u;
+                throw [u, mui];
             }
         };
         // 0n
@@ -373,7 +373,15 @@ export default {
             () => c(2n)(1n)(-3n),
             () => c(2n)(2n)(2n),
             () => c(2n)(3n)(3n),
-            () => c(2n)(-7n)(3n), //< overflow
+            // -1 is 0b.....1
+            // -2 is 0b....10
+            // -3 is 0b...101
+            // -4 is 0b...100
+            // -5 is 0b..1011
+            // -6 is 0b..1010
+            // -7 is 0b..1011, cut 0b11, vec: -0b11
+            // -8 is 0b..1100 = ~(8-1) = ~7
+            () => c(2n)(-7n)(-3n), //< overflow.
         ];
     },
     concat2: () => {
@@ -420,5 +428,19 @@ export default {
         if (repeat(7n)(vec(5n)(0x13n)) !== vec(35n)(21059194483n)) {
             throw 'repeat failed';
         }
+    },
+    msbCmp: () => {
+        const c = (a) => (b) => (r) => {
+            const result = msbCmp(a)(b);
+            if (result !== r) {
+                throw `result: ${result}, expected: ${r}`;
+            }
+        };
+        c(vec(4n)(0x5n))(vec(4n)(0x5n))(0); // 0b0101 == 0b0101
+        c(vec(4n)(0x5n))(vec(4n)(0x6n))(-1); // 0b0101 < 0b0110
+        c(vec(4n)(0x6n))(vec(4n)(0x5n))(1); // 0b0110 > 0b0101
+        c(vec(4n)(0x5n))(vec(5n)(0x5n))(1); // 0b0101_ < 0b00101
+        c(vec(5n)(0x5n))(vec(4n)(0x5n))(-1); // 0b00101 < 0b0101_
+        c(vec(4n)(0x5n))(vec(5n)(0xan))(-1); // 0b0101_ < 0b01010
     }
 };

package/types/effect/node/module.f.d.ts

@@ -2,6 +2,10 @@ import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
 import { type Do, type Effect, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
+export type Fetch = {
+    readonly fetch: readonly [string, IoResult<Vec>];
+};
+export declare const fetch: (url: string) => Do<Fetch, IoResult<Vec>>;
 export type MakeDirectoryOptions = {
     readonly recursive: true;
 };
@@ -46,7 +50,7 @@ export type Log = {
 };
 export declare const log: (msg: string) => Do<Log, void>;
 export type Console = Log & Error;
-export type NodeOperations = Console & Fs;
+export type NodeOperations = Fetch & Console & Fs;
 export type NodeEffect<T> = Effect<NodeOperations, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOperations>;
 export type NodeProgram = (argv: readonly string[]) => NodeEffect<number>;

package/types/effect/node/module.f.js

@@ -1,4 +1,5 @@
 import { do_ } from "../module.f.js";
+export const fetch = (url) => do_('fetch', url);
 export const mkdir = (...p) => do_('mkdir', p);
 export const readFile = (path) => do_('readFile', path);
 export const readdir = (...p) => do_('readdir', p);

package/types/effect/node/test.f.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     map: () => void;
+    fetch: () => void;
     mkdir: {
         one: () => void;
         rec: () => void;

package/types/effect/node/test.f.js

@@ -1,6 +1,6 @@
 import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
 import { run } from "../mock/module.f.js";
-import { mkdir, readdir, readFile, writeFile } from "./module.f.js";
+import { fetch, mkdir, readdir, readFile, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export default {
     map: () => {
@@ -29,6 +29,24 @@ export default {
             e = cont(['ok', vec8(0x15n)]);
         }
     },
+    fetch: () => {
+        const v = run(virtual);
+        const [_, [t, result]] = v({
+            ...emptyState,
+            internet: {
+                'https://example.com/data': vec8(0x2an),
+            },
+        })(fetch('https://example.com/data'));
+        if (t === 'error') {
+            throw result;
+        }
+        if (!isVec(result)) {
+            throw result;
+        }
+        if (uint(result) !== 0x2an) {
+            throw result;
+        }
+    },
     mkdir: {
         one: () => {
             const v = run(virtual);

package/types/effect/node/virtual/module.f.d.ts

@@ -8,6 +8,9 @@ export type VirtualState = {
     stdout: string;
     stderr: string;
     root: VirtualDir;
+    internet: {
+        readonly [url: string]: Vec;
+    };
 };
 export declare const emptyState: VirtualState;
 export declare const virtual: MemOperationMap<NodeOperations, VirtualState>;

package/types/effect/node/virtual/module.f.js

@@ -5,6 +5,7 @@ export const emptyState = {
     stdout: '',
     stderr: '',
     root: {},
+    internet: {},
 };
 const operation = (op) => {
     const f = (dir, path) => {
@@ -91,6 +92,10 @@ const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name
 export const virtual = {
     error: console('stderr'),
     log: console('stdout'),
+    fetch: (state, url) => {
+        const result = state.internet[url];
+        return result === undefined ? [state, error('not found')] : [state, ok(result)];
+    },
     mkdir: (state, [path, p]) => mkdir(p !== undefined)(state, path),
     readFile,
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),