openrod 0.0.0 → 0.1.0

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/json.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimum google.protobuf.Timestamp in milliseconds (inclusive).
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export declare const timestampMsMin: number;
+/**
+ * Maximum google.protobuf.Timestamp in milliseconds (inclusive).
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export declare const timestampMsMax: number;
+/**
+ * Minimum google.protobuf.Duration in seconds.
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export declare const durationSecondsMin = -315576000000;
+/**
+ * Maximum google.protobuf.Duration in seconds.
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export declare const durationSecondsMax = 315576000000;

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/json.js

@@ -0,0 +1,41 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// 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.
+/**
+ * Minimum google.protobuf.Timestamp in milliseconds (inclusive).
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export const timestampMsMin = /*@__PURE__*/ Date.parse("0001-01-01T00:00:00Z");
+/**
+ * Maximum google.protobuf.Timestamp in milliseconds (inclusive).
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export const timestampMsMax = /*@__PURE__*/ Date.parse("9999-12-31T23:59:59Z");
+/**
+ * Minimum google.protobuf.Duration in seconds.
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export const durationSecondsMin = -315576000000;
+/**
+ * Maximum google.protobuf.Duration in seconds.
+ * Only enforced in ProtoJSON.
+ *
+ * @private
+ */
+export const durationSecondsMax = 315576000000;

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/timestamp.d.ts

@@ -0,0 +1,21 @@
+import type { Timestamp } from "./gen/google/protobuf/timestamp_pb.js";
+/**
+ * Create a google.protobuf.Timestamp for the current time.
+ */
+export declare function timestampNow(): Timestamp;
+/**
+ * Create a google.protobuf.Timestamp message from an ECMAScript Date.
+ */
+export declare function timestampFromDate(date: Date): Timestamp;
+/**
+ * Convert a google.protobuf.Timestamp message to an ECMAScript Date.
+ */
+export declare function timestampDate(timestamp: Timestamp): Date;
+/**
+ * Create a google.protobuf.Timestamp message from a Unix timestamp in milliseconds.
+ */
+export declare function timestampFromMs(timestampMs: number): Timestamp;
+/**
+ * Convert a google.protobuf.Timestamp to a Unix timestamp in milliseconds.
+ */
+export declare function timestampMs(timestamp: Timestamp): number;

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/timestamp.js

@@ -0,0 +1,50 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// 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 { TimestampSchema } from "./gen/google/protobuf/timestamp_pb.js";
+import { create } from "../create.js";
+import { protoInt64 } from "../proto-int64.js";
+/**
+ * Create a google.protobuf.Timestamp for the current time.
+ */
+export function timestampNow() {
+    return timestampFromDate(new Date());
+}
+/**
+ * Create a google.protobuf.Timestamp message from an ECMAScript Date.
+ */
+export function timestampFromDate(date) {
+    return timestampFromMs(date.getTime());
+}
+/**
+ * Convert a google.protobuf.Timestamp message to an ECMAScript Date.
+ */
+export function timestampDate(timestamp) {
+    return new Date(timestampMs(timestamp));
+}
+/**
+ * Create a google.protobuf.Timestamp message from a Unix timestamp in milliseconds.
+ */
+export function timestampFromMs(timestampMs) {
+    const seconds = Math.floor(timestampMs / 1000);
+    return create(TimestampSchema, {
+        seconds: protoInt64.parse(seconds),
+        nanos: (timestampMs - seconds * 1000) * 1000000,
+    });
+}
+/**
+ * Convert a google.protobuf.Timestamp to a Unix timestamp in milliseconds.
+ */
+export function timestampMs(timestamp) {
+    return (Number(timestamp.seconds) * 1000 + Math.round(timestamp.nanos / 1000000));
+}

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/wrappers.d.ts

@@ -0,0 +1,25 @@
+import type { Message } from "../types.js";
+import type { BoolValue, BytesValue, DoubleValue, FloatValue, Int32Value, Int64Value, StringValue, UInt32Value, UInt64Value } from "./gen/google/protobuf/wrappers_pb.js";
+import type { DescField, DescMessage } from "../descriptors.js";
+export declare function isWrapper(arg: Message): arg is DoubleValue | FloatValue | Int64Value | UInt64Value | Int32Value | UInt32Value | BoolValue | StringValue | BytesValue;
+export type WktWrapperDesc = DescMessage & {
+    fields: [
+        DescField & {
+            fieldKind: "scalar";
+            number: 1;
+            name: "value";
+            oneof: undefined;
+        }
+    ];
+};
+export declare function isWrapperDesc(messageDesc: DescMessage): messageDesc is WktWrapperDesc;
+/**
+ * Returns true if the descriptor is a well-known type with a custom JSON
+ * representation per the protobuf JSON spec. Examples: Timestamp as an
+ * RFC 3339 string, Duration as "5s", wrappers as the unwrapped scalar.
+ *
+ * When packed inside `google.protobuf.Any`, these messages are serialized
+ * as `{"@type": ..., "value": <custom form>}`; all other messages embed
+ * their fields directly.
+ */
+export declare function hasCustomJsonRepresentation(desc: DescMessage): boolean;

package/node_modules/@bufbuild/protobuf/dist/esm/wkt/wrappers.js

@@ -0,0 +1,61 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// 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 function isWrapper(arg) {
+    return isWrapperTypeName(arg.$typeName);
+}
+export function isWrapperDesc(messageDesc) {
+    const f = messageDesc.fields[0];
+    return (isWrapperTypeName(messageDesc.typeName) &&
+        f !== undefined &&
+        f.fieldKind == "scalar" &&
+        f.name == "value" &&
+        f.number == 1);
+}
+/**
+ * Returns true if the descriptor is a well-known type with a custom JSON
+ * representation per the protobuf JSON spec. Examples: Timestamp as an
+ * RFC 3339 string, Duration as "5s", wrappers as the unwrapped scalar.
+ *
+ * When packed inside `google.protobuf.Any`, these messages are serialized
+ * as `{"@type": ..., "value": <custom form>}`; all other messages embed
+ * their fields directly.
+ */
+export function hasCustomJsonRepresentation(desc) {
+    switch (desc.typeName) {
+        case "google.protobuf.Any":
+        case "google.protobuf.Timestamp":
+        case "google.protobuf.Duration":
+        case "google.protobuf.FieldMask":
+        case "google.protobuf.Struct":
+        case "google.protobuf.Value":
+        case "google.protobuf.ListValue":
+            return true;
+        default:
+            return isWrapperDesc(desc);
+    }
+}
+const wrapperTypeNames = /*@__PURE__*/ new Set([
+    "google.protobuf.DoubleValue",
+    "google.protobuf.FloatValue",
+    "google.protobuf.Int64Value",
+    "google.protobuf.UInt64Value",
+    "google.protobuf.Int32Value",
+    "google.protobuf.UInt32Value",
+    "google.protobuf.BoolValue",
+    "google.protobuf.StringValue",
+    "google.protobuf.BytesValue",
+]);
+function isWrapperTypeName(name) {
+    return wrapperTypeNames.has(name);
+}

package/node_modules/@bufbuild/protobuf/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@bufbuild/protobuf",
+  "version": "2.15.0",
+  "license": "(Apache-2.0 AND BSD-3-Clause)",
+  "description": "Protocol Buffers for ECMAScript. Fully compliant with the Protobuf conformance tests.",
+  "keywords": [
+    "protobuf",
+    "schema",
+    "typescript",
+    "ecmascript"
+  ],
+  "homepage": "https://protobufes.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bufbuild/protobuf-es.git",
+    "directory": "packages/protobuf"
+  },
+  "scripts": {
+    "build": "tshy",
+    "bootstrap": "npm run bootstrap:inject && npm run bootstrap:wkt",
+    "bootstrap:inject": "node scripts/bootstrap-inject.mjs src",
+    "bootstrap:wkt": "protoc --es_out=src/wkt/gen --es_opt=bootstrap_wkt=true,target=ts,import_extension=js,json_types=true --proto_path $(upstream-include wkt) $(upstream-files wkt)",
+    "postbootstrap:wkt": "license-header src/wkt/gen",
+    "format": "biome format --write",
+    "license-header": "license-header --ignore 'src/wire/varint.ts'",
+    "lint": "biome lint --error-on-warnings",
+    "attw": "attw --pack"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "tshy": {
+    "selfLink": false,
+    "exports": {
+      ".": "./src/index.ts",
+      "./codegenv1": "./src/codegenv1/index.ts",
+      "./codegenv2": "./src/codegenv2/index.ts",
+      "./reflect": "./src/reflect/index.ts",
+      "./wkt": "./src/wkt/index.ts",
+      "./wire": "./src/wire/index.ts",
+      "./txtpb": "./src/txtpb/index.ts"
+    }
+  },
+  "devDependencies": {
+    "tshy": "^4.1.3",
+    "upstream-protobuf": "*"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./codegenv1": {
+      "import": {
+        "types": "./dist/esm/codegenv1/index.d.ts",
+        "default": "./dist/esm/codegenv1/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/codegenv1/index.d.ts",
+        "default": "./dist/commonjs/codegenv1/index.js"
+      }
+    },
+    "./codegenv2": {
+      "import": {
+        "types": "./dist/esm/codegenv2/index.d.ts",
+        "default": "./dist/esm/codegenv2/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/codegenv2/index.d.ts",
+        "default": "./dist/commonjs/codegenv2/index.js"
+      }
+    },
+    "./reflect": {
+      "import": {
+        "types": "./dist/esm/reflect/index.d.ts",
+        "default": "./dist/esm/reflect/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/reflect/index.d.ts",
+        "default": "./dist/commonjs/reflect/index.js"
+      }
+    },
+    "./wkt": {
+      "import": {
+        "types": "./dist/esm/wkt/index.d.ts",
+        "default": "./dist/esm/wkt/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/wkt/index.d.ts",
+        "default": "./dist/commonjs/wkt/index.js"
+      }
+    },
+    "./wire": {
+      "import": {
+        "types": "./dist/esm/wire/index.d.ts",
+        "default": "./dist/esm/wire/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/wire/index.d.ts",
+        "default": "./dist/commonjs/wire/index.js"
+      }
+    },
+    "./txtpb": {
+      "import": {
+        "types": "./dist/esm/txtpb/index.d.ts",
+        "default": "./dist/esm/txtpb/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/txtpb/index.d.ts",
+        "default": "./dist/commonjs/txtpb/index.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "typesVersions": {
+    "*": {
+      "codegenv1": [
+        "./dist/commonjs/codegenv1/index.d.ts"
+      ],
+      "codegenv2": [
+        "./dist/commonjs/codegenv2/index.d.ts"
+      ],
+      "reflect": [
+        "./dist/commonjs/reflect/index.d.ts"
+      ],
+      "wkt": [
+        "./dist/commonjs/wkt/index.d.ts"
+      ],
+      "wire": [
+        "./dist/commonjs/wire/index.d.ts"
+      ],
+      "txtpb": [
+        "./dist/commonjs/txtpb/index.d.ts"
+      ]
+    }
+  }
+}

package/node_modules/@connectrpc/connect/README.md

@@ -0,0 +1,62 @@
+# @connectrpc/connect
+
+Connect is a family of libraries for building type-safe APIs with different languages and platforms.
+[@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings them to TypeScript,
+web browsers, and Node.js.
+
+With Connect, you define your schema first:
+
+```proto
+service ElizaService {
+  rpc Say(SayRequest) returns (SayResponse) {}
+}
+```
+
+And with the magic of code generation, this schema produces servers and clients:
+
+```ts
+const answer = await eliza.say({ sentence: "I feel happy." });
+console.log(answer);
+// {sentence: 'When you feel happy, what do you do?'}
+```
+
+Unlike REST, the RPCs you use with Connect are typesafe end to end, but they are
+regular HTTP under the hood. You can see all requests in the network inspector,
+and you can `curl` them if you want:
+
+```shell
+curl \
+    --header 'Content-Type: application/json' \
+    --data '{"sentence": "I feel happy."}' \
+    https://demo.connectrpc.com/connectrpc.eliza.v1.ElizaService/Say
+```
+
+With Connect for ECMAScript, you can spin up a service in Node.js and call it
+from the web, the terminal, or native mobile clients. Under the hood, it uses
+[Protocol Buffers](https://github.com/bufbuild/protobuf-es) for the schema, and
+implements RPC (remote procedure calls) with three protocols: The widely available
+gRPC and gRPC-web, and Connect's [own protocol](https://connectrpc.com/docs/protocol/),
+optimized for the web. This gives you unparalleled interoperability with
+full-stack type safety.
+
+## Get started on the web
+
+Follow our [10-minute tutorial](https://connectrpc.com/docs/web/getting-started) where
+we use [Vite](https://vitejs.dev/) and [React](https://reactjs.org/) to create a
+web interface for ELIZA.
+
+**React**, **Svelte**, **Vue**, **Next.js** and **Angular** are supported (see [examples](https://github.com/connectrpc/examples-es)),
+and we have an expansion pack for [TanStack Query](https://github.com/connectrpc/connect-query-es).
+We support all modern web browsers that implement the widely available
+[fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+and the [Encoding API](https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API).
+
+## Get started on Node.js
+
+Follow our [10-minute tutorial](https://connectrpc.com/docs/node/getting-started)
+to spin up a service in Node.js, and call it from the web, and from a gRPC client
+in your terminal.
+
+You can use vanilla Node.js, or our server plugins for [Fastify](https://www.fastify.io/)
+or [Express](https://expressjs.com/). We support the builtin `http`, and `http2`
+modules on Node.js v18.14.1 and later.

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

@@ -0,0 +1,19 @@
+import type { DescService, DescMethodUnary, DescMethodStreaming } from "@bufbuild/protobuf";
+/**
+ * AnyClient is an arbitrary service client with any method signature.
+ *
+ * It usually has methods for all methods defined for a service, but may
+ * omit some, for example because it's transport does not support streaming.
+ */
+export type AnyClient = Record<string, AnyClientMethod>;
+type AnyClientMethod = (...args: any[]) => any;
+type CreateAnyClientMethod = (method: DescMethodUnary | DescMethodStreaming) => AnyClientMethod | null;
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+export declare function makeAnyClient(service: DescService, createMethod: CreateAnyClientMethod): AnyClient;
+export {};

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

@@ -0,0 +1,33 @@
+"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.makeAnyClient = makeAnyClient;
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+function makeAnyClient(service, createMethod) {
+    const client = {};
+    for (const desc of service.methods) {
+        const method = createMethod(desc);
+        if (method != null) {
+            client[desc.localName] = method;
+        }
+    }
+    return client;
+}

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

@@ -0,0 +1,34 @@
+import type { ContextValues } from "./context-values.js";
+/**
+ * Options for a call. Every client should accept CallOptions as optional
+ * argument in its RPC methods.
+ */
+export interface CallOptions {
+    /**
+     * Timeout in milliseconds.
+     *
+     * Set to <= 0 to disable the default timeout.
+     */
+    timeoutMs?: number;
+    /**
+     * Custom headers to send with the request.
+     */
+    headers?: HeadersInit;
+    /**
+     * An optional AbortSignal to cancel the call.
+     * If cancelled, an error with Code.Canceled is raised.
+     */
+    signal?: AbortSignal;
+    /**
+     * Called when response headers are received.
+     */
+    onHeader?(headers: Headers): void;
+    /**
+     * Called when response trailers are received.
+     */
+    onTrailer?(trailers: Headers): void;
+    /**
+     * ContextValues to pass to the interceptors.
+     */
+    contextValues?: ContextValues;
+}

package/node_modules/@connectrpc/connect/dist/cjs/call-options.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2021-2026 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,31 @@
+import type { DescService, MessageInitShape, MessageShape, DescMethodServerStreaming, DescMethodUnary } from "@bufbuild/protobuf";
+import { ConnectError } from "./connect-error.js";
+import type { Transport } from "./transport.js";
+import type { CallOptions } from "./call-options.js";
+/**
+ * CallbackClient is a simple client that supports unary and server
+ * streaming methods. Methods take callback functions, which will be
+ * called when a response message arrives, or an error occurs.
+ *
+ * Client methods return a function that cancels the call. This is a
+ * convenient alternative to creating a AbortController and passing
+ * its AbortSignal as an option to the method.
+ *
+ * If a call is cancelled by an AbortController or by the returned
+ * cancel function, ConnectErrors with the code Canceled are
+ * silently discarded.
+ *
+ * CallbackClient is most convenient for use in React effects, where
+ * a function returned by the effect is called when the effect is
+ * torn down.
+ */
+export type CallbackClient<Desc extends DescService> = {
+    [P in keyof Desc["method"]]: Desc["method"][P] extends DescMethodUnary<infer I, infer O> ? (request: MessageInitShape<I>, callback: (error: ConnectError | undefined, response: MessageShape<O>) => void, options?: CallOptions) => CancelFn : Desc["method"][P] extends DescMethodServerStreaming<infer I, infer O> ? (request: MessageInitShape<I>, messageCallback: (response: MessageShape<O>) => void, closeCallback: (error: ConnectError | undefined) => void, options?: CallOptions) => CancelFn : never;
+};
+type CancelFn = () => void;
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+export declare function createCallbackClient<T extends DescService>(service: T, transport: Transport): CallbackClient<T>;
+export {};