distillate 0.14.1 → 0.15.0

package/README.md

@@ -52,12 +52,13 @@ Each structure ships as its own subpath, so you only bundle what you import.
 | `distillate/hll`      | HyperLogLog    | how many distinct?  | Counting distinct users, IPs, or keys in fixed space     |
 | `distillate/countmin` | Count-Min      | how many times?     | Counting events per key in fixed space                   |
 | `distillate/topk`     | Top-K          | which are heaviest? | Finding the most frequent keys in fixed space            |
+| `distillate/ddsketch` | DDSketch       | what is the p99?    | Latency and size percentiles, mergeable, in fixed space  |
 
 The filters are mutable except Binary Fuse, which is built once from the whole
-key set. HyperLogLog, Count-Min and Top-K are sketches rather than filters:
-none reports whether it saw any particular key. HyperLogLog counts distinct
-keys, Count-Min counts how often each key appeared, and Top-K reports which
-keys appeared most.
+key set. HyperLogLog, Count-Min, Top-K and DDSketch are sketches rather than
+filters: none reports whether it saw any particular key. HyperLogLog counts
+distinct keys, Count-Min counts how often each key appeared, Top-K reports which
+keys appeared most, and DDSketch reports quantiles of numbers rather than keys.
 
 ### Classic Bloom (`distillate/bloom`)
 
@@ -215,6 +216,24 @@ Keys come back as `Uint8Array`, exactly as recorded, so a serialized Top-K sketc
 
 Also: `equals`, `toBytes` / `fromBytes`, `toJSON` / `fromJSON`, `total`, `error()`, `epsilon`, `capacity`, `topKSizing(epsilon)`, and a low-level `new TopK({ capacity, seed })`.
 
+### DDSketch (`distillate/ddsketch`)
+
+A **sketch** of numbers rather than keys: every quantile it reports is within a relative error of the true value, tails included, and two sketches merge exactly. Full API, mappings, stores and the bound: [DDSketch guide](https://distillate.akxp.net/guides/ddsketch/).
+
+```ts
+import { DDSketch } from "distillate/ddsketch";
+
+const latency = DDSketch.create(0.01); // within 1%
+for (let ms = 1; ms <= 1000; ms++) latency.add(ms);
+
+latency.quantile(0.99); // ~992
+latency.max; // 1000
+```
+
+By default it bins with the bitwise mapping Datadog's `DDSketch.fast()` uses, about 1.75 times as fast as the log mapping, and keeps at most 4096 bins per sign, enough for about 19 orders of magnitude at 1%; at a tighter accuracy, raise `maxBins` through `collapsingLowestStore`. `distillate/ddsketch/protobuf` converts to and from the protobuf message Datadog's libraries exchange.
+
+Also: `add(value, count)`, `quantiles`, `count`, `sum`, `min`, `union`, `equals`, `toBytes` / `fromBytes`, `toJSON` / `fromJSON`, and the `bitwiseMapping`, `logMapping`, `linearMapping`, `quadraticMapping`, `cubicMapping`, `denseStore`, `sparseStore`, `collapsingLowestStore` and `collapsingHighestStore` factories.
+
 ## Performance
 
 Classic Bloom head-to-head at a **matched 1% false-positive rate** over the same 100k keys, measured by identical code (cross-library harness, node v24.14.1, Apple M5):

package/dist/blocked/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hasher = require("../hasher-DPXmP7SH.cjs");
+const require_hasher = require("../hasher-CKLP9Oqe.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, u as reduce } from "../hasher-DOdmZ-LI.js";
+import { a as hash32x2Into, u as reduce } from "../hasher-BQxNrCQC.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,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sizing = require("../sizing-Ch0SDdza.cjs");
-const require_hasher = require("../hasher-DPXmP7SH.cjs");
+const require_hasher = require("../hasher-CKLP9Oqe.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
 //#region src/bloom/bloom.ts
@@ -67,7 +67,7 @@ var BloomFilter = class BloomFilter {
 		this.#m = m;
 		this.#k = k;
 		this.#seed = seed;
-		this.#scratch = new Uint32Array(k);
+		this.#scratch = new Uint32Array(Math.max(k, 2));
 		this.#n = n ?? Math.max(1, Math.round(m * Math.LN2 / k));
 	}
 	get m() {
@@ -131,8 +131,10 @@ var BloomFilter = class BloomFilter {
 		for (let i = 0; i < this.#k; i++) this.#bits.set(this.#scratch[i] ?? 0);
 	}
 	has(key) {
-		require_hasher.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;
+		require_hasher.hash32x2Into(key, this.#seed, this.#scratch);
+		const a = this.#scratch[0] ?? 0;
+		const b = this.#scratch[1] ?? 0;
+		for (let i = 0; i < this.#k; i++) if (!this.#bits.get(require_hasher.probeAt(a, b, i, this.#m))) return false;
 		return true;
 	}
 };

package/dist/bloom/index.js

@@ -1,5 +1,5 @@
 import { n as BitSet, t as bloomSizing } from "../sizing-zxCBlyhO.js";
-import { c as probeInto } from "../hasher-DOdmZ-LI.js";
+import { a as hash32x2Into, c as probeInto, s as probeAt } from "../hasher-BQxNrCQC.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";
 //#region src/bloom/bloom.ts
@@ -66,7 +66,7 @@ var BloomFilter = class BloomFilter {
 		this.#m = m;
 		this.#k = k;
 		this.#seed = seed;
-		this.#scratch = new Uint32Array(k);
+		this.#scratch = new Uint32Array(Math.max(k, 2));
 		this.#n = n ?? Math.max(1, Math.round(m * Math.LN2 / k));
 	}
 	get m() {
@@ -130,8 +130,10 @@ var BloomFilter = class BloomFilter {
 		for (let i = 0; i < this.#k; i++) this.#bits.set(this.#scratch[i] ?? 0);
 	}
 	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;
+		hash32x2Into(key, this.#seed, this.#scratch);
+		const a = this.#scratch[0] ?? 0;
+		const b = this.#scratch[1] ?? 0;
+		for (let i = 0; i < this.#k; i++) if (!this.#bits.get(probeAt(a, b, i, this.#m))) return false;
 		return true;
 	}
 };

package/dist/bytes-DWGupBUE.cjs

@@ -0,0 +1,45 @@
+//#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);
+}
+const ASCII_FAST_MAX = 12;
+let keyBuf = new Uint8Array(256);
+let keyBytes = keyBuf;
+function encodedBytes() {
+	return keyBytes;
+}
+function encodeKey(key) {
+	if (typeof key === "string") {
+		const n = key.length;
+		if (keyBuf.length < n * 3) keyBuf = new Uint8Array(n * 3);
+		keyBytes = keyBuf;
+		if (n <= ASCII_FAST_MAX) {
+			let i = 0;
+			for (; i < n; i++) {
+				const c = key.charCodeAt(i);
+				if (c > 127) break;
+				keyBuf[i] = c;
+			}
+			if (i === n) return n;
+		}
+		return encoder.encodeInto(key, keyBuf).written;
+	}
+	keyBytes = normalize(key);
+	return keyBytes.length;
+}
+//#endregion
+Object.defineProperty(exports, "encodeKey", {
+	enumerable: true,
+	get: function() {
+		return encodeKey;
+	}
+});
+Object.defineProperty(exports, "encodedBytes", {
+	enumerable: true,
+	get: function() {
+		return encodedBytes;
+	}
+});

package/dist/bytes-oOWlu7N5.js

@@ -0,0 +1,34 @@
+//#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);
+}
+const ASCII_FAST_MAX = 12;
+let keyBuf = new Uint8Array(256);
+let keyBytes = keyBuf;
+function encodedBytes() {
+	return keyBytes;
+}
+function encodeKey(key) {
+	if (typeof key === "string") {
+		const n = key.length;
+		if (keyBuf.length < n * 3) keyBuf = new Uint8Array(n * 3);
+		keyBytes = keyBuf;
+		if (n <= ASCII_FAST_MAX) {
+			let i = 0;
+			for (; i < n; i++) {
+				const c = key.charCodeAt(i);
+				if (c > 127) break;
+				keyBuf[i] = c;
+			}
+			if (i === n) return n;
+		}
+		return encoder.encodeInto(key, keyBuf).written;
+	}
+	keyBytes = normalize(key);
+	return keyBytes.length;
+}
+//#endregion
+export { encodedBytes as n, encodeKey as t };

package/dist/countmin/index.cjs

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

package/dist/countmin/index.js

@@ -1,4 +1,4 @@
-import { a as hash32x2Into, s as probeAt } from "../hasher-DOdmZ-LI.js";
+import { a as hash32x2Into, s as probeAt } from "../hasher-BQxNrCQC.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";
 //#region src/countmin/sizing.ts

package/dist/cuckoo/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hasher = require("../hasher-DPXmP7SH.cjs");
+const require_hasher = require("../hasher-CKLP9Oqe.cjs");
 const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
 const require_distinct = require("../distinct-Ck5PKuCS.cjs");

package/dist/cuckoo/index.js

@@ -1,4 +1,4 @@
-import { i as hash128KeyInto, u as reduce } from "../hasher-DOdmZ-LI.js";
+import { i as hash128KeyInto, u as reduce } from "../hasher-BQxNrCQC.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 DistinctHashes } from "../distinct-BhxDB8mW.js";

package/dist/ddsketch/index.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serialize = require("../serialize-CHikZ4GH.cjs");
+const require_params = require("../params-UTZbJ22c.cjs");
+const require_ddsketch = require("../ddsketch-Ao9louSV.cjs");
+exports.BadMagicError = require_serialize.BadMagicError;
+exports.ChecksumError = require_serialize.ChecksumError;
+exports.DDSketch = require_ddsketch.DDSketch;
+exports.DDSketchParamMismatchError = require_ddsketch.DDSketchParamMismatchError;
+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.bitwiseMapping = require_ddsketch.bitwiseMapping;
+exports.collapsingHighestStore = require_ddsketch.collapsingHighestStore;
+exports.collapsingLowestStore = require_ddsketch.collapsingLowestStore;
+exports.cubicMapping = require_ddsketch.cubicMapping;
+exports.denseStore = require_ddsketch.denseStore;
+exports.linearMapping = require_ddsketch.linearMapping;
+exports.logMapping = require_ddsketch.logMapping;
+exports.quadraticMapping = require_ddsketch.quadraticMapping;
+exports.sparseStore = require_ddsketch.sparseStore;

package/dist/ddsketch/index.d.cts

@@ -0,0 +1,4 @@
+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 { _ as quadraticMapping, a as StoreFactory, c as collapsingLowestStore, d as IndexMapping, f as MappingKind, g as logMapping, h as linearMapping, i as Store, l as denseStore, m as cubicMapping, n as DDSketchOptions, o as StoreKind, p as bitwiseMapping, r as DDSketchParamMismatchError, s as collapsingHighestStore, t as DDSketch, u as sparseStore } from "../ddsketch-1Buc9M3P.cjs";
+export { BadMagicError, ChecksumError, DDSketch, type DDSketchOptions, DDSketchParamMismatchError, type FilterJSON, type IndexMapping, type MappingKind, ParamError, ReservedBitsError, SerializationError, type Store, type StoreFactory, type StoreKind, TruncatedError, UnknownHashVariantError, UnknownVersionError, bitwiseMapping, collapsingHighestStore, collapsingLowestStore, cubicMapping, denseStore, linearMapping, logMapping, quadraticMapping, sparseStore };

package/dist/ddsketch/index.d.ts

@@ -0,0 +1,4 @@
+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 { _ as quadraticMapping, a as StoreFactory, c as collapsingLowestStore, d as IndexMapping, f as MappingKind, g as logMapping, h as linearMapping, i as Store, l as denseStore, m as cubicMapping, n as DDSketchOptions, o as StoreKind, p as bitwiseMapping, r as DDSketchParamMismatchError, s as collapsingHighestStore, t as DDSketch, u as sparseStore } from "../ddsketch-CvwWk86v.js";
+export { BadMagicError, ChecksumError, DDSketch, type DDSketchOptions, DDSketchParamMismatchError, type FilterJSON, type IndexMapping, type MappingKind, ParamError, ReservedBitsError, SerializationError, type Store, type StoreFactory, type StoreKind, TruncatedError, UnknownHashVariantError, UnknownVersionError, bitwiseMapping, collapsingHighestStore, collapsingLowestStore, cubicMapping, denseStore, linearMapping, logMapping, quadraticMapping, sparseStore };

package/dist/ddsketch/index.js

@@ -0,0 +1,4 @@
+import { a as TruncatedError, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as ReservedBitsError, s as UnknownVersionError, t as BadMagicError } from "../serialize-CMSYFym-.js";
+import { t as ParamError } from "../params-CeajSrwv.js";
+import { a as collapsingHighestStore, c as sparseStore, f as linearMapping, h as quadraticMapping, l as bitwiseMapping, n as DDSketchParamMismatchError, o as collapsingLowestStore, p as logMapping, s as denseStore, t as DDSketch, u as cubicMapping } from "../ddsketch-D3Sy8CAU.js";
+export { BadMagicError, ChecksumError, DDSketch, DDSketchParamMismatchError, ParamError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, bitwiseMapping, collapsingHighestStore, collapsingLowestStore, cubicMapping, denseStore, linearMapping, logMapping, quadraticMapping, sparseStore };

package/dist/ddsketch/protobuf/index.cjs

@@ -0,0 +1,297 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serialize = require("../../serialize-CHikZ4GH.cjs");
+const require_ddsketch = require("../../ddsketch-Ao9louSV.cjs");
+//#region src/ddsketch/protobuf/protobuf.ts
+const KINDS = [
+	"log",
+	"linear",
+	"quadratic",
+	"cubic"
+];
+const VARINT = 0;
+const FIXED64 = 1;
+const LENGTH = 2;
+const FIXED32 = 5;
+var Reader = class Reader {
+	#bytes;
+	#view;
+	#at;
+	#end;
+	constructor(bytes, at = 0, end = bytes.length) {
+		this.#bytes = bytes;
+		this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		this.#at = at;
+		this.#end = end;
+	}
+	get done() {
+		return this.#at >= this.#end;
+	}
+	varint() {
+		let value = 0;
+		for (let shift = 0; shift < 70; shift += 7) {
+			if (this.#at >= this.#end) throw new require_serialize.SerializationError("protobuf: truncated varint");
+			const byte = this.#bytes[this.#at++] ?? 0;
+			value += (byte & 127) * 2 ** shift;
+			if (byte < 128) return value;
+		}
+		throw new require_serialize.SerializationError("protobuf: varint longer than ten bytes");
+	}
+	sint32() {
+		const u = this.varint() % 2 ** 32;
+		return u >>> 1 ^ -(u & 1);
+	}
+	double() {
+		this.#need(8);
+		const value = this.#view.getFloat64(this.#at, true);
+		this.#at += 8;
+		return value;
+	}
+	message() {
+		const length = this.varint();
+		this.#need(length);
+		const sub = new Reader(this.#bytes, this.#at, this.#at + length);
+		this.#at += length;
+		return sub;
+	}
+	tag() {
+		const tag = this.varint();
+		return [Math.floor(tag / 8), tag % 8];
+	}
+	skip(wire) {
+		if (wire === VARINT) this.varint();
+		else if (wire === FIXED64) this.#skipBytes(8);
+		else if (wire === LENGTH) this.message();
+		else if (wire === FIXED32) this.#skipBytes(4);
+		else throw new require_serialize.SerializationError(`protobuf: unsupported wire type ${String(wire)}`);
+	}
+	#skipBytes(n) {
+		this.#need(n);
+		this.#at += n;
+	}
+	#need(n) {
+		if (this.#at + n > this.#end) throw new require_serialize.SerializationError("protobuf: field runs past the end of its message");
+	}
+};
+function expectWire(field, wire, want) {
+	if (wire !== want) throw new require_serialize.SerializationError(`protobuf: ${field} has wire type ${String(wire)}, want ${String(want)}`);
+}
+function readMapping(r, into) {
+	while (!r.done) {
+		const [field, wire] = r.tag();
+		if (field === 1) {
+			expectWire("gamma", wire, FIXED64);
+			into.gamma = r.double();
+		} else if (field === 2) {
+			expectWire("indexOffset", wire, FIXED64);
+			into.indexOffset = r.double();
+		} else if (field === 3) {
+			expectWire("interpolation", wire, VARINT);
+			into.interpolation = r.varint();
+		} else r.skip(wire);
+	}
+}
+function readStore(r, bins) {
+	const contiguous = [];
+	let offset = 0;
+	while (!r.done) {
+		const [field, wire] = r.tag();
+		if (field === 1) {
+			expectWire("binCounts", wire, LENGTH);
+			const entry = r.message();
+			let index = 0;
+			let count = 0;
+			while (!entry.done) {
+				const [f, w] = entry.tag();
+				if (f === 1) {
+					expectWire("binCounts key", w, VARINT);
+					index = entry.sint32();
+				} else if (f === 2) {
+					expectWire("binCounts value", w, FIXED64);
+					count = entry.double();
+				} else entry.skip(w);
+			}
+			bins.set(index, (bins.get(index) ?? 0) + count);
+		} else if (field === 2) {
+			if (wire === LENGTH) {
+				const packed = r.message();
+				while (!packed.done) contiguous.push(packed.double());
+			} else {
+				expectWire("contiguousBinCounts", wire, FIXED64);
+				contiguous.push(r.double());
+			}
+		} else if (field === 3) {
+			expectWire("contiguousBinIndexOffset", wire, VARINT);
+			offset = r.sint32();
+		} else r.skip(wire);
+	}
+	contiguous.forEach((count, i) => {
+		if (count !== 0) bins.set(offset + i, (bins.get(offset + i) ?? 0) + count);
+	});
+}
+function fromProtobuf(bytes, options = {}) {
+	const { store = require_ddsketch.collapsingLowestStore(4096) } = options;
+	const r = new Reader(bytes);
+	const mapped = {
+		gamma: 0,
+		indexOffset: 0,
+		interpolation: 0
+	};
+	const positive = new Map();
+	const negative = new Map();
+	let zeroCount = 0;
+	while (!r.done) {
+		const [field, wire] = r.tag();
+		if (field === 1) {
+			expectWire("mapping", wire, LENGTH);
+			readMapping(r.message(), mapped);
+		} else if (field === 2) {
+			expectWire("positiveValues", wire, LENGTH);
+			readStore(r.message(), positive);
+		} else if (field === 3) {
+			expectWire("negativeValues", wire, LENGTH);
+			readStore(r.message(), negative);
+		} else if (field === 4) {
+			expectWire("zeroCount", wire, FIXED64);
+			zeroCount = r.double();
+		} else r.skip(wire);
+	}
+	const kind = KINDS[mapped.interpolation];
+	if (kind === void 0) throw new require_serialize.SerializationError(`protobuf: unknown interpolation ${String(mapped.interpolation)}`);
+	const { gamma, indexOffset } = mapped;
+	if (!(gamma > 1 && gamma < Infinity) || !Number.isFinite(indexOffset)) throw new require_serialize.SerializationError("protobuf: gamma must be finite and above 1, and indexOffset finite");
+	if (!(zeroCount >= 0 && zeroCount < Infinity)) throw new require_serialize.SerializationError(`protobuf: zeroCount must be finite and not negative, got ${String(zeroCount)}`);
+	const mapping = require_ddsketch.mappingWithGamma(kind, gamma, indexOffset);
+	if (!require_ddsketch.isIndexable(mapping)) throw new require_serialize.SerializationError("protobuf: the mapping leaves no value indexable");
+	const lo = mapping.index(mapping.minIndexableValue);
+	const hi = mapping.index(mapping.maxIndexableValue);
+	for (const bins of [positive, negative]) for (const [index, count] of bins) if (count === 0) bins.delete(index);
+	else if (!(count > 0 && count < Infinity) || index < lo || index > hi) throw new require_serialize.SerializationError(`protobuf: bin ${String(index)} with count ${String(count)} is not one a sketch could hold`);
+	return require_ddsketch.sketchFromBins(mapping, store, positive, negative, zeroCount);
+}
+function varintSize(value) {
+	let size = 1;
+	while (value >= 128) {
+		value = Math.floor(value / 128);
+		size++;
+	}
+	return size;
+}
+function zigzag(value) {
+	return (value << 1 ^ value >> 31) >>> 0;
+}
+function present(value) {
+	return value !== 0 || Object.is(value, -0);
+}
+function storeBody(store, sparse) {
+	const indices = [];
+	const counts = [];
+	store.forEach((index, count) => {
+		indices.push(index);
+		counts.push(count);
+	});
+	let size = 0;
+	const first = indices[0];
+	if (sparse) for (const index of indices) {
+		const entry = 1 + varintSize(zigzag(index)) + 1 + 8;
+		size += 1 + varintSize(entry) + entry;
+	}
+	else if (first !== void 0) {
+		const packed = 8 * ((indices.at(-1) ?? first) - first + 1);
+		size = 1 + varintSize(packed) + packed;
+		if (first !== 0) size += 1 + varintSize(zigzag(first));
+	}
+	return {
+		indices,
+		counts,
+		sparse,
+		size
+	};
+}
+var Writer = class {
+	bytes;
+	#view;
+	#at = 0;
+	constructor(size) {
+		this.bytes = new Uint8Array(size);
+		this.#view = new DataView(this.bytes.buffer);
+	}
+	tag(field, wire) {
+		this.bytes[this.#at++] = field * 8 + wire;
+	}
+	varint(value) {
+		while (value >= 128) {
+			this.bytes[this.#at++] = value % 128 | 128;
+			value = Math.floor(value / 128);
+		}
+		this.bytes[this.#at++] = value;
+	}
+	double(value) {
+		this.#view.setFloat64(this.#at, value, true);
+		this.#at += 8;
+	}
+	store(field, body) {
+		this.tag(field, LENGTH);
+		this.varint(body.size);
+		const { indices, counts } = body;
+		const first = indices[0];
+		if (first === void 0) return;
+		if (body.sparse) {
+			indices.forEach((index, i) => {
+				const key = zigzag(index);
+				this.tag(1, LENGTH);
+				this.varint(1 + varintSize(key) + 1 + 8);
+				this.tag(1, VARINT);
+				this.varint(key);
+				this.tag(2, FIXED64);
+				this.double(counts[i] ?? 0);
+			});
+			return;
+		}
+		const span = (indices.at(-1) ?? first) - first + 1;
+		this.tag(2, LENGTH);
+		this.varint(8 * span);
+		indices.forEach((index, i) => {
+			this.#view.setFloat64(this.#at + 8 * (index - first), counts[i] ?? 0, true);
+		});
+		this.#at += 8 * span;
+		if (first !== 0) {
+			this.tag(3, VARINT);
+			this.varint(zigzag(first));
+		}
+	}
+};
+function toProtobuf(sketch) {
+	const { mapping } = sketch;
+	const { positive, negative, zeroCount } = require_ddsketch.sketchBins(sketch);
+	const sparse = sketch.store.kind === "sparse";
+	const pos = storeBody(positive, sparse);
+	const neg = storeBody(negative, sparse);
+	const interpolation = KINDS.indexOf(mapping.kind);
+	const mappingSize = (present(mapping.gamma) ? 9 : 0) + (present(mapping.indexOffset) ? 9 : 0) + (interpolation !== 0 ? 1 + varintSize(interpolation) : 0);
+	const w = new Writer(1 + varintSize(mappingSize) + mappingSize + (1 + varintSize(pos.size) + pos.size) + (1 + varintSize(neg.size) + neg.size) + (present(zeroCount) ? 9 : 0));
+	w.tag(1, LENGTH);
+	w.varint(mappingSize);
+	if (present(mapping.gamma)) {
+		w.tag(1, FIXED64);
+		w.double(mapping.gamma);
+	}
+	if (present(mapping.indexOffset)) {
+		w.tag(2, FIXED64);
+		w.double(mapping.indexOffset);
+	}
+	if (interpolation !== 0) {
+		w.tag(3, VARINT);
+		w.varint(interpolation);
+	}
+	w.store(2, pos);
+	w.store(3, neg);
+	if (present(zeroCount)) {
+		w.tag(4, FIXED64);
+		w.double(zeroCount);
+	}
+	return w.bytes;
+}
+//#endregion
+exports.SerializationError = require_serialize.SerializationError;
+exports.fromProtobuf = fromProtobuf;
+exports.toProtobuf = toProtobuf;

package/dist/ddsketch/protobuf/index.d.cts

@@ -0,0 +1,43 @@
+import { o as SerializationError } from "../../serialize--xR6vGSW.cjs";
+import { a as StoreFactory, t as DDSketch } from "../../ddsketch-1Buc9M3P.cjs";
+//#region src/ddsketch/protobuf/protobuf.d.ts
+/** Options for {@link fromProtobuf}. */
+interface ProtobufOptions {
+  /**
+   * The store the decoded sketch keeps its bins in. Defaults to
+   * {@link collapsingLowestStore} at 4096 bins, where sketches-go's FromProto
+   * takes a dense store: a message of a few dozen bytes can name two bins
+   * billions of indices apart, and a dense store would allocate every slot
+   * between them. Pass `denseStore()` for sketches-go's behavior on
+   * trusted input.
+   */
+  store?: StoreFactory;
+}
+/**
+ * Decodes Datadog's `DDSketch` protobuf message, as sketches-go, sketches-java
+ * and the Datadog agent write it.
+ *
+ * The message carries no sum, min or max, so the decoded sketch derives them
+ * from its bins: each is within `relativeAccuracy` of the truth for min and
+ * max, and approximate for sum.
+ *
+ * @param bytes - The serialized message.
+ * @param options - Optional store for the decoded bins.
+ * @returns The decoded sketch.
+ * @throws {@link SerializationError} when the message is malformed.
+ */
+export declare function fromProtobuf(bytes: Uint8Array, options?: ProtobufOptions): DDSketch;
+/**
+ * Encodes a sketch as Datadog's `DDSketch` protobuf message, the form the
+ * Datadog API and sketches-go read. For a dense or collapsing store the bytes
+ * are exactly those sketches-go writes for the same bins.
+ *
+ * The message has no fields for sum, min or max, so those do not survive the
+ * trip; {@link fromProtobuf} derives them from the bins.
+ *
+ * @param sketch - The sketch to encode.
+ * @returns The serialized message.
+ */
+export declare function toProtobuf(sketch: DDSketch): Uint8Array;
+//#endregion
+export { type ProtobufOptions, SerializationError };

package/dist/ddsketch/protobuf/index.d.ts

@@ -0,0 +1,43 @@
+import { o as SerializationError } from "../../serialize--xR6vGSW.js";
+import { a as StoreFactory, t as DDSketch } from "../../ddsketch-CvwWk86v.js";
+//#region src/ddsketch/protobuf/protobuf.d.ts
+/** Options for {@link fromProtobuf}. */
+interface ProtobufOptions {
+  /**
+   * The store the decoded sketch keeps its bins in. Defaults to
+   * {@link collapsingLowestStore} at 4096 bins, where sketches-go's FromProto
+   * takes a dense store: a message of a few dozen bytes can name two bins
+   * billions of indices apart, and a dense store would allocate every slot
+   * between them. Pass `denseStore()` for sketches-go's behavior on
+   * trusted input.
+   */
+  store?: StoreFactory;
+}
+/**
+ * Decodes Datadog's `DDSketch` protobuf message, as sketches-go, sketches-java
+ * and the Datadog agent write it.
+ *
+ * The message carries no sum, min or max, so the decoded sketch derives them
+ * from its bins: each is within `relativeAccuracy` of the truth for min and
+ * max, and approximate for sum.
+ *
+ * @param bytes - The serialized message.
+ * @param options - Optional store for the decoded bins.
+ * @returns The decoded sketch.
+ * @throws {@link SerializationError} when the message is malformed.
+ */
+export declare function fromProtobuf(bytes: Uint8Array, options?: ProtobufOptions): DDSketch;
+/**
+ * Encodes a sketch as Datadog's `DDSketch` protobuf message, the form the
+ * Datadog API and sketches-go read. For a dense or collapsing store the bytes
+ * are exactly those sketches-go writes for the same bins.
+ *
+ * The message has no fields for sum, min or max, so those do not survive the
+ * trip; {@link fromProtobuf} derives them from the bins.
+ *
+ * @param sketch - The sketch to encode.
+ * @returns The serialized message.
+ */
+export declare function toProtobuf(sketch: DDSketch): Uint8Array;
+//#endregion
+export { type ProtobufOptions, SerializationError };