distillate 0.4.0 → 0.6.0

package/dist/fuse/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-DPdiySxq.cjs");
+const require_serialize = require("../serialize-BIIKUHH6.cjs");
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -9,71 +9,23 @@ var BinaryFuseBuildError = class extends Error {
 	/** Discriminates this error from other `Error`s. */
 	name = "BinaryFuseBuildError";
 };
-let RLO = 0;
-let RHI = 0;
 const scratchHash = {
-	h1lo: 0,
-	h1hi: 0,
-	h2lo: 0,
-	h2hi: 0
+	w0: 0,
+	w1: 0,
+	w2: 0,
+	w3: 0
 };
-function mul64(alo, ahi, blo, bhi) {
-	const a0 = alo & 65535;
-	const a1 = alo >>> 16;
-	const a2 = ahi & 65535;
-	const a3 = ahi >>> 16;
-	const b0 = blo & 65535;
-	const b1 = blo >>> 16;
-	const b2 = bhi & 65535;
-	const b3 = bhi >>> 16;
-	let c0 = a0 * b0;
-	let c1 = c0 >>> 16;
-	c0 &= 65535;
-	c1 += a1 * b0;
-	let c2 = c1 >>> 16;
-	c1 &= 65535;
-	c1 += a0 * b1;
-	c2 += c1 >>> 16;
-	c1 &= 65535;
-	c2 += a2 * b0;
-	let c3 = c2 >>> 16;
-	c2 &= 65535;
-	c2 += a1 * b1;
-	c3 += c2 >>> 16;
-	c2 &= 65535;
-	c2 += a0 * b2;
-	c3 += c2 >>> 16;
-	c2 &= 65535;
-	c3 += a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
-	c3 &= 65535;
-	RLO = (c1 << 16 | c0) >>> 0;
-	RHI = (c3 << 16 | c2) >>> 0;
-}
-function fmix64(lo, hi) {
-	let l = (lo ^ hi >>> 1) >>> 0;
-	let h = hi;
-	mul64(l, h, 3981806797, 4283543511);
-	l = RLO;
-	h = RHI;
-	l = (l ^ h >>> 1) >>> 0;
-	mul64(l, h, 444984403, 3301882366);
-	l = RLO;
-	h = RHI;
-	l = (l ^ h >>> 1) >>> 0;
-	RLO = l;
-	RHI = h;
-}
 function mixSeed(lo, hi, seed) {
 	const l = (lo >>> 0) + (seed >>> 0);
 	const carry = l > 4294967295 ? 1 : 0;
-	fmix64(l >>> 0, hi + carry >>> 0);
+	require_serialize.fmix64(l >>> 0, hi + carry >>> 0);
 }
 function mulhi64(lo, hi, n) {
-	mul64(hi, 0, n, 0);
-	const aLo = RLO;
-	const aHi = RHI;
-	mul64(lo, 0, n, 0);
-	const bHi = RHI;
+	require_serialize.mul64(hi, 0, n, 0);
+	const aLo = require_serialize.RLO;
+	const aHi = require_serialize.RHI;
+	require_serialize.mul64(lo, 0, n, 0);
+	const bHi = require_serialize.RHI;
 	return aHi + ((aLo >>> 0) + (bHi >>> 0) > 4294967295 ? 1 : 0) >>> 0;
 }
 function positionsInto(mlo, mhi, seg, segMask, segCountLen, out) {
@@ -130,8 +82,8 @@ function buildFingerprints(fp, hashes, params, maxAttempts = 100) {
 		xorHi.fill(0);
 		for (let i = 0; i < size; i++) {
 			mixSeed(hashes[2 * i] ?? 0, hashes[2 * i + 1] ?? 0, seed);
-			const mlo = RLO;
-			const mhi = RHI;
+			const mlo = require_serialize.RLO;
+			const mhi = require_serialize.RHI;
 			positionsInto(mlo, mhi, seg, segMask, segCountLen, pos);
 			for (let j = 0; j < 3; j++) {
 				const p = pos[j] ?? 0;
@@ -184,8 +136,8 @@ function buildState(keys, alloc) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const key of keys) {
 		require_serialize.hash128KeyInto(key, 0, scratchHash);
-		const lo = scratchHash.h1lo >>> 0;
-		const hi = scratchHash.h1hi >>> 0;
+		const lo = scratchHash.w0 >>> 0;
+		const hi = scratchHash.w1 >>> 0;
 		const id = `${String(lo)},${String(hi)}`;
 		if (seen.has(id)) continue;
 		seen.add(id);
@@ -209,14 +161,17 @@ function buildState(keys, alloc) {
 	};
 }
 function fuseStateFromBytes(bytes, expectedType) {
-	const { type, body } = require_serialize.readHeader(bytes);
+	const { type, flags, body } = require_serialize.readHeader(bytes);
 	if (type !== expectedType) throw new require_serialize.SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	if ((flags & 15) !== 0) throw new require_serialize.UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 	require_serialize.assertMinBodyLength(body.length, 16, "fuse");
 	const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 	const seed = dv.getUint32(0, true);
 	const seg = dv.getUint32(4, true);
 	const segCountLen = dv.getUint32(8, true);
 	const size = dv.getUint32(12, true);
+	if (seg === 0 || (seg & seg - 1) !== 0 || seg > 1 << 18) throw new require_serialize.SerializationError(`invalid fuse segment length ${String(seg)}`);
+	if (segCountLen % seg !== 0) throw new require_serialize.SerializationError(`fuse segment count length ${String(segCountLen)} is not a multiple of segment length ${String(seg)}`);
 	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
 	const expectedArrayLength = size === 0 ? 0 : segCountLen + 2 * seg;
 	require_serialize.assertBodyLength(body.length, 16 + expectedArrayLength * bpe, "fuse");
@@ -260,6 +215,10 @@ var BinaryFuse = class {
 	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;
@@ -271,18 +230,17 @@ var BinaryFuse = class {
 	*/
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
-		const body = new Uint8Array(16 + laneBytes.length);
-		const dv = new DataView(body.buffer);
-		dv.setUint32(0, this.#seed, true);
-		dv.setUint32(4, this.#seg, true);
-		dv.setUint32(8, this.#segCountLen, true);
-		dv.setUint32(12, this.#size, true);
-		body.set(laneBytes, 16);
-		return require_serialize.writeHeader({
-			version: 2,
+		return require_serialize.writeFrame({
+			version: 3,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
-		}, body);
+		}, 16 + laneBytes.length, (body, dv) => {
+			dv.setUint32(0, this.#seed, true);
+			dv.setUint32(4, this.#seg, true);
+			dv.setUint32(8, this.#segCountLen, true);
+			dv.setUint32(12, this.#size, true);
+			body.set(laneBytes, 16);
+		});
 	}
 	/**
 	* Tests whether a key is in the set.
@@ -293,9 +251,9 @@ var BinaryFuse = class {
 	has(key) {
 		if (this.#fp.length === 0) return false;
 		require_serialize.hash128KeyInto(key, 0, scratchHash);
-		mixSeed(scratchHash.h1lo >>> 0, scratchHash.h1hi >>> 0, this.#seed);
-		const mlo = RLO;
-		const mhi = RHI;
+		mixSeed(scratchHash.w0 >>> 0, scratchHash.w1 >>> 0, this.#seed);
+		const mlo = require_serialize.RLO;
+		const mhi = require_serialize.RHI;
 		positionsInto(mlo, mhi, this.#seg, this.#segMask, this.#segCountLen, this.#pos);
 		const mask = fpMask(this.#fp);
 		const p0 = this.#pos[0] ?? 0;
@@ -303,6 +261,26 @@ 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 require_serialize.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 require_serialize.toJSONEnvelope(this.toBytes());
+	}
 };
 /**
 * A static 8-bit binary fuse filter: built once from a key set, then immutable.
@@ -335,6 +313,15 @@ var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
 	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(require_serialize.fromJSONEnvelope(value));
+	}
 };
 /**
 * A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
@@ -366,6 +353,15 @@ var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
 	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(require_serialize.fromJSONEnvelope(value));
+	}
 };
 //#endregion
 exports.BinaryFuse16 = BinaryFuse16;

package/dist/fuse/index.d.cts

@@ -1,4 +1,4 @@
-import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
+import { n as BytesLike, t as FilterJSON } from "../serialize-DRKh6QOr.cjs";
 //#region src/fuse/fuse.d.ts
 /** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {
@@ -26,6 +26,8 @@ declare abstract class BinaryFuse {
   protected constructor(state: FuseState);
   /** Number of distinct keys the filter was built from. */
   get size(): number;
+  /** Hash seed selected during construction (may differ from 0 after a peel retry). */
+  get seed(): number;
   /** Actual bits stored per key (`0` for an empty filter). */
   get bitsPerKey(): number;
   /**
@@ -41,6 +43,22 @@ declare abstract class BinaryFuse {
    * @returns `true` if present (possibly a false positive); `false` guarantees absence.
    */
   has(key: BytesLike): boolean;
+  /**
+   * 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: BinaryFuse8 | BinaryFuse16): boolean;
+  /**
+   * Serializes the filter to a JSON-friendly envelope wrapping the base64 of
+   * the `toBytes` frame.
+   *
+   * @returns The envelope, readable by the matching `fromJSON`.
+   */
+  toJSON(): FilterJSON;
 }
 /**
  * A static 8-bit binary fuse filter: built once from a key set, then immutable.
@@ -69,6 +87,13 @@ declare class BinaryFuse8 extends BinaryFuse {
    * @returns The reconstructed filter.
    */
   static fromBytes(bytes: Uint8Array): BinaryFuse8;
+  /**
+   * Restores a filter from its {@link BinaryFuse8.toJSON} envelope.
+   *
+   * @param value - The JSON envelope.
+   * @returns The reconstructed filter.
+   */
+  static fromJSON(value: unknown): BinaryFuse8;
 }
 /**
  * A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
@@ -96,6 +121,13 @@ declare class BinaryFuse16 extends BinaryFuse {
    * @returns The reconstructed filter.
    */
   static fromBytes(bytes: Uint8Array): BinaryFuse16;
+  /**
+   * Restores a filter from its {@link BinaryFuse16.toJSON} envelope.
+   *
+   * @param value - The JSON envelope.
+   * @returns The reconstructed filter.
+   */
+  static fromJSON(value: unknown): BinaryFuse16;
 }
 //#endregion
-export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError };
+export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, type FilterJSON };

package/dist/fuse/index.d.ts

@@ -1,4 +1,4 @@
-import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+import { n as BytesLike, t as FilterJSON } from "../serialize-DRKh6QOr.js";
 //#region src/fuse/fuse.d.ts
 /** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {
@@ -26,6 +26,8 @@ declare abstract class BinaryFuse {
   protected constructor(state: FuseState);
   /** Number of distinct keys the filter was built from. */
   get size(): number;
+  /** Hash seed selected during construction (may differ from 0 after a peel retry). */
+  get seed(): number;
   /** Actual bits stored per key (`0` for an empty filter). */
   get bitsPerKey(): number;
   /**
@@ -41,6 +43,22 @@ declare abstract class BinaryFuse {
    * @returns `true` if present (possibly a false positive); `false` guarantees absence.
    */
   has(key: BytesLike): boolean;
+  /**
+   * 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: BinaryFuse8 | BinaryFuse16): boolean;
+  /**
+   * Serializes the filter to a JSON-friendly envelope wrapping the base64 of
+   * the `toBytes` frame.
+   *
+   * @returns The envelope, readable by the matching `fromJSON`.
+   */
+  toJSON(): FilterJSON;
 }
 /**
  * A static 8-bit binary fuse filter: built once from a key set, then immutable.
@@ -69,6 +87,13 @@ declare class BinaryFuse8 extends BinaryFuse {
    * @returns The reconstructed filter.
    */
   static fromBytes(bytes: Uint8Array): BinaryFuse8;
+  /**
+   * Restores a filter from its {@link BinaryFuse8.toJSON} envelope.
+   *
+   * @param value - The JSON envelope.
+   * @returns The reconstructed filter.
+   */
+  static fromJSON(value: unknown): BinaryFuse8;
 }
 /**
  * A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
@@ -96,6 +121,13 @@ declare class BinaryFuse16 extends BinaryFuse {
    * @returns The reconstructed filter.
    */
   static fromBytes(bytes: Uint8Array): BinaryFuse16;
+  /**
+   * Restores a filter from its {@link BinaryFuse16.toJSON} envelope.
+   *
+   * @param value - The JSON envelope.
+   * @returns The reconstructed filter.
+   */
+  static fromJSON(value: unknown): BinaryFuse16;
 }
 //#endregion
-export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError };
+export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, type FilterJSON };

package/dist/fuse/index.js

@@ -1,4 +1,4 @@
-import { a as writeHeader, i as readHeader, n as assertBodyLength, o as hash128KeyInto, r as assertMinBodyLength, t as SerializationError } from "../serialize-DkkBKDT0.js";
+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";
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -8,60 +8,12 @@ var BinaryFuseBuildError = class extends Error {
 	/** Discriminates this error from other `Error`s. */
 	name = "BinaryFuseBuildError";
 };
-let RLO = 0;
-let RHI = 0;
 const scratchHash = {
-	h1lo: 0,
-	h1hi: 0,
-	h2lo: 0,
-	h2hi: 0
+	w0: 0,
+	w1: 0,
+	w2: 0,
+	w3: 0
 };
-function mul64(alo, ahi, blo, bhi) {
-	const a0 = alo & 65535;
-	const a1 = alo >>> 16;
-	const a2 = ahi & 65535;
-	const a3 = ahi >>> 16;
-	const b0 = blo & 65535;
-	const b1 = blo >>> 16;
-	const b2 = bhi & 65535;
-	const b3 = bhi >>> 16;
-	let c0 = a0 * b0;
-	let c1 = c0 >>> 16;
-	c0 &= 65535;
-	c1 += a1 * b0;
-	let c2 = c1 >>> 16;
-	c1 &= 65535;
-	c1 += a0 * b1;
-	c2 += c1 >>> 16;
-	c1 &= 65535;
-	c2 += a2 * b0;
-	let c3 = c2 >>> 16;
-	c2 &= 65535;
-	c2 += a1 * b1;
-	c3 += c2 >>> 16;
-	c2 &= 65535;
-	c2 += a0 * b2;
-	c3 += c2 >>> 16;
-	c2 &= 65535;
-	c3 += a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
-	c3 &= 65535;
-	RLO = (c1 << 16 | c0) >>> 0;
-	RHI = (c3 << 16 | c2) >>> 0;
-}
-function fmix64(lo, hi) {
-	let l = (lo ^ hi >>> 1) >>> 0;
-	let h = hi;
-	mul64(l, h, 3981806797, 4283543511);
-	l = RLO;
-	h = RHI;
-	l = (l ^ h >>> 1) >>> 0;
-	mul64(l, h, 444984403, 3301882366);
-	l = RLO;
-	h = RHI;
-	l = (l ^ h >>> 1) >>> 0;
-	RLO = l;
-	RHI = h;
-}
 function mixSeed(lo, hi, seed) {
 	const l = (lo >>> 0) + (seed >>> 0);
 	const carry = l > 4294967295 ? 1 : 0;
@@ -183,8 +135,8 @@ function buildState(keys, alloc) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const key of keys) {
 		hash128KeyInto(key, 0, scratchHash);
-		const lo = scratchHash.h1lo >>> 0;
-		const hi = scratchHash.h1hi >>> 0;
+		const lo = scratchHash.w0 >>> 0;
+		const hi = scratchHash.w1 >>> 0;
 		const id = `${String(lo)},${String(hi)}`;
 		if (seen.has(id)) continue;
 		seen.add(id);
@@ -208,14 +160,17 @@ function buildState(keys, alloc) {
 	};
 }
 function fuseStateFromBytes(bytes, expectedType) {
-	const { type, body } = readHeader(bytes);
+	const { type, flags, body } = readHeader(bytes);
 	if (type !== expectedType) throw new SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 	assertMinBodyLength(body.length, 16, "fuse");
 	const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 	const seed = dv.getUint32(0, true);
 	const seg = dv.getUint32(4, true);
 	const segCountLen = dv.getUint32(8, true);
 	const size = dv.getUint32(12, true);
+	if (seg === 0 || (seg & seg - 1) !== 0 || seg > 1 << 18) throw new SerializationError(`invalid fuse segment length ${String(seg)}`);
+	if (segCountLen % seg !== 0) throw new SerializationError(`fuse segment count length ${String(segCountLen)} is not a multiple of segment length ${String(seg)}`);
 	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
 	const expectedArrayLength = size === 0 ? 0 : segCountLen + 2 * seg;
 	assertBodyLength(body.length, 16 + expectedArrayLength * bpe, "fuse");
@@ -259,6 +214,10 @@ var BinaryFuse = class {
 	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;
@@ -270,18 +229,17 @@ var BinaryFuse = class {
 	*/
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
-		const body = new Uint8Array(16 + laneBytes.length);
-		const dv = new DataView(body.buffer);
-		dv.setUint32(0, this.#seed, true);
-		dv.setUint32(4, this.#seg, true);
-		dv.setUint32(8, this.#segCountLen, true);
-		dv.setUint32(12, this.#size, true);
-		body.set(laneBytes, 16);
-		return writeHeader({
-			version: 2,
+		return writeFrame({
+			version: 3,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
-		}, body);
+		}, 16 + laneBytes.length, (body, dv) => {
+			dv.setUint32(0, this.#seed, true);
+			dv.setUint32(4, this.#seg, true);
+			dv.setUint32(8, this.#segCountLen, true);
+			dv.setUint32(12, this.#size, true);
+			body.set(laneBytes, 16);
+		});
 	}
 	/**
 	* Tests whether a key is in the set.
@@ -292,7 +250,7 @@ var BinaryFuse = class {
 	has(key) {
 		if (this.#fp.length === 0) return false;
 		hash128KeyInto(key, 0, scratchHash);
-		mixSeed(scratchHash.h1lo >>> 0, scratchHash.h1hi >>> 0, this.#seed);
+		mixSeed(scratchHash.w0 >>> 0, scratchHash.w1 >>> 0, this.#seed);
 		const mlo = RLO;
 		const mhi = RHI;
 		positionsInto(mlo, mhi, this.#seg, this.#segMask, this.#segCountLen, this.#pos);
@@ -302,6 +260,26 @@ 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.
@@ -334,6 +312,15 @@ var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
 	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
@@ -365,6 +352,15 @@ var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
 	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 };

package/dist/index.cjs

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

package/dist/index.js

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

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

@@ -12,6 +12,10 @@ function assertPositiveInt(value, label) {
 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)}`);
@@ -45,6 +49,12 @@ Object.defineProperty(exports, "assertProbability", {
 		return assertProbability;
 	}
 });
+Object.defineProperty(exports, "assertUint16", {
+	enumerable: true,
+	get: function() {
+		return assertUint16;
+	}
+});
 Object.defineProperty(exports, "assertUint32", {
 	enumerable: true,
 	get: function() {

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

@@ -12,6 +12,10 @@ function assertPositiveInt(value, label) {
 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)}`);
@@ -21,4 +25,4 @@ 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)}`);
 }
 //#endregion
-export { assertUint32 as a, assertProbability as i, assertPositiveFinite as n, assertPositiveInt as r, ParamError as t };
+export { assertUint16 as a, assertProbability as i, assertPositiveFinite as n, assertUint32 as o, assertPositiveInt as r, ParamError as t };