distillate 0.3.0 → 0.5.0

package/README.md

@@ -43,7 +43,7 @@ Each structure ships as its own subpath, so you only bundle what you import.
 | Import               | Structure     | Mutable? | Use for                                              |
 | -------------------- | ------------- | -------- | ---------------------------------------------------- |
 | `distillate/bloom`   | Classic Bloom | yes      | Familiar default, migration from `bloom-filters`     |
-| `distillate/blocked` | Blocked Bloom | yes      | Streaming inserts, speed-first, cache-friendly       |
+| `distillate/blocked` | Blocked Bloom | yes      | Very large sets that outgrow CPU cache (10M+ keys)   |
 | `distillate/fuse`    | Binary Fuse   | no       | Static set built once and queried a lot; least space |
 
 ### Classic Bloom (`distillate/bloom`)
@@ -72,7 +72,7 @@ filter.add("alice");
 filter.has("alice"); // true
 ```
 
-Same surface as Classic Bloom (`add` / `has` / `union` / `toBytes` / `fromBytes` / `bitsPerKey`). Confines every lookup to one cache line, trading ~20-30% more space for cache-friendly throughput.
+Same surface as Classic Bloom (`add` / `has` / `union` / `toBytes` / `fromBytes` / `bitsPerKey`). Confines every lookup to a single cache line, which only pays off once the filter outgrows CPU cache. At typical sizes it matches Classic; for very large sets (tens of millions of keys, past L2/L3) it runs about 1.4x Classic's lookup throughput, at the cost of ~20-30% more space. Prefer Classic unless you are memory-bound at scale.
 
 ### Binary Fuse (`distillate/fuse`)
 
@@ -98,10 +98,10 @@ Classic Bloom head-to-head at a **matched 1% false-positive rate** over the same
 
 | Classic Bloom  | bits/key | measured FPR | `has` throughput |
 | -------------- | -------- | ------------ | ---------------- |
-| **distillate** | 9.59     | 1.03%        | ~7.0 M ops/s     |
+| **distillate** | 9.59     | 1.03%        | ~16 M ops/s      |
 | bloom-filters  | 9.59     | 0.99%        | ~0.29 M ops/s    |
 
-Same space, same accuracy, **~24x the lookup throughput** of [`bloom-filters`](https://www.npmjs.com/package/bloom-filters) (the package distillate replaces), while hashing UTF-8 bytes with MurmurHash3 so filters stay portable and cross-language readable.
+Same space, same accuracy, **~56x the lookup throughput** of [`bloom-filters`](https://www.npmjs.com/package/bloom-filters) (the package distillate replaces), while hashing UTF-8 bytes with MurmurHash3 so filters stay portable and cross-language readable.
 
 These are a point-in-time snapshot on one machine. The full report (blocked/fuse, 1M capacity, the `bloomfilter` micro-package) and exactly how it is measured live in the [distillate-bench](https://github.com/akshay-xp/distillate-bench) repo: [RESULTS.md](https://github.com/akshay-xp/distillate-bench/blob/main/RESULTS.md), [METHODOLOGY.md](https://github.com/akshay-xp/distillate-bench/blob/main/METHODOLOGY.md).
 

package/dist/blocked/index.cjs

@@ -1,15 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CHHDM4TQ.cjs");
+const require_serialize = require("../serialize-fa-pEUGq.cjs");
 const require_params = require("../params-J8p3bKq5.cjs");
 //#region src/blocked/blocked.ts
 const TYPE = 2;
 const SALT = Uint32Array.of(1203114875, 1150766481, 2284105051, 2729912477, 1884591559, 770785867, 2667333959, 1550580529);
-const scratchHash = {
-	h1lo: 0,
-	h1hi: 0,
-	h2lo: 0,
-	h2hi: 0
-};
+const scratch2 = /* @__PURE__ */ new Uint32Array(2);
 /** Thrown when an operation requires two filters built with identical parameters. */
 var BlockedBloomParamMismatchError = class extends Error {
 	/** Discriminates this error from other `Error`s. */
@@ -104,11 +99,15 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = require_serialize.readHeader(bytes);
+		const { type, flags, body } = require_serialize.readHeader(bytes);
+		if (type !== TYPE) throw new require_serialize.SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if ((flags & 15) !== 1) throw new require_serialize.UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
+		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,
@@ -132,9 +131,9 @@ 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
+			flags: 1
 		}, body);
 	}
 	/**
@@ -182,9 +181,9 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	}
 };
 function fillBlock(key, numBlocks, seed, outWords, outBits) {
-	require_serialize.hash128KeyInto(key, seed, scratchHash);
-	const block = require_serialize.reduce((scratchHash.h1lo ^ scratchHash.h1hi) >>> 0, numBlocks);
-	const x = (scratchHash.h2lo ^ scratchHash.h2hi) >>> 0;
+	require_serialize.hash32x2Into(key, seed, scratch2);
+	const block = require_serialize.reduce(scratch2[0] ?? 0, numBlocks);
+	const x = scratch2[1] ?? 0;
 	const base = block * 8;
 	for (let i = 0; i < 8; i++) {
 		outWords[i] = base + i;

package/dist/blocked/index.js

@@ -1,14 +1,9 @@
-import { i as hash128KeyInto, n as readHeader, o as reduce, r as writeHeader } from "../serialize-5XQ5y_R-.js";
+import { a as readHeader, d as hash32x2Into, i as assertMinBodyLength, m as reduce, n as UnknownHashVariantError, o as writeHeader, r as assertBodyLength, t as SerializationError } from "../serialize-BQ2UzZqq.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;
 const SALT = Uint32Array.of(1203114875, 1150766481, 2284105051, 2729912477, 1884591559, 770785867, 2667333959, 1550580529);
-const scratchHash = {
-	h1lo: 0,
-	h1hi: 0,
-	h2lo: 0,
-	h2hi: 0
-};
+const scratch2 = /* @__PURE__ */ new Uint32Array(2);
 /** Thrown when an operation requires two filters built with identical parameters. */
 var BlockedBloomParamMismatchError = class extends Error {
 	/** Discriminates this error from other `Error`s. */
@@ -103,11 +98,15 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = readHeader(bytes);
+		const { type, flags, body } = readHeader(bytes);
+		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if ((flags & 15) !== 1) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
+		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,
@@ -131,9 +130,9 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		dv.setUint32(8, this.#n, true);
 		body.set(lanes, 12);
 		return writeHeader({
-			version: 1,
+			version: 2,
 			type: TYPE,
-			flags: 0
+			flags: 1
 		}, body);
 	}
 	/**
@@ -181,9 +180,9 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	}
 };
 function fillBlock(key, numBlocks, seed, outWords, outBits) {
-	hash128KeyInto(key, seed, scratchHash);
-	const block = reduce((scratchHash.h1lo ^ scratchHash.h1hi) >>> 0, numBlocks);
-	const x = (scratchHash.h2lo ^ scratchHash.h2hi) >>> 0;
+	hash32x2Into(key, seed, scratch2);
+	const block = reduce(scratch2[0] ?? 0, numBlocks);
+	const x = scratch2[1] ?? 0;
 	const base = block * 8;
 	for (let i = 0; i < 8; i++) {
 		outWords[i] = base + i;

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-fa-pEUGq.cjs");
 const require_params = require("../params-J8p3bKq5.cjs");
 //#region src/core/bitset.ts
 var BitSetRangeError = class extends RangeError {
@@ -94,17 +94,23 @@ var BloomFilter = class BloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = require_serialize.readHeader(bytes);
+		const { type, flags, body } = require_serialize.readHeader(bytes);
+		if (type !== TYPE) throw new require_serialize.SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if ((flags & 15) !== 1) throw new require_serialize.UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
+		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;
 	}
 	/**
@@ -159,16 +165,17 @@ var BloomFilter = class BloomFilter {
 	*/
 	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
+			flags: 1
 		}, body);
 	}
 	/**

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 readHeader, i as assertMinBodyLength, n as UnknownHashVariantError, o as writeHeader, p as probeInto, r as assertBodyLength, t as SerializationError } from "../serialize-BQ2UzZqq.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,23 @@ var BloomFilter = class BloomFilter {
 	* @returns The reconstructed filter.
 	*/
 	static fromBytes(bytes) {
-		const { body } = readHeader(bytes);
+		const { type, flags, body } = readHeader(bytes);
+		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if ((flags & 15) !== 1) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
+		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;
 	}
 	/**
@@ -158,16 +164,17 @@ var BloomFilter = class BloomFilter {
 	*/
 	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
+			flags: 1
 		}, 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-fa-pEUGq.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
 };
-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;
@@ -211,13 +163,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 +231,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);
@@ -291,8 +246,8 @@ var BinaryFuse = class {
 		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;
+		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;

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 readHeader, c as RLO, f as mul64, i as assertMinBodyLength, l as fmix64, o as writeHeader, r as assertBodyLength, s as RHI, t as SerializationError, u as hash128KeyInto } from "../serialize-BQ2UzZqq.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
 };
-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;
@@ -210,13 +162,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 +230,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.3.0";
+const VERSION = "0.5.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.3.0";
+const VERSION = "0.5.0";
 //#endregion
 export { VERSION };

package/dist/{serialize-CHHDM4TQ.cjs → serialize-BQ2UzZqq.js}

@@ -81,6 +81,37 @@ function fmix64(lo, hi) {
 	RLO = l;
 	RHI = h;
 }
+function murmur32(bytes, seed, len = bytes.length) {
+	let h = seed >>> 0;
+	const n = len & -4;
+	for (let i = 0; i < n; i += 4) {
+		let k = ((bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0) << 16 | (bytes[i + 3] ?? 0) << 24) >>> 0;
+		k = Math.imul(k, 3432918353);
+		k = (k << 15 | k >>> 17) >>> 0;
+		k = Math.imul(k, 461845907);
+		h = (h ^ k) >>> 0;
+		h = (h << 13 | h >>> 19) >>> 0;
+		h = Math.imul(h, 5) + 3864292196 >>> 0;
+	}
+	let k1 = 0;
+	const rem = len & 3;
+	if (rem >= 3) k1 ^= (bytes[n + 2] ?? 0) << 16;
+	if (rem >= 2) k1 ^= (bytes[n + 1] ?? 0) << 8;
+	if (rem >= 1) {
+		k1 ^= bytes[n] ?? 0;
+		k1 = Math.imul(k1 >>> 0, 3432918353);
+		k1 = (k1 << 15 | k1 >>> 17) >>> 0;
+		k1 = Math.imul(k1, 461845907);
+		h = (h ^ k1) >>> 0;
+	}
+	h = (h ^ len) >>> 0;
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return h >>> 0;
+}
 function computeLanes(bytes, seed, len) {
 	const nblocks = len >>> 4;
 	let h1lo = seed >>> 0;
@@ -186,16 +217,22 @@ function computeLanes(bytes, seed, len) {
 }
 const keyEncoder = new TextEncoder();
 let keyBuf = /* @__PURE__ */ new Uint8Array(256);
-function keyToLanes(key, seed) {
+let encBytes = keyBuf;
+let encLen = 0;
+function encodeKey(key) {
 	if (typeof key === "string") {
 		const cap = key.length * 3;
 		if (keyBuf.length < cap) keyBuf = new Uint8Array(cap);
-		const { written } = keyEncoder.encodeInto(key, keyBuf);
-		computeLanes(keyBuf, seed, written);
+		encLen = keyEncoder.encodeInto(key, keyBuf).written;
+		encBytes = keyBuf;
 		return;
 	}
-	const bytes = normalize(key);
-	computeLanes(bytes, seed, bytes.length);
+	encBytes = normalize(key);
+	encLen = encBytes.length;
+}
+function keyToLanes(key, seed) {
+	encodeKey(key);
+	computeLanes(encBytes, seed, encLen);
 }
 function hash128KeyInto(key, seed, out) {
 	keyToLanes(key, seed);
@@ -221,10 +258,16 @@ function reduce(x, range) {
 * Kirsch-Mitzenmacher enhanced double hashing `g_i = h1 + i*h2 + i^2`
 * (the RocksDB `+i^2` fix), reduced into range with Lemire multiply-shift.
 */
+const SEED2 = 2654435761;
+function hash32x2Into(key, seed, out) {
+	encodeKey(key);
+	out[0] = murmur32(encBytes, seed, encLen);
+	out[1] = murmur32(encBytes, (seed ^ SEED2) >>> 0, encLen);
+}
 function probeInto(key, count, range, seed, out) {
-	keyToLanes(key, seed);
-	const a = (LANES.h1lo ^ LANES.h1hi) >>> 0;
-	const b = (LANES.h2lo ^ LANES.h2hi) >>> 0;
+	encodeKey(key);
+	const a = murmur32(encBytes, seed, encLen);
+	const b = murmur32(encBytes, (seed ^ SEED2) >>> 0, encLen);
 	for (let i = 0; i < count; i++) out[i] = reduce(a + Math.imul(i, b) + i * i >>> 0, range);
 }
 //#endregion
@@ -274,14 +317,31 @@ var BadMagicError = class extends SerializationError {
 var UnknownVersionError = class extends SerializationError {
 	name = "UnknownVersionError";
 };
+var UnknownHashVariantError = class extends SerializationError {
+	name = "UnknownHashVariantError";
+};
 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,39 +351,4 @@ function readHeader(frame) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "SerializationError", {
-	enumerable: true,
-	get: function() {
-		return SerializationError;
-	}
-});
-Object.defineProperty(exports, "hash128KeyInto", {
-	enumerable: true,
-	get: function() {
-		return hash128KeyInto;
-	}
-});
-Object.defineProperty(exports, "probeInto", {
-	enumerable: true,
-	get: function() {
-		return probeInto;
-	}
-});
-Object.defineProperty(exports, "readHeader", {
-	enumerable: true,
-	get: function() {
-		return readHeader;
-	}
-});
-Object.defineProperty(exports, "reduce", {
-	enumerable: true,
-	get: function() {
-		return reduce;
-	}
-});
-Object.defineProperty(exports, "writeHeader", {
-	enumerable: true,
-	get: function() {
-		return writeHeader;
-	}
-});
+export { readHeader as a, RLO as c, hash32x2Into as d, mul64 as f, assertMinBodyLength as i, fmix64 as l, reduce as m, UnknownHashVariantError as n, writeHeader as o, probeInto as p, assertBodyLength as r, RHI as s, SerializationError as t, hash128KeyInto as u };

package/dist/{serialize-5XQ5y_R-.js → serialize-fa-pEUGq.cjs}

@@ -81,6 +81,37 @@ function fmix64(lo, hi) {
 	RLO = l;
 	RHI = h;
 }
+function murmur32(bytes, seed, len = bytes.length) {
+	let h = seed >>> 0;
+	const n = len & -4;
+	for (let i = 0; i < n; i += 4) {
+		let k = ((bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0) << 16 | (bytes[i + 3] ?? 0) << 24) >>> 0;
+		k = Math.imul(k, 3432918353);
+		k = (k << 15 | k >>> 17) >>> 0;
+		k = Math.imul(k, 461845907);
+		h = (h ^ k) >>> 0;
+		h = (h << 13 | h >>> 19) >>> 0;
+		h = Math.imul(h, 5) + 3864292196 >>> 0;
+	}
+	let k1 = 0;
+	const rem = len & 3;
+	if (rem >= 3) k1 ^= (bytes[n + 2] ?? 0) << 16;
+	if (rem >= 2) k1 ^= (bytes[n + 1] ?? 0) << 8;
+	if (rem >= 1) {
+		k1 ^= bytes[n] ?? 0;
+		k1 = Math.imul(k1 >>> 0, 3432918353);
+		k1 = (k1 << 15 | k1 >>> 17) >>> 0;
+		k1 = Math.imul(k1, 461845907);
+		h = (h ^ k1) >>> 0;
+	}
+	h = (h ^ len) >>> 0;
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return h >>> 0;
+}
 function computeLanes(bytes, seed, len) {
 	const nblocks = len >>> 4;
 	let h1lo = seed >>> 0;
@@ -186,16 +217,22 @@ function computeLanes(bytes, seed, len) {
 }
 const keyEncoder = new TextEncoder();
 let keyBuf = /* @__PURE__ */ new Uint8Array(256);
-function keyToLanes(key, seed) {
+let encBytes = keyBuf;
+let encLen = 0;
+function encodeKey(key) {
 	if (typeof key === "string") {
 		const cap = key.length * 3;
 		if (keyBuf.length < cap) keyBuf = new Uint8Array(cap);
-		const { written } = keyEncoder.encodeInto(key, keyBuf);
-		computeLanes(keyBuf, seed, written);
+		encLen = keyEncoder.encodeInto(key, keyBuf).written;
+		encBytes = keyBuf;
 		return;
 	}
-	const bytes = normalize(key);
-	computeLanes(bytes, seed, bytes.length);
+	encBytes = normalize(key);
+	encLen = encBytes.length;
+}
+function keyToLanes(key, seed) {
+	encodeKey(key);
+	computeLanes(encBytes, seed, encLen);
 }
 function hash128KeyInto(key, seed, out) {
 	keyToLanes(key, seed);
@@ -221,10 +258,16 @@ function reduce(x, range) {
 * Kirsch-Mitzenmacher enhanced double hashing `g_i = h1 + i*h2 + i^2`
 * (the RocksDB `+i^2` fix), reduced into range with Lemire multiply-shift.
 */
+const SEED2 = 2654435761;
+function hash32x2Into(key, seed, out) {
+	encodeKey(key);
+	out[0] = murmur32(encBytes, seed, encLen);
+	out[1] = murmur32(encBytes, (seed ^ SEED2) >>> 0, encLen);
+}
 function probeInto(key, count, range, seed, out) {
-	keyToLanes(key, seed);
-	const a = (LANES.h1lo ^ LANES.h1hi) >>> 0;
-	const b = (LANES.h2lo ^ LANES.h2hi) >>> 0;
+	encodeKey(key);
+	const a = murmur32(encBytes, seed, encLen);
+	const b = murmur32(encBytes, (seed ^ SEED2) >>> 0, encLen);
 	for (let i = 0; i < count; i++) out[i] = reduce(a + Math.imul(i, b) + i * i >>> 0, range);
 }
 //#endregion
@@ -274,14 +317,31 @@ var BadMagicError = class extends SerializationError {
 var UnknownVersionError = class extends SerializationError {
 	name = "UnknownVersionError";
 };
+var UnknownHashVariantError = class extends SerializationError {
+	name = "UnknownHashVariantError";
+};
 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 +351,87 @@ function readHeader(frame) {
 	};
 }
 //#endregion
-export { probeInto as a, hash128KeyInto as i, readHeader as n, reduce as o, writeHeader as r, SerializationError as t };
+Object.defineProperty(exports, "RHI", {
+	enumerable: true,
+	get: function() {
+		return RHI;
+	}
+});
+Object.defineProperty(exports, "RLO", {
+	enumerable: true,
+	get: function() {
+		return RLO;
+	}
+});
+Object.defineProperty(exports, "SerializationError", {
+	enumerable: true,
+	get: function() {
+		return SerializationError;
+	}
+});
+Object.defineProperty(exports, "UnknownHashVariantError", {
+	enumerable: true,
+	get: function() {
+		return UnknownHashVariantError;
+	}
+});
+Object.defineProperty(exports, "assertBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertBodyLength;
+	}
+});
+Object.defineProperty(exports, "assertMinBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertMinBodyLength;
+	}
+});
+Object.defineProperty(exports, "fmix64", {
+	enumerable: true,
+	get: function() {
+		return fmix64;
+	}
+});
+Object.defineProperty(exports, "hash128KeyInto", {
+	enumerable: true,
+	get: function() {
+		return hash128KeyInto;
+	}
+});
+Object.defineProperty(exports, "hash32x2Into", {
+	enumerable: true,
+	get: function() {
+		return hash32x2Into;
+	}
+});
+Object.defineProperty(exports, "mul64", {
+	enumerable: true,
+	get: function() {
+		return mul64;
+	}
+});
+Object.defineProperty(exports, "probeInto", {
+	enumerable: true,
+	get: function() {
+		return probeInto;
+	}
+});
+Object.defineProperty(exports, "readHeader", {
+	enumerable: true,
+	get: function() {
+		return readHeader;
+	}
+});
+Object.defineProperty(exports, "reduce", {
+	enumerable: true,
+	get: function() {
+		return reduce;
+	}
+});
+Object.defineProperty(exports, "writeHeader", {
+	enumerable: true,
+	get: function() {
+		return writeHeader;
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "distillate",
-  "version": "0.3.0",
+  "version": "0.5.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",