distillate 0.9.0 → 0.10.0

package/dist/hll/index.d.cts

@@ -1,4 +1,5 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.cjs";
+import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
+import { a as ReservedBitsError, c as UnknownHashVariantError, l as UnknownVersionError, n as ChecksumError, o as SerializationError, r as FilterJSON, s as TruncatedError, t as BadMagicError } from "../serialize--xR6vGSW.cjs";
 import { t as ParamError } from "../params-DnqJBqLS.cjs";
 import { i as hllSizing, n as HllSizing } from "../sizing-wYOW27eY.cjs";
 //#region src/hll/hll.d.ts
@@ -19,7 +20,7 @@ interface HllParams {
  * sketch.add("alice");
  * ```
  */
-declare class HyperLogLog {
+export declare class HyperLogLog {
   #private;
   /**
    * Creates a sketch at an explicit precision.
@@ -116,4 +117,4 @@ declare class HyperLogLog {
   count(): number;
 }
 //#endregion
-export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, HyperLogLog, ParamError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };
+export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };

package/dist/hll/index.d.ts

@@ -1,4 +1,5 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.js";
+import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+import { a as ReservedBitsError, c as UnknownHashVariantError, l as UnknownVersionError, n as ChecksumError, o as SerializationError, r as FilterJSON, s as TruncatedError, t as BadMagicError } from "../serialize--xR6vGSW.js";
 import { t as ParamError } from "../params-DnqJBqLS.js";
 import { i as hllSizing, n as HllSizing } from "../sizing-wYOW27eY.js";
 //#region src/hll/hll.d.ts
@@ -19,7 +20,7 @@ interface HllParams {
  * sketch.add("alice");
  * ```
  */
-declare class HyperLogLog {
+export declare class HyperLogLog {
   #private;
   /**
    * Creates a sketch at an explicit precision.
@@ -116,4 +117,4 @@ declare class HyperLogLog {
   count(): number;
 }
 //#endregion
-export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, HyperLogLog, ParamError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };
+export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };

package/dist/hll/index.js

@@ -1,4 +1,5 @@
-import { _ as hash128KeyInto, a as UnknownHashVariantError, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, i as TruncatedError, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope } from "../serialize-D59Ri81a.js";
+import { i as hash128KeyInto } from "../hasher-DVWXS_vJ.js";
+import { a as TruncatedError, c as assertBodyLength, f as fromJSONEnvelope, g as writeFrame, h as toJSONEnvelope, i as SerializationError, l as assertMinBodyLength, m as readHeader, n as ChecksumError, o as UnknownHashVariantError, r as ReservedBitsError, s as UnknownVersionError, t as BadMagicError, u as assertParamsPadding } from "../serialize-CMSYFym-.js";
 import { o as assertUint32, t as ParamError } from "../params-CeajSrwv.js";
 import { n as hllSizing } from "../sizing-BtUrtvF_.js";
 //#region src/hll/estimate.ts
@@ -99,7 +100,7 @@ var Registers = class {
 	}
 };
 const RHO_BITS = 6;
-const RHO_MASK = (1 << RHO_BITS) - 1;
+const RHO_MASK = 63;
 function encodeSparse(index, rho) {
 	return index << RHO_BITS | rho;
 }
@@ -137,7 +138,8 @@ function compact(buf, len) {
 //#region src/hll/hll.ts
 const ERROR_CONSTANT = 1.04;
 const TYPE = 5;
-const PARAMS_SIZE = 6;
+const PARAMS_SIZE = 8;
+const PARAMS_FIELDS_END = 6;
 const DENSE = 0;
 const SPARSE = 1;
 const ENTRY_SIZE = 4;
@@ -180,6 +182,7 @@ var HyperLogLog = class HyperLogLog {
 		if (type !== TYPE) throw new SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 		assertMinBodyLength(body.length, PARAMS_SIZE, "hll");
+		assertParamsPadding(body, PARAMS_FIELDS_END, PARAMS_SIZE, "hll");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const p = body[0] ?? 0;
 		const encoding = body[1] ?? 0;
@@ -220,10 +223,10 @@ var HyperLogLog = class HyperLogLog {
 			const entries = compact(sparse, this.#len);
 			this.#len = entries;
 			return writeFrame({
-				version: 4,
+				version: 5,
 				type: TYPE,
 				flags: 0
-			}, PARAMS_SIZE + entries * ENTRY_SIZE, (body, dv) => {
+			}, PARAMS_SIZE, entries * ENTRY_SIZE, (body, dv) => {
 				body[0] = this.#p;
 				body[1] = SPARSE;
 				dv.setUint32(2, this.#seed, true);
@@ -232,10 +235,10 @@ var HyperLogLog = class HyperLogLog {
 		}
 		const payload = this.#registers.bytes;
 		return writeFrame({
-			version: 4,
+			version: 5,
 			type: TYPE,
 			flags: 0
-		}, PARAMS_SIZE + payload.length, (body, dv) => {
+		}, PARAMS_SIZE, payload.length, (body, dv) => {
 			body[0] = this.#p;
 			body[1] = DENSE;
 			dv.setUint32(2, this.#seed, true);
@@ -350,4 +353,4 @@ var HyperLogLog = class HyperLogLog {
 	}
 };
 //#endregion
-export { BadMagicError, ChecksumError, HyperLogLog, ParamError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };
+export { BadMagicError, ChecksumError, HyperLogLog, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#endregion
 //#region src/index.ts
-const VERSION = "0.9.0";
+const VERSION = "0.10.0";
 //#endregion
 exports.VERSION = VERSION;

package/dist/index.d.cts

@@ -1,5 +1,4 @@
 //#region src/index.d.ts
 /** The installed `distillate` package version. */
-declare const VERSION: string;
-//#endregion
-export { VERSION };
+export declare const VERSION: string;
+//#endregion

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 //#region src/index.d.ts
 /** The installed `distillate` package version. */
-declare const VERSION: string;
-//#endregion
-export { VERSION };
+export declare const VERSION: string;
+//#endregion

package/dist/index.js

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/index.ts
-const VERSION = "0.9.0";
+const VERSION = "0.10.0";
 //#endregion
 export { VERSION };

package/dist/{serialize-Bv1zWzrh.d.cts → serialize--xR6vGSW.d.cts}

@@ -1,6 +1,3 @@
-//#region src/core/bytes.d.ts
-type BytesLike = string | Uint8Array | ArrayBuffer;
-//#endregion
 //#region src/core/serialize.d.ts
 /**
  * Base class for every defect `fromBytes` and `fromJSON` reject. Thrown
@@ -38,22 +35,36 @@ declare class BadMagicError extends SerializationError {
 }
 /**
  * Thrown when a frame or JSON envelope declares a format version this release
- * does not read. A reader must be at least as new as the producer, so upgrade
- * `distillate` or re-serialize the data with the version you run.
+ * does not read. The remedy depends on which side is older. A frame newer than
+ * this release needs `distillate` upgraded on the reading side. A frame older
+ * than it is readable by no current release, since each reads exactly one
+ * format version; rebuild it from the source keys. Being at least as new as
+ * the producer is necessary, not sufficient.
  */
 declare class UnknownVersionError extends SerializationError {
   /** Discriminates this error from other `Error`s. */
   override readonly name = "UnknownVersionError";
 }
 /**
- * Thrown when a frame's flags nibble names a hash this release cannot
- * reproduce, so its stored bits are unreadable. Rebuild the filter from the
+ * Thrown when a frame's flags nibble names a hash or index mapping this
+ * release cannot reproduce, so its stored bits are unreadable. Rebuild the filter from the
  * source keys with the version you run.
  */
 declare class UnknownHashVariantError extends SerializationError {
   /** Discriminates this error from other `Error`s. */
   override readonly name = "UnknownHashVariantError";
 }
+/**
+ * Thrown when a frame sets a header bit this format reserves: the flags high
+ * nibble, the byte at offset 7, or the word at offset 12. Only a newer writer
+ * puts anything there, and reading its frame under this release's meaning
+ * would give a wrong answer with no error. Upgrade `distillate` on the reading
+ * side; a reader must be at least as new as the producer.
+ */
+declare class ReservedBitsError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "ReservedBitsError";
+}
 /**
  * Thrown when a frame's CRC32 trailer does not match its contents, so the
  * bytes were corrupted after they were written. Discard them and re-fetch;
@@ -72,5 +83,30 @@ interface FilterJSON {
   /** Base64 of the `toBytes` frame. */
   data: string;
 }
+/** One frame read in place from a larger buffer by {@link readFrameAt}. */
+interface Frame {
+  /** Binary format version. */
+  version: number;
+  /** Structure type code; one this release does not implement still reads. */
+  type: number;
+  /** Header flags byte; the low nibble is the hash variant. */
+  flags: number;
+  /** The body, a view into the source buffer rather than a copy. */
+  body: Uint8Array;
+  /** Bytes the whole frame occupies, so `offset + byteLength` is the next one. */
+  byteLength: number;
+}
+/**
+ * Reads and validates the frame starting at `offset` in `bytes`, which may
+ * hold further frames after it: magic, version, declared length, CRC32 and
+ * reserved bits, without needing to know the structure type. Advance by the
+ * returned `byteLength` to walk a buffer of concatenated frames.
+ *
+ * @throws TruncatedError when the frame runs past the end of `bytes`.
+ * @throws BadMagicError, UnknownVersionError, ChecksumError or
+ *   ReservedBitsError when the frame at `offset` is not one this release reads.
+ * @throws RangeError when `offset` is not a non-negative integer.
+ */
+declare function readFrameAt(bytes: Uint8Array, offset: number): Frame;
 //#endregion
-export { TruncatedError as a, BytesLike as c, SerializationError as i, ChecksumError as n, UnknownHashVariantError as o, FilterJSON as r, UnknownVersionError as s, BadMagicError as t };
+export { ReservedBitsError as a, UnknownHashVariantError as c, Frame as i, UnknownVersionError as l, ChecksumError as n, SerializationError as o, FilterJSON as r, TruncatedError as s, BadMagicError as t, readFrameAt as u };

package/dist/{serialize-Bv1zWzrh.d.ts → serialize--xR6vGSW.d.ts}

@@ -1,6 +1,3 @@
-//#region src/core/bytes.d.ts
-type BytesLike = string | Uint8Array | ArrayBuffer;
-//#endregion
 //#region src/core/serialize.d.ts
 /**
  * Base class for every defect `fromBytes` and `fromJSON` reject. Thrown
@@ -38,22 +35,36 @@ declare class BadMagicError extends SerializationError {
 }
 /**
  * Thrown when a frame or JSON envelope declares a format version this release
- * does not read. A reader must be at least as new as the producer, so upgrade
- * `distillate` or re-serialize the data with the version you run.
+ * does not read. The remedy depends on which side is older. A frame newer than
+ * this release needs `distillate` upgraded on the reading side. A frame older
+ * than it is readable by no current release, since each reads exactly one
+ * format version; rebuild it from the source keys. Being at least as new as
+ * the producer is necessary, not sufficient.
  */
 declare class UnknownVersionError extends SerializationError {
   /** Discriminates this error from other `Error`s. */
   override readonly name = "UnknownVersionError";
 }
 /**
- * Thrown when a frame's flags nibble names a hash this release cannot
- * reproduce, so its stored bits are unreadable. Rebuild the filter from the
+ * Thrown when a frame's flags nibble names a hash or index mapping this
+ * release cannot reproduce, so its stored bits are unreadable. Rebuild the filter from the
  * source keys with the version you run.
  */
 declare class UnknownHashVariantError extends SerializationError {
   /** Discriminates this error from other `Error`s. */
   override readonly name = "UnknownHashVariantError";
 }
+/**
+ * Thrown when a frame sets a header bit this format reserves: the flags high
+ * nibble, the byte at offset 7, or the word at offset 12. Only a newer writer
+ * puts anything there, and reading its frame under this release's meaning
+ * would give a wrong answer with no error. Upgrade `distillate` on the reading
+ * side; a reader must be at least as new as the producer.
+ */
+declare class ReservedBitsError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "ReservedBitsError";
+}
 /**
  * Thrown when a frame's CRC32 trailer does not match its contents, so the
  * bytes were corrupted after they were written. Discard them and re-fetch;
@@ -72,5 +83,30 @@ interface FilterJSON {
   /** Base64 of the `toBytes` frame. */
   data: string;
 }
+/** One frame read in place from a larger buffer by {@link readFrameAt}. */
+interface Frame {
+  /** Binary format version. */
+  version: number;
+  /** Structure type code; one this release does not implement still reads. */
+  type: number;
+  /** Header flags byte; the low nibble is the hash variant. */
+  flags: number;
+  /** The body, a view into the source buffer rather than a copy. */
+  body: Uint8Array;
+  /** Bytes the whole frame occupies, so `offset + byteLength` is the next one. */
+  byteLength: number;
+}
+/**
+ * Reads and validates the frame starting at `offset` in `bytes`, which may
+ * hold further frames after it: magic, version, declared length, CRC32 and
+ * reserved bits, without needing to know the structure type. Advance by the
+ * returned `byteLength` to walk a buffer of concatenated frames.
+ *
+ * @throws TruncatedError when the frame runs past the end of `bytes`.
+ * @throws BadMagicError, UnknownVersionError, ChecksumError or
+ *   ReservedBitsError when the frame at `offset` is not one this release reads.
+ * @throws RangeError when `offset` is not a non-negative integer.
+ */
+declare function readFrameAt(bytes: Uint8Array, offset: number): Frame;
 //#endregion
-export { TruncatedError as a, BytesLike as c, SerializationError as i, ChecksumError as n, UnknownHashVariantError as o, FilterJSON as r, UnknownVersionError as s, BadMagicError as t };
+export { ReservedBitsError as a, UnknownHashVariantError as c, Frame as i, UnknownVersionError as l, ChecksumError as n, SerializationError as o, FilterJSON as r, TruncatedError as s, BadMagicError as t, readFrameAt as u };

package/dist/serialize-CHikZ4GH.cjs

@@ -0,0 +1,296 @@
+//#region src/core/base64.ts
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DECODE = new Int16Array(128).fill(-1);
+for (let i = 0; i < 64; i++) DECODE[ALPHABET.charCodeAt(i)] = i;
+const sym = (n) => ALPHABET.charAt(n & 63);
+function toBase64(bytes) {
+	let out = "";
+	let i = 0;
+	for (; i + 3 <= bytes.length; i += 3) {
+		const n = (bytes[i] ?? 0) << 16 | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0);
+		out += sym(n >>> 18) + sym(n >>> 12) + sym(n >>> 6) + sym(n);
+	}
+	const rem = bytes.length - i;
+	if (rem === 1) {
+		const n = (bytes[i] ?? 0) << 16;
+		out += sym(n >>> 18) + sym(n >>> 12) + "==";
+	} else if (rem === 2) {
+		const n = (bytes[i] ?? 0) << 16 | (bytes[i + 1] ?? 0) << 8;
+		out += sym(n >>> 18) + sym(n >>> 12) + sym(n >>> 6) + "=";
+	}
+	return out;
+}
+function fromBase64(s) {
+	let len = s.length;
+	while (len > 0 && s.charCodeAt(len - 1) === 61) len--;
+	if (len % 4 === 1) throw new RangeError(`invalid base64 length ${String(len)}`);
+	const out = new Uint8Array(len * 3 >> 2);
+	let acc = 0;
+	let bits = 0;
+	let o = 0;
+	for (let i = 0; i < len; i++) {
+		const v = DECODE[s.charCodeAt(i)] ?? -1;
+		if (v < 0) throw new RangeError(`invalid base64 character at index ${String(i)}`);
+		acc = acc << 6 | v;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out[o++] = acc >>> bits & 255;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/core/crc32.ts
+const T1 = 256;
+const T2 = 512;
+const T3 = 768;
+const T4 = 1024;
+const T5 = 1280;
+const T6 = 1536;
+const T7 = 1792;
+const at = (a, i) => a[i] ?? 0;
+let tables;
+function buildTables() {
+	const t = new Uint32Array(2048);
+	for (let n = 0; n < 256; n++) {
+		let c = n;
+		for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		t[n] = c >>> 0;
+	}
+	for (let k = 1; k < 8; k++) for (let n = 0; n < 256; n++) {
+		const p = at(t, (k - 1) * 256 + n);
+		t[k * 256 + n] = (at(t, p & 255) ^ p >>> 8) >>> 0;
+	}
+	return t;
+}
+function crc32(bytes) {
+	const t = tables ??= buildTables();
+	const len = bytes.length;
+	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let crc = 4294967295;
+	let i = 0;
+	const last = len - 8;
+	while (i <= last) {
+		const one = (dv.getUint32(i, true) ^ crc) >>> 0;
+		const two = dv.getUint32(i + 4, true);
+		crc = (at(t, T7 + (one & 255)) ^ at(t, T6 + (one >>> 8 & 255)) ^ at(t, T5 + (one >>> 16 & 255)) ^ at(t, T4 + (one >>> 24 & 255)) ^ at(t, T3 + (two & 255)) ^ at(t, T2 + (two >>> 8 & 255)) ^ at(t, T1 + (two >>> 16 & 255)) ^ at(t, two >>> 24 & 255)) >>> 0;
+		i += 8;
+	}
+	for (; i < len; i++) crc = (at(t, (crc ^ dv.getUint8(i)) & 255) ^ crc >>> 8) >>> 0;
+	return (crc ^ 4294967295) >>> 0;
+}
+const MAGIC = Uint8Array.of(68, 83, 84, 76);
+const HEADER_SIZE = 16;
+const BODY_LENGTH_OFFSET = 8;
+const RESERVED_BYTE_OFFSET = 7;
+const RESERVED_WORD_OFFSET = 12;
+const TRAILER_SIZE = 4;
+const PAYLOAD_ALIGNMENT = 8;
+function writeFrame(header, paramsSize, payloadLength, fill) {
+	if ((HEADER_SIZE + paramsSize) % PAYLOAD_ALIGNMENT !== 0) throw new RangeError(`a ${String(paramsSize)}-byte params block puts the payload at ${String(HEADER_SIZE + paramsSize)}, which is not a multiple of ${String(PAYLOAD_ALIGNMENT)}`);
+	const bodyLength = paramsSize + payloadLength;
+	const frame = new Uint8Array(HEADER_SIZE + bodyLength + TRAILER_SIZE);
+	const frameView = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+	frame.set(MAGIC, 0);
+	frame[4] = header.version;
+	frame[5] = header.type;
+	frame[6] = header.flags;
+	frame[RESERVED_BYTE_OFFSET] = 0;
+	frameView.setUint32(BODY_LENGTH_OFFSET, bodyLength, true);
+	fill(frame.subarray(HEADER_SIZE, HEADER_SIZE + bodyLength), new DataView(frame.buffer, HEADER_SIZE, bodyLength));
+	const crc = crc32(frame.subarray(0, HEADER_SIZE + bodyLength));
+	frameView.setUint32(HEADER_SIZE + bodyLength, crc, true);
+	return frame;
+}
+var SerializationError = class extends Error {
+	name = "SerializationError";
+};
+var TruncatedError = class extends SerializationError {
+	name = "TruncatedError";
+};
+var BadMagicError = class extends SerializationError {
+	name = "BadMagicError";
+};
+var UnknownVersionError = class extends SerializationError {
+	name = "UnknownVersionError";
+};
+var UnknownHashVariantError = class extends SerializationError {
+	name = "UnknownHashVariantError";
+};
+var ReservedBitsError = class extends SerializationError {
+	name = "ReservedBitsError";
+};
+var ChecksumError = class extends SerializationError {
+	name = "ChecksumError";
+};
+const JSON_TAG = "distillate";
+function toJSONEnvelope(bytes) {
+	return {
+		$: JSON_TAG,
+		v: 5,
+		data: toBase64(bytes)
+	};
+}
+function fromJSONEnvelope(value) {
+	if (value === null || typeof value !== "object") throw new SerializationError("not a distillate filter JSON object");
+	const o = value;
+	if (o.$ !== JSON_TAG) throw new SerializationError(`expected "$":"${JSON_TAG}"`);
+	if (o.v !== 5) throw new UnknownVersionError(`unsupported JSON version ${String(o.v)}, expected ${String(5)}`);
+	if (typeof o.data !== "string") throw new SerializationError("missing string \"data\"");
+	try {
+		return fromBase64(o.data);
+	} catch {
+		throw new SerializationError("envelope data is not valid base64");
+	}
+}
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function assertMinBodyLength(actual, min, context) {
+	if (actual < min) throw new TruncatedError(`${context}: body of ${String(actual)} bytes is shorter than the ${String(min)}-byte params block`);
+}
+function assertParamsPadding(body, fieldsEnd, paramsSize, context) {
+	for (let at = fieldsEnd; at < paramsSize; at++) if (body[at] !== 0) throw new SerializationError(`${context}: params padding at byte ${String(at)} is not zero`);
+}
+function assertBodyLength(actual, expected, context) {
+	if (actual !== expected) throw new TruncatedError(`${context}: body of ${String(actual)} bytes does not match the declared params (expected ${String(expected)})`);
+}
+function readFrameAt(bytes, offset) {
+	if (!Number.isInteger(offset) || offset < 0) throw new RangeError(`frame offset must be a non-negative integer, got ${String(offset)}`);
+	return readFrame(bytes, offset, false);
+}
+function readFrame(bytes, offset, exact) {
+	const available = bytes.length - offset;
+	if (available < 20) throw new TruncatedError(`${String(available)} bytes remain at offset ${String(offset)}, fewer than the minimum frame of ${String(20)}`);
+	const frame = bytes.subarray(offset);
+	for (let i = 0; i < MAGIC.length; i++) if (frame[i] !== MAGIC[i]) throw new BadMagicError("frame does not start with the DSTL magic");
+	const version = frame[4] ?? 0;
+	if (version !== 5) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
+	const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+	const bodyLength = view.getUint32(BODY_LENGTH_OFFSET, true);
+	const byteLength = HEADER_SIZE + bodyLength + TRAILER_SIZE;
+	if (exact ? byteLength !== available : byteLength > available) throw new TruncatedError(`frame declares a ${String(bodyLength)}-byte body but ${String(available - HEADER_SIZE - TRAILER_SIZE)} remain`);
+	const trailerAt = byteLength - TRAILER_SIZE;
+	if (view.getUint32(trailerAt, true) !== crc32(frame.subarray(0, trailerAt))) throw new ChecksumError("frame CRC32 does not match its contents");
+	const flags = frame[6] ?? 0;
+	if ((flags & 240) !== 0) throw new ReservedBitsError(`frame sets reserved flags bits 4-7 (flags 0x${flags.toString(16)})`);
+	if (frame[RESERVED_BYTE_OFFSET] !== 0) throw new ReservedBitsError(`frame sets reserved byte 7 (0x${(frame[RESERVED_BYTE_OFFSET] ?? 0).toString(16)})`);
+	const reservedWord = view.getUint32(RESERVED_WORD_OFFSET, true);
+	if (reservedWord !== 0) throw new ReservedBitsError(`frame sets the reserved u32 at offset 12 (0x${reservedWord.toString(16)})`);
+	return {
+		version,
+		type: frame[5] ?? 0,
+		flags,
+		body: frame.subarray(HEADER_SIZE, HEADER_SIZE + bodyLength),
+		byteLength
+	};
+}
+function readHeader(frame) {
+	const { version, type, flags, body } = readFrame(frame, 0, true);
+	return {
+		version,
+		type,
+		flags,
+		body
+	};
+}
+//#endregion
+Object.defineProperty(exports, "BadMagicError", {
+	enumerable: true,
+	get: function() {
+		return BadMagicError;
+	}
+});
+Object.defineProperty(exports, "ChecksumError", {
+	enumerable: true,
+	get: function() {
+		return ChecksumError;
+	}
+});
+Object.defineProperty(exports, "ReservedBitsError", {
+	enumerable: true,
+	get: function() {
+		return ReservedBitsError;
+	}
+});
+Object.defineProperty(exports, "SerializationError", {
+	enumerable: true,
+	get: function() {
+		return SerializationError;
+	}
+});
+Object.defineProperty(exports, "TruncatedError", {
+	enumerable: true,
+	get: function() {
+		return TruncatedError;
+	}
+});
+Object.defineProperty(exports, "UnknownHashVariantError", {
+	enumerable: true,
+	get: function() {
+		return UnknownHashVariantError;
+	}
+});
+Object.defineProperty(exports, "UnknownVersionError", {
+	enumerable: true,
+	get: function() {
+		return UnknownVersionError;
+	}
+});
+Object.defineProperty(exports, "assertBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertBodyLength;
+	}
+});
+Object.defineProperty(exports, "assertMinBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertMinBodyLength;
+	}
+});
+Object.defineProperty(exports, "assertParamsPadding", {
+	enumerable: true,
+	get: function() {
+		return assertParamsPadding;
+	}
+});
+Object.defineProperty(exports, "bytesEqual", {
+	enumerable: true,
+	get: function() {
+		return bytesEqual;
+	}
+});
+Object.defineProperty(exports, "fromJSONEnvelope", {
+	enumerable: true,
+	get: function() {
+		return fromJSONEnvelope;
+	}
+});
+Object.defineProperty(exports, "readFrameAt", {
+	enumerable: true,
+	get: function() {
+		return readFrameAt;
+	}
+});
+Object.defineProperty(exports, "readHeader", {
+	enumerable: true,
+	get: function() {
+		return readHeader;
+	}
+});
+Object.defineProperty(exports, "toJSONEnvelope", {
+	enumerable: true,
+	get: function() {
+		return toJSONEnvelope;
+	}
+});
+Object.defineProperty(exports, "writeFrame", {
+	enumerable: true,
+	get: function() {
+		return writeFrame;
+	}
+});