openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect-node/dist/cjs/node-universal-client.js

@@ -0,0 +1,347 @@
+"use strict";
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeHttpClient = createNodeHttpClient;
+const http = require("node:http");
+const https = require("node:https");
+const connect_1 = require("@connectrpc/connect");
+const node_universal_header_js_1 = require("./node-universal-header.js");
+const node_error_js_1 = require("./node-error.js");
+const protocol_1 = require("@connectrpc/connect/protocol");
+const http2_session_manager_js_1 = require("./http2-session-manager.js");
+/**
+ * Create a universal client function, a minimal abstraction of an HTTP client,
+ * using the Node.js `http`, `https`, or `http2` module.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createNodeHttpClient(options) {
+    var _a;
+    if (options.httpVersion == "1.1") {
+        return createNodeHttp1Client(options.nodeOptions);
+    }
+    const sessionProvider = (_a = options.sessionProvider) !== null && _a !== void 0 ? _a : ((url) => new http2_session_manager_js_1.Http2SessionManager(url));
+    return createNodeHttp2Client(sessionProvider);
+}
+/**
+ * Create an HTTP client using the Node.js `http` or `https` package.
+ *
+ * The HTTP client is a simple function conforming to the type UniversalClientFn.
+ * It takes an UniversalClientRequest as an argument, and returns a promise for
+ * an UniversalClientResponse.
+ */
+function createNodeHttp1Client(httpOptions) {
+    return async function request(req) {
+        const sentinel = createSentinel(req.signal);
+        return new Promise((resolve, reject) => {
+            sentinel.onError((e) => {
+                reject(e);
+            });
+            h1Request(sentinel, req.url, Object.assign(Object.assign({}, httpOptions), { headers: (0, node_universal_header_js_1.webHeaderToNodeHeaders)(req.header, httpOptions === null || httpOptions === void 0 ? void 0 : httpOptions.headers), method: req.method }), (request) => {
+                void sinkRequest(req, request, sentinel);
+                request.on("response", (response) => {
+                    var _a;
+                    response.on("error", sentinel.error);
+                    sentinel.onError((reason) => response.destroy(reason));
+                    const trailer = new Headers();
+                    resolve({
+                        status: (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0,
+                        header: (0, node_universal_header_js_1.nodeHeaderToWebHeader)(response.headers),
+                        body: h1ResponseIterable(sentinel, response, trailer),
+                        trailer,
+                    });
+                });
+            });
+        });
+    };
+}
+/**
+ * Create an HTTP client using the Node.js `http2` package.
+ *
+ * The HTTP client is a simple function conforming to the type UniversalClientFn.
+ * It takes an UniversalClientRequest as an argument, and returns a promise for
+ * an UniversalClientResponse.
+ */
+function createNodeHttp2Client(sessionProvider) {
+    return function request(req) {
+        const sentinel = createSentinel(req.signal);
+        const sessionManager = sessionProvider(req.url);
+        return new Promise((resolve, reject) => {
+            sentinel.onError((e) => {
+                reject(e);
+            });
+            h2Request(sentinel, sessionManager, req.url, req.method, (0, node_universal_header_js_1.webHeaderToNodeHeaders)(req.header), {}, (stream) => {
+                void sinkRequest(req, stream, sentinel);
+                stream.on("response", (headers) => {
+                    var _a;
+                    const response = {
+                        status: (_a = headers[":status"]) !== null && _a !== void 0 ? _a : 0,
+                        header: (0, node_universal_header_js_1.nodeHeaderToWebHeader)(headers),
+                        body: h2ResponseIterable(sentinel, stream, sessionManager),
+                        trailer: h2ResponseTrailer(stream),
+                    };
+                    resolve(response);
+                });
+            });
+        });
+    };
+}
+function h1Request(sentinel, url, options, onRequest) {
+    let request;
+    if (new URL(url).protocol.startsWith("https")) {
+        request = https.request(url, options);
+    }
+    else {
+        request = http.request(url, options);
+    }
+    sentinel.onError((reason) => request.destroy(reason));
+    // Node.js will only send headers with the first request body byte by default.
+    // We force it to send headers right away for consistent behavior between
+    // HTTP/1.1 and HTTP/2.0 clients.
+    request.flushHeaders();
+    request.on("error", sentinel.error);
+    request.on("socket", function onRequestSocket(socket) {
+        function onSocketConnect() {
+            socket.off("connect", onSocketConnect);
+            onRequest(request);
+        }
+        // If readyState is open, then socket is already open due to keepAlive, so
+        // the 'connect' event will never fire so call onRequest explicitly
+        if (socket.readyState === "open") {
+            onRequest(request);
+        }
+        else {
+            socket.on("connect", onSocketConnect);
+        }
+    });
+}
+function h1ResponseIterable(sentinel, response, trailer) {
+    const inner = response[Symbol.asyncIterator]();
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    const r = await sentinel.race(inner.next());
+                    if (r.done === true) {
+                        (0, node_universal_header_js_1.nodeHeaderToWebHeader)(response.trailers).forEach((value, key) => {
+                            trailer.set(key, value);
+                        });
+                        sentinel.close();
+                    }
+                    return r;
+                },
+                throw(e) {
+                    sentinel.error(e);
+                    throw e;
+                },
+            };
+        },
+    };
+}
+function h2Request(sentinel, sm, url, method, headers, options, onStream) {
+    const requestUrl = new URL(url);
+    if (requestUrl.origin !== sm.authority) {
+        const message = `cannot make a request to ${requestUrl.origin}: the http2 session is connected to ${sm.authority}`;
+        sentinel.error(new connect_1.ConnectError(message, connect_1.Code.Internal));
+        return;
+    }
+    sm.request(method, requestUrl.pathname + requestUrl.search, headers, {}).then((stream) => {
+        sentinel.onError((reason) => {
+            if (stream.closed) {
+                return;
+            }
+            // Node.js http2 streams that are aborted via an AbortSignal close with
+            // an RST_STREAM with code INTERNAL_ERROR.
+            // To comply with the mapping between gRPC and HTTP/2 codes, we need to
+            // close with code CANCEL.
+            // See https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#errors
+            // See https://www.rfc-editor.org/rfc/rfc7540#section-7
+            const rstCode = reason.code == connect_1.Code.Canceled ? node_error_js_1.H2Code.CANCEL : node_error_js_1.H2Code.INTERNAL_ERROR;
+            return new Promise((resolve) => stream.close(rstCode, resolve));
+        });
+        stream.on("error", function h2StreamError(e) {
+            if (stream.writableEnded &&
+                (0, node_error_js_1.unwrapNodeErrorChain)(e)
+                    .map(node_error_js_1.getNodeErrorProps)
+                    .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
+                return;
+            }
+            sentinel.error(e);
+        });
+        stream.on("close", function h2StreamClose() {
+            const err = (0, node_error_js_1.connectErrorFromH2ResetCode)(stream.rstCode);
+            if (err) {
+                sentinel.error(err);
+            }
+        });
+        onStream(stream);
+    }, (reason) => {
+        sentinel.error(reason);
+    });
+}
+function h2ResponseTrailer(response) {
+    const trailer = new Headers();
+    response.on("trailers", (args) => {
+        (0, node_universal_header_js_1.nodeHeaderToWebHeader)(args).forEach((value, key) => {
+            trailer.set(key, value);
+        });
+    });
+    return trailer;
+}
+function h2ResponseIterable(sentinel, response, sm) {
+    const inner = response[Symbol.asyncIterator]();
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    const r = await sentinel.race(inner.next());
+                    if (r.done === true) {
+                        sentinel.close();
+                    }
+                    sm === null || sm === void 0 ? void 0 : sm.notifyResponseByteRead(response);
+                    return r;
+                },
+                throw(e) {
+                    sentinel.error(e);
+                    throw e;
+                },
+            };
+        },
+    };
+}
+async function sinkRequest(request, nodeRequest, sentinel) {
+    if (request.body === undefined) {
+        await new Promise((resolve) => nodeRequest.end(resolve));
+        return;
+    }
+    const it = request.body[Symbol.asyncIterator]();
+    return new Promise((resolve) => {
+        writeNext();
+        function writeNext() {
+            if (sentinel.isClosed()) {
+                return;
+            }
+            it.next().then((r) => {
+                if (r.done === true) {
+                    nodeRequest.end(resolve);
+                    return;
+                }
+                nodeRequest.write(r.value, "binary", (e) => {
+                    if (e === null || e === undefined) {
+                        writeNext();
+                        return;
+                    }
+                    if (it.throw !== undefined) {
+                        it.throw((0, node_error_js_1.connectErrorFromNodeReason)(e)).catch(() => {
+                            //
+                        });
+                    }
+                    // If the server responds and closes the connection before the client has written the entire response
+                    // body, we get an ERR_STREAM_WRITE_AFTER_END error code from Node.js here.
+                    // We do want to notify the iterable of the error condition, but we do not want to reject our sentinel,
+                    // because that would also affect the reading side.
+                    if (nodeRequest.writableEnded &&
+                        (0, node_error_js_1.unwrapNodeErrorChain)(e)
+                            .map(node_error_js_1.getNodeErrorProps)
+                            .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
+                        return;
+                    }
+                    sentinel.error(e);
+                });
+            }, (e) => {
+                sentinel.error(e);
+            });
+        }
+    });
+}
+function createSentinel(signal) {
+    let rejectRace;
+    let closed = false;
+    let closedError = undefined;
+    let onErrorListeners = [];
+    const sentinel = {
+        error(error) {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            closedError =
+                error instanceof connect_1.ConnectError
+                    ? error
+                    : (0, node_error_js_1.connectErrorFromNodeReason)(error);
+            rejectRace === null || rejectRace === void 0 ? void 0 : rejectRace(closedError);
+            for (const onRejected of onErrorListeners) {
+                onRejected(closedError);
+            }
+            cleanup();
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            if (rejectRace) {
+                rejectRace(new connect_1.ConnectError("sentinel completed early", connect_1.Code.Internal));
+            }
+            cleanup();
+        },
+        isClosed() {
+            return closed;
+        },
+        onError(onError) {
+            if (closed) {
+                if (closedError !== undefined) {
+                    onError(closedError);
+                }
+            }
+            else {
+                onErrorListeners.push(onError);
+            }
+        },
+        race(promise) {
+            let resolveRace;
+            const race = new Promise((resolve, reject) => {
+                resolveRace = resolve;
+                rejectRace = reject;
+            });
+            promise.then((value) => {
+                resolveRace === null || resolveRace === void 0 ? void 0 : resolveRace(value);
+            }, (reason) => {
+                rejectRace === null || rejectRace === void 0 ? void 0 : rejectRace(reason);
+            });
+            if (closed) {
+                rejectRace === null || rejectRace === void 0 ? void 0 : rejectRace(closedError !== null && closedError !== void 0 ? closedError : new connect_1.ConnectError("sentinel completed early", connect_1.Code.Internal));
+            }
+            return race;
+        },
+    };
+    function cleanup() {
+        if (signal) {
+            signal.removeEventListener("abort", onSignalAbort);
+        }
+        onErrorListeners = [];
+        rejectRace = undefined;
+    }
+    function onSignalAbort() {
+        sentinel.error((0, protocol_1.getAbortSignalReason)(this));
+    }
+    if (signal) {
+        signal.addEventListener("abort", onSignalAbort);
+        if (signal.aborted) {
+            sentinel.error((0, protocol_1.getAbortSignalReason)(signal));
+        }
+    }
+    return sentinel;
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/node-universal-handler.d.ts

@@ -0,0 +1,42 @@
+import type * as http from "node:http";
+import type * as http2 from "node:http2";
+import type { JsonValue } from "@bufbuild/protobuf";
+import type { UniversalServerRequest, UniversalServerResponse } from "@connectrpc/connect/protocol";
+import type { ContextValues } from "@connectrpc/connect";
+/**
+ * NodeHandlerFn is compatible with http.RequestListener and its equivalent
+ * for http2.
+ */
+export type NodeHandlerFn = (request: NodeServerRequest, response: NodeServerResponse) => void;
+/**
+ * A Node.js server request from the http, https, or the http2 module.
+ */
+export type NodeServerRequest = http.IncomingMessage | http2.Http2ServerRequest;
+/**
+ * A Node.js server response from the http, https, or the http2 module.
+ * Note that we are taking the liberty to patch the types of write()
+ * and writeHead() so that they are compatible with each other.
+ */
+export type NodeServerResponse = (Omit<http.ServerResponse, "write"> | Omit<http2.Http2ServerResponse, "write">) & {
+    write(chunk: string | Uint8Array, callback?: (err: Error | null | undefined) => void): boolean;
+    write(chunk: string | Uint8Array, encoding: BufferEncoding, callback?: (err: Error | null | undefined) => void): boolean;
+    writeHead(status: number, headers?: http.OutgoingHttpHeaders): unknown;
+};
+/**
+ * Converts a Node.js server request to a UniversalServerRequest.
+ * This function helps to implement adapters to server frameworks running
+ * on Node.js. Please be careful using this function in your own code, as we
+ * may have to make changes to it in the future.
+ */
+export declare function universalRequestFromNodeRequest(nodeRequest: NodeServerRequest, nodeResponse: NodeServerResponse, parsedJsonBody: JsonValue | undefined, contextValues: ContextValues | undefined): UniversalServerRequest;
+/**
+ * @deprecated
+ */
+export declare function universalRequestFromNodeRequest(nodeRequest: NodeServerRequest, parsedJsonBody: JsonValue | undefined, contextValues: ContextValues | undefined): UniversalServerRequest;
+/**
+ * Writes a UniversalServerResponse to a Node.js server response.
+ * This function helps to implement adapters to server frameworks running
+ * on Node.js. Please be careful using this function in your own code, as we
+ * may have to make changes to it in the future.
+ */
+export declare function universalResponseToNodeResponse(universalResponse: UniversalServerResponse, nodeResponse: NodeServerResponse): Promise<void>;

package/node_modules/@connectrpc/connect-node/dist/cjs/node-universal-handler.js

@@ -0,0 +1,225 @@
+"use strict";
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.universalRequestFromNodeRequest = universalRequestFromNodeRequest;
+exports.universalResponseToNodeResponse = universalResponseToNodeResponse;
+const connect_1 = require("@connectrpc/connect");
+const node_universal_header_js_1 = require("./node-universal-header.js");
+const node_error_js_1 = require("./node-error.js");
+function universalRequestFromNodeRequest(nodeRequest, ...rest) {
+    var _a, _b;
+    const nodeResponse = rest.length === 3 ? rest[0] : undefined;
+    const parsedJsonBody = rest.length === 3 ? rest[1] : rest[0];
+    const contextValues = rest.length === 3 ? rest[2] : rest[1];
+    const encrypted = "encrypted" in nodeRequest.socket && nodeRequest.socket.encrypted;
+    const protocol = encrypted ? "https" : "http";
+    const authority = "authority" in nodeRequest
+        ? nodeRequest.authority
+        : nodeRequest.headers.host;
+    const pathname = (_a = nodeRequest.url) !== null && _a !== void 0 ? _a : "";
+    if (authority === undefined) {
+        throw new connect_1.ConnectError("unable to determine request authority from Node.js server request", connect_1.Code.Internal);
+    }
+    const body = parsedJsonBody !== undefined
+        ? parsedJsonBody
+        : asyncIterableFromNodeServerRequest(nodeRequest);
+    const abortController = new AbortController();
+    if ("stream" in nodeRequest) {
+        // HTTP/2 has error codes we want to honor
+        nodeRequest.once("close", () => {
+            const err = (0, node_error_js_1.connectErrorFromH2ResetCode)(nodeRequest.stream.rstCode);
+            if (err !== undefined) {
+                abortController.abort(err);
+            }
+            else {
+                abortController.abort();
+            }
+        });
+    }
+    else {
+        // HTTP/1.1 does not have error codes, but Node.js has ECONNRESET
+        const nodeResponsOrRequest = nodeResponse !== null && nodeResponse !== void 0 ? nodeResponse : nodeRequest;
+        const onH1Error = (e) => {
+            nodeRequest.off("error", onH1Error);
+            nodeResponsOrRequest.off("close", onH1Close);
+            abortController.abort((0, node_error_js_1.connectErrorFromNodeReason)(e));
+        };
+        const onH1Close = () => {
+            nodeRequest.off("error", onH1Error);
+            nodeResponsOrRequest.off("close", onH1Close);
+            // When subscribed to the response, this can get called before "error"
+            abortController.abort(nodeRequest.errored
+                ? (0, node_error_js_1.connectErrorFromNodeReason)(nodeRequest.errored)
+                : undefined);
+        };
+        nodeRequest.once("error", onH1Error);
+        // Node emits close on the request as soon as all data is read.
+        // We instead subscribe to the response (if available)
+        //
+        // Ref: https://github.com/nodejs/node/issues/40775
+        nodeResponsOrRequest.once("close", onH1Close);
+    }
+    return {
+        httpVersion: nodeRequest.httpVersion,
+        method: (_b = nodeRequest.method) !== null && _b !== void 0 ? _b : "",
+        url: new URL(pathname, `${protocol}://${authority}`).toString(),
+        header: (0, node_universal_header_js_1.nodeHeaderToWebHeader)(nodeRequest.headers),
+        body,
+        signal: abortController.signal,
+        contextValues: contextValues,
+    };
+}
+/**
+ * Writes a UniversalServerResponse to a Node.js server response.
+ * This function helps to implement adapters to server frameworks running
+ * on Node.js. Please be careful using this function in your own code, as we
+ * may have to make changes to it in the future.
+ */
+async function universalResponseToNodeResponse(universalResponse, nodeResponse) {
+    var _a, _b, _c;
+    const it = (_a = universalResponse.body) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]();
+    let isWriteError = false;
+    try {
+        if (it !== undefined) {
+            let chunk = await it.next();
+            isWriteError = true;
+            // we deliberately send headers after first read, not before,
+            // because we have to give the implementation a chance to
+            // set response headers
+            nodeResponse.writeHead(universalResponse.status, (0, node_universal_header_js_1.webHeaderToNodeHeaders)(universalResponse.header));
+            isWriteError = false;
+            for (; chunk.done !== true; chunk = await it.next()) {
+                isWriteError = true;
+                await write(nodeResponse, chunk.value);
+                if ("flush" in nodeResponse &&
+                    typeof nodeResponse.flush == "function") {
+                    // The npm package "compression" is an express middleware that is widely used,
+                    // for example in next.js. It uses the npm package "compressible" to determine
+                    // whether to apply compression to a response. Unfortunately, "compressible"
+                    // matches every mime type that ends with "+json", causing our server-streaming
+                    // RPCs to be buffered.
+                    // The package modifies the response object, and adds a flush() method, which
+                    // flushes the underlying gzip or deflate stream from the Node.js zlib module.
+                    // The method is added here:
+                    // https://github.com/expressjs/compression/blob/ad5113b98cafe1382a0ece30bb4673707ac59ce7/index.js#L70
+                    nodeResponse.flush();
+                }
+                isWriteError = false;
+            }
+        }
+        if (!nodeResponse.headersSent) {
+            nodeResponse.writeHead(universalResponse.status, (0, node_universal_header_js_1.webHeaderToNodeHeaders)(universalResponse.header));
+        }
+        if (universalResponse.trailer) {
+            nodeResponse.addTrailers((0, node_universal_header_js_1.webHeaderToNodeHeaders)(universalResponse.trailer));
+        }
+        await new Promise((resolve) => {
+            // The npm package "compression" crashes when a callback is passed to end()
+            // https://github.com/expressjs/compression/blob/ad5113b98cafe1382a0ece30bb4673707ac59ce7/index.js#L115
+            nodeResponse.once("end", resolve);
+            nodeResponse.end();
+        });
+    }
+    catch (e) {
+        // Report write errors to the handler.
+        if (isWriteError) {
+            (_b = it === null || it === void 0 ? void 0 : it.throw) === null || _b === void 0 ? void 0 : _b.call(it, e).catch(() => { });
+        }
+        throw (0, node_error_js_1.connectErrorFromNodeReason)(e);
+    }
+    finally {
+        (_c = it === null || it === void 0 ? void 0 : it.return) === null || _c === void 0 ? void 0 : _c.call(it).catch(() => { });
+    }
+}
+function asyncIterableFromNodeServerRequest(request) {
+    return __asyncGenerator(this, arguments, function* asyncIterableFromNodeServerRequest_1() {
+        var _a, e_1, _b, _c;
+        try {
+            for (var _d = true, request_1 = __asyncValues(request), request_1_1; request_1_1 = yield __await(request_1.next()), _a = request_1_1.done, !_a; _d = true) {
+                _c = request_1_1.value;
+                _d = false;
+                const chunk = _c;
+                yield yield __await(chunk);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = request_1.return)) yield __await(_b.call(request_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function write(stream, data) {
+    return new Promise((resolve, reject) => {
+        if (stream.errored) {
+            return error(stream.errored);
+        }
+        stream.once("error", error);
+        stream.once("drain", drain);
+        // flushed == false: the stream wishes for the calling code to wait for
+        // the 'drain' event to be emitted before continuing to write additional
+        // data.
+        const flushed = stream.write(data, "binary", (err) => {
+            if (err && !flushed) {
+                // We are never getting a "drain" nor an "error" event if the stream
+                // has already ended (ERR_STREAM_WRITE_AFTER_END), so we have to
+                // resolve our promise in this callback.
+                error(err);
+                // However, once we do that (and remove our event listeners), we _do_
+                // get an "error" event, which ends up as an uncaught exception.
+                // We silence this error specifically with the following listener.
+                // All of this seems very fragile.
+                stream.once("error", () => {
+                    //
+                });
+            }
+        });
+        if (flushed) {
+            drain();
+        }
+        function error(err) {
+            stream.off("error", error);
+            stream.off("drain", drain);
+            reject(err);
+        }
+        function drain() {
+            stream.off("error", error);
+            stream.off("drain", drain);
+            resolve();
+        }
+    });
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/node-universal-header.d.ts

@@ -0,0 +1,20 @@
+import type * as http from "node:http";
+import type * as http2 from "node:http2";
+/**
+ * Convert a Node.js header object to a fetch API Headers object.
+ *
+ * This function works for Node.js incoming and outgoing headers, and for the
+ * http and the http2 package.
+ *
+ * HTTP/2 pseudo-headers (:method, :path, etc.) are stripped.
+ */
+export declare function nodeHeaderToWebHeader(nodeHeaders: http.OutgoingHttpHeaders | http.IncomingHttpHeaders | http2.IncomingHttpHeaders | http.IncomingMessage["trailers"]): Headers;
+/**
+ * Convert a fetch API Headers object to a Node.js headers object.
+ *
+ * Optionally accepts default Node.js headers as a dict or an array.
+ * If provided, fetch API headers are appended to the defaults.
+ * The original defaults headers are not modified.
+ */
+export declare function webHeaderToNodeHeaders(headersInit: HeadersInit, defaultNodeHeaders?: http.OutgoingHttpHeaders | readonly string[]): http.OutgoingHttpHeaders;
+export declare function webHeaderToNodeHeaders(headersInit: HeadersInit | undefined): http.OutgoingHttpHeaders | undefined;