distillate 0.7.0 → 0.8.0

package/dist/fuse/index.js

@@ -1,11 +1,9 @@
-import { a as bytesEqual, c as toJSONEnvelope, d as RLO, f as fmix64, h as mul64, i as assertMinBodyLength, l as writeFrame, n as UnknownHashVariantError, o as fromJSONEnvelope, p as hash128KeyInto, r as assertBodyLength, s as readHeader, t as SerializationError, u as RHI } from "../serialize-BnwtzcMw.js";
+import { _ as hash128KeyInto, a as UnknownHashVariantError, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, g as fmix64, h as RLO, i as TruncatedError, l as bytesEqual, m as RHI, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope, y as mul64 } from "../serialize-BqIcsR2J.js";
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
 const TYPE_FUSE16 = 4;
-/** Thrown when binary fuse construction fails to converge on the key set. */
 var BinaryFuseBuildError = class extends Error {
-	/** Discriminates this error from other `Error`s. */
 	name = "BinaryFuseBuildError";
 };
 const scratchHash = {
@@ -58,24 +56,10 @@ function computeParams(size) {
 		arrayLength
 	};
 }
-/**
-* Bits stored per key by a binary fuse filter over `n` keys at a fingerprint
-* width, without building one. Counts `n` as distinct keys, since a built
-* filter sizes on its deduped hash count.
-*
-* @param n - Number of distinct keys.
-* @param width - Fingerprint width in bits: `8` for {@link BinaryFuse8}, `16` for {@link BinaryFuse16}.
-* @returns Bits per key (`0` for an empty filter).
-*/
 function fuseBitsPerKey(n, width) {
 	if (n === 0) return 0;
 	return computeParams(n).arrayLength * width / n;
 }
-/**
-* Peel the 3-hypergraph and assign fingerprints so every key's XOR of its 3
-* lanes equals its fingerprint. Retries with a bumped seed on a stall; returns
-* the seed that succeeded.
-*/
 function buildFingerprints(fp, hashes, params, maxAttempts = 100) {
 	const size = hashes.length / 2;
 	const { seg, segMask, segCountLen, arrayLength } = params;
@@ -86,7 +70,7 @@ function buildFingerprints(fp, hashes, params, maxAttempts = 100) {
 	const orderLo = new Uint32Array(size);
 	const orderHi = new Uint32Array(size);
 	const orderIdx = new Uint32Array(size);
-	const pos = /* @__PURE__ */ new Uint32Array(3);
+	const pos = new Uint32Array(3);
 	for (let attempt = 0; attempt < maxAttempts; attempt++) {
 		const seed = attempt;
 		counts.fill(0);
@@ -145,7 +129,7 @@ function buildFingerprints(fp, hashes, params, maxAttempts = 100) {
 }
 function buildState(keys, alloc) {
 	const hashList = [];
-	const seen = /* @__PURE__ */ new Set();
+	const seen = new Set();
 	for (const key of keys) {
 		hash128KeyInto(key, 0, scratchHash);
 		const lo = scratchHash.w0 >>> 0;
@@ -203,10 +187,6 @@ function fuseStateFromBytes(bytes, expectedType) {
 		size
 	};
 }
-/**
-* Shared behavior for the static binary fuse filters: an immutable,
-* space-efficient membership filter built once from a fixed key set.
-*/
 var BinaryFuse = class {
 	#fp;
 	#seed;
@@ -214,7 +194,7 @@ var BinaryFuse = class {
 	#segMask;
 	#segCountLen;
 	#size;
-	#pos = /* @__PURE__ */ new Uint32Array(3);
+	#pos = new Uint32Array(3);
 	constructor(state) {
 		this.#fp = state.fp;
 		this.#seed = state.seed;
@@ -223,23 +203,15 @@ var BinaryFuse = class {
 		this.#segCountLen = state.params.segCountLen;
 		this.#size = state.size;
 	}
-	/** Number of distinct keys the filter was built from. */
 	get size() {
 		return this.#size;
 	}
-	/** Hash seed selected during construction (may differ from 0 after a peel retry). */
 	get seed() {
 		return this.#seed;
 	}
-	/** Actual bits stored per key (`0` for an empty filter). */
 	get bitsPerKey() {
 		return this.#size === 0 ? 0 : this.#fp.byteLength * 8 / this.#size;
 	}
-	/**
-	* Serializes the filter to a portable little-endian byte layout.
-	*
-	* @returns The serialized filter, readable by the matching `fromBytes`.
-	*/
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
 		return writeFrame({
@@ -254,12 +226,6 @@ var BinaryFuse = class {
 			body.set(laneBytes, 16);
 		});
 	}
-	/**
-	* Tests whether a key is in the set.
-	*
-	* @param key - The key to test.
-	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
-	*/
 	has(key) {
 		if (this.#fp.length === 0) return false;
 		hash128KeyInto(key, 0, scratchHash);
@@ -273,107 +239,34 @@ var BinaryFuse = class {
 		const p2 = this.#pos[2] ?? 0;
 		return ((mlo ^ mhi) & mask) === (((this.#fp[p0] ?? 0) ^ (this.#fp[p1] ?? 0) ^ (this.#fp[p2] ?? 0)) & mask);
 	}
-	/**
-	* Tests structural equality: `true` when `other` serializes to identical
-	* bytes. A {@link BinaryFuse8} and a {@link BinaryFuse16} are never equal,
-	* since their frames carry different type bytes.
-	*
-	* @param other - The filter to compare against.
-	* @returns `true` if the two filters are byte-for-byte identical.
-	*/
 	equals(other) {
 		return bytesEqual(this.toBytes(), other.toBytes());
 	}
-	/**
-	* Serializes the filter to a JSON-friendly envelope wrapping the base64 of
-	* the `toBytes` frame.
-	*
-	* @returns The envelope, readable by the matching `fromJSON`.
-	*/
 	toJSON() {
 		return toJSONEnvelope(this.toBytes());
 	}
 };
-/**
-* A static 8-bit binary fuse filter: built once from a key set, then immutable.
-* The most space-efficient option (~9 bits/key at ~0.39% false-positive rate).
-*
-* @example
-* ```ts
-* const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
-* filter.has("alice"); // true
-* filter.size; // 3
-* ```
-*/
 var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
-	/**
-	* Builds a filter from the given keys; duplicates are ignored.
-	*
-	* @param keys - The complete set of keys to store.
-	* @returns A new immutable filter.
-	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
-	*/
 	static from(keys) {
 		return new BinaryFuse8(buildState(keys, (n) => new Uint8Array(n)));
 	}
-	/**
-	* Restores a filter from its {@link BinaryFuse8.toBytes} serialization.
-	*
-	* @param bytes - The serialized filter.
-	* @returns The reconstructed filter.
-	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse8(fuseStateFromBytes(bytes, TYPE_FUSE8));
 	}
-	/**
-	* Restores a filter from its {@link BinaryFuse8.toJSON} envelope.
-	*
-	* @param value - The JSON envelope.
-	* @returns The reconstructed filter.
-	*/
 	static fromJSON(value) {
 		return BinaryFuse8.fromBytes(fromJSONEnvelope(value));
 	}
 };
-/**
-* A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
-* space (~18 bits/key) for a far lower false-positive rate (~1/65536).
-*
-* @example
-* ```ts
-* const filter = BinaryFuse16.from(["alice", "bob", "carol"]);
-* filter.has("alice"); // true
-* ```
-*/
 var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
-	/**
-	* Builds a filter from the given keys; duplicates are ignored.
-	*
-	* @param keys - The complete set of keys to store.
-	* @returns A new immutable filter.
-	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
-	*/
 	static from(keys) {
 		return new BinaryFuse16(buildState(keys, (n) => new Uint16Array(n)));
 	}
-	/**
-	* Restores a filter from its {@link BinaryFuse16.toBytes} serialization.
-	*
-	* @param bytes - The serialized filter.
-	* @returns The reconstructed filter.
-	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse16(fuseStateFromBytes(bytes, TYPE_FUSE16));
 	}
-	/**
-	* Restores a filter from its {@link BinaryFuse16.toJSON} envelope.
-	*
-	* @param value - The JSON envelope.
-	* @returns The reconstructed filter.
-	*/
 	static fromJSON(value) {
 		return BinaryFuse16.fromBytes(fromJSONEnvelope(value));
 	}
 };
 //#endregion
-export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, fuseBitsPerKey };
+export { BadMagicError, BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, ChecksumError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, fuseBitsPerKey };

package/dist/index.cjs

@@ -1,7 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#endregion
 //#region src/index.ts
-/** The installed `distillate` package version. */
-const VERSION = "0.7.0";
+const VERSION = "0.8.0";
 //#endregion
 exports.VERSION = VERSION;

package/dist/index.js

@@ -1,6 +1,5 @@
 //#endregion
 //#region src/index.ts
-/** The installed `distillate` package version. */
-const VERSION = "0.7.0";
+const VERSION = "0.8.0";
 //#endregion
 export { VERSION };

package/dist/{params-BrWuBC2A.js → params-CeajSrwv.js}

@@ -1,26 +1,19 @@
 //#region src/core/params.ts
-/** Thrown when a structure is constructed with invalid parameters. */
 var ParamError = class extends RangeError {
-	/** Discriminates this error from other `Error`s. */
 	name = "ParamError";
 };
-/** Asserts `value` is an integer greater than or equal to 1. */
 function assertPositiveInt(value, label) {
 	if (!Number.isInteger(value) || value < 1) throw new ParamError(`${label} must be a positive integer, got ${String(value)}`);
 }
-/** Asserts `value` is a finite number greater than 0 (a positive real). */
 function assertPositiveFinite(value, label) {
 	if (!Number.isFinite(value) || value <= 0) throw new ParamError(`${label} must be a positive number, got ${String(value)}`);
 }
-/** Asserts `value` is an integer in the uint16 range `[0, 65535]`. */
 function assertUint16(value, label) {
 	if (!Number.isInteger(value) || value < 0 || value > 65535) throw new ParamError(`${label} must be a uint16, got ${String(value)}`);
 }
-/** Asserts `value` is an integer in the uint32 range `[0, 2^32 - 1]`. */
 function assertUint32(value, label) {
 	if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new ParamError(`${label} must be a uint32, got ${String(value)}`);
 }
-/** Asserts `value` is a finite number in the open interval `(0, 1)`. */
 function assertProbability(value, label) {
 	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new ParamError(`${label} must be in the open interval (0, 1), got ${String(value)}`);
 }

package/dist/{params--8CNXYWu.cjs → params-UTZbJ22c.cjs}

@@ -1,26 +1,19 @@
 //#region src/core/params.ts
-/** Thrown when a structure is constructed with invalid parameters. */
 var ParamError = class extends RangeError {
-	/** Discriminates this error from other `Error`s. */
 	name = "ParamError";
 };
-/** Asserts `value` is an integer greater than or equal to 1. */
 function assertPositiveInt(value, label) {
 	if (!Number.isInteger(value) || value < 1) throw new ParamError(`${label} must be a positive integer, got ${String(value)}`);
 }
-/** Asserts `value` is a finite number greater than 0 (a positive real). */
 function assertPositiveFinite(value, label) {
 	if (!Number.isFinite(value) || value <= 0) throw new ParamError(`${label} must be a positive number, got ${String(value)}`);
 }
-/** Asserts `value` is an integer in the uint16 range `[0, 65535]`. */
 function assertUint16(value, label) {
 	if (!Number.isInteger(value) || value < 0 || value > 65535) throw new ParamError(`${label} must be a uint16, got ${String(value)}`);
 }
-/** Asserts `value` is an integer in the uint32 range `[0, 2^32 - 1]`. */
 function assertUint32(value, label) {
 	if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new ParamError(`${label} must be a uint32, got ${String(value)}`);
 }
-/** Asserts `value` is a finite number in the open interval `(0, 1)`. */
 function assertProbability(value, label) {
 	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new ParamError(`${label} must be in the open interval (0, 1), got ${String(value)}`);
 }

package/dist/{serialize-BnwtzcMw.js → serialize-BqIcsR2J.js}

@@ -174,7 +174,7 @@ function computeLanes(bytes, seed, len) {
 	LANES.w3 = h4;
 }
 const keyEncoder = new TextEncoder();
-let keyBuf = /* @__PURE__ */ new Uint8Array(256);
+let keyBuf = new Uint8Array(256);
 let encBytes = keyBuf;
 let encLen = 0;
 function encodeKey(key) {
@@ -216,11 +216,6 @@ function hash32x2Into(key, seed, out) {
 	out[0] = LANES.w0;
 	out[1] = LANES.w1;
 }
-/**
-* Derive `count` bucket indices in `[0, range)` from a key using
-* Kirsch-Mitzenmacher enhanced double hashing `g_i = h1 + i*h2 + i^2`
-* (the RocksDB `+i^2` fix), reduced into range with Lemire multiply-shift.
-*/
 function probeInto(key, count, range, seed, out) {
 	keyToLanes(key, seed);
 	const a = LANES.w0;
@@ -230,7 +225,7 @@ function probeInto(key, count, range, seed, out) {
 //#endregion
 //#region src/core/base64.ts
 const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const DECODE = (/* @__PURE__ */ new Int16Array(128)).fill(-1);
+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) {
@@ -312,12 +307,6 @@ function crc32(bytes) {
 }
 const HEADER_SIZE = 8;
 const TRAILER_SIZE = 4;
-/**
-* Allocates a full frame once, hands `fill` a writable view over the body region
-* (and a `DataView` scoped to it), then seals the CRC trailer. The body view
-* aliases the frame's buffer, so callers write fields and payload straight into
-* the frame with no intermediate body allocation or copy.
-*/
 function writeFrame(header, bodyLength, fill) {
 	const frame = new Uint8Array(HEADER_SIZE + bodyLength + TRAILER_SIZE);
 	frame[0] = 65;
@@ -352,7 +341,6 @@ var ChecksumError = class extends SerializationError {
 	name = "ChecksumError";
 };
 const JSON_TAG = "distillate";
-/** Wraps a serialized frame in the JSON envelope. */
 function toJSONEnvelope(bytes) {
 	return {
 		$: JSON_TAG,
@@ -360,11 +348,6 @@ function toJSONEnvelope(bytes) {
 		data: toBase64(bytes)
 	};
 }
-/**
-* Validates a JSON envelope and returns the raw frame bytes for a structure's
-* own `fromBytes` to decode. Throws {@link SerializationError} on any envelope
-* defect; the frame itself is checked downstream.
-*/
 function fromJSONEnvelope(value) {
 	if (value === null || typeof value !== "object") throw new SerializationError("not a distillate filter JSON object");
 	const o = value;
@@ -377,23 +360,14 @@ function fromJSONEnvelope(value) {
 		throw new SerializationError("envelope data is not valid base64");
 	}
 }
-/** Byte-wise equality of two frames; the basis for structure `equals`. */
 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;
 }
-/**
-* Asserts a frame body is long enough to hold its fixed params block, so the
-* params can be read without running off the end.
-*/
 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`);
 }
-/**
-* Asserts a frame body is exactly the length its declared params imply, so a
-* hostile or truncated frame is rejected before any backing store is allocated.
-*/
 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)})`);
 }
@@ -411,4 +385,4 @@ function readHeader(frame) {
 	};
 }
 //#endregion
-export { reduce as _, bytesEqual as a, toJSONEnvelope as c, RLO as d, fmix64 as f, probeInto as g, mul64 as h, assertMinBodyLength as i, writeFrame as l, hash32x2Into as m, UnknownHashVariantError as n, fromJSONEnvelope as o, hash128KeyInto as p, assertBodyLength as r, readHeader as s, SerializationError as t, RHI as u };
+export { hash128KeyInto as _, UnknownHashVariantError as a, probeInto as b, assertMinBodyLength as c, readHeader as d, toJSONEnvelope as f, fmix64 as g, RLO as h, TruncatedError as i, bytesEqual as l, RHI as m, ChecksumError as n, UnknownVersionError as o, writeFrame as p, SerializationError as r, assertBodyLength as s, BadMagicError as t, fromJSONEnvelope as u, hash32x2Into as v, reduce as x, mul64 as y };

package/dist/{serialize-BIIKUHH6.cjs → serialize-CXnRWItH.cjs}

@@ -174,7 +174,7 @@ function computeLanes(bytes, seed, len) {
 	LANES.w3 = h4;
 }
 const keyEncoder = new TextEncoder();
-let keyBuf = /* @__PURE__ */ new Uint8Array(256);
+let keyBuf = new Uint8Array(256);
 let encBytes = keyBuf;
 let encLen = 0;
 function encodeKey(key) {
@@ -216,11 +216,6 @@ function hash32x2Into(key, seed, out) {
 	out[0] = LANES.w0;
 	out[1] = LANES.w1;
 }
-/**
-* Derive `count` bucket indices in `[0, range)` from a key using
-* Kirsch-Mitzenmacher enhanced double hashing `g_i = h1 + i*h2 + i^2`
-* (the RocksDB `+i^2` fix), reduced into range with Lemire multiply-shift.
-*/
 function probeInto(key, count, range, seed, out) {
 	keyToLanes(key, seed);
 	const a = LANES.w0;
@@ -230,7 +225,7 @@ function probeInto(key, count, range, seed, out) {
 //#endregion
 //#region src/core/base64.ts
 const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const DECODE = (/* @__PURE__ */ new Int16Array(128)).fill(-1);
+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) {
@@ -312,12 +307,6 @@ function crc32(bytes) {
 }
 const HEADER_SIZE = 8;
 const TRAILER_SIZE = 4;
-/**
-* Allocates a full frame once, hands `fill` a writable view over the body region
-* (and a `DataView` scoped to it), then seals the CRC trailer. The body view
-* aliases the frame's buffer, so callers write fields and payload straight into
-* the frame with no intermediate body allocation or copy.
-*/
 function writeFrame(header, bodyLength, fill) {
 	const frame = new Uint8Array(HEADER_SIZE + bodyLength + TRAILER_SIZE);
 	frame[0] = 65;
@@ -352,7 +341,6 @@ var ChecksumError = class extends SerializationError {
 	name = "ChecksumError";
 };
 const JSON_TAG = "distillate";
-/** Wraps a serialized frame in the JSON envelope. */
 function toJSONEnvelope(bytes) {
 	return {
 		$: JSON_TAG,
@@ -360,11 +348,6 @@ function toJSONEnvelope(bytes) {
 		data: toBase64(bytes)
 	};
 }
-/**
-* Validates a JSON envelope and returns the raw frame bytes for a structure's
-* own `fromBytes` to decode. Throws {@link SerializationError} on any envelope
-* defect; the frame itself is checked downstream.
-*/
 function fromJSONEnvelope(value) {
 	if (value === null || typeof value !== "object") throw new SerializationError("not a distillate filter JSON object");
 	const o = value;
@@ -377,23 +360,14 @@ function fromJSONEnvelope(value) {
 		throw new SerializationError("envelope data is not valid base64");
 	}
 }
-/** Byte-wise equality of two frames; the basis for structure `equals`. */
 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;
 }
-/**
-* Asserts a frame body is long enough to hold its fixed params block, so the
-* params can be read without running off the end.
-*/
 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`);
 }
-/**
-* Asserts a frame body is exactly the length its declared params imply, so a
-* hostile or truncated frame is rejected before any backing store is allocated.
-*/
 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)})`);
 }
@@ -411,6 +385,18 @@ function readHeader(frame) {
 	};
 }
 //#endregion
+Object.defineProperty(exports, "BadMagicError", {
+	enumerable: true,
+	get: function() {
+		return BadMagicError;
+	}
+});
+Object.defineProperty(exports, "ChecksumError", {
+	enumerable: true,
+	get: function() {
+		return ChecksumError;
+	}
+});
 Object.defineProperty(exports, "RHI", {
 	enumerable: true,
 	get: function() {
@@ -429,12 +415,24 @@ Object.defineProperty(exports, "SerializationError", {
 		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() {

package/dist/serialize-ChyWpB9F.d.cts

@@ -0,0 +1,73 @@
+//#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
+ * directly when a JSON envelope is malformed: not an object, missing the
+ * `"distillate"` tag, missing `data`, or `data` that is not valid base64.
+ * Catch this to handle any decode failure at once, or a subclass to tell the
+ * causes apart. The input is corrupt or foreign, so discard it; retrying the
+ * same bytes cannot succeed.
+ */
+declare class SerializationError extends Error {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name: string;
+}
+/**
+ * Thrown when a frame is shorter than its header plus trailer, or when its
+ * body length does not match the length its declared params imply. The bytes
+ * were cut short in transit or storage; re-fetch the whole frame.
+ */
+declare class TruncatedError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "TruncatedError";
+}
+/**
+ * Thrown when a frame does not start with the four-byte `AMQF` magic, so it
+ * was never produced by `toBytes`. Check that the bytes really are a
+ * distillate frame and not another payload, a text encoding of one, or a
+ * slice taken at the wrong offset.
+ */
+declare class BadMagicError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "BadMagicError";
+}
+/**
+ * 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.
+ */
+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
+ * 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's CRC32 trailer does not match its contents, so the
+ * bytes were corrupted after they were written. Discard them and re-fetch;
+ * the payload cannot be trusted even where it still parses.
+ */
+declare class ChecksumError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "ChecksumError";
+}
+/** JSON-friendly envelope for a filter: the binary frame, base64-encoded. */
+interface FilterJSON {
+  /** Format tag; always `"distillate"`. */
+  $: string;
+  /** Binary format version. */
+  v: number;
+  /** Base64 of the `toBytes` frame. */
+  data: string;
+}
+//#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 };

package/dist/serialize-ChyWpB9F.d.ts

@@ -0,0 +1,73 @@
+//#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
+ * directly when a JSON envelope is malformed: not an object, missing the
+ * `"distillate"` tag, missing `data`, or `data` that is not valid base64.
+ * Catch this to handle any decode failure at once, or a subclass to tell the
+ * causes apart. The input is corrupt or foreign, so discard it; retrying the
+ * same bytes cannot succeed.
+ */
+declare class SerializationError extends Error {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name: string;
+}
+/**
+ * Thrown when a frame is shorter than its header plus trailer, or when its
+ * body length does not match the length its declared params imply. The bytes
+ * were cut short in transit or storage; re-fetch the whole frame.
+ */
+declare class TruncatedError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "TruncatedError";
+}
+/**
+ * Thrown when a frame does not start with the four-byte `AMQF` magic, so it
+ * was never produced by `toBytes`. Check that the bytes really are a
+ * distillate frame and not another payload, a text encoding of one, or a
+ * slice taken at the wrong offset.
+ */
+declare class BadMagicError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "BadMagicError";
+}
+/**
+ * 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.
+ */
+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
+ * 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's CRC32 trailer does not match its contents, so the
+ * bytes were corrupted after they were written. Discard them and re-fetch;
+ * the payload cannot be trusted even where it still parses.
+ */
+declare class ChecksumError extends SerializationError {
+  /** Discriminates this error from other `Error`s. */
+  override readonly name = "ChecksumError";
+}
+/** JSON-friendly envelope for a filter: the binary frame, base64-encoded. */
+interface FilterJSON {
+  /** Format tag; always `"distillate"`. */
+  $: string;
+  /** Binary format version. */
+  v: number;
+  /** Base64 of the `toBytes` frame. */
+  data: string;
+}
+//#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 };