distillate 0.1.1 → 0.1.2

package/README.md

@@ -92,6 +92,19 @@ const precise = BinaryFuse16.from(["alice", "bob", "carol"]);
 
 Also: `toBytes` / `fromBytes`. No `add` / `delete`; rebuild `from` the new set to change membership.
 
+## Performance
+
+Classic Bloom head-to-head at a **matched 1% false-positive rate** over the same 100k keys, measured by identical code (Node, Apple M5):
+
+| Classic Bloom  | bits/key | measured FPR | `has` throughput |
+| -------------- | -------- | ------------ | ---------------- |
+| **distillate** | 9.59     | 1.03%        | ~7.0 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.
+
+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).
+
 ## Docs
 
 Design notes, the structure decision matrix, hashing, and the binary format live in [`docs/`](./docs):
@@ -99,6 +112,8 @@ Design notes, the structure decision matrix, hashing, and the binary format live
 - [overview](./docs/overview.md): what and why
 - [structures](./docs/structures.md): decision matrix and the full lineup
 - [architecture](./docs/architecture.md), [hashing](./docs/hashing.md), [serialization](./docs/serialization.md)
+- [versioning](./docs/versioning.md): SemVer policy and supported-runtime baseline
+- [API reference](./docs/api): generated from TSDoc (per entry point)
 
 ## License
 

package/dist/blocked/index.cjs

@@ -9,15 +9,22 @@ const scratchHash = {
 	h2lo: 0,
 	h2hi: 0
 };
-/**
-* Split-block probe: derive one block index and 8 single-bit lane masks for
-* `key`. Writes lane word indices into `outWords` and their masks into
-* `outBits` (both length 8, caller-owned so no per-call allocation). A block is
-* 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
-*/
+/** Thrown when an operation requires two filters built with identical parameters. */
 var BlockedBloomParamMismatchError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BlockedBloomParamMismatchError";
 };
+/**
+* A blocked (split-block) Bloom filter: confines every lookup to a single cache
+* line, trading ~20-30% more space for cache-friendly throughput.
+*
+* @example
+* ```ts
+* const filter = BlockedBloomFilter.create(100_000, 0.01);
+* filter.add("alice");
+* filter.has("alice"); // true
+* ```
+*/
 var BlockedBloomFilter = class BlockedBloomFilter {
 	#lanes;
 	#numBlocks;
@@ -30,6 +37,13 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		[3, 16.9],
 		[4, 26.4]
 	];
+	/**
+	* Creates a filter sized for `n` expected keys at a target false-positive rate.
+	*
+	* @param n - Expected number of keys.
+	* @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+	* @returns A new, empty filter.
+	*/
 	static create(n, epsilon) {
 		const t = Math.log10(1 / epsilon);
 		const a = BlockedBloomFilter.#ANCHORS;
@@ -43,15 +57,26 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			capacity: n
 		});
 	}
+	/**
+	* Constructs a filter from low-level {@link BlockedBloomParams}. Prefer
+	* {@link BlockedBloomFilter.create} unless restoring a specific configuration.
+	*/
 	constructor({ bitsPerKey, capacity, seed = 0 }) {
 		this.#numBlocks = Math.max(1, Math.ceil(bitsPerKey * capacity / 256));
 		this.#lanes = new Uint32Array(this.#numBlocks * 8);
 		this.#seed = seed;
 		this.#n = capacity;
 	}
+	/** Actual bits allocated per key (`total bits / capacity`). */
 	get bitsPerKey() {
 		return this.#numBlocks * 256 / this.#n;
 	}
+	/**
+	* Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		const { body } = require_serialize.readHeader(bytes);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -67,6 +92,11 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		new Uint8Array(f.#lanes.buffer).set(body.subarray(12));
 		return f;
 	}
+	/**
+	* Serializes the filter to a portable little-endian byte layout.
+	*
+	* @returns The serialized filter, readable by {@link BlockedBloomFilter.fromBytes}.
+	*/
 	toBytes() {
 		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
 		const body = new Uint8Array(12 + lanes.length);
@@ -81,6 +111,13 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Returns a new filter containing the union of this filter and `other`.
+	*
+	* @param other - A filter built with identical parameters.
+	* @returns A new filter reporting membership for keys in either input.
+	* @throws {@link BlockedBloomParamMismatchError} if the parameters differ.
+	*/
 	union(other) {
 		if (this.#numBlocks !== other.#numBlocks || this.#seed !== other.#seed) throw new BlockedBloomParamMismatchError("cannot union blocked Bloom filters whose parameters do not match");
 		const r = new BlockedBloomFilter({
@@ -91,6 +128,11 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		for (let i = 0; i < this.#lanes.length; i++) r.#lanes[i] = (this.#lanes[i] ?? 0) | (other.#lanes[i] ?? 0);
 		return r;
 	}
+	/**
+	* Adds a key to the set.
+	*
+	* @param key - The key to insert, as a string or bytes.
+	*/
 	add(key) {
 		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
 		for (let i = 0; i < 8; i++) {
@@ -98,6 +140,12 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			this.#lanes[w] = (this.#lanes[w] ?? 0) | (this.#bits[i] ?? 0);
 		}
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
 		for (let i = 0; i < 8; i++) {

package/dist/blocked/index.d.cts

@@ -1,28 +1,80 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
 //#region src/blocked/blocked.d.ts
-/**
- * Split-block probe: derive one block index and 8 single-bit lane masks for
- * `key`. Writes lane word indices into `outWords` and their masks into
- * `outBits` (both length 8, caller-owned so no per-call allocation). A block is
- * 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
- */
+/** Thrown when an operation requires two filters built with identical parameters. */
 declare class BlockedBloomParamMismatchError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BlockedBloomParamMismatchError";
 }
+/** Low-level blocked Bloom filter parameters. */
 interface BlockedBloomParams {
+  /** Bits allocated per key; higher lowers the false-positive rate. */
   bitsPerKey: number;
+  /** Expected number of keys. */
   capacity: number;
+  /** Hash seed; defaults to `0`. */
   seed?: number;
 }
+/**
+ * A blocked (split-block) Bloom filter: confines every lookup to a single cache
+ * line, trading ~20-30% more space for cache-friendly throughput.
+ *
+ * @example
+ * ```ts
+ * const filter = BlockedBloomFilter.create(100_000, 0.01);
+ * filter.add("alice");
+ * filter.has("alice"); // true
+ * ```
+ */
 declare class BlockedBloomFilter {
   #private;
+  /**
+   * Creates a filter sized for `n` expected keys at a target false-positive rate.
+   *
+   * @param n - Expected number of keys.
+   * @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+   * @returns A new, empty filter.
+   */
   static create(n: number, epsilon: number): BlockedBloomFilter;
+  /**
+   * Constructs a filter from low-level {@link BlockedBloomParams}. Prefer
+   * {@link BlockedBloomFilter.create} unless restoring a specific configuration.
+   */
   constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
+  /** Actual bits allocated per key (`total bits / capacity`). */
   get bitsPerKey(): number;
+  /**
+   * Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BlockedBloomFilter;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by {@link BlockedBloomFilter.fromBytes}.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Returns a new filter containing the union of this filter and `other`.
+   *
+   * @param other - A filter built with identical parameters.
+   * @returns A new filter reporting membership for keys in either input.
+   * @throws {@link BlockedBloomParamMismatchError} if the parameters differ.
+   */
   union(other: BlockedBloomFilter): BlockedBloomFilter;
+  /**
+   * Adds a key to the set.
+   *
+   * @param key - The key to insert, as a string or bytes.
+   */
   add(key: BytesLike): void;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
 //#endregion

package/dist/blocked/index.d.ts

@@ -1,28 +1,80 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.js";
 //#region src/blocked/blocked.d.ts
-/**
- * Split-block probe: derive one block index and 8 single-bit lane masks for
- * `key`. Writes lane word indices into `outWords` and their masks into
- * `outBits` (both length 8, caller-owned so no per-call allocation). A block is
- * 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
- */
+/** Thrown when an operation requires two filters built with identical parameters. */
 declare class BlockedBloomParamMismatchError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BlockedBloomParamMismatchError";
 }
+/** Low-level blocked Bloom filter parameters. */
 interface BlockedBloomParams {
+  /** Bits allocated per key; higher lowers the false-positive rate. */
   bitsPerKey: number;
+  /** Expected number of keys. */
   capacity: number;
+  /** Hash seed; defaults to `0`. */
   seed?: number;
 }
+/**
+ * A blocked (split-block) Bloom filter: confines every lookup to a single cache
+ * line, trading ~20-30% more space for cache-friendly throughput.
+ *
+ * @example
+ * ```ts
+ * const filter = BlockedBloomFilter.create(100_000, 0.01);
+ * filter.add("alice");
+ * filter.has("alice"); // true
+ * ```
+ */
 declare class BlockedBloomFilter {
   #private;
+  /**
+   * Creates a filter sized for `n` expected keys at a target false-positive rate.
+   *
+   * @param n - Expected number of keys.
+   * @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+   * @returns A new, empty filter.
+   */
   static create(n: number, epsilon: number): BlockedBloomFilter;
+  /**
+   * Constructs a filter from low-level {@link BlockedBloomParams}. Prefer
+   * {@link BlockedBloomFilter.create} unless restoring a specific configuration.
+   */
   constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
+  /** Actual bits allocated per key (`total bits / capacity`). */
   get bitsPerKey(): number;
+  /**
+   * Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BlockedBloomFilter;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by {@link BlockedBloomFilter.fromBytes}.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Returns a new filter containing the union of this filter and `other`.
+   *
+   * @param other - A filter built with identical parameters.
+   * @returns A new filter reporting membership for keys in either input.
+   * @throws {@link BlockedBloomParamMismatchError} if the parameters differ.
+   */
   union(other: BlockedBloomFilter): BlockedBloomFilter;
+  /**
+   * Adds a key to the set.
+   *
+   * @param key - The key to insert, as a string or bytes.
+   */
   add(key: BytesLike): void;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
 //#endregion

package/dist/blocked/index.js

@@ -8,15 +8,22 @@ const scratchHash = {
 	h2lo: 0,
 	h2hi: 0
 };
-/**
-* Split-block probe: derive one block index and 8 single-bit lane masks for
-* `key`. Writes lane word indices into `outWords` and their masks into
-* `outBits` (both length 8, caller-owned so no per-call allocation). A block is
-* 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
-*/
+/** Thrown when an operation requires two filters built with identical parameters. */
 var BlockedBloomParamMismatchError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BlockedBloomParamMismatchError";
 };
+/**
+* A blocked (split-block) Bloom filter: confines every lookup to a single cache
+* line, trading ~20-30% more space for cache-friendly throughput.
+*
+* @example
+* ```ts
+* const filter = BlockedBloomFilter.create(100_000, 0.01);
+* filter.add("alice");
+* filter.has("alice"); // true
+* ```
+*/
 var BlockedBloomFilter = class BlockedBloomFilter {
 	#lanes;
 	#numBlocks;
@@ -29,6 +36,13 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		[3, 16.9],
 		[4, 26.4]
 	];
+	/**
+	* Creates a filter sized for `n` expected keys at a target false-positive rate.
+	*
+	* @param n - Expected number of keys.
+	* @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+	* @returns A new, empty filter.
+	*/
 	static create(n, epsilon) {
 		const t = Math.log10(1 / epsilon);
 		const a = BlockedBloomFilter.#ANCHORS;
@@ -42,15 +56,26 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			capacity: n
 		});
 	}
+	/**
+	* Constructs a filter from low-level {@link BlockedBloomParams}. Prefer
+	* {@link BlockedBloomFilter.create} unless restoring a specific configuration.
+	*/
 	constructor({ bitsPerKey, capacity, seed = 0 }) {
 		this.#numBlocks = Math.max(1, Math.ceil(bitsPerKey * capacity / 256));
 		this.#lanes = new Uint32Array(this.#numBlocks * 8);
 		this.#seed = seed;
 		this.#n = capacity;
 	}
+	/** Actual bits allocated per key (`total bits / capacity`). */
 	get bitsPerKey() {
 		return this.#numBlocks * 256 / this.#n;
 	}
+	/**
+	* Restores a filter from its {@link BlockedBloomFilter.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		const { body } = readHeader(bytes);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -66,6 +91,11 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		new Uint8Array(f.#lanes.buffer).set(body.subarray(12));
 		return f;
 	}
+	/**
+	* Serializes the filter to a portable little-endian byte layout.
+	*
+	* @returns The serialized filter, readable by {@link BlockedBloomFilter.fromBytes}.
+	*/
 	toBytes() {
 		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
 		const body = new Uint8Array(12 + lanes.length);
@@ -80,6 +110,13 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Returns a new filter containing the union of this filter and `other`.
+	*
+	* @param other - A filter built with identical parameters.
+	* @returns A new filter reporting membership for keys in either input.
+	* @throws {@link BlockedBloomParamMismatchError} if the parameters differ.
+	*/
 	union(other) {
 		if (this.#numBlocks !== other.#numBlocks || this.#seed !== other.#seed) throw new BlockedBloomParamMismatchError("cannot union blocked Bloom filters whose parameters do not match");
 		const r = new BlockedBloomFilter({
@@ -90,6 +127,11 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 		for (let i = 0; i < this.#lanes.length; i++) r.#lanes[i] = (this.#lanes[i] ?? 0) | (other.#lanes[i] ?? 0);
 		return r;
 	}
+	/**
+	* Adds a key to the set.
+	*
+	* @param key - The key to insert, as a string or bytes.
+	*/
 	add(key) {
 		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
 		for (let i = 0; i < 8; i++) {
@@ -97,6 +139,12 @@ var BlockedBloomFilter = class BlockedBloomFilter {
 			this.#lanes[w] = (this.#lanes[w] ?? 0) | (this.#bits[i] ?? 0);
 		}
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
 		for (let i = 0; i < 8; i++) {

package/dist/bloom/index.cjs

@@ -48,9 +48,23 @@ function optimal(n, epsilon) {
 //#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
+/** Thrown when an operation requires two filters built with identical parameters. */
 var BloomParamMismatchError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BloomParamMismatchError";
 };
+/**
+* A classic Bloom filter: a space-efficient set with a tunable false-positive
+* rate and zero false negatives.
+*
+* @example
+* ```ts
+* const filter = BloomFilter.create(100_000, 0.01);
+* filter.add("alice");
+* filter.has("alice"); // true
+* filter.has("bob"); // false (or a ~1% false positive)
+* ```
+*/
 var BloomFilter = class BloomFilter {
 	#bits;
 	#m;
@@ -58,11 +72,24 @@ var BloomFilter = class BloomFilter {
 	#seed;
 	#scratch;
 	#n;
+	/**
+	* Creates a filter sized for `n` expected keys at a target false-positive rate.
+	*
+	* @param n - Expected number of keys.
+	* @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+	* @returns A new, empty filter.
+	*/
 	static create(n, epsilon) {
 		const f = new BloomFilter(optimal(n, epsilon));
 		f.#n = n;
 		return f;
 	}
+	/**
+	* Restores a filter from its {@link BloomFilter.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		const { body } = require_serialize.readHeader(bytes);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -77,6 +104,10 @@ var BloomFilter = class BloomFilter {
 		f.#bits.bytes.set(body.subarray(9));
 		return f;
 	}
+	/**
+	* Constructs a filter from low-level {@link BloomParams}. Prefer
+	* {@link BloomFilter.create} unless restoring a specific configuration.
+	*/
 	constructor({ m, k, seed = 0 }) {
 		this.#bits = new BitSet(m);
 		this.#m = m;
@@ -89,6 +120,11 @@ var BloomFilter = class BloomFilter {
 	get bitsPerKey() {
 		return this.#m / this.#n;
 	}
+	/**
+	* 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);
@@ -103,6 +139,13 @@ var BloomFilter = class BloomFilter {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Returns a new filter containing the union of this filter and `other`.
+	*
+	* @param other - A filter built with identical parameters.
+	* @returns A new filter reporting membership for keys in either input.
+	* @throws {@link BloomParamMismatchError} if the parameters differ.
+	*/
 	union(other) {
 		if (this.#m !== other.#m || this.#k !== other.#k || this.#seed !== other.#seed) throw new BloomParamMismatchError("cannot union Bloom filters whose parameters do not match");
 		const a = this.#bits.bytes;
@@ -117,10 +160,21 @@ var BloomFilter = class BloomFilter {
 		r.#bits.bytes.set(merged);
 		return r;
 	}
+	/**
+	* Adds a key to the set.
+	*
+	* @param key - The key to insert, as a string or bytes.
+	*/
 	add(key) {
 		require_serialize.probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
 		for (let i = 0; i < this.#k; i++) this.#bits.set(this.#scratch[i] ?? 0);
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		require_serialize.probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
 		for (let i = 0; i < this.#k; i++) if (!this.#bits.get(this.#scratch[i] ?? 0)) return false;

package/dist/bloom/index.d.cts

@@ -1,23 +1,81 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
 //#region src/bloom/bloom.d.ts
+/** Thrown when an operation requires two filters built with identical parameters. */
 declare class BloomParamMismatchError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BloomParamMismatchError";
 }
+/** Low-level Bloom filter parameters. */
 interface BloomParams {
+  /** Number of bits in the filter. */
   m: number;
+  /** Number of hash probes per key. */
   k: number;
+  /** Hash seed; defaults to `0`. */
   seed?: number;
 }
+/**
+ * A classic Bloom filter: a space-efficient set with a tunable false-positive
+ * rate and zero false negatives.
+ *
+ * @example
+ * ```ts
+ * const filter = BloomFilter.create(100_000, 0.01);
+ * filter.add("alice");
+ * filter.has("alice"); // true
+ * filter.has("bob"); // false (or a ~1% false positive)
+ * ```
+ */
 declare class BloomFilter {
   #private;
+  /**
+   * Creates a filter sized for `n` expected keys at a target false-positive rate.
+   *
+   * @param n - Expected number of keys.
+   * @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+   * @returns A new, empty filter.
+   */
   static create(n: number, epsilon: number): BloomFilter;
+  /**
+   * Restores a filter from its {@link BloomFilter.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BloomFilter;
+  /**
+   * Constructs a filter from low-level {@link BloomParams}. Prefer
+   * {@link BloomFilter.create} unless restoring a specific configuration.
+   */
   constructor({ m, k, seed }: BloomParams);
   /** Analytic design bits-per-key `m / n`. */
   get bitsPerKey(): number;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by {@link BloomFilter.fromBytes}.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Returns a new filter containing the union of this filter and `other`.
+   *
+   * @param other - A filter built with identical parameters.
+   * @returns A new filter reporting membership for keys in either input.
+   * @throws {@link BloomParamMismatchError} if the parameters differ.
+   */
   union(other: BloomFilter): BloomFilter;
+  /**
+   * Adds a key to the set.
+   *
+   * @param key - The key to insert, as a string or bytes.
+   */
   add(key: BytesLike): void;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
 //#endregion

package/dist/bloom/index.d.ts

@@ -1,23 +1,81 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.js";
 //#region src/bloom/bloom.d.ts
+/** Thrown when an operation requires two filters built with identical parameters. */
 declare class BloomParamMismatchError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BloomParamMismatchError";
 }
+/** Low-level Bloom filter parameters. */
 interface BloomParams {
+  /** Number of bits in the filter. */
   m: number;
+  /** Number of hash probes per key. */
   k: number;
+  /** Hash seed; defaults to `0`. */
   seed?: number;
 }
+/**
+ * A classic Bloom filter: a space-efficient set with a tunable false-positive
+ * rate and zero false negatives.
+ *
+ * @example
+ * ```ts
+ * const filter = BloomFilter.create(100_000, 0.01);
+ * filter.add("alice");
+ * filter.has("alice"); // true
+ * filter.has("bob"); // false (or a ~1% false positive)
+ * ```
+ */
 declare class BloomFilter {
   #private;
+  /**
+   * Creates a filter sized for `n` expected keys at a target false-positive rate.
+   *
+   * @param n - Expected number of keys.
+   * @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+   * @returns A new, empty filter.
+   */
   static create(n: number, epsilon: number): BloomFilter;
+  /**
+   * Restores a filter from its {@link BloomFilter.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BloomFilter;
+  /**
+   * Constructs a filter from low-level {@link BloomParams}. Prefer
+   * {@link BloomFilter.create} unless restoring a specific configuration.
+   */
   constructor({ m, k, seed }: BloomParams);
   /** Analytic design bits-per-key `m / n`. */
   get bitsPerKey(): number;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by {@link BloomFilter.fromBytes}.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Returns a new filter containing the union of this filter and `other`.
+   *
+   * @param other - A filter built with identical parameters.
+   * @returns A new filter reporting membership for keys in either input.
+   * @throws {@link BloomParamMismatchError} if the parameters differ.
+   */
   union(other: BloomFilter): BloomFilter;
+  /**
+   * Adds a key to the set.
+   *
+   * @param key - The key to insert, as a string or bytes.
+   */
   add(key: BytesLike): void;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
 //#endregion

package/dist/bloom/index.js

@@ -47,9 +47,23 @@ function optimal(n, epsilon) {
 //#endregion
 //#region src/bloom/bloom.ts
 const TYPE = 1;
+/** Thrown when an operation requires two filters built with identical parameters. */
 var BloomParamMismatchError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BloomParamMismatchError";
 };
+/**
+* A classic Bloom filter: a space-efficient set with a tunable false-positive
+* rate and zero false negatives.
+*
+* @example
+* ```ts
+* const filter = BloomFilter.create(100_000, 0.01);
+* filter.add("alice");
+* filter.has("alice"); // true
+* filter.has("bob"); // false (or a ~1% false positive)
+* ```
+*/
 var BloomFilter = class BloomFilter {
 	#bits;
 	#m;
@@ -57,11 +71,24 @@ var BloomFilter = class BloomFilter {
 	#seed;
 	#scratch;
 	#n;
+	/**
+	* Creates a filter sized for `n` expected keys at a target false-positive rate.
+	*
+	* @param n - Expected number of keys.
+	* @param epsilon - Target false-positive rate, e.g. `0.01` for 1%.
+	* @returns A new, empty filter.
+	*/
 	static create(n, epsilon) {
 		const f = new BloomFilter(optimal(n, epsilon));
 		f.#n = n;
 		return f;
 	}
+	/**
+	* Restores a filter from its {@link BloomFilter.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		const { body } = readHeader(bytes);
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
@@ -76,6 +103,10 @@ var BloomFilter = class BloomFilter {
 		f.#bits.bytes.set(body.subarray(9));
 		return f;
 	}
+	/**
+	* Constructs a filter from low-level {@link BloomParams}. Prefer
+	* {@link BloomFilter.create} unless restoring a specific configuration.
+	*/
 	constructor({ m, k, seed = 0 }) {
 		this.#bits = new BitSet(m);
 		this.#m = m;
@@ -88,6 +119,11 @@ var BloomFilter = class BloomFilter {
 	get bitsPerKey() {
 		return this.#m / this.#n;
 	}
+	/**
+	* 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);
@@ -102,6 +138,13 @@ var BloomFilter = class BloomFilter {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Returns a new filter containing the union of this filter and `other`.
+	*
+	* @param other - A filter built with identical parameters.
+	* @returns A new filter reporting membership for keys in either input.
+	* @throws {@link BloomParamMismatchError} if the parameters differ.
+	*/
 	union(other) {
 		if (this.#m !== other.#m || this.#k !== other.#k || this.#seed !== other.#seed) throw new BloomParamMismatchError("cannot union Bloom filters whose parameters do not match");
 		const a = this.#bits.bytes;
@@ -116,10 +159,21 @@ var BloomFilter = class BloomFilter {
 		r.#bits.bytes.set(merged);
 		return r;
 	}
+	/**
+	* Adds a key to the set.
+	*
+	* @param key - The key to insert, as a string or bytes.
+	*/
 	add(key) {
 		probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
 		for (let i = 0; i < this.#k; i++) this.#bits.set(this.#scratch[i] ?? 0);
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
 		for (let i = 0; i < this.#k; i++) if (!this.#bits.get(this.#scratch[i] ?? 0)) return false;

package/dist/fuse/index.cjs

@@ -4,7 +4,9 @@ const require_serialize = require("../serialize-CHHDM4TQ.cjs");
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
 const TYPE_FUSE16 = 4;
+/** Thrown when binary fuse construction fails to converge on the key set. */
 var BinaryFuseBuildError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BinaryFuseBuildError";
 };
 let RLO = 0;
@@ -231,6 +233,10 @@ function fuseStateFromBytes(bytes, expectedType) {
 		size
 	};
 }
+/**
+* Shared behavior for the static binary fuse filters: an immutable,
+* space-efficient membership filter built once from a fixed key set.
+*/
 var BinaryFuse = class {
 	#fp;
 	#seed;
@@ -247,12 +253,19 @@ var BinaryFuse = class {
 		this.#segCountLen = state.params.segCountLen;
 		this.#size = state.size;
 	}
+	/** Number of distinct keys the filter was built from. */
 	get size() {
 		return this.#size;
 	}
+	/** Actual bits stored per key (`0` for an empty filter). */
 	get bitsPerKey() {
 		return this.#size === 0 ? 0 : this.#fp.byteLength * 8 / this.#size;
 	}
+	/**
+	* Serializes the filter to a portable little-endian byte layout.
+	*
+	* @returns The serialized filter, readable by the matching `fromBytes`.
+	*/
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
 		const body = new Uint8Array(16 + laneBytes.length);
@@ -268,6 +281,12 @@ var BinaryFuse = class {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		if (this.#fp.length === 0) return false;
 		require_serialize.hash128KeyInto(key, 0, scratchHash);
@@ -282,18 +301,65 @@ var BinaryFuse = class {
 		return ((mlo ^ mhi) & mask) === (((this.#fp[p0] ?? 0) ^ (this.#fp[p1] ?? 0) ^ (this.#fp[p2] ?? 0)) & mask);
 	}
 };
+/**
+* A static 8-bit binary fuse filter: built once from a key set, then immutable.
+* The most space-efficient option (~9 bits/key at ~0.39% false-positive rate).
+*
+* @example
+* ```ts
+* const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
+* filter.has("alice"); // true
+* filter.size; // 3
+* ```
+*/
 var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
+	/**
+	* Builds a filter from the given keys; duplicates are ignored.
+	*
+	* @param keys - The complete set of keys to store.
+	* @returns A new immutable filter.
+	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
+	*/
 	static from(keys) {
 		return new BinaryFuse8(buildState(keys, (n) => new Uint8Array(n)));
 	}
+	/**
+	* Restores a filter from its {@link BinaryFuse8.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse8(fuseStateFromBytes(bytes, TYPE_FUSE8));
 	}
 };
+/**
+* A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
+* space (~18 bits/key) for a far lower false-positive rate (~1/65536).
+*
+* @example
+* ```ts
+* const filter = BinaryFuse16.from(["alice", "bob", "carol"]);
+* filter.has("alice"); // true
+* ```
+*/
 var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
+	/**
+	* Builds a filter from the given keys; duplicates are ignored.
+	*
+	* @param keys - The complete set of keys to store.
+	* @returns A new immutable filter.
+	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
+	*/
 	static from(keys) {
 		return new BinaryFuse16(buildState(keys, (n) => new Uint16Array(n)));
 	}
+	/**
+	* Restores a filter from its {@link BinaryFuse16.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse16(fuseStateFromBytes(bytes, TYPE_FUSE16));
 	}

package/dist/fuse/index.d.cts

@@ -1,6 +1,8 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
 //#region src/fuse/fuse.d.ts
+/** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BinaryFuseBuildError";
 }
 interface FuseParams {
@@ -15,20 +17,84 @@ interface FuseState {
   params: FuseParams;
   size: number;
 }
+/**
+ * Shared behavior for the static binary fuse filters: an immutable,
+ * space-efficient membership filter built once from a fixed key set.
+ */
 declare abstract class BinaryFuse {
   #private;
   protected constructor(state: FuseState);
+  /** Number of distinct keys the filter was built from. */
   get size(): number;
+  /** Actual bits stored per key (`0` for an empty filter). */
   get bitsPerKey(): number;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by the matching `fromBytes`.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
+/**
+ * A static 8-bit binary fuse filter: built once from a key set, then immutable.
+ * The most space-efficient option (~9 bits/key at ~0.39% false-positive rate).
+ *
+ * @example
+ * ```ts
+ * const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
+ * filter.has("alice"); // true
+ * filter.size; // 3
+ * ```
+ */
 declare class BinaryFuse8 extends BinaryFuse {
+  /**
+   * Builds a filter from the given keys; duplicates are ignored.
+   *
+   * @param keys - The complete set of keys to store.
+   * @returns A new immutable filter.
+   * @throws {@link BinaryFuseBuildError} if construction fails to converge.
+   */
   static from(keys: Iterable<BytesLike>): BinaryFuse8;
+  /**
+   * Restores a filter from its {@link BinaryFuse8.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BinaryFuse8;
 }
+/**
+ * A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
+ * space (~18 bits/key) for a far lower false-positive rate (~1/65536).
+ *
+ * @example
+ * ```ts
+ * const filter = BinaryFuse16.from(["alice", "bob", "carol"]);
+ * filter.has("alice"); // true
+ * ```
+ */
 declare class BinaryFuse16 extends BinaryFuse {
+  /**
+   * Builds a filter from the given keys; duplicates are ignored.
+   *
+   * @param keys - The complete set of keys to store.
+   * @returns A new immutable filter.
+   * @throws {@link BinaryFuseBuildError} if construction fails to converge.
+   */
   static from(keys: Iterable<BytesLike>): BinaryFuse16;
+  /**
+   * Restores a filter from its {@link BinaryFuse16.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BinaryFuse16;
 }
 //#endregion

package/dist/fuse/index.d.ts

@@ -1,6 +1,8 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.js";
 //#region src/fuse/fuse.d.ts
+/** Thrown when binary fuse construction fails to converge on the key set. */
 declare class BinaryFuseBuildError extends Error {
+  /** Discriminates this error from other `Error`s. */
   override readonly name = "BinaryFuseBuildError";
 }
 interface FuseParams {
@@ -15,20 +17,84 @@ interface FuseState {
   params: FuseParams;
   size: number;
 }
+/**
+ * Shared behavior for the static binary fuse filters: an immutable,
+ * space-efficient membership filter built once from a fixed key set.
+ */
 declare abstract class BinaryFuse {
   #private;
   protected constructor(state: FuseState);
+  /** Number of distinct keys the filter was built from. */
   get size(): number;
+  /** Actual bits stored per key (`0` for an empty filter). */
   get bitsPerKey(): number;
+  /**
+   * Serializes the filter to a portable little-endian byte layout.
+   *
+   * @returns The serialized filter, readable by the matching `fromBytes`.
+   */
   toBytes(): Uint8Array;
+  /**
+   * Tests whether a key is in the set.
+   *
+   * @param key - The key to test.
+   * @returns `true` if present (possibly a false positive); `false` guarantees absence.
+   */
   has(key: BytesLike): boolean;
 }
+/**
+ * A static 8-bit binary fuse filter: built once from a key set, then immutable.
+ * The most space-efficient option (~9 bits/key at ~0.39% false-positive rate).
+ *
+ * @example
+ * ```ts
+ * const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
+ * filter.has("alice"); // true
+ * filter.size; // 3
+ * ```
+ */
 declare class BinaryFuse8 extends BinaryFuse {
+  /**
+   * Builds a filter from the given keys; duplicates are ignored.
+   *
+   * @param keys - The complete set of keys to store.
+   * @returns A new immutable filter.
+   * @throws {@link BinaryFuseBuildError} if construction fails to converge.
+   */
   static from(keys: Iterable<BytesLike>): BinaryFuse8;
+  /**
+   * Restores a filter from its {@link BinaryFuse8.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BinaryFuse8;
 }
+/**
+ * A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
+ * space (~18 bits/key) for a far lower false-positive rate (~1/65536).
+ *
+ * @example
+ * ```ts
+ * const filter = BinaryFuse16.from(["alice", "bob", "carol"]);
+ * filter.has("alice"); // true
+ * ```
+ */
 declare class BinaryFuse16 extends BinaryFuse {
+  /**
+   * Builds a filter from the given keys; duplicates are ignored.
+   *
+   * @param keys - The complete set of keys to store.
+   * @returns A new immutable filter.
+   * @throws {@link BinaryFuseBuildError} if construction fails to converge.
+   */
   static from(keys: Iterable<BytesLike>): BinaryFuse16;
+  /**
+   * Restores a filter from its {@link BinaryFuse16.toBytes} serialization.
+   *
+   * @param bytes - The serialized filter.
+   * @returns The reconstructed filter.
+   */
   static fromBytes(bytes: Uint8Array): BinaryFuse16;
 }
 //#endregion

package/dist/fuse/index.js

@@ -3,7 +3,9 @@ import { i as hash128KeyInto, n as readHeader, r as writeHeader, t as Serializat
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
 const TYPE_FUSE16 = 4;
+/** Thrown when binary fuse construction fails to converge on the key set. */
 var BinaryFuseBuildError = class extends Error {
+	/** Discriminates this error from other `Error`s. */
 	name = "BinaryFuseBuildError";
 };
 let RLO = 0;
@@ -230,6 +232,10 @@ function fuseStateFromBytes(bytes, expectedType) {
 		size
 	};
 }
+/**
+* Shared behavior for the static binary fuse filters: an immutable,
+* space-efficient membership filter built once from a fixed key set.
+*/
 var BinaryFuse = class {
 	#fp;
 	#seed;
@@ -246,12 +252,19 @@ var BinaryFuse = class {
 		this.#segCountLen = state.params.segCountLen;
 		this.#size = state.size;
 	}
+	/** Number of distinct keys the filter was built from. */
 	get size() {
 		return this.#size;
 	}
+	/** Actual bits stored per key (`0` for an empty filter). */
 	get bitsPerKey() {
 		return this.#size === 0 ? 0 : this.#fp.byteLength * 8 / this.#size;
 	}
+	/**
+	* Serializes the filter to a portable little-endian byte layout.
+	*
+	* @returns The serialized filter, readable by the matching `fromBytes`.
+	*/
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
 		const body = new Uint8Array(16 + laneBytes.length);
@@ -267,6 +280,12 @@ var BinaryFuse = class {
 			flags: 0
 		}, body);
 	}
+	/**
+	* Tests whether a key is in the set.
+	*
+	* @param key - The key to test.
+	* @returns `true` if present (possibly a false positive); `false` guarantees absence.
+	*/
 	has(key) {
 		if (this.#fp.length === 0) return false;
 		hash128KeyInto(key, 0, scratchHash);
@@ -281,18 +300,65 @@ var BinaryFuse = class {
 		return ((mlo ^ mhi) & mask) === (((this.#fp[p0] ?? 0) ^ (this.#fp[p1] ?? 0) ^ (this.#fp[p2] ?? 0)) & mask);
 	}
 };
+/**
+* A static 8-bit binary fuse filter: built once from a key set, then immutable.
+* The most space-efficient option (~9 bits/key at ~0.39% false-positive rate).
+*
+* @example
+* ```ts
+* const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
+* filter.has("alice"); // true
+* filter.size; // 3
+* ```
+*/
 var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
+	/**
+	* Builds a filter from the given keys; duplicates are ignored.
+	*
+	* @param keys - The complete set of keys to store.
+	* @returns A new immutable filter.
+	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
+	*/
 	static from(keys) {
 		return new BinaryFuse8(buildState(keys, (n) => new Uint8Array(n)));
 	}
+	/**
+	* Restores a filter from its {@link BinaryFuse8.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse8(fuseStateFromBytes(bytes, TYPE_FUSE8));
 	}
 };
+/**
+* A static 16-bit binary fuse filter: like {@link BinaryFuse8} but twice the
+* space (~18 bits/key) for a far lower false-positive rate (~1/65536).
+*
+* @example
+* ```ts
+* const filter = BinaryFuse16.from(["alice", "bob", "carol"]);
+* filter.has("alice"); // true
+* ```
+*/
 var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
+	/**
+	* Builds a filter from the given keys; duplicates are ignored.
+	*
+	* @param keys - The complete set of keys to store.
+	* @returns A new immutable filter.
+	* @throws {@link BinaryFuseBuildError} if construction fails to converge.
+	*/
 	static from(keys) {
 		return new BinaryFuse16(buildState(keys, (n) => new Uint16Array(n)));
 	}
+	/**
+	* Restores a filter from its {@link BinaryFuse16.toBytes} serialization.
+	*
+	* @param bytes - The serialized filter.
+	* @returns The reconstructed filter.
+	*/
 	static fromBytes(bytes) {
 		return new BinaryFuse16(fuseStateFromBytes(bytes, TYPE_FUSE16));
 	}

package/dist/index.cjs

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

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 //#region src/index.d.ts
-declare const VERSION = "0.1.0";
+/** The installed `distillate` package version. */
+declare const VERSION: string;
 //#endregion
 export { VERSION };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 //#region src/index.d.ts
-declare const VERSION = "0.1.0";
+/** The installed `distillate` package version. */
+declare const VERSION: string;
 //#endregion
 export { VERSION };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "distillate",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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",
@@ -76,9 +76,12 @@
     "@commitlint/cli": "^21.2.1",
     "@commitlint/config-conventional": "^21.2.0",
     "@eslint/js": "^10.0.1",
+    "@microsoft/api-extractor": "^7.58.12",
     "@types/node": "^26.1.2",
+    "@vitest/coverage-v8": "^4.1.10",
     "eslint": "^10.8.0",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-tsdoc": "^0.5.2",
     "fast-check": "^4.9.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.2.0",
@@ -87,6 +90,8 @@
     "publint": "^0.3.22",
     "tsdown": "^0.22.14",
     "tsx": "^4.23.1",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-markdown": "^4.12.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.65.0",
     "vitest": "^4.1.10"
@@ -100,6 +105,10 @@
     "check": "publint --strict && attw --pack . --profile node16",
     "attw": "attw --pack . --profile node16",
     "test": "vitest run",
+    "coverage": "vitest run --coverage",
+    "api:report": "node scripts/api-extractor.mjs --local",
+    "api:check": "node scripts/api-extractor.mjs",
+    "docs:api": "typedoc",
     "changeset": "changeset",
     "version": "changeset version",
     "release": "changeset publish",