@in-human-resources/backend-proto 0.1.4 → 0.1.6

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

@@ -0,0 +1,182 @@
+// Copyright 2021-2024 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 __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; }
+};
+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 = {}, 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 { validateResponseWithCompression } from "./validate-response.js";
+import { validateTrailer } from "./validate-trailer.js";
+import { Code } from "../code.js";
+import { ConnectError } from "../connect-error.js";
+import { pipe, createAsyncIterable, transformSerializeEnvelope, transformCompressEnvelope, transformJoinEnvelopes, pipeTo, 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 { headerGrpcStatus } from "./headers.js";
+/**
+ * Create a Transport for the gRPC protocol.
+ */
+export function createTransport(opt) {
+    return {
+        async unary(service, 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,
+                    url: createMethodUrl(opt.baseUrl, service, method),
+                    init: {},
+                    header: requestHeaderWithCompression(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression),
+                    contextValues: contextValues !== null && contextValues !== void 0 ? contextValues : createContextValues(),
+                    message,
+                },
+                next: async (req) => {
+                    const uRes = await opt.httpClient({
+                        url: req.url,
+                        method: "POST",
+                        header: req.header,
+                        signal: req.signal,
+                        body: pipe(createAsyncIterable([req.message]), transformSerializeEnvelope(serialization.getI(opt.useBinaryFormat)), transformCompressEnvelope(opt.sendCompression, opt.compressMinBytes), transformJoinEnvelopes(), {
+                            propagateDownStreamError: true,
+                        }),
+                    });
+                    const { compression, headerError } = validateResponseWithCompression(opt.acceptCompression, uRes.status, uRes.header);
+                    const message = await pipeTo(uRes.body, transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), transformParseEnvelope(serialization.getO(opt.useBinaryFormat)), async (iterable) => {
+                        var _a, e_1, _b, _c;
+                        let message;
+                        try {
+                            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = await iterable_1.next(), _a = iterable_1_1.done, !_a; _d = true) {
+                                _c = iterable_1_1.value;
+                                _d = false;
+                                const chunk = _c;
+                                if (message !== undefined) {
+                                    throw new ConnectError("protocol error: received extra output message for unary method", Code.Unimplemented);
+                                }
+                                message = chunk;
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = iterable_1.return)) await _b.call(iterable_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return message;
+                    }, { propagateDownStreamError: false });
+                    validateTrailer(uRes.trailer, uRes.header);
+                    if (message === undefined) {
+                        // Trailers only response
+                        if (headerError) {
+                            throw headerError;
+                        }
+                        throw new ConnectError("protocol error: missing output message for unary method", uRes.trailer.has(headerGrpcStatus)
+                            ? Code.Unimplemented
+                            : Code.Unknown);
+                    }
+                    if (headerError) {
+                        throw new ConnectError("protocol error: received output message for unary method with error status", Code.Unknown);
+                    }
+                    return {
+                        stream: false,
+                        service,
+                        method,
+                        header: uRes.header,
+                        message,
+                        trailer: uRes.trailer,
+                    };
+                },
+            });
+        },
+        async stream(service, method, signal, timeoutMs, header, input, contextValues) {
+            const serialization = createMethodSerializationLookup(method, opt.binaryOptions, opt.jsonOptions, opt);
+            timeoutMs =
+                timeoutMs === undefined
+                    ? opt.defaultTimeoutMs
+                    : timeoutMs <= 0
+                        ? undefined
+                        : timeoutMs;
+            return runStreamingCall({
+                interceptors: opt.interceptors,
+                signal,
+                timeoutMs,
+                req: {
+                    stream: true,
+                    service,
+                    method,
+                    url: createMethodUrl(opt.baseUrl, service, method),
+                    init: {},
+                    header: requestHeaderWithCompression(opt.useBinaryFormat, timeoutMs, header, opt.acceptCompression, opt.sendCompression),
+                    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, foundStatus, headerError } = validateResponseWithCompression(opt.acceptCompression, uRes.status, uRes.header);
+                    if (headerError) {
+                        throw headerError;
+                    }
+                    const res = Object.assign(Object.assign({}, req), { header: uRes.header, trailer: uRes.trailer, message: pipe(uRes.body, transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression !== null && compression !== void 0 ? compression : null, opt.readMaxBytes), transformParseEnvelope(serialization.getO(opt.useBinaryFormat)), function (iterable) {
+                            return __asyncGenerator(this, arguments, function* () {
+                                yield __await(yield* __asyncDelegator(__asyncValues(iterable)));
+                                if (!foundStatus) {
+                                    validateTrailer(uRes.trailer, uRes.header);
+                                }
+                            });
+                        }, { propagateDownStreamError: true }) });
+                    return res;
+                },
+            });
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+import { ConnectError } from "../connect-error.js";
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Validates response status and header for the gRPC protocol.
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponse(status: number, headers: Headers): {
+    foundStatus: boolean;
+    headerError: ConnectError | undefined;
+};
+/**
+ * Validates response status and header for the gRPC protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateResponseWithCompression(acceptCompression: Compression[], status: number, headers: Headers): {
+    foundStatus: boolean;
+    compression: Compression | undefined;
+    headerError: ConnectError | undefined;
+};

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

@@ -0,0 +1,71 @@
+// Copyright 2021-2024 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 { codeFromHttpStatus } from "./http-status.js";
+import { ConnectError } from "../connect-error.js";
+import { findTrailerError } from "./trailer-status.js";
+import { Code } from "../code.js";
+import { headerContentType, headerEncoding, headerGrpcStatus, } from "./headers.js";
+import { parseContentType } from "./content-type.js";
+/**
+ * Validates response status and header for the gRPC protocol.
+ * Throws a ConnectError if the header contains an error status,
+ * or if the HTTP status indicates an error.
+ *
+ * Returns an object that indicates whether a gRPC status was found
+ * in the response header. In this case, clients can not expect a
+ * trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponse(status, headers) {
+    if (status != 200) {
+        throw new ConnectError(`HTTP ${status}`, codeFromHttpStatus(status), headers);
+    }
+    const mimeType = headers.get(headerContentType);
+    const parsedType = parseContentType(mimeType);
+    if (parsedType == undefined) {
+        throw new ConnectError(`unsupported content type ${mimeType}`, Code.Unknown);
+    }
+    return {
+        foundStatus: headers.has(headerGrpcStatus),
+        headerError: findTrailerError(headers),
+    };
+}
+/**
+ * Validates response status and header for the gRPC protocol.
+ * This function is identical to validateResponse(), but also verifies
+ * that a given encoding header is acceptable.
+ *
+ * Returns an object with the response compression, and a boolean
+ * indicating whether a gRPC status was found in the response header
+ * (in this case, clients can not expect a trailer).
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateResponseWithCompression(acceptCompression, status, headers) {
+    const { foundStatus, headerError } = validateResponse(status, headers);
+    let compression;
+    const encoding = headers.get(headerEncoding);
+    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 {
+        foundStatus,
+        compression,
+        headerError,
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/validate-trailer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validates a trailer for the gRPC and the gRPC-web protocol.
+ *
+ * If the trailer contains an error status, a ConnectError is
+ * thrown. It will include trailer and header in the error's
+ * "metadata" property.
+ *
+ * Throws a ConnectError with code "internal" if neither the trailer
+ * nor the header contain the Grpc-Status field.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function validateTrailer(trailer: Headers, header: Headers): void;

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc/validate-trailer.js

@@ -0,0 +1,41 @@
+// Copyright 2021-2024 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 { ConnectError } from "../connect-error.js";
+import { headerGrpcStatus } from "./headers.js";
+import { findTrailerError } from "./trailer-status.js";
+/**
+ * Validates a trailer for the gRPC and the gRPC-web protocol.
+ *
+ * If the trailer contains an error status, a ConnectError is
+ * thrown. It will include trailer and header in the error's
+ * "metadata" property.
+ *
+ * Throws a ConnectError with code "internal" if neither the trailer
+ * nor the header contain the Grpc-Status field.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export function validateTrailer(trailer, header) {
+    const err = findTrailerError(trailer);
+    if (err) {
+        header.forEach((value, key) => {
+            err.metadata.append(key, value);
+        });
+        throw err;
+    }
+    if (!header.has(headerGrpcStatus) && !trailer.has(headerGrpcStatus)) {
+        throw new ConnectError("protocol error: missing status", Code.Internal);
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+// Copyright 2021-2024 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-web Content-Type header value.
+ * Note that this includes application/grpc-web-text with the additional base64
+ * encoding.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const contentTypeRegExp = /^application\/grpc-web(-text)?(?:\+(?:(json)(?:; ?charset=utf-?8)?|proto))?$/i;
+export const contentTypeProto = "application/grpc-web+proto";
+export const contentTypeJson = "application/grpc-web+json";
+/**
+ * Parse a gRPC-web Content-Type header value.
+ *
+ * @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 text = !!match[1];
+    const binary = !match[2];
+    return { text, binary };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/handler-factory.d.ts

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

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/handler-factory.js

@@ -0,0 +1,125 @@
+// Copyright 2021-2024 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";
+import { createHandlerContext } from "../implementation.js";
+import { createTrailerSerialization, trailerFlag } from "./trailer.js";
+import { headerAcceptEncoding, headerContentType, headerEncoding, headerGrpcStatus, headerTimeout, } from "./headers.js";
+import { contentTypeJson, contentTypeProto, contentTypeRegExp, parseContentType, } from "./content-type.js";
+import { parseTimeout } from "../protocol-grpc/parse-timeout.js";
+import { grpcStatusOk, setTrailerStatus, } from "../protocol-grpc/trailer-status.js";
+import { pipe, transformPrepend, transformSplitEnvelope, transformDecompressEnvelope, transformParseEnvelope, transformSerializeEnvelope, transformCatchFinally, transformCompressEnvelope, transformJoinEnvelopes, untilFirst, } from "../protocol/async-iterable.js";
+import { compressionNegotiate } from "../protocol/compression.js";
+import { contentTypeMatcher } from "../protocol/content-type-matcher.js";
+import { createMethodUrl } from "../protocol/create-method-url.js";
+import { transformInvokeImplementation } from "../protocol/invoke-implementation.js";
+import { createMethodSerializationLookup } from "../protocol/serialization.js";
+import { validateUniversalHandlerOptions } from "../protocol/universal-handler.js";
+import { assertByteStreamRequest, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseOk, } from "../protocol/universal.js";
+const protocolName = "grpc-web";
+const methodPost = "POST";
+/**
+ * Create a factory that creates gRPC-web handlers.
+ */
+export function createHandlerFactory(options) {
+    const opt = validateUniversalHandlerOptions(options);
+    const trailerSerialization = createTrailerSerialization();
+    function fact(spec) {
+        const h = createHandler(opt, trailerSerialization, spec);
+        return Object.assign(h, {
+            protocolNames: [protocolName],
+            allowedMethods: [methodPost],
+            supportedContentType: contentTypeMatcher(contentTypeRegExp),
+            requestPath: createMethodUrl("/", spec.service, spec.method),
+            service: spec.service,
+            method: spec.method,
+        });
+    }
+    fact.protocolName = protocolName;
+    return fact;
+}
+function createHandler(opt, trailerSerialization, spec) {
+    const serialization = createMethodSerializationLookup(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
+    return async function handle(req) {
+        assertByteStreamRequest(req);
+        const type = parseContentType(req.header.get(headerContentType));
+        if (type == undefined || type.text) {
+            return uResponseUnsupportedMediaType;
+        }
+        if (req.method !== methodPost) {
+            return uResponseMethodNotAllowed;
+        }
+        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
+        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headerContentType]: type.binary ? contentTypeProto : contentTypeJson,
+            }, responseTrailer: {
+                [headerGrpcStatus]: grpcStatusOk,
+            }, contextValues: req.contextValues }));
+        const compression = compressionNegotiate(opt.acceptCompression, req.header.get(headerEncoding), req.header.get(headerAcceptEncoding), headerAcceptEncoding);
+        if (compression.response) {
+            context.responseHeader.set(headerEncoding, compression.response.name);
+        }
+        // We split the pipeline into two parts: The request iterator, and the
+        // response iterator. We do this because the request iterator is responsible
+        // for parsing the request body, and we don't want write errors of the response
+        // iterator to affect the request iterator.
+        const inputIt = pipe(req.body, transformPrepend(() => {
+            // raise compression error to serialize it as a trailer status
+            if (compression.error)
+                throw compression.error;
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error)
+                throw timeout.error;
+            return undefined;
+        }), transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression.request, opt.readMaxBytes), transformParseEnvelope(serialization.getI(type.binary), trailerFlag));
+        const it = transformInvokeImplementation(spec, context, opt.interceptors)(inputIt)[Symbol.asyncIterator]();
+        const outputIt = pipe(
+        // We wrap the iterator in an async iterator to ensure that the
+        // abort signal is aborted when the iterator is done.
+        {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => it.next(),
+                    throw: (e) => {
+                        var _a, _b;
+                        context.abort(e);
+                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
+                    },
+                    return: (v) => {
+                        var _a, _b;
+                        context.abort();
+                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
+                    },
+                };
+            },
+        }, transformSerializeEnvelope(serialization.getO(type.binary)), transformCatchFinally((e) => {
+            context.abort();
+            if (e instanceof ConnectError) {
+                setTrailerStatus(context.responseTrailer, e);
+            }
+            else if (e !== undefined) {
+                setTrailerStatus(context.responseTrailer, new ConnectError("internal error", Code.Internal, undefined, undefined, e));
+            }
+            return {
+                flags: trailerFlag,
+                data: trailerSerialization.serialize(context.responseTrailer),
+            };
+        }), transformCompressEnvelope(compression.response, opt.compressMinBytes), transformJoinEnvelopes(), { propagateDownStreamError: true });
+        return Object.assign(Object.assign({}, uResponseOk), { 
+            // We wait for the first response body bytes before resolving, so that
+            // implementations have a chance to add headers before an adapter commits
+            // them to the wire.
+            body: await untilFirst(outputIt), header: context.responseHeader });
+    };
+}

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/headers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export { headerContentType, headerEncoding, headerAcceptEncoding, headerTimeout, headerGrpcStatus, headerGrpcMessage, headerStatusDetailsBin, headerUserAgent, } from "../protocol-grpc/headers.js";
+/**
+ * gRPC-web does not use the standard header User-Agent.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerXUserAgent = "X-User-Agent";
+/**
+ * The canonical grpc/grpc-web JavaScript implementation sets
+ * this request header with value "1".
+ * Some servers may rely on the header to identify gRPC-web
+ * requests. For example the proxy by improbable:
+ * https://github.com/improbable-eng/grpc-web/blob/53aaf4cdc0fede7103c1b06f0cfc560c003a5c41/go/grpcweb/wrapper.go#L231
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerXGrpcWeb = "X-Grpc-Web";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/headers.js

@@ -0,0 +1,33 @@
+// Copyright 2021-2024 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.
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export { headerContentType, headerEncoding, headerAcceptEncoding, headerTimeout, headerGrpcStatus, headerGrpcMessage, headerStatusDetailsBin, headerUserAgent, } from "../protocol-grpc/headers.js";
+/**
+ * gRPC-web does not use the standard header User-Agent.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const headerXUserAgent = "X-User-Agent";
+/**
+ * The canonical grpc/grpc-web JavaScript implementation sets
+ * this request header with value "1".
+ * Some servers may rely on the header to identify gRPC-web
+ * requests. For example the proxy by improbable:
+ * https://github.com/improbable-eng/grpc-web/blob/53aaf4cdc0fede7103c1b06f0cfc560c003a5c41/go/grpcweb/wrapper.go#L231
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export const headerXGrpcWeb = "X-Grpc-Web";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/index.d.ts

@@ -0,0 +1,8 @@
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { parseContentType, contentTypeRegExp, contentTypeProto, contentTypeJson, } from "./content-type.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerFlag, trailerParse, trailerSerialize, createTrailerSerialization, } from "./trailer.js";
+export { parseTimeout, setTrailerStatus, validateTrailer, grpcStatusOk, } from "../protocol-grpc/index.js";
+export * from "./headers.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/index.js

@@ -0,0 +1,26 @@
+// Copyright 2021-2024 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 { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+// 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 ^).
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { parseContentType, contentTypeRegExp, contentTypeProto, contentTypeJson, } from "./content-type.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerFlag, trailerParse, trailerSerialize, createTrailerSerialization, } from "./trailer.js";
+export { parseTimeout, setTrailerStatus, validateTrailer, grpcStatusOk, } from "../protocol-grpc/index.js";
+export * from "./headers.js";

package/gen/ts/node_modules/@connectrpc/connect/dist/esm/protocol-grpc-web/request-header.d.ts

@@ -0,0 +1,13 @@
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Creates headers for a gRPC-web request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeader(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, setUserAgent: boolean): Headers;
+/**
+ * Creates headers for a gRPC-web request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeaderWithCompression(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, acceptCompression: Compression[], sendCompression: Compression | null, setUserAgent: boolean): Headers;