snapreq 0.0.3 → 0.0.5

package/build/transports/fetch-transport.js

@@ -0,0 +1,116 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqAbortError, SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * Transport backed by the `fetch` global. Works on web, Expo / React Native and
+ * Node 18+. It cannot open Unix sockets, present client certificates or
+ * compress request bodies — those raise `SnapReqUnsupportedFeatureError`.
+ * Response streaming uses `response.body` where available and otherwise buffers
+ * the body once, keeping the same stream interface everywhere.
+ */
+export default class FetchTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "fetch";
+    }
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable() {
+        return typeof fetch === "function";
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({
+            responseStreaming: true,
+            abort: true
+        });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        if (request.bodyCompression && request.bodyCompression !== "identity") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "request body compression", transport: "fetch" });
+        }
+        /** @type {Record<string, any>} */
+        const init = {
+            method: request.method,
+            headers: request.headers.toObject()
+        };
+        if (request.signal)
+            init.signal = request.signal;
+        if (request.credentials)
+            init.credentials = request.credentials;
+        const body = request.body;
+        if (body.kind === "text") {
+            init.body = body.value;
+        }
+        else if (body.kind === "bytes") {
+            init.body = body.value;
+        }
+        else if (body.kind === "stream") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "streamed request bodies", transport: "fetch" });
+        }
+        /** @type {Response} */
+        let fetchResponse;
+        try {
+            fetchResponse = await fetch(request.url, init);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError")
+                throw new SnapReqAbortError();
+            throw error;
+        }
+        return new SnapReqResponse({
+            url: request.url,
+            method: request.method,
+            status: fetchResponse.status,
+            statusText: fetchResponse.statusText,
+            headers: this._responseHeaders(fetchResponse),
+            stream: this._responseStream(fetchResponse)
+        });
+    }
+    /**
+     * @param {Response} response - The fetch response.
+     * @returns {SnapReqHeaders} - The response headers.
+     */
+    _responseHeaders(response) {
+        const headers = new SnapReqHeaders();
+        response.headers.forEach((value, name) => headers.set(name, value));
+        return headers;
+    }
+    /**
+     * Builds an async iterable of byte chunks over a fetch response. Uses the
+     * `ReadableStream` body for true streaming when present and otherwise buffers
+     * the whole body once so the stream interface stays identical everywhere.
+     * @param {Response} response - The fetch response.
+     * @returns {AsyncIterable<Uint8Array>} - The response body stream.
+     */
+    _responseStream(response) {
+        const body = response.body;
+        if (body && typeof body.getReader === "function") {
+            return (async function* () {
+                const reader = body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value)
+                            yield value instanceof Uint8Array ? value : new Uint8Array(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock?.();
+                }
+            })();
+        }
+        return (async function* () {
+            const buffer = await response.arrayBuffer();
+            yield new Uint8Array(buffer);
+        })();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/transports/fetch.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./fetch-transport.js";
+//# sourceMappingURL=fetch.d.ts.map

package/build/transports/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/transports/fetch.js"],"names":[],"mappings":""}

package/build/transports/fetch.js

@@ -0,0 +1,3 @@
+// @ts-check
+export { default } from "./fetch-transport.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJhbnNwb3J0cy9mZXRjaC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLHNCQUFzQixDQUFBIn0=

package/{types → build}/transports/node-transport.d.ts

@@ -110,3 +110,4 @@ export default class NodeTransport {
 }
 import SnapReqResponse from "../response.js";
 import SnapReqHeaders from "../headers.js";
+//# sourceMappingURL=node-transport.d.ts.map

package/build/transports/node-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-transport.d.ts","sourceRoot":"","sources":["../../src/transports/node-transport.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IACE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAED,sFAAsF;IACtF,sBADc,OAAO,CAGpB;IAED;;;;;OAKG;IACH,6CAJG;QAAwB,UAAU,GAA1B,MAAM;QACuG,GAAG,GAAhH;YAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;SAAC;QAClF,SAAS,GAA1B,OAAO;KACjB,EAWA;IATC,mBAA4B;IAC5B;aALe,MAAM,GAAG,MAAM;eAAS,MAAM,GAAG,MAAM;cAAQ,MAAM,GAAG,MAAM;6BAAuB,OAAO;MAK7F;IACd,mBAA0B;IAC1B,qEAAqE;IACrE,UADW;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,GAAG,IAAI,CAC7C;IACpB,kBAAkB;IAClB,YADW,GAAG,CACQ;IACtB,kBAAkB;IAClB,aADW,GAAG,CACS;IAGzB,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAW/D;IAED,wGAAwG;IACxG,SADc,OAAO,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,CAAC,CAcrE;IAED;;;OAGG;IACH,eAHW,OAAO,GACL,GAAG,CAoBf;IAED;;;;;OAKG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA2FpC;IAED;;;;;OAKG;IACH,6BALW,OAAO,gBAAgB,EAAE,iBAAiB,WAC1C,cAAc,oBACd;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,GACtB;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,QAAQ,GAAG,IAAI,CAAA;KAAC,CA8ClF;IAED;;;;OAIG;IACH,6BAJW,MAAM,QACN,GAAG,GACD,OAAO,aAAa,EAAE,SAAS,CAS3C;IAED;;;;OAIG;IACH,gCAJW,OAAO,WAAW,EAAE,eAAe,QACnC,GAAG,GACD,OAAO,aAAa,EAAE,QAAQ,CAkB1C;IAED;;;;OAIG;IACH,2BAJW,MAAM,QACN,GAAG,GACD,OAAO,aAAa,EAAE,SAAS,CAS3C;IAED;;;OAGG;IACH,2BAHW,OAAO,WAAW,EAAE,eAAe,GACjC,cAAc,CAY1B;IAED;;;OAGG;IACH,SAFa,IAAI,CAOhB;CACF;4BA7T2B,gBAAgB;2BADjB,eAAe"}

package/build/transports/node-transport.js

@@ -0,0 +1,287 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqAbortError, SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * Full-featured transport backed by Node's `http`/`https` modules. Supports
+ * Unix sockets, client TLS, keep-alive, request-body compression, response
+ * decompression and streaming. The `node:*` modules are loaded with a dynamic
+ * `import()` so this file never has to be bundled by web/Expo bundlers — the
+ * transport selector only imports it when running on Node.
+ */
+export default class NodeTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "node";
+    }
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable() {
+        return typeof process !== "undefined" && Boolean(process.versions?.node);
+    }
+    /**
+     * @param {object} [config] - Transport configuration.
+     * @param {string} [config.socketPath] - Unix domain socket path.
+     * @param {{ca?: string | Buffer, cert?: string | Buffer, key?: string | Buffer, rejectUnauthorized?: boolean}} [config.tls] - TLS material for HTTPS connections.
+     * @param {boolean} [config.keepAlive] - Reuse connections across requests. Defaults to true.
+     */
+    constructor({ socketPath, tls, keepAlive = true } = {}) {
+        this.socketPath = socketPath;
+        this.tls = tls;
+        this.keepAlive = keepAlive;
+        /** @type {{http: any, https: any, zlib: any, stream: any} | null} */
+        this._modules = null;
+        /** @type {any} */
+        this._httpAgent = null;
+        /** @type {any} */
+        this._httpsAgent = null;
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({
+            unixSocket: true,
+            tlsClientCert: true,
+            requestCompression: true,
+            responseStreaming: true,
+            requestStreaming: true,
+            keepAlive: true,
+            abort: true
+        });
+    }
+    /** @returns {Promise<{http: any, https: any, zlib: any, stream: any}>} - Lazily-loaded Node modules. */
+    async _load() {
+        if (!this._modules) {
+            const [http, https, zlib, stream] = await Promise.all([
+                import("node:http"),
+                import("node:https"),
+                import("node:zlib"),
+                import("node:stream")
+            ]);
+            this._modules = { http, https, zlib, stream };
+        }
+        return this._modules;
+    }
+    /**
+     * @param {boolean} useTls - Whether the request uses TLS.
+     * @returns {any} - The keep-alive agent for the protocol.
+     */
+    _agent(useTls) {
+        const { http, https } = /** @type {{http: any, https: any}} */ (this._modules);
+        if (useTls) {
+            this._httpsAgent || (this._httpsAgent = new https.Agent({
+                keepAlive: this.keepAlive,
+                ...(this.tls?.ca !== undefined ? { ca: this.tls.ca } : {}),
+                ...(this.tls?.cert !== undefined ? { cert: this.tls.cert } : {}),
+                ...(this.tls?.key !== undefined ? { key: this.tls.key } : {}),
+                ...(this.tls?.rejectUnauthorized !== undefined ? { rejectUnauthorized: this.tls.rejectUnauthorized } : {})
+            }));
+            return this._httpsAgent;
+        }
+        this._httpAgent || (this._httpAgent = new http.Agent({ keepAlive: this.keepAlive }));
+        return this._httpAgent;
+    }
+    /**
+     * Performs a single request and resolves once the response headers arrive,
+     * exposing the (decoded) body as a stream so callers can buffer or stream it.
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        const modules = await this._load();
+        const { zlib, stream } = modules;
+        const parsedUrl = new URL(request.url);
+        const useTls = Boolean(this.tls) || parsedUrl.protocol === "https:";
+        const httpModule = useTls ? modules.https : modules.http;
+        const headers = new SnapReqHeaders(request.headers);
+        const requestBody = this._prepareRequestBody(request, headers, { zlib, stream });
+        /** @type {Record<string, any>} */
+        const requestOptions = {
+            method: request.method,
+            path: `${parsedUrl.pathname}${parsedUrl.search}`,
+            headers: headers.toObject(),
+            agent: this._agent(useTls)
+        };
+        if (this.socketPath) {
+            requestOptions.socketPath = this.socketPath;
+        }
+        else {
+            requestOptions.hostname = parsedUrl.hostname;
+            requestOptions.port = parsedUrl.port || (useTls ? 443 : 80);
+        }
+        return await new Promise((resolve, reject) => {
+            if (request.signal?.aborted) {
+                reject(new SnapReqAbortError());
+                return;
+            }
+            let settled = false;
+            const abort = () => req.destroy(new SnapReqAbortError());
+            const removeAbortListener = () => request.signal?.removeEventListener("abort", abort);
+            const req = httpModule.request(requestOptions, (res) => {
+                /** @type {import("node:stream").Readable} */
+                let responseStream;
+                try {
+                    responseStream = this._decodeResponseStream(res, zlib);
+                }
+                catch (error) {
+                    if (!settled) {
+                        settled = true;
+                        removeAbortListener();
+                        reject(error);
+                    }
+                    return;
+                }
+                // Re-point the abort listener at the response stream so aborting after
+                // headers arrive tears down the body stream rather than the request.
+                removeAbortListener();
+                const abortStream = () => responseStream.destroy(new SnapReqAbortError());
+                request.signal?.addEventListener("abort", abortStream, { once: true });
+                responseStream.on("close", () => request.signal?.removeEventListener("abort", abortStream));
+                settled = true;
+                resolve(new SnapReqResponse({
+                    url: request.url,
+                    method: request.method,
+                    status: res.statusCode,
+                    statusText: res.statusMessage || "",
+                    headers: this._responseHeaders(res),
+                    stream: responseStream,
+                    nodeStream: responseStream
+                }));
+            });
+            request.signal?.addEventListener("abort", abort, { once: true });
+            req.on("error", (/** @type {unknown} */ error) => {
+                removeAbortListener();
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                }
+            });
+            if (requestBody.stream) {
+                requestBody.stream.pipe(req);
+            }
+            else {
+                if (requestBody.buffer)
+                    req.write(requestBody.buffer);
+                req.end();
+            }
+        });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @param {SnapReqHeaders} headers - Headers, mutated with Content-Length / Content-Encoding.
+     * @param {{zlib: any, stream: any}} modules - Node modules.
+     * @returns {{buffer: Buffer | null, stream: import("node:stream").Readable | null}} - Prepared body.
+     */
+    _prepareRequestBody(request, headers, { zlib, stream }) {
+        const compression = request.bodyCompression || "identity";
+        const body = request.body;
+        if (body.kind === "none")
+            return { buffer: null, stream: null };
+        /** @type {Buffer | null} */
+        let buffer = null;
+        /** @type {import("node:stream").Readable | null} */
+        let bodyStream = null;
+        if (body.kind === "stream") {
+            const value = /** @type {any} */ (body.value);
+            bodyStream = typeof value.pipe === "function" ? value : stream.Readable.from(value);
+        }
+        else if (body.kind === "bytes") {
+            buffer = Buffer.from(/** @type {Uint8Array} */ (body.value));
+        }
+        else {
+            buffer = Buffer.from(/** @type {string} */ (body.value));
+        }
+        if (compression === "identity") {
+            if (buffer)
+                headers.set("Content-Length", String(buffer.length));
+            return { buffer, stream: bodyStream };
+        }
+        if (headers.has("content-encoding")) {
+            throw new SnapReqUnsupportedFeatureError({
+                feature: "bodyCompression",
+                transport: "node",
+                detail: "cannot combine bodyCompression with an explicit Content-Encoding header"
+            });
+        }
+        headers.set("Content-Encoding", compression);
+        const compressor = this._requestCompressor(compression, zlib);
+        const source = bodyStream || stream.Readable.from(/** @type {Buffer} */ (buffer));
+        source.on("error", (/** @type {Error} */ error) => compressor.destroy(error));
+        source.pipe(compressor);
+        return { buffer: null, stream: compressor };
+    }
+    /**
+     * @param {string} encoding - Compression encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A compressor transform.
+     */
+    _requestCompressor(encoding, zlib) {
+        if (encoding === "gzip")
+            return zlib.createGzip();
+        if (encoding === "deflate")
+            return zlib.createDeflate();
+        if (encoding === "br")
+            return zlib.createBrotliCompress();
+        if (encoding === "zstd" && typeof zlib.createZstdCompress === "function")
+            return zlib.createZstdCompress();
+        throw new SnapReqUnsupportedFeatureError({ feature: `bodyCompression "${encoding}"`, transport: "node" });
+    }
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Readable} - The decoded response body stream.
+     */
+    _decodeResponseStream(response, zlib) {
+        const header = response.headers["content-encoding"];
+        const headerValue = Array.isArray(header) ? header.join(",") : header;
+        const encodings = (headerValue || "")
+            .split(",")
+            .map((encoding) => encoding.trim().toLowerCase())
+            .filter((encoding) => encoding && encoding !== "identity");
+        /** @type {import("node:stream").Readable} */
+        let decoded = response;
+        for (let index = encodings.length - 1; index >= 0; index -= 1) {
+            decoded = decoded.pipe(this._responseDecoder(encodings[index], zlib));
+        }
+        return decoded;
+    }
+    /**
+     * @param {string} encoding - Content encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A decompressor transform.
+     */
+    _responseDecoder(encoding, zlib) {
+        if (encoding === "gzip" || encoding === "x-gzip")
+            return zlib.createGunzip();
+        if (encoding === "deflate")
+            return zlib.createInflate();
+        if (encoding === "br")
+            return zlib.createBrotliDecompress();
+        if (encoding === "zstd" && typeof zlib.createZstdDecompress === "function")
+            return zlib.createZstdDecompress();
+        throw new SnapReqUnsupportedFeatureError({ feature: `response content-encoding "${encoding}"`, transport: "node" });
+    }
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @returns {SnapReqHeaders} - The response headers.
+     */
+    _responseHeaders(response) {
+        const headers = new SnapReqHeaders();
+        for (const [name, value] of Object.entries(response.headers)) {
+            if (value === undefined)
+                continue;
+            headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+        }
+        return headers;
+    }
+    /**
+     * Destroys the keep-alive agents, closing all persistent connections.
+     * @returns {void}
+     */
+    close() {
+        this._httpAgent?.destroy();
+        this._httpsAgent?.destroy();
+        this._httpAgent = null;
+        this._httpsAgent = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-transport.js","sourceRoot":"","sources":["../../src/transports/node-transport.js"],"names":[],"mappings":"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"}

package/build/transports/proxy-bounce-transport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transport that bounces every request through a same-origin proxy endpoint.
+ * Used when the real target is a different origin and CORS would block direct
+ * browser `fetch` calls. The proxy backend makes the outbound request
+ * server-side where CORS does not apply.
+ */
+export default class ProxyBounceTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName(): string;
+    /**
+     * @param {object} config - Transport configuration.
+     * @param {string} config.proxyUrl - Absolute URL of the proxy endpoint.
+     */
+    constructor({ proxyUrl }: {
+        proxyUrl: string;
+    });
+    proxyUrl: string;
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities(): import("../capabilities.js").TransportCapabilities;
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    performRequest(request: import("../snap-req.js").NormalizedRequest): Promise<SnapReqResponse>;
+}
+import SnapReqResponse from "../response.js";
+//# sourceMappingURL=proxy-bounce-transport.d.ts.map

package/build/transports/proxy-bounce-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-bounce-transport.d.ts","sourceRoot":"","sources":["../../src/transports/proxy-bounce-transport.js"],"names":[],"mappings":"AAgCA;;;;;GAKG;AACH;IASE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAXD;;;OAGG;IACH,0BAFG;QAAuB,QAAQ,EAAvB,MAAM;KAChB,EAGA;IADC,iBAAwB;IAQ1B,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAG/D;IAED;;;OAGG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA2EpC;CACF;4BAlI2B,gBAAgB"}

package/build/transports/proxy-bounce-transport.js

@@ -0,0 +1,116 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * @param {Uint8Array} bytes - Bytes to encode.
+ * @returns {string} - Base64 string.
+ */
+function base64Encode(bytes) {
+    const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+}
+/**
+ * @param {string} base64 - Base64-encoded string.
+ * @returns {Uint8Array} - Decoded bytes.
+ */
+function base64Decode(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Transport that bounces every request through a same-origin proxy endpoint.
+ * Used when the real target is a different origin and CORS would block direct
+ * browser `fetch` calls. The proxy backend makes the outbound request
+ * server-side where CORS does not apply.
+ */
+export default class ProxyBounceTransport {
+    /**
+     * @param {object} config - Transport configuration.
+     * @param {string} config.proxyUrl - Absolute URL of the proxy endpoint.
+     */
+    constructor({ proxyUrl }) {
+        this.proxyUrl = proxyUrl;
+    }
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "proxy-bounce";
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({ abort: true });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        const requestBody = request.body;
+        /** @type {string | null} */
+        let serializedBody = null;
+        /** @type {string | undefined} */
+        let bodyEncoding;
+        if (requestBody.kind === "text") {
+            serializedBody = /** @type {string} */ (requestBody.value);
+        }
+        else if (requestBody.kind === "bytes") {
+            serializedBody = base64Encode(/** @type {Uint8Array} */ (requestBody.value));
+            bodyEncoding = "base64";
+        }
+        else if (requestBody.kind === "stream") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "streamed request bodies", transport: "proxy-bounce" });
+        }
+        /** @type {Record<string, any>} */
+        const proxyPayload = {
+            body: serializedBody,
+            headers: request.headers.toObject(),
+            method: request.method,
+            url: request.url
+        };
+        if (bodyEncoding) {
+            proxyPayload.bodyEncoding = bodyEncoding;
+        }
+        /** @type {Response} */
+        let proxyResponse;
+        try {
+            proxyResponse = await fetch(this.proxyUrl, {
+                body: JSON.stringify(proxyPayload),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+                signal: request.signal || undefined
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw error;
+            }
+            throw error;
+        }
+        const payload = await proxyResponse.json();
+        const responseHeaders = new SnapReqHeaders();
+        if (payload.headers) {
+            for (const [name, value] of Object.entries(payload.headers)) {
+                responseHeaders.set(name, String(value));
+            }
+        }
+        /** @type {Uint8Array} */
+        let bodyBytes = new Uint8Array(0);
+        if (payload.body) {
+            bodyBytes = base64Decode(payload.body);
+        }
+        return new SnapReqResponse({
+            bytes: bodyBytes,
+            headers: responseHeaders,
+            method: request.method,
+            status: payload.status,
+            statusText: payload.statusText || "",
+            url: request.url
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveHktYm91bmNlLXRyYW5zcG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmFuc3BvcnRzL3Byb3h5LWJvdW5jZS10cmFuc3BvcnQuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLG9CQUFvQixDQUFBO0FBQ3BELE9BQU8sRUFBQyw4QkFBOEIsRUFBQyxNQUFNLGNBQWMsQ0FBQTtBQUMzRCxPQUFPLGNBQWMsTUFBTSxlQUFlLENBQUE7QUFDMUMsT0FBTyxlQUFlLE1BQU0sZ0JBQWdCLENBQUE7QUFFNUM7OztHQUdHO0FBQ0gsU0FBUyxZQUFZLENBQUMsS0FBSztJQUN6QixNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUV4RSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUNyQixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBUyxZQUFZLENBQUMsTUFBTTtJQUMxQixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDM0IsTUFBTSxLQUFLLEdBQUcsSUFBSSxVQUFVLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTNDLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUMxQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUNqQyxDQUFDO0lBRUQsT0FBTyxLQUFLLENBQUE7QUFDZCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsT0FBTyxPQUFPLG9CQUFvQjtJQUN2Qzs7O09BR0c7SUFDSCxZQUFZLEVBQUMsUUFBUSxFQUFDO1FBQ3BCLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFBO0lBQzFCLENBQUM7SUFFRCwwQ0FBMEM7SUFDMUMsTUFBTSxLQUFLLGFBQWE7UUFDdEIsT0FBTyxjQUFjLENBQUE7SUFDdkIsQ0FBQztJQUVELDhGQUE4RjtJQUM5RixJQUFJLFlBQVk7UUFDZCxPQUFPLGlCQUFpQixDQUFDLEVBQUMsS0FBSyxFQUFFLElBQUksRUFBQyxDQUFDLENBQUE7SUFDekMsQ0FBQztJQUVEOzs7T0FHRztJQUNILEtBQUssQ0FBQyxjQUFjLENBQUMsT0FBTztRQUMxQixNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFBO1FBRWhDLDRCQUE0QjtRQUM1QixJQUFJLGNBQWMsR0FBRyxJQUFJLENBQUE7UUFFekIsaUNBQWlDO1FBQ2pDLElBQUksWUFBWSxDQUFBO1FBRWhCLElBQUksV0FBVyxDQUFDLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FBQztZQUNoQyxjQUFjLEdBQUcscUJBQXFCLENBQUMsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDNUQsQ0FBQzthQUFNLElBQUksV0FBVyxDQUFDLElBQUksS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUN4QyxjQUFjLEdBQUcsWUFBWSxDQUFDLHlCQUF5QixDQUFDLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7WUFDNUUsWUFBWSxHQUFHLFFBQVEsQ0FBQTtRQUN6QixDQUFDO2FBQU0sSUFBSSxXQUFXLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQ3pDLE1BQU0sSUFBSSw4QkFBOEIsQ0FBQyxFQUFDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFDLENBQUMsQ0FBQTtRQUMzRyxDQUFDO1FBRUQsa0NBQWtDO1FBQ2xDLE1BQU0sWUFBWSxHQUFHO1lBQ25CLElBQUksRUFBRSxjQUFjO1lBQ3BCLE9BQU8sRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRTtZQUNuQyxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07WUFDdEIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1NBQ2pCLENBQUE7UUFFRCxJQUFJLFlBQVksRUFBRSxDQUFDO1lBQ2pCLFlBQVksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFBO1FBQzFDLENBQUM7UUFFRCx1QkFBdUI7UUFDdkIsSUFBSSxhQUFhLENBQUE7UUFFakIsSUFBSSxDQUFDO1lBQ0gsYUFBYSxHQUFHLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ3pDLElBQUksRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQztnQkFDbEMsT0FBTyxFQUFFLEVBQUMsY0FBYyxFQUFFLGtCQUFrQixFQUFDO2dCQUM3QyxNQUFNLEVBQUUsTUFBTTtnQkFDZCxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sSUFBSSxTQUFTO2FBQ3BDLENBQUMsQ0FBQTtRQUNKLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsSUFBSSxLQUFLLFlBQVksS0FBSyxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssWUFBWSxFQUFFLENBQUM7Z0JBQzFELE1BQU0sS0FBSyxDQUFBO1lBQ2IsQ0FBQztZQUVELE1BQU0sS0FBSyxDQUFBO1FBQ2IsQ0FBQztRQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sYUFBYSxDQUFDLElBQUksRUFBRSxDQUFBO1FBRTFDLE1BQU0sZUFBZSxHQUFHLElBQUksY0FBYyxFQUFFLENBQUE7UUFFNUMsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDcEIsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQzVELGVBQWUsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO1lBQzFDLENBQUM7UUFDSCxDQUFDO1FBRUQseUJBQXlCO1FBQ3pCLElBQUksU0FBUyxHQUFHLElBQUksVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBRWpDLElBQUksT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ2pCLFNBQVMsR0FBRyxZQUFZLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQ3hDLENBQUM7UUFFRCxPQUFPLElBQUksZUFBZSxDQUFDO1lBQ3pCLEtBQUssRUFBRSxTQUFTO1lBQ2hCLE9BQU8sRUFBRSxlQUFlO1lBQ3hCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtZQUN0QixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07WUFDdEIsVUFBVSxFQUFFLE9BQU8sQ0FBQyxVQUFVLElBQUksRUFBRTtZQUNwQyxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUc7U0FDakIsQ0FBQyxDQUFBO0lBQ0osQ0FBQztDQUNGIn0=

package/{types → build}/transports/select.d.ts

@@ -36,3 +36,4 @@ export type Transport = {
      */
     close?: () => void;
 };
+//# sourceMappingURL=select.d.ts.map

package/build/transports/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/transports/select.js"],"names":[],"mappings":"AAMA;;GAEG;AAEH;;;;;GAKG;AAEH;;;GAGG;AACH,iCAFa,MAAM,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAU3D;AAYD;;;;;;;GAOG;AACH,4CAJW,aAAa,GAAG,SAAS,GAAG,SAAS,cACrC,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAyB9B;4BAjEY,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK;;;;;kBAKhC,OAAO,oBAAoB,EAAE,qBAAqB;;;;oBAClD,CAAC,OAAO,EAAE,OAAO,gBAAgB,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,gBAAgB,EAAE,OAAO,CAAC;;;;YAClG,MAAM,IAAI"}