silgi 0.43.29 → 0.50.1

package/dist/client/adapters/websocket/index.mjs

@@ -0,0 +1,101 @@
+import { SilgiError } from "../../../core/error.mjs";
+//#region src/client/adapters/websocket/index.ts
+/**
+* WebSocket client link — bidirectional RPC over WebSocket.
+*
+* Uses the same wire protocol as the server-side ws.ts adapter:
+*   Client → Server: { id: string, path: string, input?: unknown }
+*   Server → Client: { id: string, result?: unknown, error?: unknown }
+*   Server → Client (stream): { id: string, data: unknown, done?: boolean }
+*
+* @example
+* ```ts
+* import { WSLink } from 'silgi/client/ws'
+*
+* const link = new WSLink({ url: 'ws://localhost:3000/ws' })
+* const client = createClient<AppRouter>(link)
+* ```
+*/
+var WSLink = class {
+	#url;
+	#WebSocket;
+	#ws;
+	#pending = /* @__PURE__ */ new Map();
+	#nextId = 0;
+	#connecting;
+	constructor(options) {
+		this.#url = typeof options.url === "string" ? options.url : options.url.href;
+		this.#WebSocket = options.WebSocket ?? globalThis.WebSocket;
+	}
+	async call(path, input, options) {
+		await this.#ensureConnected();
+		const id = String(this.#nextId++);
+		return new Promise((resolve, reject) => {
+			this.#pending.set(id, {
+				resolve,
+				reject
+			});
+			options.signal?.addEventListener("abort", () => {
+				this.#pending.delete(id);
+				reject(new DOMException("Aborted", "AbortError"));
+			}, { once: true });
+			const msg = {
+				id,
+				path: path.join("/"),
+				input
+			};
+			this.#ws.send(JSON.stringify(msg));
+		});
+	}
+	#ensureConnected() {
+		if (this.#ws?.readyState === WebSocket.OPEN) return Promise.resolve();
+		if (this.#connecting) return this.#connecting;
+		this.#connecting = new Promise((resolve, reject) => {
+			const ws = new this.#WebSocket(this.#url);
+			ws.binaryType = "arraybuffer";
+			ws.addEventListener("open", () => {
+				this.#ws = ws;
+				this.#connecting = void 0;
+				resolve();
+			});
+			ws.addEventListener("error", () => {
+				this.#connecting = void 0;
+				reject(new SilgiError("INTERNAL_SERVER_ERROR", { message: "WebSocket connection failed" }));
+			});
+			ws.addEventListener("message", (event) => {
+				const msg = JSON.parse(typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data));
+				const pending = this.#pending.get(msg.id);
+				if (!pending) return;
+				if (msg.error) {
+					this.#pending.delete(msg.id);
+					const err = msg.error;
+					pending.reject(new SilgiError(err.code ?? "INTERNAL_SERVER_ERROR", {
+						status: err.status,
+						message: err.message,
+						data: err.data
+					}));
+				} else if (msg.done) {
+					this.#pending.delete(msg.id);
+					pending.resolve(msg.data);
+				} else if ("result" in msg) {
+					this.#pending.delete(msg.id);
+					pending.resolve(msg.result);
+				}
+			});
+			ws.addEventListener("close", () => {
+				this.#ws = void 0;
+				for (const [, p] of this.#pending) p.reject(new SilgiError("INTERNAL_SERVER_ERROR", { message: "WebSocket closed" }));
+				this.#pending.clear();
+			});
+		});
+		return this.#connecting;
+	}
+	/** Close the WebSocket connection and reject all pending calls */
+	dispose() {
+		this.#ws?.close();
+		for (const [, p] of this.#pending) p.reject(new DOMException("Link disposed", "AbortError"));
+		this.#pending.clear();
+	}
+};
+//#endregion
+export { WSLink };

package/dist/client/client.d.mts

@@ -0,0 +1,37 @@
+import { InferClient } from "../types.mjs";
+import { SilgiError } from "../core/error.mjs";
+import { ClientContext, ClientLink } from "./types.mjs";
+
+//#region src/client/client.d.ts
+/**
+ * Create a type-safe client from a link.
+ *
+ * ```ts
+ * const client = createClient<typeof appRouter>(link)
+ * ```
+ */
+declare function createClient<T, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>): InferClient<T>;
+/**
+ * Safe client wrapper — returns [error, data] tuples instead of throwing.
+ */
+interface SafeResult<TOutput, TError> {
+  error: TError | null;
+  data: TOutput | undefined;
+  isError: boolean;
+  isSuccess: boolean;
+}
+declare function safe<TOutput, TError = unknown>(promise: Promise<TOutput>): Promise<SafeResult<TOutput, TError>>;
+/**
+ * Create a safe client — every procedure call returns { error, data } instead of throwing.
+ *
+ * ```ts
+ * const safeClient = createSafeClient<typeof appRouter>(link)
+ * const { error, data } = await safeClient.users.list()
+ * if (error) console.error(error)
+ * ```
+ */
+declare function createSafeClient<T, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>): InferSafeClient<T>;
+/** Infer a safe client type where every procedure returns SafeResult */
+type InferSafeClient<T> = T extends ((...args: infer A) => Promise<infer R>) ? (...args: A) => Promise<SafeResult<R, SilgiError>> : { [K in keyof T]: InferSafeClient<T[K]> };
+//#endregion
+export { InferSafeClient, SafeResult, createClient, createSafeClient, safe };

package/dist/client/client.mjs

@@ -0,0 +1,80 @@
+//#region src/client/client.ts
+/**
+* Create a type-safe client from a link.
+*
+* ```ts
+* const client = createClient<typeof appRouter>(link)
+* ```
+*/
+function createClient(link) {
+	return createClientProxy(link, []);
+}
+function createClientProxy(link, path) {
+	const cache = /* @__PURE__ */ new Map();
+	const procedureClient = (input, options) => link.call(path, input, options ?? {});
+	return new Proxy(procedureClient, {
+		get(_target, prop) {
+			if (prop === "then") return void 0;
+			if (typeof prop !== "string") return void 0;
+			let cached = cache.get(prop);
+			if (!cached) {
+				cached = createClientProxy(link, [...path, prop]);
+				cache.set(prop, cached);
+			}
+			return cached;
+		},
+		apply(_target, _thisArg, args) {
+			return procedureClient(args[0], args[1]);
+		}
+	});
+}
+async function safe(promise) {
+	try {
+		return {
+			error: null,
+			data: await promise,
+			isError: false,
+			isSuccess: true
+		};
+	} catch (error) {
+		return {
+			error,
+			data: void 0,
+			isError: true,
+			isSuccess: false
+		};
+	}
+}
+/**
+* Create a safe client — every procedure call returns { error, data } instead of throwing.
+*
+* ```ts
+* const safeClient = createSafeClient<typeof appRouter>(link)
+* const { error, data } = await safeClient.users.list()
+* if (error) console.error(error)
+* ```
+*/
+function createSafeClient(link) {
+	return createSafeProxy(link, []);
+}
+function createSafeProxy(link, path) {
+	const cache = /* @__PURE__ */ new Map();
+	const procedureClient = (input, options) => safe(link.call(path, input, options ?? {}));
+	return new Proxy(procedureClient, {
+		get(_target, prop) {
+			if (prop === "then") return void 0;
+			if (typeof prop !== "string") return void 0;
+			let cached = cache.get(prop);
+			if (!cached) {
+				cached = createSafeProxy(link, [...path, prop]);
+				cache.set(prop, cached);
+			}
+			return cached;
+		},
+		apply(_target, _thisArg, args) {
+			return procedureClient(args[0], args[1]);
+		}
+	});
+}
+//#endregion
+export { createClient, createSafeClient, safe };

package/dist/client/consume.d.mts

@@ -0,0 +1,50 @@
+//#region src/client/consume.d.ts
+/**
+ * Client-side SSE/streaming consumption utilities.
+ *
+ * @example
+ * ```ts
+ * const iterator = await client.events.subscribe()
+ * await consumeIterator(iterator, {
+ *   onEvent: (data) => console.log('Event:', data),
+ *   onError: (err) => console.error('Error:', err),
+ *   onFinish: () => console.log('Stream ended'),
+ * })
+ * ```
+ */
+interface ConsumeOptions<T> {
+  /** Called for each event value */
+  onEvent?: (data: T) => void | Promise<void>;
+  /** Called when an error occurs */
+  onError?: (error: Error) => void;
+  /** Called when the stream ends (success or error) */
+  onFinish?: () => void;
+  /** AbortSignal to cancel consumption */
+  signal?: AbortSignal;
+}
+/**
+ * Consume an async iterator with lifecycle callbacks.
+ * Returns the final value (if any) when the iterator completes.
+ */
+declare function consumeIterator<T>(iterator: AsyncIterableIterator<T>, options?: ConsumeOptions<T>): Promise<void>;
+/**
+ * Map values from an async iterator, producing a new iterator.
+ */
+declare function mapIterator<T, U>(iterator: AsyncIterableIterator<T>, fn: (value: T) => U | Promise<U>): AsyncIterableIterator<U>;
+interface ReconnectOptions<T> extends ConsumeOptions<T> {
+  /** Factory to create a new iterator on reconnection */
+  connect: (lastEventId?: string) => AsyncIterableIterator<T> | Promise<AsyncIterableIterator<T>>;
+  /** Maximum reconnection attempts (default: Infinity) */
+  maxReconnects?: number;
+  /** Delay between reconnections in ms (default: 1000) */
+  reconnectDelay?: number;
+  /** Called on each reconnection attempt */
+  onReconnect?: (attempt: number) => void;
+}
+/**
+ * Consume an iterator with automatic reconnection on failure.
+ * Uses lastEventId for resumption if available.
+ */
+declare function consumeWithReconnect<T>(options: ReconnectOptions<T>): Promise<void>;
+//#endregion
+export { ConsumeOptions, ReconnectOptions, consumeIterator, consumeWithReconnect, mapIterator };

package/dist/client/consume.mjs

@@ -0,0 +1,66 @@
+//#region src/client/consume.ts
+/**
+* Consume an async iterator with lifecycle callbacks.
+* Returns the final value (if any) when the iterator completes.
+*/
+async function consumeIterator(iterator, options = {}) {
+	const { onEvent, onError, onFinish, signal } = options;
+	try {
+		while (true) {
+			if (signal?.aborted) {
+				await iterator.return?.();
+				break;
+			}
+			const result = await iterator.next();
+			if (result.done) break;
+			if (onEvent) await onEvent(result.value);
+		}
+	} catch (error) {
+		onError?.(error instanceof Error ? error : new Error(String(error)));
+	} finally {
+		onFinish?.();
+	}
+}
+/**
+* Map values from an async iterator, producing a new iterator.
+*/
+async function* mapIterator(iterator, fn) {
+	try {
+		for await (const value of iterator) yield await fn(value);
+	} finally {
+		await iterator.return?.();
+	}
+}
+/**
+* Consume an iterator with automatic reconnection on failure.
+* Uses lastEventId for resumption if available.
+*/
+async function consumeWithReconnect(options) {
+	const { connect, maxReconnects = Infinity, reconnectDelay = 1e3, onReconnect, signal, ...consumeOpts } = options;
+	let lastEventId;
+	let attempt = 0;
+	while (attempt <= maxReconnects) {
+		if (signal?.aborted) break;
+		try {
+			const iterator = await connect(lastEventId);
+			attempt = 0;
+			await consumeIterator(iterator, {
+				...consumeOpts,
+				signal,
+				onEvent: async (data) => {
+					if (data && typeof data === "object" && "id" in data) lastEventId = String(data.id);
+					if (consumeOpts.onEvent) await consumeOpts.onEvent(data);
+				}
+			});
+			break;
+		} catch {
+			attempt++;
+			if (attempt > maxReconnects || signal?.aborted) break;
+			onReconnect?.(attempt);
+			await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+		}
+	}
+	consumeOpts.onFinish?.();
+}
+//#endregion
+export { consumeIterator, consumeWithReconnect, mapIterator };

package/dist/client/dynamic-link.d.mts

@@ -0,0 +1,16 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/dynamic-link.d.ts
+type LinkSelector<TClientContext extends ClientContext = ClientContext> = (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => ClientLink<TClientContext> | Promise<ClientLink<TClientContext>>;
+/**
+ * A link that delegates to other links based on a selector function.
+ * The selector runs on every call, so it can use dynamic state.
+ * Supports both sync and async selectors (e.g. lazy-importing a link).
+ */
+declare class DynamicLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(selector: LinkSelector<TClientContext>);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { DynamicLink, LinkSelector };

package/dist/client/dynamic-link.mjs

@@ -0,0 +1,19 @@
+//#region src/client/dynamic-link.ts
+/**
+* A link that delegates to other links based on a selector function.
+* The selector runs on every call, so it can use dynamic state.
+* Supports both sync and async selectors (e.g. lazy-importing a link).
+*/
+var DynamicLink = class {
+	#selector;
+	constructor(selector) {
+		this.#selector = selector;
+	}
+	call(path, input, options) {
+		const result = this.#selector(path, input, options);
+		if (result && typeof result.then === "function") return result.then((link) => link.call(path, input, options));
+		return result.call(path, input, options);
+	}
+};
+//#endregion
+export { DynamicLink };

package/dist/client/index.d.mts

@@ -0,0 +1,6 @@
+import { SilgiError, SilgiErrorCode, SilgiErrorJSON, isDefinedError } from "../core/error.mjs";
+import { Client, ClientContext, ClientLink, ClientOptions, ClientRest, InferClientInputs, InferClientOutputs, NestedClient } from "./types.mjs";
+import { InferSafeClient, SafeResult, createClient, createSafeClient, safe } from "./client.mjs";
+import { DynamicLink, LinkSelector } from "./dynamic-link.mjs";
+import { ClientInterceptors, withInterceptors } from "./interceptor.mjs";
+export { type Client, type ClientContext, type ClientInterceptors, type ClientLink, type ClientOptions, type ClientRest, DynamicLink, type InferClientInputs, type InferClientOutputs, type InferSafeClient, type LinkSelector, type NestedClient, type SafeResult, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, createClient, createSafeClient, isDefinedError, safe, withInterceptors };

package/dist/client/index.mjs

@@ -0,0 +1,5 @@
+import { SilgiError, isDefinedError } from "../core/error.mjs";
+import { createClient, createSafeClient, safe } from "./client.mjs";
+import { DynamicLink } from "./dynamic-link.mjs";
+import { withInterceptors } from "./interceptor.mjs";
+export { DynamicLink, SilgiError, createClient, createSafeClient, isDefinedError, safe, withInterceptors };

package/dist/client/interceptor.d.mts

@@ -0,0 +1,31 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/interceptor.d.ts
+interface ClientInterceptors<TClientContext extends ClientContext = ClientContext> {
+  /** Called before every request. Can modify input or options. */
+  onRequest?: (event: {
+    path: readonly string[];
+    input: unknown;
+    options: ClientOptions<TClientContext>;
+  }) => void | Promise<void>;
+  /** Called after a successful response. */
+  onResponse?: (event: {
+    path: readonly string[];
+    input: unknown;
+    output: unknown;
+    durationMs: number;
+  }) => void | Promise<void>;
+  /** Called when a request fails. */
+  onError?: (event: {
+    path: readonly string[];
+    input: unknown;
+    error: unknown;
+  }) => void | Promise<void>;
+}
+/**
+ * Wrap a ClientLink with interceptor hooks.
+ * Returns a new link that calls the interceptors around the original.
+ */
+declare function withInterceptors<TClientContext extends ClientContext = ClientContext>(link: ClientLink<TClientContext>, interceptors: ClientInterceptors<TClientContext>): ClientLink<TClientContext>;
+//#endregion
+export { ClientInterceptors, withInterceptors };

package/dist/client/interceptor.mjs

@@ -0,0 +1,34 @@
+//#region src/client/interceptor.ts
+/**
+* Wrap a ClientLink with interceptor hooks.
+* Returns a new link that calls the interceptors around the original.
+*/
+function withInterceptors(link, interceptors) {
+	return { async call(path, input, options) {
+		if (interceptors.onRequest) await interceptors.onRequest({
+			path,
+			input,
+			options
+		});
+		const t0 = performance.now();
+		try {
+			const output = await link.call(path, input, options);
+			if (interceptors.onResponse) await interceptors.onResponse({
+				path,
+				input,
+				output,
+				durationMs: performance.now() - t0
+			});
+			return output;
+		} catch (error) {
+			if (interceptors.onError) await interceptors.onError({
+				path,
+				input,
+				error
+			});
+			throw error;
+		}
+	} };
+}
+//#endregion
+export { withInterceptors };

package/dist/client/openapi.d.mts

@@ -0,0 +1,29 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/openapi.d.ts
+interface OpenAPILinkOptions {
+  /** Base URL of the API */
+  url: string;
+  /** OpenAPI 3.x specification object (parsed JSON) */
+  spec?: Record<string, unknown>;
+  /** Default headers */
+  headers?: Record<string, string> | (() => Record<string, string>);
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+}
+/**
+ * A ClientLink that makes REST requests to an OpenAPI endpoint.
+ *
+ * Maps procedure paths to REST paths:
+ * - `client.users.list({ limit: 10 })` → `GET /users/list?limit=10` or `POST /users/list`
+ *
+ * Without a spec, it defaults to POST requests with JSON body.
+ * With a spec, it uses the correct HTTP method and parameter placement.
+ */
+declare class OpenAPILink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(options: OpenAPILinkOptions);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TCtx>): Promise<unknown>;
+}
+//#endregion
+export { OpenAPILink, OpenAPILinkOptions };

package/dist/client/openapi.mjs

@@ -0,0 +1,89 @@
+import { SilgiError } from "../core/error.mjs";
+//#region src/client/openapi.ts
+/**
+* OpenAPI Client Link — consume any OpenAPI endpoint as a Silgi client.
+*
+* Unlike RPCLink (which uses Silgi's wire protocol), OpenAPILink sends
+* standard REST requests based on an OpenAPI spec.
+*
+* @example
+* ```ts
+* import { OpenAPILink } from "silgi/client/openapi"
+* import { createClient } from "silgi/client"
+*
+* const link = new OpenAPILink({
+*   url: "https://api.example.com",
+*   spec: await fetch("/api/openapi.json").then(r => r.json()),
+* })
+*
+* const client = createClient<ExternalAPI>(link)
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* A ClientLink that makes REST requests to an OpenAPI endpoint.
+*
+* Maps procedure paths to REST paths:
+* - `client.users.list({ limit: 10 })` → `GET /users/list?limit=10` or `POST /users/list`
+*
+* Without a spec, it defaults to POST requests with JSON body.
+* With a spec, it uses the correct HTTP method and parameter placement.
+*/
+var OpenAPILink = class {
+	#url;
+	#spec;
+	#headers;
+	#fetch;
+	constructor(options) {
+		this.#url = options.url.replace(/\/$/, "");
+		this.#spec = options.spec;
+		this.#headers = options.headers ?? {};
+		this.#fetch = options.fetch ?? globalThis.fetch;
+	}
+	async call(path, input, options) {
+		const endpoint = "/" + path.join("/");
+		const url = this.#url + endpoint;
+		const headers = {
+			"content-type": "application/json",
+			...typeof this.#headers === "function" ? this.#headers() : this.#headers
+		};
+		let method = "POST";
+		if (this.#spec) {
+			const paths = this.#spec.paths;
+			if (paths?.[endpoint]) {
+				if (paths[endpoint].get) method = "GET";
+				else if (paths[endpoint].post) method = "POST";
+				else if (paths[endpoint].put) method = "PUT";
+				else if (paths[endpoint].patch) method = "PATCH";
+				else if (paths[endpoint].delete) method = "DELETE";
+			}
+		}
+		let requestUrl = url;
+		let body;
+		if (method === "GET" || method === "HEAD") {
+			if (input && typeof input === "object") {
+				const params = new URLSearchParams();
+				for (const [k, v] of Object.entries(input)) if (v !== void 0) params.set(k, String(v));
+				const qs = params.toString();
+				if (qs) requestUrl = `${url}?${qs}`;
+			}
+		} else body = input !== void 0 ? JSON.stringify(input) : void 0;
+		const response = await this.#fetch(requestUrl, {
+			method,
+			headers,
+			body,
+			signal: options.signal
+		});
+		if (!response.ok) {
+			const errorBody = await response.json().catch(() => null);
+			throw new SilgiError(errorBody?.code ?? `HTTP_${response.status}`, {
+				status: response.status,
+				message: errorBody?.message ?? response.statusText,
+				data: errorBody
+			});
+		}
+		return response.json();
+	}
+};
+//#endregion
+export { OpenAPILink };

package/dist/client/plugins/batch.d.mts

@@ -0,0 +1,26 @@
+import { ClientContext, ClientLink, ClientOptions } from "../types.mjs";
+
+//#region src/client/plugins/batch.d.ts
+interface BatchLinkOptions {
+  /** The underlying link to send the batch through */
+  link: ClientLink;
+  /** Batch endpoint path (default: /__batch__) */
+  path?: string;
+  /** Maximum batch size (default: 20) */
+  maxSize?: number;
+  /** URL for the batch endpoint */
+  url: string | URL;
+  /**
+   * Enable streaming mode — server streams individual responses progressively
+   * via newline-delimited JSON instead of waiting for all to complete.
+   * @default false
+   */
+  streaming?: boolean;
+}
+declare class BatchLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(options: BatchLinkOptions);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { BatchLink, BatchLinkOptions };

package/dist/client/plugins/batch.mjs

@@ -0,0 +1,64 @@
+//#region src/client/plugins/batch.ts
+var BatchLink = class {
+	#link;
+	#batchPath;
+	#maxSize;
+	#pending = [];
+	#scheduled = false;
+	constructor(options) {
+		this.#link = options.link;
+		this.#batchPath = options.path ?? "/__batch__";
+		this.#maxSize = options.maxSize ?? 20;
+	}
+	call(path, input, options) {
+		return new Promise((resolve, reject) => {
+			this.#pending.push({
+				path,
+				input,
+				options,
+				resolve,
+				reject
+			});
+			if (!this.#scheduled) {
+				this.#scheduled = true;
+				queueMicrotask(() => this.#flush());
+			}
+		});
+	}
+	async #flush() {
+		this.#scheduled = false;
+		const batch = this.#pending.splice(0);
+		if (batch.length === 0) return;
+		const chunks = [];
+		for (let i = 0; i < batch.length; i += this.#maxSize) chunks.push(batch.slice(i, i + this.#maxSize));
+		await Promise.all(chunks.map((chunk) => this.#sendChunk(chunk)));
+	}
+	async #sendChunk(chunk) {
+		const batchBody = chunk.map((call) => ({
+			path: "/" + call.path.join("/"),
+			method: "POST",
+			body: call.input
+		}));
+		try {
+			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk.length === 1 ? chunk[0].options.signal : AbortSignal.any(chunk.map((c) => c.options.signal).filter(Boolean)) });
+			if (!Array.isArray(responses)) {
+				for (const call of chunk) call.reject(/* @__PURE__ */ new Error("Invalid batch response"));
+				return;
+			}
+			for (const response of responses) {
+				const call = chunk[response.index];
+				if (!call) continue;
+				if (response.status >= 400) call.reject(response.body ?? /* @__PURE__ */ new Error(`HTTP ${response.status}`));
+				else call.resolve(response.body);
+			}
+			for (let i = 0; i < chunk.length; i++) {
+				const call = chunk[i];
+				if (!responses.some((r) => r.index === i)) call.reject(/* @__PURE__ */ new Error("No response in batch"));
+			}
+		} catch (error) {
+			for (const call of chunk) call.reject(error);
+		}
+	}
+};
+//#endregion
+export { BatchLink };