distillate 0.1.0

package/dist/bloom/index.js

@@ -0,0 +1,130 @@
+import { a as probeInto, n as readHeader, r as writeHeader } from "../serialize-E_4WyueA.js";
+//#region src/core/bitset.ts
+var BitSetRangeError = class extends RangeError {
+	name = "BitSetRangeError";
+};
+const MAX_BITS = 2 ** 32;
+var BitSet = class BitSet {
+	#bits;
+	static fromBytes(bytes) {
+		const bs = new BitSet(bytes.length * 8);
+		bs.#bits.set(bytes);
+		return bs;
+	}
+	constructor(nbits) {
+		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
+		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
+	}
+	set(i) {
+		const idx = i >>> 3;
+		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
+	}
+	get(i) {
+		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
+	}
+	get bytes() {
+		return this.#bits;
+	}
+	count() {
+		let total = 0;
+		for (let byte of this.#bits) while (byte) {
+			byte &= byte - 1;
+			total++;
+		}
+		return total;
+	}
+};
+//#endregion
+//#region src/core/sizing.ts
+/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
+function optimal(n, epsilon) {
+	const m = Math.ceil(-n * Math.log(epsilon) / (Math.LN2 * Math.LN2));
+	return {
+		m,
+		k: Math.max(1, Math.round(m / n * Math.LN2))
+	};
+}
+//#endregion
+//#region src/bloom/bloom.ts
+const TYPE = 1;
+var BloomParamMismatchError = class extends Error {
+	name = "BloomParamMismatchError";
+};
+var BloomFilter = class BloomFilter {
+	#bits;
+	#m;
+	#k;
+	#seed;
+	#scratch;
+	#n;
+	static create(n, epsilon) {
+		const f = new BloomFilter(optimal(n, epsilon));
+		f.#n = n;
+		return f;
+	}
+	static fromBytes(bytes) {
+		const { body } = readHeader(bytes);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const m = dv.getUint32(0, true);
+		const k = body[4] ?? 0;
+		const seed = dv.getUint32(5, true);
+		const f = new BloomFilter({
+			m,
+			k,
+			seed
+		});
+		f.#bits.bytes.set(body.subarray(9));
+		return f;
+	}
+	constructor({ m, k, seed = 0 }) {
+		this.#bits = new BitSet(m);
+		this.#m = m;
+		this.#k = k;
+		this.#seed = seed;
+		this.#scratch = new Uint32Array(k);
+		this.#n = Math.round(m * Math.LN2 / k);
+	}
+	/** Analytic design bits-per-key `m / n`. */
+	get bitsPerKey() {
+		return this.#m / this.#n;
+	}
+	toBytes() {
+		const payload = this.#bits.bytes;
+		const body = new Uint8Array(9 + payload.length);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		dv.setUint32(0, this.#m, true);
+		body[4] = this.#k;
+		dv.setUint32(5, this.#seed, true);
+		body.set(payload, 9);
+		return writeHeader({
+			version: 1,
+			type: TYPE,
+			flags: 0
+		}, body);
+	}
+	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;
+		const b = other.#bits.bytes;
+		const merged = new Uint8Array(a.length);
+		for (let i = 0; i < a.length; i++) merged[i] = (a[i] ?? 0) | (b[i] ?? 0);
+		const r = new BloomFilter({
+			m: this.#m,
+			k: this.#k,
+			seed: this.#seed
+		});
+		r.#bits.bytes.set(merged);
+		return r;
+	}
+	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);
+	}
+	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;
+		return true;
+	}
+};
+//#endregion
+export { BloomFilter, BloomParamMismatchError };

package/dist/bytes-DCuYtUVS.d.cts

@@ -0,0 +1,4 @@
+//#region src/core/bytes.d.ts
+type BytesLike = string | Uint8Array | ArrayBuffer;
+//#endregion
+export { BytesLike as t };

package/dist/bytes-DCuYtUVS.d.ts

@@ -0,0 +1,4 @@
+//#region src/core/bytes.d.ts
+type BytesLike = string | Uint8Array | ArrayBuffer;
+//#endregion
+export { BytesLike as t };

package/dist/fuse/index.cjs

@@ -0,0 +1,298 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serialize = require("../serialize-C5rwVPvv.cjs");
+//#region src/fuse/fuse.ts
+const ARITY = 3;
+const TYPE_FUSE8 = 3;
+const TYPE_FUSE16 = 4;
+var BinaryFuseBuildError = class extends Error {
+	name = "BinaryFuseBuildError";
+};
+let RLO = 0;
+let RHI = 0;
+function mul64(alo, ahi, blo, bhi) {
+	const a0 = alo & 65535;
+	const a1 = alo >>> 16;
+	const a2 = ahi & 65535;
+	const a3 = ahi >>> 16;
+	const b0 = blo & 65535;
+	const b1 = blo >>> 16;
+	const b2 = bhi & 65535;
+	const b3 = bhi >>> 16;
+	let c0 = a0 * b0;
+	let c1 = c0 >>> 16;
+	c0 &= 65535;
+	c1 += a1 * b0;
+	let c2 = c1 >>> 16;
+	c1 &= 65535;
+	c1 += a0 * b1;
+	c2 += c1 >>> 16;
+	c1 &= 65535;
+	c2 += a2 * b0;
+	let c3 = c2 >>> 16;
+	c2 &= 65535;
+	c2 += a1 * b1;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c2 += a0 * b2;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c3 += a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+	c3 &= 65535;
+	RLO = (c1 << 16 | c0) >>> 0;
+	RHI = (c3 << 16 | c2) >>> 0;
+}
+function fmix64(lo, hi) {
+	let l = (lo ^ hi >>> 1) >>> 0;
+	let h = hi;
+	mul64(l, h, 3981806797, 4283543511);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	mul64(l, h, 444984403, 3301882366);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	RLO = l;
+	RHI = h;
+}
+function mixSeed(lo, hi, seed) {
+	const l = (lo >>> 0) + (seed >>> 0);
+	const carry = l > 4294967295 ? 1 : 0;
+	fmix64(l >>> 0, hi + carry >>> 0);
+}
+function mulhi64(lo, hi, n) {
+	mul64(hi, 0, n, 0);
+	const aLo = RLO;
+	const aHi = RHI;
+	mul64(lo, 0, n, 0);
+	const bHi = RHI;
+	return aHi + ((aLo >>> 0) + (bHi >>> 0) > 4294967295 ? 1 : 0) >>> 0;
+}
+function positionsInto(mlo, mhi, seg, segMask, segCountLen, out) {
+	const h0 = mulhi64(mlo, mhi, segCountLen);
+	let h1 = h0 + seg >>> 0;
+	let h2 = h1 + seg >>> 0;
+	h1 = (h1 ^ (mlo >>> 18 | mhi << 14) & segMask) >>> 0;
+	h2 = (h2 ^ mlo & segMask) >>> 0;
+	out[0] = h0;
+	out[1] = h1;
+	out[2] = h2;
+}
+function fpMask(fp) {
+	return (1 << 8 * fp.BYTES_PER_ELEMENT) - 1 >>> 0;
+}
+function computeParams(size) {
+	const seg = Math.min(1 << Math.floor(Math.log(size) / Math.log(3.33) + 2.25), 1 << 18);
+	const segMask = seg - 1;
+	const sizeFactor = Math.max(1.125, .875 + .25 * Math.log(1e6) / Math.log(Math.max(size, 2)));
+	const capacity = Math.round(size * sizeFactor);
+	let segCount = Math.floor((capacity + seg - 1) / seg) - (ARITY - 1);
+	if (segCount <= 0) segCount = 1;
+	let arrayLength = (segCount + ARITY - 1) * seg;
+	segCount = Math.floor((arrayLength + seg - 1) / seg) - (ARITY - 1);
+	if (segCount <= 0) segCount = 1;
+	arrayLength = (segCount + ARITY - 1) * seg;
+	return {
+		seg,
+		segMask,
+		segCountLen: segCount * seg,
+		arrayLength
+	};
+}
+/**
+* Peel the 3-hypergraph and assign fingerprints so every key's XOR of its 3
+* lanes equals its fingerprint. Retries with a bumped seed on a stall; returns
+* the seed that succeeded.
+*/
+function buildFingerprints(fp, hashes, params, maxAttempts = 100) {
+	const size = hashes.length / 2;
+	const { seg, segMask, segCountLen, arrayLength } = params;
+	const mask = fpMask(fp);
+	const counts = new Uint32Array(arrayLength);
+	const xorLo = new Uint32Array(arrayLength);
+	const xorHi = new Uint32Array(arrayLength);
+	const orderLo = new Uint32Array(size);
+	const orderHi = new Uint32Array(size);
+	const orderIdx = new Uint32Array(size);
+	const pos = /* @__PURE__ */ new Uint32Array(3);
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const seed = attempt;
+		counts.fill(0);
+		xorLo.fill(0);
+		xorHi.fill(0);
+		for (let i = 0; i < size; i++) {
+			mixSeed(hashes[2 * i] ?? 0, hashes[2 * i + 1] ?? 0, seed);
+			const mlo = RLO;
+			const mhi = RHI;
+			positionsInto(mlo, mhi, seg, segMask, segCountLen, pos);
+			for (let j = 0; j < 3; j++) {
+				const p = pos[j] ?? 0;
+				counts[p] = (counts[p] ?? 0) + 1;
+				xorLo[p] = (xorLo[p] ?? 0) ^ mlo;
+				xorHi[p] = (xorHi[p] ?? 0) ^ mhi;
+			}
+		}
+		const queue = [];
+		for (let idx = 0; idx < arrayLength; idx++) if ((counts[idx] ?? 0) === 1) queue.push(idx);
+		let processed = 0;
+		while (queue.length > 0) {
+			const idx = queue.pop();
+			if (idx === void 0) break;
+			if ((counts[idx] ?? 0) !== 1) continue;
+			const mlo = xorLo[idx] ?? 0;
+			const mhi = xorHi[idx] ?? 0;
+			orderLo[processed] = mlo;
+			orderHi[processed] = mhi;
+			orderIdx[processed] = idx;
+			processed++;
+			positionsInto(mlo, mhi, seg, segMask, segCountLen, pos);
+			for (let j = 0; j < 3; j++) {
+				const p = pos[j] ?? 0;
+				counts[p] = (counts[p] ?? 0) - 1;
+				xorLo[p] = (xorLo[p] ?? 0) ^ mlo;
+				xorHi[p] = (xorHi[p] ?? 0) ^ mhi;
+				if ((counts[p] ?? 0) === 1) queue.push(p);
+			}
+		}
+		if (processed === size) {
+			fp.fill(0);
+			for (let i = processed - 1; i >= 0; i--) {
+				const mlo = orderLo[i] ?? 0;
+				const mhi = orderHi[i] ?? 0;
+				const idx = orderIdx[i] ?? 0;
+				positionsInto(mlo, mhi, seg, segMask, segCountLen, pos);
+				const p0 = pos[0] ?? 0;
+				const p1 = pos[1] ?? 0;
+				const p2 = pos[2] ?? 0;
+				fp[idx] = ((mlo ^ mhi) & mask ^ (fp[p0] ?? 0) ^ (fp[p1] ?? 0) ^ (fp[p2] ?? 0)) & mask;
+			}
+			return seed;
+		}
+	}
+	throw new BinaryFuseBuildError("binary fuse construction failed");
+}
+function buildState(keys, alloc) {
+	const hashList = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of keys) {
+		const { h1lo, h1hi } = require_serialize.hash128(require_serialize.normalize(key), 0);
+		const lo = h1lo >>> 0;
+		const hi = h1hi >>> 0;
+		const id = `${String(lo)},${String(hi)}`;
+		if (seen.has(id)) continue;
+		seen.add(id);
+		hashList.push(lo, hi);
+	}
+	const size = hashList.length / 2;
+	const params = computeParams(size);
+	if (size === 0) return {
+		fp: alloc(0),
+		seed: 0,
+		params,
+		size: 0
+	};
+	const hashes = Uint32Array.from(hashList);
+	const fp = alloc(params.arrayLength);
+	return {
+		fp,
+		seed: buildFingerprints(fp, hashes, params),
+		params,
+		size
+	};
+}
+function fuseStateFromBytes(bytes, expectedType) {
+	const { type, body } = require_serialize.readHeader(bytes);
+	if (type !== expectedType) throw new require_serialize.SerializationError(`expected AMQF type ${String(expectedType)}, got ${String(type)}`);
+	const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+	const seed = dv.getUint32(0, true);
+	const seg = dv.getUint32(4, true);
+	const segCountLen = dv.getUint32(8, true);
+	const size = dv.getUint32(12, true);
+	const laneBytes = body.subarray(16);
+	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
+	const arrayLength = laneBytes.length / bpe;
+	const fp = bpe === 1 ? new Uint8Array(arrayLength) : new Uint16Array(arrayLength);
+	new Uint8Array(fp.buffer).set(laneBytes);
+	return {
+		fp,
+		seed,
+		params: {
+			seg,
+			segMask: seg - 1,
+			segCountLen,
+			arrayLength
+		},
+		size
+	};
+}
+var BinaryFuse = class {
+	#fp;
+	#seed;
+	#seg;
+	#segMask;
+	#segCountLen;
+	#size;
+	#pos = /* @__PURE__ */ new Uint32Array(3);
+	constructor(state) {
+		this.#fp = state.fp;
+		this.#seed = state.seed;
+		this.#seg = state.params.seg;
+		this.#segMask = state.params.segMask;
+		this.#segCountLen = state.params.segCountLen;
+		this.#size = state.size;
+	}
+	get size() {
+		return this.#size;
+	}
+	get bitsPerKey() {
+		return this.#size === 0 ? 0 : this.#fp.byteLength * 8 / this.#size;
+	}
+	toBytes() {
+		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
+		const body = new Uint8Array(16 + laneBytes.length);
+		const dv = new DataView(body.buffer);
+		dv.setUint32(0, this.#seed, true);
+		dv.setUint32(4, this.#seg, true);
+		dv.setUint32(8, this.#segCountLen, true);
+		dv.setUint32(12, this.#size, true);
+		body.set(laneBytes, 16);
+		return require_serialize.writeHeader({
+			version: 1,
+			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
+			flags: 0
+		}, body);
+	}
+	has(key) {
+		if (this.#fp.length === 0) return false;
+		const { h1lo, h1hi } = require_serialize.hash128(require_serialize.normalize(key), 0);
+		mixSeed(h1lo >>> 0, h1hi >>> 0, this.#seed);
+		const mlo = RLO;
+		const mhi = RHI;
+		positionsInto(mlo, mhi, this.#seg, this.#segMask, this.#segCountLen, this.#pos);
+		const mask = fpMask(this.#fp);
+		const p0 = this.#pos[0] ?? 0;
+		const p1 = this.#pos[1] ?? 0;
+		const p2 = this.#pos[2] ?? 0;
+		return ((mlo ^ mhi) & mask) === (((this.#fp[p0] ?? 0) ^ (this.#fp[p1] ?? 0) ^ (this.#fp[p2] ?? 0)) & mask);
+	}
+};
+var BinaryFuse8 = class BinaryFuse8 extends BinaryFuse {
+	static from(keys) {
+		return new BinaryFuse8(buildState(keys, (n) => new Uint8Array(n)));
+	}
+	static fromBytes(bytes) {
+		return new BinaryFuse8(fuseStateFromBytes(bytes, TYPE_FUSE8));
+	}
+};
+var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
+	static from(keys) {
+		return new BinaryFuse16(buildState(keys, (n) => new Uint16Array(n)));
+	}
+	static fromBytes(bytes) {
+		return new BinaryFuse16(fuseStateFromBytes(bytes, TYPE_FUSE16));
+	}
+};
+//#endregion
+exports.BinaryFuse16 = BinaryFuse16;
+exports.BinaryFuse8 = BinaryFuse8;
+exports.BinaryFuseBuildError = BinaryFuseBuildError;

package/dist/fuse/index.d.cts

@@ -0,0 +1,35 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
+//#region src/fuse/fuse.d.ts
+declare class BinaryFuseBuildError extends Error {
+  override readonly name = "BinaryFuseBuildError";
+}
+interface FuseParams {
+  seg: number;
+  segMask: number;
+  segCountLen: number;
+  arrayLength: number;
+}
+interface FuseState {
+  fp: Uint8Array | Uint16Array;
+  seed: number;
+  params: FuseParams;
+  size: number;
+}
+declare abstract class BinaryFuse {
+  #private;
+  protected constructor(state: FuseState);
+  get size(): number;
+  get bitsPerKey(): number;
+  toBytes(): Uint8Array;
+  has(key: BytesLike): boolean;
+}
+declare class BinaryFuse8 extends BinaryFuse {
+  static from(keys: Iterable<BytesLike>): BinaryFuse8;
+  static fromBytes(bytes: Uint8Array): BinaryFuse8;
+}
+declare class BinaryFuse16 extends BinaryFuse {
+  static from(keys: Iterable<BytesLike>): BinaryFuse16;
+  static fromBytes(bytes: Uint8Array): BinaryFuse16;
+}
+//#endregion
+export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError };

package/dist/fuse/index.d.ts

@@ -0,0 +1,35 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+//#region src/fuse/fuse.d.ts
+declare class BinaryFuseBuildError extends Error {
+  override readonly name = "BinaryFuseBuildError";
+}
+interface FuseParams {
+  seg: number;
+  segMask: number;
+  segCountLen: number;
+  arrayLength: number;
+}
+interface FuseState {
+  fp: Uint8Array | Uint16Array;
+  seed: number;
+  params: FuseParams;
+  size: number;
+}
+declare abstract class BinaryFuse {
+  #private;
+  protected constructor(state: FuseState);
+  get size(): number;
+  get bitsPerKey(): number;
+  toBytes(): Uint8Array;
+  has(key: BytesLike): boolean;
+}
+declare class BinaryFuse8 extends BinaryFuse {
+  static from(keys: Iterable<BytesLike>): BinaryFuse8;
+  static fromBytes(bytes: Uint8Array): BinaryFuse8;
+}
+declare class BinaryFuse16 extends BinaryFuse {
+  static from(keys: Iterable<BytesLike>): BinaryFuse16;
+  static fromBytes(bytes: Uint8Array): BinaryFuse16;
+}
+//#endregion
+export { BinaryFuse16, BinaryFuse8, BinaryFuseBuildError };