openrod 0.0.0 → 0.1.0

package/node_modules/@bufbuild/protobuf/dist/commonjs/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./types.js";
+export * from "./is-message.js";
+export * from "./create.js";
+export * from "./clone.js";
+export * from "./descriptors.js";
+export * from "./equals.js";
+export * from "./fields.js";
+export * from "./registry.js";
+export type { JsonValue, JsonObject } from "./json-value.js";
+export { toBinary } from "./to-binary.js";
+export type { BinaryWriteOptions } from "./to-binary.js";
+export { fromBinary, mergeFromBinary } from "./from-binary.js";
+export type { BinaryReadOptions } from "./from-binary.js";
+export * from "./to-json.js";
+export * from "./from-json.js";
+export * from "./merge.js";
+export { hasExtension, getExtension, setExtension, clearExtension, hasOption, getOption, } from "./extensions.js";
+export * from "./proto-int64.js";
+export * from "./unknown-enum.js";

package/node_modules/@bufbuild/protobuf/dist/commonjs/index.js

@@ -0,0 +1,55 @@
+"use strict";
+// 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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOption = exports.hasOption = exports.clearExtension = exports.setExtension = exports.getExtension = exports.hasExtension = exports.mergeFromBinary = exports.fromBinary = exports.toBinary = void 0;
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./is-message.js"), exports);
+__exportStar(require("./create.js"), exports);
+__exportStar(require("./clone.js"), exports);
+__exportStar(require("./descriptors.js"), exports);
+__exportStar(require("./equals.js"), exports);
+__exportStar(require("./fields.js"), exports);
+__exportStar(require("./registry.js"), exports);
+var to_binary_js_1 = require("./to-binary.js");
+Object.defineProperty(exports, "toBinary", { enumerable: true, get: function () { return to_binary_js_1.toBinary; } });
+var from_binary_js_1 = require("./from-binary.js");
+Object.defineProperty(exports, "fromBinary", { enumerable: true, get: function () { return from_binary_js_1.fromBinary; } });
+Object.defineProperty(exports, "mergeFromBinary", { enumerable: true, get: function () { return from_binary_js_1.mergeFromBinary; } });
+__exportStar(require("./to-json.js"), exports);
+__exportStar(require("./from-json.js"), exports);
+__exportStar(require("./merge.js"), exports);
+var extensions_js_1 = require("./extensions.js");
+Object.defineProperty(exports, "hasExtension", { enumerable: true, get: function () { return extensions_js_1.hasExtension; } });
+Object.defineProperty(exports, "getExtension", { enumerable: true, get: function () { return extensions_js_1.getExtension; } });
+Object.defineProperty(exports, "setExtension", { enumerable: true, get: function () { return extensions_js_1.setExtension; } });
+Object.defineProperty(exports, "clearExtension", { enumerable: true, get: function () { return extensions_js_1.clearExtension; } });
+Object.defineProperty(exports, "hasOption", { enumerable: true, get: function () { return extensions_js_1.hasOption; } });
+Object.defineProperty(exports, "getOption", { enumerable: true, get: function () { return extensions_js_1.getOption; } });
+__exportStar(require("./proto-int64.js"), exports);
+__exportStar(require("./unknown-enum.js"), exports);

package/node_modules/@bufbuild/protobuf/dist/commonjs/is-message.d.ts

@@ -0,0 +1,7 @@
+import type { MessageShape } from "./types.js";
+import type { DescMessage } from "./descriptors.js";
+/**
+ * Determine whether the given `arg` is a message.
+ * If `desc` is set, determine whether `arg` is this specific message.
+ */
+export declare function isMessage<Desc extends DescMessage>(arg: unknown, schema?: Desc): arg is MessageShape<Desc>;

package/node_modules/@bufbuild/protobuf/dist/commonjs/is-message.js

@@ -0,0 +1,33 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMessage = isMessage;
+/**
+ * Determine whether the given `arg` is a message.
+ * If `desc` is set, determine whether `arg` is this specific message.
+ */
+function isMessage(arg, schema) {
+    const isMessage = arg !== null &&
+        typeof arg == "object" &&
+        "$typeName" in arg &&
+        typeof arg.$typeName == "string";
+    if (!isMessage) {
+        return false;
+    }
+    if (schema === undefined) {
+        return true;
+    }
+    return schema.typeName === arg.$typeName;
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/json-value.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Represents any possible JSON value:
+ * - number
+ * - string
+ * - boolean
+ * - null
+ * - object (with any JSON value as property)
+ * - array (with any JSON value as element)
+ */
+export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[];
+/**
+ * Represents a JSON object.
+ */
+export type JsonObject = {
+    [k: string]: JsonValue;
+};

package/node_modules/@bufbuild/protobuf/dist/commonjs/json-value.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@bufbuild/protobuf/dist/commonjs/merge.d.ts

@@ -0,0 +1,13 @@
+import type { MessageShape } from "./types.js";
+import type { DescMessage } from "./descriptors.js";
+/**
+ * Merge message `source` into message `target`, following Protobuf semantics.
+ *
+ * This is the same as serializing the source message, then deserializing it
+ * into the target message via `mergeFromBinary()`, with one difference:
+ * While serialization will create a copy of all values, `merge()` will copy
+ * the reference for `bytes` and messages.
+ *
+ * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages
+ */
+export declare function merge<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, source: MessageShape<Desc>): void;

package/node_modules/@bufbuild/protobuf/dist/commonjs/merge.js

@@ -0,0 +1,70 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+const reflect_js_1 = require("./reflect/reflect.js");
+/**
+ * Merge message `source` into message `target`, following Protobuf semantics.
+ *
+ * This is the same as serializing the source message, then deserializing it
+ * into the target message via `mergeFromBinary()`, with one difference:
+ * While serialization will create a copy of all values, `merge()` will copy
+ * the reference for `bytes` and messages.
+ *
+ * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages
+ */
+function merge(schema, target, source) {
+    reflectMerge((0, reflect_js_1.reflect)(schema, target), (0, reflect_js_1.reflect)(schema, source));
+}
+function reflectMerge(target, source) {
+    var _a;
+    var _b;
+    const sourceUnknown = source.message.$unknown;
+    if (sourceUnknown !== undefined && sourceUnknown.length > 0) {
+        (_a = (_b = target.message).$unknown) !== null && _a !== void 0 ? _a : (_b.$unknown = []);
+        target.message.$unknown.push(...sourceUnknown);
+    }
+    for (const f of target.fields) {
+        if (!source.isSet(f)) {
+            continue;
+        }
+        switch (f.fieldKind) {
+            case "scalar":
+            case "enum":
+                target.set(f, source.get(f));
+                break;
+            case "message":
+                if (target.isSet(f)) {
+                    reflectMerge(target.get(f), source.get(f));
+                }
+                else {
+                    target.set(f, source.get(f));
+                }
+                break;
+            case "list":
+                const list = target.get(f);
+                for (const e of source.get(f)) {
+                    list.add(e);
+                }
+                break;
+            case "map":
+                const map = target.get(f);
+                for (const [k, v] of source.get(f)) {
+                    map.set(k, v);
+                }
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": false
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/proto-int64.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Int64Support for the current environment.
+ */
+export declare const protoInt64: Int64Support;
+/**
+ * We use the `bigint` primitive to represent 64-bit integral types. If bigint
+ * is unavailable, we fall back to a string representation, which means that
+ * all values typed as `bigint` will actually be strings.
+ *
+ * If your code is intended to run in an environment where bigint may be
+ * unavailable, it must handle both the bigint and the string representation.
+ * For presenting values, this is straight-forward with implicit or explicit
+ * conversion to string:
+ *
+ * ```ts
+ * let el = document.createElement("span");
+ * el.innerText = message.int64Field; // assuming a protobuf int64 field
+ *
+ * console.log(`int64: ${message.int64Field}`);
+ *
+ * let str: string = message.int64Field.toString();
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values and are sure the values
+ * can be safely represented as an IEEE-754 double precision number, you can
+ * convert to a JavaScript Number:
+ *
+ * ```ts
+ * console.log(message.int64Field.toString())
+ * let num = Number(message.int64Field);
+ * num = num + 1;
+ * message.int64Field = protoInt64.parse(num);
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values that are outside the
+ * range of safe representation as a JavaScript Number, we recommend you
+ * use a third party library, for example the npm package "long":
+ *
+ * ```ts
+ * // convert the field value to a Long
+ * const bits = protoInt64.enc(message.int64Field);
+ * const longValue = Long.fromBits(bits.lo, bits.hi);
+ *
+ * // perform arithmetic
+ * const longResult = longValue.subtract(1);
+ *
+ * // set the result in the field
+ * message.int64Field = protoInt64.dec(longResult.low, longResult.high);
+ *
+ * // Assuming int64Field contains 9223372036854775807:
+ * console.log(message.int64Field); // 9223372036854775806
+ * ```
+ */
+interface Int64Support {
+    /**
+     * 0n if bigint is available, "0" if unavailable.
+     */
+    readonly zero: bigint;
+    /**
+     * Is bigint available?
+     */
+    readonly supported: boolean;
+    /**
+     * Parse a signed 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    parse(value: string | number | bigint): bigint;
+    /**
+     * Parse an unsigned 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uParse(value: string | number | bigint): bigint;
+    /**
+     * Convert a signed 64-bit integral value to a two's complement.
+     */
+    enc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert an unsigned 64-bit integral value to a two's complement.
+     */
+    uEnc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert a two's complement to a signed 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    dec(lo: number, hi: number): bigint;
+    /**
+     * Convert a two's complement to an unsigned 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uDec(lo: number, hi: number): bigint;
+}
+export {};

package/node_modules/@bufbuild/protobuf/dist/commonjs/proto-int64.js

@@ -0,0 +1,131 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protoInt64 = void 0;
+const varint_js_1 = require("./wire/varint.js");
+/**
+ * Int64Support for the current environment.
+ */
+exports.protoInt64 = makeInt64Support();
+function makeInt64Support() {
+    const dv = new DataView(new ArrayBuffer(8));
+    // note that Safari 14 implements BigInt, but not the DataView methods
+    const ok = typeof BigInt === "function" &&
+        typeof dv.getBigInt64 === "function" &&
+        typeof dv.getBigUint64 === "function" &&
+        typeof dv.setBigInt64 === "function" &&
+        typeof dv.setBigUint64 === "function" &&
+        (!!globalThis.Deno ||
+            !!globalThis.Bun ||
+            typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
+    if (ok) {
+        const MIN = BigInt("-9223372036854775808");
+        const MAX = BigInt("9223372036854775807");
+        const UMIN = BigInt("0");
+        const UMAX = BigInt("18446744073709551615");
+        return {
+            zero: BigInt(0),
+            supported: true,
+            parse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > MAX || bi < MIN) {
+                    throw new Error(`invalid int64: ${value}`);
+                }
+                return bi;
+            },
+            uParse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > UMAX || bi < UMIN) {
+                    throw new Error(`invalid uint64: ${value}`);
+                }
+                return bi;
+            },
+            enc(value) {
+                dv.setBigInt64(0, this.parse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            uEnc(value) {
+                dv.setBigInt64(0, this.uParse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            dec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigInt64(0, true);
+            },
+            uDec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigUint64(0, true);
+            },
+        };
+    }
+    return {
+        zero: "0",
+        supported: false,
+        parse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return value;
+        },
+        uParse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return value;
+        },
+        enc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
+        },
+        uEnc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
+        },
+        dec(lo, hi) {
+            return (0, varint_js_1.int64ToString)(lo, hi);
+        },
+        uDec(lo, hi) {
+            return (0, varint_js_1.uInt64ToString)(lo, hi);
+        },
+    };
+}
+function assertInt64String(value) {
+    if (!/^-?[0-9]+$/.test(value)) {
+        throw new Error("invalid int64: " + value);
+    }
+}
+function assertUInt64String(value) {
+    if (!/^[0-9]+$/.test(value)) {
+        throw new Error("invalid uint64: " + value);
+    }
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/error.d.ts

@@ -0,0 +1,9 @@
+import type { DescField, DescOneof } from "../descriptors.js";
+declare const errorNames: string[];
+export declare class FieldError extends Error {
+    readonly name: (typeof errorNames)[number];
+    constructor(fieldOrOneof: DescField | DescOneof, message: string, name?: (typeof errorNames)[number]);
+    readonly field: () => DescField | DescOneof;
+}
+export declare function isFieldError(arg: unknown): arg is FieldError;
+export {};

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/error.js

@@ -0,0 +1,36 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldError = void 0;
+exports.isFieldError = isFieldError;
+const errorNames = [
+    "FieldValueInvalidError",
+    "FieldListRangeError",
+    "ForeignFieldError",
+];
+class FieldError extends Error {
+    constructor(fieldOrOneof, message, name = "FieldValueInvalidError") {
+        super(message);
+        this.name = name;
+        this.field = () => fieldOrOneof;
+    }
+}
+exports.FieldError = FieldError;
+function isFieldError(arg) {
+    return (arg instanceof Error &&
+        errorNames.includes(arg.name) &&
+        "field" in arg &&
+        typeof arg.field == "function");
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/guard.d.ts

@@ -0,0 +1,20 @@
+import type { Message } from "../types.js";
+import type { ScalarValue } from "./scalar.js";
+import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
+import type { DescField, DescMessage } from "../descriptors.js";
+export declare function isObject(arg: unknown): arg is Record<string, unknown>;
+export declare function isOneofADT(arg: unknown): arg is OneofADT;
+export type OneofADT = {
+    case: undefined;
+    value?: undefined;
+} | {
+    case: string;
+    value: Message | ScalarValue;
+};
+export declare function isReflectList(arg: unknown, field?: DescField & {
+    fieldKind: "list";
+}): arg is ReflectList;
+export declare function isReflectMap(arg: unknown, field?: DescField & {
+    fieldKind: "map";
+}): arg is ReflectMap;
+export declare function isReflectMessage(arg: unknown, messageDesc?: DescMessage): arg is ReflectMessage;

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/guard.js

@@ -0,0 +1,78 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.isOneofADT = isOneofADT;
+exports.isReflectList = isReflectList;
+exports.isReflectMap = isReflectMap;
+exports.isReflectMessage = isReflectMessage;
+const unsafe_js_1 = require("./unsafe.js");
+function isObject(arg) {
+    return arg !== null && typeof arg == "object" && !Array.isArray(arg);
+}
+function isOneofADT(arg) {
+    return (arg !== null &&
+        typeof arg == "object" &&
+        "case" in arg &&
+        ((typeof arg.case == "string" && "value" in arg && arg.value != null) ||
+            (arg.case === undefined &&
+                (!("value" in arg) || arg.value === undefined))));
+}
+function isReflectList(arg, field) {
+    var _a, _b, _c, _d;
+    if (isObject(arg) &&
+        unsafe_js_1.unsafeLocal in arg &&
+        "add" in arg &&
+        "field" in arg &&
+        typeof arg.field == "function") {
+        if (field !== undefined) {
+            const a = field;
+            const b = arg.field();
+            return (a.listKind == b.listKind &&
+                a.scalar === b.scalar &&
+                ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) &&
+                ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName));
+        }
+        return true;
+    }
+    return false;
+}
+function isReflectMap(arg, field) {
+    var _a, _b, _c, _d;
+    if (isObject(arg) &&
+        unsafe_js_1.unsafeLocal in arg &&
+        "has" in arg &&
+        "field" in arg &&
+        typeof arg.field == "function") {
+        if (field !== undefined) {
+            const a = field, b = arg.field();
+            return (a.mapKey === b.mapKey &&
+                a.mapKind == b.mapKind &&
+                a.scalar === b.scalar &&
+                ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) &&
+                ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName));
+        }
+        return true;
+    }
+    return false;
+}
+function isReflectMessage(arg, messageDesc) {
+    return (isObject(arg) &&
+        unsafe_js_1.unsafeLocal in arg &&
+        "desc" in arg &&
+        isObject(arg.desc) &&
+        arg.desc.kind === "message" &&
+        (messageDesc === undefined || arg.desc.typeName == messageDesc.typeName));
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./error.js";
+export * from "./names.js";
+export * from "./nested-types.js";
+export * from "./reflect.js";
+export * from "./reflect-types.js";
+export * from "./scalar.js";
+export * from "./path.js";
+export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";