pi-cursor-sdk 0.1.47 → 0.1.49

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

@@ -0,0 +1,324 @@
+// Copyright 2021-2024 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.
+import * as http2 from "http2";
+import * as http from "http";
+import * as https from "https";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { nodeHeaderToWebHeader, webHeaderToNodeHeaders, } from "./node-universal-header.js";
+import { connectErrorFromH2ResetCode, connectErrorFromNodeReason, getNodeErrorProps, H2Code, unwrapNodeErrorChain, } from "./node-error.js";
+import { getAbortSignalReason } from "@connectrpc/connect/protocol";
+import { Http2SessionManager } from "./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.
+ */
+export 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 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.catch((e) => {
+                reject(e);
+            });
+            h1Request(sentinel, req.url, Object.assign(Object.assign({}, httpOptions), { headers: 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.reject);
+                    sentinel.catch((reason) => response.destroy(connectErrorFromNodeReason(reason)));
+                    const trailer = new Headers();
+                    resolve({
+                        status: (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0,
+                        header: 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.catch((e) => {
+                reject(e);
+            });
+            h2Request(sentinel, sessionManager, req.url, req.method, 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: 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.catch((reason) => request.destroy(connectErrorFromNodeReason(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.2 clients.
+    request.flushHeaders();
+    request.on("error", sentinel.reject);
+    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) {
+                        nodeHeaderToWebHeader(response.trailers).forEach((value, key) => {
+                            trailer.set(key, value);
+                        });
+                        sentinel.resolve();
+                        await sentinel;
+                    }
+                    return r;
+                },
+                throw(e) {
+                    sentinel.reject(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.reject(new ConnectError(message, Code.Internal));
+        return;
+    }
+    sm.request(method, requestUrl.pathname + requestUrl.search, headers, {}).then((stream) => {
+        sentinel.catch((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 instanceof ConnectError && reason.code == Code.Canceled
+                ? H2Code.CANCEL
+                : H2Code.INTERNAL_ERROR;
+            return new Promise((resolve) => stream.close(rstCode, resolve));
+        });
+        stream.on("error", function h2StreamError(e) {
+            if (stream.writableEnded &&
+                unwrapNodeErrorChain(e)
+                    .map(getNodeErrorProps)
+                    .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
+                return;
+            }
+            sentinel.reject(e);
+        });
+        stream.on("close", function h2StreamClose() {
+            const err = connectErrorFromH2ResetCode(stream.rstCode);
+            if (err) {
+                sentinel.reject(err);
+            }
+        });
+        onStream(stream);
+    }, (reason) => {
+        sentinel.reject(reason);
+    });
+}
+function h2ResponseTrailer(response) {
+    const trailer = new Headers();
+    response.on("trailers", (args) => {
+        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.resolve();
+                        await sentinel;
+                    }
+                    sm === null || sm === void 0 ? void 0 : sm.notifyResponseByteRead(response);
+                    return r;
+                },
+                throw(e) {
+                    sentinel.reject(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.isRejected()) {
+                return;
+            }
+            it.next().then((r) => {
+                if (r.done === true) {
+                    nodeRequest.end(resolve);
+                    return;
+                }
+                nodeRequest.write(r.value, "binary", function (e) {
+                    if (e === null || e === undefined) {
+                        writeNext();
+                        return;
+                    }
+                    if (it.throw !== undefined) {
+                        it.throw(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 &&
+                        unwrapNodeErrorChain(e)
+                            .map(getNodeErrorProps)
+                            .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
+                        return;
+                    }
+                    sentinel.reject(e);
+                });
+            }, (e) => {
+                sentinel.reject(e);
+            });
+        }
+    });
+}
+function createSentinel(signal) {
+    let res;
+    let rej;
+    let resolved = false;
+    let rejected = false;
+    const p = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+    });
+    const c = {
+        resolve() {
+            if (!resolved && !rejected) {
+                resolved = true;
+                res === null || res === void 0 ? void 0 : res();
+            }
+        },
+        isResolved() {
+            return resolved;
+        },
+        reject(reason) {
+            if (!resolved && !rejected) {
+                rejected = true;
+                rej === null || rej === void 0 ? void 0 : rej(connectErrorFromNodeReason(reason));
+            }
+        },
+        isRejected() {
+            return rejected;
+        },
+        async race(promise) {
+            const r = await Promise.race([promise, p]);
+            if (r === undefined && resolved) {
+                throw new ConnectError("sentinel completed early", Code.Internal);
+            }
+            return r;
+        },
+    };
+    const s = Object.assign(p, c);
+    function onSignalAbort() {
+        c.reject(getAbortSignalReason(this));
+    }
+    if (signal) {
+        if (signal.aborted) {
+            c.reject(getAbortSignalReason(signal));
+        }
+        else {
+            signal.addEventListener("abort", onSignalAbort);
+        }
+        p.finally(() => signal.removeEventListener("abort", onSignalAbort)).catch(() => {
+            // We intentionally swallow sentinel rejection - errors must
+            // propagate through the request or response iterables.
+        });
+    }
+    return s;
+}

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

@@ -0,0 +1,41 @@
+import type * as http from "http";
+import type * as http2 from "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 type of write() 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;
+};
+/**
+ * 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/esm/node-universal-handler.js

@@ -0,0 +1,230 @@
+// Copyright 2021-2024 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 = {}, 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]); }
+};
+import { Code, ConnectError } from "@connectrpc/connect";
+import { nodeHeaderToWebHeader, webHeaderToNodeHeaders, } from "./node-universal-header.js";
+import { connectErrorFromH2ResetCode, connectErrorFromNodeReason, } from "./node-error.js";
+export 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 ConnectError("unable to determine request authority from Node.js server request", 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 = 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(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
+                ? 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: 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.
+ */
+export 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, 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, webHeaderToNodeHeaders(universalResponse.header));
+        }
+        if (universalResponse.trailer) {
+            nodeResponse.addTrailers(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 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;
+        const it = request.iterator({
+            // Node.js v16 closes request and response when this option isn't disabled.
+            // When one of our handlers receives invalid data (such as an unexpected
+            // compression flag in a streaming request), we're unable to write the error
+            // response.
+            // Later major versions have a more sensible behavior - we can revert this
+            // workaround once we stop supporting v16.
+            destroyOnReturn: false,
+        });
+        try {
+            for (var _d = true, it_1 = __asyncValues(it), it_1_1; it_1_1 = yield __await(it_1.next()), _a = it_1_1.done, !_a; _d = true) {
+                _c = it_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 = it_1.return)) yield __await(_b.call(it_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", function (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/esm/node-universal-header.d.ts

@@ -0,0 +1,19 @@
+import type * as http from "http";
+import type * as http2 from "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. 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): http.OutgoingHttpHeaders;
+export declare function webHeaderToNodeHeaders(headersInit: HeadersInit | undefined): http.OutgoingHttpHeaders | undefined;