@voltro/runtime 0.85.0 → 0.87.0

package/dist/finopsAccountant.js

@@ -0,0 +1,216 @@
+//#region src/finopsAccountant.ts
+var e = class {
+	total = 0;
+	byUnit = /* @__PURE__ */ new Map();
+	bySubscription = /* @__PURE__ */ new Map();
+	lastUpdatedAt = null;
+	add(e, t, n) {
+		this.total += t, this.byUnit.set(e.unit, (this.byUnit.get(e.unit) ?? 0) + t);
+		let r = e.subscriptionId;
+		r != null && r.length > 0 && this.bySubscription.set(r, (this.bySubscription.get(r) ?? 0) + t), this.lastUpdatedAt = e.at ?? n;
+	}
+	state(e) {
+		return {
+			tenantId: e,
+			total: this.total,
+			byUnit: Object.fromEntries(this.byUnit),
+			bySubscription: Object.fromEntries(this.bySubscription),
+			lastUpdatedAt: this.lastUpdatedAt
+		};
+	}
+}, t = {
+	ok: 0,
+	warn: 1,
+	exceeded: 2
+}, n = class {
+	def;
+	tenantId;
+	spent = 0;
+	windowStart = null;
+	status = "ok";
+	since = null;
+	lastUpdatedAt = null;
+	lastCause = null;
+	constructor(e, t) {
+		this.def = e, this.tenantId = t;
+	}
+	get warnThreshold() {
+		return this.def.warnAt * this.def.limit;
+	}
+	statusOf(e) {
+		return e >= this.def.limit ? "exceeded" : e >= this.warnThreshold ? "warn" : "ok";
+	}
+	rollWindow(e) {
+		if (this.def.windowMs === null) return null;
+		if (this.windowStart === null) return this.windowStart = e, null;
+		let t = e - this.windowStart;
+		return t < this.def.windowMs ? null : (this.windowStart = e - t % this.def.windowMs, this.spent = 0, this.settle("ok", e, null));
+	}
+	settle(e, n, r) {
+		let i = this.status;
+		return e === i ? null : (this.status = e, this.since = n, t[e] > t[i] ? (this.lastCause = r, {
+			kind: e === "exceeded" ? "exceeded" : "warn",
+			state: this.state(),
+			cause: r
+		}) : {
+			kind: "recovered",
+			state: this.state(),
+			cause: null
+		});
+	}
+	apply(e, t, n) {
+		let i = [], a = this.rollWindow(n);
+		a !== null && i.push(a), this.spent += t, this.lastUpdatedAt = e.at ?? n;
+		let o = this.settle(this.statusOf(this.spent), n, r(e));
+		return o !== null && i.push(o), i;
+	}
+	tick(e) {
+		return this.rollWindow(e);
+	}
+	reset(e) {
+		return this.spent = 0, this.windowStart = this.def.windowMs === null ? null : e, this.lastUpdatedAt = e, this.settle("ok", e, null);
+	}
+	state() {
+		return {
+			budget: this.def.name,
+			tenantId: this.tenantId,
+			status: this.status,
+			severity: this.def.severity,
+			onExceeded: this.def.onExceeded,
+			spent: this.spent,
+			limit: this.def.limit,
+			warnThreshold: this.warnThreshold,
+			unit: this.def.unit,
+			windowStartedAt: this.windowStart,
+			since: this.since,
+			lastUpdatedAt: this.lastUpdatedAt,
+			lastCause: this.lastCause,
+			...this.def.description === void 0 ? {} : { description: this.def.description }
+		};
+	}
+}, r = (e) => ({
+	unit: e.unit,
+	subscriptionId: e.subscriptionId ?? null,
+	procedure: e.procedure ?? null,
+	traceId: e.traceId ?? null
+}), i = (e) => Number.isFinite(e) && e > 0 ? e : 0, a = class {
+	now;
+	attribution = /* @__PURE__ */ new Map();
+	counters = /* @__PURE__ */ new Map();
+	budgetsByName = /* @__PURE__ */ new Map();
+	totalBudgets = [];
+	unitBudgets = /* @__PURE__ */ new Map();
+	constructor(e, t = {}) {
+		this.now = t.now ?? Date.now;
+		for (let t of e) {
+			if (this.budgetsByName.has(t.name)) throw Error(`cost budget: duplicate name '${t.name}' — names must be unique across all cost budgets`);
+			if (this.budgetsByName.set(t.name, t), this.counters.set(t.name, /* @__PURE__ */ new Map()), t.unit === null) this.totalBudgets.push(t);
+			else {
+				let e = this.unitBudgets.get(t.unit) ?? [];
+				e.push(t), this.unitBudgets.set(t.unit, e);
+			}
+		}
+	}
+	counterFor(e, t) {
+		let r = this.counters.get(e.name), i = r.get(t);
+		return i === void 0 && (i = new n(e, t), r.set(t, i)), i;
+	}
+	record(t) {
+		let n = i(t.amount);
+		if (n === 0) return [];
+		let r = t.at ?? this.now(), a = this.attribution.get(t.tenantId);
+		a === void 0 && (a = new e(), this.attribution.set(t.tenantId, a)), a.add(t, n, r);
+		let o = this.unitBudgets.get(t.unit);
+		if (this.totalBudgets.length === 0 && o === void 0) return [];
+		let s = [];
+		for (let e of this.totalBudgets) s.push(...this.counterFor(e, t.tenantId).apply(t, n, r));
+		if (o !== void 0) for (let e of o) s.push(...this.counterFor(e, t.tenantId).apply(t, n, r));
+		return s;
+	}
+	tick() {
+		let e = this.now(), t = [];
+		for (let n of this.budgetsByName.values()) if (n.windowMs !== null) for (let r of this.counters.get(n.name).values()) {
+			let n = r.tick(e);
+			n !== null && t.push(n);
+		}
+		return t;
+	}
+	reset(e) {
+		let t = this.now(), n = [], r = (e) => {
+			this.attribution.delete(e);
+			for (let r of this.counters.values()) {
+				let i = r.get(e);
+				if (i !== void 0) {
+					let e = i.reset(t);
+					e !== null && n.push(e);
+				}
+			}
+		};
+		if (e === void 0) for (let e of /* @__PURE__ */ new Set([...this.attribution.keys(), ...this.allCounterTenants()])) r(e);
+		else r(e);
+		return n;
+	}
+	allCounterTenants() {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of this.counters.values()) for (let n of t.keys()) e.add(n);
+		return e;
+	}
+	attributionSnapshot() {
+		let e = Array(this.attribution.size), t = 0;
+		return this.attribution.forEach((n, r) => {
+			e[t++] = n.state(r);
+		}), e;
+	}
+	tenantState(e) {
+		return this.attribution.get(e)?.state(e) ?? null;
+	}
+	budgetStates() {
+		let e = [];
+		for (let t of this.counters.values()) for (let n of t.values()) e.push(n.state());
+		return e;
+	}
+	budgetState(e, t) {
+		return this.counters.get(e)?.get(t)?.state() ?? null;
+	}
+	breaches() {
+		return this.budgetStates().filter((e) => e.status !== "ok");
+	}
+}, o = (e) => {
+	let t = e.now ?? Date.now, n = e.log, r = /* @__PURE__ */ new Set(), i = e.discovered.map((e) => e.definition), o = new a(i, {
+		now: t,
+		...n === void 0 ? {} : { log: n }
+	}), s = i.some((e) => e.windowMs !== null), c = (e) => {
+		for (let t of e) for (let e of r) try {
+			e(t);
+		} catch (e) {
+			n.warn("finops: budget signal listener threw", { budget: t.state.budget }, e);
+		}
+	}, l = (e) => {
+		try {
+			c(o.record(e));
+		} catch (t) {
+			n.warn("finops: cost record failed", { unit: e.unit }, t);
+		}
+	}, u = () => {
+		s && c(o.tick());
+	}, d = null;
+	return s && (d = setInterval(u, e.tickIntervalMs ?? 3e4), d.unref?.()), {
+		registry: {
+			attribution: () => o.attributionSnapshot(),
+			tenant: (e) => o.tenantState(e),
+			budgets: () => o.budgetStates(),
+			budget: (e, t) => o.budgetState(e, t),
+			breaches: () => o.breaches(),
+			subscribe: (e) => (r.add(e), () => r.delete(e))
+		},
+		record: l,
+		reset: (e) => c(o.reset(e)),
+		detach: () => {
+			d !== null && clearInterval(d), r.clear();
+		},
+		registered: i.map((e) => e.name),
+		runTick: u
+	};
+};
+//#endregion
+export { a as CostAccountant, o as attachFinops };

package/dist/handlerBody.js

@@ -0,0 +1,8 @@
+import { Effect as e } from "effect";
+//#region src/handlerBody.ts
+function t(t, n) {
+	if (e.isEffect(t)) return n ? n(t) : e.runPromise(t);
+	if (t instanceof Promise) return t;
+}
+//#endregion
+export { t as settleHandlerBody };

package/dist/healthProbes.js

@@ -0,0 +1,55 @@
+//#region src/healthProbes.ts
+var e = "/internal", t = (t, n) => ({
+	path: (t?.path ?? e).replace(/\/+$/, "") || e,
+	liveness: t?.liveness ?? (() => !0),
+	readiness: t?.readiness ?? n
+}), n = (e, t) => {
+	if (!t.startsWith(`${e.path}/`)) return;
+	let n = t.slice(e.path.length + 1);
+	return n === "liveness" || n === "readiness" || n === "startup" ? n : void 0;
+}, r = async (e, t, n) => {
+	if (t === "liveness") try {
+		return await e.liveness() ? {
+			status: 200,
+			body: "ok",
+			contentType: "text/plain"
+		} : {
+			status: 503,
+			body: "not-live",
+			contentType: "text/plain"
+		};
+	} catch {
+		return {
+			status: 503,
+			body: "not-live",
+			contentType: "text/plain"
+		};
+	}
+	if (t === "startup" && n !== void 0) {
+		let e = n();
+		return {
+			status: e.ready ? 200 : 503,
+			body: JSON.stringify(e),
+			contentType: "application/json"
+		};
+	}
+	try {
+		return await e.readiness() ? {
+			status: 200,
+			body: "ready",
+			contentType: "text/plain"
+		} : {
+			status: 503,
+			body: "not-ready",
+			contentType: "text/plain"
+		};
+	} catch {
+		return {
+			status: 503,
+			body: "not-ready",
+			contentType: "text/plain"
+		};
+	}
+};
+//#endregion
+export { r as answerProbe, n as probeFor, t as resolveHealth };

package/dist/hot.d.ts

@@ -0,0 +1,56 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
+import { DialectId } from '@voltro/database';
+import { FieldDefinitions } from '@voltro/database';
+import { HotStoreShape } from '@voltro/kv/hot/contract';
+import { Table } from '@voltro/database';
+
+/** Small-deployment SQL backend. One database lock serializes complete batches.
+ * The lock row contains no application key, tenant identity or payload. All
+ * application rows, including sorted members, are physically removed on delete.
+ * SQL stores own transaction retries; callbacks perform no external side effects.
+ */
+export declare const dataStoreHotStore: (store: DataStore, options: HotDataStoreOptions) => HotStoreShape;
+
+export declare interface HotDataStoreOptions {
+    /** Actual SQL dialect: SQLite-family writer admission differs from row locks. */
+    readonly dialect: DialectId;
+    readonly namespace: string;
+    /** Trusted server/test time, sampled after acquiring the transaction lock. */
+    readonly now?: () => number;
+}
+
+export declare const hotDataStoreTables: readonly [ Table<"_voltro_hot_kv", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly namespace: ColumnBuilder<string | null, "text", boolean>;
+    readonly key: ColumnBuilder<string | null, "text", boolean>;
+    readonly payload: ColumnBuilder<string | null, "text", boolean>;
+    readonly expiresAtMs: ColumnBuilder<number | null, "real", boolean>;
+}>, false, never>, Table<"_voltro_hot_z", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly memberHash: ColumnBuilder<string, "text", boolean>;
+    readonly member: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<number, "real", boolean>;
+}>, false, never>];
+
+/** Activated with the database HotStore; importing definitions performs no I/O. */
+export declare const hotKvTable: Table<"_voltro_hot_kv", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly namespace: ColumnBuilder<string | null, "text", boolean>;
+    readonly key: ColumnBuilder<string | null, "text", boolean>;
+    readonly payload: ColumnBuilder<string | null, "text", boolean>;
+    readonly expiresAtMs: ColumnBuilder<number | null, "real", boolean>;
+}>, false, never>;
+
+export declare const hotZTable: Table<"_voltro_hot_z", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly keyHash: ColumnBuilder<string, "text", boolean>;
+    readonly memberHash: ColumnBuilder<string, "text", boolean>;
+    readonly member: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<number, "real", boolean>;
+}>, false, never>;
+
+export { }

package/dist/hot.js

@@ -0,0 +1,3 @@
+import { hotDataStoreTables as e, hotKvTable as t, hotZTable as n } from "./hotDataStoreTables.js";
+import { dataStoreHotStore as r } from "./hotDataStore.js";
+export { r as dataStoreHotStore, e as hotDataStoreTables, t as hotKvTable, n as hotZTable };

package/dist/hotDataStore.js

@@ -0,0 +1,148 @@
+import { decodeHotSnapshot as e, encodeHotSnapshot as t } from "./hotDataStoreSnapshot.js";
+import { hotKvTable as n, hotZTable as r } from "./hotDataStoreTables.js";
+import { Effect as i, Stream as a } from "effect";
+import { and as o, eq as s, generateId as c, gt as l, isNull as u, isSqliteFamily as d, or as f, queryFor as p, startsWith as m } from "@voltro/database";
+import { createHash as h } from "node:crypto";
+import { HotError as g, applyHotOperations as _, compareHotMembers as v, hotStoreFromRunner as y, validateHotOp as b } from "@voltro/kv/hot/contract";
+//#region src/hotDataStore.ts
+var x = n.tableName, S = r.tableName, C = "lock", w = (e) => h("sha256").update(e).digest("hex"), T = (h, T) => {
+	let { namespace: E } = T;
+	if (!E || !E.isWellFormed() || /[{}]/.test(E)) throw new g({
+		operation: "connect",
+		key: "",
+		reason: "invalid"
+	});
+	let D = T.now ?? Date.now, O = (e) => w(JSON.stringify([E, e])), k, A = () => k ??= h.transactional(async (e) => {
+		let t = {
+			id: c({
+				kind: "typeid",
+				prefix: "hot"
+			}, x),
+			keyHash: C,
+			namespace: null,
+			key: null,
+			payload: null,
+			expiresAtMs: null
+		};
+		T.dialect === "mssql" ? await e.upsert(x, t, {
+			conflictColumns: ["keyHash"],
+			update: []
+		}) : await e.insertIgnore(x, t, { conflictColumns: ["keyHash"] });
+	}).catch((e) => {
+		throw k = void 0, e;
+	}), j = async (t, i) => {
+		let a = O(i), o = (await t.query(p(n).where(s("keyHash", a)).descriptor))[0];
+		if (o === void 0) return;
+		if (o.namespace !== E || o.key !== i || typeof o.payload != "string") throw new g({
+			operation: "read",
+			key: i,
+			reason: "unavailable"
+		});
+		let c = o.expiresAtMs;
+		if (c !== null && (typeof c != "number" || !Number.isFinite(c))) throw new g({
+			operation: "read",
+			key: i,
+			reason: "unavailable"
+		});
+		let l = await t.query(p(r).where(s("keyHash", a)).descriptor), u = [];
+		for (let e of l) {
+			let t = e.member, n = e.score;
+			if (typeof t != "string" || typeof n != "number" || !Number.isFinite(n)) throw new g({
+				operation: "read",
+				key: i,
+				reason: "unavailable"
+			});
+			u.push([t, n]);
+		}
+		return e(o.payload, c === null ? Infinity : c, u);
+	}, M = async (e, n, r) => {
+		let i = O(n);
+		if (await e.deleteMany(S, { where: s("keyHash", i) }), r === void 0) await e.deleteMany(x, { where: s("keyHash", i) });
+		else if (await e.upsert(x, {
+			id: c({
+				kind: "typeid",
+				prefix: "hot"
+			}, x),
+			keyHash: i,
+			namespace: E,
+			key: n,
+			payload: t(r),
+			expiresAtMs: r.expiresAt === Infinity ? null : r.expiresAt
+		}, {
+			conflictColumns: ["keyHash"],
+			update: [
+				"namespace",
+				"key",
+				"payload",
+				"expiresAtMs"
+			]
+		}), r.kind === "z") for (let [t, n] of r.values) await e.insert(S, {
+			id: c({
+				kind: "typeid",
+				prefix: "hotz"
+			}, S),
+			keyHash: i,
+			memberHash: w(t),
+			member: t,
+			score: n
+		});
+	};
+	return y((e) => i.try({
+		try: () => {
+			e.forEach(b);
+		},
+		catch: (e) => e instanceof g ? e : new g({
+			operation: "multi",
+			key: "",
+			reason: "invalid"
+		})
+	}).pipe(i.flatMap(() => i.tryPromise({
+		try: async () => e.length === 0 ? [] : (await A(), h.transactional(async (t) => {
+			if (d(T.dialect) && await t.updateMany(x, { payload: null }, { where: s("keyHash", C) }), (await t.query(p(n).where(s("keyHash", C)).forUpdate().descriptor)).length !== 1) throw new g({
+				operation: "multi",
+				key: "",
+				reason: "unavailable"
+			});
+			let r = D();
+			if (!Number.isFinite(r)) throw new g({
+				operation: "multi",
+				key: "",
+				reason: "invalid"
+			});
+			let i = /* @__PURE__ */ new Map(), a = [...new Set(e.map((e) => e.key))];
+			for (let e of a) {
+				let n = await j(t, e);
+				n !== void 0 && i.set(e, n);
+			}
+			let o = new Map(i), c = _(i, e, r);
+			for (let e of a) i.get(e) !== o.get(e) && await M(t, e, i.get(e));
+			return c;
+		})),
+		catch: (e) => e instanceof g ? e : new g({
+			operation: "multi",
+			key: "",
+			reason: "unavailable"
+		})
+	}))), (e) => a.unwrap(i.tryPromise({
+		try: async () => {
+			if (!e.isWellFormed()) throw new g({
+				operation: "scanPrefix",
+				key: e,
+				reason: "invalid"
+			});
+			let t = D(), r = (await h.query(p(n).where(o(s("namespace", E), m("key", e), f(u("expiresAtMs"), l("expiresAtMs", t)))).descriptor)).flatMap((t) => t.namespace === E && typeof t.key == "string" && t.key.startsWith(e) && typeof t.payload == "string" ? [t.key] : []);
+			return a.fromIterable(r.sort(v));
+		},
+		catch: (t) => t instanceof g ? t : new g({
+			operation: "scanPrefix",
+			key: e,
+			reason: "unavailable"
+		})
+	})), {
+		atomicMulti: !0,
+		crossNode: !0,
+		persistent: !0
+	});
+};
+//#endregion
+export { T as dataStoreHotStore };

package/dist/hotDataStoreSnapshot.js

@@ -0,0 +1,98 @@
+import { Schema as e } from "effect";
+//#region src/hotDataStoreSnapshot.ts
+var t = e.Number.pipe(e.check(e.makeFilter(Number.isFinite))), n = e.Union([
+	e.Struct({
+		kind: e.Literal("fixed"),
+		windowStart: t,
+		count: t
+	}),
+	e.Struct({
+		kind: e.Literal("sliding"),
+		currStart: t,
+		currCount: t,
+		prevCount: t
+	}),
+	e.Struct({
+		kind: e.Literal("token"),
+		tokens: t,
+		lastRefill: t
+	})
+]), r = e.Union([
+	e.Struct({ kind: e.Literal("z") }),
+	e.Struct({
+		kind: e.Literal("h"),
+		values: e.Array(e.Tuple([e.String, e.String]))
+	}),
+	e.Struct({
+		kind: e.Literal("s"),
+		values: e.Array(e.String)
+	}),
+	e.Struct({
+		kind: e.Literal("counter"),
+		value: t
+	}),
+	e.Struct({
+		kind: e.Literal("lease"),
+		value: e.String
+	}),
+	e.Struct({
+		kind: e.Literal("bucket"),
+		tokens: t,
+		updatedAt: t
+	}),
+	e.Struct({
+		kind: e.Literal("rateLimit"),
+		state: n
+	})
+]), i = e.decodeUnknownSync(r), a = (e) => {
+	switch (e.kind) {
+		case "z": return JSON.stringify({ kind: "z" });
+		case "h":
+		case "s": return JSON.stringify({
+			kind: e.kind,
+			values: [...e.values]
+		});
+		case "counter": return JSON.stringify({
+			kind: e.kind,
+			value: e.value
+		});
+		case "lease": return JSON.stringify({
+			kind: e.kind,
+			value: e.value
+		});
+		case "bucket": return JSON.stringify({
+			kind: e.kind,
+			tokens: e.tokens,
+			updatedAt: e.updatedAt
+		});
+		case "rateLimit": return JSON.stringify({
+			kind: e.kind,
+			state: e.state
+		});
+	}
+}, o = (e, t, n) => {
+	let r = i(JSON.parse(e));
+	switch (r.kind) {
+		case "z": return {
+			kind: "z",
+			values: new Map(n),
+			expiresAt: t
+		};
+		case "h": return {
+			kind: "h",
+			values: new Map(r.values),
+			expiresAt: t
+		};
+		case "s": return {
+			kind: "s",
+			values: new Set(r.values),
+			expiresAt: t
+		};
+		default: return {
+			...r,
+			expiresAt: t
+		};
+	}
+};
+//#endregion
+export { o as decodeHotSnapshot, a as encodeHotSnapshot };

package/dist/hotDataStoreTables.js

@@ -0,0 +1,18 @@
+import { id as e, real as t, table as n, text as r } from "@voltro/database";
+//#region src/hotDataStoreTables.ts
+var i = n("_voltro_hot_kv", {
+	id: e({ prefix: "hot" }),
+	keyHash: r().maxLength(64),
+	namespace: r().nullable(),
+	key: r().nullable(),
+	payload: r().nullable(),
+	expiresAtMs: t().nullable()
+}).unique("hotKeyHash", ["keyHash"]).index(["expiresAtMs"]).nonReactive(), a = n("_voltro_hot_z", {
+	id: e({ prefix: "hotz" }),
+	keyHash: r().maxLength(64),
+	memberHash: r().maxLength(64),
+	member: r(),
+	score: t()
+}).unique("hotMemberHash", ["keyHash", "memberHash"]).index(["keyHash", "score"]).nonReactive(), o = [i, a];
+//#endregion
+export { o as hotDataStoreTables, i as hotKvTable, a as hotZTable };

package/dist/http-range.d.ts

@@ -0,0 +1,53 @@
+/** The outcome of a `Range` header against a representation of `size` bytes. */
+export declare type ByteRangeRequest = 
+/** Absent, malformed, another unit, or several ranges: serve the whole thing. */
+    {
+    readonly _tag: 'ignored';
+}
+/** Syntactically valid, but no byte of it exists: 416 `bytes *\/size`. */
+| {
+    readonly _tag: 'unsatisfiable';
+}
+/** Serve bytes `start..end`, both inclusive: 206 `bytes start-end/size`. */
+| {
+    readonly _tag: 'satisfiable';
+    readonly start: number;
+    readonly end: number;
+};
+
+/**
+ * RFC 9110 §13.1.5: may a `Range` be honoured given this `If-Range`?
+ *
+ * `true` when there is no `If-Range`, or when it names the current
+ * representation by a STRONG validator: an identical strong entity tag, or
+ * the exact `Last-Modified` second — and only once that second is over
+ * (`nowMs`), because a file written twice within one second would otherwise
+ * keep a date that no longer names its bytes. A weak tag, an unparsable
+ * value, or a validator the representation does not have never matches: the
+ * client then gets the whole representation, never bytes of a different one.
+ */
+export declare const ifRangeAllowsRange: (ifRange: string | undefined, current: RangeValidators, nowMs?: number) => boolean;
+
+/**
+ * Resolve a `Range` header against a representation of `size` bytes
+ * (a non-negative safe integer, normally from `stat`).
+ */
+export declare const parseByteRange: (header: string | undefined, size: number) => ByteRangeRequest;
+
+/**
+ * An HTTP-date (RFC 9110 §5.6.7) in epoch milliseconds, `undefined` when the
+ * value is none. All three historical forms are accepted. asctime carries no
+ * zone and HTTP dates are always GMT, so it is read as GMT — `Date.parse`
+ * alone would read it in the server's local time zone.
+ */
+export declare const parseHttpDate: (value: string) => number | undefined;
+
+/** The current validators of the representation a range would be cut from. */
+export declare interface RangeValidators {
+    /** The representation's entity tag as sent in `ETag`, quotes included. */
+    readonly etag?: string | undefined;
+    /** Last modification time in epoch milliseconds (as sent in `Last-Modified`). */
+    readonly lastModifiedMs?: number | undefined;
+}
+
+export { }