openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal.js

@@ -0,0 +1,78 @@
+"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.uResponseVersionNotSupported = exports.uResponseMethodNotAllowed = exports.uResponseUnsupportedMediaType = exports.uResponseNotFound = exports.uResponseOk = void 0;
+exports.assertByteStreamRequest = assertByteStreamRequest;
+/**
+ * Assert that the given UniversalServerRequest has a byte stream body, not
+ * a JSON value.
+ *
+ * We accept a JSON object or a byte stream in server requests.
+ * In practice, only Connect unary handlers will receive a parse
+ * JSON object. Other call-sites can use this assertion to narrow
+ * the union type. A failure in such a call-sites indicates that
+ * the contract between a server framework and the connect-node \
+ * handler is broken.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function assertByteStreamRequest(req) {
+    if (typeof req.body == "object" &&
+        req.body !== null &&
+        Symbol.asyncIterator in req.body) {
+        return;
+    }
+    throw new Error("byte stream required, but received JSON");
+}
+/**
+ * HTTP 200 OK
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.uResponseOk = {
+    status: 200,
+};
+/**
+ * HTTP 404 Not Found
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.uResponseNotFound = {
+    status: 404,
+};
+/**
+ * HTTP 415 Unsupported Media Type
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.uResponseUnsupportedMediaType = {
+    status: 415,
+};
+/**
+ * HTTP 405 Method Not Allowed
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.uResponseMethodNotAllowed = {
+    status: 405,
+};
+/**
+ * HTTP 505 Version Not Supported
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.uResponseVersionNotSupported = {
+    status: 505,
+};

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/code-string.d.ts

@@ -0,0 +1,16 @@
+import { Code } from "../code.js";
+/**
+ * codeToString returns the string representation of a Code.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeToString(value: Code): string;
+/**
+ * codeFromString parses the string representation of a Code in snake_case.
+ * For example, the string "permission_denied" parses into Code.PermissionDenied.
+ *
+ * If the given string cannot be parsed, the function returns undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeFromString(value: string): Code | undefined;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/code-string.js

@@ -0,0 +1,52 @@
+"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.codeToString = codeToString;
+exports.codeFromString = codeFromString;
+const code_js_1 = require("../code.js");
+/**
+ * codeToString returns the string representation of a Code.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function codeToString(value) {
+    const name = code_js_1.Code[value];
+    if (typeof name != "string") {
+        return value.toString();
+    }
+    return (name[0].toLowerCase() +
+        name.substring(1).replace(/[A-Z]/g, (c) => "_" + c.toLowerCase()));
+}
+let stringToCode;
+/**
+ * codeFromString parses the string representation of a Code in snake_case.
+ * For example, the string "permission_denied" parses into Code.PermissionDenied.
+ *
+ * If the given string cannot be parsed, the function returns undefined.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function codeFromString(value) {
+    if (!stringToCode) {
+        stringToCode = {};
+        for (const value of Object.values(code_js_1.Code)) {
+            if (typeof value == "string") {
+                continue;
+            }
+            stringToCode[codeToString(value)] = value;
+        }
+    }
+    return stringToCode[value];
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/content-type.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Regular Expression that matches any valid Connect Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeRegExp: RegExp;
+/**
+ * Regular Expression that matches a Connect unary Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeUnaryRegExp: RegExp;
+/**
+ * Regular Expression that matches a Connect streaming Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeStreamRegExp: RegExp;
+export declare const contentTypeUnaryProto = "application/proto";
+export declare const contentTypeUnaryJson = "application/json";
+export declare const contentTypeStreamProto = "application/connect+proto";
+export declare const contentTypeStreamJson = "application/connect+json";
+/**
+ * Parse a Connect Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseContentType(contentType: string | null): {
+    stream: boolean;
+    binary: boolean;
+} | undefined;
+/**
+ * Parse a Connect Get encoding query parameter.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseEncodingQuery(encoding: string | null): {
+    stream: boolean;
+    binary: boolean;
+} | undefined;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/content-type.js

@@ -0,0 +1,71 @@
+"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.contentTypeStreamJson = exports.contentTypeStreamProto = exports.contentTypeUnaryJson = exports.contentTypeUnaryProto = exports.contentTypeStreamRegExp = exports.contentTypeUnaryRegExp = exports.contentTypeRegExp = void 0;
+exports.parseContentType = parseContentType;
+exports.parseEncodingQuery = parseEncodingQuery;
+/**
+ * Regular Expression that matches any valid Connect Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.contentTypeRegExp = /^application\/(connect\+)?(?:(json)(?:; ?charset=utf-?8)?|(proto))$/i;
+/**
+ * Regular Expression that matches a Connect unary Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.contentTypeUnaryRegExp = /^application\/(?:json(?:; ?charset=utf-?8)?|proto)$/i;
+/**
+ * Regular Expression that matches a Connect streaming Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.contentTypeStreamRegExp = /^application\/connect\+?(?:json(?:; ?charset=utf-?8)?|proto)$/i;
+exports.contentTypeUnaryProto = "application/proto";
+exports.contentTypeUnaryJson = "application/json";
+exports.contentTypeStreamProto = "application/connect+proto";
+exports.contentTypeStreamJson = "application/connect+json";
+const encodingProto = "proto";
+const encodingJson = "json";
+/**
+ * Parse a Connect Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function parseContentType(contentType) {
+    const match = contentType === null || contentType === void 0 ? void 0 : contentType.match(exports.contentTypeRegExp);
+    if (!match) {
+        return undefined;
+    }
+    const stream = !!match[1];
+    const binary = !!match[3];
+    return { stream, binary };
+}
+/**
+ * Parse a Connect Get encoding query parameter.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function parseEncodingQuery(encoding) {
+    switch (encoding) {
+        case encodingProto:
+            return { stream: false, binary: true };
+        case encodingJson:
+            return { stream: false, binary: false };
+        default:
+            return undefined;
+    }
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/end-stream.d.ts

@@ -0,0 +1,44 @@
+import type { JsonObject, JsonWriteOptions } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+import type { Serialization } from "../protocol/serialization.js";
+/**
+ * endStreamFlag indicates that the data in a EnvelopedMessage
+ * is a EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const endStreamFlag = 2;
+/**
+ * Represents the EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface EndStreamResponse {
+    metadata: Headers;
+    error?: ConnectError;
+}
+/**
+ * Parse an EndStreamResponse of the Connect protocol.
+ * Throws a ConnectError on malformed input.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function endStreamFromJson(data: Uint8Array | string): EndStreamResponse;
+/**
+ * Serialize the given EndStreamResponse to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation of error details if the detail uses
+ * google.protobuf.Any.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function endStreamToJson(metadata: Headers, error: ConnectError | undefined, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): JsonObject;
+/**
+ * Create a Serialization object that serializes a Connect EndStreamResponse.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEndStreamSerialization(options: Partial<JsonWriteOptions> | undefined): Serialization<EndStreamResponse>;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/end-stream.js

@@ -0,0 +1,137 @@
+"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.endStreamFlag = void 0;
+exports.endStreamFromJson = endStreamFromJson;
+exports.endStreamToJson = endStreamToJson;
+exports.createEndStreamSerialization = createEndStreamSerialization;
+const error_json_js_1 = require("./error-json.js");
+const protocol_headers_js_1 = require("../protocol/protocol-headers.js");
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * endStreamFlag indicates that the data in a EnvelopedMessage
+ * is a EndStreamResponse of the Connect protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.endStreamFlag = 0b00000010;
+/**
+ * Parse an EndStreamResponse of the Connect protocol.
+ * Throws a ConnectError on malformed input.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function endStreamFromJson(data) {
+    const parseErr = new connect_error_js_1.ConnectError("invalid end stream", code_js_1.Code.Unknown);
+    let jsonValue;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        jsonValue = JSON.parse(typeof data == "string" ? data : new TextDecoder().decode(data));
+    }
+    catch (e) {
+        throw parseErr;
+    }
+    if (typeof jsonValue != "object" ||
+        jsonValue == null ||
+        Array.isArray(jsonValue)) {
+        throw parseErr;
+    }
+    const metadata = new Headers();
+    if ("metadata" in jsonValue) {
+        if (typeof jsonValue.metadata != "object" ||
+            jsonValue.metadata == null ||
+            Array.isArray(jsonValue.metadata)) {
+            throw parseErr;
+        }
+        for (const [key, values] of Object.entries(jsonValue.metadata)) {
+            if (!Array.isArray(values) ||
+                values.some((value) => typeof value != "string")) {
+                throw parseErr;
+            }
+            for (const value of values) {
+                metadata.append(key, value);
+            }
+        }
+    }
+    const error = "error" in jsonValue && jsonValue.error != null
+        ? (0, error_json_js_1.errorFromJson)(jsonValue.error, metadata, parseErr)
+        : undefined;
+    return { metadata, error };
+}
+/**
+ * Serialize the given EndStreamResponse to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation of error details if the detail uses
+ * google.protobuf.Any.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function endStreamToJson(metadata, error, jsonWriteOptions) {
+    const es = {};
+    if (error !== undefined) {
+        es.error = (0, error_json_js_1.errorToJson)(error, jsonWriteOptions);
+        // Copy any metadata specified in the error into the target Headers.
+        // For errors parsed from the wire, we only relay the structured payload
+        // and ignore the metadata.
+        if (!error.isWireError) {
+            (0, protocol_headers_js_1.mergeNonProtocolHeaders)(metadata, error.metadata);
+        }
+    }
+    let hasMetadata = false;
+    const md = {};
+    metadata.forEach((value, key) => {
+        hasMetadata = true;
+        md[key] = [value];
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (hasMetadata) {
+        es.metadata = md;
+    }
+    return es;
+}
+/**
+ * Create a Serialization object that serializes a Connect EndStreamResponse.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createEndStreamSerialization(options) {
+    const textEncoder = new TextEncoder();
+    return {
+        serialize(data) {
+            try {
+                const jsonObject = endStreamToJson(data.metadata, data.error, options);
+                const jsonString = JSON.stringify(jsonObject);
+                return textEncoder.encode(jsonString);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new connect_error_js_1.ConnectError(`failed to serialize EndStreamResponse: ${m}`, code_js_1.Code.Internal);
+            }
+        },
+        parse(data) {
+            try {
+                return endStreamFromJson(data);
+            }
+            catch (e) {
+                const m = e instanceof Error ? e.message : String(e);
+                throw new connect_error_js_1.ConnectError(`failed to parse EndStreamResponse: ${m}`, code_js_1.Code.InvalidArgument);
+            }
+        },
+    };
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/error-json.d.ts

@@ -0,0 +1,36 @@
+import type { JsonObject, JsonValue, JsonWriteOptions } from "@bufbuild/protobuf";
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a Connect error from a JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorFromJson(jsonValue: JsonValue, metadata: HeadersInit | undefined, fallback: ConnectError): ConnectError;
+/**
+ * Parse a Connect error from a serialized JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorFromJsonBytes(bytes: Uint8Array, metadata: HeadersInit | undefined, fallback: ConnectError): ConnectError;
+/**
+ * Serialize the given error to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation in the "debug" key if the detail uses
+ * google.protobuf.Any. If serialization of the "debug" value fails, it
+ * is silently disregarded.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorToJson(error: ConnectError, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): JsonObject;
+/**
+ * Serialize the given error to JSON. This calls errorToJson(), but stringifies
+ * the result, and converts it into a UInt8Array.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function errorToJsonBytes(error: ConnectError, jsonWriteOptions: Partial<JsonWriteOptions> | undefined): Uint8Array;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/error-json.js

@@ -0,0 +1,166 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorFromJson = errorFromJson;
+exports.errorFromJsonBytes = errorFromJsonBytes;
+exports.errorToJson = errorToJson;
+exports.errorToJsonBytes = errorToJsonBytes;
+const wire_1 = require("@bufbuild/protobuf/wire");
+const protobuf_1 = require("@bufbuild/protobuf");
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const code_string_js_1 = require("./code-string.js");
+/**
+ * Parse a Connect error from a JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function errorFromJson(jsonValue, metadata, fallback) {
+    var _a;
+    if (metadata) {
+        new Headers(metadata).forEach((value, key) => fallback.metadata.append(key, value));
+    }
+    if (typeof jsonValue !== "object" ||
+        jsonValue == null ||
+        Array.isArray(jsonValue)) {
+        throw fallback;
+    }
+    let code = fallback.code;
+    if ("code" in jsonValue && typeof jsonValue.code === "string") {
+        code = (_a = (0, code_string_js_1.codeFromString)(jsonValue.code)) !== null && _a !== void 0 ? _a : code;
+    }
+    const message = jsonValue.message;
+    if (message != null && typeof message !== "string") {
+        throw fallback;
+    }
+    const error = new connect_error_js_1.ConnectError(message !== null && message !== void 0 ? message : "", code, metadata);
+    error.isWireError = true;
+    if ("details" in jsonValue && Array.isArray(jsonValue.details)) {
+        for (const detail of jsonValue.details) {
+            if (detail === null ||
+                typeof detail != "object" ||
+                Array.isArray(detail) ||
+                typeof detail.type != "string" ||
+                typeof detail.value != "string") {
+                throw fallback;
+            }
+            try {
+                error.details.push({
+                    type: detail.type,
+                    value: (0, wire_1.base64Decode)(detail.value),
+                    debug: detail.debug,
+                });
+            }
+            catch (e) {
+                throw fallback;
+            }
+        }
+    }
+    return error;
+}
+/**
+ * Parse a Connect error from a serialized JSON value.
+ * Will return a ConnectError, and throw the provided fallback if parsing failed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function errorFromJsonBytes(bytes, metadata, fallback) {
+    let jsonValue;
+    try {
+        jsonValue = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch (e) {
+        throw fallback;
+    }
+    return errorFromJson(jsonValue, metadata, fallback);
+}
+/**
+ * Serialize the given error to JSON.
+ *
+ * The JSON serialization options are required to produce the optional
+ * human-readable representation in the "debug" key if the detail uses
+ * google.protobuf.Any. If serialization of the "debug" value fails, it
+ * is silently disregarded.
+ *
+ * See https://connectrpc.com/docs/protocol#error-end-stream
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function errorToJson(error, jsonWriteOptions) {
+    const o = {
+        code: (0, code_string_js_1.codeToString)(error.code),
+    };
+    if (error.rawMessage.length > 0) {
+        o.message = error.rawMessage;
+    }
+    if (error.details.length > 0) {
+        o.details = error.details
+            .map((detail) => {
+            if ("desc" in detail) {
+                const msg = (0, protobuf_1.create)(detail.desc, detail.value);
+                const i = {
+                    type: detail.desc.typeName,
+                    value: (0, protobuf_1.toBinary)(detail.desc, msg),
+                };
+                try {
+                    i.debug = (0, protobuf_1.toJson)(detail.desc, msg, jsonWriteOptions);
+                }
+                catch (e) {
+                    // We deliberately ignore errors that may occur when serializing
+                    // a message to JSON (the message contains an Any).
+                    // The rationale is that we are only trying to provide optional
+                    // debug information.
+                }
+                return i;
+            }
+            return detail;
+        })
+            .map((_a) => {
+            var { value } = _a, rest = __rest(_a, ["value"]);
+            return (Object.assign(Object.assign({}, rest), { value: (0, wire_1.base64Encode)(value, "std_raw") }));
+        });
+    }
+    return o;
+}
+/**
+ * Serialize the given error to JSON. This calls errorToJson(), but stringifies
+ * the result, and converts it into a UInt8Array.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function errorToJsonBytes(error, jsonWriteOptions) {
+    const textEncoder = new TextEncoder();
+    try {
+        const jsonObject = errorToJson(error, jsonWriteOptions);
+        const jsonString = JSON.stringify(jsonObject);
+        return textEncoder.encode(jsonString);
+    }
+    catch (e) {
+        const m = e instanceof Error ? e.message : String(e);
+        throw new connect_error_js_1.ConnectError(`failed to serialize Connect Error: ${m}`, code_js_1.Code.Internal);
+    }
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/get-request.d.ts

@@ -0,0 +1,6 @@
+import type { DescMessage } from "@bufbuild/protobuf";
+import type { UnaryRequest } from "../interceptor.js";
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function transformConnectPostToGetRequest<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage>(request: UnaryRequest<I, O>, message: Uint8Array, useBase64: boolean): UnaryRequest<I, O>;