distillate 0.10.0 → 0.12.0

package/README.md

@@ -6,7 +6,7 @@
 
 Probabilistic data structures for JavaScript: space-efficient, approximate answers with tunable error and zero false negatives. TypeScript-first, zero dependencies, and the right structure per workload. It opens with a family of membership filters and is built to grow into other sketches.
 
-> **Pre-release (0.x).** The published structures are correct, tested, and benchmarked, but the public API may still change before `1.0`, and more structures (Cuckoo, Scalable Bloom) are on the way. Pin a version if you depend on it.
+> **Pre-release (0.x).** The published structures are correct, tested, and benchmarked, but the public API may still change before `1.0`. Pin a version if you depend on it.
 
 ## Why
 
@@ -42,12 +42,14 @@ 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     | 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     |
+| Import                | Structure      | Answers            | Use for                                                  |
+| --------------------- | -------------- | ------------------ | -------------------------------------------------------- |
+| `distillate/bloom`    | Classic Bloom  | seen this key?     | Familiar default, migration from `bloom-filters`         |
+| `distillate/scalable` | Scalable Bloom | seen this key?     | Key count unknown or growing; keeps its FPR bound        |
+| `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/cuckoo`   | Cuckoo         | seen this key?     | Keys come and go; the one filter with delete             |
+| `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
@@ -69,6 +71,24 @@ const restored = BloomFilter.fromBytes(bytes);
 
 Also: `union(other)` (merge equal-parameter filters), `bitsPerKey`, and a low-level `new BloomFilter({ m, k, seed })`.
 
+### Scalable Bloom (`distillate/scalable`)
+
+For when you cannot say how many keys are coming. It grows by opening larger, tighter Bloom stages as keys arrive, and keeps its false-positive rate under the target however many open. Full API and trade-offs: [Scalable Bloom guide](https://distillate.akxp.net/guides/scalable/).
+
+```ts
+import { ScalableBloomFilter } from "distillate/scalable";
+
+const seen = ScalableBloomFilter.create(10, 0.01); // first stage, target FPR
+for (let i = 0; i < 30; i++) seen.add(`key-${String(i)}`);
+
+seen.stages; // 2
+seen.has("key-29"); // true
+```
+
+A key already held is not counted again, so duplicates never use up capacity. It costs more bits per key than a Classic Bloom sized for a known `n`; if you know `n`, use that.
+
+Also: `from(keys, epsilon)`, `union`, `equals`, `rate`, `toBytes` / `fromBytes`, `toJSON` / `fromJSON`, and `growth` / `tightening` / `seed` options.
+
 ### Blocked Bloom (`distillate/blocked`)
 
 ```ts
@@ -101,6 +121,25 @@ const precise = BinaryFuse16.from(["alice", "bob", "carol"]);
 
 Also: `toBytes` / `fromBytes`. No `add` / `delete`; rebuild `from` the new set to change membership.
 
+### Cuckoo (`distillate/cuckoo`)
+
+For a set that shrinks as well as grows: the one filter here with `delete`. Full API and trade-offs: [Cuckoo guide](https://distillate.akxp.net/guides/cuckoo/).
+
+```ts
+import { CuckooFilter } from "distillate/cuckoo";
+
+const sessions = CuckooFilter.create(100_000, 0.01);
+sessions.add("alice");
+sessions.has("alice"); // true
+
+sessions.delete("alice"); // true
+sessions.has("alice"); // false
+```
+
+Only delete keys you added: a key never added can share a fingerprint with one that was, and deleting it removes that one instead. An add into a full filter throws `CuckooFullError` and leaves the filter unchanged. It is larger than a Classic Bloom at common targets and smaller only at about 0.2% and below, so pick it for delete, not for space.
+
+Also: `from(keys, epsilon)`, `equals`, `rate`, `count`, `toBytes` / `fromBytes`, `toJSON` / `fromJSON`, `cuckooSizing(n, epsilon)`, and a `seed` option.
+
 ### 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/).

package/dist/bitset-Cf2jwRJX.js

@@ -0,0 +1,32 @@
+//#region src/core/bitset.ts
+var BitSetRangeError = class extends RangeError {
+	name = "BitSetRangeError";
+};
+const MAX_BITS = 2 ** 32;
+var BitSet = class {
+	#bits;
+	constructor(nbits) {
+		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
+		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
+	}
+	set(i) {
+		const idx = i >>> 3;
+		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
+	}
+	get(i) {
+		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
+	}
+	get bytes() {
+		return this.#bits;
+	}
+	count() {
+		let total = 0;
+		for (let byte of this.#bits) while (byte) {
+			byte &= byte - 1;
+			total++;
+		}
+		return total;
+	}
+};
+//#endregion
+export { BitSet as t };

package/dist/bitset-QYGqxnEf.cjs

@@ -0,0 +1,37 @@
+//#region src/core/bitset.ts
+var BitSetRangeError = class extends RangeError {
+	name = "BitSetRangeError";
+};
+const MAX_BITS = 2 ** 32;
+var BitSet = class {
+	#bits;
+	constructor(nbits) {
+		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
+		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
+	}
+	set(i) {
+		const idx = i >>> 3;
+		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
+	}
+	get(i) {
+		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
+	}
+	get bytes() {
+		return this.#bits;
+	}
+	count() {
+		let total = 0;
+		for (let byte of this.#bits) while (byte) {
+			byte &= byte - 1;
+			total++;
+		}
+		return total;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "BitSet", {
+	enumerable: true,
+	get: function() {
+		return BitSet;
+	}
+});

package/dist/blocked/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hasher = require("../hasher-D8LCBTOM.cjs");
+const require_hasher = require("../hasher-MhY7aQ8F.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
 //#region src/blocked/blocked.ts

package/dist/blocked/index.js

@@ -1,4 +1,4 @@
-import { a as hash32x2Into, c as reduce } from "../hasher-DVWXS_vJ.js";
+import { a as hash32x2Into, u as reduce } from "../hasher-3Cyn7Yg-.js";
 import { a as TruncatedError, c as assertBodyLength, d as bytesEqual, f as fromJSONEnvelope, g as writeFrame, h as toJSONEnvelope, i as SerializationError, l as assertMinBodyLength, m as readHeader, n as ChecksumError, o as UnknownHashVariantError, r as ReservedBitsError, s as UnknownVersionError, t as BadMagicError, u as assertParamsPadding } from "../serialize-CMSYFym-.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

package/dist/bloom/index.cjs

@@ -1,39 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hasher = require("../hasher-D8LCBTOM.cjs");
+const require_bitset = require("../bitset-QYGqxnEf.cjs");
+const require_hasher = require("../hasher-MhY7aQ8F.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.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";
-};
-const MAX_BITS = 2 ** 32;
-var BitSet = class {
-	#bits;
-	constructor(nbits) {
-		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
-		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
-	}
-	set(i) {
-		const idx = i >>> 3;
-		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
-	}
-	get(i) {
-		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
-	}
-	get bytes() {
-		return this.#bits;
-	}
-	count() {
-		let total = 0;
-		for (let byte of this.#bits) while (byte) {
-			byte &= byte - 1;
-			total++;
-		}
-		return total;
-	}
-};
-//#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
 const PARAMS_SIZE = 16;
@@ -94,7 +64,7 @@ var BloomFilter = class BloomFilter {
 			require_params.assertPositiveInt(n, "n");
 			require_params.assertUint32(n, "n");
 		}
-		this.#bits = new BitSet(m);
+		this.#bits = new require_bitset.BitSet(m);
 		this.#m = m;
 		this.#k = k;
 		this.#seed = seed;

package/dist/bloom/index.js

@@ -1,38 +1,8 @@
-import { s as probeInto } from "../hasher-DVWXS_vJ.js";
+import { t as BitSet } from "../bitset-Cf2jwRJX.js";
+import { c as probeInto } from "../hasher-3Cyn7Yg-.js";
 import { a as TruncatedError, c as assertBodyLength, d as bytesEqual, f as fromJSONEnvelope, g as writeFrame, h as toJSONEnvelope, i as SerializationError, l as assertMinBodyLength, m as readHeader, n as ChecksumError, o as UnknownHashVariantError, r as ReservedBitsError, s as UnknownVersionError, t as BadMagicError, u as assertParamsPadding } from "../serialize-CMSYFym-.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";
-};
-const MAX_BITS = 2 ** 32;
-var BitSet = class {
-	#bits;
-	constructor(nbits) {
-		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
-		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
-	}
-	set(i) {
-		const idx = i >>> 3;
-		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
-	}
-	get(i) {
-		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
-	}
-	get bytes() {
-		return this.#bits;
-	}
-	count() {
-		let total = 0;
-		for (let byte of this.#bits) while (byte) {
-			byte &= byte - 1;
-			total++;
-		}
-		return total;
-	}
-};
-//#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
 const PARAMS_SIZE = 16;

package/dist/cuckoo/index.cjs

@@ -0,0 +1,278 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hasher = require("../hasher-MhY7aQ8F.cjs");
+const require_serialize = require("../serialize-CHikZ4GH.cjs");
+const require_params = require("../params-UTZbJ22c.cjs");
+function cuckooSizing(n, epsilon) {
+	require_params.assertProbability(epsilon, "epsilon");
+	const f = Math.max(4, Math.ceil(Math.log2(8 / epsilon)));
+	if (f > 32) throw new require_params.ParamError(`epsilon ${String(epsilon)} needs a ${String(f)}-bit fingerprint, above the maximum ${String(32)} bits`);
+	const buckets = Math.ceil(n / 3.8) + Math.ceil(Math.sqrt(n));
+	return {
+		f,
+		buckets,
+		bitsPerKey: 4 * f * buckets / n
+	};
+}
+//#endregion
+//#region src/cuckoo/cuckoo.ts
+const TYPE = 7;
+const PARAMS_SIZE = 32;
+const PARAMS_FIELDS_END = 28;
+const padded8 = (length) => Math.ceil(length / 8) * 8;
+const wordBytes = (words) => new Uint8Array(words.buffer, words.byteOffset, words.byteLength);
+const SLOTS = 4;
+const MAX_KICKS = 500;
+const UNDO_SLOT = new Float64Array(MAX_KICKS);
+const UNDO_FP = new Uint32Array(MAX_KICKS);
+const HASH = {
+	w0: 0,
+	w1: 0,
+	w2: 0,
+	w3: 0
+};
+let restoring;
+var CuckooFullError = class extends Error {
+	name = "CuckooFullError";
+};
+var CuckooFilter = class CuckooFilter {
+	#n;
+	#epsilon;
+	#seed;
+	#f;
+	#buckets;
+	#mask;
+	#words;
+	#count = 0;
+	#fp = 0;
+	#i1 = 0;
+	#i2 = 0;
+	static create(n, epsilon, options = {}) {
+		return new CuckooFilter({
+			...options,
+			n,
+			epsilon
+		});
+	}
+	static from(keys, epsilon, options = {}) {
+		const seen = new Set();
+		const distinct = [];
+		for (const key of keys) {
+			require_hasher.hash128KeyInto(key, options.seed ?? 0, HASH);
+			const id = `${String(HASH.w0)},${String(HASH.w1)},${String(HASH.w2)},${String(HASH.w3)}`;
+			if (seen.has(id)) continue;
+			seen.add(id);
+			distinct.push(key);
+		}
+		const f = CuckooFilter.create(Math.max(1, distinct.length), epsilon, options);
+		for (const k of distinct) f.add(k);
+		return f;
+	}
+	static fromBytes(bytes) {
+		const { type, flags, body } = require_serialize.readHeader(bytes);
+		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, PARAMS_SIZE, "cuckoo");
+		require_serialize.assertParamsPadding(body, PARAMS_FIELDS_END, PARAMS_SIZE, "cuckoo");
+		const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const params = {
+			n: view.getUint32(0, true),
+			seed: view.getUint32(4, true),
+			epsilon: view.getFloat64(8, true)
+		};
+		let filter;
+		try {
+			const f = view.getUint32(16, true);
+			const buckets = view.getUint32(20, true);
+			if (f < 4 || f > 32) throw new require_serialize.SerializationError(`cuckoo: stored f ${String(f)} is outside 4..${String(32)}`);
+			if (buckets < 1) throw new require_serialize.SerializationError("cuckoo: stored buckets is 0");
+			const m = f * SLOTS * buckets;
+			if (m > 4294967295) throw new require_serialize.SerializationError(`cuckoo: stored geometry gives m ${String(m)} bits, more than 2^32 - 1`);
+			const words = Math.ceil(m / 32);
+			require_serialize.assertBodyLength(body.length, PARAMS_SIZE + padded8(4 * words), "cuckoo");
+			restoring = {
+				f,
+				buckets
+			};
+			try {
+				filter = new CuckooFilter(params);
+			} finally {
+				restoring = void 0;
+			}
+		} catch (err) {
+			if (err instanceof require_params.ParamError) throw new require_serialize.SerializationError(`cuckoo: ${err.message}`);
+			throw err;
+		}
+		const words = filter.#words;
+		for (let w = 0; w < words.length; w++) words[w] = view.getUint32(PARAMS_SIZE + 4 * w, true);
+		const tail = filter.m % 32;
+		if (tail !== 0 && (words[words.length - 1] ?? 0) >>> tail !== 0) throw new require_serialize.SerializationError("cuckoo: bits set past the last slot");
+		if (body.subarray(PARAMS_SIZE + 4 * words.length).some((b) => b !== 0)) throw new require_serialize.SerializationError("cuckoo: slot padding is not zero");
+		const count = view.getUint32(24, true);
+		let occupied = 0;
+		for (let j = 0; j < filter.capacity; j++) if (filter.#slot(j) !== 0) occupied++;
+		if (count !== occupied) throw new require_serialize.SerializationError(`cuckoo: count ${String(count)} does not match ${String(occupied)} occupied slots`);
+		filter.#count = count;
+		return filter;
+	}
+	static fromJSON(value) {
+		return CuckooFilter.fromBytes(require_serialize.fromJSONEnvelope(value));
+	}
+	constructor({ n, epsilon, seed = 0 }) {
+		require_params.assertPositiveInt(n, "n");
+		require_params.assertUint32(n, "n");
+		require_params.assertProbability(epsilon, "epsilon");
+		require_params.assertUint32(seed, "seed");
+		const { f, buckets } = restoring ?? cuckooSizing(n, epsilon);
+		require_params.assertUint32(f * SLOTS * buckets, "m");
+		this.#n = n;
+		this.#epsilon = epsilon;
+		this.#seed = seed;
+		this.#f = f;
+		this.#buckets = buckets;
+		this.#mask = 2 ** f - 1;
+		this.#words = new Uint32Array(Math.ceil(f * SLOTS * buckets / 32));
+	}
+	add(key) {
+		this.#hash(key);
+		if (this.#replace(this.#i1, 0, this.#fp) || this.#replace(this.#i2, 0, this.#fp)) {
+			this.#count++;
+			return;
+		}
+		let i = (HASH.w2 & 1) === 0 ? this.#i1 : this.#i2;
+		let x = (HASH.w3 | 1) >>> 0;
+		let fp = this.#fp;
+		for (let kick = 0; kick < MAX_KICKS; kick++) {
+			x ^= x << 13;
+			x >>>= 0;
+			x ^= x >>> 17;
+			x ^= x << 5;
+			x >>>= 0;
+			const j = i * SLOTS + (x & 3);
+			const victim = this.#slot(j);
+			UNDO_SLOT[kick] = j;
+			UNDO_FP[kick] = victim;
+			this.#setSlot(j, fp);
+			fp = victim;
+			i = this.#alt(i, fp);
+			if (this.#replace(i, 0, fp)) {
+				this.#count++;
+				return;
+			}
+		}
+		for (let kick = 499; kick >= 0; kick--) this.#setSlot(UNDO_SLOT[kick] ?? 0, UNDO_FP[kick] ?? 0);
+		throw new CuckooFullError(`cuckoo filter is full at ${String(this.#count)} of ${String(this.capacity)} slots`);
+	}
+	delete(key) {
+		this.#hash(key);
+		const removed = this.#replace(this.#i1, this.#fp, 0) || this.#i2 !== this.#i1 && this.#replace(this.#i2, this.#fp, 0);
+		if (removed) this.#count--;
+		return removed;
+	}
+	has(key) {
+		this.#hash(key);
+		return this.#find(this.#i1, this.#fp) >= 0 || this.#find(this.#i2, this.#fp) >= 0;
+	}
+	rate() {
+		const occupied = 8 * this.#count / this.capacity;
+		return 1 - (1 - 1 / this.#mask) ** occupied;
+	}
+	toBytes() {
+		const words = this.#words;
+		return require_serialize.writeFrame({
+			version: 5,
+			type: TYPE,
+			flags: 0
+		}, PARAMS_SIZE, padded8(4 * words.length), (_, view) => {
+			view.setUint32(0, this.#n, true);
+			view.setUint32(4, this.#seed, true);
+			view.setFloat64(8, this.#epsilon, true);
+			view.setUint32(16, this.#f, true);
+			view.setUint32(20, this.#buckets, true);
+			view.setUint32(24, this.#count, true);
+			words.forEach((word, w) => {
+				view.setUint32(PARAMS_SIZE + 4 * w, word, true);
+			});
+		});
+	}
+	equals(other) {
+		return this.#n === other.#n && this.#epsilon === other.#epsilon && this.#seed === other.#seed && this.#count === other.#count && require_serialize.bytesEqual(wordBytes(this.#words), wordBytes(other.#words));
+	}
+	toJSON() {
+		return require_serialize.toJSONEnvelope(this.toBytes());
+	}
+	#hash(key) {
+		require_hasher.hash128KeyInto(key, this.#seed, HASH);
+		this.#fp = HASH.w1 >>> 32 - this.#f || 1;
+		this.#i1 = require_hasher.reduce(HASH.w0, this.#buckets);
+		this.#i2 = this.#alt(this.#i1, this.#fp);
+	}
+	#alt(i, fp) {
+		const b = this.#buckets;
+		return ((Math.imul(fp, 1540483477) >>> 0) % b + b - i) % b;
+	}
+	#find(bucket, value) {
+		for (let j = bucket * SLOTS; j < bucket * SLOTS + SLOTS; j++) if (this.#slot(j) === value) return j;
+		return -1;
+	}
+	#replace(bucket, from, to) {
+		const j = this.#find(bucket, from);
+		if (j < 0) return false;
+		this.#setSlot(j, to);
+		return true;
+	}
+	#slot(j) {
+		const bit = j * this.#f;
+		const w = bit >>> 5;
+		const off = bit & 31;
+		let v = (this.#words[w] ?? 0) >>> off;
+		if (off + this.#f > 32) v |= (this.#words[w + 1] ?? 0) << 32 - off;
+		return (v & this.#mask) >>> 0;
+	}
+	#setSlot(j, fp) {
+		const bit = j * this.#f;
+		const w = bit >>> 5;
+		const off = bit & 31;
+		const words = this.#words;
+		words[w] = (words[w] ?? 0) & ~(this.#mask << off) | fp << off;
+		if (off + this.#f > 32) {
+			const shift = 32 - off;
+			words[w + 1] = (words[w + 1] ?? 0) & ~(this.#mask >>> shift) | fp >>> shift;
+		}
+	}
+	get count() {
+		return this.#count;
+	}
+	get capacity() {
+		return SLOTS * this.#buckets;
+	}
+	get buckets() {
+		return this.#buckets;
+	}
+	get fingerprintBits() {
+		return this.#f;
+	}
+	get m() {
+		return this.#f * this.capacity;
+	}
+	get bitsPerKey() {
+		return this.m / this.#n;
+	}
+	get seed() {
+		return this.#seed;
+	}
+	get epsilon() {
+		return this.#epsilon;
+	}
+};
+//#endregion
+exports.BadMagicError = require_serialize.BadMagicError;
+exports.ChecksumError = require_serialize.ChecksumError;
+exports.CuckooFilter = CuckooFilter;
+exports.CuckooFullError = CuckooFullError;
+exports.ParamError = require_params.ParamError;
+exports.ReservedBitsError = require_serialize.ReservedBitsError;
+exports.SerializationError = require_serialize.SerializationError;
+exports.TruncatedError = require_serialize.TruncatedError;
+exports.UnknownHashVariantError = require_serialize.UnknownHashVariantError;
+exports.UnknownVersionError = require_serialize.UnknownVersionError;
+exports.cuckooSizing = cuckooSizing;