distillate 0.8.2 → 0.9.0

package/README.md

@@ -42,11 +42,16 @@ Every push runs a CI smoke matrix that imports the built package on Node 22/24,
 
 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      | Faster lookups and a lower FPR for a small space premium |
-| `distillate/fuse`    | Binary Fuse   | no       | Static set built once and queried a lot; least space     |
+| Import               | Structure     | Answers            | Use for                                                  |
+| -------------------- | ------------- | ------------------ | -------------------------------------------------------- |
+| `distillate/bloom`   | Classic Bloom | seen this key?     | Familiar default, migration from `bloom-filters`         |
+| `distillate/blocked` | Blocked Bloom | seen this key?     | Faster lookups and a lower FPR for a small space premium |
+| `distillate/fuse`    | Binary Fuse   | seen this key?     | Static set built once and queried a lot; least space     |
+| `distillate/hll`     | HyperLogLog   | how many distinct? | Counting distinct users, IPs, or keys in fixed space     |
+
+The filters are mutable except Binary Fuse, which is built once from the whole
+key set. HyperLogLog is not a filter: it counts distinct keys and cannot report
+whether it saw any particular one.
 
 ### Classic Bloom (`distillate/bloom`)
 
@@ -86,7 +91,7 @@ import { BinaryFuse8, BinaryFuse16 } from "distillate/fuse";
 const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
 filter.has("alice"); // true
 filter.size; // 3
-filter.bitsPerKey; // 64 at this size; see below
+filter.bitsPerKey; // 64
 
 // Lower false-positive rate, twice the space:
 const precise = BinaryFuse16.from(["alice", "bob", "carol"]);
@@ -96,6 +101,29 @@ const precise = BinaryFuse16.from(["alice", "bob", "carol"]);
 
 Also: `toBytes` / `fromBytes`. No `add` / `delete`; rebuild `from` the new set to change membership.
 
+### HyperLogLog (`distillate/hll`)
+
+A **sketch**, not a filter: it counts distinct keys in space fixed by precision rather than by the answer, and cannot report whether it saw any particular key. 12 KiB counts a thousand distinct keys or a billion, at about 0.8% relative error. Full API and sizing: [HyperLogLog guide](https://distillate.akxp.net/guides/hll/).
+
+```ts
+import { HyperLogLog } from "distillate/hll";
+
+const sketch = HyperLogLog.create(0.01); // target relative error
+sketch.add("alice");
+sketch.add("bob");
+sketch.add("alice"); // already counted
+
+sketch.count(); // 2
+
+// Merge per-shard sketches without double-counting the overlap:
+const other = HyperLogLog.from(["bob", "carol"], 0.01);
+sketch.union(other).count(); // 3
+```
+
+Below a few thousand distinct keys the sketch counts rather than estimates, so small answers are exact. It switches to fixed-size registers on its own once that stops paying, with nothing to configure.
+
+Also: `equals`, `toBytes` / `fromBytes`, `toJSON` / `fromJSON`, `standardError`, `hllSizing(relativeError)`, and a low-level `new HyperLogLog({ p, seed })`.
+
 ## Performance
 
 Classic Bloom head-to-head at a **matched 1% false-positive rate** over the same 100k keys, measured by identical code (cross-library harness, node v24.14.1, Apple M5):

package/dist/blocked/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CXnRWItH.cjs");
+const require_serialize = require("../serialize-Ul2LKFJU.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
 //#region src/blocked/blocked.ts
 const TYPE = 2;
@@ -89,7 +89,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	}
 	static fromBytes(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 (type !== TYPE) throw new require_serialize.SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) 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);
@@ -105,7 +105,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	toBytes() {
 		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
 		return require_serialize.writeFrame({
-			version: 3,
+			version: 4,
 			type: TYPE,
 			flags: 0
 		}, 12 + lanes.length, (body, dv) => {

package/dist/blocked/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.cjs";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.cjs";
 import { t as ParamError } from "../params-DnqJBqLS.cjs";
 //#region src/blocked/blocked.d.ts
 /**

package/dist/blocked/index.d.ts

@@ -1,4 +1,4 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.js";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.js";
 import { t as ParamError } from "../params-DnqJBqLS.js";
 //#region src/blocked/blocked.d.ts
 /**

package/dist/blocked/index.js

@@ -1,4 +1,4 @@
-import { a as UnknownHashVariantError, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, i as TruncatedError, l as bytesEqual, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope, v as hash32x2Into, x as reduce } from "../serialize-BqIcsR2J.js";
+import { a as UnknownHashVariantError, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, i as TruncatedError, l as bytesEqual, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope, v as hash32x2Into, x as reduce } from "../serialize-D59Ri81a.js";
 import { i as assertProbability, n as assertPositiveFinite, o as assertUint32, r as assertPositiveInt, t as ParamError } from "../params-CeajSrwv.js";
 //#region src/blocked/blocked.ts
 const TYPE = 2;
@@ -88,7 +88,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	}
 	static fromBytes(bytes) {
 		const { type, flags, body } = readHeader(bytes);
-		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if (type !== TYPE) throw new SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 		assertMinBodyLength(body.length, 12, "blocked");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -104,7 +104,7 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 	toBytes() {
 		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
 		return writeFrame({
-			version: 3,
+			version: 4,
 			type: TYPE,
 			flags: 0
 		}, 12 + lanes.length, (body, dv) => {

package/dist/bloom/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CXnRWItH.cjs");
+const require_serialize = require("../serialize-Ul2LKFJU.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
+const require_sizing = require("../sizing-BLzZk2zr.cjs");
 //#region src/core/bitset.ts
 var BitSetRangeError = class extends RangeError {
 	name = "BitSetRangeError";
@@ -32,15 +33,6 @@ var BitSet = class {
 	}
 };
 //#endregion
-//#region src/core/sizing.ts
-function bloomSizing(n, epsilon) {
-	const m = Math.ceil(-n * Math.log(epsilon) / (Math.LN2 * Math.LN2));
-	return {
-		m,
-		k: Math.max(1, Math.round(m / n * Math.LN2))
-	};
-}
-//#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
 var BloomParamMismatchError = class extends Error {
@@ -57,7 +49,10 @@ var BloomFilter = class BloomFilter {
 		require_params.assertPositiveInt(n, "n");
 		require_params.assertUint32(n, "n");
 		require_params.assertProbability(epsilon, "epsilon");
-		return BloomFilter.#withN(bloomSizing(n, epsilon), n);
+		return new BloomFilter({
+			...require_sizing.bloomSizing(n, epsilon),
+			n
+		});
 	}
 	static from(keys, epsilon) {
 		const arr = [...keys];
@@ -67,7 +62,7 @@ var BloomFilter = class BloomFilter {
 	}
 	static fromBytes(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 (type !== TYPE) throw new require_serialize.SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) 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);
@@ -76,31 +71,31 @@ var BloomFilter = class BloomFilter {
 		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 = BloomFilter.#withN({
+		const f = new BloomFilter({
 			m,
 			k,
-			seed
-		}, n);
+			seed,
+			n
+		});
 		f.#bits.bytes.set(body.subarray(14));
 		return f;
 	}
-	constructor({ m, k, seed = 0 }) {
+	constructor({ m, k, seed = 0, n }) {
 		require_params.assertPositiveInt(m, "m");
 		require_params.assertUint32(m, "m");
 		require_params.assertPositiveInt(k, "k");
 		require_params.assertUint16(k, "k");
 		require_params.assertUint32(seed, "seed");
+		if (n !== void 0) {
+			require_params.assertPositiveInt(n, "n");
+			require_params.assertUint32(n, "n");
+		}
 		this.#bits = new BitSet(m);
 		this.#m = m;
 		this.#k = k;
 		this.#seed = seed;
 		this.#scratch = new Uint32Array(k);
-		this.#n = Math.round(m * Math.LN2 / k);
-	}
-	static #withN(params, n) {
-		const f = new BloomFilter(params);
-		f.#n = n;
-		return f;
+		this.#n = n ?? Math.max(1, Math.round(m * Math.LN2 / k));
 	}
 	get m() {
 		return this.#m;
@@ -123,7 +118,7 @@ var BloomFilter = class BloomFilter {
 	toBytes() {
 		const payload = this.#bits.bytes;
 		return require_serialize.writeFrame({
-			version: 3,
+			version: 4,
 			type: TYPE,
 			flags: 0
 		}, 14 + payload.length, (body, dv) => {
@@ -149,11 +144,12 @@ var BloomFilter = class BloomFilter {
 		const b = other.#bits.bytes;
 		const merged = new Uint8Array(a.length);
 		for (let i = 0; i < a.length; i++) merged[i] = (a[i] ?? 0) | (b[i] ?? 0);
-		const r = BloomFilter.#withN({
+		const r = new BloomFilter({
 			m: this.#m,
 			k: this.#k,
-			seed: this.#seed
-		}, this.#n);
+			seed: this.#seed,
+			n: this.#n
+		});
 		r.#bits.bytes.set(merged);
 		return r;
 	}
@@ -177,4 +173,4 @@ exports.SerializationError = require_serialize.SerializationError;
 exports.TruncatedError = require_serialize.TruncatedError;
 exports.UnknownHashVariantError = require_serialize.UnknownHashVariantError;
 exports.UnknownVersionError = require_serialize.UnknownVersionError;
-exports.bloomSizing = bloomSizing;
+exports.bloomSizing = require_sizing.bloomSizing;

package/dist/bloom/index.d.cts

@@ -1,5 +1,6 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.cjs";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.cjs";
 import { t as ParamError } from "../params-DnqJBqLS.cjs";
+import { r as bloomSizing, t as BloomSizing } from "../sizing-wYOW27eY.cjs";
 //#region src/bloom/bloom.d.ts
 /** Thrown when an operation requires two filters built with identical parameters. */
 declare class BloomParamMismatchError extends Error {
@@ -14,6 +15,12 @@ interface BloomParams {
   k: number;
   /** Hash seed; defaults to `0`. */
   seed?: number;
+  /**
+   * Expected number of keys. Omitted, it is derived as `m * ln2 / k`, the
+   * count this geometry is optimal for, which need not be the count the
+   * geometry was solved for.
+   */
+  n?: number;
 }
 /**
  * A classic Bloom filter: a space-efficient set with a tunable false-positive
@@ -58,7 +65,7 @@ declare class BloomFilter {
    * Constructs a filter from low-level {@link BloomParams}. Prefer
    * {@link BloomFilter.create} unless restoring a specific configuration.
    */
-  constructor({ m, k, seed }: BloomParams);
+  constructor({ m, k, seed, n }: BloomParams);
   /** Number of bits in the filter. */
   get m(): number;
   /** Number of hash probes per key. */
@@ -67,7 +74,15 @@ declare class BloomFilter {
   get seed(): number;
   /** Number of bits currently set. */
   get length(): number;
-  /** Analytic design bits-per-key `m / n`. */
+  /**
+   * Analytic design bits-per-key, `m / n`.
+   *
+   * A filter built without an explicit `n` derives one as `m * ln2 / k`, the
+   * count its geometry is optimal for. That need not be the count the
+   * geometry was solved for, so the same `m` and `k` can report a different
+   * cost depending on how the filter was constructed. `create` and
+   * `fromBytes` always carry the real `n`.
+   */
   get bitsPerKey(): number;
   /**
    * Estimates the current false-positive rate from the actual fill,
@@ -128,15 +143,4 @@ declare class BloomFilter {
   has(key: BytesLike): boolean;
 }
 //#endregion
-//#region src/core/sizing.d.ts
-/** Bloom filter geometry: the `BloomParams` fields a sizing solve determines. */
-interface BloomSizing {
-  /** Number of bits in the filter. */
-  m: number;
-  /** Number of hash probes per key. */
-  k: number;
-}
-/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
-declare function bloomSizing(n: number, epsilon: number): BloomSizing;
-//#endregion
 export { BadMagicError, BloomFilter, BloomParamMismatchError, type BloomParams, type BloomSizing, ChecksumError, type FilterJSON, ParamError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, bloomSizing };

package/dist/bloom/index.d.ts

@@ -1,5 +1,6 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.js";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.js";
 import { t as ParamError } from "../params-DnqJBqLS.js";
+import { r as bloomSizing, t as BloomSizing } from "../sizing-wYOW27eY.js";
 //#region src/bloom/bloom.d.ts
 /** Thrown when an operation requires two filters built with identical parameters. */
 declare class BloomParamMismatchError extends Error {
@@ -14,6 +15,12 @@ interface BloomParams {
   k: number;
   /** Hash seed; defaults to `0`. */
   seed?: number;
+  /**
+   * Expected number of keys. Omitted, it is derived as `m * ln2 / k`, the
+   * count this geometry is optimal for, which need not be the count the
+   * geometry was solved for.
+   */
+  n?: number;
 }
 /**
  * A classic Bloom filter: a space-efficient set with a tunable false-positive
@@ -58,7 +65,7 @@ declare class BloomFilter {
    * Constructs a filter from low-level {@link BloomParams}. Prefer
    * {@link BloomFilter.create} unless restoring a specific configuration.
    */
-  constructor({ m, k, seed }: BloomParams);
+  constructor({ m, k, seed, n }: BloomParams);
   /** Number of bits in the filter. */
   get m(): number;
   /** Number of hash probes per key. */
@@ -67,7 +74,15 @@ declare class BloomFilter {
   get seed(): number;
   /** Number of bits currently set. */
   get length(): number;
-  /** Analytic design bits-per-key `m / n`. */
+  /**
+   * Analytic design bits-per-key, `m / n`.
+   *
+   * A filter built without an explicit `n` derives one as `m * ln2 / k`, the
+   * count its geometry is optimal for. That need not be the count the
+   * geometry was solved for, so the same `m` and `k` can report a different
+   * cost depending on how the filter was constructed. `create` and
+   * `fromBytes` always carry the real `n`.
+   */
   get bitsPerKey(): number;
   /**
    * Estimates the current false-positive rate from the actual fill,
@@ -128,15 +143,4 @@ declare class BloomFilter {
   has(key: BytesLike): boolean;
 }
 //#endregion
-//#region src/core/sizing.d.ts
-/** Bloom filter geometry: the `BloomParams` fields a sizing solve determines. */
-interface BloomSizing {
-  /** Number of bits in the filter. */
-  m: number;
-  /** Number of hash probes per key. */
-  k: number;
-}
-/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
-declare function bloomSizing(n: number, epsilon: number): BloomSizing;
-//#endregion
 export { BadMagicError, BloomFilter, BloomParamMismatchError, type BloomParams, type BloomSizing, ChecksumError, type FilterJSON, ParamError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, bloomSizing };

package/dist/bloom/index.js

@@ -1,5 +1,6 @@
-import { a as UnknownHashVariantError, b as probeInto, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, i as TruncatedError, l as bytesEqual, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope } from "../serialize-BqIcsR2J.js";
+import { a as UnknownHashVariantError, b as probeInto, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, i as TruncatedError, l as bytesEqual, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope } from "../serialize-D59Ri81a.js";
 import { a as assertUint16, i as assertProbability, o as assertUint32, r as assertPositiveInt, t as ParamError } from "../params-CeajSrwv.js";
+import { t as bloomSizing } from "../sizing-BtUrtvF_.js";
 //#region src/core/bitset.ts
 var BitSetRangeError = class extends RangeError {
 	name = "BitSetRangeError";
@@ -31,15 +32,6 @@ var BitSet = class {
 	}
 };
 //#endregion
-//#region src/core/sizing.ts
-function bloomSizing(n, epsilon) {
-	const m = Math.ceil(-n * Math.log(epsilon) / (Math.LN2 * Math.LN2));
-	return {
-		m,
-		k: Math.max(1, Math.round(m / n * Math.LN2))
-	};
-}
-//#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
 var BloomParamMismatchError = class extends Error {
@@ -56,7 +48,10 @@ var BloomFilter = class BloomFilter {
 		assertPositiveInt(n, "n");
 		assertUint32(n, "n");
 		assertProbability(epsilon, "epsilon");
-		return BloomFilter.#withN(bloomSizing(n, epsilon), n);
+		return new BloomFilter({
+			...bloomSizing(n, epsilon),
+			n
+		});
 	}
 	static from(keys, epsilon) {
 		const arr = [...keys];
@@ -66,7 +61,7 @@ var BloomFilter = class BloomFilter {
 	}
 	static fromBytes(bytes) {
 		const { type, flags, body } = readHeader(bytes);
-		if (type !== TYPE) throw new SerializationError(`expected AMQF type ${String(TYPE)}, got ${String(type)}`);
+		if (type !== TYPE) throw new SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 		assertMinBodyLength(body.length, 14, "bloom");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -75,31 +70,31 @@ var BloomFilter = class BloomFilter {
 		const seed = dv.getUint32(6, true);
 		const n = dv.getUint32(10, true);
 		assertBodyLength(body.length, 14 + Math.ceil(m / 8), "bloom");
-		const f = BloomFilter.#withN({
+		const f = new BloomFilter({
 			m,
 			k,
-			seed
-		}, n);
+			seed,
+			n
+		});
 		f.#bits.bytes.set(body.subarray(14));
 		return f;
 	}
-	constructor({ m, k, seed = 0 }) {
+	constructor({ m, k, seed = 0, n }) {
 		assertPositiveInt(m, "m");
 		assertUint32(m, "m");
 		assertPositiveInt(k, "k");
 		assertUint16(k, "k");
 		assertUint32(seed, "seed");
+		if (n !== void 0) {
+			assertPositiveInt(n, "n");
+			assertUint32(n, "n");
+		}
 		this.#bits = new BitSet(m);
 		this.#m = m;
 		this.#k = k;
 		this.#seed = seed;
 		this.#scratch = new Uint32Array(k);
-		this.#n = Math.round(m * Math.LN2 / k);
-	}
-	static #withN(params, n) {
-		const f = new BloomFilter(params);
-		f.#n = n;
-		return f;
+		this.#n = n ?? Math.max(1, Math.round(m * Math.LN2 / k));
 	}
 	get m() {
 		return this.#m;
@@ -122,7 +117,7 @@ var BloomFilter = class BloomFilter {
 	toBytes() {
 		const payload = this.#bits.bytes;
 		return writeFrame({
-			version: 3,
+			version: 4,
 			type: TYPE,
 			flags: 0
 		}, 14 + payload.length, (body, dv) => {
@@ -148,11 +143,12 @@ var BloomFilter = class BloomFilter {
 		const b = other.#bits.bytes;
 		const merged = new Uint8Array(a.length);
 		for (let i = 0; i < a.length; i++) merged[i] = (a[i] ?? 0) | (b[i] ?? 0);
-		const r = BloomFilter.#withN({
+		const r = new BloomFilter({
 			m: this.#m,
 			k: this.#k,
-			seed: this.#seed
-		}, this.#n);
+			seed: this.#seed,
+			n: this.#n
+		});
 		r.#bits.bytes.set(merged);
 		return r;
 	}

package/dist/fuse/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-CXnRWItH.cjs");
+const require_serialize = require("../serialize-Ul2LKFJU.cjs");
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -159,7 +159,7 @@ function buildState(keys, alloc) {
 }
 function fuseStateFromBytes(bytes, expectedType) {
 	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 (type !== expectedType) throw new require_serialize.SerializationError(`expected DSTL 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);
@@ -216,7 +216,7 @@ var BinaryFuse = class {
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
 		return require_serialize.writeFrame({
-			version: 3,
+			version: 4,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
 		}, 16 + laneBytes.length, (body, dv) => {

package/dist/fuse/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.cjs";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.cjs";
 //#region src/fuse/fuse.d.ts
 /** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {

package/dist/fuse/index.d.ts

@@ -1,4 +1,4 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-ChyWpB9F.js";
+import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.js";
 //#region src/fuse/fuse.d.ts
 /** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {

package/dist/fuse/index.js

@@ -1,4 +1,4 @@
-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";
+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-D59Ri81a.js";
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
@@ -158,7 +158,7 @@ function buildState(keys, alloc) {
 }
 function fuseStateFromBytes(bytes, expectedType) {
 	const { type, flags, body } = readHeader(bytes);
-	if (type !== expectedType) throw new SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	if (type !== expectedType) throw new SerializationError(`expected DSTL 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);
@@ -215,7 +215,7 @@ var BinaryFuse = class {
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
 		return writeFrame({
-			version: 3,
+			version: 4,
 			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
 			flags: 0
 		}, 16 + laneBytes.length, (body, dv) => {