@voltro/runtime 0.86.0 → 0.87.0

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 { }

package/dist/http-range.js

@@ -0,0 +1,52 @@
+//#region src/httpRange.ts
+var e = { _tag: "ignored" }, t = { _tag: "unsatisfiable" }, n = /^([!#$%&'*+.^_`|~0-9A-Za-z-]+)=(.*)$/s, r = /^(\d*)-(\d*)$/, i = (e) => {
+	let t = e.replace(/^0+(?=\d)/, "");
+	if (t.length > 16) return;
+	let n = Number(t);
+	return Number.isSafeInteger(n) ? n : void 0;
+}, a = (e, t) => {
+	let n = e.replace(/^0+(?=\d)/, ""), r = t.replace(/^0+(?=\d)/, "");
+	return n.length === r.length ? n < r : n.length < r.length;
+}, o = (o, s) => {
+	if (o === void 0) return e;
+	let c = n.exec(o.trim());
+	if (c === null || c[1].toLowerCase() !== "bytes") return e;
+	let l = c[2].split(",").map((e) => e.trim()).filter((e) => e !== "");
+	if (l.length !== 1) return e;
+	let u = r.exec(l[0]);
+	if (u === null) return e;
+	let [, d = "", f = ""] = u;
+	if (d === "") {
+		if (f === "") return e;
+		let n = i(f);
+		return n === 0 || s === 0 ? t : {
+			_tag: "satisfiable",
+			start: n === void 0 ? 0 : Math.max(0, s - n),
+			end: s - 1
+		};
+	}
+	if (f !== "" && a(f, d)) return e;
+	let p = i(d);
+	if (p === void 0 || p >= s) return t;
+	let m = f === "" ? void 0 : i(f);
+	return {
+		_tag: "satisfiable",
+		start: p,
+		end: m === void 0 ? s - 1 : Math.min(m, s - 1)
+	};
+}, s = /^(W\/)?"[\x21\x23-\x7e\x80-\xff]*"$/, c = /^[A-Za-z]{3}/, l = (e) => {
+	let t = e.trim();
+	if (!c.test(t)) return;
+	let n = Date.parse(/(?:GMT|UTC)$/i.test(t) ? t : `${t} GMT`);
+	return Number.isNaN(n) ? void 0 : n;
+}, u = (e, t, n = Date.now()) => {
+	if (e === void 0) return !0;
+	let r = e.trim();
+	if (r.startsWith("\"") || r.startsWith("W/")) return !s.test(r) || r.startsWith("W/") ? !1 : t.etag !== void 0 && !t.etag.startsWith("W/") && t.etag === r;
+	let i = l(r);
+	if (i === void 0 || t.lastModifiedMs === void 0) return !1;
+	let a = Math.floor(t.lastModifiedMs / 1e3);
+	return a * 1e3 === i && Math.floor(n / 1e3) > a;
+};
+//#endregion
+export { u as ifRangeAllowsRange, o as parseByteRange, l as parseHttpDate };

package/dist/httpClientSsrf.js

@@ -1,49 +1,24 @@
 import { Effect as e, Layer as t } from "effect";
-import { HttpClient as n, HttpClientError as r } from "effect/http";
+import { ssrfReason as n, ssrfReason as r } from "@voltro/protocol";
+import { HttpClient as i, HttpClientError as a } from "effect/http";
 //#region src/httpClientSsrf.ts
-var i = class extends Error {
+var o = class extends Error {
 	url;
 	reason;
 	_tag = "SsrfBlockedError";
 	constructor(e, t) {
 		super(`SSRF: blocked outbound request to ${e} — ${t}. If this target is intentional, add its host to \`http.allowHosts\` in app.config.ts.`), this.url = e, this.reason = t, this.name = "SsrfBlockedError";
 	}
-}, a = (e, t) => e === 0 || e === 10 || e === 127 || e === 100 && t >= 64 && t <= 127 || e === 169 && t === 254 || e === 172 && t >= 16 && t <= 31 || e === 192 && t === 168 || e === 198 && (t === 18 || t === 19) || e >= 224, o = (e) => e === "::" || e === "::1" || e.startsWith("fc") || e.startsWith("fd") || e.startsWith("fe80") || e.startsWith("::ffff:"), s = (e, t, n) => n.some((n) => {
-	let r = n.trim().toLowerCase();
-	if (r === "") return !1;
-	let i = t === "" ? e : `${e}:${t}`;
-	return r === e || r === i ? !0 : r.startsWith("*.") ? e.endsWith(r.slice(1)) : !1;
-}), c = (e, t = {}) => {
-	let n;
-	try {
-		n = new URL(e);
-	} catch {
-		return "malformed url";
-	}
-	if (n.protocol !== "http:" && n.protocol !== "https:") return `blocked scheme "${n.protocol}"`;
-	let r = n.hostname.replace(/^\[|\]$/g, "").toLowerCase();
-	if (s(r, n.port, t.allowHosts ?? [])) return null;
-	if (r === "localhost" || r.endsWith(".localhost") || r.endsWith(".internal") || r.endsWith(".local")) return `blocked host "${r}"`;
-	let i = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(r);
-	if (i) {
-		let e = Number(i[1]), t = Number(i[2]);
-		return e > 255 || t > 255 || Number(i[3]) > 255 || Number(i[4]) > 255 ? "malformed ipv4 literal" : a(e, t) ? `blocked private/reserved address ${r}` : null;
-	}
-	if (r.includes(":")) {
-		let e = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(r);
-		return e ? c(`${n.protocol}//${e[1]}`, t) : o(r) ? `blocked private/reserved address ${r}` : null;
-	}
-	return null;
-}, l = (a = {}) => t.effect(n.HttpClient, e.map(n.HttpClient, (t) => {
-	let o = n.transform(t, (t, n) => e.suspend(() => {
-		let o = c(n.url, a);
-		return o === null ? t : e.fail(new r.HttpClientError({ reason: new r.TransportError({
-			request: n,
-			cause: new i(n.url, o),
-			description: `SSRF policy: ${o}`
+}, s = (r = {}) => t.effect(i.HttpClient, e.map(i.HttpClient, (t) => {
+	let s = i.transform(t, (t, i) => e.suspend(() => {
+		let s = n(i.url, r);
+		return s === null ? t : e.fail(new a.HttpClientError({ reason: new a.TransportError({
+			request: i,
+			cause: new o(i.url, s),
+			description: `SSRF policy: ${s}`
 		}) }));
 	}));
-	return n.followRedirects(o, a.maxRedirects ?? 5);
+	return i.followRedirects(s, r.maxRedirects ?? 5);
 }));
 //#endregion
-export { i as SsrfBlockedError, l as ssrfGuardHttpClientLayer, c as ssrfReason };
+export { o as SsrfBlockedError, s as ssrfGuardHttpClientLayer, r as ssrfReason };

package/dist/httpClientTracing.js

@@ -1,11 +1,14 @@
-import { formatTraceparent as e } from "./traceparent.js";
-import { Effect as t, Layer as n } from "effect";
-import { HttpClient as r, HttpClientRequest as i } from "effect/http";
+import { noteCacheVolatile as e } from "./computedQueryCache.js";
+import { formatTraceparent as t } from "./traceparent.js";
+import { Effect as n, Layer as r } from "effect";
+import { HttpClient as i, HttpClientRequest as a } from "effect/http";
 //#region src/httpClientTracing.ts
-var a = n.effect(r.HttpClient, t.map(r.HttpClient, (n) => n.pipe(r.mapRequestEffect((n) => t.currentSpan.pipe(t.map((t) => n.headers.traceparent === void 0 ? i.setHeader(n, "traceparent", e({
-	traceId: t.traceId,
-	spanId: t.spanId,
-	sampled: t.sampled
-})) : n), t.catch(() => t.succeed(n)))))));
+var o = r.effect(i.HttpClient, n.map(i.HttpClient, (r) => r.pipe(i.mapRequestEffect((r) => n.sync(() => {
+	e("HttpClient");
+}).pipe(n.andThen(n.currentSpan), n.map((e) => r.headers.traceparent === void 0 ? a.setHeader(r, "traceparent", t({
+	traceId: e.traceId,
+	spanId: e.spanId,
+	sampled: e.sampled
+})) : r), n.catch(() => n.succeed(r)))))));
 //#endregion
-export { a as tracingHttpClientLayer };
+export { o as tracingHttpClientLayer };

package/dist/httpCompression.js

@@ -36,32 +36,32 @@ var r = 1024, i = [
 	[t.BROTLI_PARAM_QUALITY]: 4,
 	[t.BROTLI_PARAM_SIZE_HINT]: r.length
 } })) : new Uint8Array(n(r, { level: 6 })), c = (e) => {
-	let t = e.options?.enabled ?? !0, n = e.options?.minBytes ?? 1024, r = a(e.contentType), i = r ? { vary: "Accept-Encoding" } : {};
-	if (!t || !r || e.body.length < n) return {
+	let t = e.options?.enabled ?? !0, n = e.options?.minBytes ?? 1024;
+	if (!(!t || !a(e.contentType) || e.size < n)) return o(e.acceptEncoding);
+}, l = (e) => {
+	let t = a(e.contentType) ? { vary: "Accept-Encoding" } : {}, n = c({
+		...e,
+		size: e.body.length
+	});
+	if (n === void 0) return {
 		bytes: e.body,
-		headers: i,
+		headers: t,
 		compressed: !1
 	};
-	let c = o(e.acceptEncoding);
-	if (c === void 0) return {
+	let r = s(e.body, n);
+	return r.length >= e.body.length ? {
 		bytes: e.body,
-		headers: i,
-		compressed: !1
-	};
-	let l = s(e.body, c);
-	return l.length >= e.body.length ? {
-		bytes: e.body,
-		headers: i,
+		headers: t,
 		compressed: !1
 	} : {
-		bytes: l,
+		bytes: r,
 		headers: {
-			...i,
-			"content-encoding": c
+			...t,
+			"content-encoding": n
 		},
 		compressed: !0
 	};
-}, l = (e, t) => {
+}, u = (e, t) => {
 	let n = {}, r = [], i = (e) => {
 		for (let t of String(e).split(",")) {
 			let e = t.trim();
@@ -73,4 +73,4 @@ var r = 1024, i = [
 	return r.length > 0 && (n.vary = r.join(", ")), n;
 };
 //#endregion
-export { r as DEFAULT_COMPRESSION_MIN_BYTES, a as isCompressibleContentType, c as maybeCompress, l as mergeCompressionHeaders, o as negotiateEncoding };
+export { r as DEFAULT_COMPRESSION_MIN_BYTES, a as isCompressibleContentType, l as maybeCompress, u as mergeCompressionHeaders, o as negotiateEncoding, c as negotiatedCompression };

package/dist/httpInputStream.js

@@ -0,0 +1,82 @@
+//#region src/httpInputStream.ts
+var e = async (e, t, n, r, i) => {
+	let a = new AbortController(), o, s = !1, c = e.readableEnded, l = e.destroyed && !c, u = !1, d = 0, f = !1, p = !1, m = () => {
+		o?.();
+	}, h = () => {
+		l = !0, a.abort(), m();
+	}, g = () => {
+		c = !0, m();
+	}, _ = () => {
+		e.complete || h();
+	};
+	e.once("end", g), e.once("error", h), e.once("aborted", h), e.once("close", _), i.addEventListener("abort", h, { once: !0 }), (i.aborted || l) && h();
+	let v = { [Symbol.asyncIterator]() {
+		if (f) throw Error("HTTP input can only be consumed once");
+		return f = !0, {
+			async next() {
+				if (p) throw Error("Concurrent HTTP input reads are not supported");
+				p = !0;
+				try {
+					for (;;) {
+						if (l || a.signal.aborted) throw Error("HTTP input aborted");
+						if (u) throw Error("HTTP input exceeds its byte limit");
+						if (s) return {
+							done: !0,
+							value: void 0
+						};
+						let n = e.read();
+						if (n !== null) {
+							if (d += n.byteLength, d > t) throw u = !0, Error("HTTP input exceeds its byte limit");
+							return {
+								done: !1,
+								value: n
+							};
+						}
+						if (c) return {
+							done: !0,
+							value: void 0
+						};
+						await new Promise((t) => {
+							let n = () => {
+								e.off("readable", n), o = void 0, t();
+							};
+							o = n, e.once("readable", n);
+						});
+					}
+				} finally {
+					p = !1;
+				}
+			},
+			async return() {
+				return s = !0, m(), {
+					done: !0,
+					value: void 0
+				};
+			}
+		};
+	} }, y = () => ({
+		status: 413,
+		body: "payload too large",
+		contentType: "text/plain"
+	}), b;
+	try {
+		let e = new Promise((e, t) => {
+			b = () => t(/* @__PURE__ */ Error("HTTP input aborted")), a.signal.addEventListener("abort", b, { once: !0 }), a.signal.aborted && b();
+		}), t = await Promise.race([e, Promise.resolve().then(() => {
+			if (a.signal.aborted) throw Error("HTTP input aborted");
+			return r({
+				...n,
+				body: v,
+				signal: a.signal
+			});
+		})]);
+		return u ? y() : t;
+	} catch (e) {
+		if (u) return y();
+		throw e;
+	} finally {
+		s = !0, b !== void 0 && a.signal.removeEventListener("abort", b), a.abort(), m(), e.off("end", g), e.off("error", h), e.off("aborted", h), e.off("close", _), i.removeEventListener("abort", h), !e.destroyed && !e.readableEnded && e.resume();
+	}
+};
+//#endregion
+export { e as dispatchHttpInputStream };

package/dist/httpRouteMounts.js

@@ -14,6 +14,7 @@ var n = (e) => e.split("/").map((e) => e.startsWith(":") ? ":param" : e).join("/
 	}
 	let i = [];
 	t.forEach((e, t) => {
+		if (e.some((e) => e.handleStream !== void 0) && (e.length !== 1 || e[0].match !== "exact" || e[0].path.endsWith("/*"))) throw Error("A streamed HTTP input requires an exclusive exact route path");
 		i.push({
 			mountPath: t,
 			routes: e,