openrod 0.0.0 → 0.1.0

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

@@ -0,0 +1,66 @@
+"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.transformConnectPostToGetRequest = transformConnectPostToGetRequest;
+const wire_1 = require("@bufbuild/protobuf/wire");
+const headers_js_1 = require("./headers.js");
+const version_js_1 = require("./version.js");
+const contentTypePrefix = "application/";
+function encodeMessageForUrl(message, useBase64) {
+    if (useBase64) {
+        return (0, wire_1.base64Encode)(message, "url");
+    }
+    return encodeURIComponent(new TextDecoder().decode(message));
+}
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+function transformConnectPostToGetRequest(request, message, useBase64) {
+    // Parameters are ordered per the Connect protocol Query-Get rule
+    // (connect, base64, compression, encoding, message).
+    let query = `?connect=v${version_js_1.protocolVersion}`;
+    let compressionQuery = "";
+    const compression = request.header.get(headers_js_1.headerUnaryEncoding);
+    if (compression !== null && compression !== "identity") {
+        compressionQuery = "&compression=" + encodeURIComponent(compression);
+        // Force base64 for compressed payloads.
+        useBase64 = true;
+    }
+    if (useBase64) {
+        query += "&base64=1";
+    }
+    query += compressionQuery;
+    const contentType = request.header.get(headers_js_1.headerContentType);
+    if ((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(contentTypePrefix)) === 0) {
+        query +=
+            "&encoding=" +
+                encodeURIComponent(contentType.slice(contentTypePrefix.length));
+    }
+    query += "&message=" + encodeMessageForUrl(message, useBase64);
+    const url = request.url + query;
+    const header = new Headers(request.header);
+    // Omit headers that are not used for unary GET requests.
+    for (const h of [
+        headers_js_1.headerProtocolVersion,
+        headers_js_1.headerContentType,
+        headers_js_1.headerUnaryContentLength,
+        headers_js_1.headerUnaryEncoding,
+        headers_js_1.headerUnaryAcceptEncoding,
+    ]) {
+        header.delete(h);
+    }
+    return Object.assign(Object.assign({}, request), { requestMethod: "GET", url,
+        header });
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/handler-factory.d.ts

@@ -0,0 +1,6 @@
+import type { UniversalHandlerOptions } from "../protocol/universal-handler.js";
+import type { ProtocolHandlerFactory } from "../protocol/protocol-handler-factory.js";
+/**
+ * Create a factory that creates Connect handlers.
+ */
+export declare function createHandlerFactory(options: Partial<UniversalHandlerOptions>): ProtocolHandlerFactory;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/handler-factory.js

@@ -0,0 +1,296 @@
+"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.createHandlerFactory = createHandlerFactory;
+const protobuf_1 = require("@bufbuild/protobuf");
+const wire_1 = require("@bufbuild/protobuf/wire");
+const code_js_1 = require("../code.js");
+const connect_error_js_1 = require("../connect-error.js");
+const implementation_js_1 = require("../implementation.js");
+const content_type_js_1 = require("./content-type.js");
+const end_stream_js_1 = require("./end-stream.js");
+const error_json_js_1 = require("./error-json.js");
+const headers_js_1 = require("./headers.js");
+const http_status_js_1 = require("./http-status.js");
+const parse_timeout_js_1 = require("./parse-timeout.js");
+const query_params_js_1 = require("./query-params.js");
+const trailer_mux_js_1 = require("./trailer-mux.js");
+const version_js_1 = require("./version.js");
+const compression_js_1 = require("../protocol/compression.js");
+const protocol_headers_js_1 = require("../protocol/protocol-headers.js");
+const serialization_js_1 = require("../protocol/serialization.js");
+const universal_handler_js_1 = require("../protocol/universal-handler.js");
+const universal_js_1 = require("../protocol/universal.js");
+const async_iterable_js_1 = require("../protocol/async-iterable.js");
+const content_type_matcher_js_1 = require("../protocol/content-type-matcher.js");
+const create_method_url_js_1 = require("../protocol/create-method-url.js");
+const invoke_implementation_js_1 = require("../protocol/invoke-implementation.js");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+const protocolName = "connect";
+const methodPost = "POST";
+const methodGet = "GET";
+/**
+ * Create a factory that creates Connect handlers.
+ */
+function createHandlerFactory(options) {
+    const opt = (0, universal_handler_js_1.validateUniversalHandlerOptions)(options);
+    const endStreamSerialization = (0, end_stream_js_1.createEndStreamSerialization)(opt.jsonOptions);
+    function fact(spec) {
+        let h;
+        let contentTypeRegExp;
+        const serialization = (0, serialization_js_1.createMethodSerializationLookup)(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
+        switch (spec.kind) {
+            case "unary":
+                contentTypeRegExp = content_type_js_1.contentTypeUnaryRegExp;
+                h = createUnaryHandler(opt, spec, serialization);
+                break;
+            default:
+                contentTypeRegExp = content_type_js_1.contentTypeStreamRegExp;
+                h = createStreamHandler(opt, spec, serialization, endStreamSerialization);
+                break;
+        }
+        const allowedMethods = [methodPost];
+        if (spec.method.idempotency === wkt_1.MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS) {
+            allowedMethods.push(methodGet);
+        }
+        return Object.assign(h, {
+            protocolNames: [protocolName],
+            supportedContentType: (0, content_type_matcher_js_1.contentTypeMatcher)(contentTypeRegExp),
+            allowedMethods,
+            requestPath: (0, create_method_url_js_1.createMethodUrl)("/", spec.method),
+            service: spec.method.parent,
+            method: spec.method,
+        });
+    }
+    fact.protocolName = protocolName;
+    return fact;
+}
+function createUnaryHandler(opt, spec, serialization) {
+    return async function handle(req) {
+        const isGet = req.method == methodGet;
+        if (isGet &&
+            spec.method.idempotency != wkt_1.MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS) {
+            return universal_js_1.uResponseMethodNotAllowed;
+        }
+        const queryParams = new URL(req.url).searchParams;
+        const compressionRequested = isGet
+            ? queryParams.get(query_params_js_1.paramCompression)
+            : req.header.get(headers_js_1.headerUnaryEncoding);
+        const type = isGet
+            ? (0, content_type_js_1.parseEncodingQuery)(queryParams.get(query_params_js_1.paramEncoding))
+            : (0, content_type_js_1.parseContentType)(req.header.get(headers_js_1.headerContentType));
+        if (type == undefined || type.stream) {
+            return universal_js_1.uResponseUnsupportedMediaType;
+        }
+        const timeout = (0, parse_timeout_js_1.parseTimeout)(req.header.get(headers_js_1.headerTimeout), opt.maxTimeoutMs);
+        const context = (0, implementation_js_1.createHandlerContext)(Object.assign(Object.assign({}, spec), { service: spec.method.parent, requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headers_js_1.headerContentType]: type.binary
+                    ? content_type_js_1.contentTypeUnaryProto
+                    : content_type_js_1.contentTypeUnaryJson,
+            }, contextValues: req.contextValues }));
+        const compression = (0, compression_js_1.compressionNegotiate)(opt.acceptCompression, compressionRequested, req.header.get(headers_js_1.headerUnaryAcceptEncoding), headers_js_1.headerUnaryAcceptEncoding);
+        let status = universal_js_1.uResponseOk.status;
+        let body;
+        try {
+            // We run the request gate before receiving the body, so that a request it
+            // rejects is never read, decompressed, or parsed.
+            if (opt.requestGate !== undefined) {
+                await opt.requestGate(context);
+            }
+            if (opt.requireConnectProtocolHeader) {
+                if (isGet) {
+                    (0, version_js_1.requireProtocolVersionParam)(queryParams);
+                }
+                else {
+                    (0, version_js_1.requireProtocolVersionHeader)(req.header);
+                }
+            }
+            // raise compression error to serialize it as a error response
+            if (compression.error) {
+                throw compression.error;
+            }
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error) {
+                throw timeout.error;
+            }
+            let reqBody;
+            if (isGet) {
+                reqBody = await readUnaryMessageFromQuery(opt.readMaxBytes, compression.request, queryParams);
+            }
+            else {
+                reqBody = await readUnaryMessageFromBody(opt.readMaxBytes, compression.request, req);
+            }
+            const input = parseUnaryMessage(spec.method, type.binary, serialization, reqBody);
+            const output = await (0, invoke_implementation_js_1.invokeUnaryImplementation)(spec, context, input, opt.interceptors);
+            body = serialization.getO(type.binary).serialize(output);
+        }
+        catch (e) {
+            context.abort(e);
+            let error;
+            if (e instanceof connect_error_js_1.ConnectError) {
+                error = e;
+            }
+            else {
+                error = new connect_error_js_1.ConnectError("internal error", code_js_1.Code.Internal, undefined, undefined, e);
+            }
+            status = (0, http_status_js_1.codeToHttpStatus)(error.code);
+            context.responseHeader.set(headers_js_1.headerContentType, content_type_js_1.contentTypeUnaryJson);
+            // 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)(context.responseHeader, error.metadata);
+            }
+            body = (0, error_json_js_1.errorToJsonBytes)(error, opt.jsonOptions);
+        }
+        finally {
+            context.abort();
+        }
+        if (compression.response && body.byteLength >= opt.compressMinBytes) {
+            body = await compression.response.compress(body);
+            context.responseHeader.set(headers_js_1.headerUnaryEncoding, compression.response.name);
+        }
+        const header = (0, trailer_mux_js_1.trailerMux)(context.responseHeader, context.responseTrailer);
+        header.set(headers_js_1.headerUnaryContentLength, body.byteLength.toString(10));
+        return {
+            status,
+            body: (0, async_iterable_js_1.createAsyncIterable)([body]),
+            header,
+        };
+    };
+}
+async function readUnaryMessageFromBody(readMaxBytes, compression, request) {
+    if (typeof request.body == "object" &&
+        request.body !== null &&
+        Symbol.asyncIterator in request.body) {
+        let reqBytes = await (0, async_iterable_js_1.readAllBytes)(request.body, readMaxBytes, request.header.get(headers_js_1.headerUnaryContentLength));
+        if (compression) {
+            reqBytes = await compression.decompress(reqBytes, readMaxBytes);
+        }
+        return reqBytes;
+    }
+    return request.body;
+}
+async function readUnaryMessageFromQuery(readMaxBytes, compression, queryParams) {
+    var _a;
+    const base64 = queryParams.get(query_params_js_1.paramBase64);
+    const message = (_a = queryParams.get(query_params_js_1.paramMessage)) !== null && _a !== void 0 ? _a : "";
+    let decoded;
+    if (base64 === "1") {
+        decoded = (0, wire_1.base64Decode)(message);
+    }
+    else {
+        decoded = new TextEncoder().encode(message);
+    }
+    if (compression) {
+        decoded = await compression.decompress(decoded, readMaxBytes);
+    }
+    return decoded;
+}
+function parseUnaryMessage(method, useBinaryFormat, serialization, input) {
+    if (input instanceof Uint8Array) {
+        return serialization.getI(useBinaryFormat).parse(input);
+    }
+    if (useBinaryFormat) {
+        throw new connect_error_js_1.ConnectError("received parsed JSON request body, but content-type indicates binary format", code_js_1.Code.Internal);
+    }
+    try {
+        return (0, protobuf_1.fromJson)(method.input, input);
+    }
+    catch (e) {
+        throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.InvalidArgument);
+    }
+}
+function createStreamHandler(opt, spec, serialization, endStreamSerialization) {
+    return async function handle(req) {
+        (0, universal_js_1.assertByteStreamRequest)(req);
+        const type = (0, content_type_js_1.parseContentType)(req.header.get(headers_js_1.headerContentType));
+        if (type == undefined || !type.stream) {
+            return universal_js_1.uResponseUnsupportedMediaType;
+        }
+        if (req.method !== methodPost) {
+            return universal_js_1.uResponseMethodNotAllowed;
+        }
+        const timeout = (0, parse_timeout_js_1.parseTimeout)(req.header.get(headers_js_1.headerTimeout), opt.maxTimeoutMs);
+        const context = (0, implementation_js_1.createHandlerContext)(Object.assign(Object.assign({}, spec), { service: spec.method.parent, requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headers_js_1.headerContentType]: type.binary
+                    ? content_type_js_1.contentTypeStreamProto
+                    : content_type_js_1.contentTypeStreamJson,
+            }, contextValues: req.contextValues }));
+        const compression = (0, compression_js_1.compressionNegotiate)(opt.acceptCompression, req.header.get(headers_js_1.headerStreamEncoding), req.header.get(headers_js_1.headerStreamAcceptEncoding), headers_js_1.headerStreamAcceptEncoding);
+        if (compression.response) {
+            context.responseHeader.set(headers_js_1.headerStreamEncoding, compression.response.name);
+        }
+        // We split the pipeline into two parts: The request iterator, and the
+        // response iterator. We do this because the request iterator is responsible
+        // for parsing the request body, and we don't want write errors of the response
+        // iterator to affect the request iterator.
+        const inputIt = (0, async_iterable_js_1.pipe)(req.body, (0, async_iterable_js_1.transformPrepend)(() => {
+            if (opt.requireConnectProtocolHeader) {
+                (0, version_js_1.requireProtocolVersionHeader)(req.header);
+            }
+            // raise compression error to serialize it as the end stream response
+            if (compression.error)
+                throw compression.error;
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error)
+                throw timeout.error;
+            return undefined;
+        }), (0, async_iterable_js_1.transformSplitEnvelope)(opt.readMaxBytes), (0, async_iterable_js_1.transformDecompressEnvelope)(compression.request, opt.readMaxBytes), (0, async_iterable_js_1.transformParseEnvelope)(serialization.getI(type.binary), end_stream_js_1.endStreamFlag));
+        // We run the request gate before receiving the body, so that a request it
+        // rejects is never read, decompressed, or parsed.
+        const it = await (0, invoke_implementation_js_1.applyRequestGate)(context, opt.requestGate, () => (0, invoke_implementation_js_1.transformInvokeImplementation)(spec, context, opt.interceptors)(inputIt));
+        const outputIt = (0, async_iterable_js_1.pipe)(
+        // We wrap the iterator in an async iterator to ensure that the
+        // abort signal is aborted when the iterator is done.
+        {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => it.next(),
+                    throw: (e) => {
+                        var _a, _b;
+                        context.abort(e);
+                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
+                    },
+                    return: (v) => {
+                        var _a, _b;
+                        context.abort();
+                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
+                    },
+                };
+            },
+        }, (0, async_iterable_js_1.transformSerializeEnvelope)(serialization.getO(type.binary)), (0, async_iterable_js_1.transformCatchFinally)((e) => {
+            context.abort(e);
+            const end = {
+                metadata: context.responseTrailer,
+            };
+            if (e instanceof connect_error_js_1.ConnectError) {
+                end.error = e;
+            }
+            else if (e !== undefined) {
+                end.error = new connect_error_js_1.ConnectError("internal error", code_js_1.Code.Internal, undefined, undefined, e);
+            }
+            return {
+                flags: end_stream_js_1.endStreamFlag,
+                data: endStreamSerialization.serialize(end),
+            };
+        }), (0, async_iterable_js_1.transformCompressEnvelope)(compression.response, opt.compressMinBytes), (0, async_iterable_js_1.transformJoinEnvelopes)(), { propagateDownStreamError: true });
+        return Object.assign(Object.assign({}, universal_js_1.uResponseOk), { 
+            // We wait for the first response body bytes before resolving, so that
+            // implementations have a chance to add headers before an adapter commits
+            // them to the wire.
+            body: await (0, async_iterable_js_1.untilFirst)(outputIt), header: context.responseHeader });
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerContentType = "Content-Type";
+export declare const headerUnaryContentLength = "Content-Length";
+export declare const headerUnaryEncoding = "Content-Encoding";
+export declare const headerStreamEncoding = "Connect-Content-Encoding";
+export declare const headerUnaryAcceptEncoding = "Accept-Encoding";
+export declare const headerStreamAcceptEncoding = "Connect-Accept-Encoding";
+export declare const headerTimeout = "Connect-Timeout-Ms";
+export declare const headerProtocolVersion = "Connect-Protocol-Version";
+export declare const headerDate = "Date";
+export declare const headerHost = "Host";
+export declare const headerTrailer = "Trailer";
+export declare const headerUserAgent = "User-Agent";
+export declare const headerUnaryTrailerPrefix = "Trailer-";

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

@@ -0,0 +1,32 @@
+"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.headerUnaryTrailerPrefix = exports.headerUserAgent = exports.headerTrailer = exports.headerHost = exports.headerDate = exports.headerProtocolVersion = exports.headerTimeout = exports.headerStreamAcceptEncoding = exports.headerUnaryAcceptEncoding = exports.headerStreamEncoding = exports.headerUnaryEncoding = exports.headerUnaryContentLength = exports.headerContentType = void 0;
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.headerContentType = "Content-Type";
+exports.headerUnaryContentLength = "Content-Length";
+exports.headerUnaryEncoding = "Content-Encoding";
+exports.headerStreamEncoding = "Connect-Content-Encoding";
+exports.headerUnaryAcceptEncoding = "Accept-Encoding";
+exports.headerStreamAcceptEncoding = "Connect-Accept-Encoding";
+exports.headerTimeout = "Connect-Timeout-Ms";
+exports.headerProtocolVersion = "Connect-Protocol-Version";
+exports.headerDate = "Date";
+exports.headerHost = "Host";
+exports.headerTrailer = "Trailer";
+exports.headerUserAgent = "User-Agent";
+exports.headerUnaryTrailerPrefix = "Trailer-";

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/http-status.d.ts

@@ -0,0 +1,15 @@
+import { Code } from "../code.js";
+/**
+ * Determine the Connect error code for the given HTTP status code.
+ * See https://connectrpc.com/docs/protocol/#http-to-error-code
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeFromHttpStatus(httpStatus: number): Code;
+/**
+ * Returns a HTTP status code for the given Connect code.
+ * See https://connectrpc.com/docs/protocol#error-codes
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function codeToHttpStatus(code: Code): number;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/http-status.js

@@ -0,0 +1,90 @@
+"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.codeFromHttpStatus = codeFromHttpStatus;
+exports.codeToHttpStatus = codeToHttpStatus;
+const code_js_1 = require("../code.js");
+/**
+ * Determine the Connect error code for the given HTTP status code.
+ * See https://connectrpc.com/docs/protocol/#http-to-error-code
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function codeFromHttpStatus(httpStatus) {
+    switch (httpStatus) {
+        case 400: // Bad Request
+            return code_js_1.Code.Internal;
+        case 401: // Unauthorized
+            return code_js_1.Code.Unauthenticated;
+        case 403: // Forbidden
+            return code_js_1.Code.PermissionDenied;
+        case 404: // Not Found
+            return code_js_1.Code.Unimplemented;
+        case 429: // Too Many Requests
+            return code_js_1.Code.Unavailable;
+        case 502: // Bad Gateway
+            return code_js_1.Code.Unavailable;
+        case 503: // Service Unavailable
+            return code_js_1.Code.Unavailable;
+        case 504: // Gateway Timeout
+            return code_js_1.Code.Unavailable;
+        default:
+            return code_js_1.Code.Unknown;
+    }
+}
+/**
+ * Returns a HTTP status code for the given Connect code.
+ * See https://connectrpc.com/docs/protocol#error-codes
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function codeToHttpStatus(code) {
+    switch (code) {
+        case code_js_1.Code.Canceled:
+            return 499; // Client Closed Request
+        case code_js_1.Code.Unknown:
+            return 500; // Internal Server Error
+        case code_js_1.Code.InvalidArgument:
+            return 400; // Bad Request
+        case code_js_1.Code.DeadlineExceeded:
+            return 504; // Gateway Timeout
+        case code_js_1.Code.NotFound:
+            return 404; // Not Found
+        case code_js_1.Code.AlreadyExists:
+            return 409; // Conflict
+        case code_js_1.Code.PermissionDenied:
+            return 403; // Forbidden
+        case code_js_1.Code.ResourceExhausted:
+            return 429; // Too Many Requests
+        case code_js_1.Code.FailedPrecondition:
+            return 400; // Bad Request
+        case code_js_1.Code.Aborted:
+            return 409; // Conflict
+        case code_js_1.Code.OutOfRange:
+            return 400; // Bad Request
+        case code_js_1.Code.Unimplemented:
+            return 501; // Not Implemented
+        case code_js_1.Code.Internal:
+            return 500; // Internal Server Error
+        case code_js_1.Code.Unavailable:
+            return 503; // Service Unavailable
+        case code_js_1.Code.DataLoss:
+            return 500; // Internal Server Error
+        case code_js_1.Code.Unauthenticated:
+            return 401; // Unauthorized
+        default:
+            return 500; // same as CodeUnknown
+    }
+}

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

@@ -0,0 +1,16 @@
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+export { codeFromHttpStatus, codeToHttpStatus } from "./http-status.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { endStreamToJson, endStreamFromJson, endStreamFlag, createEndStreamSerialization, } from "./end-stream.js";
+export type { EndStreamResponse } from "./end-stream.js";
+export { errorFromJson, errorFromJsonBytes, errorToJson, errorToJsonBytes, } from "./error-json.js";
+export { parseContentType, contentTypeUnaryProto, contentTypeUnaryJson, contentTypeStreamProto, contentTypeStreamJson, contentTypeRegExp, contentTypeUnaryRegExp, contentTypeStreamRegExp, } from "./content-type.js";
+export { parseTimeout } from "./parse-timeout.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerMux, trailerDemux } from "./trailer-mux.js";
+export * from "./headers.js";
+export { transformConnectPostToGetRequest } from "./get-request.js";
+export { protocolVersion } from "./version.js";
+export { codeFromString } from "./code-string.js";
+export { codeToString } from "./code-string.js";

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

@@ -0,0 +1,81 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeToString = exports.codeFromString = exports.protocolVersion = exports.transformConnectPostToGetRequest = exports.trailerDemux = exports.trailerMux = exports.validateResponseWithCompression = exports.validateResponse = exports.parseTimeout = exports.contentTypeStreamRegExp = exports.contentTypeUnaryRegExp = exports.contentTypeRegExp = exports.contentTypeStreamJson = exports.contentTypeStreamProto = exports.contentTypeUnaryJson = exports.contentTypeUnaryProto = exports.parseContentType = exports.errorToJsonBytes = exports.errorToJson = exports.errorFromJsonBytes = exports.errorFromJson = exports.createEndStreamSerialization = exports.endStreamFlag = exports.endStreamFromJson = exports.endStreamToJson = exports.requestHeaderWithCompression = exports.requestHeader = exports.codeToHttpStatus = exports.codeFromHttpStatus = exports.createTransport = exports.createHandlerFactory = void 0;
+var handler_factory_js_1 = require("./handler-factory.js");
+Object.defineProperty(exports, "createHandlerFactory", { enumerable: true, get: function () { return handler_factory_js_1.createHandlerFactory; } });
+var transport_js_1 = require("./transport.js");
+Object.defineProperty(exports, "createTransport", { enumerable: true, get: function () { return transport_js_1.createTransport; } });
+// All exports below are private — internal code that does not follow semantic
+// versioning.
+// We will try hard to avoid breaking changes, but if you depend on the
+// following exports, we recommend that you do so with an exact version
+// constraint (no ~ or ^).
+var http_status_js_1 = require("./http-status.js");
+Object.defineProperty(exports, "codeFromHttpStatus", { enumerable: true, get: function () { return http_status_js_1.codeFromHttpStatus; } });
+Object.defineProperty(exports, "codeToHttpStatus", { enumerable: true, get: function () { return http_status_js_1.codeToHttpStatus; } });
+var request_header_js_1 = require("./request-header.js");
+Object.defineProperty(exports, "requestHeader", { enumerable: true, get: function () { return request_header_js_1.requestHeader; } });
+Object.defineProperty(exports, "requestHeaderWithCompression", { enumerable: true, get: function () { return request_header_js_1.requestHeaderWithCompression; } });
+var end_stream_js_1 = require("./end-stream.js");
+Object.defineProperty(exports, "endStreamToJson", { enumerable: true, get: function () { return end_stream_js_1.endStreamToJson; } });
+Object.defineProperty(exports, "endStreamFromJson", { enumerable: true, get: function () { return end_stream_js_1.endStreamFromJson; } });
+Object.defineProperty(exports, "endStreamFlag", { enumerable: true, get: function () { return end_stream_js_1.endStreamFlag; } });
+Object.defineProperty(exports, "createEndStreamSerialization", { enumerable: true, get: function () { return end_stream_js_1.createEndStreamSerialization; } });
+var error_json_js_1 = require("./error-json.js");
+Object.defineProperty(exports, "errorFromJson", { enumerable: true, get: function () { return error_json_js_1.errorFromJson; } });
+Object.defineProperty(exports, "errorFromJsonBytes", { enumerable: true, get: function () { return error_json_js_1.errorFromJsonBytes; } });
+Object.defineProperty(exports, "errorToJson", { enumerable: true, get: function () { return error_json_js_1.errorToJson; } });
+Object.defineProperty(exports, "errorToJsonBytes", { enumerable: true, get: function () { return error_json_js_1.errorToJsonBytes; } });
+var content_type_js_1 = require("./content-type.js");
+Object.defineProperty(exports, "parseContentType", { enumerable: true, get: function () { return content_type_js_1.parseContentType; } });
+Object.defineProperty(exports, "contentTypeUnaryProto", { enumerable: true, get: function () { return content_type_js_1.contentTypeUnaryProto; } });
+Object.defineProperty(exports, "contentTypeUnaryJson", { enumerable: true, get: function () { return content_type_js_1.contentTypeUnaryJson; } });
+Object.defineProperty(exports, "contentTypeStreamProto", { enumerable: true, get: function () { return content_type_js_1.contentTypeStreamProto; } });
+Object.defineProperty(exports, "contentTypeStreamJson", { enumerable: true, get: function () { return content_type_js_1.contentTypeStreamJson; } });
+Object.defineProperty(exports, "contentTypeRegExp", { enumerable: true, get: function () { return content_type_js_1.contentTypeRegExp; } });
+Object.defineProperty(exports, "contentTypeUnaryRegExp", { enumerable: true, get: function () { return content_type_js_1.contentTypeUnaryRegExp; } });
+Object.defineProperty(exports, "contentTypeStreamRegExp", { enumerable: true, get: function () { return content_type_js_1.contentTypeStreamRegExp; } });
+var parse_timeout_js_1 = require("./parse-timeout.js");
+Object.defineProperty(exports, "parseTimeout", { enumerable: true, get: function () { return parse_timeout_js_1.parseTimeout; } });
+var validate_response_js_1 = require("./validate-response.js");
+Object.defineProperty(exports, "validateResponse", { enumerable: true, get: function () { return validate_response_js_1.validateResponse; } });
+Object.defineProperty(exports, "validateResponseWithCompression", { enumerable: true, get: function () { return validate_response_js_1.validateResponseWithCompression; } });
+var trailer_mux_js_1 = require("./trailer-mux.js");
+Object.defineProperty(exports, "trailerMux", { enumerable: true, get: function () { return trailer_mux_js_1.trailerMux; } });
+Object.defineProperty(exports, "trailerDemux", { enumerable: true, get: function () { return trailer_mux_js_1.trailerDemux; } });
+__exportStar(require("./headers.js"), exports);
+var get_request_js_1 = require("./get-request.js");
+Object.defineProperty(exports, "transformConnectPostToGetRequest", { enumerable: true, get: function () { return get_request_js_1.transformConnectPostToGetRequest; } });
+var version_js_1 = require("./version.js");
+Object.defineProperty(exports, "protocolVersion", { enumerable: true, get: function () { return version_js_1.protocolVersion; } });
+var code_string_js_1 = require("./code-string.js");
+Object.defineProperty(exports, "codeFromString", { enumerable: true, get: function () { return code_string_js_1.codeFromString; } });
+var code_string_js_2 = require("./code-string.js");
+Object.defineProperty(exports, "codeToString", { enumerable: true, get: function () { return code_string_js_2.codeToString; } });

package/node_modules/@connectrpc/connect/dist/cjs/protocol-connect/parse-timeout.d.ts

@@ -0,0 +1,13 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * Parse a Connect Timeout (Deadline) header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseTimeout(value: string | null, maxTimeoutMs: number): {
+    timeoutMs?: number;
+    error?: undefined;
+} | {
+    timeoutMs?: number;
+    error: ConnectError;
+};