mlform 0.1.2 → 0.1.4

package/dist/transport-A1RsnZhD.js

@@ -0,0 +1,2143 @@
+//#region src/shared/errors.ts
+var e = class extends Error {
+	constructor(e) {
+		super(e), this.name = "MLFormError";
+	}
+}, t = {
+	TIMEOUT: "TIMEOUT",
+	AUTH_FAILED: "AUTH_FAILED",
+	RATE_LIMITED: "RATE_LIMITED",
+	OPEN_CIRCUIT: "OPEN_CIRCUIT",
+	PARSE_FAILED: "PARSE_FAILED",
+	UPSTREAM_5XX: "UPSTREAM_5XX",
+	ABORTED: "ABORTED",
+	CAPABILITY_MISMATCH: "CAPABILITY_MISMATCH",
+	PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+	SESSION_RESULT_MISSING: "SESSION_RESULT_MISSING",
+	GRAPHQL_ERROR: "GRAPHQL_ERROR",
+	WEBSOCKET_BUFFER_OVERFLOW: "WEBSOCKET_BUFFER_OVERFLOW",
+	POLICY_STORE_CONFLICT: "POLICY_STORE_CONFLICT",
+	QUORUM_NOT_REACHED: "QUORUM_NOT_REACHED"
+}, n = class extends e {
+	cause;
+	source;
+	status;
+	code;
+	retryable;
+	details;
+	response;
+	constructor(e, t = {}) {
+		super(e), this.name = "TransportError", this.cause = t.cause, this.source = t.source, this.status = t.status, this.code = t.code, this.retryable = t.retryable, this.details = t.details, this.response = t.response;
+	}
+}, r = {
+	method: "POST",
+	acceptHeader: "application/json",
+	contentTypeHeader: "application/json",
+	requestBodyKey: "inputs"
+}, i = {
+	missingFetch: "A fetch implementation is required to use the default transport.",
+	unsupportedMethod: (e) => `Unsupported HTTP method "${e}" for createJsonTransport. Use POST, PUT, PATCH, or DELETE.`,
+	requestFailed: (e, t) => `Request failed with status ${e}${t ? ` ${t}` : ""}.`,
+	emptyComposedTransport: (e) => `${e} requires at least one transport.`,
+	unknownComposedTransport: (e, t, n) => `${e} selected unknown transport "${t}". Available transports: ${n.join(", ")}.`,
+	duplicateFanoutReport: (e, t, n) => `createFanoutTransport received report "${e}" from both ${t} and ${n}. Provide unique report ids or a custom merge implementation.`,
+	fanoutFailed: (e) => `createFanoutTransport failed for ${e.join(", ")}.`,
+	fanoutEmpty: "createFanoutTransport: all transports filtered out. No submissions dispatched.",
+	fallbackFailed: (e) => `createFallbackTransport exhausted all transports: ${e.join(", ")}.`,
+	emptyPipeline: "createPipelineTransport requires at least one stage.",
+	pipelineAborted: (e) => `createPipelineTransport: aborted during stage "${e}".`,
+	racingAllFailed: "createRacingTransport: all transports failed.",
+	missingStream: (e) => `${e} does not support streaming.`,
+	retryInvalidAttempts: "withRetry: attempts must be at least 1.",
+	timeoutInvalid: "withTimeout: timeout must be a positive number.",
+	retryUnsafe: "withRetry: transport declares retrySafe=false. Pass `allowUnsafeRetry: true` to override.",
+	cacheUnsafe: "withCache: transport declares cacheable=false. Pass `allowUnsafeCache: true` to override.",
+	circuitInvalidFailureThreshold: "withCircuitBreaker: failureThreshold must be at least 1.",
+	circuitInvalidResetTimeout: "withCircuitBreaker: resetTimeout must be a positive number.",
+	rateLimitInvalid: "withRateLimit: provide at least one positive maxConcurrent or perSecond limit.",
+	rateLimitQueueFull: "withRateLimit: queue limit exceeded.",
+	cacheInvalidTtl: "withCache: ttl must be a positive number.",
+	circuitOpen: (e) => `Transport circuit is open for ${e}.`,
+	hedgedUnsafe: "createHedgedTransport: every transport must declare retrySafe !== false or allowUnsafeHedging must be true.",
+	sseInvalidEvent: "createSseTransport: failed to parse SSE event payload.",
+	websocketMissing: "createWebSocketSessionTransport requires a WebSocket implementation in this environment."
+}, a = {
+	modes: {
+		submit: !0,
+		stream: !1,
+		session: !1
+	},
+	safety: {
+		idempotent: !1,
+		retrySafe: !1,
+		cacheable: !1,
+		hedgeSafe: !1
+	},
+	limits: {},
+	auth: { kinds: ["none"] },
+	delivery: {
+		mode: "request-response",
+		consistency: "unknown",
+		backpressure: "none"
+	}
+}, o = (e) => [...new Set(e)], s = (e, t) => {
+	let n = e ?? {}, r = t ?? {}, i = {
+		...a.modes,
+		...r.modes,
+		...n.modes
+	}, s = !!i.session, c = !!i.stream;
+	return {
+		modes: {
+			submit: i.submit !== !1,
+			stream: c,
+			session: s
+		},
+		safety: {
+			...a.safety,
+			...r.safety,
+			...n.safety
+		},
+		limits: {
+			...a.limits,
+			...r.limits,
+			...n.limits
+		},
+		auth: { kinds: o([...r.auth?.kinds ?? [], ...n.auth?.kinds ?? a.auth.kinds]) },
+		delivery: {
+			mode: n.delivery?.mode ?? r.delivery?.mode ?? (s ? "session" : c ? "stream" : "request-response"),
+			consistency: n.delivery?.consistency ?? r.delivery?.consistency ?? a.delivery.consistency,
+			backpressure: n.delivery?.backpressure ?? r.delivery?.backpressure ?? a.delivery.backpressure
+		}
+	};
+}, c = (e, t) => {
+	if (!(!e && !t)) return s({
+		modes: {
+			submit: e?.modes.submit !== !1 && t?.modes.submit !== !1,
+			stream: !!(e?.modes.stream || t?.modes.stream),
+			session: !!(e?.modes.session || t?.modes.session)
+		},
+		safety: {
+			idempotent: !!(e?.safety.idempotent && t?.safety.idempotent),
+			retrySafe: !!(e?.safety.retrySafe && t?.safety.retrySafe),
+			cacheable: !!(e?.safety.cacheable && t?.safety.cacheable),
+			hedgeSafe: !!(e?.safety.hedgeSafe && t?.safety.hedgeSafe)
+		},
+		limits: {
+			maxPayloadBytes: e?.limits.maxPayloadBytes === void 0 ? t?.limits.maxPayloadBytes : t?.limits.maxPayloadBytes === void 0 ? e.limits.maxPayloadBytes : Math.min(e.limits.maxPayloadBytes, t.limits.maxPayloadBytes),
+			maxBufferedMessages: e?.limits.maxBufferedMessages === void 0 ? t?.limits.maxBufferedMessages : t?.limits.maxBufferedMessages === void 0 ? e.limits.maxBufferedMessages : Math.min(e.limits.maxBufferedMessages, t.limits.maxBufferedMessages)
+		},
+		auth: { kinds: o([...e?.auth.kinds ?? [], ...t?.auth.kinds ?? []]) },
+		delivery: {
+			mode: t?.delivery.mode ?? e?.delivery.mode ?? a.delivery.mode,
+			consistency: t?.delivery.consistency ?? e?.delivery.consistency ?? a.delivery.consistency,
+			backpressure: t?.delivery.backpressure ?? e?.delivery.backpressure ?? a.delivery.backpressure
+		}
+	}, { modes: {
+		submit: e?.modes.submit !== !1 && t?.modes.submit !== !1,
+		stream: !!(e?.modes.stream || t?.modes.stream),
+		session: !!(e?.modes.session || t?.modes.session)
+	} });
+}, l = (e) => s(e.capabilities, {
+	modes: {
+		submit: !0,
+		stream: e.stream !== void 0,
+		session: e.openSession !== void 0
+	},
+	delivery: {
+		mode: e.openSession ? "session" : e.stream ? "stream" : "request-response",
+		backpressure: e.openSession ? "bounded-buffer" : "none",
+		consistency: "unknown"
+	}
+}), u = (e) => e ? s(JSON.parse(JSON.stringify(e))) : void 0, d = (e, r, i) => {
+	let a = l(e);
+	if (r.modes) {
+		for (let [e, o] of Object.entries(r.modes)) if (o !== void 0 && a.modes[e] !== o) throw new n(`${i}: transport does not satisfy mode "${e}=${o}".`, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: {
+				requirement: r,
+				capabilities: a
+			}
+		});
+	}
+	if (r.safety) {
+		for (let [e, o] of Object.entries(r.safety)) if (o !== void 0 && a.safety[e] !== o) throw new n(`${i}: transport does not satisfy safety "${e}=${o}".`, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: {
+				requirement: r,
+				capabilities: a
+			}
+		});
+	}
+	if (r.authKinds?.length) {
+		let e = new Set(a.auth.kinds);
+		for (let o of r.authKinds) if (!e.has(o)) throw new n(`${i}: transport does not support auth kind "${o}".`, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: {
+				requirement: r,
+				capabilities: a
+			}
+		});
+	}
+	let o = r.maxPayloadBytes;
+	if (o !== void 0 && a.limits.maxPayloadBytes !== void 0 && a.limits.maxPayloadBytes < o) throw new n(`${i}: transport maxPayloadBytes ${a.limits.maxPayloadBytes} is below required ${o}.`, {
+		code: t.CAPABILITY_MISMATCH,
+		retryable: !1,
+		details: {
+			requirement: r,
+			capabilities: a
+		}
+	});
+}, f = (e, r, i) => {
+	let a = l(e), o = a.limits.maxPayloadBytes, s = r.metadata?.estimatedPayloadBytes;
+	if (o !== void 0 && s !== void 0 && s > o) throw new n(`${i}: estimated payload ${s} exceeds maxPayloadBytes ${o}.`, {
+		code: t.PAYLOAD_TOO_LARGE,
+		retryable: !1,
+		details: {
+			estimatedPayloadBytes: s,
+			maxPayloadBytes: o,
+			capabilities: a
+		}
+	});
+}, p = "__policy", m = (e) => ({ ...e }), h = (e) => {
+	let t = e.transport?.attributes?.[p], n = e.transport?.policy ?? (typeof t == "object" && t ? t : void 0) ?? {
+		scope: e.backend ?? "transport",
+		backend: e.backend
+	};
+	return {
+		scope: n.scope || e.backend || "transport",
+		source: n.source,
+		backend: n.backend ?? e.backend,
+		requestId: n.requestId
+	};
+}, g = (e, t) => {
+	let n = h(e), r = {
+		...n,
+		...t,
+		scope: t.scope ?? n.scope,
+		backend: t.backend ?? n.backend ?? e.backend
+	}, i = {
+		...e.transport,
+		policy: r,
+		attributes: {
+			...m(e.transport?.attributes),
+			[p]: r
+		}
+	};
+	return {
+		...e,
+		transport: i
+	};
+}, _ = (e) => typeof e == "object" && !!e && !Array.isArray(e), v = (e) => {
+	if (typeof e != "object" || !e) return e;
+	if (e instanceof Date) return new Date(e.getTime());
+	if (e instanceof Map) return new Map(Array.from(e.entries(), ([e, t]) => [v(e), v(t)]));
+	if (e instanceof Set) return new Set(Array.from(e, (e) => v(e)));
+	if (Array.isArray(e)) return e.map((e) => v(e));
+	if (_(e)) {
+		let t = {};
+		for (let n of Object.keys(e)) t[n] = v(e[n]);
+		return t;
+	}
+	return e;
+}, y = (e) => typeof e == "object" && !!e && !Array.isArray(e), b = (e) => e instanceof Error && (e.name === "AbortError" || e.message.toLowerCase().includes("aborted")), x = (e, t, n) => {
+	let r = { submit: e };
+	return t && (r.stream = t), n?.openSession && (r.openSession = n.openSession), r.capabilities = s(n?.capabilities, {
+		modes: {
+			submit: !0,
+			stream: !!t,
+			session: !!n?.openSession
+		},
+		delivery: {
+			mode: n?.openSession ? "session" : t ? "stream" : "request-response",
+			consistency: "unknown",
+			backpressure: n?.openSession ? "bounded-buffer" : "none"
+		}
+	}), r;
+}, S = () => {
+	let e = [], t = [], n = !1;
+	return {
+		push(r) {
+			if (n) return;
+			let i = t.shift();
+			if (i) {
+				i({
+					value: r,
+					done: !1
+				});
+				return;
+			}
+			e.push(r);
+		},
+		close() {
+			if (!n) for (n = !0; t.length > 0;) t.shift()?.({
+				value: void 0,
+				done: !0
+			});
+		},
+		[Symbol.asyncIterator]() {
+			return { next: () => {
+				let r = e.shift();
+				return r === void 0 ? n ? Promise.resolve({
+					value: void 0,
+					done: !0
+				}) : new Promise((e) => {
+					t.push(e);
+				}) : Promise.resolve({
+					value: r,
+					done: !1
+				});
+			} };
+		}
+	};
+}, C = async (e, t) => {
+	if (d(e, { modes: { stream: !0 } }, "resolveStream"), f(e, t, "resolveStream"), !e.stream) throw new n(i.missingStream("Transport"), {
+		code: "STREAM_UNSUPPORTED",
+		retryable: !1
+	});
+	return e.stream(t);
+}, w = (e, t) => {
+	let n = new Headers(e);
+	if (!t) return n;
+	for (let [e, r] of new Headers(t).entries()) n.set(e, r);
+	return n;
+}, T = (e, t) => t.transport?.credentials ?? e, E = (e, t) => g({
+	...e,
+	transport: {
+		...e.transport,
+		...t,
+		headers: w(e.transport?.headers, t.headers),
+		attributes: {
+			...e.transport?.attributes,
+			...t.attributes
+		},
+		policy: t.policy ?? e.transport?.policy
+	}
+}, t.policy ?? {}), D = (e) => g(e, h(e)), O = (e, t, n, r) => {
+	t && d(n, t, r);
+	let i = D(e);
+	return f(n, i, r), i;
+}, k = (e, t, n) => {
+	let r = D(e);
+	return f(t, r, n), r;
+}, A = (e, t) => h(e).scope || t, ee = (e, t, n) => g(e, {
+	scope: t,
+	source: n?.source,
+	backend: n?.backend,
+	requestId: n?.requestId
+}), j = (e) => e instanceof Error && e.message ? e.message : String(e), M = (e, t = {}) => e instanceof n ? new n(e.message, {
+	cause: e.cause,
+	source: t.source ?? e.source,
+	status: t.status ?? e.status,
+	code: t.code ?? e.code,
+	retryable: t.retryable ?? e.retryable,
+	response: t.response ?? e.response,
+	details: t.details ?? e.details
+}) : new n(j(e), {
+	cause: e,
+	...t
+}), te = (e, r = !1) => {
+	if (!r) {
+		try {
+			d(e, { safety: { retrySafe: !0 } }, "withRetry");
+			return;
+		} catch {}
+		throw new n(i.retryUnsafe, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: { capabilities: l(e) }
+		});
+	}
+}, ne = (e, r = !1) => {
+	if (!r) {
+		try {
+			d(e, { safety: { cacheable: !0 } }, "withCache");
+			return;
+		} catch {}
+		throw new n(i.cacheUnsafe, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: { capabilities: l(e) }
+		});
+	}
+}, re = (e, r = !1) => {
+	if (!r) {
+		try {
+			d(e, { safety: { hedgeSafe: !0 } }, "createHedgedTransport");
+			return;
+		} catch {}
+		throw new n(i.hedgedUnsafe, {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1,
+			details: { capabilities: l(e) }
+		});
+	}
+}, ie = (e) => JSON.stringify({
+	backend: e.backend,
+	serializedValues: e.serializedValues,
+	reports: e.reports.map((e) => e.id)
+}), N = (e) => y(e) ? {
+	reports: y(e.reports) ? e.reports : void 0,
+	meta: y(e.meta) ? e.meta : void 0,
+	raw: "raw" in e ? e.raw : e
+} : { raw: e }, P = (e) => y(e) && typeof e.type == "string" ? e : {
+	type: "chunk",
+	chunk: v(e)
+}, F = (e, t) => {
+	let n = Array.isArray(e) ? e.map((e, t) => ({
+		id: void 0,
+		index: t,
+		label: `transport[${t}]`,
+		transport: e
+	})) : Object.entries(e).map(([e, t], n) => ({
+		id: e,
+		index: n,
+		label: e,
+		transport: t
+	}));
+	if (n.length === 0) throw TypeError(i.emptyComposedTransport(t));
+	return n;
+}, I = (e, t) => {
+	let r = t.map(({ label: e, error: t }) => {
+		let n = M(t, { source: e });
+		return {
+			source: e,
+			message: n.message,
+			status: n.status,
+			code: n.code,
+			retryable: n.retryable,
+			details: n.details
+		};
+	});
+	return new n(e, {
+		cause: AggregateError(t.map(({ error: e, label: t }) => e instanceof Error ? e : /* @__PURE__ */ Error(`${t}: ${String(e)}`)), e),
+		code: "COMPOSITE_TRANSPORT_ERROR",
+		retryable: r.every((e) => e.retryable !== !1),
+		details: { failures: r }
+	});
+}, L = (e) => {
+	let t = new AbortController(), n = [];
+	for (let r of e) {
+		if (!r) continue;
+		if (r.aborted) return t.abort(r.reason), {
+			signal: t.signal,
+			cleanup: () => {}
+		};
+		let e = () => t.abort(r.reason);
+		r.addEventListener("abort", e, { once: !0 }), n.push(() => r.removeEventListener("abort", e));
+	}
+	return {
+		signal: t.signal,
+		cleanup: () => {
+			for (let e of n) e();
+		}
+	};
+}, R = (e, t) => new Promise((n, r) => {
+	if (t?.aborted) {
+		r(t.reason);
+		return;
+	}
+	let i = setTimeout(() => {
+		t?.removeEventListener("abort", a), n();
+	}, e), a = () => {
+		clearTimeout(i), r(t?.reason);
+	};
+	t?.addEventListener("abort", a, { once: !0 });
+}), z = (e, t) => ({
+	...e,
+	meta: {
+		...e.meta,
+		...t
+	}
+}), ae = (e) => {
+	switch (e.type) {
+		case "progress": return e;
+		case "meta": return e;
+		case "result": return e;
+		case "error": return e;
+		case "message": return {
+			type: "chunk",
+			chunk: e.message,
+			meta: {
+				...e.meta,
+				session: !0,
+				messageType: e.message.type
+			}
+		};
+		case "close": return {
+			type: "meta",
+			meta: {
+				...e.meta,
+				sessionClosed: !0,
+				reason: e.reason
+			}
+		};
+	}
+}, oe = async function* (e, t) {
+	yield {
+		type: "result",
+		result: await e.submit(t)
+	};
+}, B = (e, t) => e.stream ? e.stream(t) : oe(e, t), V = async (e, t) => typeof e == "function" ? e(t) : e, se = async function* (e) {
+	let t = e.getReader(), n = new TextDecoder(), r = "";
+	for (;;) {
+		let { value: e, done: i } = await t.read();
+		if (i) break;
+		for (r += n.decode(e, { stream: !0 });;) {
+			let e = r.indexOf("\n\n");
+			if (e === -1) break;
+			let t = r.slice(0, e);
+			r = r.slice(e + 2);
+			let n, i, a, o = [];
+			for (let e of t.split(/\r?\n/)) {
+				if (!e || e.startsWith(":")) continue;
+				let t = e.indexOf(":"), r = t === -1 ? e : e.slice(0, t), s = t === -1 ? "" : e.slice(t + 1).trimStart();
+				r === "id" ? n = s : r === "event" ? i = s : r === "retry" ? a = Number.parseInt(s, 10) : r === "data" && o.push(s);
+			}
+			yield {
+				id: n,
+				event: i,
+				data: o.join("\n"),
+				retry: Number.isFinite(a) ? a : void 0
+			};
+		}
+	}
+	r.trim() && (yield { data: r.trim() });
+}, ce = async (e) => {
+	let t = e.data;
+	if (e.data) try {
+		t = JSON.parse(e.data);
+	} catch {
+		t = e.data;
+	}
+	return e.event === "progress" && y(t) ? {
+		type: "progress",
+		loaded: typeof t.loaded == "number" ? t.loaded : void 0,
+		total: typeof t.total == "number" ? t.total : void 0,
+		message: typeof t.message == "string" ? t.message : void 0,
+		meta: {
+			event: e.event,
+			id: e.id,
+			retry: e.retry
+		}
+	} : e.event === "result" || y(t) && t.type === "result" ? {
+		type: "result",
+		result: y(t) && "result" in t ? t.result : t,
+		meta: {
+			event: e.event,
+			id: e.id,
+			retry: e.retry
+		}
+	} : e.event === "error" || y(t) && t.type === "error" ? {
+		type: "error",
+		error: y(t) && "error" in t ? t.error : t,
+		meta: {
+			event: e.event,
+			id: e.id,
+			retry: e.retry
+		}
+	} : y(t) && typeof t.type == "string" ? t : {
+		type: "chunk",
+		chunk: t,
+		meta: {
+			event: e.event,
+			id: e.id,
+			retry: e.retry
+		}
+	};
+}, H = (e) => ({ [r.requestBodyKey]: e.serializedValues }), U = async (e) => {
+	if (e.status === 204) return null;
+	if ((e.headers.get("content-type") ?? "").includes("application/json")) return e.json();
+	let t = await e.text();
+	if (!t) return null;
+	try {
+		return JSON.parse(t);
+	} catch {
+		return t;
+	}
+}, W = (e, t, n) => {
+	if (n && typeof n == "object" && "message" in n) {
+		let e = n.message;
+		if (typeof e == "string" && e.trim()) return e;
+	}
+	return i.requestFailed(e, t);
+}, G = (e) => {
+	if (!(!y(e) || typeof e.code != "string" || !e.code.trim())) return e.code;
+}, le = (e) => {
+	let t = (e ?? r.method).toUpperCase();
+	if (t === "POST" || t === "PUT" || t === "PATCH" || t === "DELETE") return t;
+	throw TypeError(i.unsupportedMethod(t));
+}, ue = async (e) => typeof e == "function" ? e() : e, K = async (e, t, r, i) => {
+	let a = [];
+	for (let n of t) {
+		if (i && !await i(n, e)) continue;
+		let t = typeof r == "function" ? await r(e, n) : r[n];
+		(t ?? 0) > 0 && a.push({
+			id: n,
+			weight: t ?? 0
+		});
+	}
+	if (a.length === 0) throw new n("No eligible transport available for weighted routing.", {
+		code: "NO_ELIGIBLE_TRANSPORT",
+		retryable: !1
+	});
+	let o = a.reduce((e, t) => e + t.weight, 0), s = Math.random() * o;
+	for (let e of a) if (s -= e.weight, s <= 0) return e.id;
+	return a.at(-1).id;
+}, de = (e, t) => {
+	let n = { transports: e.some((e) => e.id !== void 0) ? Object.fromEntries(e.map((e) => [e.id ?? String(e.index), e.response.meta ?? {}])) : e.map((e) => e.response.meta ?? {}) };
+	return t.length > 0 && (n.failures = t.map((e) => ({
+		id: e.id ?? String(e.index),
+		error: e.error instanceof Error ? e.error.message : String(e.error)
+	}))), n;
+}, fe = (e) => e.some((e) => e.id !== void 0) ? Object.fromEntries(e.map((e) => [e.id ?? String(e.index), e.response.raw])) : e.map((e) => e.response.raw), q = (e, t) => {
+	let n = {}, r = /* @__PURE__ */ new Map();
+	for (let t of e) for (let [e, a] of Object.entries(t.response.reports ?? {})) {
+		let o = t.id ?? `transport[${t.index}]`, s = r.get(e);
+		if (s) throw Error(i.duplicateFanoutReport(e, s, o));
+		r.set(e, o), n[e] = a;
+	}
+	return {
+		reports: n,
+		meta: de(e, t),
+		raw: fe(e)
+	};
+}, pe = (e) => {
+	let a = le(e.method), o = e.source ?? String(e.endpoint), c = e.stream, l = x(async (s) => {
+		s = k(s, l, "createJsonTransport");
+		let c = e.fetch ?? globalThis.fetch;
+		if (typeof c != "function") throw new n(i.missingFetch, {
+			source: o,
+			code: "FETCH_MISSING",
+			retryable: !1
+		});
+		let u = w(typeof e.headers == "function" ? await e.headers() : e.headers, s.transport?.headers), d = typeof e.body == "function" ? e.body(s) : JSON.stringify(H(s));
+		u.has("accept") || u.set("accept", r.acceptHeader), typeof e.body != "function" && !u.has("content-type") && u.set("content-type", r.contentTypeHeader);
+		let f;
+		try {
+			f = await c(String(e.endpoint), {
+				method: a,
+				headers: u,
+				credentials: T(e.credentials, s),
+				body: d,
+				signal: s.signal
+			});
+		} catch (e) {
+			throw M(e, {
+				source: o,
+				code: b(e) ? t.ABORTED : "TRANSPORT_REQUEST_FAILED",
+				retryable: !b(e)
+			});
+		}
+		let p = e.parse ?? U;
+		if (!f.ok) {
+			let e = null;
+			try {
+				e = await p(f);
+			} catch {
+				e = null;
+			}
+			throw new n(W(f.status, f.statusText, e), {
+				source: o,
+				status: f.status,
+				code: G(e) ?? (f.status >= 500 ? t.UPSTREAM_5XX : void 0),
+				retryable: f.status >= 500 || f.status === 429,
+				response: e
+			});
+		}
+		try {
+			return await p(f);
+		} catch (e) {
+			throw M(e, {
+				source: o,
+				code: t.PARSE_FAILED,
+				retryable: !1
+			});
+		}
+	}, c ? async (s) => {
+		s = O(s, { modes: { stream: !0 } }, l, "createJsonTransport.stream");
+		let u = e.fetch ?? globalThis.fetch;
+		if (typeof u != "function") throw new n(i.missingFetch, {
+			source: o,
+			code: "FETCH_MISSING",
+			retryable: !1
+		});
+		let d = w(typeof e.headers == "function" ? await e.headers() : e.headers, s.transport?.headers), f = typeof e.body == "function" ? e.body(s) : JSON.stringify(H(s));
+		d.has("accept") || d.set("accept", r.acceptHeader), typeof e.body != "function" && !d.has("content-type") && d.set("content-type", r.contentTypeHeader);
+		let p;
+		try {
+			p = await u(String(e.endpoint), {
+				method: a,
+				headers: d,
+				credentials: T(e.credentials, s),
+				body: f,
+				signal: s.signal
+			});
+		} catch (e) {
+			throw M(e, {
+				source: o,
+				code: b(e) ? t.ABORTED : "TRANSPORT_REQUEST_FAILED",
+				retryable: !b(e)
+			});
+		}
+		if (!p.ok) {
+			let r = e.parse ?? U, i = null;
+			try {
+				i = await r(p);
+			} catch {
+				i = null;
+			}
+			throw new n(W(p.status, p.statusText, i), {
+				source: o,
+				status: p.status,
+				code: G(i) ?? (p.status >= 500 ? t.UPSTREAM_5XX : void 0),
+				retryable: p.status >= 500 || p.status === 429,
+				response: i
+			});
+		}
+		return c(p, s);
+	} : void 0, { capabilities: s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !!c,
+			session: !1
+		},
+		safety: {
+			idempotent: a === "PUT" || a === "DELETE",
+			retrySafe: a === "PUT" || a === "DELETE",
+			cacheable: !1,
+			hedgeSafe: a === "PUT" || a === "DELETE"
+		},
+		auth: { kinds: [
+			"none",
+			"api-key",
+			"bearer",
+			"transport-context",
+			"custom"
+		] },
+		delivery: {
+			mode: c ? "stream" : "request-response",
+			consistency: "best-effort",
+			backpressure: "consumer-pull"
+		}
+	}) });
+	return l;
+}, me = (e) => {
+	let a = e.source ?? String(e.endpoint), o = x(async (s) => {
+		s = k(s, o, "createGraphqlTransport");
+		let c = e.fetch ?? globalThis.fetch;
+		if (typeof c != "function") throw new n(i.missingFetch, {
+			source: a,
+			code: "FETCH_MISSING",
+			retryable: !1
+		});
+		let l = w(typeof e.headers == "function" ? await e.headers() : e.headers, s.transport?.headers);
+		l.has("accept") || l.set("accept", r.acceptHeader), l.has("content-type") || l.set("content-type", r.contentTypeHeader);
+		let u = await V(e.query, s), d = e.operationName ? await V(e.operationName, s) : void 0, f = e.variables ? await e.variables(s) : s.serializedValues, p = await c(String(e.endpoint), {
+			method: "POST",
+			headers: l,
+			credentials: T(e.credentials, s),
+			body: JSON.stringify({
+				query: u,
+				variables: f,
+				operationName: d
+			}),
+			signal: s.signal
+		}), m = await (e.parse ?? U)(p);
+		if (!p.ok) throw new n(W(p.status, p.statusText, m), {
+			source: a,
+			status: p.status,
+			code: G(m) ?? (p.status >= 500 ? t.UPSTREAM_5XX : void 0),
+			retryable: p.status >= 500,
+			response: m
+		});
+		if (y(m) && Array.isArray(m.errors) && m.errors.length > 0) throw new n(String(m.errors.map((e) => y(e) && typeof e.message == "string" ? e.message : String(e)).join(", ")), {
+			source: a,
+			code: t.GRAPHQL_ERROR,
+			retryable: !1,
+			response: m
+		});
+		if (e.resolveResult) return e.resolveResult(m, s);
+		let h = e.resultPath ?? "data";
+		if (h === "data") return y(m) && "data" in m ? m.data : m;
+		let g = h.split(".").slice(1), _ = y(m) ? m.data : void 0;
+		for (let e of g) {
+			if (!y(_) || !(e in _)) {
+				_ = void 0;
+				break;
+			}
+			_ = _[e];
+		}
+		return _;
+	}, void 0, { capabilities: s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !1,
+			session: !1
+		},
+		safety: {
+			idempotent: !1,
+			retrySafe: !1,
+			cacheable: !0,
+			hedgeSafe: !1
+		},
+		auth: { kinds: [
+			"none",
+			"api-key",
+			"bearer",
+			"transport-context",
+			"custom"
+		] },
+		delivery: {
+			mode: "request-response",
+			consistency: "best-effort",
+			backpressure: "none"
+		}
+	}) });
+	return o;
+}, he = (e) => {
+	let a = e.source ?? String(e.endpoint), o = e.method ?? "POST", c = async function* (s) {
+		s = k(s, l, "createSseTransport");
+		let c = e.fetch ?? globalThis.fetch;
+		if (typeof c != "function") throw new n(i.missingFetch, {
+			source: a,
+			code: "FETCH_MISSING",
+			retryable: !1
+		});
+		let u = w(typeof e.headers == "function" ? await e.headers() : e.headers, s.transport?.headers);
+		u.set("accept", "text/event-stream"), u.has("content-type") || u.set("content-type", r.contentTypeHeader);
+		let d = typeof e.body == "function" ? e.body(s) : JSON.stringify(H(s)), f = await c(String(e.endpoint), {
+			method: o,
+			headers: u,
+			credentials: T(e.credentials, s),
+			body: d,
+			signal: s.signal
+		});
+		if (!f.ok) throw new n(i.requestFailed(f.status, f.statusText), {
+			source: a,
+			status: f.status,
+			code: f.status >= 500 ? t.UPSTREAM_5XX : void 0,
+			retryable: f.status >= 500
+		});
+		if (!f.body) throw new n(i.missingStream(a), {
+			source: a,
+			code: "STREAM_BODY_MISSING",
+			retryable: !1
+		});
+		let p = e.decodeEvent ?? ce;
+		for await (let r of se(f.body)) try {
+			let t = await p(r, s);
+			yield t, e.resultEvent && (typeof e.resultEvent == "string" && r.event === e.resultEvent || typeof e.resultEvent == "function" && e.resultEvent(r)) && (yield {
+				type: "result",
+				result: t.type === "chunk" ? t.chunk : t.type === "meta" ? t.meta : t.type === "result" ? t.result : t,
+				meta: { event: r.event }
+			});
+		} catch (e) {
+			throw new n(i.sseInvalidEvent, {
+				source: a,
+				cause: e,
+				code: t.PARSE_FAILED,
+				retryable: !1
+			});
+		}
+	}, l = x(async (e) => {
+		e = k(e, l, "createSseTransport.submit");
+		let r, i = !1;
+		for await (let t of c(e)) if (t.type === "result") r = t.result, i = !0;
+		else if (t.type === "error") throw t.error;
+		if (!i) throw new n("createSseTransport: stream completed without a result event.", {
+			source: a,
+			code: t.SESSION_RESULT_MISSING,
+			retryable: !1
+		});
+		return r;
+	}, async function* (e) {
+		e = O(e, { modes: { stream: !0 } }, l, "createSseTransport.stream");
+		for await (let t of c(e)) yield t;
+	}, { capabilities: s(void 0, {
+		modes: {
+			submit: !!e.resultEvent,
+			stream: !0,
+			session: !1
+		},
+		safety: {
+			idempotent: o === "PUT",
+			retrySafe: o === "PUT",
+			cacheable: !1,
+			hedgeSafe: o === "PUT"
+		},
+		limits: { maxPayloadBytes: e.maxPayloadBytes },
+		auth: { kinds: [
+			"none",
+			"api-key",
+			"bearer",
+			"transport-context",
+			"custom"
+		] },
+		delivery: {
+			mode: "stream",
+			consistency: "best-effort",
+			backpressure: "consumer-pull"
+		}
+	}) });
+	return l;
+}, J = (e) => x(e.submit ?? (async (r) => {
+	let i = await e.openSession(r);
+	try {
+		for await (let e of await i.receive()) {
+			if (e.type === "result") return e.result;
+			if (e.type === "error") throw e.error;
+		}
+		throw new n("createSessionTransport: session closed without a result.", {
+			code: t.SESSION_RESULT_MISSING,
+			retryable: !1
+		});
+	} finally {
+		await i.close("submit-complete");
+	}
+}), e.stream ?? async function* (t) {
+	let n = await e.openSession(t);
+	try {
+		yield {
+			type: "meta",
+			meta: {
+				sessionOpen: !0,
+				bufferedMessages: n.capabilities?.bufferedMessages
+			}
+		};
+		for await (let e of await n.receive()) {
+			let t = ae(e);
+			t && (yield t);
+		}
+	} finally {
+		yield {
+			type: "meta",
+			meta: { sessionClosing: !0 }
+		}, await n.close("stream-complete");
+	}
+}, {
+	openSession: e.openSession,
+	capabilities: c(s(e.capabilities), s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !0,
+			session: !0
+		},
+		delivery: {
+			mode: "session",
+			consistency: "unknown",
+			backpressure: "bounded-buffer"
+		}
+	}))
+}), ge = (e) => {
+	let r = e.source ?? "websocket";
+	return J({
+		async openSession(a) {
+			let o = e.WebSocket ?? globalThis.WebSocket;
+			if (typeof o != "function") throw new n(i.websocketMissing, {
+				source: r,
+				code: "WEBSOCKET_MISSING",
+				retryable: !1
+			});
+			let s = e.url instanceof Function ? await e.url(a) : e.url, c = typeof e.protocols == "function" ? await e.protocols(a) : e.protocols, l = e.serializeMessage ?? ((e) => JSON.stringify(e)), u = e.deserializeMessage ?? (async (e) => {
+				if (typeof e == "string") try {
+					return JSON.parse(e);
+				} catch {
+					return e;
+				}
+				if (e instanceof Blob) {
+					let t = await e.text();
+					try {
+						return JSON.parse(t);
+					} catch {
+						return t;
+					}
+				}
+				let t = new TextDecoder().decode(e);
+				try {
+					return JSON.parse(t);
+				} catch {
+					return t;
+				}
+			}), d = new o(String(s), c), f = S(), p = [], m = e.maxBufferedMessages ?? 1e3, h = e.bufferOverflow ?? "error", g = (e) => {
+				if (typeof e == "string" || e instanceof Blob || e instanceof ArrayBuffer) {
+					d.send(e);
+					return;
+				}
+				d.send(e.buffer);
+			}, _ = (e) => {
+				if (p.length < m) {
+					p.push(e), f.push(e);
+					return;
+				}
+				if (h === "drop-oldest") {
+					p.shift(), p.push(e), f.push(e);
+					return;
+				}
+				if (h !== "drop-newest") {
+					if (h === "close") {
+						d.close(1013, "buffer-overflow");
+						return;
+					}
+					f.push({
+						type: "error",
+						error: new n("WebSocket session buffer exceeded.", {
+							source: r,
+							code: t.WEBSOCKET_BUFFER_OVERFLOW,
+							retryable: !1
+						})
+					});
+				}
+			};
+			await new Promise((e, t) => {
+				d.addEventListener("open", () => e(), { once: !0 }), d.addEventListener("error", () => t(new n("WebSocket failed to open.", {
+					source: r,
+					code: "WEBSOCKET_OPEN_FAILED",
+					retryable: !0
+				})), { once: !0 });
+			}), d.addEventListener("message", (e) => {
+				(async () => {
+					let t = await u(e.data);
+					if (y(t) && typeof t.type == "string") {
+						let e = t;
+						if (e.type === "progress" || e.type === "meta" || e.type === "result" || e.type === "error") {
+							_(t);
+							return;
+						}
+					}
+					_({
+						type: "message",
+						message: {
+							type: "message",
+							data: t
+						},
+						meta: { session: !0 }
+					});
+				})().catch((e) => {
+					f.push({
+						type: "error",
+						error: e
+					});
+				});
+			}), d.addEventListener("close", (e) => {
+				f.push({
+					type: "close",
+					reason: e.reason,
+					meta: {
+						code: e.code,
+						wasClean: e.wasClean
+					}
+				}), f.close();
+			});
+			let v = typeof e.sessionInit == "function" ? await e.sessionInit(a) : e.sessionInit;
+			return v && g(l(v)), {
+				async send(e) {
+					g(l(e));
+				},
+				async *receive() {
+					for await (let e of f) yield e;
+				},
+				async close(t) {
+					d.readyState === d.CLOSING || d.readyState === d.CLOSED || (d.close(1e3, t), (e.closeTimeoutMs ?? 0) > 0 && await R(e.closeTimeoutMs ?? 0));
+				},
+				capabilities: {
+					bufferedMessages: p.length,
+					backpressure: "bounded-buffer"
+				}
+			};
+		},
+		capabilities: s(void 0, {
+			modes: {
+				submit: !0,
+				stream: !0,
+				session: !0
+			},
+			safety: {
+				idempotent: !1,
+				retrySafe: !1,
+				cacheable: !1,
+				hedgeSafe: !1
+			},
+			limits: { maxBufferedMessages: e.maxBufferedMessages },
+			auth: { kinds: [
+				"none",
+				"bearer",
+				"api-key",
+				"transport-context",
+				"custom"
+			] },
+			delivery: {
+				mode: "session",
+				consistency: "best-effort",
+				backpressure: "bounded-buffer"
+			}
+		})
+	});
+}, _e = (e) => {
+	if (!e.unary) throw TypeError("createGrpcUnaryTransport requires a unary handler.");
+	let t = x(async (n) => e.unary(k(n, t, "createGrpcUnaryTransport")), void 0, { capabilities: c(s(e.capabilities), s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !1,
+			session: !1
+		},
+		auth: { kinds: [
+			"transport-context",
+			"custom",
+			"bearer",
+			"api-key"
+		] }
+	})) });
+	return t;
+}, ve = (e) => {
+	let t = x(async (n) => {
+		n = k(n, t, "createGrpcStreamTransport");
+		let r;
+		for await (let t of await e.stream(n)) {
+			let e = P(t);
+			if (e.type === "result") r = e.result;
+			else if (e.type === "error") throw e.error;
+		}
+		return r;
+	}, async function* (n) {
+		n = O(n, { modes: { stream: !0 } }, t, "createGrpcStreamTransport.stream");
+		let r = await e.stream(n);
+		for await (let e of r) yield P(e);
+	}, { capabilities: c(s(e.capabilities), s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !0,
+			session: !1
+		},
+		auth: { kinds: [
+			"transport-context",
+			"custom",
+			"bearer",
+			"api-key"
+		] },
+		delivery: {
+			mode: "stream",
+			consistency: "best-effort",
+			backpressure: "consumer-pull"
+		}
+	})) });
+	return t;
+}, ye = (e) => J({
+	openSession: e.session,
+	capabilities: c(s(e.capabilities), s(void 0, {
+		modes: {
+			submit: !0,
+			stream: !0,
+			session: !0
+		},
+		auth: { kinds: [
+			"transport-context",
+			"custom",
+			"bearer",
+			"api-key"
+		] },
+		delivery: {
+			mode: "session",
+			consistency: "best-effort",
+			backpressure: "bounded-buffer"
+		}
+	}))
+}), be = (e) => {
+	if (!e.unary && !e.stream && !e.session) throw TypeError("createGrpcTransport requires at least unary, stream, or session.");
+	let t = x(e.unary ? async (n) => e.unary(k(n, t, "createGrpcTransport")) : async (n) => {
+		n = k(n, t, "createGrpcTransport");
+		let r = null;
+		if (!e.stream) return r;
+		for await (let t of await e.stream(n)) {
+			let e = P(t);
+			if (e.type === "result") r = e.result;
+			else if (e.type === "error") throw e.error;
+		}
+		return r;
+	}, e.stream ? async function* (n) {
+		n = O(n, { modes: { stream: !0 } }, t, "createGrpcTransport.stream");
+		let r = await e.stream(n);
+		for await (let e of r) yield P(e);
+	} : void 0, {
+		openSession: e.session,
+		capabilities: c(s(e.capabilities), s(void 0, {
+			auth: { kinds: [
+				"transport-context",
+				"custom",
+				"bearer",
+				"api-key"
+			] },
+			modes: {
+				submit: !0,
+				stream: !!e.stream,
+				session: !!e.session
+			},
+			delivery: {
+				mode: e.session ? "session" : e.stream ? "stream" : "request-response",
+				consistency: "best-effort",
+				backpressure: e.session ? "bounded-buffer" : e.stream ? "consumer-pull" : "none"
+			}
+		}))
+	});
+	return t;
+}, xe = (e, ...t) => t.reduce((e, t) => t(e), e), Y = (e, t) => {
+	let n = e.baseDelay ?? 1e3, r = e.maxDelay ?? 3e4, { backoff: i = "exponential" } = e, a;
+	return a = typeof i == "function" ? i(t) : Array.isArray(i) ? i[Math.min(t, i.length - 1)] ?? n : i === "linear" ? n * (t + 1) : n * 2 ** t, a = Math.min(a, r), e.jitter && (a = Math.floor(a * Math.random())), a;
+}, Se = (e) => {
+	if (e.attempts < 1) throw TypeError(i.retryInvalidAttempts);
+	return (t) => (te(t, e.allowUnsafeRetry), x(async (n) => {
+		let r;
+		for (let i = 0; i < e.attempts; i++) try {
+			return await t.submit(n);
+		} catch (t) {
+			if (r = t, n.signal?.aborted || e.retryOn && !e.retryOn(t, i)) throw t;
+			i < e.attempts - 1 && await R(Y(e, i), n.signal);
+		}
+		throw r;
+	}, t.stream ? async function* (n) {
+		let r;
+		for (let i = 0; i < e.attempts; i++) {
+			let a = !1;
+			try {
+				let e = await C(t, n);
+				for await (let t of e) a = !0, yield t;
+				return;
+			} catch (t) {
+				if (r = t, n.signal?.aborted || a || e.retryOn && !e.retryOn(t, i)) throw t;
+				i < e.attempts - 1 && await R(Y(e, i), n.signal);
+			}
+		}
+		throw r;
+	} : void 0, {
+		openSession: t.openSession,
+		capabilities: u(l(t))
+	}));
+}, Ce = (e) => {
+	if (e <= 0 || !Number.isFinite(e)) throw TypeError(i.timeoutInvalid);
+	return (r) => x(async (i) => {
+		let a = new AbortController(), o = setTimeout(() => a.abort(`Transport timed out after ${e}ms`), e), { signal: s, cleanup: c } = L([i.signal, a.signal]);
+		try {
+			return await r.submit({
+				...i,
+				signal: s
+			});
+		} catch (r) {
+			throw a.signal.aborted && !i.signal?.aborted ? new n(`Transport timed out after ${e}ms`, {
+				cause: r,
+				code: t.TIMEOUT,
+				retryable: !0
+			}) : r;
+		} finally {
+			clearTimeout(o), c();
+		}
+	}, r.stream ? async function* (i) {
+		let a = new AbortController(), o = setTimeout(() => a.abort(`Transport timed out after ${e}ms`), e), { signal: s, cleanup: c } = L([i.signal, a.signal]);
+		try {
+			let e = await C(r, {
+				...i,
+				signal: s
+			});
+			for await (let t of e) yield t;
+		} catch (r) {
+			throw a.signal.aborted && !i.signal?.aborted ? new n(`Transport timed out after ${e}ms`, {
+				cause: r,
+				code: t.TIMEOUT,
+				retryable: !0
+			}) : r;
+		} finally {
+			clearTimeout(o), c();
+		}
+	} : void 0, {
+		openSession: r.openSession ? async (i) => {
+			let a = new AbortController(), o = setTimeout(() => a.abort(`Transport timed out after ${e}ms`), e), { signal: s, cleanup: c } = L([i.signal, a.signal]);
+			try {
+				let e = await r.openSession({
+					...i,
+					signal: s
+				});
+				return {
+					send: e.send,
+					receive: e.receive,
+					close: async (t) => {
+						clearTimeout(o), c(), await e.close(t);
+					},
+					capabilities: e.capabilities
+				};
+			} catch (r) {
+				throw clearTimeout(o), c(), a.signal.aborted && !i.signal?.aborted ? new n(`Transport timed out after ${e}ms`, {
+					cause: r,
+					code: t.TIMEOUT,
+					retryable: !0
+				}) : r;
+			}
+		} : void 0,
+		capabilities: u(l(r))
+	});
+}, X = (e) => (t) => x(async (n) => {
+	let r = await e(n);
+	return t.submit(r);
+}, t.stream ? async function* (n) {
+	let r = await C(t, await e(n));
+	for await (let e of r) yield e;
+} : void 0, {
+	openSession: t.openSession ? async (n) => t.openSession(await e(n)) : void 0,
+	capabilities: u(l(t))
+}), we = (e) => (t) => x(async (n) => e(await t.submit(n), n), t.stream ? async function* (n) {
+	let r = await C(t, n);
+	for await (let t of r) {
+		if (t.type === "result") {
+			yield {
+				type: "result",
+				result: await e(t.result, n)
+			};
+			continue;
+		}
+		yield t;
+	}
+} : void 0, {
+	openSession: t.openSession,
+	capabilities: u(l(t))
+}), Te = (e) => (t) => x(async (n) => {
+	e.onRequest?.(n);
+	let r = Date.now();
+	try {
+		let i = await t.submit(n);
+		return e.onResponse?.(i, n, Date.now() - r), i;
+	} catch (t) {
+		throw e.onError?.(t, n, Date.now() - r), t;
+	}
+}, t.stream ? async function* (n) {
+	e.onRequest?.(n);
+	let r = Date.now();
+	try {
+		let i = await C(t, n);
+		for await (let t of i) e.onStreamEvent?.(t, n), t.type === "result" && e.onResponse?.(t.result, n, Date.now() - r), yield t;
+	} catch (t) {
+		throw e.onError?.(t, n, Date.now() - r), t;
+	}
+} : void 0, {
+	openSession: t.openSession ? async (n) => (e.onRequest?.(n), t.openSession(n)) : void 0,
+	capabilities: u(l(t))
+}), Ee = (e) => X(async (t) => {
+	let n = e.traceparent ? await V(e.traceparent, t) : void 0, r = e.baggage ? await V(e.baggage, t) : void 0, i = e.attributes ? await e.attributes(t) : void 0, a = e.requestId ? await V(e.requestId, t) : void 0, o = e.scope ? await V(e.scope, t) : void 0, s = new Headers(t.transport?.headers), c = new Headers(e.preserveExistingHeaders === !1 ? void 0 : s);
+	return n && (!e.preserveExistingHeaders || !c.has("traceparent")) && c.set("traceparent", n), r && (!e.preserveExistingHeaders || !c.has("baggage")) && c.set("baggage", r), ee(E(t, {
+		headers: c,
+		attributes: {
+			...i,
+			traceparent: n,
+			baggage: r,
+			requestId: a
+		}
+	}), o ?? A(t, "transport"), {
+		source: h(t).source,
+		backend: t.backend,
+		requestId: a
+	});
+}), De = (e) => (t) => x(async (n) => {
+	n = k(n, t, "withMetrics");
+	let r = A(n, "transport");
+	e.emit({
+		kind: "request-start",
+		request: n,
+		scope: r
+	});
+	let i = Date.now();
+	try {
+		let a = await t.submit(n);
+		return e.emit({
+			kind: "request-success",
+			request: n,
+			scope: r,
+			durationMs: Date.now() - i,
+			meta: { response: a }
+		}), a;
+	} catch (t) {
+		throw e.emit({
+			kind: "request-error",
+			request: n,
+			scope: r,
+			durationMs: Date.now() - i,
+			error: t
+		}), t;
+	}
+}, t.stream ? async function* (n) {
+	n = k(n, t, "withMetrics.stream");
+	let r = A(n, "transport");
+	e.emit({
+		kind: "request-start",
+		request: n,
+		scope: r
+	});
+	let i = Date.now();
+	try {
+		let a = await C(t, n);
+		for await (let t of a) e.emit({
+			kind: "stream-event",
+			request: n,
+			scope: r,
+			meta: { event: t }
+		}), t.type === "result" && e.emit({
+			kind: "request-success",
+			request: n,
+			scope: r,
+			durationMs: Date.now() - i,
+			meta: { response: t.result }
+		}), yield t;
+	} catch (t) {
+		throw e.emit({
+			kind: "request-error",
+			request: n,
+			scope: r,
+			durationMs: Date.now() - i,
+			error: t
+		}), t;
+	}
+} : void 0, {
+	openSession: t.openSession ? async (n) => {
+		n = k(n, t, "withMetrics.session");
+		let r = A(n, "transport");
+		e.emit({
+			kind: "session-open",
+			request: n,
+			scope: r
+		});
+		let i = await t.openSession(n);
+		return {
+			send: i.send,
+			receive: i.receive,
+			close: async (t) => {
+				e.emit({
+					kind: "session-close",
+					request: n,
+					scope: r,
+					meta: t ? { reason: t } : void 0
+				}), await i.close(t);
+			},
+			capabilities: i.capabilities
+		};
+	} : void 0,
+	capabilities: u(l(t))
+}), Oe = (e) => e.type === "custom" ? X(async (r) => {
+	try {
+		return await e.apply(r);
+	} catch (e) {
+		throw new n(j(e), {
+			cause: e,
+			code: t.AUTH_FAILED,
+			retryable: !1
+		});
+	}
+}) : e.type === "transport-context" ? X(async (t) => E(t, typeof e.context == "function" ? await e.context() : e.context)) : X(async (r) => {
+	try {
+		let t = e.header ?? (e.type === "bearer" ? "authorization" : "x-api-key"), n = e.type === "bearer" ? e.prefix ?? "Bearer " : e.prefix ?? "", i = await ue(e.type === "bearer" ? e.token : e.key);
+		return E(r, { headers: new Headers([[t, `${n}${i}`]]) });
+	} catch (e) {
+		throw new n(j(e), {
+			cause: e,
+			code: t.AUTH_FAILED,
+			retryable: !1
+		});
+	}
+}), Z = () => {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		async get(t) {
+			return e.get(t);
+		},
+		async compareAndSet(t, n, r) {
+			let i = e.get(t);
+			return JSON.stringify(i) === JSON.stringify(n) ? (e.set(t, v(r)), !0) : !1;
+		},
+		async set(t, n) {
+			e.set(t, v(n));
+		}
+	};
+}, ke = (e) => {
+	if (e.failureThreshold < 1) throw TypeError(i.circuitInvalidFailureThreshold);
+	if (e.resetTimeout <= 0 || !Number.isFinite(e.resetTimeout)) throw TypeError(i.circuitInvalidResetTimeout);
+	let r = e.sharedState ?? Z(), a = (t) => e.scope ?? e.key ?? (t ? A(t, "transport") : "transport"), o = async (e) => await r.get(a(e)) ?? {
+		state: "closed",
+		failureCount: 0,
+		openUntil: 0,
+		halfOpenActive: 0
+	}, s = async (i, o) => {
+		e.onStateChange?.(i.state);
+		let s = a(o);
+		if (r.compareAndSet) {
+			let e = await r.get(s);
+			if (!await r.compareAndSet(s, e, i)) throw new n("withCircuitBreaker: shared state compare-and-set failed.", {
+				code: t.POLICY_STORE_CONFLICT,
+				retryable: !0
+			});
+			return;
+		}
+		await r.set(s, i);
+	}, c = async (r) => {
+		let a = await o(r), c = Date.now();
+		if (a.state === "open") {
+			if (c >= a.openUntil) {
+				let e = {
+					...a,
+					state: "half-open"
+				};
+				return await s(e, r), e;
+			}
+			throw new n(i.circuitOpen("transport"), {
+				code: t.OPEN_CIRCUIT,
+				retryable: !0
+			});
+		}
+		if (a.state === "half-open") {
+			let o = e.halfOpenMaxRequests ?? 1;
+			if (a.halfOpenActive >= o) throw new n(i.circuitOpen("transport"), {
+				code: t.OPEN_CIRCUIT,
+				retryable: !0
+			});
+			let c = {
+				...a,
+				halfOpenActive: a.halfOpenActive + 1
+			};
+			return await s(c, r), c;
+		}
+		return a;
+	}, d = async (e) => {
+		await s({
+			state: "closed",
+			failureCount: 0,
+			openUntil: 0,
+			halfOpenActive: 0
+		}, e);
+	}, f = async (t, n) => {
+		if (e.tripOn && !e.tripOn(n)) return;
+		let r = await o(t), i = r.failureCount + 1;
+		if (r.state === "half-open" || i >= e.failureThreshold) {
+			await s({
+				state: "open",
+				failureCount: i,
+				openUntil: Date.now() + e.resetTimeout,
+				halfOpenActive: 0
+			}, t);
+			return;
+		}
+		await s({
+			...r,
+			failureCount: i
+		}, t);
+	};
+	return (e) => x(async (t) => {
+		t = k(t, e, "withCircuitBreaker"), await c(t);
+		try {
+			let n = await e.submit(t);
+			return await d(t), n;
+		} catch (e) {
+			throw await f(t, e), e;
+		}
+	}, e.stream ? async function* (t) {
+		t = k(t, e, "withCircuitBreaker.stream"), await c(t);
+		try {
+			let n = await C(e, t);
+			for await (let e of n) yield e;
+			await d(t);
+		} catch (e) {
+			throw await f(t, e), e;
+		}
+	} : void 0, {
+		openSession: e.openSession,
+		capabilities: u(l(e))
+	});
+}, Q = () => {
+	let e = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = (e) => {
+		let t = a.get(e) ?? [], n = Date.now() - 1e3;
+		for (; t.length > 0 && t[0] !== void 0 && t[0] < n;) t.shift();
+		a.set(e, t);
+	}, s = async (e, t) => {
+		let n = (a.get(e) ?? [])[0] ?? Date.now();
+		await R(Math.max(0, 1e3 - (Date.now() - n)), t);
+	};
+	return { async acquire(c, l) {
+		let u = l.request, d = c, f = l, p = r.get(d) ?? [];
+		for (r.set(d, p); f.maxConcurrent && (e.get(d) ?? 0) >= f.maxConcurrent;) {
+			if (f.queueLimit !== void 0 && p.length >= f.queueLimit) throw new n(i.rateLimitQueueFull, {
+				code: t.RATE_LIMITED,
+				retryable: !0
+			});
+			await new Promise((e, t) => {
+				if (u.signal?.aborted) {
+					t(u.signal.reason);
+					return;
+				}
+				let n = () => {
+					u.signal?.removeEventListener("abort", r), e();
+				}, r = () => t(u.signal?.reason);
+				u.signal?.addEventListener("abort", r, { once: !0 }), p.push(n);
+			});
+		}
+		if (e.set(d, (e.get(d) ?? 0) + 1), f.perSecond) for (;;) {
+			o(d);
+			let e = a.get(d) ?? [];
+			if (e.length < f.perSecond) {
+				e.push(Date.now()), a.set(d, e);
+				break;
+			}
+			await s(d, u.signal);
+		}
+		let m = !1;
+		return { async release() {
+			m || (m = !0, e.set(d, Math.max(0, (e.get(d) ?? 1) - 1)), p.shift()?.());
+		} };
+	} };
+}, Ae = (e) => {
+	if ((!e.maxConcurrent || e.maxConcurrent < 1) && (!e.perSecond || e.perSecond < 1)) throw TypeError(i.rateLimitInvalid);
+	let t = e.limiter ?? Q();
+	return (n) => x(async (r) => {
+		r = k(r, n, "withRateLimit");
+		let i = e.scope ?? e.key ?? A(r, "transport"), a = await t.acquire(i, {
+			request: r,
+			maxConcurrent: e.maxConcurrent,
+			perSecond: e.perSecond,
+			queueLimit: e.queueLimit
+		});
+		try {
+			return await n.submit(r);
+		} finally {
+			await a.release();
+		}
+	}, n.stream ? async function* (r) {
+		r = k(r, n, "withRateLimit.stream");
+		let i = e.scope ?? e.key ?? A(r, "transport"), a = await t.acquire(i, {
+			request: r,
+			maxConcurrent: e.maxConcurrent,
+			perSecond: e.perSecond,
+			queueLimit: e.queueLimit
+		});
+		try {
+			let e = await C(n, r);
+			for await (let t of e) yield t;
+		} finally {
+			await a.release();
+		}
+	} : void 0, {
+		openSession: n.openSession,
+		capabilities: u(l(n))
+	});
+}, je = (e = {}) => {
+	let t = e.key ?? ie, n = /* @__PURE__ */ new Map();
+	return (e) => x(async (r) => {
+		let i = t(r), a = n.get(i);
+		if (a) return a;
+		let o = e.submit(r).finally(() => {
+			n.delete(i);
+		});
+		return n.set(i, o), o;
+	}, e.stream, {
+		openSession: e.openSession,
+		capabilities: u(l(e))
+	});
+}, $ = () => {
+	let e = /* @__PURE__ */ new Map(), t = (t) => {
+		let n = e.get(t) ?? /* @__PURE__ */ new Map();
+		return e.set(t, n), n;
+	};
+	return {
+		async get(e, n) {
+			return t(e).get(n);
+		},
+		async set(e, n, r) {
+			t(e).set(n, v(r));
+		},
+		async delete(e, n) {
+			t(e).delete(n);
+		},
+		async evictExpired(e, n) {
+			let r = t(e);
+			for (let [e, t] of r.entries()) t.expiresAt <= n && r.delete(e);
+		},
+		async keys(e) {
+			return [...t(e).keys()];
+		}
+	};
+}, Me = (e) => {
+	if (e.ttl <= 0 || !Number.isFinite(e.ttl)) throw TypeError(i.cacheInvalidTtl);
+	let t = e.store ?? $();
+	return (n) => (ne(n, e.allowUnsafeCache), x(async (r) => {
+		r = k(r, n, "withCache");
+		let i = e.scope ?? A(r, "transport"), a = e.key(r), o = await t.get(i, a);
+		if (o && o.expiresAt > Date.now()) return v(o.response);
+		o && await t.delete(i, a);
+		let s = await n.submit(r);
+		if ((e.shouldCache?.(s, r) ?? !0) === !0 && (await t.set(i, a, {
+			expiresAt: Date.now() + e.ttl,
+			response: v(s)
+		}), t.evictExpired && await t.evictExpired(i, Date.now()), e.maxEntries && t.keys)) {
+			let n = await t.keys(i);
+			if (n.length > e.maxEntries) {
+				let e = n[0];
+				e && await t.delete(i, e);
+			}
+		}
+		return v(s);
+	}, n.stream, {
+		openSession: n.openSession,
+		capabilities: c(u(l(n)), s(void 0, { safety: {
+			cacheable: !0,
+			idempotent: l(n).safety.idempotent,
+			retrySafe: l(n).safety.retrySafe,
+			hedgeSafe: l(n).safety.hedgeSafe
+		} }))
+	}));
+}, Ne = (e) => {
+	let t = F(e.transports, "createRoutingTransport"), n = t.map((e) => e.id);
+	return x(async (t) => {
+		let r = await e.selectTransport(t, { transportIds: n }), a = e.transports[r];
+		if (!a) throw Error(i.unknownComposedTransport("createRoutingTransport", String(r), n));
+		return t = O(t, e.requiredCapabilities, a, "createRoutingTransport"), a.submit(t);
+	}, async (t) => {
+		let r = await e.selectTransport(t, { transportIds: n }), a = e.transports[r];
+		if (!a) throw Error(i.unknownComposedTransport("createRoutingTransport", String(r), n));
+		return t = O(t, e.requiredCapabilities, a, "createRoutingTransport.stream"), B(a, t);
+	}, { capabilities: t.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, Pe = (e) => {
+	let t = Object.keys(e.transports);
+	return Ne({
+		transports: e.transports,
+		requiredCapabilities: e.requiredCapabilities,
+		selectTransport: (n) => K(n, t, e.weights, e.filter)
+	});
+}, Fe = (e) => {
+	let r = F(e.transports, "createLoadBalancedTransport"), i = /* @__PURE__ */ new Map(), a = 0, o = async (t, n) => e.weights ? typeof e.weights == "function" ? e.weights(t, n) : e.weights[n] ?? 1 : 1, s = async (t, n) => {
+		let r = await o(t, n), i = await e.healthState?.getSnapshot(A(t, "transport"), n), a = (i?.consecutiveFailures ?? 0) * .25;
+		return i ? Math.max(.05, r - a) : r;
+	}, u = async (c) => {
+		let l = r.filter((t) => {
+			if (!e.requiredCapabilities) return !0;
+			try {
+				return d(t.transport, e.requiredCapabilities, "createLoadBalancedTransport"), !0;
+			} catch {
+				return !1;
+			}
+		});
+		if (l.length === 0) throw new n("createLoadBalancedTransport: no eligible transport available.", {
+			code: t.CAPABILITY_MISMATCH,
+			retryable: !1
+		});
+		let u = e.strategy ?? "round-robin";
+		if (u === "random") return l[Math.floor(Math.random() * l.length)];
+		if (u === "least-loaded") return [...l].sort((e, t) => (i.get(e.id) ?? 0) - (i.get(t.id) ?? 0))[0];
+		if (u === "weighted" || u === "health-weighted") {
+			let e = await Promise.all(l.map(async (e) => ({
+				id: e.id,
+				weight: u === "health-weighted" ? await s(c, e.id) : await o(c, e.id)
+			}))), t = await K(c, l.map((e) => e.id), Object.fromEntries(e.map((e) => [e.id, e.weight])));
+			return l.find((e) => e.id === t);
+		}
+		let f = l[a % l.length];
+		return a += 1, f;
+	}, f = async (t, n, r) => {
+		i.set(n, Math.max(0, (i.get(n) ?? 1) - 1)), await e.healthState?.recordSuccess(A(t, "transport"), n, Date.now() - r);
+	}, p = async (t, n, r, a) => {
+		i.set(n, Math.max(0, (i.get(n) ?? 1) - 1)), await e.healthState?.recordFailure(A(t, "transport"), n, a);
+	};
+	return x(async (t) => {
+		let n = await u(t), r = Date.now();
+		i.set(n.id, (i.get(n.id) ?? 0) + 1);
+		try {
+			t = O(t, e.requiredCapabilities, n.transport, "createLoadBalancedTransport");
+			let i = await n.transport.submit(t);
+			return await f(t, n.id, r), i;
+		} catch (e) {
+			throw await p(t, n.id, r, e), e;
+		}
+	}, async function* (t) {
+		let n = await u(t), r = Date.now();
+		i.set(n.id, (i.get(n.id) ?? 0) + 1);
+		try {
+			t = O(t, e.requiredCapabilities, n.transport, "createLoadBalancedTransport.stream");
+			let i = await B(n.transport, t);
+			for await (let e of i) yield z(e, { source: n.id });
+			await f(t, n.id, r);
+		} catch (e) {
+			throw await p(t, n.id, r, e), e;
+		}
+	}, { capabilities: r.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, Ie = (e) => {
+	let t = F(e.transports, "createFanoutTransport"), n = async (n) => {
+		let r = t;
+		return e.filter && (r = (await Promise.all(t.map(async (t) => ({
+			entry: t,
+			include: await e.filter(t.id ?? String(t.index), n)
+		})))).filter((e) => e.include).map((e) => e.entry)), e.requiredCapabilities && (r = r.filter((t) => {
+			try {
+				return d(t.transport, e.requiredCapabilities, "createFanoutTransport"), !0;
+			} catch {
+				return !1;
+			}
+		})), r;
+	};
+	return x(async (t) => {
+		let r = await n(t);
+		if (r.length === 0) return {
+			reports: {},
+			meta: {},
+			raw: null
+		};
+		let i = e.abortPolicy ?? "wait-all", a = r.map(() => new AbortController()), o = !1, s = (e, t) => {
+			if (!o) {
+				o = !0;
+				for (let [n, r] of a.entries()) n !== t && r.abort(e);
+			}
+		}, c = await Promise.allSettled(r.map(async (n, r) => {
+			let o = O(e.transformRequest ? await e.transformRequest(n.id ?? String(n.index), t) : t, e.requiredCapabilities, n.transport, "createFanoutTransport"), { signal: c, cleanup: l } = L([o.signal, a[r]?.signal]);
+			try {
+				let e = N(await n.transport.submit({
+					...o,
+					signal: c
+				}));
+				return i === "abort-pending-on-first-success" && s("fanout-first-success", r), {
+					id: n.id,
+					index: n.index,
+					response: e
+				};
+			} catch (e) {
+				throw i === "abort-pending-on-first-failure" && !(a[r]?.signal.aborted ?? !1) && s("fanout-first-failure", r), e;
+			} finally {
+				l();
+			}
+		})), l = c.filter((e) => e.status === "fulfilled").map((e) => e.value), u = c.flatMap((e, t) => e.status === "rejected" ? [{
+			id: r[t]?.id,
+			index: r[t]?.index ?? t,
+			error: e.reason
+		}] : []), d = e.failurePolicy ?? "fail-all";
+		if (u.length > 0 && d === "fail-all" || l.length === 0 && u.length > 0) throw I(`createFanoutTransport failed for ${u.map((e) => e.id ?? `transport[${e.index}]`).join(", ")}.`, u.map((e) => ({
+			label: e.id ?? `transport[${e.index}]`,
+			error: e.error
+		})));
+		return e.merge ? e.merge({
+			request: t,
+			results: l,
+			failures: u
+		}) : q(l, u);
+	}, async function* (t) {
+		let r = await n(t);
+		if (r.length === 0) {
+			yield {
+				type: "result",
+				result: {
+					reports: {},
+					meta: {},
+					raw: null
+				}
+			};
+			return;
+		}
+		let i = e.abortPolicy ?? "wait-all", a = e.failurePolicy ?? "fail-all", o = S(), s = r.map(() => new AbortController()), c = [], l = [], u = r.length, d = !1, f = (e, t) => {
+			if (!d) {
+				d = !0;
+				for (let [n, r] of s.entries()) n !== t && r.abort(e);
+			}
+		}, p = () => {
+			--u, u === 0 && o.close();
+		};
+		r.forEach((n, r) => {
+			(async () => {
+				let a = n.id ?? `transport[${n.index}]`, u = O(e.transformRequest ? await e.transformRequest(a, t) : t, e.requiredCapabilities, n.transport, "createFanoutTransport.stream"), { signal: d, cleanup: m } = L([u.signal, s[r]?.signal]);
+				try {
+					let e = await B(n.transport, {
+						...u,
+						signal: d
+					});
+					for await (let t of e) {
+						let e = z(t, { source: a });
+						if (t.type === "result") {
+							c.push({
+								id: n.id,
+								index: n.index,
+								response: N(t.result)
+							}), o.push(e), i === "abort-pending-on-first-success" && f("fanout-first-success", r);
+							break;
+						}
+						if (t.type === "error") throw t.error;
+						o.push(e);
+					}
+				} catch (e) {
+					l.push({
+						id: n.id,
+						index: n.index,
+						error: e
+					}), o.push(z({
+						type: "error",
+						error: e
+					}, { source: a })), i === "abort-pending-on-first-failure" && f("fanout-first-failure", r);
+				} finally {
+					m(), p();
+				}
+			})().catch((e) => {
+				o.push({
+					type: "error",
+					error: e,
+					meta: { source: n.id ?? `transport[${n.index}]` }
+				}), p();
+			});
+		});
+		for await (let e of o) yield e;
+		if (l.length > 0 && a === "fail-all" || c.length === 0 && l.length > 0) throw I(`createFanoutTransport failed for ${l.map((e) => e.id ?? `transport[${e.index}]`).join(", ")}.`, l.map((e) => ({
+			label: e.id ?? `transport[${e.index}]`,
+			error: e.error
+		})));
+		yield {
+			type: "result",
+			result: e.merge ? await e.merge({
+				request: t,
+				results: c,
+				failures: l
+			}) : q(c, l),
+			meta: { source: "fanout" }
+		};
+	}, { capabilities: t.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, Le = (e) => {
+	let t = Ie({
+		...e,
+		failurePolicy: "partial-success"
+	}), r = (t) => {
+		let r = N(t).meta?.transports, i = Array.isArray(r) ? r.length : y(r) ? Object.keys(r).length : 0;
+		if (i < e.quorum) throw new n(`createQuorumFanoutTransport: quorum ${e.quorum} not reached.`, {
+			code: "QUORUM_NOT_REACHED",
+			retryable: !0,
+			details: {
+				required: e.quorum,
+				actual: i
+			}
+		});
+		return t;
+	};
+	return x(async (e) => r(await t.submit(e)), async function* (e) {
+		let n = await B(t, e);
+		for await (let e of n) {
+			if (e.type === "result") {
+				yield {
+					...e,
+					result: r(e.result)
+				};
+				continue;
+			}
+			yield e;
+		}
+	}, { capabilities: u(t.capabilities) });
+}, Re = (e) => {
+	let t = F(e.transports, "createFallbackTransport");
+	return x(async (n) => {
+		let r = [];
+		for (let i of t) {
+			if (n.signal?.aborted) throw Error(String(n.signal.reason ?? "Submission aborted."));
+			try {
+				return await i.transport.submit(n);
+			} catch (t) {
+				if (n.signal?.aborted) throw t;
+				let a = {
+					id: i.id,
+					index: i.index,
+					error: t
+				};
+				if (r.push(a), !(await e.shouldFallback?.(t, {
+					request: n,
+					id: a.id,
+					index: a.index,
+					failures: r
+				}) ?? !0)) throw t;
+			}
+		}
+		throw I(`createFallbackTransport exhausted all transports: ${t.map((e) => e.label).join(", ")}.`, r.map((e) => ({
+			label: e.id ?? `transport[${e.index}]`,
+			error: e.error
+		})));
+	}, async function* (n) {
+		let r = [];
+		for (let i of t) {
+			if (n.signal?.aborted) throw Error(String(n.signal.reason ?? "Submission aborted."));
+			try {
+				let e = await B(i.transport, n);
+				for await (let t of e) yield t;
+				return;
+			} catch (t) {
+				if (n.signal?.aborted) throw t;
+				let a = {
+					id: i.id,
+					index: i.index,
+					error: t
+				};
+				if (r.push(a), !(await e.shouldFallback?.(t, {
+					request: n,
+					id: a.id,
+					index: a.index,
+					failures: r
+				}) ?? !0)) throw t;
+			}
+		}
+		throw I(`createFallbackTransport exhausted all transports: ${t.map((e) => e.label).join(", ")}.`, r.map((e) => ({
+			label: e.id ?? `transport[${e.index}]`,
+			error: e.error
+		})));
+	}, { capabilities: t.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, ze = (e) => {
+	if (e.stages.length === 0) throw TypeError(i.emptyPipeline);
+	return x(async (t) => {
+		let n = t, r;
+		for (let a of e.stages) {
+			if (t.signal?.aborted) throw Error(i.pipelineAborted(a.id ?? `stage[${e.stages.indexOf(a)}]`));
+			if (n = k(n, a.transport, "createPipelineTransport"), r = await a.transport.submit(n), a.mapToNext) {
+				n = await a.mapToNext(r, t);
+				let i = e.stages[e.stages.indexOf(a) + 1];
+				i?.nextStageRequirements && (n = O(n, i.nextStageRequirements, i.transport, "createPipelineTransport.nextStage"));
+			}
+		}
+		return r;
+	}, async function* (t) {
+		let n = t, r;
+		for (let [a, o] of e.stages.entries()) {
+			if (t.signal?.aborted) throw Error(i.pipelineAborted(o.id ?? `stage[${a}]`));
+			n = O(n, void 0, o.transport, "createPipelineTransport.stream");
+			let s = await B(o.transport, n);
+			for await (let e of s) {
+				let t = z(e, { stage: o.id ?? `stage[${a}]` });
+				if (e.type === "result") {
+					r = e.result, yield t;
+					break;
+				}
+				if (e.type === "error") throw e.error;
+				yield t;
+			}
+			if (o.mapToNext) {
+				n = await o.mapToNext(r, t);
+				let i = e.stages[a + 1];
+				i?.nextStageRequirements && (n = O(n, i.nextStageRequirements, i.transport, "createPipelineTransport.nextStage"));
+			}
+		}
+		yield {
+			type: "result",
+			result: r,
+			meta: { source: "pipeline" }
+		};
+	}, { capabilities: e.stages.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, Be = (e) => {
+	let t = F(e.transports, "createRacingTransport");
+	return x(async (e) => {
+		let n = new AbortController(), { signal: r, cleanup: a } = L([e.signal, n.signal]);
+		try {
+			let n = await Promise.any(t.map((t) => t.transport.submit({
+				...e,
+				signal: r
+			})));
+			return y(n) ? {
+				...n,
+				meta: {
+					...y(n.meta) ? n.meta : {},
+					selection: "first-success"
+				}
+			} : n;
+		} catch (e) {
+			throw e instanceof AggregateError ? I(i.racingAllFailed, t.map((t, n) => ({
+				label: t.id ?? `transport[${t.index}]`,
+				error: e.errors[n] ?? /* @__PURE__ */ Error("Unknown transport failure.")
+			}))) : e;
+		} finally {
+			n.abort("racing-complete"), a();
+		}
+	}, async function* (e) {
+		let n = new AbortController(), { signal: r, cleanup: a } = L([e.signal, n.signal]), o = S(), s = [], c = t.length, l = !1, u = () => {
+			--c, c === 0 && o.close();
+		};
+		for (let i of t) (async () => {
+			try {
+				let t = await B(i.transport, {
+					...e,
+					signal: r
+				});
+				for await (let e of t) {
+					let t = z(e, { source: i.id ?? `transport[${i.index}]` });
+					if (e.type === "result") {
+						l || (l = !0, o.push(z(t, { selection: "first-success" })), n.abort("racing-complete"));
+						break;
+					}
+					if (e.type === "error") throw e.error;
+					l || o.push(t);
+				}
+			} catch (e) {
+				r.aborted && l || s.push({
+					label: i.id ?? `transport[${i.index}]`,
+					error: e
+				});
+			} finally {
+				u();
+			}
+		})();
+		for await (let e of o) yield e;
+		if (a(), !l) throw I(i.racingAllFailed, s.length > 0 ? s : t.map((e) => ({
+			label: e.id ?? `transport[${e.index}]`,
+			error: /* @__PURE__ */ Error("No transport produced a result.")
+		})));
+	}, { capabilities: t.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, Ve = (e) => {
+	let t = F(e.transports, "createHedgedTransport"), n = Math.min(e.maxAttempts ?? t.length, t.length);
+	if (e.hedgeDelayMs < 0) throw TypeError("createHedgedTransport: hedgeDelayMs must be non-negative.");
+	for (let n of t) re(n.transport, e.allowUnsafeHedging);
+	return x(async (r) => {
+		let i = new AbortController(), { signal: a, cleanup: o } = L([r.signal, i.signal]), s = [];
+		try {
+			return await new Promise((o, c) => {
+				let l = !1, u = 0, d = (e, t) => {
+					setTimeout(async () => {
+						if (!l) try {
+							let t = await e.transport.submit({
+								...r,
+								signal: a
+							});
+							l || (l = !0, i.abort("hedged-complete"), o(t));
+						} catch (t) {
+							s.push({
+								label: e.id,
+								error: t
+							}), u += 1, !l && u >= n && c(I("createHedgedTransport: all attempts failed.", s));
+						}
+					}, t);
+				};
+				for (let [r, i] of t.slice(0, n).entries()) d(i, r * e.hedgeDelayMs);
+			});
+		} finally {
+			o();
+		}
+	}, async function* (e) {
+		let r = await Be({ transports: Object.fromEntries(t.slice(0, n).map((e) => [e.id, e.transport])) }).stream(e);
+		for await (let e of r) yield e;
+	}, { capabilities: t.reduce((e, t) => c(e, l(t.transport)), void 0) });
+}, He = () => {
+	let e = /* @__PURE__ */ new Map(), t = (t) => {
+		let n = e.get(t) ?? /* @__PURE__ */ new Map();
+		return e.set(t, n), n;
+	};
+	return {
+		async getSnapshot(e, n) {
+			return t(e).get(n);
+		},
+		async recordSuccess(e, n, r) {
+			let i = t(e), a = i.get(n);
+			i.set(n, {
+				consecutiveFailures: 0,
+				lastFailureAt: a?.lastFailureAt,
+				lastSuccessAt: Date.now(),
+				averageLatencyMs: a?.averageLatencyMs === void 0 ? r : (a.averageLatencyMs + r) / 2
+			});
+		},
+		async recordFailure(e, n) {
+			let r = t(e), i = r.get(n);
+			r.set(n, {
+				consecutiveFailures: (i?.consecutiveFailures ?? 0) + 1,
+				lastFailureAt: Date.now(),
+				lastSuccessAt: i?.lastSuccessAt,
+				averageLatencyMs: i?.averageLatencyMs
+			});
+		}
+	};
+};
+//#endregion
+export { _e as A, u as B, we as C, ye as D, xe as E, pe as F, i as G, c as H, h as I, e as J, n as K, g as L, J as M, he as N, ve as O, me as P, f as R, X as S, Se as T, s as U, l as V, r as W, Z as _, Re as a, Ee as b, Fe as c, Me as d, $ as f, ke as g, Q as h, ze as i, ge as j, be as k, Ne as l, Ae as m, Ve as n, Ie as o, je as p, t as q, Be as r, Le as s, He as t, Pe as u, Oe as v, Ce as w, Te as x, De as y, d as z };