@trpc/client 11.4.0 → 11.4.2-canary.1

package/dist/index.mjs

@@ -1,66 +1,44 @@
-import { createChain, splitLink } from "./splitLink-BVblHq4n.mjs";
-import { TRPCClientError, isTRPCClientError } from "./TRPCClientError-COkhCKf3.mjs";
-import { fetchHTTPResponse, getBody, getFetch, getUrl, resolveHTTPLinkOptions } from "./httpUtils-3pbQzhUL.mjs";
-import { httpLink, isFormData, isNonJsonSerializable, isOctetType } from "./httpLink-9bpwQ15c.mjs";
-import { abortSignalToPromise, allAbortSignals, dataLoader, httpBatchLink, raceAbortSignals } from "./httpBatchLink-DIfnmmcu.mjs";
-import { getTransformer } from "./unstable-internals-DU4WecoG.mjs";
-import { loggerLink } from "./loggerLink-PGBSQFcR.mjs";
-import { createWSClient, resultOf, wsLink } from "./wsLink-DbSHOzlB.mjs";
+import { __commonJS, __toESM, require_defineProperty, require_objectSpread2 } from "./objectSpread2-BvkFp-_Y.mjs";
+import { createChain, splitLink } from "./splitLink-B7Cuf2c_.mjs";
+import { TRPCClientError, isTRPCClientError } from "./TRPCClientError-CjKyS10w.mjs";
+import { fetchHTTPResponse, getBody, getFetch, getUrl, resolveHTTPLinkOptions } from "./httpUtils-ZiawzpnD.mjs";
+import { httpLink, isFormData, isNonJsonSerializable, isOctetType } from "./httpLink-Dptv1zSJ.mjs";
+import { abortSignalToPromise, allAbortSignals, dataLoader, httpBatchLink, raceAbortSignals } from "./httpBatchLink-BfUVex5U.mjs";
+import { getTransformer } from "./unstable-internals-Bg7n9BBj.mjs";
+import { loggerLink } from "./loggerLink-ineCN1PO.mjs";
+import { createWSClient, resultOf, wsLink } from "./wsLink-H5IjZfJW.mjs";
 import { behaviorSubject, observable, observableToPromise, share } from "@trpc/server/observable";
 import { callProcedure, createFlatProxy, createRecursiveProxy, isAbortError, isAsyncIterable, iteratorResource, jsonlStreamConsumer, makeResource, retryableRpcCodes, run, sseStreamConsumer } from "@trpc/server/unstable-core-do-not-import";
 import { getTRPCErrorFromUnknown, getTRPCErrorShape, isTrackedEnvelope } from "@trpc/server";
 import { TRPC_ERROR_CODES_BY_KEY } from "@trpc/server/rpc";
 
-//#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
 //#region src/internals/TRPCUntypedClient.ts
+var import_defineProperty = __toESM(require_defineProperty(), 1);
+var import_objectSpread2$4 = __toESM(require_objectSpread2(), 1);
 var TRPCUntypedClient = class {
-	links;
-	runtime;
-	requestId;
 	constructor(opts) {
+		(0, import_defineProperty.default)(this, "links", void 0);
+		(0, import_defineProperty.default)(this, "runtime", void 0);
+		(0, import_defineProperty.default)(this, "requestId", void 0);
 		this.requestId = 0;
 		this.runtime = {};
 		this.links = opts.links.map((link) => link(this.runtime));
 	}
 	$request(opts) {
+		var _opts$context;
 		const chain$ = createChain({
 			links: this.links,
-			op: {
-				...opts,
-				context: opts.context ?? {},
+			op: (0, import_objectSpread2$4.default)((0, import_objectSpread2$4.default)({}, opts), {}, {
+				context: (_opts$context = opts.context) !== null && _opts$context !== void 0 ? _opts$context : {},
 				id: ++this.requestId
-			}
+			})
 		});
 		return chain$.pipe(share());
 	}
 	async requestAsPromise(opts) {
+		var _this = this;
 		try {
-			const req$ = this.$request(opts);
+			const req$ = _this.$request(opts);
 			const envelope = await observableToPromise(req$);
 			const data = envelope.result.data;
 			return data;
@@ -73,8 +51,8 @@ var TRPCUntypedClient = class {
 			type: "query",
 			path,
 			input,
-			context: opts?.context,
-			signal: opts?.signal
+			context: opts === null || opts === void 0 ? void 0 : opts.context,
+			signal: opts === null || opts === void 0 ? void 0 : opts.signal
 		});
 	}
 	mutation(path, input, opts) {
@@ -82,8 +60,8 @@ var TRPCUntypedClient = class {
 			type: "mutation",
 			path,
 			input,
-			context: opts?.context,
-			signal: opts?.signal
+			context: opts === null || opts === void 0 ? void 0 : opts.context,
+			signal: opts === null || opts === void 0 ? void 0 : opts.signal
 		});
 	}
 	subscription(path, input, opts) {
@@ -98,29 +76,35 @@ var TRPCUntypedClient = class {
 			next(envelope) {
 				switch (envelope.result.type) {
 					case "state": {
-						opts.onConnectionStateChange?.(envelope.result);
+						var _opts$onConnectionSta;
+						(_opts$onConnectionSta = opts.onConnectionStateChange) === null || _opts$onConnectionSta === void 0 || _opts$onConnectionSta.call(opts, envelope.result);
 						break;
 					}
 					case "started": {
-						opts.onStarted?.({ context: envelope.context });
+						var _opts$onStarted;
+						(_opts$onStarted = opts.onStarted) === null || _opts$onStarted === void 0 || _opts$onStarted.call(opts, { context: envelope.context });
 						break;
 					}
 					case "stopped": {
-						opts.onStopped?.();
+						var _opts$onStopped;
+						(_opts$onStopped = opts.onStopped) === null || _opts$onStopped === void 0 || _opts$onStopped.call(opts);
 						break;
 					}
 					case "data":
 					case void 0: {
-						opts.onData?.(envelope.result.data);
+						var _opts$onData;
+						(_opts$onData = opts.onData) === null || _opts$onData === void 0 || _opts$onData.call(opts, envelope.result.data);
 						break;
 					}
 				}
 			},
 			error(err) {
-				opts.onError?.(err);
+				var _opts$onError;
+				(_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, err);
 			},
 			complete() {
-				opts.onComplete?.();
+				var _opts$onComplete;
+				(_opts$onComplete = opts.onComplete) === null || _opts$onComplete === void 0 || _opts$onComplete.call(opts);
 			}
 		});
 	}
@@ -174,13 +158,15 @@ function getUntypedClient(client) {
 
 //#endregion
 //#region src/links/httpBatchStreamLink.ts
+var import_objectSpread2$3 = __toESM(require_objectSpread2(), 1);
 /**
 * @see https://trpc.io/docs/client/links/httpBatchStreamLink
 */
 function httpBatchStreamLink(opts) {
+	var _opts$maxURLLength, _opts$maxItems;
 	const resolvedOpts = resolveHTTPLinkOptions(opts);
-	const maxURLLength = opts.maxURLLength ?? Infinity;
-	const maxItems = opts.maxItems ?? Infinity;
+	const maxURLLength = (_opts$maxURLLength = opts.maxURLLength) !== null && _opts$maxURLLength !== void 0 ? _opts$maxURLLength : Infinity;
+	const maxItems = (_opts$maxItems = opts.maxItems) !== null && _opts$maxItems !== void 0 ? _opts$maxItems : Infinity;
 	return () => {
 		const batchLoader = (type) => {
 			return {
@@ -189,13 +175,12 @@ function httpBatchStreamLink(opts) {
 					if (batchOps.length > maxItems) return false;
 					const path = batchOps.map((op) => op.path).join(",");
 					const inputs = batchOps.map((op) => op.input);
-					const url = getUrl({
-						...resolvedOpts,
+					const url = getUrl((0, import_objectSpread2$3.default)((0, import_objectSpread2$3.default)({}, resolvedOpts), {}, {
 						type,
 						path,
 						inputs,
 						signal: null
-					});
+					}));
 					return url.length <= maxURLLength;
 				},
 				async fetch(batchOps) {
@@ -203,8 +188,7 @@ function httpBatchStreamLink(opts) {
 					const inputs = batchOps.map((op) => op.input);
 					const batchSignals = allAbortSignals(...batchOps.map((op) => op.signal));
 					const abortController = new AbortController();
-					const responsePromise = fetchHTTPResponse({
-						...resolvedOpts,
+					const responsePromise = fetchHTTPResponse((0, import_objectSpread2$3.default)((0, import_objectSpread2$3.default)({}, resolvedOpts), {}, {
 						signal: raceAbortSignals(batchSignals, abortController.signal),
 						type,
 						contentTypeHeader: "application/json",
@@ -218,7 +202,7 @@ function httpBatchStreamLink(opts) {
 							if (typeof opts.headers === "function") return opts.headers({ opList: batchOps });
 							return opts.headers;
 						}
-					});
+					}));
 					const res = await responsePromise;
 					const [head] = await jsonlStreamConsumer({
 						from: res.body,
@@ -276,7 +260,7 @@ function httpBatchStreamLink(opts) {
 					}
 					observer.complete();
 				}).catch((err) => {
-					observer.error(TRPCClientError.from(err, { meta: _res?.meta }));
+					observer.error(TRPCClientError.from(err, { meta: _res === null || _res === void 0 ? void 0 : _res.meta }));
 				});
 				return () => {};
 			});
@@ -290,17 +274,63 @@ const unstable_httpBatchStreamLink = httpBatchStreamLink;
 
 //#endregion
 //#region src/internals/inputWithTrackedEventId.ts
+var import_objectSpread2$2 = __toESM(require_objectSpread2(), 1);
 function inputWithTrackedEventId(input, lastEventId) {
 	if (!lastEventId) return input;
 	if (input != null && typeof input !== "object") return input;
-	return {
-		...input ?? {},
-		lastEventId
-	};
+	return (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, input !== null && input !== void 0 ? input : {}), {}, { lastEventId });
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js
+var require_asyncIterator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+	function _asyncIterator$1(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$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/links/httpSubscriptionLink.ts
+var import_asyncIterator = __toESM(require_asyncIterator(), 1);
 async function urlWithConnectionParams(opts) {
 	let url = await resultOf(opts.url);
 	if (opts.connectionParams) {
@@ -318,6 +348,7 @@ function httpSubscriptionLink(opts) {
 	return () => {
 		return ({ op }) => {
 			return observable((observer) => {
+				var _opts$EventSource;
 				const { type, path, input } = op;
 				/* istanbul ignore if -- @preserve */
 				if (type !== "subscription") throw new Error("httpSubscriptionLink only supports subscriptions");
@@ -336,7 +367,7 @@ function httpSubscriptionLink(opts) {
 					init: () => resultOf(opts.eventSourceOptions, { op }),
 					signal,
 					deserialize: transformer.output.deserialize,
-					EventSource: opts.EventSource ?? globalThis.EventSource
+					EventSource: (_opts$EventSource = opts.EventSource) !== null && _opts$EventSource !== void 0 ? _opts$EventSource : globalThis.EventSource
 				});
 				const connectionState = behaviorSubject({
 					type: "state",
@@ -347,63 +378,80 @@ function httpSubscriptionLink(opts) {
 					observer.next({ result: state });
 				} });
 				run(async () => {
-					for await (const chunk of eventSourceStream) switch (chunk.type) {
-						case "ping": break;
-						case "data":
-							const chunkData = chunk.data;
-							let result;
-							if (chunkData.id) {
-								lastEventId = chunkData.id;
-								result = {
-									id: chunkData.id,
-									data: chunkData
-								};
-							} else result = { data: chunkData.data };
-							observer.next({
-								result,
-								context: { eventSource: chunk.eventSource }
-							});
-							break;
-						case "connected": {
-							observer.next({
-								result: { type: "started" },
-								context: { eventSource: chunk.eventSource }
-							});
-							connectionState.next({
-								type: "state",
-								state: "pending",
-								error: null
-							});
-							break;
-						}
-						case "serialized-error": {
-							const error = TRPCClientError.from({ error: chunk.error });
-							if (retryableRpcCodes.includes(chunk.error.code)) {
-								connectionState.next({
+					var _iteratorAbruptCompletion = false;
+					var _didIteratorError = false;
+					var _iteratorError;
+					try {
+						for (var _iterator = (0, import_asyncIterator.default)(eventSourceStream), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
+							const chunk = _step.value;
+							switch (chunk.type) {
+								case "ping": break;
+								case "data":
+									const chunkData = chunk.data;
+									let result;
+									if (chunkData.id) {
+										lastEventId = chunkData.id;
+										result = {
+											id: chunkData.id,
+											data: chunkData
+										};
+									} else result = { data: chunkData.data };
+									observer.next({
+										result,
+										context: { eventSource: chunk.eventSource }
+									});
+									break;
+								case "connected": {
+									observer.next({
+										result: { type: "started" },
+										context: { eventSource: chunk.eventSource }
+									});
+									connectionState.next({
+										type: "state",
+										state: "pending",
+										error: null
+									});
+									break;
+								}
+								case "serialized-error": {
+									const error = TRPCClientError.from({ error: chunk.error });
+									if (retryableRpcCodes.includes(chunk.error.code)) {
+										connectionState.next({
+											type: "state",
+											state: "connecting",
+											error
+										});
+										break;
+									}
+									throw error;
+								}
+								case "connecting": {
+									const lastState = connectionState.get();
+									const error = chunk.event && TRPCClientError.from(chunk.event);
+									if (!error && lastState.state === "connecting") break;
+									connectionState.next({
+										type: "state",
+										state: "connecting",
+										error
+									});
+									break;
+								}
+								case "timeout": connectionState.next({
 									type: "state",
 									state: "connecting",
-									error
+									error: new TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
 								});
-								break;
 							}
-							throw error;
 						}
-						case "connecting": {
-							const lastState = connectionState.get();
-							const error = chunk.event && TRPCClientError.from(chunk.event);
-							if (!error && lastState.state === "connecting") break;
-							connectionState.next({
-								type: "state",
-								state: "connecting",
-								error
-							});
-							break;
+					} catch (err) {
+						_didIteratorError = true;
+						_iteratorError = err;
+					} finally {
+						try {
+							if (_iteratorAbruptCompletion && _iterator.return != null) await _iterator.return();
+						} finally {
+							if (_didIteratorError) throw _iteratorError;
 						}
-						case "timeout": connectionState.next({
-							type: "state",
-							state: "connecting",
-							error: new TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
-						});
 					}
 					observer.next({ result: { type: "stopped" } });
 					connectionState.next({
@@ -431,6 +479,7 @@ const unstable_httpSubscriptionLink = httpSubscriptionLink;
 
 //#endregion
 //#region src/links/retryLink.ts
+var import_objectSpread2$1 = __toESM(require_objectSpread2(), 1);
 /**
 * @see https://trpc.io/docs/v11/client/links/retryLink
 */
@@ -445,15 +494,13 @@ function retryLink(opts) {
 				function opWithLastEventId() {
 					const op = callOpts.op;
 					if (!lastEventId) return op;
-					return {
-						...op,
-						input: inputWithTrackedEventId(op.input, lastEventId)
-					};
+					return (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, op), {}, { input: inputWithTrackedEventId(op.input, lastEventId) });
 				}
 				function attempt(attempts) {
 					const op = opWithLastEventId();
 					next$ = callOpts.next(op).subscribe({
 						error(error) {
+							var _opts$retryDelayMs, _opts$retryDelayMs2;
 							const shouldRetry = opts.retry({
 								op,
 								attempts,
@@ -463,7 +510,7 @@ function retryLink(opts) {
 								observer.error(error);
 								return;
 							}
-							const delayMs = opts.retryDelayMs?.(attempts) ?? 0;
+							const delayMs = (_opts$retryDelayMs = (_opts$retryDelayMs2 = opts.retryDelayMs) === null || _opts$retryDelayMs2 === void 0 ? void 0 : _opts$retryDelayMs2.call(opts, attempts)) !== null && _opts$retryDelayMs !== void 0 ? _opts$retryDelayMs : 0;
 							if (delayMs <= 0) {
 								attempt(attempts + 1);
 								return;
@@ -548,9 +595,102 @@ 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 = __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 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+	var OverloadYield$1 = require_OverloadYield();
+	function _awaitAsyncGenerator$1(e) {
+		return new OverloadYield$1(e, 0);
+	}
+	module.exports = _awaitAsyncGenerator$1, 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 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+	var OverloadYield = require_OverloadYield();
+	function _wrapAsyncGenerator$1(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;
+				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$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/links/localLink.ts
 var import_usingCtx = __toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator = __toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator = __toESM(require_wrapAsyncGenerator(), 1);
+var import_objectSpread2 = __toESM(require_objectSpread2(), 1);
 /**
 * localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.
 *
@@ -585,8 +725,9 @@ function unstable_localLink(opts) {
 			});
 		}
 		function onErrorCallback(cause) {
+			var _opts$onError;
 			if (isAbortError(cause)) return;
-			opts.onError?.({
+			(_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, {
 				error: getTRPCErrorFromUnknown(cause),
 				type: op.type,
 				path: op.path,
@@ -617,7 +758,7 @@ function unstable_localLink(opts) {
 						observer.complete();
 						break;
 					}
-					observer.next({ result: { data: async function* () {
+					observer.next({ result: { data: (0, import_wrapAsyncGenerator.default)(function* () {
 						try {
 							var _usingCtx$1 = (0, import_usingCtx.default)();
 							const iterator = _usingCtx$1.a(iteratorResource(result));
@@ -626,7 +767,7 @@ function unstable_localLink(opts) {
 							}));
 							try {
 								while (true) {
-									const res = await Promise.race([iterator.next(), signalPromise]);
+									const res = yield (0, import_awaitAsyncGenerator.default)(Promise.race([iterator.next(), signalPromise]));
 									if (res.done) return transformChunk(res.value);
 									yield transformChunk(res.value);
 								}
@@ -637,9 +778,9 @@ function unstable_localLink(opts) {
 						} catch (_) {
 							_usingCtx$1.e = _;
 						} finally {
-							await _usingCtx$1.d();
+							yield (0, import_awaitAsyncGenerator.default)(_usingCtx$1.d());
 						}
-					}() } });
+					})() } });
 					break;
 				}
 				case "subscription": try {
@@ -701,10 +842,7 @@ function unstable_localLink(opts) {
 									}
 								};
 							} else chunk = { data: res.value };
-							observer.next({ result: {
-								...chunk,
-								data: transformChunk(chunk.data)
-							} });
+							observer.next({ result: (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, chunk), {}, { data: transformChunk(chunk.data) }) });
 						}
 					} catch (_) {
 						_usingCtx4.e = _;