pi-cursor-sdk 0.1.47 → 0.1.49

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

@@ -0,0 +1,97 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeHeaderToWebHeader = nodeHeaderToWebHeader;
+exports.webHeaderToNodeHeaders = webHeaderToNodeHeaders;
+/**
+ * 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.
+ */
+function nodeHeaderToWebHeader(nodeHeaders) {
+    const header = new Headers();
+    for (const [k, v] of Object.entries(nodeHeaders)) {
+        if (k.startsWith(":")) {
+            continue;
+        }
+        if (v === undefined) {
+            continue;
+        }
+        if (typeof v == "string") {
+            header.append(k, v);
+        }
+        else if (typeof v == "number") {
+            header.append(k, String(v));
+        }
+        else {
+            for (const e of v) {
+                header.append(k, e);
+            }
+        }
+    }
+    return header;
+}
+function webHeaderToNodeHeaders(headersInit, defaultNodeHeaders) {
+    if (headersInit === undefined && defaultNodeHeaders === undefined) {
+        return undefined;
+    }
+    const o = Object.create(null);
+    if (defaultNodeHeaders !== undefined) {
+        for (const [key, value] of Object.entries(defaultNodeHeaders)) {
+            if (Array.isArray(value)) {
+                o[key] = value.concat();
+            }
+            else if (value !== undefined) {
+                o[key] = value;
+            }
+        }
+    }
+    if (headersInit !== undefined) {
+        if (Array.isArray(headersInit)) {
+            for (const [key, value] of headersInit) {
+                appendWebHeader(o, key, value);
+            }
+        }
+        else if ("forEach" in headersInit) {
+            if (typeof headersInit.forEach == "function") {
+                headersInit.forEach((value, key) => {
+                    appendWebHeader(o, key, value);
+                });
+            }
+        }
+        else {
+            for (const [key, value] of Object.entries(headersInit)) {
+                appendWebHeader(o, key, value);
+            }
+        }
+    }
+    return o;
+}
+function appendWebHeader(o, key, value) {
+    key = key.toLowerCase();
+    const existing = o[key];
+    if (Array.isArray(existing)) {
+        existing.push(value);
+    }
+    else if (existing === undefined) {
+        o[key] = value;
+    }
+    else {
+        o[key] = [existing.toString(), value];
+    }
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/node_modules/@connectrpc/connect-node/dist/esm/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/esm/compression.js

@@ -0,0 +1,86 @@
+// 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 zlib from "zlib";
+import { promisify } from "util";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { getNodeErrorProps } from "./node-error.js";
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+const brotliCompress = promisify(zlib.brotliCompress);
+const brotliDecompress = 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.
+ */
+export const compressionGzip = {
+    name: "gzip",
+    compress(bytes) {
+        return gzip(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return 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.
+ */
+export const compressionBrotli = {
+    name: "br",
+    compress(bytes) {
+        return brotliCompress(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return wrapZLibErrors(brotliDecompress(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes);
+    },
+};
+function wrapZLibErrors(promise, readMaxBytes) {
+    return promise.catch((e) => {
+        const props = getNodeErrorProps(e);
+        let code = Code.Internal;
+        let message = "decompression failed";
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (props.code) {
+            case "ERR_BUFFER_TOO_LARGE":
+                code = Code.ResourceExhausted;
+                message = `message is larger than configured readMaxBytes ${readMaxBytes} after decompression`;
+                break;
+            case "Z_DATA_ERROR":
+            case "ERR_PADDING_2":
+                code = Code.InvalidArgument;
+                break;
+            default:
+                if (props.code !== undefined &&
+                    props.code.startsWith("ERR__ERROR_FORMAT_")) {
+                    code = Code.InvalidArgument;
+                }
+                break;
+        }
+        return Promise.reject(new ConnectError(message, code, undefined, undefined, e));
+    });
+}

package/node_modules/@connectrpc/connect-node/dist/esm/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/esm/connect-node-adapter.js

@@ -0,0 +1,58 @@
+// 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 { Code, ConnectError, createConnectRouter } from "@connectrpc/connect";
+import { uResponseNotFound } from "@connectrpc/connect/protocol";
+import { universalRequestFromNodeRequest, universalResponseToNodeResponse, } from "./node-universal-handler.js";
+import { compressionBrotli, compressionGzip } from "./compression.js";
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+export function connectNodeAdapter(options) {
+    var _a;
+    if (options.acceptCompression === undefined) {
+        options.acceptCompression = [compressionGzip, compressionBrotli];
+    }
+    const router = 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 = universalRequestFromNodeRequest(req, res, undefined, (_d = options.contextValues) === null || _d === void 0 ? void 0 : _d.call(options, req));
+        uHandler(uReq)
+            .then((uRes) => universalResponseToNodeResponse(uRes, res))
+            .catch((reason) => {
+            if (ConnectError.from(reason).code == Code.Aborted) {
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.error(`handler for rpc ${uHandler.method.name} of ${uHandler.service.typeName} failed`, reason);
+        });
+    };
+}
+const fallback = (request, response) => {
+    response.writeHead(uResponseNotFound.status);
+    response.end();
+};

package/node_modules/@connectrpc/connect-node/dist/esm/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`, `http2`,
+ * or `http2` module.
+ */
+export declare function createConnectTransport(options: ConnectTransportOptions): Transport;

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

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

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

@@ -0,0 +1,96 @@
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the gRPC-web transport.
+ *
+ * See createGrpcTransport().
+ */
+export type GrpcTransportOptions = 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, clients use the binary format for gRPC-web, because
+     * not all gRPC-web implementations support JSON.
+     */
+    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;
+    /**
+     * 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 gRPC protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+export declare function createGrpcTransport(options: GrpcTransportOptions): Transport;

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

@@ -0,0 +1,22 @@
+// 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 { createTransport } from "@connectrpc/connect/protocol-grpc";
+import { validateNodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Create a Transport for the gRPC protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+export function createGrpcTransport(options) {
+    return createTransport(validateNodeTransportOptions(options));
+}

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-web-transport.d.ts

@@ -0,0 +1,96 @@
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the gRPC-web transport.
+ *
+ * See createGrpcWebTransport().
+ */
+export type GrpcWebTransportOptions = 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, clients use the binary format for gRPC-web, because
+     * not all gRPC-web implementations support JSON.
+     */
+    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;
+    /**
+     * 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 gRPC-web protocol using the Node.js `http`,
+ * `http2`, or `http2` module.
+ */
+export declare function createGrpcWebTransport(options: GrpcWebTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-web-transport.js

@@ -0,0 +1,22 @@
+// 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 { createTransport } from "@connectrpc/connect/protocol-grpc-web";
+import { validateNodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Create a Transport for the gRPC-web protocol using the Node.js `http`,
+ * `http2`, or `http2` module.
+ */
+export function createGrpcWebTransport(options) {
+    return createTransport(validateNodeTransportOptions(options));
+}