distillate 0.2.0 → 0.4.0

package/dist/blocked/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CHHDM4TQ.cjs");
+const require_serialize = require("../serialize-DPdiySxq.cjs");
 const require_params = require("../params-J8p3bKq5.cjs");
 //#region src/blocked/blocked.ts
 const TYPE = 2;
@@ -77,6 +77,26 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	get bitsPerKey() {
 		return this.#numBlocks * 256 / this.#n;
 	}
+	/** Number of bits currently set across all lanes. */
+	get length() {
+		let bits = 0;
+		for (let w of this.#lanes) while (w) {
+			w &= w - 1;
+			bits++;
+		}
+		return bits;
+	}
+	/**
+	* Estimates the current false-positive rate from the actual fill,
+	* `(length / totalBits) ** 8`. A split-block query checks exactly 8 lane-bits,
+	* so the exponent is 8 rather than a classic probe count `k`. This reflects
+	* how full the filter is right now, not the design target.
+	*
+	* @returns The estimated false-positive rate, `0` for an empty filter.
+	*/
+	rate() {
+		return (this.length / (this.#numBlocks * 256)) ** 8;
+	}
 	/**
 	* Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
 	*
@@ -84,11 +104,14 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = require_serialize.readHeader(bytes);
+		const { type, body } = require_serialize.readHeader(bytes);
+		if (type !== TYPE) throw new require_serialize.SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		require_serialize.assertMinBodyLength(body.length, 12, "blocked");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const numBlocks = dv.getUint32(0, true);
 		const seed = dv.getUint32(4, true);
 		const n = dv.getUint32(8, true);
+		require_serialize.assertBodyLength(body.length, 12 + numBlocks * 32, "blocked");
 		const f = new BlockedBloomFilter({
 			bitsPerKey: 256,
 			capacity: numBlocks,
@@ -112,7 +135,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		dv.setUint32(8, this.#n, true);
 		body.set(lanes, 12);
 		return require_serialize.writeHeader({
-			version: 1,
+			version: 2,
 			type: TYPE,
 			flags: 0
 		}, body);

package/dist/blocked/index.d.cts

@@ -43,6 +43,17 @@ declare class BlockedBloomFilter {
   constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
   /** Actual bits allocated per key (`total bits / capacity`). */
   get bitsPerKey(): number;
+  /** Number of bits currently set across all lanes. */
+  get length(): number;
+  /**
+   * Estimates the current false-positive rate from the actual fill,
+   * `(length / totalBits) ** 8`. A split-block query checks exactly 8 lane-bits,
+   * so the exponent is 8 rather than a classic probe count `k`. This reflects
+   * how full the filter is right now, not the design target.
+   *
+   * @returns The estimated false-positive rate, `0` for an empty filter.
+   */
+  rate(): number;
   /**
    * Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
    *

package/dist/blocked/index.d.ts

@@ -43,6 +43,17 @@ declare class BlockedBloomFilter {
   constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
   /** Actual bits allocated per key (`total bits / capacity`). */
   get bitsPerKey(): number;
+  /** Number of bits currently set across all lanes. */
+  get length(): number;
+  /**
+   * Estimates the current false-positive rate from the actual fill,
+   * `(length / totalBits) ** 8`. A split-block query checks exactly 8 lane-bits,
+   * so the exponent is 8 rather than a classic probe count `k`. This reflects
+   * how full the filter is right now, not the design target.
+   *
+   * @returns The estimated false-positive rate, `0` for an empty filter.
+   */
+  rate(): number;
   /**
    * Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
    *

package/dist/blocked/index.js

@@ -1,4 +1,4 @@
-import { i as hash128KeyInto, n as readHeader, o as reduce, r as writeHeader } from "../serialize-5XQ5y_R-.js";
+import { a as writeHeader, c as reduce, i as readHeader, n as assertBodyLength, o as hash128KeyInto, r as assertMinBodyLength, t as SerializationError } from "../serialize-DkkBKDT0.js";
 import { a as assertUint32, i as assertProbability, n as assertPositiveFinite, r as assertPositiveInt, t as ParamError } from "../params-ChTRNxM9.js";
 //#region src/blocked/blocked.ts
 const TYPE = 2;
@@ -76,6 +76,26 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	get bitsPerKey() {
 		return this.#numBlocks * 256 / this.#n;
 	}
+	/** Number of bits currently set across all lanes. */
+	get length() {
+		let bits = 0;
+		for (let w of this.#lanes) while (w) {
+			w &= w - 1;
+			bits++;
+		}
+		return bits;
+	}
+	/**
+	* Estimates the current false-positive rate from the actual fill,
+	* `(length / totalBits) ** 8`. A split-block query checks exactly 8 lane-bits,
+	* so the exponent is 8 rather than a classic probe count `k`. This reflects
+	* how full the filter is right now, not the design target.
+	*
+	* @returns The estimated false-positive rate, `0` for an empty filter.
+	*/
+	rate() {
+		return (this.length / (this.#numBlocks * 256)) ** 8;
+	}
 	/**
 	* Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
 	*
@@ -83,11 +103,14 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = readHeader(bytes);
+		const { type, body } = readHeader(bytes);
+		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		assertMinBodyLength(body.length, 12, "blocked");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const numBlocks = dv.getUint32(0, true);
 		const seed = dv.getUint32(4, true);
 		const n = dv.getUint32(8, true);
+		assertBodyLength(body.length, 12 + numBlocks * 32, "blocked");
 		const f = new BlockedBloomFilter({
 			bitsPerKey: 256,
 			capacity: numBlocks,
@@ -111,7 +134,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		dv.setUint32(8, this.#n, true);
 		body.set(lanes, 12);
 		return writeHeader({
-			version: 1,
+			version: 2,
 			type: TYPE,
 			flags: 0
 		}, body);

package/dist/bloom/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CHHDM4TQ.cjs");
+const require_serialize = require("../serialize-DPdiySxq.cjs");
 const require_params = require("../params-J8p3bKq5.cjs");
 //#region src/core/bitset.ts
 var BitSetRangeError = class extends RangeError {
@@ -94,17 +94,22 @@ var BloomFilter = class BloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = require_serialize.readHeader(bytes);
+		const { type, body } = require_serialize.readHeader(bytes);
+		if (type !== TYPE) throw new require_serialize.SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		require_serialize.assertMinBodyLength(body.length, 14, "bloom");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const m = dv.getUint32(0, true);
-		const k = body[4] ?? 0;
-		const seed = dv.getUint32(5, true);
+		const k = dv.getUint16(4, true);
+		const seed = dv.getUint32(6, true);
+		const n = dv.getUint32(10, true);
+		require_serialize.assertBodyLength(body.length, 14 + Math.ceil(m / 8), "bloom");
 		const f = new BloomFilter({
 			m,
 			k,
 			seed
 		});
-		f.#bits.bytes.set(body.subarray(9));
+		f.#n = n;
+		f.#bits.bytes.set(body.subarray(14));
 		return f;
 	}
 	/**
@@ -122,25 +127,52 @@ var BloomFilter = class BloomFilter {
 		this.#scratch = new Uint32Array(k);
 		this.#n = Math.round(m * Math.LN2 / k);
 	}
+	/** Number of bits in the filter. */
+	get m() {
+		return this.#m;
+	}
+	/** Number of hash probes per key. */
+	get k() {
+		return this.#k;
+	}
+	/** Hash seed. */
+	get seed() {
+		return this.#seed;
+	}
+	/** Number of bits currently set. */
+	get length() {
+		return this.#bits.count();
+	}
 	/** Analytic design bits-per-key `m / n`. */
 	get bitsPerKey() {
 		return this.#m / this.#n;
 	}
 	/**
+	* Estimates the current false-positive rate from the actual fill,
+	* `(length / m) ** k`. This reflects how full the filter is right now, not
+	* the design target; it rises as keys are added.
+	*
+	* @returns The estimated false-positive rate, `0` for an empty filter.
+	*/
+	rate() {
+		return (this.length / this.#m) ** this.#k;
+	}
+	/**
 	* Serializes the filter to a portable little-endian byte layout.
 	*
 	* @returns The serialized filter, readable by {@link BloomFilter.fromBytes}.
 	*/
 	toBytes() {
 		const payload = this.#bits.bytes;
-		const body = new Uint8Array(9 + payload.length);
+		const body = new Uint8Array(14 + payload.length);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		dv.setUint32(0, this.#m, true);
-		body[4] = this.#k;
-		dv.setUint32(5, this.#seed, true);
-		body.set(payload, 9);
+		dv.setUint16(4, this.#k, true);
+		dv.setUint32(6, this.#seed, true);
+		dv.setUint32(10, this.#n, true);
+		body.set(payload, 14);
 		return require_serialize.writeHeader({
-			version: 1,
+			version: 2,
 			type: TYPE,
 			flags: 0
 		}, body);

package/dist/bloom/index.d.cts

@@ -49,8 +49,24 @@ declare class BloomFilter {
    * {@link BloomFilter.create} unless restoring a specific configuration.
    */
   constructor({ m, k, seed }: BloomParams);
+  /** Number of bits in the filter. */
+  get m(): number;
+  /** Number of hash probes per key. */
+  get k(): number;
+  /** Hash seed. */
+  get seed(): number;
+  /** Number of bits currently set. */
+  get length(): number;
   /** Analytic design bits-per-key `m / n`. */
   get bitsPerKey(): number;
+  /**
+   * Estimates the current false-positive rate from the actual fill,
+   * `(length / m) ** k`. This reflects how full the filter is right now, not
+   * the design target; it rises as keys are added.
+   *
+   * @returns The estimated false-positive rate, `0` for an empty filter.
+   */
+  rate(): number;
   /**
    * Serializes the filter to a portable little-endian byte layout.
    *

package/dist/bloom/index.d.ts

@@ -49,8 +49,24 @@ declare class BloomFilter {
    * {@link BloomFilter.create} unless restoring a specific configuration.
    */
   constructor({ m, k, seed }: BloomParams);
+  /** Number of bits in the filter. */
+  get m(): number;
+  /** Number of hash probes per key. */
+  get k(): number;
+  /** Hash seed. */
+  get seed(): number;
+  /** Number of bits currently set. */
+  get length(): number;
   /** Analytic design bits-per-key `m / n`. */
   get bitsPerKey(): number;
+  /**
+   * Estimates the current false-positive rate from the actual fill,
+   * `(length / m) ** k`. This reflects how full the filter is right now, not
+   * the design target; it rises as keys are added.
+   *
+   * @returns The estimated false-positive rate, `0` for an empty filter.
+   */
+  rate(): number;
   /**
    * Serializes the filter to a portable little-endian byte layout.
    *

package/dist/bloom/index.js

@@ -1,4 +1,4 @@
-import { a as probeInto, n as readHeader, r as writeHeader } from "../serialize-5XQ5y_R-.js";
+import { a as writeHeader, i as readHeader, n as assertBodyLength, r as assertMinBodyLength, s as probeInto, t as SerializationError } from "../serialize-DkkBKDT0.js";
 import { a as assertUint32, i as assertProbability, r as assertPositiveInt, t as ParamError } from "../params-ChTRNxM9.js";
 //#region src/core/bitset.ts
 var BitSetRangeError = class extends RangeError {
@@ -93,17 +93,22 @@ var BloomFilter = class BloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = readHeader(bytes);
+		const { type, body } = readHeader(bytes);
+		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		assertMinBodyLength(body.length, 14, "bloom");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const m = dv.getUint32(0, true);
-		const k = body[4] ?? 0;
-		const seed = dv.getUint32(5, true);
+		const k = dv.getUint16(4, true);
+		const seed = dv.getUint32(6, true);
+		const n = dv.getUint32(10, true);
+		assertBodyLength(body.length, 14 + Math.ceil(m / 8), "bloom");
 		const f = new BloomFilter({
 			m,
 			k,
 			seed
 		});
-		f.#bits.bytes.set(body.subarray(9));
+		f.#n = n;
+		f.#bits.bytes.set(body.subarray(14));
 		return f;
 	}
 	/**
@@ -121,25 +126,52 @@ var BloomFilter = class BloomFilter {
 		this.#scratch = new Uint32Array(k);
 		this.#n = Math.round(m * Math.LN2 / k);
 	}
+	/** Number of bits in the filter. */
+	get m() {
+		return this.#m;
+	}
+	/** Number of hash probes per key. */
+	get k() {
+		return this.#k;
+	}
+	/** Hash seed. */
+	get seed() {
+		return this.#seed;
+	}
+	/** Number of bits currently set. */
+	get length() {
+		return this.#bits.count();
+	}
 	/** Analytic design bits-per-key `m / n`. */
 	get bitsPerKey() {
 		return this.#m / this.#n;
 	}
 	/**
+	* Estimates the current false-positive rate from the actual fill,
+	* `(length / m) ** k`. This reflects how full the filter is right now, not
+	* the design target; it rises as keys are added.
+	*
+	* @returns The estimated false-positive rate, `0` for an empty filter.
+	*/
+	rate() {
+		return (this.length / this.#m) ** this.#k;
+	}
+	/**
 	* Serializes the filter to a portable little-endian byte layout.
 	*
 	* @returns The serialized filter, readable by {@link BloomFilter.fromBytes}.
 	*/
 	toBytes() {
 		const payload = this.#bits.bytes;
-		const body = new Uint8Array(9 + payload.length);
+		const body = new Uint8Array(14 + payload.length);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		dv.setUint32(0, this.#m, true);
-		body[4] = this.#k;
-		dv.setUint32(5, this.#seed, true);
-		body.set(payload, 9);
+		dv.setUint16(4, this.#k, true);
+		dv.setUint32(6, this.#seed, true);
+		dv.setUint32(10, this.#n, true);
+		body.set(payload, 14);
 		return writeHeader({
-			version: 1,
+			version: 2,
 			type: TYPE,
 			flags: 0
 		}, body);

package/dist/fuse/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CHHDM4TQ.cjs");
+const require_serialize = require("../serialize-DPdiySxq.cjs");
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -211,13 +211,16 @@ function buildState(keys, alloc) {
 function fuseStateFromBytes(bytes, expectedType) {
 	const { type, body } = require_serialize.readHeader(bytes);
 	if (type !== expectedType) throw new require_serialize.SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	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);
-	const laneBytes = body.subarray(16);
 	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
+	const expectedArrayLength = size === 0 ? 0 : segCountLen + 2 * seg;
+	require_serialize.assertBodyLength(body.length, 16 + expectedArrayLength * bpe, "fuse");
+	const laneBytes = body.subarray(16);
 	const arrayLength = laneBytes.length / bpe;
 	const fp = bpe === 1 ? new Uint8Array(arrayLength) : new Uint16Array(arrayLength);
 	new Uint8Array(fp.buffer).set(laneBytes);
@@ -276,7 +279,7 @@ var BinaryFuse = class {
 		dv.setUint32(12, this.#size, true);
 		body.set(laneBytes, 16);
 		return require_serialize.writeHeader({
-			version: 1,
+			version: 2,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
 		}, body);

package/dist/fuse/index.js

@@ -1,4 +1,4 @@
-import { i as hash128KeyInto, n as readHeader, r as writeHeader, t as SerializationError } from "../serialize-5XQ5y_R-.js";
+import { a as writeHeader, i as readHeader, n as assertBodyLength, o as hash128KeyInto, r as assertMinBodyLength, t as SerializationError } from "../serialize-DkkBKDT0.js";
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -210,13 +210,16 @@ function buildState(keys, alloc) {
 function fuseStateFromBytes(bytes, expectedType) {
 	const { type, body } = readHeader(bytes);
 	if (type !== expectedType) throw new SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	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);
-	const laneBytes = body.subarray(16);
 	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
+	const expectedArrayLength = size === 0 ? 0 : segCountLen + 2 * seg;
+	assertBodyLength(body.length, 16 + expectedArrayLength * bpe, "fuse");
+	const laneBytes = body.subarray(16);
 	const arrayLength = laneBytes.length / bpe;
 	const fp = bpe === 1 ? new Uint8Array(arrayLength) : new Uint16Array(arrayLength);
 	new Uint8Array(fp.buffer).set(laneBytes);
@@ -275,7 +278,7 @@ var BinaryFuse = class {
 		dv.setUint32(12, this.#size, true);
 		body.set(laneBytes, 16);
 		return writeHeader({
-			version: 1,
+			version: 2,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
 		}, body);

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.2.0";
+const VERSION = "0.4.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.2.0";
+const VERSION = "0.4.0";
 //#endregion
 export { VERSION };

package/dist/{serialize-CHHDM4TQ.cjs → serialize-DPdiySxq.cjs}

@@ -277,11 +277,25 @@ var UnknownVersionError = class extends SerializationError {
 var ChecksumError = class extends SerializationError {
 	name = "ChecksumError";
 };
+/**
+* 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)})`);
+}
 function readHeader(frame) {
 	if (frame.length < 12) throw new TruncatedError(`frame of ${String(frame.length)} bytes is shorter than the minimum ${String(12)}`);
 	if (frame[0] !== 65 || frame[1] !== 77 || frame[2] !== 81 || frame[3] !== 70) throw new BadMagicError("frame does not start with the AMQF magic");
 	const version = frame[4] ?? 0;
-	if (version !== 1) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
+	if (version !== 2) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
 	if (new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(frame.length - TRAILER_SIZE, true) !== crc32(frame.subarray(0, frame.length - TRAILER_SIZE))) throw new ChecksumError("frame CRC32 does not match its contents");
 	return {
 		version,
@@ -297,6 +311,18 @@ Object.defineProperty(exports, "SerializationError", {
 		return SerializationError;
 	}
 });
+Object.defineProperty(exports, "assertBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertBodyLength;
+	}
+});
+Object.defineProperty(exports, "assertMinBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertMinBodyLength;
+	}
+});
 Object.defineProperty(exports, "hash128KeyInto", {
 	enumerable: true,
 	get: function() {

package/dist/{serialize-5XQ5y_R-.js → serialize-DkkBKDT0.js}

@@ -277,11 +277,25 @@ var UnknownVersionError = class extends SerializationError {
 var ChecksumError = class extends SerializationError {
 	name = "ChecksumError";
 };
+/**
+* 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)})`);
+}
 function readHeader(frame) {
 	if (frame.length < 12) throw new TruncatedError(`frame of ${String(frame.length)} bytes is shorter than the minimum ${String(12)}`);
 	if (frame[0] !== 65 || frame[1] !== 77 || frame[2] !== 81 || frame[3] !== 70) throw new BadMagicError("frame does not start with the AMQF magic");
 	const version = frame[4] ?? 0;
-	if (version !== 1) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
+	if (version !== 2) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
 	if (new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(frame.length - TRAILER_SIZE, true) !== crc32(frame.subarray(0, frame.length - TRAILER_SIZE))) throw new ChecksumError("frame CRC32 does not match its contents");
 	return {
 		version,
@@ -291,4 +305,4 @@ function readHeader(frame) {
 	};
 }
 //#endregion
-export { probeInto as a, hash128KeyInto as i, readHeader as n, reduce as o, writeHeader as r, SerializationError as t };
+export { writeHeader as a, reduce as c, readHeader as i, assertBodyLength as n, hash128KeyInto as o, assertMinBodyLength as r, probeInto as s, SerializationError as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "distillate",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Probabilistic data structures for JavaScript. Space-efficient, approximate-membership filters (Bloom, Blocked Bloom, Binary Fuse) with tunable error and a portable binary format; zero dependencies, universal.",
   "keywords": [
     "bloom-filter",