openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/request-header.js

@@ -0,0 +1,66 @@
+// 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 { headerContentType, headerStreamAcceptEncoding, headerStreamEncoding, headerUnaryAcceptEncoding, headerUnaryEncoding, headerTimeout, headerProtocolVersion, headerUserAgent, } from "./headers.js";
+import { protocolVersion } from "./version.js";
+import { contentTypeStreamJson, contentTypeStreamProto, contentTypeUnaryJson, contentTypeUnaryProto, } from "./content-type.js";
+/**
+ * Creates headers for a Connect request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    if (timeoutMs !== undefined) {
+        result.set(headerTimeout, `${timeoutMs}`);
+    }
+    result.set(headerContentType, methodKind == "unary"
+        ? useBinaryFormat
+            ? contentTypeUnaryProto
+            : contentTypeUnaryJson
+        : useBinaryFormat
+            ? contentTypeStreamProto
+            : contentTypeStreamJson);
+    result.set(headerProtocolVersion, protocolVersion);
+    if (!result.has(headerUserAgent) && setUserAgent) {
+        // Note that we do not strictly comply with gRPC user agents.
+        // We use "connect-es/1.2.3" where gRPC would use "grpc-es/1.2.3".
+        // See https://github.com/grpc/grpc/blob/c462bb8d485fc1434ecfae438823ca8d14cf3154/doc/PROTOCOL-HTTP2.md#user-agents
+        result.set(headerUserAgent, "connect-es/2.2.0");
+    }
+    return result;
+}
+/**
+ * Creates headers for a Connect request with compression.
+ *
+ * Note that we always set the Content-Encoding header for unary methods.
+ * It is up to the caller to decide whether to apply compression - and remove
+ * the header if compression is not used, for example because the payload is
+ * too small to make compression effective.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requestHeaderWithCompression(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
+    const result = requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
+    if (sendCompression != null) {
+        const name = methodKind == "unary" ? headerUnaryEncoding : headerStreamEncoding;
+        result.set(name, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        const name = methodKind == "unary"
+            ? headerUnaryAcceptEncoding
+            : headerStreamAcceptEncoding;
+        result.set(name, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/trailer-mux.d.ts

@@ -0,0 +1,19 @@
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerDemux(header: Headers): [header: Headers, trailer: Headers];
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerMux(header: Headers, trailer: Headers): Headers;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/trailer-mux.js

@@ -0,0 +1,49 @@
+// 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.
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function demuxes headers and trailers into two separate Headers
+ * objects.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerDemux(header) {
+    const h = new Headers(), t = new Headers();
+    header.forEach((value, key) => {
+        if (key.toLowerCase().startsWith("trailer-")) {
+            t.append(key.substring(8), value);
+        }
+        else {
+            h.append(key, value);
+        }
+    });
+    return [h, t];
+}
+/**
+ * In unary RPCs, Connect transports trailing metadata as response header
+ * fields, prefixed with "trailer-".
+ *
+ * This function muxes a header and a trailer into a single Headers object.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function trailerMux(header, trailer) {
+    const h = new Headers(header);
+    trailer.forEach((value, key) => {
+        h.append(`trailer-${key}`, value);
+    });
+    return h;
+}

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

@@ -0,0 +1,6 @@
+import type { CommonTransportOptions } from "../protocol/transport-options.js";
+import type { Transport } from "../transport.js";
+/**
+ * Create a Transport for the Connect protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;

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

@@ -0,0 +1,207 @@
+// 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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { requestHeaderWithCompression } from "./request-header.js";
+import { headerUnaryContentLength, headerUnaryEncoding } from "./headers.js";
+import { validateResponseWithCompression } from "./validate-response.js";
+import { trailerDemux } from "./trailer-mux.js";
+import { errorFromJsonBytes } from "./error-json.js";
+import { createEndStreamSerialization, endStreamFlag } from "./end-stream.js";
+import { transformConnectPostToGetRequest } from "./get-request.js";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { appendHeaders } from "../http-headers.js";
+import { createAsyncIterable, pipeTo, sinkAllBytes, pipe, transformSerializeEnvelope, transformCompressEnvelope, transformJoinEnvelopes, transformSplitEnvelope, transformDecompressEnvelope, transformParseEnvelope, } from "../protocol/async-iterable.js";
+import { createMethodUrl } from "../protocol/create-method-url.js";
+import { runUnaryCall, runStreamingCall } from "../protocol/run-call.js";
+import { createMethodSerializationLookup } from "../protocol/serialization.js";
+import { createContextValues } from "../context-values.js";
+import { MethodOptions_IdempotencyLevel } from "@bufbuild/protobuf/wkt";
+/**
+ * Create a Transport for the Connect protocol.
+ */
+export function createTransport(opt) {
+    return {
+        async unary(method, signal, timeoutMs, header, message, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return await runUnaryCall({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: false,
+                    service: method.parent,
+                    method,
+                    requestMethod: "POST",
+                    url: createMethodUrl(opt.baseUrl, method),
+                    header: requestHeaderWithCompression(method.methodKind, opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message,
+                },
+                next: async (req) => {
+                    let requestBody = serialization
+                        .getI(opt.useBinaryFormat)
+                        .serialize(req.message);
+                    if (opt.sendCompression &&
+                        requestBody.byteLength > opt.compressMinBytes) {
+                        requestBody = await opt.sendCompression.compress(requestBody);
+                        req.header.set(headerUnaryEncoding, opt.sendCompression.name);
+                    }
+                    else {
+                        req.header.delete(headerUnaryEncoding);
+                    }
+                    const useGet = opt.useHttpGet === true &&
+                        method.idempotency ===
+                            MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS;
+                    let body;
+                    if (useGet) {
+                        req = transformConnectPostToGetRequest(req, requestBody, opt.useBinaryFormat);
+                    }
+                    else {
+                        body = createAsyncIterable([requestBody]);
+                    }
+                    const universalResponse = await opt.httpClient({
+                        url: req.url,
+                        method: req.requestMethod,
+                        header: req.header,
+                        signal: req.signal,
+                        body,
+                    });
+                    const { compression, isUnaryError, unaryError } = validateResponseWithCompression(method.methodKind, opt.acceptCompression, opt.useBinaryFormat, universalResponse.status, universalResponse.header);
+                    const [header, trailer] = trailerDemux(universalResponse.header);
+                    let responseBody = await pipeTo(universalResponse.body, sinkAllBytes(opt.readMaxBytes, universalResponse.header.get(headerUnaryContentLength)), { propagateDownStreamError: false });
+                    if (compression) {
+                        responseBody = await compression.decompress(responseBody, opt.readMaxBytes);
+                    }
+                    if (isUnaryError) {
+                        throw errorFromJsonBytes(responseBody, appendHeaders(header, trailer), unaryError);
+                    }
+                    return {
+                        stream: false,
+                        service: method.parent,
+                        method,
+                        header,
+                        message: serialization
+                            .getO(opt.useBinaryFormat)
+                            .parse(responseBody),
+                        trailer,
+                    };
+                },
+            });
+        },
+        async stream(method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            const endStreamSerialization = createEndStreamSerialization(opt.jsonOptions);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return runStreamingCall({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: true,
+                    service: method.parent,
+                    method,
+                    requestMethod: "POST",
+                    url: createMethodUrl(opt.baseUrl, method),
+                    header: requestHeaderWithCompression(method.methodKind, opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression, true),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message: input,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: pipe(req.message, transformSerializeEnvelope(serialization.getI(opt.useBinaryFormat)), transformCompressEnvelope(opt.sendCompression, opt.compressMinBytes), transformJoinEnvelopes(), { propagateDownStreamError: true }),
+                    });
+                    const { compression } = validateResponseWithCompression(method.methodKind, opt.acceptCompression, opt.useBinaryFormat, uRes.status, uRes.header);
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: new Headers(), message: pipe(uRes.body, transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), transformParseEnvelope(serialization.getO(opt.useBinaryFormat), endStreamFlag, endStreamSerialization), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                var _a, e_1, _b, _c;
+                                let endStreamReceived = false;
+                                try {
+                                    for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+                                        _c = iterable_1_1.value;
+                                        _d = false;
+                                        const chunk = _c;
+                                        if (chunk.end) {
+                                            if (endStreamReceived) {
+                                                throw new ConnectError("protocol error: received extra EndStreamResponse", Code.InvalidArgument);
+                                            }
+                                            endStreamReceived = true;
+                                            if (chunk.value.error) {
+                                                const error = chunk.value.error;
+                                                uRes.header.forEach((value, key) => {
+                                                    error.metadata.append(key, value);
+                                                });
+                                                throw error;
+                                            }
+                                            chunk.value.metadata.forEach((value, key) => res.trailer.set(key, value));
+                                            continue;
+                                        }
+                                        if (endStreamReceived) {
+                                            throw new ConnectError("protocol error: received extra message after EndStreamResponse", Code.InvalidArgument);
+                                        }
+                                        yield yield __await(chunk.value);
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                                if (!endStreamReceived) {
+                                    throw new ConnectError("protocol error: missing EndStreamResponse", Code.InvalidArgument);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/validate-response.d.ts

@@ -0,0 +1,30 @@
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+import type { DescMethod } from "@bufbuild/protobuf";
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(methodKind: DescMethod["methodKind"], useBinaryFormat: boolean, status: number, headers: Headers): {
+    isUnaryError: false;
+    unaryError?: undefined;
+} | {
+    isUnaryError: true;
+    unaryError: ConnectError;
+};
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+export declare function validateResponseWithCompression(methodKind: DescMethod["methodKind"], acceptCompression: Compression[], useBinaryFormat: boolean, status: number, headers: Headers): ReturnType<typeof validateResponse> & {
+    compression: Compression | undefined;
+};

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/validate-response.js

@@ -0,0 +1,67 @@
+// 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 { Code } from "../code.js";
+import { codeFromHttpStatus } from "./http-status.js";
+import { ConnectError } from "../connect-error.js";
+import { parseContentType } from "./content-type.js";
+import { headerContentType, headerStreamEncoding, headerUnaryEncoding, } from "./headers.js";
+/**
+ * Validates response status and header for the Connect protocol.
+ * Throws a ConnectError if the header indicates an error, or if
+ * the content type is unexpected, with the following exception:
+ * For unary RPCs with an HTTP error status, this returns an error
+ * derived from the HTTP status instead of throwing it, giving an
+ * implementation a chance to parse a Connect error from the wire.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponse(methodKind, useBinaryFormat, status, headers) {
+    const mimeType = headers.get(headerContentType);
+    const parsedType = parseContentType(mimeType);
+    if (status !== 200) {
+        const errorFromStatus = new ConnectError(`HTTP ${status}`, codeFromHttpStatus(status), headers);
+        // If parsedType is defined and it is not binary, then this is a unary JSON response
+        if (methodKind == "unary" && parsedType && !parsedType.binary) {
+            return { isUnaryError: true, unaryError: errorFromStatus };
+        }
+        throw errorFromStatus;
+    }
+    const allowedContentType = {
+        binary: useBinaryFormat,
+        stream: methodKind !== "unary",
+    };
+    if ((parsedType === null || parsedType === void 0 ? void 0 : parsedType.binary) !== allowedContentType.binary ||
+        parsedType.stream !== allowedContentType.stream) {
+        throw new ConnectError(`unsupported content type ${mimeType}`, parsedType === undefined ? Code.Unknown : Code.Internal, headers);
+    }
+    return { isUnaryError: false };
+}
+/**
+ * Validates response status and header for the Connect protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * @private
+ */
+export function validateResponseWithCompression(methodKind, acceptCompression, useBinaryFormat, status, headers) {
+    let compression;
+    const encoding = headers.get(methodKind == "unary" ? headerUnaryEncoding : headerStreamEncoding);
+    if (encoding != null && encoding.toLowerCase() !== "identity") {
+        compression = acceptCompression.find((c) => c.name === encoding);
+        if (!compression) {
+            throw new ConnectError(`unsupported response encoding "${encoding}"`, Code.Internal, headers);
+        }
+    }
+    return Object.assign({ compression }, validateResponse(methodKind, useBinaryFormat, status, headers));
+}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/version.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionHeader(requestHeader: Headers): void;
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requireProtocolVersionParam(queryParams: URLSearchParams): void;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/version.js

@@ -0,0 +1,53 @@
+// 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 { headerProtocolVersion } from "./headers.js";
+import { paramConnectVersion } from "./query-params.js";
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+/**
+ * The only know value for the header Connect-Protocol-Version.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const protocolVersion = "1";
+/**
+ * Requires the Connect-Protocol-Version header to be present with the expected
+ * value. Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requireProtocolVersionHeader(requestHeader) {
+    const v = requestHeader.get(headerProtocolVersion);
+    if (v === null) {
+        throw new ConnectError(`missing required header: set ${headerProtocolVersion} to "${protocolVersion}"`, Code.InvalidArgument);
+    }
+    if (v !== protocolVersion) {
+        throw new ConnectError(`${headerProtocolVersion} must be "${protocolVersion}": got "${v}"`, Code.InvalidArgument);
+    }
+}
+/**
+ * Requires the connect query parameter to be present with the expected value.
+ * Raises a ConnectError with Code.InvalidArgument otherwise.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function requireProtocolVersionParam(queryParams) {
+    const v = queryParams.get(paramConnectVersion);
+    if (v === null) {
+        throw new ConnectError(`missing required parameter: set ${paramConnectVersion} to "v${protocolVersion}"`, Code.InvalidArgument);
+    }
+    if (v !== `v${protocolVersion}`) {
+        throw new ConnectError(`${paramConnectVersion} must be "v${protocolVersion}": got "${v}"`, Code.InvalidArgument);
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const contentTypeRegExp: RegExp;
+export declare const contentTypeProto = "application/grpc+proto";
+export declare const contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function parseContentType(contentType: string | null): {
+    binary: boolean;
+} | undefined;

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

@@ -0,0 +1,34 @@
+// 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.
+/**
+ * Regular Expression that matches any valid gRPC Content-Type header value.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeRegExp = /^application\/grpc(?:\+(?:(json)(?:; ?charset=utf-?8)?|proto))?$/i;
+export const contentTypeProto = "application/grpc+proto";
+export const contentTypeJson = "application/grpc+json";
+/**
+ * Parse a gRPC Content-Type header.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function parseContentType(contentType) {
+    const match = contentType === null || contentType === void 0 ? void 0 : contentType.match(contentTypeRegExp);
+    if (!match) {
+        return undefined;
+    }
+    const binary = !match[1];
+    return { binary };
+}