openrod 0.0.0 → 0.1.0

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

@@ -0,0 +1,173 @@
+// 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; }
+};
+import { ConnectError } from "../connect-error.js";
+import { Code } from "../code.js";
+import { createAsyncIterable } from "./async-iterable.js";
+import { normalize, normalizeIterable } from "./normalize.js";
+import { applyInterceptors } 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 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.
+ */
+export async function invokeUnaryImplementation(spec, context, input, interceptors) {
+    const anyFn = async (req) => {
+        return Object.assign({ message: normalize(spec.method.output, await spec.impl(req.message, mergeRequest(context, req))), stream: false, method: spec.method }, responseCommon(context, spec));
+    };
+    const next = 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.
+ */
+export 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 = 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: createAsyncIterable([
+                            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: 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 = 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 ConnectError(`protocol error: missing input message for ${method} method`, Code.Unimplemented);
+    }
+    const second = await it.next();
+    if (second.done !== true) {
+        throw new ConnectError(`protocol error: received extra input message for ${method} method`, 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/esm/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/esm/protocol/limit-io.js

@@ -0,0 +1,75 @@
+// 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 { ConnectError } from "../connect-error.js";
+import { Code } from "../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.
+ */
+export 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 ConnectError(`writeMaxBytes ${writeMaxBytes} must be >= 1 and <= ${maxWriteMaxBytes}`, Code.Internal);
+    }
+    if (readMaxBytes < 1 || readMaxBytes > maxReadMaxBytes) {
+        throw new ConnectError(`readMaxBytes ${readMaxBytes} must be >= 1 and <= ${maxReadMaxBytes}`, Code.Internal);
+    }
+    return {
+        readMaxBytes,
+        writeMaxBytes,
+        compressMinBytes,
+    };
+}
+/**
+ * Raise an error ResourceExhausted if more than writeMaxByte are written.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function assertWriteMaxBytes(writeMaxBytes, bytesWritten) {
+    if (bytesWritten > writeMaxBytes) {
+        throw new ConnectError(`message size ${bytesWritten} is larger than configured writeMaxBytes ${writeMaxBytes}`, Code.ResourceExhausted);
+    }
+}
+/**
+ * Raise an error ResourceExhausted if more than readMaxBytes are read.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export 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 ConnectError(message, Code.ResourceExhausted);
+    }
+}

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

@@ -0,0 +1,51 @@
+// 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 { create } from "@bufbuild/protobuf";
+/**
+ *  Takes a partial protobuf messages of the
+ *  specified message type as input, and returns full instances.
+ */
+export function normalize(desc, message) {
+    return create(desc, message);
+}
+/**
+ * Takes an AsyncIterable of partial protobuf messages of the
+ * specified message type as input, and yields full instances.
+ */
+export 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/esm/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/esm/protocol/protocol-handler-factory.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

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

@@ -0,0 +1,64 @@
+// 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, headerProtocolVersion as headerConnectProtocolVersion, headerStreamAcceptEncoding as headerConnectStreamAcceptEncoding, headerStreamEncoding as headerConnectStreamEncoding, headerTimeout as headerConnectTimeout, headerUnaryAcceptEncoding, headerUnaryContentLength, headerUnaryEncoding, headerUnaryTrailerPrefix as headerConnectUnaryTrailerPrefix, headerUserAgent, headerHost, headerTrailer, headerDate, } from "../protocol-connect/headers.js";
+import { headerAcceptEncoding as headerGrpcAcceptEncoding, headerEncoding as headerGrpcEncoding, headerGrpcDetails, headerGrpcMessage, headerGrpcStatus, headerTimeout as headerGrpcTimeout, } from "../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.
+    headerContentType,
+    headerUnaryContentLength,
+    headerUnaryEncoding,
+    headerHost,
+    headerUserAgent,
+    headerTrailer,
+    headerDate,
+    // Connect headers.
+    headerUnaryAcceptEncoding,
+    headerConnectUnaryTrailerPrefix,
+    headerConnectStreamEncoding,
+    headerConnectStreamAcceptEncoding,
+    headerConnectTimeout,
+    headerConnectProtocolVersion,
+    // gRPC headers.
+    headerGrpcEncoding,
+    headerGrpcAcceptEncoding,
+    headerGrpcTimeout,
+    headerGrpcStatus,
+    headerGrpcMessage,
+    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.
+ */
+export function mergeNonProtocolHeaders(into, from) {
+    from.forEach((value, key) => {
+        if (!protocolHeaders.has(key.toLowerCase())) {
+            into.append(key, value);
+        }
+    });
+}

package/node_modules/@connectrpc/connect/dist/esm/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 {};

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

@@ -0,0 +1,121 @@
+// 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 { applyInterceptors } from "../interceptor.js";
+import { ConnectError } from "../connect-error.js";
+import { createDeadlineSignal, createLinkedAbortController, getAbortSignalReason, } from "./signals.js";
+import { normalize, normalizeIterable } from "./normalize.js";
+import { Code } from "../code.js";
+/**
+ * Runs a unary method with the given interceptors. Note that this function
+ * is only used when implementing a Transport.
+ */
+export function runUnaryCall(opt) {
+    const next = applyInterceptors(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: normalize(opt.req.method.input, opt.req.message), signal });
+    return next(req).then((res) => {
+        done();
+        return res;
+    }, abort);
+}
+/**
+ * Runs a server-streaming method with the given interceptors. Note that this
+ * function is only used when implementing a Transport.
+ */
+export function runStreamingCall(opt) {
+    const next = applyInterceptors(opt.next, opt.interceptors);
+    const [signal, abort, done] = setupSignal(opt);
+    const req = Object.assign(Object.assign({}, opt.req), { message: normalizeIterable(opt.req.method.input, opt.req.message), signal });
+    let doneCalled = false;
+    // Call return on the request iterable to indicate
+    // that we will no longer consume it and it should
+    // cleanup any allocated resources.
+    signal.addEventListener("abort", function () {
+        var _a, _b;
+        const it = opt.req.message[Symbol.asyncIterator]();
+        // If the signal is aborted due to an error, we want to throw
+        // the error to the request iterator.
+        if (!doneCalled) {
+            (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, this.reason).catch(() => {
+                // throw returns a promise, which we don't care about.
+                //
+                // Uncaught promises are thrown at sometime/somewhere by the event loop,
+                // this is to ensure error is caught and ignored.
+            });
+        }
+        (_b = it.return) === null || _b === void 0 ? void 0 : _b.call(it).catch(() => {
+            // return returns a promise, which we don't care about.
+            //
+            // Uncaught promises are thrown at sometime/somewhere by the event loop,
+            // this is to ensure error is caught and ignored.
+        });
+    });
+    return next(req).then((res) => {
+        return Object.assign(Object.assign({}, res), { message: {
+                [Symbol.asyncIterator]() {
+                    const it = res.message[Symbol.asyncIterator]();
+                    return {
+                        next() {
+                            if (!doneCalled && signal.aborted) {
+                                return abort(getAbortSignalReason(signal));
+                            }
+                            return it.next().then((r) => {
+                                if (r.done == true) {
+                                    doneCalled = true;
+                                    done();
+                                }
+                                return r;
+                            }, abort);
+                        },
+                        // We deliberately omit throw/return.
+                    };
+                },
+            } });
+    }, abort);
+}
+/**
+ * Create an AbortSignal for Transport implementations. The signal is available
+ * in UnaryRequest and StreamingRequest, and is triggered when the call is
+ * aborted (via a timeout or explicit cancellation), errored (e.g. when reading
+ * an error from the server from the wire), or finished successfully.
+ *
+ * Transport implementations can pass the signal to HTTP clients to ensure that
+ * there are no unused connections leak.
+ *
+ * Returns a tuple:
+ * [0]: The signal, which is also aborted if the optional deadline is reached.
+ * [1]: Function to call if the Transport encountered an error.
+ * [2]: Function to call if the Transport finished without an error.
+ */
+function setupSignal(opt) {
+    const { signal, cleanup } = createDeadlineSignal(opt.timeoutMs);
+    const controller = createLinkedAbortController(opt.signal, signal);
+    return [
+        controller.signal,
+        function abort(reason) {
+            // We peek at the signal because fetch() will throw an error on abort
+            // that discards the signal reason.
+            const e = controller.signal.aborted
+                ? ConnectError.from(getAbortSignalReason(controller.signal), Code.Canceled)
+                : ConnectError.from(reason);
+            controller.abort(e);
+            cleanup();
+            return Promise.reject(e);
+        },
+        function done() {
+            cleanup();
+            controller.abort();
+        },
+    ];
+}