@btoon/js 0.0.0-stage → 0.1.0

package/dist/cjs/sha256.js

@@ -0,0 +1,141 @@
+"use strict";
+// SHA-256 (FIPS 180-4) and HMAC-SHA256 (RFC 2104) for runtimes without a synchronous
+// native implementation. Used only for the signed envelope (SPEC §8).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.hmacSha256 = hmacSha256;
+exports.timingSafeEqual = timingSafeEqual;
+const K = new Int32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98,
+    0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8,
+    0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+    0xc67178f2,
+]);
+const IV = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+class Sha256 {
+    constructor() {
+        this.h = new Int32Array(IV);
+        this.w = new Int32Array(64);
+        this.block = new Uint8Array(64);
+        this.blockLen = 0;
+        this.total = 0;
+    }
+    update(data) {
+        let i = 0;
+        const n = data.length;
+        this.total += n;
+        if (this.blockLen > 0) {
+            const take = Math.min(64 - this.blockLen, n);
+            this.block.set(data.subarray(0, take), this.blockLen);
+            this.blockLen += take;
+            i = take;
+            if (this.blockLen < 64)
+                return this;
+            this.compress(this.block, 0);
+            this.blockLen = 0;
+        }
+        for (; i + 64 <= n; i += 64)
+            this.compress(data, i);
+        if (i < n) {
+            this.block.set(data.subarray(i), 0);
+            this.blockLen = n - i;
+        }
+        return this;
+    }
+    digest() {
+        const bits = this.total * 8;
+        const block = this.block;
+        block[this.blockLen++] = 0x80;
+        if (this.blockLen > 56) {
+            block.fill(0, this.blockLen);
+            this.compress(block, 0);
+            this.blockLen = 0;
+        }
+        block.fill(0, this.blockLen, 56);
+        const view = new DataView(block.buffer);
+        view.setUint32(56, Math.floor(bits / 4294967296));
+        view.setUint32(60, bits >>> 0);
+        this.compress(block, 0);
+        const out = new Uint8Array(32);
+        const ov = new DataView(out.buffer);
+        for (let j = 0; j < 8; j++)
+            ov.setInt32(j * 4, this.h[j]);
+        return out;
+    }
+    compress(d, p) {
+        const w = this.w;
+        for (let j = 0; j < 16; j++, p += 4)
+            w[j] = (d[p] << 24) | (d[p + 1] << 16) | (d[p + 2] << 8) | d[p + 3];
+        for (let j = 16; j < 64; j++) {
+            const a = w[j - 15];
+            const b = w[j - 2];
+            const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
+            const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
+            w[j] = (w[j - 16] + s0 + w[j - 7] + s1) | 0;
+        }
+        const h = this.h;
+        let a = h[0];
+        let b = h[1];
+        let c = h[2];
+        let e = h[4];
+        let f = h[5];
+        let g = h[6];
+        let d0 = h[3];
+        let hh = h[7];
+        for (let j = 0; j < 64; j++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + K[j] + w[j]) | 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) | 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d0 + t1) | 0;
+            d0 = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        h[0] = (h[0] + a) | 0;
+        h[1] = (h[1] + b) | 0;
+        h[2] = (h[2] + c) | 0;
+        h[3] = (h[3] + d0) | 0;
+        h[4] = (h[4] + e) | 0;
+        h[5] = (h[5] + f) | 0;
+        h[6] = (h[6] + g) | 0;
+        h[7] = (h[7] + hh) | 0;
+    }
+}
+function sha256(data) {
+    return new Sha256().update(data).digest();
+}
+/** HMAC-SHA256 over the concatenation of `parts` (no copy of the parts is made). */
+function hmacSha256(key, parts) {
+    const k = key.length > 64 ? sha256(key) : key;
+    const ipad = new Uint8Array(64);
+    const opad = new Uint8Array(64);
+    for (let i = 0; i < 64; i++) {
+        const b = i < k.length ? k[i] : 0;
+        ipad[i] = b ^ 0x36;
+        opad[i] = b ^ 0x5c;
+    }
+    const inner = new Sha256().update(ipad);
+    for (const p of parts)
+        inner.update(p);
+    return new Sha256().update(opad).update(inner.digest()).digest();
+}
+/** Compares two byte strings in time that depends only on their length. */
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+        diff |= a[i] ^ b[i];
+    return diff === 0;
+}

package/dist/cjs/utf8.d.ts

@@ -0,0 +1,19 @@
+export declare const textEncoder: TextEncoder;
+/** True if `s` has no lone surrogates, i.e. it can be encoded as UTF-8 losslessly. */
+export declare function isWellFormed(s: string): boolean;
+export declare function loneSurrogateError(): Error;
+/** Exact UTF-8 byte length of `s`; throws `invalid_utf8` for a lone surrogate. */
+export declare function utf8Length(s: string): number;
+/**
+ * Orders strings by their UTF-8 bytes (SPEC §4.4), which equals code point order. Plain
+ * `<` compares UTF-16 code units, which puts astral characters (surrogate pairs,
+ * U+D800–U+DFFF) before U+E000–U+FFFF; this corrects exactly that case.
+ */
+export declare function compareUtf8(a: string, b: string): number;
+/**
+ * Decodes `length` bytes at `start`. Strict mode rejects ill-formed UTF-8 (RFC 3629:
+ * overlongs, surrogates, > U+10FFFF, truncated sequences) via TextDecoder's fatal mode;
+ * non-strict mode substitutes U+FFFD. Returns `undefined` for invalid input so the caller
+ * can report the position.
+ */
+export declare function decodeUtf8(bytes: Uint8Array, start: number, length: number, strict: boolean): string | undefined;

package/dist/cjs/utf8.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textEncoder = void 0;
+exports.isWellFormed = isWellFormed;
+exports.loneSurrogateError = loneSurrogateError;
+exports.utf8Length = utf8Length;
+exports.compareUtf8 = compareUtf8;
+exports.decodeUtf8 = decodeUtf8;
+const errors_js_1 = require("./errors.js");
+exports.textEncoder = new TextEncoder();
+// ignoreBOM: true keeps a leading U+FEFF instead of silently stripping it.
+const fatalDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const lenientDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
+const LONE_SURROGATE = /(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])/;
+const HAS_SURROGATE = /[\uD800-\uDFFF]/;
+const nativeIsWellFormed = typeof String.prototype.isWellFormed === 'function';
+/** True if `s` has no lone surrogates, i.e. it can be encoded as UTF-8 losslessly. */
+function isWellFormed(s) {
+    if (nativeIsWellFormed)
+        return s.isWellFormed();
+    return !HAS_SURROGATE.test(s) || !LONE_SURROGATE.test(s);
+}
+function loneSurrogateError() {
+    return (0, errors_js_1.fail)('invalid_utf8', 'string contains a lone surrogate and cannot be encoded as UTF-8');
+}
+/** Exact UTF-8 byte length of `s`; throws `invalid_utf8` for a lone surrogate. */
+function utf8Length(s) {
+    const n = s.length;
+    let bytes = n;
+    for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x80)
+            continue;
+        if (c < 0x800) {
+            bytes += 1;
+        }
+        else if (c < 0xd800 || c > 0xdfff) {
+            bytes += 2;
+        }
+        else {
+            const d = c <= 0xdbff && i + 1 < n ? s.charCodeAt(i + 1) : 0;
+            if (d < 0xdc00 || d > 0xdfff)
+                throw loneSurrogateError();
+            i++;
+            bytes += 2; // 4 bytes for 2 code units
+        }
+    }
+    return bytes;
+}
+/**
+ * Orders strings by their UTF-8 bytes (SPEC §4.4), which equals code point order. Plain
+ * `<` compares UTF-16 code units, which puts astral characters (surrogate pairs,
+ * U+D800–U+DFFF) before U+E000–U+FFFF; this corrects exactly that case.
+ */
+function compareUtf8(a, b) {
+    if (a === b)
+        return 0;
+    const n = a.length < b.length ? a.length : b.length;
+    for (let i = 0; i < n; i++) {
+        const x = a.charCodeAt(i);
+        const y = b.charCodeAt(i);
+        if (x !== y) {
+            if (x >= 0xd800 && y >= 0xd800) {
+                const xs = x <= 0xdfff;
+                const ys = y <= 0xdfff;
+                if (xs !== ys)
+                    return xs ? 1 : -1;
+            }
+            return x - y;
+        }
+    }
+    return a.length - b.length;
+}
+const fromCharCode = String.fromCharCode;
+/**
+ * Decodes `length` bytes at `start`. Strict mode rejects ill-formed UTF-8 (RFC 3629:
+ * overlongs, surrogates, > U+10FFFF, truncated sequences) via TextDecoder's fatal mode;
+ * non-strict mode substitutes U+FFFD. Returns `undefined` for invalid input so the caller
+ * can report the position.
+ */
+function decodeUtf8(bytes, start, length, strict) {
+    if (length <= 32) {
+        // Short ASCII: one pass, no TextDecoder call.
+        let s = '';
+        let i = start;
+        const end = start + length;
+        for (; i < end; i++) {
+            const b = bytes[i];
+            if (b >= 0x80)
+                break;
+            s += fromCharCode(b);
+        }
+        if (i === end)
+            return s;
+    }
+    const view = bytes.subarray(start, start + length);
+    try {
+        return (strict ? fatalDecoder : lenientDecoder).decode(view);
+    }
+    catch (e) {
+        // The fatal decoder reports ill-formed input as a TypeError; anything else is the
+        // engine refusing to build a string that large.
+        if (strict && e instanceof TypeError)
+            return undefined;
+        throw (0, errors_js_1.fail)('size_limit', 'string is too long for this JavaScript engine', e);
+    }
+}

package/dist/cjs/values.d.ts

@@ -0,0 +1,58 @@
+/** True for a Uint8Array from any realm (including Node.js Buffers). */
+export declare function isUint8Array(v: unknown): v is Uint8Array;
+/**
+ * A generic MessagePack extension value: a signed 8-bit type id and an opaque payload.
+ *
+ * Decoding returns `Ext` for every extension id BTOON does not define (application ids
+ * 0…127 and the reserved negative ids). Encoding writes it verbatim with the smallest
+ * header. An `Ext` may also carry one of the ids BTOON defines (-1…-6, -10) — this is how
+ * to emit a `date` (-2) or `datetime` (-3) value, which have no JavaScript type of their
+ * own — but its payload must then be well-formed for that type, or encoding fails with
+ * `invalid_argument`.
+ */
+export declare class Ext {
+    /** Extension type id, an integer in [-128, 127]. */
+    readonly type: number;
+    /** The payload bytes (not copied by the constructor). */
+    readonly data: Uint8Array;
+    constructor(type: number, data: Uint8Array);
+}
+/**
+ * A BTOON timestamp (extension -1): an instant with nanosecond precision and an optional
+ * UTC offset.
+ *
+ * `seconds` and `nanoseconds` always describe the instant in UTC. `offsetMinutes` is
+ * presentation metadata ("local time is UTC + offset") and is encoded only when present.
+ * Decoding returns `Timestamp` objects when `timestamps: 'object'` is set, and for
+ * instants outside the range of `Date`.
+ */
+export declare class Timestamp {
+    /** Whole seconds since the Unix epoch (UTC), in the int64 range. */
+    readonly seconds: bigint;
+    /** Nanoseconds within the second, in [0, 999 999 999]. */
+    readonly nanoseconds: number;
+    /** UTC offset in minutes, in [-1080, 1080], or `undefined` for a plain UTC timestamp. */
+    readonly offsetMinutes?: number;
+    /**
+     * @param seconds Seconds since the Unix epoch; a `bigint`, or a `number` that is a safe integer.
+     * @param nanoseconds Nanoseconds within the second, an integer in [0, 1e9).
+     * @param offsetMinutes Optional UTC offset in minutes, an integer in [-1080, 1080].
+     * @throws {BtoonError} `invalid_argument` if a field is out of range.
+     */
+    constructor(seconds: bigint | number, nanoseconds: number, offsetMinutes?: number);
+    /**
+     * The instant as a `Date`. Sub-millisecond nanoseconds are truncated toward the past and
+     * the offset is dropped (a `Date` has no offset).
+     * @throws {BtoonError} `invalid_argument` if the instant is outside the range of `Date`.
+     */
+    toDate(): Date;
+    /**
+     * The UTC timestamp of a `Date` (millisecond precision, no offset).
+     * @throws {BtoonError} `invalid_argument` for an invalid `Date`.
+     */
+    static fromDate(date: Date): Timestamp;
+}
+/** Milliseconds of a Date (from any realm); throws for an invalid Date. */
+export declare function dateTime(date: unknown): number;
+export declare function isExt(v: object): v is Ext;
+export declare function isTimestamp(v: object): v is Timestamp;

package/dist/cjs/values.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = exports.Ext = void 0;
+exports.isUint8Array = isUint8Array;
+exports.dateTime = dateTime;
+exports.isExt = isExt;
+exports.isTimestamp = isTimestamp;
+const constants_js_1 = require("./constants.js");
+const errors_js_1 = require("./errors.js");
+const INT64_MIN = -(1n << 63n);
+const INT64_MAX = (1n << 63n) - 1n;
+/** True for a Uint8Array from any realm (including Node.js Buffers). */
+function isUint8Array(v) {
+    return ArrayBuffer.isView(v) && v[Symbol.toStringTag] === 'Uint8Array';
+}
+/**
+ * A generic MessagePack extension value: a signed 8-bit type id and an opaque payload.
+ *
+ * Decoding returns `Ext` for every extension id BTOON does not define (application ids
+ * 0…127 and the reserved negative ids). Encoding writes it verbatim with the smallest
+ * header. An `Ext` may also carry one of the ids BTOON defines (-1…-6, -10) — this is how
+ * to emit a `date` (-2) or `datetime` (-3) value, which have no JavaScript type of their
+ * own — but its payload must then be well-formed for that type, or encoding fails with
+ * `invalid_argument`.
+ */
+class Ext {
+    constructor(type, data) {
+        if (typeof type !== 'number' || !Number.isInteger(type) || type < -128 || type > 127) {
+            throw (0, errors_js_1.fail)('invalid_argument', `Ext type must be an integer in [-128, 127], got ${String(type)}`);
+        }
+        if (!isUint8Array(data)) {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Ext data must be a Uint8Array');
+        }
+        this.type = type;
+        this.data = data;
+    }
+}
+exports.Ext = Ext;
+Object.defineProperty(Ext.prototype, constants_js_1.EXT_BRAND, { value: true });
+/**
+ * A BTOON timestamp (extension -1): an instant with nanosecond precision and an optional
+ * UTC offset.
+ *
+ * `seconds` and `nanoseconds` always describe the instant in UTC. `offsetMinutes` is
+ * presentation metadata ("local time is UTC + offset") and is encoded only when present.
+ * Decoding returns `Timestamp` objects when `timestamps: 'object'` is set, and for
+ * instants outside the range of `Date`.
+ */
+class Timestamp {
+    /**
+     * @param seconds Seconds since the Unix epoch; a `bigint`, or a `number` that is a safe integer.
+     * @param nanoseconds Nanoseconds within the second, an integer in [0, 1e9).
+     * @param offsetMinutes Optional UTC offset in minutes, an integer in [-1080, 1080].
+     * @throws {BtoonError} `invalid_argument` if a field is out of range.
+     */
+    constructor(seconds, nanoseconds, offsetMinutes) {
+        let s;
+        if (typeof seconds === 'bigint') {
+            s = seconds;
+        }
+        else if (typeof seconds === 'number' && Number.isSafeInteger(seconds)) {
+            s = BigInt(seconds);
+        }
+        else {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Timestamp seconds must be a bigint or a safe integer');
+        }
+        if (s < INT64_MIN || s > INT64_MAX) {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Timestamp seconds must fit in a signed 64-bit integer');
+        }
+        if (typeof nanoseconds !== 'number' ||
+            !Number.isInteger(nanoseconds) ||
+            nanoseconds < 0 ||
+            nanoseconds >= constants_js_1.NANOS_PER_SECOND) {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Timestamp nanoseconds must be an integer in [0, 999999999]');
+        }
+        if (offsetMinutes !== undefined &&
+            (typeof offsetMinutes !== 'number' ||
+                !Number.isInteger(offsetMinutes) ||
+                offsetMinutes < -constants_js_1.MAX_OFFSET_MINUTES ||
+                offsetMinutes > constants_js_1.MAX_OFFSET_MINUTES)) {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Timestamp offsetMinutes must be an integer in [-1080, 1080]');
+        }
+        this.seconds = s;
+        this.nanoseconds = nanoseconds;
+        this.offsetMinutes = offsetMinutes;
+    }
+    /**
+     * The instant as a `Date`. Sub-millisecond nanoseconds are truncated toward the past and
+     * the offset is dropped (a `Date` has no offset).
+     * @throws {BtoonError} `invalid_argument` if the instant is outside the range of `Date`.
+     */
+    toDate() {
+        const ms = this.seconds * 1000n + BigInt(Math.floor(this.nanoseconds / 1e6));
+        if (ms > BigInt(constants_js_1.MAX_DATE_MS) || ms < -BigInt(constants_js_1.MAX_DATE_MS)) {
+            throw (0, errors_js_1.fail)('invalid_argument', 'Timestamp is outside the range of Date');
+        }
+        return new Date(Number(ms));
+    }
+    /**
+     * The UTC timestamp of a `Date` (millisecond precision, no offset).
+     * @throws {BtoonError} `invalid_argument` for an invalid `Date`.
+     */
+    static fromDate(date) {
+        const ms = dateTime(date);
+        const seconds = Math.floor(ms / 1000);
+        return new Timestamp(BigInt(seconds), (ms - seconds * 1000) * 1e6);
+    }
+}
+exports.Timestamp = Timestamp;
+Object.defineProperty(Timestamp.prototype, constants_js_1.TIMESTAMP_BRAND, { value: true });
+/** Milliseconds of a Date (from any realm); throws for an invalid Date. */
+function dateTime(date) {
+    let ms;
+    try {
+        ms = Date.prototype.getTime.call(date);
+    }
+    catch {
+        throw (0, errors_js_1.fail)('invalid_argument', 'expected a Date');
+    }
+    if (!Number.isFinite(ms))
+        throw (0, errors_js_1.fail)('invalid_argument', 'cannot encode an invalid Date');
+    return ms;
+}
+function isExt(v) {
+    return v[constants_js_1.EXT_BRAND] === true;
+}
+function isTimestamp(v) {
+    return v[constants_js_1.TIMESTAMP_BRAND] === true;
+}

package/dist/cjs/web.d.ts

@@ -0,0 +1,25 @@
+import type { CompressionAlgorithm } from './options.js';
+/** The Compression Streams format name for `alg`, if this runtime supports it. */
+export declare function webFormat(alg: CompressionAlgorithm, kind: 'CompressionStream' | 'DecompressionStream'): string | undefined;
+export declare function webCompress(format: string, data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompresses with a DecompressionStream, stopping as soon as the output exceeds
+ * `limit` (the declared size). For zlib it also checks that the payload ends with the
+ * Adler-32 of the output: older runtimes silently ignore bytes after the end of the
+ * stream, which a strict decoder must reject.
+ */
+export declare function webDecompress(alg: CompressionAlgorithm, format: string, data: Uint8Array, limit: number): Promise<Uint8Array>;
+type Subtle = {
+    importKey(format: 'raw', key: Uint8Array, alg: {
+        name: string;
+        hash: string;
+    }, extractable: boolean, usages: string[]): Promise<unknown>;
+    sign(alg: string, key: unknown, data: Uint8Array): Promise<ArrayBuffer>;
+    verify(alg: string, key: unknown, signature: Uint8Array, data: Uint8Array): Promise<boolean>;
+};
+/** WebCrypto's SubtleCrypto, if available (absent in Node 18 and on insecure origins). */
+export declare function subtle(): Subtle | undefined;
+export declare function webHmacSign(s: Subtle, key: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+/** Constant-time verification (crypto.subtle.verify compares internally). */
+export declare function webHmacVerify(s: Subtle, key: Uint8Array, mac: Uint8Array, data: Uint8Array): Promise<boolean>;
+export {};

package/dist/cjs/web.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFormat = webFormat;
+exports.webCompress = webCompress;
+exports.webDecompress = webDecompress;
+exports.subtle = subtle;
+exports.webHmacSign = webHmacSign;
+exports.webHmacVerify = webHmacVerify;
+// Asynchronous implementations on top of web platform APIs: Compression Streams and
+// WebCrypto. Used by encodeAsync/decodeAsync wherever the runtime provides them.
+const errors_js_1 = require("./errors.js");
+const inflate_js_1 = require("./inflate.js");
+const FORMATS = { zlib: 'deflate', brotli: 'brotli', zstd: 'zstd' };
+const CHUNK = 64 * 1024;
+const supported = new Map();
+function streamCtor(kind) {
+    const ctor = globalThis[kind];
+    return typeof ctor === 'function' ? ctor : undefined;
+}
+/** The Compression Streams format name for `alg`, if this runtime supports it. */
+function webFormat(alg, kind) {
+    const format = FORMATS[alg];
+    const Ctor = streamCtor(kind);
+    if (format === undefined || Ctor === undefined)
+        return undefined;
+    const key = `${kind}:${format}`;
+    let ok = supported.get(key);
+    if (ok === undefined) {
+        try {
+            new Ctor(format);
+            ok = true;
+        }
+        catch {
+            ok = false;
+        }
+        supported.set(key, ok);
+    }
+    return ok ? format : undefined;
+}
+function concat(chunks, total) {
+    if (chunks.length === 1 && chunks[0].byteLength === total)
+        return chunks[0];
+    const out = new Uint8Array(total);
+    let p = 0;
+    for (const c of chunks) {
+        out.set(c, p);
+        p += c.byteLength;
+    }
+    return out;
+}
+async function readAll(reader, limit, alg) {
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > limit) {
+            reader.cancel().catch(() => undefined);
+            throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload decompresses to more than the declared size`);
+        }
+        chunks.push(value);
+    }
+    return concat(chunks, total);
+}
+/** Feeds `data` in chunks, honouring backpressure, then closes the writer. */
+async function pump(writer, data) {
+    for (let i = 0; i < data.length; i += CHUNK) {
+        await writer.ready;
+        await writer.write(data.subarray(i, Math.min(i + CHUNK, data.length)));
+    }
+    await writer.close();
+}
+function messageOf(e) {
+    return e instanceof Error ? e.message || e.name : String(e);
+}
+async function webCompress(format, data) {
+    const stream = new (streamCtor('CompressionStream'))(format);
+    const writer = stream.writable.getWriter();
+    const writing = pump(writer, data);
+    writing.catch(() => undefined);
+    const out = await readAll(stream.readable.getReader(), Infinity, format);
+    await writing;
+    return out;
+}
+/**
+ * Decompresses with a DecompressionStream, stopping as soon as the output exceeds
+ * `limit` (the declared size). For zlib it also checks that the payload ends with the
+ * Adler-32 of the output: older runtimes silently ignore bytes after the end of the
+ * stream, which a strict decoder must reject.
+ */
+async function webDecompress(alg, format, data, limit) {
+    const stream = new (streamCtor('DecompressionStream'))(format);
+    const writer = stream.writable.getWriter();
+    const writing = pump(writer, data);
+    writing.catch(() => undefined);
+    let out;
+    try {
+        out = await readAll(stream.readable.getReader(), limit, alg);
+        await writing;
+    }
+    catch (e) {
+        writer.abort(e).catch(() => undefined);
+        if (e instanceof errors_js_1.BtoonError)
+            throw e;
+        throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload is corrupt: ${messageOf(e)}`, e);
+    }
+    if (alg === 'zlib') {
+        const n = data.length;
+        const trailer = n >= 4 ? ((data[n - 4] << 24) | (data[n - 3] << 16) | (data[n - 2] << 8) | data[n - 1]) >>> 0 : -1;
+        if (trailer !== (0, inflate_js_1.adler32)(out))
+            throw (0, errors_js_1.fail)('invalid_envelope', 'zlib payload has trailing bytes');
+    }
+    return out;
+}
+/** WebCrypto's SubtleCrypto, if available (absent in Node 18 and on insecure origins). */
+function subtle() {
+    const c = globalThis.crypto;
+    const s = c?.subtle;
+    return s && typeof s.importKey === 'function' && typeof s.sign === 'function' && typeof s.verify === 'function'
+        ? s
+        : undefined;
+}
+async function importKey(s, key, usage) {
+    try {
+        return await s.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, [usage]);
+    }
+    catch (e) {
+        throw (0, errors_js_1.fail)('invalid_argument', `cannot use hmacKey with WebCrypto: ${messageOf(e)}`, e);
+    }
+}
+async function webHmacSign(s, key, data) {
+    const k = await importKey(s, key, 'sign');
+    try {
+        return new Uint8Array(await s.sign('HMAC', k, data));
+    }
+    catch (e) {
+        throw (0, errors_js_1.fail)('invalid_argument', `WebCrypto HMAC signing failed: ${messageOf(e)}`, e);
+    }
+}
+/** Constant-time verification (crypto.subtle.verify compares internally). */
+async function webHmacVerify(s, key, mac, data) {
+    const k = await importKey(s, key, 'verify');
+    try {
+        return await s.verify('HMAC', k, mac, data);
+    }
+    catch (e) {
+        throw (0, errors_js_1.fail)('authentication_failed', `WebCrypto HMAC verification failed: ${messageOf(e)}`, e);
+    }
+}

package/dist/esm/constants.d.ts

@@ -0,0 +1,34 @@
+/** Version of this library. */
+export declare const VERSION: "0.1.0";
+/** Version of the BTOON specification this library implements. */
+export declare const SPEC_VERSION: "0.1";
+export declare const EXT_TIMESTAMP = -1;
+export declare const EXT_DATE = -2;
+export declare const EXT_DATETIME = -3;
+export declare const EXT_BIGINT = -4;
+export declare const EXT_F32_VECTOR = -5;
+export declare const EXT_F64_VECTOR = -6;
+export declare const EXT_TABULAR = -10;
+export declare const TABULAR_VERSION = 1;
+export declare const MAX_OFFSET_MINUTES = 1080;
+export declare const NANOS_PER_SECOND = 1000000000;
+export declare const DEFAULT_MAX_DEPTH = 128;
+export declare const DEFAULT_MAX_DECOMPRESSED_SIZE: number;
+/** Encoders SHOULD skip compression below this size (SPEC §6). */
+export declare const MIN_COMPRESSION_SIZE = 256;
+export declare const COMPRESSION_HEADER_SIZE = 16;
+export declare const SIGNED_HEADER_SIZE = 40;
+/** Compression algorithm ids of the envelope header (SPEC §6). */
+export declare const ALGORITHM_IDS: {
+    readonly zlib: 0;
+    readonly lz4: 1;
+    readonly zstd: 2;
+    readonly brotli: 3;
+    readonly snappy: 4;
+};
+export declare const ALGORITHM_NAMES: readonly ["zlib", "lz4", "zstd", "brotli", "snappy"];
+/** Brands that identify {@link Ext} and {@link Timestamp} instances across module copies. */
+export declare const EXT_BRAND: unique symbol;
+export declare const TIMESTAMP_BRAND: unique symbol;
+/** Date's representable range is ±8.64e15 ms around the epoch. */
+export declare const MAX_DATE_MS = 8640000000000000;