distillate 0.13.0 → 0.14.1

package/dist/{hasher-MhY7aQ8F.cjs → hasher-DPXmP7SH.cjs}

@@ -1,11 +1,4 @@
-//#region src/core/bytes.ts
-const encoder = new TextEncoder();
-function normalize(input) {
-	if (typeof input === "string") return encoder.encode(input);
-	if (input instanceof Uint8Array) return input;
-	return new Uint8Array(input);
-}
-//#endregion
+const require_bytes = require("./bytes-D2duG1jq.cjs");
 //#region src/core/hasher.ts
 let RLO = 0;
 let RHI = 0;
@@ -185,7 +178,7 @@ function encodeKey(key) {
 		encBytes = keyBuf;
 		return;
 	}
-	encBytes = normalize(key);
+	encBytes = require_bytes.normalize(key);
 	encLen = encBytes.length;
 }
 function keyToLanes(key, seed) {

package/dist/hll/index.cjs

@@ -1,8 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hasher = require("../hasher-MhY7aQ8F.cjs");
+const require_hasher = require("../hasher-DPXmP7SH.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
-const require_sizing = require("../sizing-R1pwbzjC.cjs");
+function hllSizing(relativeError) {
+	require_params.assertProbability(relativeError, "relativeError");
+	const p = Math.max(4, Math.ceil(2 * Math.log2(1.04 / relativeError)));
+	if (p > 18) throw new require_params.ParamError(`relativeError ${String(relativeError)} needs precision ${String(p)}, above the maximum ${String(18)}`);
+	return { p };
+}
+//#endregion
 //#region src/hll/estimate.ts
 const ALPHA_INF = .5 / Math.LN2;
 function sigma(x) {
@@ -171,7 +177,7 @@ var HyperLogLog = class HyperLogLog {
 		this.#sparse = new Int32Array(sparseCapacity(this.#registers));
 	}
 	static create(relativeError) {
-		return new HyperLogLog(require_sizing.hllSizing(relativeError));
+		return new HyperLogLog(hllSizing(relativeError));
 	}
 	static from(keys, relativeError) {
 		const sketch = HyperLogLog.create(relativeError);
@@ -363,4 +369,4 @@ exports.SerializationError = require_serialize.SerializationError;
 exports.TruncatedError = require_serialize.TruncatedError;
 exports.UnknownHashVariantError = require_serialize.UnknownHashVariantError;
 exports.UnknownVersionError = require_serialize.UnknownVersionError;
-exports.hllSizing = require_sizing.hllSizing;
+exports.hllSizing = hllSizing;

package/dist/hll/index.d.cts

@@ -1,7 +1,6 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
 import { a as ReservedBitsError, c as UnknownHashVariantError, l as UnknownVersionError, n as ChecksumError, o as SerializationError, r as FilterJSON, s as TruncatedError, t as BadMagicError } from "../serialize--xR6vGSW.cjs";
 import { t as ParamError } from "../params-DnqJBqLS.cjs";
-import { o as hllSizing, r as HllSizing } from "../sizing-BmKfHf_V.cjs";
 //#region src/hll/hll.d.ts
 /** Construction parameters for a {@link HyperLogLog} sketch. */
 interface HllParams {
@@ -117,4 +116,16 @@ export declare class HyperLogLog {
   count(): number;
 }
 //#endregion
-export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };
+//#region src/hll/sizing.d.ts
+/** HyperLogLog geometry: the `HllParams` fields a sizing solve determines. */
+interface HllSizing {
+  /** Precision: the sketch holds `2 ** p` registers. */
+  p: number;
+}
+/**
+ * Smallest precision whose standard error `1.04 / sqrt(2 ** p)` meets
+ * `relativeError`. Throws {@link ParamError} when even `HLL_MAX_P` cannot.
+ */
+export declare function hllSizing(relativeError: number): HllSizing;
+//#endregion
+export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError };

package/dist/hll/index.d.ts

@@ -1,7 +1,6 @@
 import { t as BytesLike } from "../bytes-DCuYtUVS.js";
 import { a as ReservedBitsError, c as UnknownHashVariantError, l as UnknownVersionError, n as ChecksumError, o as SerializationError, r as FilterJSON, s as TruncatedError, t as BadMagicError } from "../serialize--xR6vGSW.js";
 import { t as ParamError } from "../params-DnqJBqLS.js";
-import { o as hllSizing, r as HllSizing } from "../sizing-BmKfHf_V.js";
 //#region src/hll/hll.d.ts
 /** Construction parameters for a {@link HyperLogLog} sketch. */
 interface HllParams {
@@ -117,4 +116,16 @@ export declare class HyperLogLog {
   count(): number;
 }
 //#endregion
-export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, hllSizing };
+//#region src/hll/sizing.d.ts
+/** HyperLogLog geometry: the `HllParams` fields a sizing solve determines. */
+interface HllSizing {
+  /** Precision: the sketch holds `2 ** p` registers. */
+  p: number;
+}
+/**
+ * Smallest precision whose standard error `1.04 / sqrt(2 ** p)` meets
+ * `relativeError`. Throws {@link ParamError} when even `HLL_MAX_P` cannot.
+ */
+export declare function hllSizing(relativeError: number): HllSizing;
+//#endregion
+export { BadMagicError, ChecksumError, type FilterJSON, type HllParams, type HllSizing, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError };

package/dist/hll/index.js

@@ -1,7 +1,13 @@
-import { i as hash128KeyInto } from "../hasher-3Cyn7Yg-.js";
+import { i as hash128KeyInto } from "../hasher-DOdmZ-LI.js";
 import { a as TruncatedError, c as assertBodyLength, 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 { o as assertUint32, t as ParamError } from "../params-CeajSrwv.js";
-import { r as hllSizing } from "../sizing-D3-_7pdP.js";
+import { i as assertProbability, o as assertUint32, t as ParamError } from "../params-CeajSrwv.js";
+function hllSizing(relativeError) {
+	assertProbability(relativeError, "relativeError");
+	const p = Math.max(4, Math.ceil(2 * Math.log2(1.04 / relativeError)));
+	if (p > 18) throw new ParamError(`relativeError ${String(relativeError)} needs precision ${String(p)}, above the maximum ${String(18)}`);
+	return { p };
+}
+//#endregion
 //#region src/hll/estimate.ts
 const ALPHA_INF = .5 / Math.LN2;
 function sigma(x) {

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#endregion
 //#region src/index.ts
-const VERSION = "0.13.0";
+const VERSION = "0.14.1";
 //#endregion
 exports.VERSION = VERSION;

package/dist/index.js

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/index.ts
-const VERSION = "0.13.0";
+const VERSION = "0.14.1";
 //#endregion
 export { VERSION };

package/dist/scalable/index.cjs

@@ -1,9 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bitset = require("../bitset-QYGqxnEf.cjs");
-const require_hasher = require("../hasher-MhY7aQ8F.cjs");
+const require_sizing = require("../sizing-Ch0SDdza.cjs");
+const require_hasher = require("../hasher-DPXmP7SH.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
-const require_sizing = require("../sizing-R1pwbzjC.cjs");
 //#region src/scalable/scalable.ts
 const MAX_BITS = 4294967295;
 const TYPE = 6;
@@ -35,7 +34,7 @@ function readStages(body, entries, start) {
 	let at = start;
 	return entries.map((entry, i) => {
 		const length = Math.ceil(entry.m / 8);
-		const bits = new require_bitset.BitSet(entry.m);
+		const bits = new require_sizing.BitSet(entry.m);
 		bits.bytes.set(body.subarray(at, at + length));
 		for (let j = at + length; j < at + padded8(length); j++) if (body[j] !== 0) throw new require_serialize.SerializationError(`scalable: stage ${String(i)} bit padding is not zero`);
 		at += padded8(length);
@@ -103,7 +102,7 @@ var ScalableBloomFilter = class ScalableBloomFilter {
 	}
 	#open({ capacity, m, k }) {
 		const stage = {
-			bits: new require_bitset.BitSet(m),
+			bits: new require_sizing.BitSet(m),
 			m,
 			k,
 			capacity,
@@ -206,7 +205,7 @@ var ScalableBloomFilter = class ScalableBloomFilter {
 		this.#assertMergeable(other);
 		const [longer, shorter] = this.#stages.length >= other.#stages.length ? [this.#stages, other.#stages] : [other.#stages, this.#stages];
 		const stages = longer.map((stage, i) => {
-			const bits = new require_bitset.BitSet(stage.m);
+			const bits = new require_sizing.BitSet(stage.m);
 			bits.bytes.set(stage.bits.bytes);
 			const twin = shorter[i];
 			if (twin) {

package/dist/scalable/index.js

@@ -1,8 +1,7 @@
-import { t as BitSet } from "../bitset-Cf2jwRJX.js";
-import { i as hash128KeyInto, l as probeLanesInto, s as probeAt } from "../hasher-3Cyn7Yg-.js";
+import { n as BitSet, t as bloomSizing } from "../sizing-zxCBlyhO.js";
+import { i as hash128KeyInto, l as probeLanesInto, s as probeAt } from "../hasher-DOdmZ-LI.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, o as assertUint32, r as assertPositiveInt, t as ParamError } from "../params-CeajSrwv.js";
-import { t as bloomSizing } from "../sizing-D3-_7pdP.js";
 //#region src/scalable/scalable.ts
 const MAX_BITS = 4294967295;
 const TYPE = 6;

package/dist/{bitset-QYGqxnEf.cjs → sizing-Ch0SDdza.cjs}

@@ -29,9 +29,24 @@ 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
 Object.defineProperty(exports, "BitSet", {
 	enumerable: true,
 	get: function() {
 		return BitSet;
 	}
 });
+Object.defineProperty(exports, "bloomSizing", {
+	enumerable: true,
+	get: function() {
+		return bloomSizing;
+	}
+});

package/dist/{bitset-Cf2jwRJX.js → sizing-zxCBlyhO.js}

@@ -29,4 +29,13 @@ var BitSet = class {
 	}
 };
 //#endregion
-export { BitSet as t };
+//#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
+export { BitSet as n, bloomSizing as t };

package/dist/topk/index.cjs

@@ -0,0 +1,423 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes = require("../bytes-D2duG1jq.cjs");
+const require_serialize = require("../serialize-CHikZ4GH.cjs");
+const require_params = require("../params-UTZbJ22c.cjs");
+//#region src/topk/halfsip.ts
+function halfSipHash13(bytes, k0, k1) {
+	let v0 = k0 | 0;
+	let v1 = k1 | 0;
+	let v2 = 1819895653 ^ k0 | 0;
+	let v3 = 1952801890 ^ k1 | 0;
+	const len = bytes.length;
+	const end = len & -4;
+	for (let i = 0; i < end; i += 4) {
+		const m = (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0) << 16 | (bytes[i + 3] ?? 0) << 24;
+		v3 ^= m;
+		v0 = v0 + v1 | 0;
+		v1 = v1 << 5 | v1 >>> 27;
+		v1 ^= v0;
+		v0 = v0 << 16 | v0 >>> 16;
+		v2 = v2 + v3 | 0;
+		v3 = v3 << 8 | v3 >>> 24;
+		v3 ^= v2;
+		v0 = v0 + v3 | 0;
+		v3 = v3 << 7 | v3 >>> 25;
+		v3 ^= v0;
+		v2 = v2 + v1 | 0;
+		v1 = v1 << 13 | v1 >>> 19;
+		v1 ^= v2;
+		v2 = v2 << 16 | v2 >>> 16;
+		v0 ^= m;
+	}
+	let b = len << 24;
+	for (let i = len - 1; i >= end; i--) b |= (bytes[i] ?? 0) << 8 * (i - end);
+	v3 ^= b;
+	for (let r = 0; r < 4; r++) {
+		if (r === 1) {
+			v0 ^= b;
+			v2 ^= 255;
+		}
+		v0 = v0 + v1 | 0;
+		v1 = v1 << 5 | v1 >>> 27;
+		v1 ^= v0;
+		v0 = v0 << 16 | v0 >>> 16;
+		v2 = v2 + v3 | 0;
+		v3 = v3 << 8 | v3 >>> 24;
+		v3 ^= v2;
+		v0 = v0 + v3 | 0;
+		v3 = v3 << 7 | v3 >>> 25;
+		v3 ^= v0;
+		v2 = v2 + v1 | 0;
+		v1 = v1 << 13 | v1 >>> 19;
+		v1 ^= v2;
+		v2 = v2 << 16 | v2 >>> 16;
+	}
+	return (v1 ^ v3) >>> 0;
+}
+const TOPK_MAX_CAPACITY = 2 ** 24;
+function topKLoadLimit(capacity) {
+	return Math.floor(.75 * capacity);
+}
+function topKPurgeWidth(capacity) {
+	return topKLoadLimit(capacity) + 2 >> 1;
+}
+function topKSizing(epsilon) {
+	require_params.assertProbability(epsilon, "epsilon");
+	for (let capacity = 4; capacity <= TOPK_MAX_CAPACITY; capacity *= 2) if (1 / topKPurgeWidth(capacity) <= epsilon) return { capacity };
+	throw new require_params.ParamError(`epsilon ${String(epsilon)} needs more than the maximum capacity ${String(TOPK_MAX_CAPACITY)}`);
+}
+//#endregion
+//#region src/topk/topk.ts
+const TYPE = 9;
+const TABLE_START = 8;
+const PARAMS_SIZE = 32;
+const PARAMS_FIELDS_END = 24;
+function assertCount(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new require_serialize.SerializationError(`topk: ${label} ${String(value)} is not an integer in [0, ${String(Number.MAX_SAFE_INTEGER)}]`);
+}
+function compareBytes(a, b) {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) {
+		const diff = (a[i] ?? 0) - (b[i] ?? 0);
+		if (diff !== 0) return diff;
+	}
+	return a.length - b.length;
+}
+var TopKOverflowError = class extends RangeError {
+	name = "TopKOverflowError";
+};
+var TopKParamMismatchError = class extends Error {
+	name = "TopKParamMismatchError";
+};
+var TopK = class TopK {
+	#capacity;
+	#loadLimit;
+	#k0 = 0;
+	#k1 = 0;
+	#keyed = false;
+	#size = 0;
+	#counts = new Uint32Array(0);
+	#keyOffsets = new Uint32Array(0);
+	#keyLengths = new Uint32Array(0);
+	#arena;
+	#arenaLen = 0;
+	#entries = 0;
+	#offset = 0;
+	#total = 0;
+	static create(epsilon) {
+		return new TopK(topKSizing(epsilon));
+	}
+	static from(keys, epsilon) {
+		const sketch = TopK.create(epsilon);
+		for (const key of keys) sketch.add(key);
+		return sketch;
+	}
+	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, "topk");
+		require_serialize.assertParamsPadding(body, PARAMS_FIELDS_END, PARAMS_SIZE, "topk");
+		const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const capacity = view.getUint32(0, true);
+		const entries = view.getUint32(4, true);
+		if (entries > topKLoadLimit(capacity)) throw new require_serialize.SerializationError(`topk: frame holds ${String(entries)} entries, above the load limit ${String(topKLoadLimit(capacity))} for capacity ${String(capacity)}`);
+		const tableEnd = PARAMS_SIZE + 8 * entries;
+		require_serialize.assertMinBodyLength(body.length, tableEnd, "topk");
+		let keyBytes = 0;
+		for (let i = 0; i < entries; i++) keyBytes += view.getUint32(PARAMS_SIZE + 4 * (entries + i), true);
+		require_serialize.assertBodyLength(body.length, tableEnd + keyBytes, "topk");
+		const offset = view.getFloat64(8, true);
+		const total = view.getFloat64(16, true);
+		assertCount(offset, "offset");
+		assertCount(total, "total");
+		let sketch;
+		try {
+			sketch = new TopK({ capacity });
+			sketch.#allocate(sketch.#fit(entries));
+		} catch (err) {
+			if (err instanceof require_params.ParamError) throw new require_serialize.SerializationError(`topk: ${err.message}`);
+			throw err;
+		}
+		let keyAt = tableEnd;
+		let stored = 0;
+		let prevCount = Infinity;
+		let prevKey = new Uint8Array(0);
+		for (let i = 0; i < entries; i++) {
+			const count = view.getUint32(PARAMS_SIZE + 4 * i, true);
+			const len = view.getUint32(PARAMS_SIZE + 4 * (entries + i), true);
+			const key = body.subarray(keyAt, keyAt + len);
+			keyAt += len;
+			if (count === 0) throw new require_serialize.SerializationError(`topk: entry ${String(i)} has count 0`);
+			if (count > prevCount || count === prevCount && compareBytes(prevKey, key) >= 0) throw new require_serialize.SerializationError(`topk: entry ${String(i)} is out of canonical order`);
+			prevCount = count;
+			prevKey = key;
+			const slot = sketch.#slotFor(key);
+			if ((sketch.#counts[slot] ?? 0) !== 0) throw new require_serialize.SerializationError(`topk: entry ${String(i)} repeats a key already held`);
+			sketch.#storeKey(slot, key);
+			sketch.#counts[slot] = count;
+			stored += count;
+		}
+		const width = topKPurgeWidth(capacity);
+		if (stored + width * offset > total) throw new require_serialize.SerializationError(`topk: stored counts ${String(stored)} plus ${String(width)} x offset ${String(offset)} exceed total ${String(total)}`);
+		sketch.#entries = entries;
+		sketch.#offset = offset;
+		sketch.#total = total;
+		return sketch;
+	}
+	constructor({ capacity }) {
+		require_params.assertUint32(capacity, "capacity");
+		if (!Number.isInteger(Math.log2(capacity))) throw new require_params.ParamError(`capacity must be a power of two, got ${String(capacity)}`);
+		if (capacity < 4 || capacity > TOPK_MAX_CAPACITY) throw new require_params.ParamError(`capacity must be in [${String(4)}, ${String(TOPK_MAX_CAPACITY)}], got ${String(capacity)}`);
+		this.#capacity = capacity;
+		this.#loadLimit = topKLoadLimit(capacity);
+		this.#allocate(Math.min(TABLE_START, capacity));
+		this.#arena = new Uint8Array(256);
+	}
+	get capacity() {
+		return this.#capacity;
+	}
+	get epsilon() {
+		return 1 / topKPurgeWidth(this.#capacity);
+	}
+	get total() {
+		return this.#total;
+	}
+	error() {
+		return this.#offset;
+	}
+	#purge() {
+		const keys = [];
+		const counts = [];
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			keys.push(this.#keyAt(slot).slice());
+			counts.push(stored);
+		}
+		this.#reduceTo(keys, counts);
+	}
+	#reduceTo(keys, counts) {
+		while (keys.length > this.#loadLimit) {
+			const median = [...counts].sort((a, b) => a - b)[counts.length >> 1] ?? 0;
+			let kept = 0;
+			for (let i = 0; i < keys.length; i++) {
+				const survived = (counts[i] ?? 0) - median;
+				if (survived <= 0) continue;
+				keys[kept] = keys[i] ?? new Uint8Array(0);
+				counts[kept] = survived;
+				kept++;
+			}
+			keys.length = kept;
+			counts.length = kept;
+			this.#offset += median;
+		}
+		const size = this.#fit(keys.length);
+		if (size > this.#size) this.#allocate(size);
+		else this.#counts.fill(0);
+		this.#arenaLen = 0;
+		this.#entries = keys.length;
+		for (let i = 0; i < keys.length; i++) {
+			const bytes = keys[i] ?? new Uint8Array(0);
+			const slot = this.#slotFor(bytes);
+			this.#storeKey(slot, bytes);
+			this.#counts[slot] = counts[i] ?? 0;
+		}
+	}
+	#allocate(size) {
+		this.#size = size;
+		this.#counts = new Uint32Array(size);
+		this.#keyOffsets = new Uint32Array(size);
+		this.#keyLengths = new Uint32Array(size);
+	}
+	#resize(size) {
+		const counts = this.#counts;
+		const offsets = this.#keyOffsets;
+		const lengths = this.#keyLengths;
+		this.#allocate(size);
+		for (let old = 0; old < counts.length; old++) {
+			const stored = counts[old] ?? 0;
+			if (stored === 0) continue;
+			const at = offsets[old] ?? 0;
+			const len = lengths[old] ?? 0;
+			const slot = this.#slotFor(this.#arena.subarray(at, at + len));
+			this.#counts[slot] = stored;
+			this.#keyOffsets[slot] = at;
+			this.#keyLengths[slot] = len;
+		}
+	}
+	#fit(entries) {
+		let size = Math.min(TABLE_START, this.#capacity);
+		while (size < this.#capacity && topKLoadLimit(size) < entries) size *= 2;
+		return size;
+	}
+	#slotHolds(slot, bytes) {
+		const len = this.#keyLengths[slot] ?? 0;
+		if (len !== bytes.length) return false;
+		const at = this.#keyOffsets[slot] ?? 0;
+		for (let i = 0; i < len; i++) if (this.#arena[at + i] !== bytes[i]) return false;
+		return true;
+	}
+	#storeKey(slot, bytes) {
+		let arena = this.#arena;
+		if (this.#arenaLen + bytes.length > arena.length) {
+			let size = arena.length;
+			while (size < this.#arenaLen + bytes.length) size *= 2;
+			const grown = new Uint8Array(size);
+			grown.set(arena.subarray(0, this.#arenaLen));
+			arena = grown;
+			this.#arena = grown;
+		}
+		arena.set(bytes, this.#arenaLen);
+		this.#keyOffsets[slot] = this.#arenaLen;
+		this.#keyLengths[slot] = bytes.length;
+		this.#arenaLen += bytes.length;
+	}
+	#slotFor(bytes) {
+		if (!this.#keyed) {
+			const key = crypto.getRandomValues(new Uint32Array(2));
+			this.#k0 = key[0] ?? 0;
+			this.#k1 = key[1] ?? 0;
+			this.#keyed = true;
+		}
+		const mask = this.#size - 1;
+		let slot = halfSipHash13(bytes, this.#k0, this.#k1) & mask;
+		for (;;) {
+			if ((this.#counts[slot] ?? 0) === 0) return slot;
+			if (this.#slotHolds(slot, bytes)) return slot;
+			slot = slot + 1 & mask;
+		}
+	}
+	add(key, count = 1) {
+		require_params.assertPositiveInt(count, "count");
+		if (this.#total + count > Number.MAX_SAFE_INTEGER) throw new TopKOverflowError(`adding ${String(count)} would carry the total past ${String(Number.MAX_SAFE_INTEGER)}`);
+		const bytes = require_bytes.normalize(key);
+		const slot = this.#slotFor(bytes);
+		const stored = this.#counts[slot] ?? 0;
+		if (stored + count > 4294967295) throw new TopKOverflowError(`adding ${String(count)} would carry a stored count past ${String(4294967295)}`);
+		if (stored === 0) {
+			this.#storeKey(slot, bytes);
+			this.#entries++;
+		}
+		this.#counts[slot] = stored + count;
+		this.#total += count;
+		if (this.#entries > topKLoadLimit(this.#size)) {
+			if (this.#size < this.#capacity) this.#resize(this.#size * 2);
+			else this.#purge();
+		}
+	}
+	count(key) {
+		const bytes = require_bytes.normalize(key);
+		const stored = this.#counts[this.#slotFor(bytes)] ?? 0;
+		return stored === 0 ? 0 : stored + this.#offset;
+	}
+	top(k) {
+		require_params.assertPositiveInt(k, "k");
+		return this.#canonicalSlots().slice(0, k).map((slot) => {
+			const at = this.#keyOffsets[slot] ?? 0;
+			return {
+				key: this.#arena.slice(at, at + (this.#keyLengths[slot] ?? 0)),
+				count: (this.#counts[slot] ?? 0) + this.#offset,
+				lowerBound: this.#counts[slot] ?? 0
+			};
+		});
+	}
+	union(other) {
+		if (this.#capacity !== other.#capacity) throw new TopKParamMismatchError(`cannot union Top-K sketches with capacity ${String(this.#capacity)} and ${String(other.#capacity)}`);
+		if (this.#total + other.#total > Number.MAX_SAFE_INTEGER) throw new TopKOverflowError(`union would carry the total past ${String(Number.MAX_SAFE_INTEGER)}`);
+		const keys = [];
+		const counts = [];
+		const indexOf = new Int32Array(this.#size).fill(-1);
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			indexOf[slot] = keys.length;
+			keys.push(this.#keyAt(slot).slice());
+			counts.push(stored);
+		}
+		for (let slot = 0; slot < other.#size; slot++) {
+			const stored = other.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			const key = other.#keyAt(slot);
+			const at = indexOf[this.#slotFor(key)] ?? -1;
+			if (at >= 0) {
+				const sum = (counts[at] ?? 0) + stored;
+				if (sum > 4294967295) throw new TopKOverflowError(`union would carry a stored count to ${String(sum)}, past ${String(4294967295)}`);
+				counts[at] = sum;
+			} else {
+				keys.push(key.slice());
+				counts.push(stored);
+			}
+		}
+		const merged = new TopK({ capacity: this.#capacity });
+		merged.#offset = this.#offset + other.#offset;
+		merged.#total = this.#total + other.#total;
+		merged.#reduceTo(keys, counts);
+		return merged;
+	}
+	toBytes() {
+		const slots = this.#canonicalSlots();
+		const tableEnd = PARAMS_SIZE + 8 * slots.length;
+		return require_serialize.writeFrame({
+			version: 5,
+			type: TYPE,
+			flags: 0
+		}, PARAMS_SIZE, 8 * slots.length + this.#arenaLen, (body, view) => {
+			view.setUint32(0, this.#capacity, true);
+			view.setUint32(4, slots.length, true);
+			view.setFloat64(8, this.#offset, true);
+			view.setFloat64(16, this.#total, true);
+			let keyAt = tableEnd;
+			slots.forEach((slot, i) => {
+				const at = this.#keyOffsets[slot] ?? 0;
+				const len = this.#keyLengths[slot] ?? 0;
+				view.setUint32(PARAMS_SIZE + 4 * i, this.#counts[slot] ?? 0, true);
+				view.setUint32(PARAMS_SIZE + 4 * (slots.length + i), len, true);
+				body.set(this.#arena.subarray(at, at + len), keyAt);
+				keyAt += len;
+			});
+		});
+	}
+	equals(other) {
+		if (this.#capacity !== other.#capacity || this.#offset !== other.#offset || this.#total !== other.#total || this.#entries !== other.#entries) return false;
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			if (other.#counts[other.#slotFor(this.#keyAt(slot))] !== stored) return false;
+		}
+		return true;
+	}
+	toJSON() {
+		return require_serialize.toJSONEnvelope(this.toBytes());
+	}
+	static fromJSON(value) {
+		return TopK.fromBytes(require_serialize.fromJSONEnvelope(value));
+	}
+	#canonicalSlots() {
+		const slots = [];
+		for (let slot = 0; slot < this.#size; slot++) if ((this.#counts[slot] ?? 0) !== 0) slots.push(slot);
+		return slots.sort((a, b) => {
+			const byCount = (this.#counts[b] ?? 0) - (this.#counts[a] ?? 0);
+			return byCount !== 0 ? byCount : this.#compareKeys(a, b);
+		});
+	}
+	#compareKeys(a, b) {
+		return compareBytes(this.#keyAt(a), this.#keyAt(b));
+	}
+	#keyAt(slot) {
+		const at = this.#keyOffsets[slot] ?? 0;
+		return this.#arena.subarray(at, at + (this.#keyLengths[slot] ?? 0));
+	}
+};
+//#endregion
+exports.BadMagicError = require_serialize.BadMagicError;
+exports.ChecksumError = require_serialize.ChecksumError;
+exports.ParamError = require_params.ParamError;
+exports.ReservedBitsError = require_serialize.ReservedBitsError;
+exports.SerializationError = require_serialize.SerializationError;
+exports.TopK = TopK;
+exports.TopKOverflowError = TopKOverflowError;
+exports.TopKParamMismatchError = TopKParamMismatchError;
+exports.TruncatedError = require_serialize.TruncatedError;
+exports.UnknownHashVariantError = require_serialize.UnknownHashVariantError;
+exports.UnknownVersionError = require_serialize.UnknownVersionError;
+exports.topKSizing = topKSizing;