openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/cjs/callback-client.js

@@ -0,0 +1,116 @@
+"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 __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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCallbackClient = createCallbackClient;
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_error_js_1 = require("./connect-error.js");
+const code_js_1 = require("./code.js");
+const any_client_js_1 = require("./any-client.js");
+const async_iterable_js_1 = require("./protocol/async-iterable.js");
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+function createCallbackClient(service, transport) {
+    return (0, any_client_js_1.makeAnyClient)(service, (method) => {
+        switch (method.methodKind) {
+            case "unary":
+                return createUnaryFn(transport, method);
+            case "server_streaming":
+                return createServerStreamingFn(transport, method);
+            default:
+                return null;
+        }
+    });
+}
+function createUnaryFn(transport, method) {
+    return (requestMessage, callback, options) => {
+        const abort = new AbortController();
+        options = wrapSignal(abort, options);
+        transport
+            .unary(method, abort.signal, options.timeoutMs, options.headers, requestMessage, options.contextValues)
+            .then((response) => {
+            var _a, _b;
+            (_a = options.onHeader) === null || _a === void 0 ? void 0 : _a.call(options, response.header);
+            (_b = options.onTrailer) === null || _b === void 0 ? void 0 : _b.call(options, response.trailer);
+            callback(undefined, response.message);
+        }, (reason) => {
+            const err = connect_error_js_1.ConnectError.from(reason, code_js_1.Code.Internal);
+            if (err.code === code_js_1.Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user.
+                return;
+            }
+            callback(err, (0, protobuf_1.create)(method.output));
+        });
+        return () => abort.abort();
+    };
+}
+function createServerStreamingFn(transport, method) {
+    return (input, onResponse, onClose, options) => {
+        const abort = new AbortController();
+        async function run() {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            options = wrapSignal(abort, options);
+            const response = await transport.stream(method, options.signal, options.timeoutMs, options.headers, (0, async_iterable_js_1.createAsyncIterable)([input]), options.contextValues);
+            (_d = options.onHeader) === null || _d === void 0 ? void 0 : _d.call(options, response.header);
+            try {
+                for (var _f = true, _g = __asyncValues(response.message), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const message = _c;
+                    onResponse(message);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            (_e = options.onTrailer) === null || _e === void 0 ? void 0 : _e.call(options, response.trailer);
+            onClose(undefined);
+        }
+        run().catch((reason) => {
+            const err = connect_error_js_1.ConnectError.from(reason, code_js_1.Code.Internal);
+            if (err.code === code_js_1.Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user,
+                // but do invoke the close-callback.
+                onClose(undefined);
+            }
+            else {
+                onClose(err);
+            }
+        });
+        return () => abort.abort();
+    };
+}
+function wrapSignal(abort, options) {
+    if (options === null || options === void 0 ? void 0 : options.signal) {
+        options.signal.addEventListener("abort", () => abort.abort());
+        if (options.signal.aborted) {
+            abort.abort();
+        }
+    }
+    return Object.assign(Object.assign({}, options), { signal: abort.signal });
+}

package/node_modules/@connectrpc/connect/dist/cjs/code.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Connect represents categories of errors as codes, and each code maps to a
+ * specific HTTP status code. The codes and their semantics were chosen to
+ * match gRPC. Only the codes below are valid — there are no user-defined
+ * codes.
+ *
+ * See the specification at https://connectrpc.com/docs/protocol#error-codes
+ * for details.
+ */
+export declare enum Code {
+    /**
+     * Canceled, usually by the user
+     */
+    Canceled = 1,
+    /**
+     * Unknown error
+     */
+    Unknown = 2,
+    /**
+     * Argument invalid regardless of system state
+     */
+    InvalidArgument = 3,
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    DeadlineExceeded = 4,
+    /**
+     * Entity not found.
+     */
+    NotFound = 5,
+    /**
+     * Entity already exists.
+     */
+    AlreadyExists = 6,
+    /**
+     * Operation not authorized.
+     */
+    PermissionDenied = 7,
+    /**
+     * Quota exhausted.
+     */
+    ResourceExhausted = 8,
+    /**
+     * Argument invalid in current system state.
+     */
+    FailedPrecondition = 9,
+    /**
+     * Operation aborted.
+     */
+    Aborted = 10,
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    OutOfRange = 11,
+    /**
+     * Operation not implemented or disabled.
+     */
+    Unimplemented = 12,
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Internal = 13,
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Unavailable = 14,
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    DataLoss = 15,
+    /**
+     * Request isn't authenticated.
+     */
+    Unauthenticated = 16
+}

package/node_modules/@connectrpc/connect/dist/cjs/code.js

@@ -0,0 +1,92 @@
+"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.Code = void 0;
+/**
+ * Connect represents categories of errors as codes, and each code maps to a
+ * specific HTTP status code. The codes and their semantics were chosen to
+ * match gRPC. Only the codes below are valid — there are no user-defined
+ * codes.
+ *
+ * See the specification at https://connectrpc.com/docs/protocol#error-codes
+ * for details.
+ */
+var Code;
+(function (Code) {
+    /**
+     * Canceled, usually by the user
+     */
+    Code[Code["Canceled"] = 1] = "Canceled";
+    /**
+     * Unknown error
+     */
+    Code[Code["Unknown"] = 2] = "Unknown";
+    /**
+     * Argument invalid regardless of system state
+     */
+    Code[Code["InvalidArgument"] = 3] = "InvalidArgument";
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    Code[Code["DeadlineExceeded"] = 4] = "DeadlineExceeded";
+    /**
+     * Entity not found.
+     */
+    Code[Code["NotFound"] = 5] = "NotFound";
+    /**
+     * Entity already exists.
+     */
+    Code[Code["AlreadyExists"] = 6] = "AlreadyExists";
+    /**
+     * Operation not authorized.
+     */
+    Code[Code["PermissionDenied"] = 7] = "PermissionDenied";
+    /**
+     * Quota exhausted.
+     */
+    Code[Code["ResourceExhausted"] = 8] = "ResourceExhausted";
+    /**
+     * Argument invalid in current system state.
+     */
+    Code[Code["FailedPrecondition"] = 9] = "FailedPrecondition";
+    /**
+     * Operation aborted.
+     */
+    Code[Code["Aborted"] = 10] = "Aborted";
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    Code[Code["OutOfRange"] = 11] = "OutOfRange";
+    /**
+     * Operation not implemented or disabled.
+     */
+    Code[Code["Unimplemented"] = 12] = "Unimplemented";
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Code[Code["Internal"] = 13] = "Internal";
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Code[Code["Unavailable"] = 14] = "Unavailable";
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    Code[Code["DataLoss"] = 15] = "DataLoss";
+    /**
+     * Request isn't authenticated.
+     */
+    Code[Code["Unauthenticated"] = 16] = "Unauthenticated";
+})(Code || (exports.Code = Code = {}));

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

@@ -0,0 +1,104 @@
+import { Code } from "./code.js";
+import type { Message, JsonValue, DescMessage, MessageShape, Registry, MessageInitShape } from "@bufbuild/protobuf";
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+export declare class ConnectError extends Error {
+    /**
+     * The Code for this error.
+     */
+    readonly code: Code;
+    /**
+     * A union of response headers and trailers associated with this error.
+     */
+    readonly metadata: Headers;
+    /**
+     * When an error is parsed from the wire, incoming error details are stored
+     * in this property. They can be retrieved using findDetails().
+     *
+     * When an error is constructed to be sent over the wire, outgoing error
+     * details are stored in this property as well.
+     */
+    details: (OutgoingDetail | IncomingDetail)[];
+    /**
+     * The error message, but without a status code in front.
+     *
+     * For example, a new `ConnectError("hello", Code.NotFound)` will have
+     * the message `[not found] hello`, and the rawMessage `hello`.
+     */
+    readonly rawMessage: string;
+    name: string;
+    /**
+     * The underlying cause of this error, if any. In cases where the actual cause
+     * is elided with the error message, the cause is specified here so that we
+     * don't leak the underlying error, but instead make it available for logging.
+     */
+    cause: unknown;
+    /**
+     * @private Internal field, indicates whether this error was parsed from the
+     * wire by a Connect client, as opposed to being created by application code.
+     *
+     * Do not set this field in application code.
+     */
+    isWireError: boolean;
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with the error.
+     */
+    constructor(message: string, code?: Code, metadata?: HeadersInit, outgoingDetails?: OutgoingDetail[], cause?: unknown);
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError or TimeoutError from the fetch API, return
+     *   the message of the error with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason: unknown, code?: Code): ConnectError;
+    static [Symbol.hasInstance](v: unknown): boolean;
+    /**
+     * Retrieve error details from a ConnectError. On the wire, error details are
+     * wrapped with google.protobuf.Any, so that a server or middleware can attach
+     * arbitrary data to an error. This function decodes the array of error details
+     * from the ConnectError object, and returns an array with the decoded
+     * messages. Any decoding errors are ignored, and the detail will simply be
+     * omitted from the list.
+     */
+    findDetails<Desc extends DescMessage>(desc: Desc): MessageShape<Desc>[];
+    findDetails(registry: Registry): Message[];
+}
+/**
+ * An incoming detail is basically a google.protobuf.Any, but it includes an
+ * optional JSON representation in the "debug" key, and stores a type name
+ * instead of a type URL.
+ */
+type IncomingDetail = {
+    type: string;
+    value: Uint8Array;
+    debug?: JsonValue;
+};
+/**
+ * Message and Desc Pair.
+ */
+type OutgoingDetail = {
+    desc: DescMessage;
+    value: MessageInitShape<DescMessage>;
+};
+export {};

package/node_modules/@connectrpc/connect/dist/cjs/connect-error.js

@@ -0,0 +1,141 @@
+"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.ConnectError = void 0;
+const code_js_1 = require("./code.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+const code_string_js_1 = require("./protocol-connect/code-string.js");
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+class ConnectError extends Error {
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with the error.
+     */
+    constructor(message, code = code_js_1.Code.Unknown, metadata, outgoingDetails, cause) {
+        super(createMessage(message, code));
+        this.name = "ConnectError";
+        /**
+         * @private Internal field, indicates whether this error was parsed from the
+         * wire by a Connect client, as opposed to being created by application code.
+         *
+         * Do not set this field in application code.
+         */
+        this.isWireError = false;
+        // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.rawMessage = message;
+        this.code = code;
+        this.metadata = new Headers(metadata !== null && metadata !== void 0 ? metadata : {});
+        this.details = outgoingDetails !== null && outgoingDetails !== void 0 ? outgoingDetails : [];
+        this.cause = cause;
+    }
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError or TimeoutError from the fetch API, return
+     *   the message of the error with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason, code = code_js_1.Code.Unknown) {
+        if (reason instanceof ConnectError) {
+            return reason;
+        }
+        if (reason instanceof Error) {
+            if (reason.name == "AbortError" || reason.name == "TimeoutError") {
+                // Fetch requests can only be canceled with an AbortController,
+                // or with AbortSignal.timeout().
+                return new ConnectError(reason.message, code_js_1.Code.Canceled);
+            }
+            return new ConnectError(reason.message, code, undefined, undefined, reason);
+        }
+        return new ConnectError(String(reason), code, undefined, undefined, reason);
+    }
+    static [Symbol.hasInstance](v) {
+        if (!(v instanceof Error)) {
+            return false;
+        }
+        if (Object.getPrototypeOf(v) === ConnectError.prototype) {
+            return true;
+        }
+        return (v.name === "ConnectError" &&
+            "code" in v &&
+            typeof v.code === "number" &&
+            "metadata" in v &&
+            "details" in v &&
+            Array.isArray(v.details) &&
+            "rawMessage" in v &&
+            typeof v.rawMessage == "string" &&
+            "cause" in v);
+    }
+    findDetails(typeOrRegistry) {
+        const registry = typeOrRegistry.kind === "message"
+            ? {
+                getMessage: (typeName) => typeName === typeOrRegistry.typeName ? typeOrRegistry : undefined,
+            }
+            : typeOrRegistry;
+        const details = [];
+        for (const data of this.details) {
+            if ("desc" in data) {
+                if (registry.getMessage(data.desc.typeName)) {
+                    details.push((0, protobuf_1.create)(data.desc, data.value));
+                }
+                continue;
+            }
+            const desc = registry.getMessage(data.type);
+            if (desc) {
+                try {
+                    details.push((0, protobuf_1.fromBinary)(desc, data.value));
+                }
+                catch (_) {
+                    // We silently give up if we are unable to parse the detail, because
+                    // that appears to be the least worst behavior.
+                    // It is very unlikely that a user surrounds a catch body handling the
+                    // error with another try-catch statement, and we do not want to
+                    // recommend doing so.
+                }
+            }
+        }
+        return details;
+    }
+}
+exports.ConnectError = ConnectError;
+/**
+ * Create an error message, prefixing the given code.
+ */
+function createMessage(message, code) {
+    return message.length
+        ? `[${(0, code_string_js_1.codeToString)(code)}] ${message}`
+        : `[${(0, code_string_js_1.codeToString)(code)}]`;
+}

package/node_modules/@connectrpc/connect/dist/cjs/context-values.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ContextValues is a collection of context values.
+ */
+export interface ContextValues {
+    /**
+     * get returns a context value.
+     */
+    get<T>(key: ContextKey<T>): T;
+    /**
+     * set sets a context value. It returns the ContextValues to allow chaining.
+     */
+    set<T>(key: ContextKey<T>, value: T): this;
+    /**
+     * delete deletes a context value. It returns the ContextValues to allow chaining.
+     */
+    delete(key: ContextKey<unknown>): this;
+}
+/**
+ * createContextValues creates a new ContextValues.
+ */
+export declare function createContextValues(): ContextValues;
+/**
+ * ContextKey is a unique identifier for a context value.
+ */
+export type ContextKey<T> = {
+    id: symbol;
+    defaultValue: T;
+};
+/**
+ * createContextKey creates a new ContextKey.
+ */
+export declare function createContextKey<T>(defaultValue: T, options?: {
+    description?: string;
+}): ContextKey<T>;

package/node_modules/@connectrpc/connect/dist/cjs/context-values.js

@@ -0,0 +1,41 @@
+"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.createContextValues = createContextValues;
+exports.createContextKey = createContextKey;
+/**
+ * createContextValues creates a new ContextValues.
+ */
+function createContextValues() {
+    return {
+        get(key) {
+            return key.id in this ? this[key.id] : key.defaultValue;
+        },
+        set(key, value) {
+            this[key.id] = value;
+            return this;
+        },
+        delete(key) {
+            delete this[key.id];
+            return this;
+        },
+    };
+}
+/**
+ * createContextKey creates a new ContextKey.
+ */
+function createContextKey(defaultValue, options) {
+    return { id: Symbol(options === null || options === void 0 ? void 0 : options.description), defaultValue };
+}

package/node_modules/@connectrpc/connect/dist/cjs/cors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CORS prevents rogue scripts in a web browser from making arbitrary requests
+ * to other web servers.
+ *
+ * This object provides helpful constants to configure CORS middleware for
+ * cross-domain requests with the protocols supported by Connect.
+ *
+ * Make sure to add application-specific headers that your application
+ * uses as well.
+ */
+export declare const cors: {
+    /**
+     * Request methods that scripts running in the browser are permitted to use.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these headers fields must be included in the preflight response header
+     * Access-Control-Allow-Methods.
+     */
+    allowedMethods: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running in the browser are permitted to send.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in the preflight response header
+     * Access-Control-Allow-Headers.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * may send.
+     */
+    allowedHeaders: ReadonlyArray<string>;
+    /**
+     * Header fields that scripts running the browser are permitted to see.
+     *
+     * To support cross-domain requests with the protocols supported by Connect,
+     * these field names must be included in header Access-Control-Expose-Headers
+     * of the actual response.
+     *
+     * Make sure to include any application-specific headers your browser client
+     * should see. If your application uses trailers, they will be sent as header
+     * fields with a `Trailer-` prefix for Connect unary RPCs - make sure to
+     * expose them as well if you want them to be visible in all supported
+     * protocols.
+     */
+    exposedHeaders: ReadonlyArray<string>;
+};