@trpc/server 11.4.0 → 11.4.2-canary.1

package/dist/{resolveResponse-B2CuaT_1.cjs → resolveResponse-CVGbakBm.cjs}

@@ -1,33 +1,7 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const require_getErrorShape = require('./getErrorShape-CsikfkAc.cjs');
-const require_tracked = require('./tracked-Dl9sBZxY.cjs');
-const require_utils = require('./utils-DVO6HZiR.cjs');
-const require_observable = require('./observable-BwdrSFZU.cjs');
+const require_getErrorShape = require('./getErrorShape-DKiEF6Zc.cjs');
+const require_tracked = require('./tracked-HoF8L_mq.cjs');
+const require_utils = require('./utils-BhNVZA-c.cjs');
+const require_observable = require('./observable-B1Nk6r1H.cjs');
 
 //#region src/unstable-core-do-not-import/http/parseConnectionParams.ts
 function parseConnectionParamsFromUnknown(parsed) {
@@ -61,6 +35,7 @@ function parseConnectionParamsFromString(str) {
 
 //#endregion
 //#region src/unstable-core-do-not-import/http/contentType.ts
+var import_objectSpread2$1 = require_getErrorShape.__toESM(require_getErrorShape.require_objectSpread2(), 1);
 /**
 * Memoize a function that takes no arguments
 * @internal
@@ -71,15 +46,16 @@ function memo(fn) {
 	let value = sym;
 	return {
 		read: async () => {
+			var _promise;
 			if (value !== sym) return value;
-			promise ??= fn().catch((cause) => {
+			(_promise = promise) !== null && _promise !== void 0 || (promise = fn().catch((cause) => {
 				if (cause instanceof require_tracked.TRPCError) throw cause;
 				throw new require_tracked.TRPCError({
 					code: "BAD_REQUEST",
 					message: cause instanceof Error ? cause.message : "Invalid input",
 					cause
 				});
-			});
+			}));
 			value = await promise;
 			promise = null;
 			return value;
@@ -91,9 +67,11 @@ function memo(fn) {
 }
 const jsonContentTypeHandler = {
 	isMatch(req) {
-		return !!req.headers.get("content-type")?.startsWith("application/json");
+		var _req$headers$get;
+		return !!((_req$headers$get = req.headers.get("content-type")) === null || _req$headers$get === void 0 ? void 0 : _req$headers$get.startsWith("application/json"));
 	},
 	async parse(opts) {
+		var _types$values$next$va;
 		const { req } = opts;
 		const isBatchCall = opts.searchParams.get("batch") === "1";
 		const paths = isBatchCall ? opts.path.split(",") : [opts.path];
@@ -124,28 +102,33 @@ const jsonContentTypeHandler = {
 				getRawInput: async () => {
 					const inputs = await getInputs.read();
 					let input = inputs[index];
-					if (procedure?._def.type === "subscription") {
-						const lastEventId = opts.headers.get("last-event-id") ?? opts.searchParams.get("lastEventId") ?? opts.searchParams.get("Last-Event-Id");
-						if (lastEventId) if (require_utils.isObject(input)) input = {
-							...input,
-							lastEventId
-						};
-						else input ??= { lastEventId };
+					if ((procedure === null || procedure === void 0 ? void 0 : procedure._def.type) === "subscription") {
+						var _ref, _opts$headers$get;
+						const lastEventId = (_ref = (_opts$headers$get = opts.headers.get("last-event-id")) !== null && _opts$headers$get !== void 0 ? _opts$headers$get : opts.searchParams.get("lastEventId")) !== null && _ref !== void 0 ? _ref : opts.searchParams.get("Last-Event-Id");
+						if (lastEventId) if (require_utils.isObject(input)) input = (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, input), {}, { lastEventId });
+						else {
+							var _input;
+							(_input = input) !== null && _input !== void 0 || (input = { lastEventId });
+						}
 					}
 					return input;
 				},
 				result: () => {
-					return getInputs.result()?.[index];
+					var _getInputs$result;
+					return (_getInputs$result = getInputs.result()) === null || _getInputs$result === void 0 ? void 0 : _getInputs$result[index];
 				}
 			};
 		}));
-		const types = new Set(calls.map((call) => call.procedure?._def.type).filter(Boolean));
+		const types = new Set(calls.map((call) => {
+			var _call$procedure;
+			return (_call$procedure = call.procedure) === null || _call$procedure === void 0 ? void 0 : _call$procedure._def.type;
+		}).filter(Boolean));
 		/* istanbul ignore if -- @preserve */
 		if (types.size > 1) throw new require_tracked.TRPCError({
 			code: "BAD_REQUEST",
 			message: `Cannot mix procedure types in call: ${Array.from(types).join(", ")}`
 		});
-		const type = types.values().next().value ?? "unknown";
+		const type = (_types$values$next$va = types.values().next().value) !== null && _types$values$next$va !== void 0 ? _types$values$next$va : "unknown";
 		const connectionParamsStr = opts.searchParams.get("connectionParams");
 		const info = {
 			isBatchCall,
@@ -161,7 +144,8 @@ const jsonContentTypeHandler = {
 };
 const formDataContentTypeHandler = {
 	isMatch(req) {
-		return !!req.headers.get("content-type")?.startsWith("multipart/form-data");
+		var _req$headers$get2;
+		return !!((_req$headers$get2 = req.headers.get("content-type")) === null || _req$headers$get2 === void 0 ? void 0 : _req$headers$get2.startsWith("multipart/form-data"));
 	},
 	async parse(opts) {
 		const { req } = opts;
@@ -192,7 +176,8 @@ const formDataContentTypeHandler = {
 };
 const octetStreamContentTypeHandler = {
 	isMatch(req) {
-		return !!req.headers.get("content-type")?.startsWith("application/octet-stream");
+		var _req$headers$get3;
+		return !!((_req$headers$get3 = req.headers.get("content-type")) === null || _req$headers$get3 === void 0 ? void 0 : _req$headers$get3.startsWith("application/octet-stream"));
 	},
 	async parse(opts) {
 		const { req } = opts;
@@ -249,6 +234,8 @@ function throwAbortError(message = "AbortError") {
 
 //#endregion
 //#region src/vendor/unpromise/unpromise.ts
+var import_defineProperty = require_getErrorShape.__toESM(require_getErrorShape.require_defineProperty(), 1);
+let _Symbol$toStringTag;
 /** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
 * which is retained for the lifetime of the original Promise.
 */
@@ -257,6 +244,7 @@ const subscribableCache = /* @__PURE__ */ new WeakMap();
 * SubscribedPromises (settled promises are not subscribed - they resolve
 * immediately). */
 const NOOP = () => {};
+_Symbol$toStringTag = Symbol.toStringTag;
 /**
 * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
 * created once, cached and reused throughout the lifetime of the Promise. Get a
@@ -291,17 +279,11 @@ const NOOP = () => {};
 *
 */
 var Unpromise = class Unpromise {
-	/** INSTANCE IMPLEMENTATION */
-	/** The promise shadowed by this Unpromise<T>  */
-	promise;
-	/** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-	* after the original promise settles - no further notifications will be issued. */
-	subscribers = [];
-	/** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
-	* calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-	* can be returned, and therefore subscription can be bypassed. */
-	settlement = null;
 	constructor(arg) {
+		(0, import_defineProperty.default)(this, "promise", void 0);
+		(0, import_defineProperty.default)(this, "subscribers", []);
+		(0, import_defineProperty.default)(this, "settlement", null);
+		(0, import_defineProperty.default)(this, _Symbol$toStringTag, "Unpromise");
 		if (typeof arg === "function") this.promise = new Promise(arg);
 		else this.promise = arg;
 		const thenReturn = this.promise.then((value) => {
@@ -311,7 +293,7 @@ var Unpromise = class Unpromise {
 				status: "fulfilled",
 				value
 			};
-			subscribers?.forEach(({ resolve }) => {
+			subscribers === null || subscribers === void 0 || subscribers.forEach(({ resolve }) => {
 				resolve(value);
 			});
 		});
@@ -322,7 +304,7 @@ var Unpromise = class Unpromise {
 				status: "rejected",
 				reason
 			};
-			subscribers?.forEach(({ reject }) => {
+			subscribers === null || subscribers === void 0 || subscribers.forEach(({ reject }) => {
 				reject(reason);
 			});
 		});
@@ -381,8 +363,6 @@ var Unpromise = class Unpromise {
 		const { unsubscribe } = subscribed;
 		return Object.assign(subscribed.finally(onfinally), { unsubscribe });
 	}
-	/** TOSTRING SUPPORT */
-	[Symbol.toStringTag] = "Unpromise";
 	/** Unpromise STATIC METHODS */
 	/** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
 	* of the provided Promise reference) */
@@ -490,8 +470,9 @@ function listWithoutMember(arr, member) {
 
 //#endregion
 //#region src/unstable-core-do-not-import/stream/utils/disposable.ts
-Symbol.dispose ??= Symbol();
-Symbol.asyncDispose ??= Symbol();
+var _Symbol, _Symbol$dispose, _Symbol2, _Symbol2$asyncDispose;
+(_Symbol$dispose = (_Symbol = Symbol).dispose) !== null && _Symbol$dispose !== void 0 || (_Symbol.dispose = Symbol());
+(_Symbol2$asyncDispose = (_Symbol2 = Symbol).asyncDispose) !== null && _Symbol2$asyncDispose !== void 0 || (_Symbol2.asyncDispose = Symbol());
 /**
 * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
 * The returned object is the original value augmented with a Symbol.dispose method.
@@ -504,7 +485,7 @@ function makeResource(thing, dispose) {
 	const existing = it[Symbol.dispose];
 	it[Symbol.dispose] = () => {
 		dispose();
-		existing?.();
+		existing === null || existing === void 0 || existing();
 	};
 	return it;
 }
@@ -520,7 +501,7 @@ function makeAsyncResource(thing, dispose) {
 	const existing = it[Symbol.asyncDispose];
 	it[Symbol.asyncDispose] = async () => {
 		await dispose();
-		await existing?.();
+		await (existing === null || existing === void 0 ? void 0 : existing());
 	};
 	return it;
 }
@@ -543,7 +524,7 @@ function timerResource(ms) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js
-var require_usingCtx = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+var require_usingCtx = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
 	function _usingCtx() {
 		var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
 			var n$1 = Error();
@@ -601,65 +582,170 @@ var require_usingCtx = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runti
 	module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
 } });
 
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js
+var require_OverloadYield = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(exports, module) {
+	function _OverloadYield(e, d) {
+		this.v = e, this.k = d;
+	}
+	module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js
+var require_awaitAsyncGenerator = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+	var OverloadYield$2 = require_OverloadYield();
+	function _awaitAsyncGenerator$5(e) {
+		return new OverloadYield$2(e, 0);
+	}
+	module.exports = _awaitAsyncGenerator$5, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js
+var require_wrapAsyncGenerator = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+	var OverloadYield$1 = require_OverloadYield();
+	function _wrapAsyncGenerator$6(e) {
+		return function() {
+			return new AsyncGenerator(e.apply(this, arguments));
+		};
+	}
+	function AsyncGenerator(e) {
+		var r, t;
+		function resume(r$1, t$1) {
+			try {
+				var n = e[r$1](t$1), o = n.value, u = o instanceof OverloadYield$1;
+				Promise.resolve(u ? o.v : o).then(function(t$2) {
+					if (u) {
+						var i = "return" === r$1 ? "return" : "next";
+						if (!o.k || t$2.done) return resume(i, t$2);
+						t$2 = e[i](t$2).value;
+					}
+					settle(n.done ? "return" : "normal", t$2);
+				}, function(e$1) {
+					resume("throw", e$1);
+				});
+			} catch (e$1) {
+				settle("throw", e$1);
+			}
+		}
+		function settle(e$1, n) {
+			switch (e$1) {
+				case "return":
+					r.resolve({
+						value: n,
+						done: !0
+					});
+					break;
+				case "throw":
+					r.reject(n);
+					break;
+				default: r.resolve({
+					value: n,
+					done: !1
+				});
+			}
+			(r = r.next) ? resume(r.key, r.arg) : t = null;
+		}
+		this._invoke = function(e$1, n) {
+			return new Promise(function(o, u) {
+				var i = {
+					key: e$1,
+					arg: n,
+					resolve: o,
+					reject: u,
+					next: null
+				};
+				t ? t = t.next = i : (r = t = i, resume(e$1, n));
+			});
+		}, "function" != typeof e["return"] && (this["return"] = void 0);
+	}
+	AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+		return this;
+	}, AsyncGenerator.prototype.next = function(e) {
+		return this._invoke("next", e);
+	}, AsyncGenerator.prototype["throw"] = function(e) {
+		return this._invoke("throw", e);
+	}, AsyncGenerator.prototype["return"] = function(e) {
+		return this._invoke("return", e);
+	};
+	module.exports = _wrapAsyncGenerator$6, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/unstable-core-do-not-import/stream/utils/asyncIterable.ts
-var import_usingCtx$4 = __toESM(require_usingCtx(), 1);
+var import_usingCtx$4 = require_getErrorShape.__toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$4 = require_getErrorShape.__toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$5 = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
 function iteratorResource(iterable) {
 	const iterator = iterable[Symbol.asyncIterator]();
 	if (iterator[Symbol.asyncDispose]) return iterator;
 	return makeAsyncResource(iterator, async () => {
-		await iterator.return?.();
+		var _iterator$return;
+		await ((_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
 	});
 }
 /**
 * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically aborts after the specified duration.
 */
-async function* withMaxDuration(iterable, opts) {
-	try {
-		var _usingCtx$1 = (0, import_usingCtx$4.default)();
-		const iterator = _usingCtx$1.a(iteratorResource(iterable));
-		const timer = _usingCtx$1.u(timerResource(opts.maxDurationMs));
-		const timerPromise = timer.start();
-		let result;
-		while (true) {
-			result = await Unpromise.race([iterator.next(), timerPromise]);
-			if (result === disposablePromiseTimerResult) throwAbortError();
-			if (result.done) return result;
-			yield result.value;
-			result = null;
+function withMaxDuration(_x, _x2) {
+	return _withMaxDuration.apply(this, arguments);
+}
+function _withMaxDuration() {
+	_withMaxDuration = (0, import_wrapAsyncGenerator$5.default)(function* (iterable, opts) {
+		try {
+			var _usingCtx$1 = (0, import_usingCtx$4.default)();
+			const iterator = _usingCtx$1.a(iteratorResource(iterable));
+			const timer = _usingCtx$1.u(timerResource(opts.maxDurationMs));
+			const timerPromise = timer.start();
+			let result;
+			while (true) {
+				result = yield (0, import_awaitAsyncGenerator$4.default)(Unpromise.race([iterator.next(), timerPromise]));
+				if (result === disposablePromiseTimerResult) throwAbortError();
+				if (result.done) return result;
+				yield result.value;
+				result = null;
+			}
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			yield (0, import_awaitAsyncGenerator$4.default)(_usingCtx$1.d());
 		}
-	} catch (_) {
-		_usingCtx$1.e = _;
-	} finally {
-		await _usingCtx$1.d();
-	}
+	});
+	return _withMaxDuration.apply(this, arguments);
 }
 /**
 * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
 * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
 * values may still come through. After this period, the generator aborts.
 */
-async function* takeWithGrace(iterable, opts) {
-	try {
-		var _usingCtx3 = (0, import_usingCtx$4.default)();
-		const iterator = _usingCtx3.a(iteratorResource(iterable));
-		let result;
-		const timer = _usingCtx3.u(timerResource(opts.gracePeriodMs));
-		let count = opts.count;
-		let timerPromise = new Promise(() => {});
-		while (true) {
-			result = await Unpromise.race([iterator.next(), timerPromise]);
-			if (result === disposablePromiseTimerResult) throwAbortError();
-			if (result.done) return result.value;
-			yield result.value;
-			if (--count === 0) timerPromise = timer.start();
-			result = null;
+function takeWithGrace(_x3, _x4) {
+	return _takeWithGrace.apply(this, arguments);
+}
+function _takeWithGrace() {
+	_takeWithGrace = (0, import_wrapAsyncGenerator$5.default)(function* (iterable, opts) {
+		try {
+			var _usingCtx3 = (0, import_usingCtx$4.default)();
+			const iterator = _usingCtx3.a(iteratorResource(iterable));
+			let result;
+			const timer = _usingCtx3.u(timerResource(opts.gracePeriodMs));
+			let count = opts.count;
+			let timerPromise = new Promise(() => {});
+			while (true) {
+				result = yield (0, import_awaitAsyncGenerator$4.default)(Unpromise.race([iterator.next(), timerPromise]));
+				if (result === disposablePromiseTimerResult) throwAbortError();
+				if (result.done) return result.value;
+				yield result.value;
+				if (--count === 0) timerPromise = timer.start();
+				result = null;
+			}
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			yield (0, import_awaitAsyncGenerator$4.default)(_usingCtx3.d());
 		}
-	} catch (_) {
-		_usingCtx3.e = _;
-	} finally {
-		await _usingCtx3.d();
-	}
+	});
+	return _takeWithGrace.apply(this, arguments);
 }
 
 //#endregion
@@ -680,7 +766,9 @@ function createDeferred() {
 
 //#endregion
 //#region src/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.ts
-var import_usingCtx$3 = __toESM(require_usingCtx(), 1);
+var import_usingCtx$3 = require_getErrorShape.__toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$3 = require_getErrorShape.__toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$4 = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
 function createManagedIterator(iterable, onResult) {
 	const iterator = iterable[Symbol.asyncIterator]();
 	let state = "idle";
@@ -718,8 +806,9 @@ function createManagedIterator(iterable, onResult) {
 	return {
 		pull,
 		destroy: async () => {
+			var _iterator$return;
 			cleanup();
-			await iterator.return?.();
+			await ((_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
 		}
 	};
 }
@@ -779,46 +868,48 @@ function mergeAsyncIterables() {
 				case "done": break;
 			}
 		},
-		async *[Symbol.asyncIterator]() {
-			try {
-				var _usingCtx$1 = (0, import_usingCtx$3.default)();
-				if (state !== "idle") throw new Error("Cannot iterate twice");
-				state = "pending";
-				const _finally = _usingCtx$1.a(makeAsyncResource({}, async () => {
-					state = "done";
-					const errors = [];
-					await Promise.all(Array.from(iterators.values()).map(async (it) => {
-						try {
-							await it.destroy();
-						} catch (cause) {
-							errors.push(cause);
-						}
+		[Symbol.asyncIterator]() {
+			return (0, import_wrapAsyncGenerator$4.default)(function* () {
+				try {
+					var _usingCtx$1 = (0, import_usingCtx$3.default)();
+					if (state !== "idle") throw new Error("Cannot iterate twice");
+					state = "pending";
+					const _finally = _usingCtx$1.a(makeAsyncResource({}, async () => {
+						state = "done";
+						const errors = [];
+						await Promise.all(Array.from(iterators.values()).map(async (it) => {
+							try {
+								await it.destroy();
+							} catch (cause) {
+								errors.push(cause);
+							}
+						}));
+						buffer.length = 0;
+						iterators.clear();
+						flushSignal.resolve();
+						if (errors.length > 0) throw new AggregateError(errors);
 					}));
-					buffer.length = 0;
-					iterators.clear();
-					flushSignal.resolve();
-					if (errors.length > 0) throw new AggregateError(errors);
-				}));
-				while (iterables.length > 0) initIterable(iterables.shift());
-				while (iterators.size > 0) {
-					await flushSignal.promise;
-					while (buffer.length > 0) {
-						const [iterator, result] = buffer.shift();
-						switch (result.status) {
-							case "yield":
-								yield result.value;
-								iterator.pull();
-								break;
-							case "error": throw result.error;
+					while (iterables.length > 0) initIterable(iterables.shift());
+					while (iterators.size > 0) {
+						yield (0, import_awaitAsyncGenerator$3.default)(flushSignal.promise);
+						while (buffer.length > 0) {
+							const [iterator, result] = buffer.shift();
+							switch (result.status) {
+								case "yield":
+									yield result.value;
+									iterator.pull();
+									break;
+								case "error": throw result.error;
+							}
 						}
+						flushSignal = createDeferred();
 					}
-					flushSignal = createDeferred();
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					yield (0, import_awaitAsyncGenerator$3.default)(_usingCtx$1.d());
 				}
-			} catch (_) {
-				_usingCtx$1.e = _;
-			} finally {
-				await _usingCtx$1.d();
-			}
+			})();
 		}
 	};
 }
@@ -835,7 +926,8 @@ function readableStreamFrom(iterable) {
 	const iterator = iterable[Symbol.asyncIterator]();
 	return new ReadableStream({
 		async cancel() {
-			await iterator.return?.();
+			var _iterator$return;
+			await ((_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
 		},
 		async pull(controller) {
 			const result = await iterator.next();
@@ -850,45 +942,103 @@ function readableStreamFrom(iterable) {
 
 //#endregion
 //#region src/unstable-core-do-not-import/stream/utils/withPing.ts
-var import_usingCtx$2 = __toESM(require_usingCtx(), 1);
+var import_usingCtx$2 = require_getErrorShape.__toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$2 = require_getErrorShape.__toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$3 = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
 const PING_SYM = Symbol("ping");
 /**
 * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
 * whenever no value has been yielded for {@link pingIntervalMs}.
 */
-async function* withPing(iterable, pingIntervalMs) {
-	try {
-		var _usingCtx$1 = (0, import_usingCtx$2.default)();
-		const iterator = _usingCtx$1.a(iteratorResource(iterable));
-		let result;
-		let nextPromise = iterator.next();
-		while (true) try {
-			var _usingCtx3 = (0, import_usingCtx$2.default)();
-			const pingPromise = _usingCtx3.u(timerResource(pingIntervalMs));
-			result = await Unpromise.race([nextPromise, pingPromise.start()]);
-			if (result === disposablePromiseTimerResult) {
-				yield PING_SYM;
-				continue;
+function withPing(_x, _x2) {
+	return _withPing.apply(this, arguments);
+}
+function _withPing() {
+	_withPing = (0, import_wrapAsyncGenerator$3.default)(function* (iterable, pingIntervalMs) {
+		try {
+			var _usingCtx$1 = (0, import_usingCtx$2.default)();
+			const iterator = _usingCtx$1.a(iteratorResource(iterable));
+			let result;
+			let nextPromise = iterator.next();
+			while (true) try {
+				var _usingCtx3 = (0, import_usingCtx$2.default)();
+				const pingPromise = _usingCtx3.u(timerResource(pingIntervalMs));
+				result = yield (0, import_awaitAsyncGenerator$2.default)(Unpromise.race([nextPromise, pingPromise.start()]));
+				if (result === disposablePromiseTimerResult) {
+					yield PING_SYM;
+					continue;
+				}
+				if (result.done) return result.value;
+				nextPromise = iterator.next();
+				yield result.value;
+				result = null;
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				_usingCtx3.d();
 			}
-			if (result.done) return result.value;
-			nextPromise = iterator.next();
-			yield result.value;
-			result = null;
 		} catch (_) {
-			_usingCtx3.e = _;
+			_usingCtx$1.e = _;
 		} finally {
-			_usingCtx3.d();
+			yield (0, import_awaitAsyncGenerator$2.default)(_usingCtx$1.d());
 		}
-	} catch (_) {
-		_usingCtx$1.e = _;
-	} finally {
-		await _usingCtx$1.d();
-	}
+	});
+	return _withPing.apply(this, arguments);
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js
+var require_asyncIterator = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+	function _asyncIterator$2(r) {
+		var n, t, o, e = 2;
+		for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) {
+			if (t && null != (n = r[t])) return n.call(r);
+			if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
+			t = "@@asyncIterator", o = "@@iterator";
+		}
+		throw new TypeError("Object is not async iterable");
+	}
+	function AsyncFromSyncIterator(r) {
+		function AsyncFromSyncIteratorContinuation(r$1) {
+			if (Object(r$1) !== r$1) return Promise.reject(new TypeError(r$1 + " is not an object."));
+			var n = r$1.done;
+			return Promise.resolve(r$1.value).then(function(r$2) {
+				return {
+					value: r$2,
+					done: n
+				};
+			});
+		}
+		return AsyncFromSyncIterator = function AsyncFromSyncIterator$1(r$1) {
+			this.s = r$1, this.n = r$1.next;
+		}, AsyncFromSyncIterator.prototype = {
+			s: null,
+			n: null,
+			next: function next() {
+				return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+			},
+			"return": function _return(r$1) {
+				var n = this.s["return"];
+				return void 0 === n ? Promise.resolve({
+					value: r$1,
+					done: !0
+				}) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+			},
+			"throw": function _throw(r$1) {
+				var n = this.s["return"];
+				return void 0 === n ? Promise.reject(r$1) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+			}
+		}, new AsyncFromSyncIterator(r);
+	}
+	module.exports = _asyncIterator$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/unstable-core-do-not-import/stream/jsonl.ts
-var import_usingCtx$1 = __toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$1 = require_getErrorShape.__toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$2 = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
+var import_usingCtx$1 = require_getErrorShape.__toESM(require_usingCtx(), 1);
+var import_asyncIterator$1 = require_getErrorShape.__toESM(require_asyncIterator(), 1);
 function isPlainObject(value) {
 	return Object.prototype.toString.call(value) === "[object Object]";
 }
@@ -900,7 +1050,7 @@ const ASYNC_ITERABLE_STATUS_RETURN = 0;
 const ASYNC_ITERABLE_STATUS_YIELD = 1;
 const ASYNC_ITERABLE_STATUS_ERROR = 2;
 function isPromise(value) {
-	return (require_utils.isObject(value) || require_utils.isFunction(value)) && typeof value?.["then"] === "function" && typeof value?.["catch"] === "function";
+	return (require_utils.isObject(value) || require_utils.isFunction(value)) && typeof (value === null || value === void 0 ? void 0 : value["then"]) === "function" && typeof (value === null || value === void 0 ? void 0 : value["catch"]) === "function";
 }
 var MaxDepthError = class extends Error {
 	constructor(path) {
@@ -908,133 +1058,169 @@ var MaxDepthError = class extends Error {
 		this.path = path;
 	}
 };
-async function* createBatchStreamProducer(opts) {
-	const { data } = opts;
-	let counter = 0;
-	const placeholder = 0;
-	const mergedIterables = mergeAsyncIterables();
-	function registerAsync(callback) {
-		const idx = counter++;
-		const iterable$1 = callback(idx);
-		mergedIterables.add(iterable$1);
-		return idx;
-	}
-	function encodePromise(promise, path) {
-		return registerAsync(async function* (idx) {
-			const error = checkMaxDepth(path);
-			if (error) {
-				promise.catch((cause) => {
-					opts.onError?.({
-						error: cause,
-						path
-					});
-				});
-				promise = Promise.reject(error);
-			}
-			try {
-				const next = await promise;
-				yield [
-					idx,
-					PROMISE_STATUS_FULFILLED,
-					encode(next, path)
-				];
-			} catch (cause) {
-				opts.onError?.({
-					error: cause,
-					path
+function createBatchStreamProducer(_x3) {
+	return _createBatchStreamProducer.apply(this, arguments);
+}
+function _createBatchStreamProducer() {
+	_createBatchStreamProducer = (0, import_wrapAsyncGenerator$2.default)(function* (opts) {
+		const { data } = opts;
+		let counter = 0;
+		const placeholder = 0;
+		const mergedIterables = mergeAsyncIterables();
+		function registerAsync(callback) {
+			const idx = counter++;
+			const iterable$1 = callback(idx);
+			mergedIterables.add(iterable$1);
+			return idx;
+		}
+		function encodePromise(promise, path) {
+			return registerAsync(/* @__PURE__ */ function() {
+				var _ref = (0, import_wrapAsyncGenerator$2.default)(function* (idx) {
+					const error = checkMaxDepth(path);
+					if (error) {
+						promise.catch((cause) => {
+							var _opts$onError;
+							(_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, {
+								error: cause,
+								path
+							});
+						});
+						promise = Promise.reject(error);
+					}
+					try {
+						const next = yield (0, import_awaitAsyncGenerator$1.default)(promise);
+						yield [
+							idx,
+							PROMISE_STATUS_FULFILLED,
+							encode(next, path)
+						];
+					} catch (cause) {
+						var _opts$onError2, _opts$formatError;
+						(_opts$onError2 = opts.onError) === null || _opts$onError2 === void 0 || _opts$onError2.call(opts, {
+							error: cause,
+							path
+						});
+						yield [
+							idx,
+							PROMISE_STATUS_REJECTED,
+							(_opts$formatError = opts.formatError) === null || _opts$formatError === void 0 ? void 0 : _opts$formatError.call(opts, {
+								error: cause,
+								path
+							})
+						];
+					}
 				});
-				yield [
-					idx,
-					PROMISE_STATUS_REJECTED,
-					opts.formatError?.({
-						error: cause,
-						path
-					})
-				];
-			}
-		});
-	}
-	function encodeAsyncIterable(iterable$1, path) {
-		return registerAsync(async function* (idx) {
-			try {
-				var _usingCtx$1 = (0, import_usingCtx$1.default)();
-				const error = checkMaxDepth(path);
-				if (error) throw error;
-				const iterator = _usingCtx$1.a(iteratorResource(iterable$1));
-				try {
-					while (true) {
-						const next = await iterator.next();
-						if (next.done) {
+				return function(_x) {
+					return _ref.apply(this, arguments);
+				};
+			}());
+		}
+		function encodeAsyncIterable(iterable$1, path) {
+			return registerAsync(/* @__PURE__ */ function() {
+				var _ref2 = (0, import_wrapAsyncGenerator$2.default)(function* (idx) {
+					try {
+						var _usingCtx$1 = (0, import_usingCtx$1.default)();
+						const error = checkMaxDepth(path);
+						if (error) throw error;
+						const iterator = _usingCtx$1.a(iteratorResource(iterable$1));
+						try {
+							while (true) {
+								const next = yield (0, import_awaitAsyncGenerator$1.default)(iterator.next());
+								if (next.done) {
+									yield [
+										idx,
+										ASYNC_ITERABLE_STATUS_RETURN,
+										encode(next.value, path)
+									];
+									break;
+								}
+								yield [
+									idx,
+									ASYNC_ITERABLE_STATUS_YIELD,
+									encode(next.value, path)
+								];
+							}
+						} catch (cause) {
+							var _opts$onError3, _opts$formatError2;
+							(_opts$onError3 = opts.onError) === null || _opts$onError3 === void 0 || _opts$onError3.call(opts, {
+								error: cause,
+								path
+							});
 							yield [
 								idx,
-								ASYNC_ITERABLE_STATUS_RETURN,
-								encode(next.value, path)
+								ASYNC_ITERABLE_STATUS_ERROR,
+								(_opts$formatError2 = opts.formatError) === null || _opts$formatError2 === void 0 ? void 0 : _opts$formatError2.call(opts, {
+									error: cause,
+									path
+								})
 							];
-							break;
 						}
-						yield [
-							idx,
-							ASYNC_ITERABLE_STATUS_YIELD,
-							encode(next.value, path)
-						];
+					} catch (_) {
+						_usingCtx$1.e = _;
+					} finally {
+						yield (0, import_awaitAsyncGenerator$1.default)(_usingCtx$1.d());
 					}
-				} catch (cause) {
-					opts.onError?.({
-						error: cause,
-						path
-					});
-					yield [
-						idx,
-						ASYNC_ITERABLE_STATUS_ERROR,
-						opts.formatError?.({
-							error: cause,
-							path
-						})
-					];
+				});
+				return function(_x2) {
+					return _ref2.apply(this, arguments);
+				};
+			}());
+		}
+		function checkMaxDepth(path) {
+			if (opts.maxDepth && path.length > opts.maxDepth) return new MaxDepthError(path);
+			return null;
+		}
+		function encodeAsync(value, path) {
+			if (isPromise(value)) return [CHUNK_VALUE_TYPE_PROMISE, encodePromise(value, path)];
+			if (require_utils.isAsyncIterable(value)) {
+				if (opts.maxDepth && path.length >= opts.maxDepth) throw new Error("Max depth reached");
+				return [CHUNK_VALUE_TYPE_ASYNC_ITERABLE, encodeAsyncIterable(value, path)];
+			}
+			return null;
+		}
+		function encode(value, path) {
+			if (value === void 0) return [[]];
+			const reg = encodeAsync(value, path);
+			if (reg) return [[placeholder], [null, ...reg]];
+			if (!isPlainObject(value)) return [[value]];
+			const newObj = {};
+			const asyncValues = [];
+			for (const [key, item] of Object.entries(value)) {
+				const transformed = encodeAsync(item, [...path, key]);
+				if (!transformed) {
+					newObj[key] = item;
+					continue;
 				}
-			} catch (_) {
-				_usingCtx$1.e = _;
-			} finally {
-				await _usingCtx$1.d();
+				newObj[key] = placeholder;
+				asyncValues.push([key, ...transformed]);
 			}
-		});
-	}
-	function checkMaxDepth(path) {
-		if (opts.maxDepth && path.length > opts.maxDepth) return new MaxDepthError(path);
-		return null;
-	}
-	function encodeAsync(value, path) {
-		if (isPromise(value)) return [CHUNK_VALUE_TYPE_PROMISE, encodePromise(value, path)];
-		if (require_utils.isAsyncIterable(value)) {
-			if (opts.maxDepth && path.length >= opts.maxDepth) throw new Error("Max depth reached");
-			return [CHUNK_VALUE_TYPE_ASYNC_ITERABLE, encodeAsyncIterable(value, path)];
+			return [[newObj], ...asyncValues];
 		}
-		return null;
-	}
-	function encode(value, path) {
-		if (value === void 0) return [[]];
-		const reg = encodeAsync(value, path);
-		if (reg) return [[placeholder], [null, ...reg]];
-		if (!isPlainObject(value)) return [[value]];
-		const newObj = {};
-		const asyncValues = [];
-		for (const [key, item] of Object.entries(value)) {
-			const transformed = encodeAsync(item, [...path, key]);
-			if (!transformed) {
-				newObj[key] = item;
-				continue;
+		const newHead = {};
+		for (const [key, item] of Object.entries(data)) newHead[key] = encode(item, [key]);
+		yield newHead;
+		let iterable = mergedIterables;
+		if (opts.pingMs) iterable = withPing(mergedIterables, opts.pingMs);
+		var _iteratorAbruptCompletion = false;
+		var _didIteratorError = false;
+		var _iteratorError;
+		try {
+			for (var _iterator = (0, import_asyncIterator$1.default)(iterable), _step; _iteratorAbruptCompletion = !(_step = yield (0, import_awaitAsyncGenerator$1.default)(_iterator.next())).done; _iteratorAbruptCompletion = false) {
+				const value = _step.value;
+				yield value;
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (_iteratorAbruptCompletion && _iterator.return != null) yield (0, import_awaitAsyncGenerator$1.default)(_iterator.return());
+			} finally {
+				if (_didIteratorError) throw _iteratorError;
 			}
-			newObj[key] = placeholder;
-			asyncValues.push([key, ...transformed]);
 		}
-		return [[newObj], ...asyncValues];
-	}
-	const newHead = {};
-	for (const [key, item] of Object.entries(data)) newHead[key] = encode(item, [key]);
-	yield newHead;
-	let iterable = mergedIterables;
-	if (opts.pingMs) iterable = withPing(mergedIterables, opts.pingMs);
-	for await (const value of iterable) yield value;
+	});
+	return _createBatchStreamProducer.apply(this, arguments);
 }
 /**
 * JSON Lines stream producer
@@ -1087,9 +1273,10 @@ function createLineAccumulator(from) {
 			return reader.cancel();
 		}
 	}).pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({ transform(chunk, controller) {
+		var _parts$pop;
 		lineAggregate += chunk;
 		const parts = lineAggregate.split("\n");
-		lineAggregate = parts.pop() ?? "";
+		lineAggregate = (_parts$pop = parts.pop()) !== null && _parts$pop !== void 0 ? _parts$pop : "";
 		for (const part of parts) controller.enqueue(part);
 	} }));
 }
@@ -1204,7 +1391,9 @@ async function jsonlStreamConsumer(opts) {
 					const [_chunkId, status, data] = value$1;
 					switch (status) {
 						case PROMISE_STATUS_FULFILLED: return decode(data);
-						case PROMISE_STATUS_REJECTED: throw opts.formatError?.({ error: data }) ?? new AsyncError(data);
+						case PROMISE_STATUS_REJECTED:
+							var _opts$formatError3, _opts$formatError4;
+							throw (_opts$formatError3 = (_opts$formatError4 = opts.formatError) === null || _opts$formatError4 === void 0 ? void 0 : _opts$formatError4.call(opts, { error: data })) !== null && _opts$formatError3 !== void 0 ? _opts$formatError3 : new AsyncError(data);
 					}
 				} catch (_) {
 					_usingCtx3.e = _;
@@ -1212,19 +1401,21 @@ async function jsonlStreamConsumer(opts) {
 					_usingCtx3.d();
 				}
 			});
-			case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: return require_utils.run(async function* () {
+			case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: return require_utils.run((0, import_wrapAsyncGenerator$2.default)(function* () {
 				try {
 					var _usingCtx4 = (0, import_usingCtx$1.default)();
 					const reader = _usingCtx4.u(controller.getReaderResource());
 					while (true) {
-						const { value: value$1 } = await reader.read();
+						const { value: value$1 } = yield (0, import_awaitAsyncGenerator$1.default)(reader.read());
 						const [_chunkId, status, data] = value$1;
 						switch (status) {
 							case ASYNC_ITERABLE_STATUS_YIELD:
 								yield decode(data);
 								break;
 							case ASYNC_ITERABLE_STATUS_RETURN: return decode(data);
-							case ASYNC_ITERABLE_STATUS_ERROR: throw opts.formatError?.({ error: data }) ?? new AsyncError(data);
+							case ASYNC_ITERABLE_STATUS_ERROR:
+								var _opts$formatError5, _opts$formatError6;
+								throw (_opts$formatError5 = (_opts$formatError6 = opts.formatError) === null || _opts$formatError6 === void 0 ? void 0 : _opts$formatError6.call(opts, { error: data })) !== null && _opts$formatError5 !== void 0 ? _opts$formatError5 : new AsyncError(data);
 						}
 					}
 				} catch (_) {
@@ -1232,7 +1423,7 @@ async function jsonlStreamConsumer(opts) {
 				} finally {
 					_usingCtx4.d();
 				}
-			});
+			}));
 		}
 	}
 	function decode(value) {
@@ -1246,7 +1437,7 @@ async function jsonlStreamConsumer(opts) {
 		return data;
 	}
 	const closeOrAbort = (reason) => {
-		headDeferred?.reject(reason);
+		headDeferred === null || headDeferred === void 0 || headDeferred.reject(reason);
 		streamManager.cancelAll(reason);
 	};
 	source.pipeTo(new WritableStream({
@@ -1269,15 +1460,48 @@ async function jsonlStreamConsumer(opts) {
 		close: () => closeOrAbort(new Error("Stream closed")),
 		abort: closeOrAbort
 	}), { signal: opts.abortController.signal }).catch((error) => {
-		opts.onError?.({ error });
+		var _opts$onError4;
+		(_opts$onError4 = opts.onError) === null || _opts$onError4 === void 0 || _opts$onError4.call(opts, { error });
 		closeOrAbort(error);
 	});
 	return [await headDeferred.promise, streamManager];
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncGeneratorDelegate.js
+var require_asyncGeneratorDelegate = require_getErrorShape.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncGeneratorDelegate.js"(exports, module) {
+	var OverloadYield = require_OverloadYield();
+	function _asyncGeneratorDelegate$1(t) {
+		var e = {}, n = !1;
+		function pump(e$1, r) {
+			return n = !0, r = new Promise(function(n$1) {
+				n$1(t[e$1](r));
+			}), {
+				done: !1,
+				value: new OverloadYield(r, 1)
+			};
+		}
+		return e["undefined" != typeof Symbol && Symbol.iterator || "@@iterator"] = function() {
+			return this;
+		}, e.next = function(t$1) {
+			return n ? (n = !1, t$1) : pump("next", t$1);
+		}, "function" == typeof t["throw"] && (e["throw"] = function(t$1) {
+			if (n) throw n = !1, t$1;
+			return pump("throw", t$1);
+		}), "function" == typeof t["return"] && (e["return"] = function(t$1) {
+			return n ? (n = !1, t$1) : pump("return", t$1);
+		}), e;
+	}
+	module.exports = _asyncGeneratorDelegate$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/unstable-core-do-not-import/stream/sse.ts
-var import_usingCtx = __toESM(require_usingCtx(), 1);
+var import_asyncIterator = require_getErrorShape.__toESM(require_asyncIterator(), 1);
+var import_awaitAsyncGenerator = require_getErrorShape.__toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$1 = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
+var import_asyncGeneratorDelegate = require_getErrorShape.__toESM(require_asyncGeneratorDelegate(), 1);
+var import_usingCtx = require_getErrorShape.__toESM(require_usingCtx(), 1);
 const PING_EVENT = "ping";
 const SERIALIZED_ERROR_EVENT = "serialized-error";
 const CONNECTED_EVENT = "connected";
@@ -1287,61 +1511,92 @@ const RETURN_EVENT = "return";
 * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
 */
 function sseStreamProducer(opts) {
+	var _opts$ping$enabled, _opts$ping, _opts$ping$intervalMs, _opts$ping2, _opts$client;
 	const { serialize = require_utils.identity } = opts;
 	const ping = {
-		enabled: opts.ping?.enabled ?? false,
-		intervalMs: opts.ping?.intervalMs ?? 1e3
+		enabled: (_opts$ping$enabled = (_opts$ping = opts.ping) === null || _opts$ping === void 0 ? void 0 : _opts$ping.enabled) !== null && _opts$ping$enabled !== void 0 ? _opts$ping$enabled : false,
+		intervalMs: (_opts$ping$intervalMs = (_opts$ping2 = opts.ping) === null || _opts$ping2 === void 0 ? void 0 : _opts$ping2.intervalMs) !== null && _opts$ping$intervalMs !== void 0 ? _opts$ping$intervalMs : 1e3
 	};
-	const client = opts.client ?? {};
+	const client = (_opts$client = opts.client) !== null && _opts$client !== void 0 ? _opts$client : {};
 	if (ping.enabled && client.reconnectAfterInactivityMs && ping.intervalMs > client.reconnectAfterInactivityMs) throw new Error(`Ping interval must be less than client reconnect interval to prevent unnecessary reconnection - ping.intervalMs: ${ping.intervalMs} client.reconnectAfterInactivityMs: ${client.reconnectAfterInactivityMs}`);
-	async function* generator() {
-		yield {
-			event: CONNECTED_EVENT,
-			data: JSON.stringify(client)
-		};
-		let iterable = opts.data;
-		if (opts.emitAndEndImmediately) iterable = takeWithGrace(iterable, {
-			count: 1,
-			gracePeriodMs: 1
+	function generator() {
+		return _generator.apply(this, arguments);
+	}
+	function _generator() {
+		_generator = (0, import_wrapAsyncGenerator$1.default)(function* () {
+			yield {
+				event: CONNECTED_EVENT,
+				data: JSON.stringify(client)
+			};
+			let iterable = opts.data;
+			if (opts.emitAndEndImmediately) iterable = takeWithGrace(iterable, {
+				count: 1,
+				gracePeriodMs: 1
+			});
+			if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) iterable = withMaxDuration(iterable, { maxDurationMs: opts.maxDurationMs });
+			if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) iterable = withPing(iterable, ping.intervalMs);
+			let value;
+			let chunk;
+			var _iteratorAbruptCompletion = false;
+			var _didIteratorError = false;
+			var _iteratorError;
+			try {
+				for (var _iterator = (0, import_asyncIterator.default)(iterable), _step; _iteratorAbruptCompletion = !(_step = yield (0, import_awaitAsyncGenerator.default)(_iterator.next())).done; _iteratorAbruptCompletion = false) {
+					value = _step.value;
+					{
+						if (value === PING_SYM) {
+							yield {
+								event: PING_EVENT,
+								data: ""
+							};
+							continue;
+						}
+						chunk = require_tracked.isTrackedEnvelope(value) ? {
+							id: value[0],
+							data: value[1]
+						} : { data: value };
+						chunk.data = JSON.stringify(serialize(chunk.data));
+						yield chunk;
+						value = null;
+						chunk = null;
+					}
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (_iteratorAbruptCompletion && _iterator.return != null) yield (0, import_awaitAsyncGenerator.default)(_iterator.return());
+				} finally {
+					if (_didIteratorError) throw _iteratorError;
+				}
+			}
 		});
-		if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) iterable = withMaxDuration(iterable, { maxDurationMs: opts.maxDurationMs });
-		if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) iterable = withPing(iterable, ping.intervalMs);
-		let value;
-		let chunk;
-		for await (value of iterable) {
-			if (value === PING_SYM) {
+		return _generator.apply(this, arguments);
+	}
+	function generatorWithErrorHandling() {
+		return _generatorWithErrorHandling.apply(this, arguments);
+	}
+	function _generatorWithErrorHandling() {
+		_generatorWithErrorHandling = (0, import_wrapAsyncGenerator$1.default)(function* () {
+			try {
+				yield* (0, import_asyncGeneratorDelegate.default)((0, import_asyncIterator.default)(generator()));
 				yield {
-					event: PING_EVENT,
+					event: RETURN_EVENT,
 					data: ""
 				};
-				continue;
+			} catch (cause) {
+				var _opts$formatError, _opts$formatError2;
+				if (isAbortError(cause)) return;
+				const error = require_tracked.getTRPCErrorFromUnknown(cause);
+				const data = (_opts$formatError = (_opts$formatError2 = opts.formatError) === null || _opts$formatError2 === void 0 ? void 0 : _opts$formatError2.call(opts, { error })) !== null && _opts$formatError !== void 0 ? _opts$formatError : null;
+				yield {
+					event: SERIALIZED_ERROR_EVENT,
+					data: JSON.stringify(serialize(data))
+				};
 			}
-			chunk = require_tracked.isTrackedEnvelope(value) ? {
-				id: value[0],
-				data: value[1]
-			} : { data: value };
-			chunk.data = JSON.stringify(serialize(chunk.data));
-			yield chunk;
-			value = null;
-			chunk = null;
-		}
-	}
-	async function* generatorWithErrorHandling() {
-		try {
-			yield* generator();
-			yield {
-				event: RETURN_EVENT,
-				data: ""
-			};
-		} catch (cause) {
-			if (isAbortError(cause)) return;
-			const error = require_tracked.getTRPCErrorFromUnknown(cause);
-			const data = opts.formatError?.({ error }) ?? null;
-			yield {
-				event: SERIALIZED_ERROR_EVENT,
-				data: JSON.stringify(serialize(data))
-			};
-		}
+		});
+		return _generatorWithErrorHandling.apply(this, arguments);
 	}
 	const stream = readableStreamFrom(generatorWithErrorHandling());
 	return stream.pipeThrough(new TransformStream({ transform(chunk, controller) {
@@ -1434,13 +1689,13 @@ function sseStreamConsumer(opts) {
 				try {
 					eventSource.close();
 					controller.close();
-				} catch {}
+				} catch (_unused) {}
 			};
 			if (signal.aborted) onAbort();
 			else signal.addEventListener("abort", onAbort);
 		},
 		cancel() {
-			_es?.close();
+			_es === null || _es === void 0 || _es.close();
 		}
 	});
 	const getStreamResource = () => {
@@ -1461,7 +1716,7 @@ function sseStreamConsumer(opts) {
 			}
 		}, dispose);
 	};
-	return require_utils.run(async function* () {
+	return require_utils.run((0, import_wrapAsyncGenerator$1.default)(function* () {
 		try {
 			var _usingCtx3 = (0, import_usingCtx.default)();
 			const stream = _usingCtx3.a(getStreamResource());
@@ -1484,16 +1739,16 @@ function sseStreamConsumer(opts) {
 						return res;
 					}
 				});
-				const result = await promise;
+				const result = yield (0, import_awaitAsyncGenerator.default)(promise);
 				if (result.done) return result.value;
 				yield result.value;
 			}
 		} catch (_) {
 			_usingCtx3.e = _;
 		} finally {
-			await _usingCtx3.d();
+			yield (0, import_awaitAsyncGenerator.default)(_usingCtx3.d());
 		}
-	});
+	}));
 }
 const sseHeaders = {
 	"Content-Type": "text/event-stream",
@@ -1504,10 +1759,12 @@ const sseHeaders = {
 
 //#endregion
 //#region src/unstable-core-do-not-import/http/resolveResponse.ts
+var import_wrapAsyncGenerator = require_getErrorShape.__toESM(require_wrapAsyncGenerator(), 1);
+var import_objectSpread2 = require_getErrorShape.__toESM(require_getErrorShape.require_objectSpread2(), 1);
 function errorToAsyncIterable(err) {
-	return require_utils.run(async function* () {
+	return require_utils.run((0, import_wrapAsyncGenerator.default)(function* () {
 		throw err;
-	});
+	}));
 }
 const TYPE_ACCEPTED_METHOD_MAP = {
 	mutation: ["POST"],
@@ -1520,19 +1777,23 @@ const TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE = {
 	subscription: ["GET", "POST"]
 };
 function initResponse(initOpts) {
+	var _responseMeta, _info$calls$find$proc, _info$calls$find;
 	const { ctx, info, responseMeta, untransformedJSON, errors = [], headers } = initOpts;
 	let status = untransformedJSON ? require_getErrorShape.getHTTPStatusCode(untransformedJSON) : 200;
 	const eagerGeneration = !untransformedJSON;
 	const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [untransformedJSON];
-	const meta = responseMeta?.({
+	const meta = (_responseMeta = responseMeta === null || responseMeta === void 0 ? void 0 : responseMeta({
 		ctx,
 		info,
-		paths: info?.calls.map((call) => call.path),
+		paths: info === null || info === void 0 ? void 0 : info.calls.map((call) => call.path),
 		data,
 		errors,
 		eagerGeneration,
-		type: info?.calls.find((call) => call.procedure?._def.type)?.procedure?._def.type ?? "unknown"
-	}) ?? {};
+		type: (_info$calls$find$proc = info === null || info === void 0 || (_info$calls$find = info.calls.find((call) => {
+			var _call$procedure;
+			return (_call$procedure = call.procedure) === null || _call$procedure === void 0 ? void 0 : _call$procedure._def.type;
+		})) === null || _info$calls$find === void 0 || (_info$calls$find = _info$calls$find.procedure) === null || _info$calls$find === void 0 ? void 0 : _info$calls$find._def.type) !== null && _info$calls$find$proc !== void 0 ? _info$calls$find$proc : "unknown"
+	})) !== null && _responseMeta !== void 0 ? _responseMeta : {};
 	if (meta.headers) {
 		if (meta.headers instanceof Headers) for (const [key, value] of meta.headers.entries()) headers.append(key, value);
 		else
@@ -1548,7 +1809,7 @@ function initResponse(initOpts) {
 function caughtErrorToData(cause, errorOpts) {
 	const { router, req, onError } = errorOpts.opts;
 	const error = require_tracked.getTRPCErrorFromUnknown(cause);
-	onError?.({
+	onError === null || onError === void 0 || onError({
 		error,
 		path: errorOpts.path,
 		input: errorOpts.input,
@@ -1583,13 +1844,14 @@ function isDataStream(v) {
 	return Object.values(v).some(isPromise) || Object.values(v).some(require_utils.isAsyncIterable);
 }
 async function resolveResponse(opts) {
+	var _ref, _opts$allowBatching, _opts$batching, _opts$allowMethodOver, _config$sse$enabled, _config$sse;
 	const { router, req } = opts;
 	const headers = new Headers([["vary", "trpc-accept"]]);
 	const config = router._def._config;
 	const url = new URL(req.url);
 	if (req.method === "HEAD") return new Response(null, { status: 204 });
-	const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
-	const allowMethodOverride = (opts.allowMethodOverride ?? false) && req.method === "POST";
+	const allowBatching = (_ref = (_opts$allowBatching = opts.allowBatching) !== null && _opts$allowBatching !== void 0 ? _opts$allowBatching : (_opts$batching = opts.batching) === null || _opts$batching === void 0 ? void 0 : _opts$batching.enabled) !== null && _ref !== void 0 ? _ref : true;
+	const allowMethodOverride = ((_opts$allowMethodOver = opts.allowMethodOverride) !== null && _opts$allowMethodOver !== void 0 ? _opts$allowMethodOver : false) && req.method === "POST";
 	const infoTuple = await require_utils.run(async () => {
 		try {
 			return [void 0, await getRequestInfo({
@@ -1632,7 +1894,7 @@ async function resolveResponse(opts) {
 	* @deprecated
 	*/
 	const isStreamCall = req.headers.get("trpc-accept") === "application/jsonl";
-	const experimentalSSE = config.sse?.enabled ?? true;
+	const experimentalSSE = (_config$sse$enabled = (_config$sse = config.sse) === null || _config$sse === void 0 ? void 0 : _config$sse.enabled) !== null && _config$sse$enabled !== void 0 ? _config$sse$enabled : true;
 	try {
 		const [infoError, info] = infoTuple;
 		if (infoError) throw infoError;
@@ -1674,14 +1936,15 @@ async function resolveResponse(opts) {
 				});
 				return [void 0, { data }];
 			} catch (cause) {
+				var _opts$onError, _call$procedure$_def$, _call$procedure2;
 				const error = require_tracked.getTRPCErrorFromUnknown(cause);
 				const input = call.result();
-				opts.onError?.({
+				(_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, {
 					error,
 					path: call.path,
 					input,
 					ctx: ctxManager.valueOrUndefined(),
-					type: call.procedure?._def.type ?? "unknown",
+					type: (_call$procedure$_def$ = (_call$procedure2 = call.procedure) === null || _call$procedure2 === void 0 ? void 0 : _call$procedure2._def.type) !== null && _call$procedure$_def$ !== void 0 ? _call$procedure$_def$ : "unknown",
 					req: opts.req
 				});
 				return [error, void 0];
@@ -1695,7 +1958,7 @@ async function resolveResponse(opts) {
 				case "mutation":
 				case "query": {
 					headers.set("content-type", "application/json");
-					if (isDataStream(result?.data)) throw new require_tracked.TRPCError({
+					if (isDataStream(result === null || result === void 0 ? void 0 : result.data)) throw new require_tracked.TRPCError({
 						code: "UNSUPPORTED_MEDIA_TYPE",
 						message: "Cannot use stream-like response in non-streaming request - use httpBatchStreamLink"
 					});
@@ -1734,16 +1997,16 @@ async function resolveResponse(opts) {
 						const dataAsIterable = require_observable.isObservable(result.data) ? require_observable.observableToAsyncIterable(result.data, opts.req.signal) : result.data;
 						return dataAsIterable;
 					});
-					const stream = sseStreamProducer({
-						...config.sse,
+					const stream = sseStreamProducer((0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, config.sse), {}, {
 						data: iterable,
 						serialize: (v) => config.transformer.output.serialize(v),
 						formatError(errorOpts) {
+							var _call$procedure$_def$2, _call$procedure3, _opts$onError2;
 							const error$1 = require_tracked.getTRPCErrorFromUnknown(errorOpts.error);
-							const input = call?.result();
-							const path = call?.path;
-							const type = call?.procedure?._def.type ?? "unknown";
-							opts.onError?.({
+							const input = call === null || call === void 0 ? void 0 : call.result();
+							const path = call === null || call === void 0 ? void 0 : call.path;
+							const type = (_call$procedure$_def$2 = call === null || call === void 0 || (_call$procedure3 = call.procedure) === null || _call$procedure3 === void 0 ? void 0 : _call$procedure3._def.type) !== null && _call$procedure$_def$2 !== void 0 ? _call$procedure$_def$2 : "unknown";
+							(_opts$onError2 = opts.onError) === null || _opts$onError2 === void 0 || _opts$onError2.call(opts, {
 								error: error$1,
 								path,
 								input,
@@ -1761,7 +2024,7 @@ async function resolveResponse(opts) {
 							});
 							return shape;
 						}
-					});
+					}));
 					for (const [key, value] of Object.entries(sseHeaders)) headers.set(key, value);
 					const headResponse$1 = initResponse({
 						ctx: ctxManager.valueOrUndefined(),
@@ -1789,20 +2052,22 @@ async function resolveResponse(opts) {
 				headers,
 				untransformedJSON: null
 			});
-			const stream = jsonlStreamProducer({
-				...config.jsonl,
+			const stream = jsonlStreamProducer((0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, config.jsonl), {}, {
 				maxDepth: Infinity,
 				data: rpcCalls.map(async (res) => {
 					const [error, result] = await res;
 					const call = info.calls[0];
-					if (error) return { error: require_getErrorShape.getErrorShape({
-						config,
-						ctx: ctxManager.valueOrUndefined(),
-						error,
-						input: call.result(),
-						path: call.path,
-						type: call.procedure?._def.type ?? "unknown"
-					}) };
+					if (error) {
+						var _procedure$_def$type, _procedure;
+						return { error: require_getErrorShape.getErrorShape({
+							config,
+							ctx: ctxManager.valueOrUndefined(),
+							error,
+							input: call.result(),
+							path: call.path,
+							type: (_procedure$_def$type = (_procedure = call.procedure) === null || _procedure === void 0 ? void 0 : _procedure._def.type) !== null && _procedure$_def$type !== void 0 ? _procedure$_def$type : "unknown"
+						}) };
+					}
 					/**
 					* Not very pretty, but we need to wrap nested data in promises
 					* Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
@@ -1812,21 +2077,23 @@ async function resolveResponse(opts) {
 				}),
 				serialize: config.transformer.output.serialize,
 				onError: (cause) => {
-					opts.onError?.({
+					var _opts$onError3, _info$type;
+					(_opts$onError3 = opts.onError) === null || _opts$onError3 === void 0 || _opts$onError3.call(opts, {
 						error: require_tracked.getTRPCErrorFromUnknown(cause),
 						path: void 0,
 						input: void 0,
 						ctx: ctxManager.valueOrUndefined(),
 						req: opts.req,
-						type: info?.type ?? "unknown"
+						type: (_info$type = info === null || info === void 0 ? void 0 : info.type) !== null && _info$type !== void 0 ? _info$type : "unknown"
 					});
 				},
 				formatError(errorOpts) {
-					const call = info?.calls[errorOpts.path[0]];
+					var _call$procedure$_def$3, _call$procedure4;
+					const call = info === null || info === void 0 ? void 0 : info.calls[errorOpts.path[0]];
 					const error = require_tracked.getTRPCErrorFromUnknown(errorOpts.error);
-					const input = call?.result();
-					const path = call?.path;
-					const type = call?.procedure?._def.type ?? "unknown";
+					const input = call === null || call === void 0 ? void 0 : call.result();
+					const path = call === null || call === void 0 ? void 0 : call.path;
+					const type = (_call$procedure$_def$3 = call === null || call === void 0 || (_call$procedure4 = call.procedure) === null || _call$procedure4 === void 0 ? void 0 : _call$procedure4._def.type) !== null && _call$procedure$_def$3 !== void 0 ? _call$procedure$_def$3 : "unknown";
 					const shape = require_getErrorShape.getErrorShape({
 						config,
 						ctx: ctxManager.valueOrUndefined(),
@@ -1837,7 +2104,7 @@ async function resolveResponse(opts) {
 					});
 					return shape;
 				}
-			});
+			}));
 			return new Response(stream, {
 				headers,
 				status: headResponse$1.status
@@ -1861,14 +2128,17 @@ async function resolveResponse(opts) {
 		});
 		const resultAsRPCResponse = results.map(([error, result], index) => {
 			const call = info.calls[index];
-			if (error) return { error: require_getErrorShape.getErrorShape({
-				config,
-				ctx: ctxManager.valueOrUndefined(),
-				error,
-				input: call.result(),
-				path: call.path,
-				type: call.procedure?._def.type ?? "unknown"
-			}) };
+			if (error) {
+				var _call$procedure$_def$4, _call$procedure5;
+				return { error: require_getErrorShape.getErrorShape({
+					config,
+					ctx: ctxManager.valueOrUndefined(),
+					error,
+					input: call.result(),
+					path: call.path,
+					type: (_call$procedure$_def$4 = (_call$procedure5 = call.procedure) === null || _call$procedure5 === void 0 ? void 0 : _call$procedure5._def.type) !== null && _call$procedure$_def$4 !== void 0 ? _call$procedure$_def$4 : "unknown"
+				}) };
+			}
 			return { result: { data: result.data } };
 		});
 		const errors = results.map(([error]) => error).filter(Boolean);
@@ -1885,12 +2155,13 @@ async function resolveResponse(opts) {
 			headers
 		});
 	} catch (cause) {
+		var _info$type2;
 		const [_infoError, info] = infoTuple;
 		const ctx = ctxManager.valueOrUndefined();
 		const { error, untransformedJSON, body } = caughtErrorToData(cause, {
 			opts,
 			ctx: ctxManager.valueOrUndefined(),
-			type: info?.type ?? "unknown"
+			type: (_info$type2 = info === null || info === void 0 ? void 0 : info.type) !== null && _info$type2 !== void 0 ? _info$type2 : "unknown"
 		});
 		const headResponse = initResponse({
 			ctx,
@@ -1914,18 +2185,6 @@ Object.defineProperty(exports, 'Unpromise', {
     return Unpromise;
   }
 });
-Object.defineProperty(exports, '__commonJS', {
-  enumerable: true,
-  get: function () {
-    return __commonJS;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
 Object.defineProperty(exports, 'createDeferred', {
   enumerable: true,
   get: function () {