openrod 0.0.0 → 0.1.0

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

@@ -0,0 +1,48 @@
+import { ConnectError } from "../connect-error.js";
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const compressedFlag = 1;
+/**
+ * Compression provides methods to compress and decompress data with
+ * a certain compression algorithm.
+ */
+export interface Compression {
+    /**
+     * The name of the compression algorithm.
+     */
+    name: string;
+    /**
+     * Compress a chunk of data.
+     */
+    compress: (bytes: Uint8Array) => Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Decompress a chunk of data.
+     *
+     * A zero-length chunk is acceptable, and will return a zero-length result.
+     *
+     * Raises a ConnectError with Code.InvalidArgument if the decompressed
+     * size exceeds readMaxBytes.
+     */
+    decompress: (bytes: Uint8Array, readMaxBytes: number) => Promise<Uint8Array<ArrayBuffer>>;
+}
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function compressionNegotiate(available: Compression[], requested: string | null, // e.g. the value of the Grpc-Encoding header
+accepted: string | null, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding: string): {
+    request: Compression | null;
+    response: Compression | null;
+    error?: ConnectError;
+};

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

@@ -0,0 +1,75 @@
+"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.compressedFlag = void 0;
+exports.compressionNegotiate = compressionNegotiate;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+/**
+ * compressedFlag indicates that the data in a EnvelopedMessage is
+ * compressed. It has the same meaning in the gRPC-Web, gRPC-HTTP2,
+ * and Connect protocols.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.compressedFlag = 0b00000001;
+/**
+ * Validates the request encoding and determines the accepted response encoding.
+ *
+ * Returns the request and response compression to use. If the client requested
+ * an encoding that is not available, the returned object contains an error that
+ * must be used for the response.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function compressionNegotiate(available, requested, // e.g. the value of the Grpc-Encoding header
+accepted, // e.g. the value of the Grpc-Accept-Encoding header
+headerNameAcceptEncoding) {
+    let request = null;
+    let response = null;
+    let error = undefined;
+    if (requested !== null && requested !== "identity") {
+        const found = available.find((c) => c.name === requested);
+        if (found) {
+            request = found;
+        }
+        else {
+            // To comply with https://github.com/grpc/grpc/blob/master/doc/compression.md
+            // and the Connect protocol, we return code "unimplemented" and specify
+            // acceptable compression(s).
+            const acceptable = available.map((c) => c.name).join(",");
+            error = new connect_error_js_1.ConnectError(`unknown compression "${requested}": supported encodings are ${acceptable}`, code_js_1.Code.Unimplemented, {
+                [headerNameAcceptEncoding]: acceptable,
+            });
+        }
+    }
+    if (accepted === null || accepted === "") {
+        // Support asymmetric compression. This logic follows
+        // https://github.com/grpc/grpc/blob/master/doc/compression.md and common
+        // sense.
+        response = request;
+    }
+    else {
+        const acceptNames = accepted.split(",").map((n) => n.trim());
+        for (const name of acceptNames) {
+            const found = available.find((c) => c.name === name);
+            if (found) {
+                response = found;
+                break;
+            }
+        }
+    }
+    return { request, response, error };
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/content-type-matcher.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A function that returns true if a given mime type is supported.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface ContentTypeMatcher {
+    (contentType: string | null): boolean;
+    supported: RegExp[];
+}
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function contentTypeMatcher(...supported: (RegExp | Pick<ContentTypeMatcher, "supported">)[]): ContentTypeMatcher;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/content-type-matcher.js

@@ -0,0 +1,43 @@
+"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.contentTypeMatcher = contentTypeMatcher;
+const contentTypeMatcherCacheSize = 1024;
+/**
+ * Create a function that returns true if the given mime type is supported.
+ * A mime type is supported when one of the regular expressions match.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function contentTypeMatcher(...supported) {
+    const cache = new Map();
+    const source = supported.reduce((previousValue, currentValue) => previousValue.concat("supported" in currentValue ? currentValue.supported : currentValue), []);
+    function match(contentType) {
+        if (contentType === null || contentType.length == 0) {
+            return false;
+        }
+        const cached = cache.get(contentType);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const ok = source.some((re) => re.test(contentType));
+        if (cache.size < contentTypeMatcherCacheSize) {
+            cache.set(contentType, ok);
+        }
+        return ok;
+    }
+    match.supported = source;
+    return match;
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/create-method-url.d.ts

@@ -0,0 +1,17 @@
+import type { DescMethod } from "@bufbuild/protobuf";
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+export declare function createMethodUrl(baseUrl: string | URL, method: DescMethod): string;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/create-method-url.js

@@ -0,0 +1,36 @@
+"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.createMethodUrl = createMethodUrl;
+/**
+ * Create a URL for the given RPC. This simply adds the qualified
+ * service name, a slash, and the method name to the path of the given
+ * baseUrl.
+ *
+ * For example, the baseUri https://example.com and method "Say" from
+ * the service example.ElizaService results in:
+ * https://example.com/example.ElizaService/Say
+ *
+ * This format is used by the protocols Connect, gRPC and Twirp.
+ *
+ * Note that this function also accepts a protocol-relative baseUrl.
+ * If given an empty string or "/" as a baseUrl, it returns just the
+ * path.
+ */
+function createMethodUrl(baseUrl, method) {
+    return baseUrl
+        .toString()
+        .replace(/\/?$/, `/${method.parent.typeName}/${method.name}`);
+}

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

@@ -0,0 +1,90 @@
+import type { Compression } from "./compression.js";
+/**
+ * Represents an Enveloped-Message of the Connect protocol.
+ * https://connectrpc.com/docs/protocol#streaming-rpcs
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export interface EnvelopedMessage {
+    /**
+     * Envelope-Flags, a set of 8 bitwise flags.
+     */
+    flags: number;
+    /**
+     * Raw data of the message that was enveloped.
+     */
+    data: Uint8Array;
+}
+/**
+ * Decodes chunks of raw bytes into enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export type EnvelopeDecoder = {
+    /**
+     * Decode enveloped messages.
+     *
+     * If the chunk is incomplete, buffer for subsequent calls.
+     *
+     * If a message exceeds `readMaxBytes`, raise an error. The decoder must be
+     * discarded.
+     */
+    decode(chunk: Uint8Array): EnvelopedMessage[];
+    /**
+     * Size of the buffer. Use this property to check for incomplete data.
+     */
+    readonly byteLength: number;
+    /**
+     * Maximum size for individual messages.
+     */
+    readonly readMaxBytes: number;
+};
+/**
+ * Create an EnvelopeDecoder. The `readMaxBytes` argument limits the maximum
+ * size for individual messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEnvelopeDecoder(readMaxBytes: number): EnvelopeDecoder;
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createEnvelopeReadableStream(stream: ReadableStream<Uint8Array>): ReadableStream<EnvelopedMessage>;
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeCompress(envelope: EnvelopedMessage, compression: Compression | null, compressMinBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function envelopeDecompress(envelope: EnvelopedMessage, compression: Compression | null, readMaxBytes: number): Promise<EnvelopedMessage>;
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelope(flags: number, data: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function encodeEnvelopes(...envelopes: EnvelopedMessage[]): Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,214 @@
+"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.createEnvelopeDecoder = createEnvelopeDecoder;
+exports.createEnvelopeReadableStream = createEnvelopeReadableStream;
+exports.envelopeCompress = envelopeCompress;
+exports.envelopeDecompress = envelopeDecompress;
+exports.encodeEnvelope = encodeEnvelope;
+exports.encodeEnvelopes = encodeEnvelopes;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const compression_js_1 = require("./compression.js");
+const limit_io_js_1 = require("./limit-io.js");
+/**
+ * Create an EnvelopeDecoder. The `readMaxBytes` argument limits the maximum
+ * size for individual messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createEnvelopeDecoder(readMaxBytes) {
+    return new EnvelopeDecoderImpl(readMaxBytes);
+}
+class EnvelopeDecoderImpl {
+    constructor(readMaxBytes) {
+        this.readMaxBytes = readMaxBytes;
+        // Envelope headers are 5 bytes: 1 byte for flags, 4 bytes message length
+        this.header = new Uint8Array(5);
+        this.headerView = new DataView(this.header.buffer);
+        this.buf = [];
+    }
+    get byteLength() {
+        return this.buf.reduce((a, b) => a + b.byteLength, 0);
+    }
+    decode(chunk) {
+        this.buf.push(chunk);
+        const envs = [];
+        for (;;) {
+            let env = this.pop();
+            if (!env) {
+                break;
+            }
+            envs.push(env);
+        }
+        return envs;
+    }
+    // consume an enveloped message
+    pop() {
+        if (!this.env) {
+            this.env = this.head();
+            if (!this.env) {
+                return undefined;
+            }
+        }
+        if (this.cons(this.env.data)) {
+            const env = this.env;
+            this.env = undefined;
+            return env;
+        }
+        return undefined;
+    }
+    // consume header
+    head() {
+        if (!this.cons(this.header)) {
+            return undefined;
+        }
+        const flags = this.headerView.getUint8(0); // first byte is flags
+        const length = this.headerView.getUint32(1); // 4 bytes message length
+        (0, limit_io_js_1.assertReadMaxBytes)(this.readMaxBytes, length, true);
+        return {
+            flags,
+            data: new Uint8Array(length),
+        };
+    }
+    // consume from buffer, fill target
+    cons(target) {
+        const wantLength = target.byteLength;
+        if (this.byteLength < wantLength) {
+            return false;
+        }
+        let offset = 0;
+        while (offset < wantLength) {
+            const chunk = this.buf.shift(); // we check length above
+            if (chunk.byteLength > wantLength - offset) {
+                target.set(chunk.subarray(0, wantLength - offset), offset);
+                this.buf.unshift(chunk.subarray(wantLength - offset));
+                offset += wantLength - offset;
+            }
+            else {
+                target.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+        }
+        return true;
+    }
+}
+/**
+ * Create a WHATWG ReadableStream of enveloped messages from a ReadableStream
+ * of bytes.
+ *
+ * Ideally, this would simply be a TransformStream, but ReadableStream.pipeThrough
+ * does not have the necessary availability at this time.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createEnvelopeReadableStream(stream) {
+    let reader;
+    const buffer = createEnvelopeDecoder(0xffffffff);
+    return new ReadableStream({
+        start() {
+            reader = stream.getReader();
+        },
+        async pull(controller) {
+            let enqueuedOnce = false;
+            while (!enqueuedOnce) {
+                const result = await reader.read();
+                if (result.done) {
+                    if (buffer.byteLength > 0) {
+                        controller.error(new connect_error_js_1.ConnectError("protocol error: incomplete envelope", code_js_1.Code.InvalidArgument));
+                    }
+                    controller.close();
+                }
+                else {
+                    for (const env of buffer.decode(result.value)) {
+                        controller.enqueue(env);
+                        enqueuedOnce = true;
+                    }
+                }
+            }
+        },
+    });
+}
+/**
+ * Compress an EnvelopedMessage.
+ *
+ * Raises Internal if an enveloped message is already compressed.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function envelopeCompress(envelope, compression, compressMinBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compression_js_1.compressedFlag) === compression_js_1.compressedFlag) {
+        throw new connect_error_js_1.ConnectError("invalid envelope, already compressed", code_js_1.Code.Internal);
+    }
+    if (compression && data.byteLength >= compressMinBytes) {
+        data = await compression.compress(data);
+        flags = flags | compression_js_1.compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Decompress an EnvelopedMessage.
+ *
+ * Raises InvalidArgument if an envelope is compressed, but compression is null.
+ *
+ * Relies on the provided Compression to raise ResourceExhausted if the
+ * *decompressed* message size is larger than readMaxBytes. If the envelope is
+ * not compressed, readMaxBytes is not honored.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+async function envelopeDecompress(envelope, compression, readMaxBytes) {
+    let { flags, data } = envelope;
+    if ((flags & compression_js_1.compressedFlag) === compression_js_1.compressedFlag) {
+        if (!compression) {
+            throw new connect_error_js_1.ConnectError("received compressed envelope, but do not know how to decompress", code_js_1.Code.Internal);
+        }
+        data = await compression.decompress(data, readMaxBytes);
+        flags = flags ^ compression_js_1.compressedFlag;
+    }
+    return { data, flags };
+}
+/**
+ * Encode a single enveloped message.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function encodeEnvelope(flags, data) {
+    const bytes = new Uint8Array(data.length + 5);
+    bytes.set(data, 5);
+    const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    v.setUint8(0, flags); // first byte is flags
+    v.setUint32(1, data.length); // 4 bytes message length
+    return bytes;
+}
+/**
+ * Encode a set of enveloped messages.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function encodeEnvelopes(...envelopes) {
+    const len = envelopes.reduce((previousValue, currentValue) => previousValue + currentValue.data.length + 5, 0);
+    const bytes = new Uint8Array(len);
+    const v = new DataView(bytes.buffer);
+    let offset = 0;
+    for (const e of envelopes) {
+        v.setUint8(offset, e.flags); // first byte is flags
+        v.setUint32(offset + 1, e.data.length); // 4 bytes message length
+        bytes.set(e.data, offset + 5);
+        offset += e.data.length + 5;
+    }
+    return bytes;
+}

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

@@ -0,0 +1,25 @@
+export { createMethodUrl } from "./create-method-url.js";
+export type { UniversalClientFn, UniversalClientRequest, UniversalClientResponse, UniversalHandlerFn, UniversalServerRequest, UniversalServerResponse, } from "./universal.js";
+export type { Compression } from "./compression.js";
+export type { UniversalHandler } from "./universal-handler.js";
+export { createUniversalHandlerClient } from "./universal-handler-client.js";
+export { createFetchClient, createFetchHandler, universalClientRequestToFetch, universalClientResponseFromFetch, universalServerRequestFromFetch, universalServerResponseToFetch, } from "./universal-fetch.js";
+export { runUnaryCall, runStreamingCall } from "./run-call.js";
+export { createMethodSerializationLookup, createClientMethodSerializers, getJsonOptions, limitSerialization, } from "./serialization.js";
+export type { Serialization, MethodSerializationLookup, } from "./serialization.js";
+export { validateReadWriteMaxBytes } from "./limit-io.js";
+export { encodeEnvelope, encodeEnvelopes, envelopeDecompress, envelopeCompress, createEnvelopeReadableStream, } from "./envelope.js";
+export type { EnvelopedMessage } from "./envelope.js";
+export { compressedFlag, compressionNegotiate } from "./compression.js";
+export { pipe, transformCatch, transformCatchFinally, transformAppend, transformPrepend, transformReadAllBytes, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformSplitEnvelope, transformSerializeEnvelope, transformParseEnvelope, pipeTo, sinkAll, sinkAllBytes, makeIterableAbortable, createWritableIterable, createAsyncIterable, readAllBytes, untilFirst, } from "./async-iterable.js";
+export type { AsyncIterableTransform, AsyncIterableSink, WritableIterable, } from "./async-iterable.js";
+export { contentTypeMatcher } from "./content-type-matcher.js";
+export type { ContentTypeMatcher } from "./content-type-matcher.js";
+export { invokeUnaryImplementation, transformInvokeImplementation, } from "./invoke-implementation.js";
+export { createLinkedAbortController, getAbortSignalReason, createDeadlineSignal, } from "./signals.js";
+export { assertByteStreamRequest, uResponseOk, uResponseNotFound, uResponseUnsupportedMediaType, uResponseMethodNotAllowed, uResponseVersionNotSupported, } from "./universal.js";
+export { validateUniversalHandlerOptions, createUniversalServiceHandlers, createUniversalMethodHandler, } from "./universal-handler.js";
+export type { UniversalHandlerOptions } from "./universal-handler.js";
+export type { ProtocolHandlerFactory } from "./protocol-handler-factory.js";
+export type { CommonTransportOptions } from "./transport-options.js";
+export { mergeNonProtocolHeaders } from "./protocol-headers.js";