openrod 0.0.0 → 0.1.0

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

@@ -0,0 +1,95 @@
+"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.uResponseOk = exports.assertByteStreamRequest = exports.createDeadlineSignal = exports.getAbortSignalReason = exports.createLinkedAbortController = exports.transformInvokeImplementation = exports.invokeUnaryImplementation = exports.contentTypeMatcher = exports.untilFirst = exports.readAllBytes = exports.createAsyncIterable = exports.createWritableIterable = exports.makeIterableAbortable = exports.sinkAllBytes = exports.sinkAll = exports.pipeTo = exports.transformParseEnvelope = exports.transformSerializeEnvelope = exports.transformSplitEnvelope = exports.transformJoinEnvelopes = exports.transformDecompressEnvelope = exports.transformCompressEnvelope = exports.transformReadAllBytes = exports.transformPrepend = exports.transformAppend = exports.transformCatchFinally = exports.transformCatch = exports.pipe = exports.compressionNegotiate = exports.compressedFlag = exports.createEnvelopeReadableStream = exports.envelopeCompress = exports.envelopeDecompress = exports.encodeEnvelopes = exports.encodeEnvelope = exports.validateReadWriteMaxBytes = exports.limitSerialization = exports.getJsonOptions = exports.createClientMethodSerializers = exports.createMethodSerializationLookup = exports.runStreamingCall = exports.runUnaryCall = exports.universalServerResponseToFetch = exports.universalServerRequestFromFetch = exports.universalClientResponseFromFetch = exports.universalClientRequestToFetch = exports.createFetchHandler = exports.createFetchClient = exports.createUniversalHandlerClient = exports.createMethodUrl = void 0;
+exports.mergeNonProtocolHeaders = exports.createUniversalMethodHandler = exports.createUniversalServiceHandlers = exports.validateUniversalHandlerOptions = exports.uResponseVersionNotSupported = exports.uResponseMethodNotAllowed = exports.uResponseUnsupportedMediaType = exports.uResponseNotFound = void 0;
+var create_method_url_js_1 = require("./create-method-url.js");
+Object.defineProperty(exports, "createMethodUrl", { enumerable: true, get: function () { return create_method_url_js_1.createMethodUrl; } });
+var universal_handler_client_js_1 = require("./universal-handler-client.js");
+Object.defineProperty(exports, "createUniversalHandlerClient", { enumerable: true, get: function () { return universal_handler_client_js_1.createUniversalHandlerClient; } });
+var universal_fetch_js_1 = require("./universal-fetch.js");
+Object.defineProperty(exports, "createFetchClient", { enumerable: true, get: function () { return universal_fetch_js_1.createFetchClient; } });
+Object.defineProperty(exports, "createFetchHandler", { enumerable: true, get: function () { return universal_fetch_js_1.createFetchHandler; } });
+Object.defineProperty(exports, "universalClientRequestToFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalClientRequestToFetch; } });
+Object.defineProperty(exports, "universalClientResponseFromFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalClientResponseFromFetch; } });
+Object.defineProperty(exports, "universalServerRequestFromFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalServerRequestFromFetch; } });
+Object.defineProperty(exports, "universalServerResponseToFetch", { enumerable: true, get: function () { return universal_fetch_js_1.universalServerResponseToFetch; } });
+var run_call_js_1 = require("./run-call.js");
+Object.defineProperty(exports, "runUnaryCall", { enumerable: true, get: function () { return run_call_js_1.runUnaryCall; } });
+Object.defineProperty(exports, "runStreamingCall", { enumerable: true, get: function () { return run_call_js_1.runStreamingCall; } });
+// 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 serialization_js_1 = require("./serialization.js");
+Object.defineProperty(exports, "createMethodSerializationLookup", { enumerable: true, get: function () { return serialization_js_1.createMethodSerializationLookup; } });
+Object.defineProperty(exports, "createClientMethodSerializers", { enumerable: true, get: function () { return serialization_js_1.createClientMethodSerializers; } });
+Object.defineProperty(exports, "getJsonOptions", { enumerable: true, get: function () { return serialization_js_1.getJsonOptions; } });
+Object.defineProperty(exports, "limitSerialization", { enumerable: true, get: function () { return serialization_js_1.limitSerialization; } });
+var limit_io_js_1 = require("./limit-io.js");
+Object.defineProperty(exports, "validateReadWriteMaxBytes", { enumerable: true, get: function () { return limit_io_js_1.validateReadWriteMaxBytes; } });
+var envelope_js_1 = require("./envelope.js");
+Object.defineProperty(exports, "encodeEnvelope", { enumerable: true, get: function () { return envelope_js_1.encodeEnvelope; } });
+Object.defineProperty(exports, "encodeEnvelopes", { enumerable: true, get: function () { return envelope_js_1.encodeEnvelopes; } });
+Object.defineProperty(exports, "envelopeDecompress", { enumerable: true, get: function () { return envelope_js_1.envelopeDecompress; } });
+Object.defineProperty(exports, "envelopeCompress", { enumerable: true, get: function () { return envelope_js_1.envelopeCompress; } });
+Object.defineProperty(exports, "createEnvelopeReadableStream", { enumerable: true, get: function () { return envelope_js_1.createEnvelopeReadableStream; } });
+var compression_js_1 = require("./compression.js");
+Object.defineProperty(exports, "compressedFlag", { enumerable: true, get: function () { return compression_js_1.compressedFlag; } });
+Object.defineProperty(exports, "compressionNegotiate", { enumerable: true, get: function () { return compression_js_1.compressionNegotiate; } });
+var async_iterable_js_1 = require("./async-iterable.js");
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return async_iterable_js_1.pipe; } });
+Object.defineProperty(exports, "transformCatch", { enumerable: true, get: function () { return async_iterable_js_1.transformCatch; } });
+Object.defineProperty(exports, "transformCatchFinally", { enumerable: true, get: function () { return async_iterable_js_1.transformCatchFinally; } });
+Object.defineProperty(exports, "transformAppend", { enumerable: true, get: function () { return async_iterable_js_1.transformAppend; } });
+Object.defineProperty(exports, "transformPrepend", { enumerable: true, get: function () { return async_iterable_js_1.transformPrepend; } });
+Object.defineProperty(exports, "transformReadAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.transformReadAllBytes; } });
+Object.defineProperty(exports, "transformCompressEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformCompressEnvelope; } });
+Object.defineProperty(exports, "transformDecompressEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformDecompressEnvelope; } });
+Object.defineProperty(exports, "transformJoinEnvelopes", { enumerable: true, get: function () { return async_iterable_js_1.transformJoinEnvelopes; } });
+Object.defineProperty(exports, "transformSplitEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformSplitEnvelope; } });
+Object.defineProperty(exports, "transformSerializeEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformSerializeEnvelope; } });
+Object.defineProperty(exports, "transformParseEnvelope", { enumerable: true, get: function () { return async_iterable_js_1.transformParseEnvelope; } });
+Object.defineProperty(exports, "pipeTo", { enumerable: true, get: function () { return async_iterable_js_1.pipeTo; } });
+Object.defineProperty(exports, "sinkAll", { enumerable: true, get: function () { return async_iterable_js_1.sinkAll; } });
+Object.defineProperty(exports, "sinkAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.sinkAllBytes; } });
+Object.defineProperty(exports, "makeIterableAbortable", { enumerable: true, get: function () { return async_iterable_js_1.makeIterableAbortable; } });
+Object.defineProperty(exports, "createWritableIterable", { enumerable: true, get: function () { return async_iterable_js_1.createWritableIterable; } });
+Object.defineProperty(exports, "createAsyncIterable", { enumerable: true, get: function () { return async_iterable_js_1.createAsyncIterable; } });
+Object.defineProperty(exports, "readAllBytes", { enumerable: true, get: function () { return async_iterable_js_1.readAllBytes; } });
+Object.defineProperty(exports, "untilFirst", { enumerable: true, get: function () { return async_iterable_js_1.untilFirst; } });
+var content_type_matcher_js_1 = require("./content-type-matcher.js");
+Object.defineProperty(exports, "contentTypeMatcher", { enumerable: true, get: function () { return content_type_matcher_js_1.contentTypeMatcher; } });
+var invoke_implementation_js_1 = require("./invoke-implementation.js");
+Object.defineProperty(exports, "invokeUnaryImplementation", { enumerable: true, get: function () { return invoke_implementation_js_1.invokeUnaryImplementation; } });
+Object.defineProperty(exports, "transformInvokeImplementation", { enumerable: true, get: function () { return invoke_implementation_js_1.transformInvokeImplementation; } });
+var signals_js_1 = require("./signals.js");
+Object.defineProperty(exports, "createLinkedAbortController", { enumerable: true, get: function () { return signals_js_1.createLinkedAbortController; } });
+Object.defineProperty(exports, "getAbortSignalReason", { enumerable: true, get: function () { return signals_js_1.getAbortSignalReason; } });
+Object.defineProperty(exports, "createDeadlineSignal", { enumerable: true, get: function () { return signals_js_1.createDeadlineSignal; } });
+var universal_js_1 = require("./universal.js");
+Object.defineProperty(exports, "assertByteStreamRequest", { enumerable: true, get: function () { return universal_js_1.assertByteStreamRequest; } });
+Object.defineProperty(exports, "uResponseOk", { enumerable: true, get: function () { return universal_js_1.uResponseOk; } });
+Object.defineProperty(exports, "uResponseNotFound", { enumerable: true, get: function () { return universal_js_1.uResponseNotFound; } });
+Object.defineProperty(exports, "uResponseUnsupportedMediaType", { enumerable: true, get: function () { return universal_js_1.uResponseUnsupportedMediaType; } });
+Object.defineProperty(exports, "uResponseMethodNotAllowed", { enumerable: true, get: function () { return universal_js_1.uResponseMethodNotAllowed; } });
+Object.defineProperty(exports, "uResponseVersionNotSupported", { enumerable: true, get: function () { return universal_js_1.uResponseVersionNotSupported; } });
+var universal_handler_js_1 = require("./universal-handler.js");
+Object.defineProperty(exports, "validateUniversalHandlerOptions", { enumerable: true, get: function () { return universal_handler_js_1.validateUniversalHandlerOptions; } });
+Object.defineProperty(exports, "createUniversalServiceHandlers", { enumerable: true, get: function () { return universal_handler_js_1.createUniversalServiceHandlers; } });
+Object.defineProperty(exports, "createUniversalMethodHandler", { enumerable: true, get: function () { return universal_handler_js_1.createUniversalMethodHandler; } });
+var protocol_headers_js_1 = require("./protocol-headers.js");
+Object.defineProperty(exports, "mergeNonProtocolHeaders", { enumerable: true, get: function () { return protocol_headers_js_1.mergeNonProtocolHeaders; } });

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

@@ -0,0 +1,33 @@
+import type { DescMessage, MessageShape } from "@bufbuild/protobuf";
+import type { HandlerContext, MethodImplSpec } from "../implementation.js";
+import type { AsyncIterableTransform } from "./async-iterable.js";
+import type { Interceptor } from "../interceptor.js";
+/**
+ * Invoke the implementation for a streaming RPC, unless a request gate rejects
+ * the call first.
+ *
+ * The gate runs before the request body is received. If it throws, the returned
+ * iterator rejects with its error, so the caller's response pipeline serializes
+ * it without reading the body; otherwise the implementation's iterator is
+ * returned.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function applyRequestGate<T>(context: HandlerContext, requestGate: ((context: HandlerContext) => void | Promise<void>) | undefined, invoke: () => AsyncIterable<T>): Promise<AsyncIterator<T>>;
+/**
+ * Invoke a user-provided implementation of a unary RPC. Returns a normalized
+ * output message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function invokeUnaryImplementation<I extends DescMessage, O extends DescMessage>(spec: MethodImplSpec<I, O> & {
+    kind: "unary";
+}, context: HandlerContext, input: MessageShape<I>, interceptors: Interceptor[]): Promise<MessageShape<O>>;
+/**
+ * Return an AsyncIterableTransform that invokes a user-provided implementation,
+ * giving it input from an asynchronous iterable, and returning its output as an
+ * asynchronous iterable.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function transformInvokeImplementation<I extends DescMessage, O extends DescMessage>(spec: MethodImplSpec<I, O>, context: HandlerContext, interceptors: Interceptor[]): AsyncIterableTransform<MessageShape<I>, MessageShape<O>>;

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

@@ -0,0 +1,178 @@
+"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 __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]); }
+};
+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 __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyRequestGate = applyRequestGate;
+exports.invokeUnaryImplementation = invokeUnaryImplementation;
+exports.transformInvokeImplementation = transformInvokeImplementation;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const async_iterable_js_1 = require("./async-iterable.js");
+const normalize_js_1 = require("./normalize.js");
+const interceptor_js_1 = require("../interceptor.js");
+/**
+ * Invoke the implementation for a streaming RPC, unless a request gate rejects
+ * the call first.
+ *
+ * The gate runs before the request body is received. If it throws, the returned
+ * iterator rejects with its error, so the caller's response pipeline serializes
+ * it without reading the body; otherwise the implementation's iterator is
+ * returned.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function applyRequestGate(context, requestGate, invoke) {
+    if (requestGate !== undefined) {
+        try {
+            await requestGate(context);
+        }
+        catch (reason) {
+            return { next: () => Promise.reject(reason) };
+        }
+    }
+    return invoke()[Symbol.asyncIterator]();
+}
+/**
+ * Invoke a user-provided implementation of a unary RPC. Returns a normalized
+ * output message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function invokeUnaryImplementation(spec, context, input, interceptors) {
+    const anyFn = async (req) => {
+        return Object.assign({ message: (0, normalize_js_1.normalize)(spec.method.output, await spec.impl(req.message, mergeRequest(context, req))), stream: false, method: spec.method }, responseCommon(context, spec));
+    };
+    const next = (0, interceptor_js_1.applyInterceptors)(anyFn, interceptors);
+    const { message, header, trailer } = await next(Object.assign({ stream: false, message: input, method: spec.method }, requestCommon(context, spec)));
+    copyHeaders(header, context.responseHeader);
+    copyHeaders(trailer, context.responseTrailer);
+    return message;
+}
+/**
+ * Return an AsyncIterableTransform that invokes a user-provided implementation,
+ * giving it input from an asynchronous iterable, and returning its output as an
+ * asynchronous iterable.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function transformInvokeImplementation(spec, context, interceptors) {
+    switch (spec.kind) {
+        case "unary":
+            return function unary(input) {
+                return __asyncGenerator(this, arguments, function* unary_1() {
+                    yield yield __await(yield __await(invokeUnaryImplementation(spec, context, yield __await(ensureSingle(input, "unary")), interceptors)));
+                });
+            };
+        case "server_streaming": {
+            return function serverStreaming(input) {
+                return invokeStreamImplementation(spec, context, input, interceptors, async (req) => {
+                    const output = (0, normalize_js_1.normalizeIterable)(spec.method.output, spec.impl(await ensureSingle(req.message, "server-streaming"), mergeRequest(context, req)));
+                    return Object.assign({ stream: true, message: output, method: spec.method }, responseCommon(context, spec));
+                });
+            };
+        }
+        case "client_streaming": {
+            return function clientStreaming(input) {
+                return invokeStreamImplementation(spec, context, input, interceptors, async (req) => {
+                    return Object.assign({ message: (0, async_iterable_js_1.createAsyncIterable)([
+                            (0, normalize_js_1.normalize)(spec.method.output, await spec.impl(req.message, mergeRequest(context, req))),
+                        ]), stream: true, method: spec.method }, responseCommon(context, spec));
+                });
+            };
+        }
+        case "bidi_streaming":
+            return function biDiStreaming(input) {
+                return invokeStreamImplementation(spec, context, input, interceptors, (req) => {
+                    return Promise.resolve(Object.assign({ message: (0, normalize_js_1.normalizeIterable)(spec.method.output, spec.impl(req.message, mergeRequest(context, req))), stream: true, method: spec.method }, responseCommon(context, spec)));
+                });
+            };
+    }
+}
+function invokeStreamImplementation(spec, context, input, interceptors, anyFn) {
+    return __asyncGenerator(this, arguments, function* invokeStreamImplementation_1() {
+        const next = (0, interceptor_js_1.applyInterceptors)(anyFn, interceptors);
+        const { message, header, trailer } = yield __await(next(Object.assign({ stream: true, message: input, method: spec.method }, requestCommon(context, spec))));
+        copyHeaders(header, context.responseHeader);
+        yield __await(yield* __asyncDelegator(__asyncValues(message)));
+        copyHeaders(trailer, context.responseTrailer);
+    });
+}
+async function ensureSingle(iterable, method) {
+    const it = iterable[Symbol.asyncIterator]();
+    const first = await it.next();
+    if (first.done === true) {
+        throw new connect_error_js_1.ConnectError(`protocol error: missing input message for ${method} method`, code_js_1.Code.Unimplemented);
+    }
+    const second = await it.next();
+    if (second.done !== true) {
+        throw new connect_error_js_1.ConnectError(`protocol error: received extra input message for ${method} method`, code_js_1.Code.Unimplemented);
+    }
+    return first.value;
+}
+function requestCommon(context, spec) {
+    return {
+        requestMethod: context.requestMethod,
+        url: context.url,
+        signal: context.signal,
+        header: context.requestHeader,
+        service: spec.method.parent,
+        contextValues: context.values,
+    };
+}
+function responseCommon(context, spec) {
+    return {
+        service: spec.method.parent,
+        header: context.responseHeader,
+        trailer: context.responseTrailer,
+    };
+}
+function mergeRequest(context, req) {
+    return Object.assign(Object.assign({}, context), { service: req.service, requestHeader: req.header, signal: req.signal, values: req.contextValues });
+}
+function copyHeaders(from, to) {
+    if (from === to) {
+        return;
+    }
+    to.forEach((_, key) => {
+        to.delete(key);
+    });
+    from.forEach((value, key) => {
+        to.set(key, value);
+    });
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Asserts that the options writeMaxBytes, readMaxBytes, and compressMinBytes
+ * are within sane limits, and returns default values where no value is
+ * provided.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateReadWriteMaxBytes(readMaxBytes: number | undefined, writeMaxBytes: number | undefined, compressMinBytes: number | undefined): {
+    readMaxBytes: number;
+    writeMaxBytes: number;
+    compressMinBytes: number;
+};
+/**
+ * Raise an error ResourceExhausted if more than writeMaxByte are written.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function assertWriteMaxBytes(writeMaxBytes: number, bytesWritten: number): void;
+/**
+ * Raise an error ResourceExhausted if more than readMaxBytes are read.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function assertReadMaxBytes(readMaxBytes: number, bytesRead: number, totalSizeKnown?: boolean): void;

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

@@ -0,0 +1,80 @@
+"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.validateReadWriteMaxBytes = validateReadWriteMaxBytes;
+exports.assertWriteMaxBytes = assertWriteMaxBytes;
+exports.assertReadMaxBytes = assertReadMaxBytes;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * At most, allow ~4GiB to be received or sent per message.
+ * zlib used by Node.js caps maxOutputLength at this value. It also happens to
+ * be the maximum theoretical message size supported by protobuf-es.
+ */
+const maxReadMaxBytes = 0xffffffff;
+const maxWriteMaxBytes = maxReadMaxBytes;
+/**
+ * The default value for the compressMinBytes option. The CPU cost of compressing
+ * very small messages usually isn't worth the small reduction in network I/O, so
+ * the default value is 1 kibibyte.
+ */
+const defaultCompressMinBytes = 1024;
+/**
+ * Asserts that the options writeMaxBytes, readMaxBytes, and compressMinBytes
+ * are within sane limits, and returns default values where no value is
+ * provided.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function validateReadWriteMaxBytes(readMaxBytes, writeMaxBytes, compressMinBytes) {
+    writeMaxBytes !== null && writeMaxBytes !== void 0 ? writeMaxBytes : (writeMaxBytes = maxWriteMaxBytes);
+    readMaxBytes !== null && readMaxBytes !== void 0 ? readMaxBytes : (readMaxBytes = maxReadMaxBytes);
+    compressMinBytes !== null && compressMinBytes !== void 0 ? compressMinBytes : (compressMinBytes = defaultCompressMinBytes);
+    if (writeMaxBytes < 1 || writeMaxBytes > maxWriteMaxBytes) {
+        throw new connect_error_js_1.ConnectError(`writeMaxBytes ${writeMaxBytes} must be >= 1 and <= ${maxWriteMaxBytes}`, code_js_1.Code.Internal);
+    }
+    if (readMaxBytes < 1 || readMaxBytes > maxReadMaxBytes) {
+        throw new connect_error_js_1.ConnectError(`readMaxBytes ${readMaxBytes} must be >= 1 and <= ${maxReadMaxBytes}`, code_js_1.Code.Internal);
+    }
+    return {
+        readMaxBytes,
+        writeMaxBytes,
+        compressMinBytes,
+    };
+}
+/**
+ * Raise an error ResourceExhausted if more than writeMaxByte are written.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function assertWriteMaxBytes(writeMaxBytes, bytesWritten) {
+    if (bytesWritten > writeMaxBytes) {
+        throw new connect_error_js_1.ConnectError(`message size ${bytesWritten} is larger than configured writeMaxBytes ${writeMaxBytes}`, code_js_1.Code.ResourceExhausted);
+    }
+}
+/**
+ * Raise an error ResourceExhausted if more than readMaxBytes are read.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function assertReadMaxBytes(readMaxBytes, bytesRead, totalSizeKnown = false) {
+    if (bytesRead > readMaxBytes) {
+        let message = `message size is larger than configured readMaxBytes ${readMaxBytes}`;
+        if (totalSizeKnown) {
+            message = `message size ${bytesRead} is larger than configured readMaxBytes ${readMaxBytes}`;
+        }
+        throw new connect_error_js_1.ConnectError(message, code_js_1.Code.ResourceExhausted);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { DescMessage, MessageInitShape, MessageShape } from "@bufbuild/protobuf";
+/**
+ *  Takes a partial protobuf messages of the
+ *  specified message type as input, and returns full instances.
+ */
+export declare function normalize<Desc extends DescMessage>(desc: Desc, message: MessageInitShape<Desc>): MessageShape<Desc>;
+/**
+ * Takes an AsyncIterable of partial protobuf messages of the
+ * specified message type as input, and yields full instances.
+ */
+export declare function normalizeIterable<Desc extends DescMessage>(desc: Desc, input: AsyncIterable<MessageInitShape<Desc>>): AsyncIterable<MessageShape<Desc>>;

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

@@ -0,0 +1,55 @@
+"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.normalize = normalize;
+exports.normalizeIterable = normalizeIterable;
+const protobuf_1 = require("@bufbuild/protobuf");
+/**
+ *  Takes a partial protobuf messages of the
+ *  specified message type as input, and returns full instances.
+ */
+function normalize(desc, message) {
+    return (0, protobuf_1.create)(desc, message);
+}
+/**
+ * Takes an AsyncIterable of partial protobuf messages of the
+ * specified message type as input, and yields full instances.
+ */
+function normalizeIterable(desc, input) {
+    function transform(result) {
+        if (result.done === true) {
+            return result;
+        }
+        return {
+            done: result.done,
+            value: normalize(desc, result.value),
+        };
+    }
+    return {
+        [Symbol.asyncIterator]() {
+            const it = input[Symbol.asyncIterator]();
+            const res = {
+                next: () => it.next().then(transform),
+            };
+            if (it.throw !== undefined) {
+                res.throw = (e) => it.throw(e).then(transform);
+            }
+            if (it.return !== undefined) {
+                res.return = (v) => it.return(v).then(transform);
+            }
+            return res;
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { MethodImplSpec } from "../implementation.js";
+import type { UniversalHandler } from "./universal-handler.js";
+/**
+ * Creates a handler function for an RPC definition and an RPC implementation,
+ * for one specific protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface ProtocolHandlerFactory {
+    /**
+     * Create a new handler with the user-provided implementation of the procedure.
+     */
+    (spec: MethodImplSpec): UniversalHandler;
+    /**
+     * The name of the protocol that the created handlers implement.
+     */
+    protocolName: string;
+}

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

@@ -0,0 +1,15 @@
+"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 });

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

@@ -0,0 +1,9 @@
+/**
+ * Append all headers from `from` into `into`, skipping any protocol headers.
+ *
+ * Mirrors mergeNonProtocolHeaders in connect-go. Any changes to this method must be
+ * made there first.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function mergeNonProtocolHeaders(into: Headers, from: Headers): void;

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

@@ -0,0 +1,67 @@
+"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.mergeNonProtocolHeaders = mergeNonProtocolHeaders;
+const headers_js_1 = require("../protocol-connect/headers.js");
+const headers_js_2 = require("../protocol-grpc/headers.js");
+/**
+ * The set of HTTP header names that carry protocol-level information for the
+ * Connect, gRPC, and gRPC-Web protocols. These are reserved by the protocol
+ * implementation and are not considered user metadata.
+ *
+ * Mirrors protocolHeaders in connect-go. Any changes to this constant must be
+ * made there first.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+const protocolHeaders = new Set([
+    // HTTP headers.
+    headers_js_1.headerContentType,
+    headers_js_1.headerUnaryContentLength,
+    headers_js_1.headerUnaryEncoding,
+    headers_js_1.headerHost,
+    headers_js_1.headerUserAgent,
+    headers_js_1.headerTrailer,
+    headers_js_1.headerDate,
+    // Connect headers.
+    headers_js_1.headerUnaryAcceptEncoding,
+    headers_js_1.headerUnaryTrailerPrefix,
+    headers_js_1.headerStreamEncoding,
+    headers_js_1.headerStreamAcceptEncoding,
+    headers_js_1.headerTimeout,
+    headers_js_1.headerProtocolVersion,
+    // gRPC headers.
+    headers_js_2.headerEncoding,
+    headers_js_2.headerAcceptEncoding,
+    headers_js_2.headerTimeout,
+    headers_js_2.headerGrpcStatus,
+    headers_js_2.headerGrpcMessage,
+    headers_js_2.headerGrpcDetails,
+].map((name) => name.toLowerCase()));
+/**
+ * Append all headers from `from` into `into`, skipping any protocol headers.
+ *
+ * Mirrors mergeNonProtocolHeaders in connect-go. Any changes to this method must be
+ * made there first.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function mergeNonProtocolHeaders(into, from) {
+    from.forEach((value, key) => {
+        if (!protocolHeaders.has(key.toLowerCase())) {
+            into.append(key, value);
+        }
+    });
+}

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

@@ -0,0 +1,45 @@
+import type { DescMessage, MessageInitShape } from "@bufbuild/protobuf";
+import type { Interceptor, StreamRequest, StreamResponse, UnaryRequest, UnaryResponse } from "../interceptor.js";
+/**
+ * UnaryFn represents the client-side invocation of a unary RPC - a method
+ * that takes a single input message, and responds with a single output
+ * message.
+ * A Transport implements such a function, and makes it available to
+ * interceptors.
+ */
+type UnaryFn<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = (req: UnaryRequest<I, O>) => Promise<UnaryResponse<I, O>>;
+/**
+ * Runs a unary method with the given interceptors. Note that this function
+ * is only used when implementing a Transport.
+ */
+export declare function runUnaryCall<I extends DescMessage, O extends DescMessage>(opt: {
+    req: Omit<UnaryRequest<I, O>, "signal" | "message"> & {
+        message: MessageInitShape<I>;
+    };
+    next: UnaryFn<I, O>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    interceptors?: Interceptor[];
+}): Promise<UnaryResponse<I, O>>;
+/**
+ * StreamingFn represents the client-side invocation of a streaming RPC - a
+ * method that takes zero or more input messages, and responds with zero or
+ * more output messages.
+ * A Transport implements such a function, and makes it available to
+ * interceptors.
+ */
+type StreamingFn<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = (req: StreamRequest<I, O>) => Promise<StreamResponse<I, O>>;
+/**
+ * Runs a server-streaming method with the given interceptors. Note that this
+ * function is only used when implementing a Transport.
+ */
+export declare function runStreamingCall<I extends DescMessage, O extends DescMessage>(opt: {
+    req: Omit<StreamRequest<I, O>, "signal" | "message"> & {
+        message: AsyncIterable<MessageInitShape<I>>;
+    };
+    next: StreamingFn<I, O>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    interceptors?: Interceptor[];
+}): Promise<StreamResponse<I, O>>;
+export {};