openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/esm/router.js

@@ -0,0 +1,65 @@
+// 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.
+import { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+import { createMethodImplSpec, createServiceImplSpec, } from "./implementation.js";
+import { createHandlerFactory as handlerFactoryGrpcWeb } from "./protocol-grpc-web/handler-factory.js";
+import { createHandlerFactory as handlerFactoryGrpc } from "./protocol-grpc/handler-factory.js";
+import { createHandlerFactory as handlerFactoryConnect } from "./protocol-connect/handler-factory.js";
+import { createUniversalMethodHandler, createUniversalServiceHandlers, validateUniversalHandlerOptions, } from "./protocol/universal-handler.js";
+/**
+ * Create a new ConnectRouter.
+ */
+export function createConnectRouter(routerOptions) {
+    const base = whichProtocols(routerOptions);
+    const handlers = [];
+    const router = {
+        handlers,
+        service: (service, implementation, options) => {
+            const { protocols } = whichProtocols(options, base);
+            handlers.push(...createUniversalServiceHandlers(createServiceImplSpec(service, implementation), protocols));
+            return router;
+        },
+        rpc: (method, impl, opt) => {
+            const { protocols } = whichProtocols(opt, base);
+            handlers.push(createUniversalMethodHandler(createMethodImplSpec(method, impl), protocols));
+            return router;
+        },
+    };
+    return router;
+}
+function whichProtocols(options, base) {
+    if (base && !options) {
+        return base;
+    }
+    const opt = base
+        ? Object.assign(Object.assign({}, validateUniversalHandlerOptions(base.options)), options) : Object.assign(Object.assign({}, options), validateUniversalHandlerOptions(options !== null && options !== void 0 ? options : {}));
+    const protocols = [];
+    if ((options === null || options === void 0 ? void 0 : options.grpc) !== false) {
+        protocols.push(handlerFactoryGrpc(opt));
+    }
+    if ((options === null || options === void 0 ? void 0 : options.grpcWeb) !== false) {
+        protocols.push(handlerFactoryGrpcWeb(opt));
+    }
+    if ((options === null || options === void 0 ? void 0 : options.connect) !== false) {
+        protocols.push(handlerFactoryConnect(opt));
+    }
+    if (protocols.length === 0) {
+        throw new ConnectError("cannot create handler, all protocols are disabled", Code.InvalidArgument);
+    }
+    return {
+        options: opt,
+        protocols,
+    };
+}

package/node_modules/@connectrpc/connect/dist/esm/transport.d.ts

@@ -0,0 +1,20 @@
+import type { DescMessage, MessageInitShape, DescMethodStreaming, DescMethodUnary } from "@bufbuild/protobuf";
+import type { StreamResponse, UnaryResponse } from "./interceptor.js";
+import type { ContextValues } from "./context-values.js";
+/**
+ * Transport represents the underlying transport for a client.
+ * A transport implements a protocol, such as Connect or gRPC-web, and allows
+ * for the concrete clients to be independent of the protocol.
+ */
+export interface Transport {
+    /**
+     * Call a unary RPC - a method that takes a single input message, and
+     * responds with a single output message.
+     */
+    unary<I extends DescMessage, O extends DescMessage>(method: DescMethodUnary<I, O>, signal: AbortSignal | undefined, timeoutMs: number | undefined, header: HeadersInit | undefined, input: MessageInitShape<I>, contextValues?: ContextValues): Promise<UnaryResponse<I, O>>;
+    /**
+     * Call a streaming RPC - a method that takes zero or more input messages,
+     * and responds with zero or more output messages.
+     */
+    stream<I extends DescMessage, O extends DescMessage>(method: DescMethodStreaming<I, O>, signal: AbortSignal | undefined, timeoutMs: number | undefined, header: HeadersInit | undefined, input: AsyncIterable<MessageInitShape<I>>, contextValues?: ContextValues): Promise<StreamResponse<I, O>>;
+}

package/node_modules/@connectrpc/connect/dist/esm/transport.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

package/node_modules/@connectrpc/connect/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@connectrpc/connect",
+  "version": "2.2.0",
+  "description": "Type-safe APIs with Protobuf and TypeScript.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/connectrpc/connect-es.git",
+    "directory": "packages/connect"
+  },
+  "scripts": {
+    "generate": "buf generate",
+    "postgenerate": "license-header src/protocol-grpc/gen",
+    "prebuild": "rm -rf ./dist/*",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm": "tsc --project tsconfig.json --outDir ./dist/esm",
+    "postbuild": "node scripts/update-user-agent.mjs",
+    "test": "tsc --noEmit && node --import tsx --test $(find src -name '*.spec.ts')",
+    "format": "biome format --write",
+    "license-header": "license-header",
+    "lint": "biome lint --error-on-warnings",
+    "attw": "attw --pack"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./protocol": {
+      "import": "./dist/esm/protocol/index.js",
+      "require": "./dist/cjs/protocol/index.js"
+    },
+    "./protocol-connect": {
+      "import": "./dist/esm/protocol-connect/index.js",
+      "require": "./dist/cjs/protocol-connect/index.js"
+    },
+    "./protocol-grpc": {
+      "import": "./dist/esm/protocol-grpc/index.js",
+      "require": "./dist/cjs/protocol-grpc/index.js"
+    },
+    "./protocol-grpc-web": {
+      "import": "./dist/esm/protocol-grpc-web/index.js",
+      "require": "./dist/cjs/protocol-grpc-web/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "protocol": ["./dist/cjs/protocol/index.d.ts"],
+      "protocol-connect": ["./dist/cjs/protocol-connect/index.d.ts"],
+      "protocol-grpc": ["./dist/cjs/protocol-grpc/index.d.ts"],
+      "protocol-grpc-web": ["./dist/cjs/protocol-grpc-web/index.d.ts"]
+    }
+  },
+  "peerDependencies": {
+    "@bufbuild/protobuf": "^2.7.0"
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.72.0",
+    "@bufbuild/protoc-gen-es": "^2.10.0",
+    "@types/node": "^24.10.1",
+    "tsx": "^4.20.6"
+  }
+}

package/node_modules/@connectrpc/connect-node/README.md

@@ -0,0 +1,144 @@
+# @connectrpc/connect-node
+
+Connect is a family of libraries for building and consuming APIs on different languages and platforms, and
+[@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings type-safe APIs with Protobuf to
+TypeScript.
+
+`@connectrpc/connect-node` provides the following adapters for Node.js:
+
+### createConnectTransport()
+
+Lets your clients running on Node.js talk to a server with the Connect protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createConnectTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createConnectTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the gRPC protocol with Node.js `http2` module
++ const transport = createGrpcTransport({
++   baseUrl: "https://demo.connectrpc.com",
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcWebTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC-web protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcWebTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createGrpcWebTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### connectNodeAdapter()
+
+Run your Connect RPCs on the Node.js `http`, `https`, or `http2` modules.
+
+```ts
+// connect.ts
+import { ConnectRouter } from "@connectrpc/connect";
+
+export default function (router: ConnectRouter) {
+  // implement rpc Say(SayRequest) returns (SayResponse)
+  router.rpc(ElizaService, ElizaService.methods.say, async (req) => ({
+    sentence: `you said: ${req.sentence}`,
+  }));
+}
+```
+
+```diff
+// server.ts
+import * as http2 from "http2";
++ import routes from "connect";
++ import { connectNodeAdapter } from "@connectrpc/connect-node";
++ import { createValidateInterceptor } from "@connectrpc/validate";
+
+http2.createServer(
++ connectNodeAdapter({
++   // Validation via Protovalidate is almost always recommended
++   interceptors: [createValidateInterceptor()],
++   routes
++ })
+).listen(8080);
+```
+
+With that server running, you can make requests with any gRPC, gRPC-Web, or Connect client.
+
+`buf curl` with the gRPC protocol:
+
+```bash
+buf curl --schema buf.build/connectrpc/eliza \
+  --protocol grpc --http2-prior-knowledge \
+  -d '{"sentence": "I feel happy."}' \
+  http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+`curl` with the Connect protocol:
+
+```bash
+curl \
+    --header "Content-Type: application/json" \
+    --data '{"sentence": "I feel happy."}' \
+     --http2-prior-knowledge \
+    http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+Node.js with the gRPC protocol:
+
+```ts
+import { createClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
+const transport = createGrpcTransport({
+  baseUrl: "http://localhost:8080",
+});
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence); // you said: I feel happy.
+```
+
+A client for the web browser actually looks identical to this example - it would
+simply use `createConnectTransport` from [@connectrpc/connect-web](https://www.npmjs.com/package/@connectrpc/connect-web)
+instead.
+
+## Getting started
+
+To get started with Connect, head over to the [docs](https://connectrpc.com/docs/node/getting-started)
+for a tutorial, or take a look at [our example](https://github.com/connectrpc/connect-es/tree/main/packages/example).

package/node_modules/@connectrpc/connect-node/buf.gen.yaml

@@ -0,0 +1,10 @@
+# Learn more: https://buf.build/docs/configuration/v2/buf-gen-yaml
+version: v2
+# Deletes the directories specified in the `out` field for all plugins before running code generation.
+clean: true
+inputs:
+  - module: buf.build/connectrpc/eliza
+plugins:
+  - local: protoc-gen-es
+    out: src/testdata/gen
+    opt: target=ts,import_extension=.js

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

@@ -0,0 +1,15 @@
+import type { Compression } from "@connectrpc/connect/protocol";
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionGzip: Compression;
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionBrotli: Compression;

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

@@ -0,0 +1,96 @@
+"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.compressionBrotli = exports.compressionGzip = void 0;
+const zlib = require("node:zlib");
+const node_util_1 = require("node:util");
+const connect_1 = require("@connectrpc/connect");
+const node_error_js_1 = require("./node-error.js");
+const gzip = (0, node_util_1.promisify)(zlib.gzip);
+const gunzip = (0, node_util_1.promisify)(zlib.gunzip);
+const brotliCompress = (0, node_util_1.promisify)(zlib.brotliCompress);
+const brotliDecompress = (0, node_util_1.promisify)(zlib.brotliDecompress);
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionGzip = {
+    name: "gzip",
+    compress(bytes) {
+        return asUint8ArrayArrayBuffer(gzip(bytes, {}));
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return asUint8ArrayArrayBuffer(wrapZLibErrors(gunzip(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes));
+    },
+};
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionBrotli = {
+    name: "br",
+    compress(bytes) {
+        return asUint8ArrayArrayBuffer(brotliCompress(bytes, {}));
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return asUint8ArrayArrayBuffer(wrapZLibErrors(brotliDecompress(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes));
+    },
+};
+function asUint8ArrayArrayBuffer(bytes) {
+    return bytes.then((b) => {
+        if (b.buffer instanceof ArrayBuffer) {
+            return b;
+        }
+        return new Uint8Array(b);
+    });
+}
+function wrapZLibErrors(promise, readMaxBytes) {
+    return promise.catch((e) => {
+        var _a;
+        const props = (0, node_error_js_1.getNodeErrorProps)(e);
+        let code = connect_1.Code.Internal;
+        let message = "decompression failed";
+        switch (props.code) {
+            case "ERR_BUFFER_TOO_LARGE":
+                code = connect_1.Code.ResourceExhausted;
+                message = `message is larger than configured readMaxBytes ${readMaxBytes} after decompression`;
+                break;
+            case "Z_DATA_ERROR":
+            case "ERR_PADDING_2":
+                code = connect_1.Code.InvalidArgument;
+                break;
+            default:
+                if ((_a = props.code) === null || _a === void 0 ? void 0 : _a.startsWith("ERR__ERROR_FORMAT_")) {
+                    code = connect_1.Code.InvalidArgument;
+                }
+                break;
+        }
+        return Promise.reject(new connect_1.ConnectError(message, code, undefined, undefined, e));
+    });
+}

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

@@ -0,0 +1,42 @@
+import type { ConnectRouter, ConnectRouterOptions, ContextValues } from "@connectrpc/connect";
+import type { NodeHandlerFn, NodeServerRequest } from "./node-universal-handler.js";
+export interface ConnectNodeAdapterOptions extends ConnectRouterOptions {
+    /**
+     * Route definitions. We recommend the following pattern:
+     *
+     * Create a file `connect.ts` with a default export such as this:
+     *
+     * ```ts
+     * import {ConnectRouter} from "@connectrpc/connect";
+     *
+     * export default (router: ConnectRouter) => {
+     *   router.service(ElizaService, {});
+     * }
+     * ```
+     *
+     * Then pass this function here.
+     */
+    routes: (router: ConnectRouter) => void;
+    /**
+     * If none of the handler request paths match, a 404 is served. This option
+     * can provide a custom fallback for this case.
+     */
+    fallback?: NodeHandlerFn;
+    /**
+     * Serve all handlers under this prefix. For example, the prefix "/something"
+     * will serve the RPC foo.FooService/Bar under "/something/foo.FooService/Bar".
+     * Note that many gRPC client implementations do not allow for prefixes.
+     */
+    requestPathPrefix?: string;
+    /**
+     * Context values to extract from the request. These values are passed to
+     * the handlers.
+     */
+    contextValues?: (req: NodeServerRequest) => ContextValues;
+}
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+export declare function connectNodeAdapter(options: ConnectNodeAdapterOptions): NodeHandlerFn;

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

@@ -0,0 +1,60 @@
+"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.connectNodeAdapter = connectNodeAdapter;
+const connect_1 = require("@connectrpc/connect");
+const protocol_1 = require("@connectrpc/connect/protocol");
+const node_universal_handler_js_1 = require("./node-universal-handler.js");
+const compression_js_1 = require("./compression.js");
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+function connectNodeAdapter(options) {
+    var _a;
+    if (options.acceptCompression === undefined) {
+        options.acceptCompression = [compression_js_1.compressionGzip, compression_js_1.compressionBrotli];
+    }
+    const router = (0, connect_1.createConnectRouter)(options);
+    options.routes(router);
+    const prefix = (_a = options.requestPathPrefix) !== null && _a !== void 0 ? _a : "";
+    const paths = new Map();
+    for (const uHandler of router.handlers) {
+        paths.set(prefix + uHandler.requestPath, uHandler);
+    }
+    return function nodeRequestHandler(req, res) {
+        var _a, _b, _c, _d;
+        // Strip the query parameter when matching paths.
+        const uHandler = paths.get((_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split("?", 2)[0]) !== null && _b !== void 0 ? _b : "");
+        if (!uHandler) {
+            ((_c = options.fallback) !== null && _c !== void 0 ? _c : fallback)(req, res);
+            return;
+        }
+        const uReq = (0, node_universal_handler_js_1.universalRequestFromNodeRequest)(req, res, undefined, (_d = options.contextValues) === null || _d === void 0 ? void 0 : _d.call(options, req));
+        uHandler(uReq)
+            .then((uRes) => (0, node_universal_handler_js_1.universalResponseToNodeResponse)(uRes, res))
+            .catch((reason) => {
+            if (connect_1.ConnectError.from(reason).code == connect_1.Code.Aborted) {
+                return;
+            }
+            console.error(`handler for rpc ${uHandler.method.name} of ${uHandler.service.typeName} failed`, reason);
+        });
+    };
+}
+const fallback = (request, response) => {
+    response.writeHead(protocol_1.uResponseNotFound.status);
+    response.end();
+};

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

@@ -0,0 +1,100 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import { type NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the Connect transport.
+ *
+ * See createConnectTransport().
+ */
+export type ConnectTransportOptions = NodeTransportOptions & {
+    /**
+     * Base URI for all HTTP requests.
+     *
+     * Requests will be made to <baseUrl>/<package>.<service>/method
+     *
+     * Example: `baseUrl: "https://example.com/my-api"`
+     *
+     * This will make a `POST /my-api/my_package.MyService/Foo` to
+     * `example.com` via HTTPS.
+     */
+    baseUrl: string;
+    /**
+     * By default, connect-node clients use the binary format.
+     */
+    useBinaryFormat?: boolean;
+    /**
+     * Interceptors that should be applied to all calls running through
+     * this transport. See the Interceptor type for details.
+     */
+    interceptors?: Interceptor[];
+    /**
+     * Options for the JSON format.
+     * By default, unknown fields are ignored.
+     */
+    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
+    /**
+     * Options for the binary wire format.
+     */
+    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
+    /**
+     * Compression algorithms available to a client. Clients ask servers to
+     * compress responses using any of the registered algorithms. The first
+     * registered algorithm is the most preferred.
+     *
+     * It is safe to use this option liberally: servers will ignore any
+     * compression algorithms they don't support. To compress requests, pair this
+     * option with `sendCompression`.
+     *
+     * If this option is not provided, the compression algorithms "gzip" and "br"
+     * (Brotli) are accepted. To opt out of response compression, pass an
+     * empty array.
+     */
+    acceptCompression?: Compression[];
+    /**
+     * Configures the client to use the specified algorithm to compress request
+     * messages.
+     *
+     * Because some servers don't support compression, clients default to sending
+     * uncompressed requests.
+     */
+    sendCompression?: Compression;
+    /**
+     * Sets a minimum size threshold for compression: Messages that are smaller
+     * than the configured minimum are sent uncompressed.
+     *
+     * The default value is 1 kibibyte, because the CPU cost of compressing very
+     * small messages usually isn't worth the small reduction in network I/O.
+     */
+    compressMinBytes?: number;
+    /**
+     * Limits the performance impact of pathologically large messages sent by the
+     * server. Limits apply to each individual message, not to the stream as a
+     * whole.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    readMaxBytes?: number;
+    /**
+     * Prevents sending messages too large for the server to handle.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    writeMaxBytes?: number;
+    /**
+     * Controls whether or not Connect GET requests should be used when
+     * available, on side-effect free methods. Defaults to false.
+     */
+    useHttpGet?: boolean;
+    /**
+     * The timeout in milliseconds to apply to all requests.
+     *
+     * This can be overridden on a per-request basis by passing a timeoutMs.
+     */
+    defaultTimeoutMs?: number;
+};
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `https`,
+ * or `http2` module.
+ */
+export declare function createConnectTransport(options: ConnectTransportOptions): Transport;

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

@@ -0,0 +1,25 @@
+"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.createConnectTransport = createConnectTransport;
+const protocol_connect_1 = require("@connectrpc/connect/protocol-connect");
+const node_transport_options_js_1 = require("./node-transport-options.js");
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `https`,
+ * or `http2` module.
+ */
+function createConnectTransport(options) {
+    return (0, protocol_connect_1.createTransport)((0, node_transport_options_js_1.validateNodeTransportOptions)(options));
+}