измененный отчет

Удалить MasterOK/src/.DS_Store
Удалить MasterOK/.DS_Store
2025-05-23 11:43:13 +04:00 · 2025-02-09 16:10:51 +04:00 · 2025-02-09 16:10:32 +04:00 · 2025-02-09 16:08:54 +04:00 · 2025-02-09 15:50:52 +04:00
3178 changed files with 386259 additions and 0 deletions
--- a/MasterOK/node_modules/.bin/esbuild
+++ b/MasterOK/node_modules/.bin/esbuild
@@ -0,0 +1 @@
+../esbuild/bin/esbuild
--- a/MasterOK/node_modules/.bin/nanoid
+++ b/MasterOK/node_modules/.bin/nanoid
@@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs
--- a/MasterOK/node_modules/.bin/rollup
+++ b/MasterOK/node_modules/.bin/rollup
@@ -0,0 +1 @@
+../rollup/dist/bin/rollup
--- a/MasterOK/node_modules/.bin/sass
+++ b/MasterOK/node_modules/.bin/sass
@@ -0,0 +1 @@
+../sass-embedded/dist/bin/sass.js
--- a/MasterOK/node_modules/.bin/vite
+++ b/MasterOK/node_modules/.bin/vite
@@ -0,0 +1 @@
+../vite/bin/vite.js
--- a/MasterOK/node_modules/.package-lock.json
+++ b/MasterOK/node_modules/.package-lock.json
@@ -0,0 +1,426 @@
+{
+  "name": "masterok",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@bufbuild/protobuf": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-2.2.3.tgz",
+      "integrity": "sha512-tFQoXHJdkEOSwj5tRIZSPNUuXK3RaR7T1nUrPgbYX1pUbvqqaaZAsfo+NXBPsz5rZMSKVFrgK1WL8Q/MSLvprg==",
+      "dev": true,
+      "license": "(Apache-2.0 AND BSD-3-Clause)"
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.24.2.tgz",
+      "integrity": "sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.34.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.34.4.tgz",
+      "integrity": "sha512-drHl+4qhFj+PV/jrQ78p9ch6A0MfNVZScl/nBps5a7u01aGf/GuBRrHnRegA9bP222CBDfjYbFdjkIJ/FurvSQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
+      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/buffer-builder": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/buffer-builder/-/buffer-builder-0.2.0.tgz",
+      "integrity": "sha512-7VPMEPuYznPSoR21NE1zvd2Xna6c/CloiZCfcMXR1Jny6PjX0N4Nsa38zcBFo/FMK+BlA+FLKbJCQ0i2yxp+Xg==",
+      "dev": true,
+      "license": "MIT/X11"
+    },
+    "node_modules/colorjs.io": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/colorjs.io/-/colorjs.io-0.5.2.tgz",
+      "integrity": "sha512-twmVoizEW7ylZSN32OgKdXRmo1qg+wT5/6C3xu5b9QsWzSFAhHLn2xd8ro0diCsKfCj1RdaTP/nrcW+vAoQPIw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.24.2.tgz",
+      "integrity": "sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.24.2",
+        "@esbuild/android-arm": "0.24.2",
+        "@esbuild/android-arm64": "0.24.2",
+        "@esbuild/android-x64": "0.24.2",
+        "@esbuild/darwin-arm64": "0.24.2",
+        "@esbuild/darwin-x64": "0.24.2",
+        "@esbuild/freebsd-arm64": "0.24.2",
+        "@esbuild/freebsd-x64": "0.24.2",
+        "@esbuild/linux-arm": "0.24.2",
+        "@esbuild/linux-arm64": "0.24.2",
+        "@esbuild/linux-ia32": "0.24.2",
+        "@esbuild/linux-loong64": "0.24.2",
+        "@esbuild/linux-mips64el": "0.24.2",
+        "@esbuild/linux-ppc64": "0.24.2",
+        "@esbuild/linux-riscv64": "0.24.2",
+        "@esbuild/linux-s390x": "0.24.2",
+        "@esbuild/linux-x64": "0.24.2",
+        "@esbuild/netbsd-arm64": "0.24.2",
+        "@esbuild/netbsd-x64": "0.24.2",
+        "@esbuild/openbsd-arm64": "0.24.2",
+        "@esbuild/openbsd-x64": "0.24.2",
+        "@esbuild/sunos-x64": "0.24.2",
+        "@esbuild/win32-arm64": "0.24.2",
+        "@esbuild/win32-ia32": "0.24.2",
+        "@esbuild/win32-x64": "0.24.2"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/immutable": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/immutable/-/immutable-5.0.3.tgz",
+      "integrity": "sha512-P8IdPQHq3lA1xVeBRi5VPqUm5HDgKnx0Ru51wZz5mjxHr5n3RWhjIpOFU7ybkUxfB+5IToy+OLaHYDBIWsv+uw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.8",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
+      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.1",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.1.tgz",
+      "integrity": "sha512-6oz2beyjc5VMn/KV1pPw8fliQkhBXrVn1Z3TVyqZxU8kZpzEKhBdmCFqI6ZbmGtamQvQGuU1sgPTk8ZrXDD7jQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.8",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.34.4",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.34.4.tgz",
+      "integrity": "sha512-spF66xoyD7rz3o08sHP7wogp1gZ6itSq22SGa/IZTcUDXDlOyrShwMwkVSB+BUxFRZZCUYqdb3KWDEOMVQZxuw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.6"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.34.4",
+        "@rollup/rollup-android-arm64": "4.34.4",
+        "@rollup/rollup-darwin-arm64": "4.34.4",
+        "@rollup/rollup-darwin-x64": "4.34.4",
+        "@rollup/rollup-freebsd-arm64": "4.34.4",
+        "@rollup/rollup-freebsd-x64": "4.34.4",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.34.4",
+        "@rollup/rollup-linux-arm-musleabihf": "4.34.4",
+        "@rollup/rollup-linux-arm64-gnu": "4.34.4",
+        "@rollup/rollup-linux-arm64-musl": "4.34.4",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.34.4",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.34.4",
+        "@rollup/rollup-linux-riscv64-gnu": "4.34.4",
+        "@rollup/rollup-linux-s390x-gnu": "4.34.4",
+        "@rollup/rollup-linux-x64-gnu": "4.34.4",
+        "@rollup/rollup-linux-x64-musl": "4.34.4",
+        "@rollup/rollup-win32-arm64-msvc": "4.34.4",
+        "@rollup/rollup-win32-ia32-msvc": "4.34.4",
+        "@rollup/rollup-win32-x64-msvc": "4.34.4",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "7.8.1",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz",
+      "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/sass-embedded": {
+      "version": "1.83.4",
+      "resolved": "https://registry.npmjs.org/sass-embedded/-/sass-embedded-1.83.4.tgz",
+      "integrity": "sha512-Hf2burRA/y5PGxsg6jB9UpoK/xZ6g/pgrkOcdl6j+rRg1Zj8XhGKZ1MTysZGtTPUUmiiErqzkP5+Kzp95yv9GQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@bufbuild/protobuf": "^2.0.0",
+        "buffer-builder": "^0.2.0",
+        "colorjs.io": "^0.5.0",
+        "immutable": "^5.0.2",
+        "rxjs": "^7.4.0",
+        "supports-color": "^8.1.1",
+        "sync-child-process": "^1.0.2",
+        "varint": "^6.0.0"
+      },
+      "bin": {
+        "sass": "dist/bin/sass.js"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "optionalDependencies": {
+        "sass-embedded-android-arm": "1.83.4",
+        "sass-embedded-android-arm64": "1.83.4",
+        "sass-embedded-android-ia32": "1.83.4",
+        "sass-embedded-android-riscv64": "1.83.4",
+        "sass-embedded-android-x64": "1.83.4",
+        "sass-embedded-darwin-arm64": "1.83.4",
+        "sass-embedded-darwin-x64": "1.83.4",
+        "sass-embedded-linux-arm": "1.83.4",
+        "sass-embedded-linux-arm64": "1.83.4",
+        "sass-embedded-linux-ia32": "1.83.4",
+        "sass-embedded-linux-musl-arm": "1.83.4",
+        "sass-embedded-linux-musl-arm64": "1.83.4",
+        "sass-embedded-linux-musl-ia32": "1.83.4",
+        "sass-embedded-linux-musl-riscv64": "1.83.4",
+        "sass-embedded-linux-musl-x64": "1.83.4",
+        "sass-embedded-linux-riscv64": "1.83.4",
+        "sass-embedded-linux-x64": "1.83.4",
+        "sass-embedded-win32-arm64": "1.83.4",
+        "sass-embedded-win32-ia32": "1.83.4",
+        "sass-embedded-win32-x64": "1.83.4"
+      }
+    },
+    "node_modules/sass-embedded-darwin-arm64": {
+      "version": "1.83.4",
+      "resolved": "https://registry.npmjs.org/sass-embedded-darwin-arm64/-/sass-embedded-darwin-arm64-1.83.4.tgz",
+      "integrity": "sha512-rp2ywymWc3nymnSnAFG5R/8hvxWCsuhK3wOnD10IDlmNB7o4rzKby1c+2ZfpQGowlYGWsWWTgz8FW2qzmZsQRw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/sync-child-process": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/sync-child-process/-/sync-child-process-1.0.2.tgz",
+      "integrity": "sha512-8lD+t2KrrScJ/7KXCSyfhT3/hRq78rC0wBFqNJXv3mZyn6hW2ypM05JmlSvtqRbeq6jqA94oHbxAr2vYsJ8vDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "sync-message-port": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/sync-message-port": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sync-message-port/-/sync-message-port-1.1.3.tgz",
+      "integrity": "sha512-GTt8rSKje5FilG+wEdfCkOcLL7LWqpMlr2c3LRuKt/YXxcJ52aGSbGBAdI4L3aaqfrBt6y711El53ItyH1NWzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD"
+    },
+    "node_modules/varint": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/varint/-/varint-6.0.0.tgz",
+      "integrity": "sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.1.0.tgz",
+      "integrity": "sha512-RjjMipCKVoR4hVfPY6GQTgveinjNuyLw+qruksLDvA5ktI1150VmcMBKmQaEWJhg/j6Uaf6dNCNA0AfdzUb/hQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.24.2",
+        "postcss": "^8.5.1",
+        "rollup": "^4.30.1"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
--- a/MasterOK/node_modules/.vite/deps/_metadata.json
+++ b/MasterOK/node_modules/.vite/deps/_metadata.json
@@ -0,0 +1,8 @@
+{
+  "hash": "928fd392",
+  "configHash": "98927574",
+  "lockfileHash": "9b4d052a",
+  "browserHash": "d38d1bbe",
+  "optimized": {},
+  "chunks": {}
+}
--- a/MasterOK/node_modules/.vite/deps/package.json
+++ b/MasterOK/node_modules/.vite/deps/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/README.md
+++ b/MasterOK/node_modules/@bufbuild/protobuf/README.md
@@ -0,0 +1,44 @@
+# @bufbuild/protobuf
+
+This package provides the runtime library for the [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
+code generator plugin.
+
+## Protocol Buffers for ECMAScript
+
+A complete implementation of [Protocol Buffers](https://protobuf.dev/) in TypeScript,
+suitable for web browsers and Node.js, created by [Buf](https://buf.build).
+
+**Protobuf-ES** is a solid, modern alternative to existing Protobuf implementations for the JavaScript ecosystem. It's
+the first project in this space to provide a comprehensive plugin framework and decouple the base types from RPC
+functionality.
+
+Some additional features that set it apart from the others:
+
+- ECMAScript module support
+- First-class TypeScript support
+- Generation of idiomatic JavaScript and TypeScript code
+- Generation of [much smaller bundles](https://github.com/bufbuild/protobuf-es/tree/main/packages/bundle-size/)
+- Implementation of all proto3 features, including the [canonical JSON format](https://protobuf.dev/programming-guides/proto3/#json)
+- Implementation of all proto2 features, except for extensions and the text format
+- Usage of standard JavaScript APIs instead of the [Closure Library](http://googlecode.blogspot.com/2009/11/introducing-closure-tools.html)
+- Compatibility is covered by the Protocol Buffers [conformance tests](https://github.com/bufbuild/protobuf-es/tree/main/packages/protobuf-conformance/)
+- Descriptor and reflection support
+
+## Installation
+
+```bash
+npm install @bufbuild/protobuf
+```
+
+## Documentation
+
+To learn how to work with `@bufbuild/protobuf`, check out the docs for the [Runtime API](https://github.com/bufbuild/protobuf-es/tree/main/MANUAL.md#working-with-messages)
+and the [generated code](https://github.com/bufbuild/protobuf-es/tree/main/MANUAL.md#generated-code).
+
+Official documentation for the Protobuf-ES project can be found at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es).
+
+For more information on Buf, check out the official [Buf documentation](https://buf.build/docs/).
+
+## Examples
+
+A complete code example can be found in the **Protobuf-ES** repo [here](https://github.com/bufbuild/protobuf-es/tree/main/packages/protobuf-example).
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/clone.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/clone.d.ts
@@ -0,0 +1,6 @@
+import type { MessageShape } from "./types.js";
+import { type DescMessage } from "./descriptors.js";
+/**
+ * Create a deep copy of a message, including extensions and unknown fields.
+ */
+export declare function clone<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>): MessageShape<Desc>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/clone.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/clone.js
@@ -0,0 +1,68 @@
+"use strict";
+// Copyright 2021-2024 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.clone = clone;
+const descriptors_js_1 = require("./descriptors.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const guard_js_1 = require("./reflect/guard.js");
+/**
+ * Create a deep copy of a message, including extensions and unknown fields.
+ */
+function clone(schema, message) {
+    return cloneReflect((0, reflect_js_1.reflect)(schema, message)).message;
+}
+function cloneReflect(i) {
+    const o = (0, reflect_js_1.reflect)(i.desc);
+    for (const f of i.fields) {
+        if (!i.isSet(f)) {
+            continue;
+        }
+        switch (f.fieldKind) {
+            default: {
+                o.set(f, cloneSingular(f, i.get(f)));
+                break;
+            }
+            case "list":
+                // eslint-disable-next-line no-case-declarations
+                const list = o.get(f);
+                for (const item of i.get(f)) {
+                    list.add(cloneSingular(f, item));
+                }
+                break;
+            case "map":
+                // eslint-disable-next-line no-case-declarations
+                const map = o.get(f);
+                for (const entry of i.get(f).entries()) {
+                    map.set(entry[0], cloneSingular(f, entry[1]));
+                }
+                break;
+        }
+    }
+    const unknown = i.getUnknown();
+    if (unknown && unknown.length > 0) {
+        o.setUnknown([...unknown]);
+    }
+    return o;
+}
+function cloneSingular(field, value) {
+    if (field.message !== undefined && (0, guard_js_1.isReflectMessage)(value)) {
+        return cloneReflect(value);
+    }
+    if (field.scalar == descriptors_js_1.ScalarType.BYTES && value instanceof Uint8Array) {
+        // @ts-expect-error T cannot extend Uint8Array in practice
+        return value.slice();
+    }
+    return value;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/boot.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/boot.d.ts
@@ -0,0 +1,63 @@
+import type { DescriptorProto_ExtensionRange, FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_OptionRetention, FieldOptions_OptionTargetType, FieldOptions_EditionDefault, EnumValueDescriptorProto, FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+import type { DescFile } from "../descriptors.js";
+/**
+ * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain
+ * object.
+ *
+ * See createFileDescriptorProtoBoot() for details.
+ *
+ * @private
+ */
+export declare function boot(boot: FileDescriptorProtoBoot): DescFile;
+/**
+ * An object literal for initializing the message google.protobuf.FileDescriptorProto
+ * for google/protobuf/descriptor.proto.
+ *
+ * See createFileDescriptorProtoBoot() for details.
+ *
+ * @private
+ */
+export type FileDescriptorProtoBoot = {
+    name: "google/protobuf/descriptor.proto";
+    package: "google.protobuf";
+    messageType: DescriptorProtoBoot[];
+    enumType: EnumDescriptorProtoBoot[];
+};
+export type DescriptorProtoBoot = {
+    name: string;
+    field?: FieldDescriptorProtoBoot[];
+    nestedType?: DescriptorProtoBoot[];
+    enumType?: EnumDescriptorProtoBoot[];
+    extensionRange?: Pick<DescriptorProto_ExtensionRange, "start" | "end">[];
+};
+export type FieldDescriptorProtoBoot = {
+    name: string;
+    number: number;
+    label?: FieldDescriptorProto_Label;
+    type: FieldDescriptorProto_Type;
+    typeName?: string;
+    extendee?: string;
+    defaultValue?: string;
+    options?: FieldOptionsBoot;
+};
+export type FieldOptionsBoot = {
+    packed?: boolean;
+    deprecated?: boolean;
+    retention?: FieldOptions_OptionRetention;
+    targets?: FieldOptions_OptionTargetType[];
+    editionDefaults?: FieldOptions_EditionDefaultBoot[];
+};
+export type FieldOptions_EditionDefaultBoot = Pick<FieldOptions_EditionDefault, "edition" | "value">;
+export type EnumDescriptorProtoBoot = {
+    name: string;
+    value: EnumValueDescriptorProtoBoot[];
+};
+export type EnumValueDescriptorProtoBoot = Pick<EnumValueDescriptorProto, "name" | "number">;
+/**
+ * Creates the message google.protobuf.FileDescriptorProto from an object literal.
+ *
+ * See createFileDescriptorProtoBoot() for details.
+ *
+ * @private
+ */
+export declare function bootFileDescriptorProto(init: FileDescriptorProtoBoot): FileDescriptorProto;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/boot.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/boot.js
@@ -0,0 +1,99 @@
+"use strict";
+// Copyright 2021-2024 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.boot = boot;
+exports.bootFileDescriptorProto = bootFileDescriptorProto;
+const restore_json_names_js_1 = require("./restore-json-names.js");
+const registry_js_1 = require("../registry.js");
+/**
+ * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain
+ * object.
+ *
+ * See createFileDescriptorProtoBoot() for details.
+ *
+ * @private
+ */
+function boot(boot) {
+    const root = bootFileDescriptorProto(boot);
+    root.messageType.forEach(restore_json_names_js_1.restoreJsonNames);
+    const reg = (0, registry_js_1.createFileRegistry)(root, () => undefined);
+    // non-null assertion because we just created the registry from the file we look up
+    return reg.getFile(root.name);
+}
+/**
+ * Creates the message google.protobuf.FileDescriptorProto from an object literal.
+ *
+ * See createFileDescriptorProtoBoot() for details.
+ *
+ * @private
+ */
+function bootFileDescriptorProto(init) {
+    const proto = Object.create({
+        syntax: "",
+        edition: 0,
+    });
+    return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) }));
+}
+function bootDescriptorProto(init) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return {
+        $typeName: "google.protobuf.DescriptorProto",
+        name: init.name,
+        field: (_b = (_a = init.field) === null || _a === void 0 ? void 0 : _a.map(bootFieldDescriptorProto)) !== null && _b !== void 0 ? _b : [],
+        extension: [],
+        nestedType: (_d = (_c = init.nestedType) === null || _c === void 0 ? void 0 : _c.map(bootDescriptorProto)) !== null && _d !== void 0 ? _d : [],
+        enumType: (_f = (_e = init.enumType) === null || _e === void 0 ? void 0 : _e.map(bootEnumDescriptorProto)) !== null && _f !== void 0 ? _f : [],
+        extensionRange: (_h = (_g = init.extensionRange) === null || _g === void 0 ? void 0 : _g.map((e) => (Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e)))) !== null && _h !== void 0 ? _h : [],
+        oneofDecl: [],
+        reservedRange: [],
+        reservedName: [],
+    };
+}
+function bootFieldDescriptorProto(init) {
+    const proto = Object.create({
+        label: 1,
+        typeName: "",
+        extendee: "",
+        defaultValue: "",
+        oneofIndex: 0,
+        jsonName: "",
+        proto3Optional: false,
+    });
+    return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : undefined }));
+}
+function bootFieldOptions(init) {
+    var _a, _b, _c;
+    const proto = Object.create({
+        ctype: 0,
+        packed: false,
+        jstype: 0,
+        lazy: false,
+        unverifiedLazy: false,
+        deprecated: false,
+        weak: false,
+        debugRedact: false,
+        retention: 0,
+    });
+    return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== void 0 ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === void 0 ? void 0 : _b.map((e) => (Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e)))) !== null && _c !== void 0 ? _c : [], uninterpretedOption: [] }));
+}
+function bootEnumDescriptorProto(init) {
+    return {
+        $typeName: "google.protobuf.EnumDescriptorProto",
+        name: init.name,
+        reservedName: [],
+        reservedRange: [],
+        value: init.value.map((e) => (Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))),
+    };
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/embed.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/embed.d.ts
@@ -0,0 +1,43 @@
+import type { DescEnum, DescExtension, DescMessage, DescService } from "../descriptors.js";
+import type { FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+import type { FileDescriptorProtoBoot } from "./boot.js";
+type EmbedUnknown = {
+    bootable: false;
+    proto(): FileDescriptorProto;
+    base64(): string;
+};
+type EmbedDescriptorProto = Omit<EmbedUnknown, "bootable"> & {
+    bootable: true;
+    boot(): FileDescriptorProtoBoot;
+};
+/**
+ * Create necessary information to embed a file descriptor in
+ * generated code.
+ *
+ * @private
+ */
+export declare function embedFileDesc(file: FileDescriptorProto): EmbedUnknown | EmbedDescriptorProto;
+/**
+ * Compute the path to a message, enumeration, extension, or service in a
+ * file descriptor.
+ *
+ * @private
+ */
+export declare function pathInFileDesc(desc: DescMessage | DescEnum | DescExtension | DescService): number[];
+/**
+ * The file descriptor for google/protobuf/descriptor.proto cannot be embedded
+ * in serialized form, since it is required to parse itself.
+ *
+ * This function takes an instance of the message, and returns a plain object
+ * that can be hydrated to the message again via bootFileDescriptorProto().
+ *
+ * This function only works with a message google.protobuf.FileDescriptorProto
+ * for google/protobuf/descriptor.proto, and only supports features that are
+ * relevant for the specific use case. For example, it discards file options,
+ * reserved ranges and reserved names, and field options that are unused in
+ * descriptor.proto.
+ *
+ * @private
+ */
+export declare function createFileDescriptorProtoBoot(proto: FileDescriptorProto): FileDescriptorProtoBoot;
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/embed.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/embed.js
@@ -0,0 +1,242 @@
+"use strict";
+// Copyright 2021-2024 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.embedFileDesc = embedFileDesc;
+exports.pathInFileDesc = pathInFileDesc;
+exports.createFileDescriptorProtoBoot = createFileDescriptorProtoBoot;
+const names_js_1 = require("../reflect/names.js");
+const fields_js_1 = require("../fields.js");
+const base64_encoding_js_1 = require("../wire/base64-encoding.js");
+const to_binary_js_1 = require("../to-binary.js");
+const clone_js_1 = require("../clone.js");
+const descriptor_pb_js_1 = require("../wkt/gen/google/protobuf/descriptor_pb.js");
+/**
+ * Create necessary information to embed a file descriptor in
+ * generated code.
+ *
+ * @private
+ */
+function embedFileDesc(file) {
+    const embed = {
+        bootable: false,
+        proto() {
+            const stripped = (0, clone_js_1.clone)(descriptor_pb_js_1.FileDescriptorProtoSchema, file);
+            (0, fields_js_1.clearField)(stripped, descriptor_pb_js_1.FileDescriptorProtoSchema.field.dependency);
+            (0, fields_js_1.clearField)(stripped, descriptor_pb_js_1.FileDescriptorProtoSchema.field.sourceCodeInfo);
+            stripped.messageType.map(stripJsonNames);
+            return stripped;
+        },
+        base64() {
+            const bytes = (0, to_binary_js_1.toBinary)(descriptor_pb_js_1.FileDescriptorProtoSchema, this.proto());
+            return (0, base64_encoding_js_1.base64Encode)(bytes, "std_raw");
+        },
+    };
+    return file.name == "google/protobuf/descriptor.proto"
+        ? Object.assign(Object.assign({}, embed), { bootable: true, boot() {
+                return createFileDescriptorProtoBoot(this.proto());
+            } }) : embed;
+}
+function stripJsonNames(d) {
+    for (const f of d.field) {
+        if (f.jsonName === (0, names_js_1.protoCamelCase)(f.name)) {
+            (0, fields_js_1.clearField)(f, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.jsonName);
+        }
+    }
+    for (const n of d.nestedType) {
+        stripJsonNames(n);
+    }
+}
+/**
+ * Compute the path to a message, enumeration, extension, or service in a
+ * file descriptor.
+ *
+ * @private
+ */
+function pathInFileDesc(desc) {
+    if (desc.kind == "service") {
+        return [desc.file.services.indexOf(desc)];
+    }
+    const parent = desc.parent;
+    if (parent == undefined) {
+        switch (desc.kind) {
+            case "enum":
+                return [desc.file.enums.indexOf(desc)];
+            case "message":
+                return [desc.file.messages.indexOf(desc)];
+            case "extension":
+                return [desc.file.extensions.indexOf(desc)];
+        }
+    }
+    function findPath(cur) {
+        const nested = [];
+        for (let parent = cur.parent; parent;) {
+            const idx = parent.nestedMessages.indexOf(cur);
+            nested.unshift(idx);
+            cur = parent;
+            parent = cur.parent;
+        }
+        nested.unshift(cur.file.messages.indexOf(cur));
+        return nested;
+    }
+    const path = findPath(parent);
+    switch (desc.kind) {
+        case "extension":
+            return [...path, parent.nestedExtensions.indexOf(desc)];
+        case "message":
+            return [...path, parent.nestedMessages.indexOf(desc)];
+        case "enum":
+            return [...path, parent.nestedEnums.indexOf(desc)];
+    }
+}
+/**
+ * The file descriptor for google/protobuf/descriptor.proto cannot be embedded
+ * in serialized form, since it is required to parse itself.
+ *
+ * This function takes an instance of the message, and returns a plain object
+ * that can be hydrated to the message again via bootFileDescriptorProto().
+ *
+ * This function only works with a message google.protobuf.FileDescriptorProto
+ * for google/protobuf/descriptor.proto, and only supports features that are
+ * relevant for the specific use case. For example, it discards file options,
+ * reserved ranges and reserved names, and field options that are unused in
+ * descriptor.proto.
+ *
+ * @private
+ */
+function createFileDescriptorProtoBoot(proto) {
+    var _a;
+    assert(proto.name == "google/protobuf/descriptor.proto");
+    assert(proto.package == "google.protobuf");
+    assert(!proto.dependency.length);
+    assert(!proto.publicDependency.length);
+    assert(!proto.weakDependency.length);
+    assert(!proto.service.length);
+    assert(!proto.extension.length);
+    assert(proto.sourceCodeInfo === undefined);
+    assert(proto.syntax == "" || proto.syntax == "proto2");
+    assert(!((_a = proto.options) === null || _a === void 0 ? void 0 : _a.features)); // we're dropping file options
+    assert(proto.edition === descriptor_pb_js_1.Edition.EDITION_UNKNOWN);
+    return {
+        name: proto.name,
+        package: proto.package,
+        messageType: proto.messageType.map(createDescriptorBoot),
+        enumType: proto.enumType.map(createEnumDescriptorBoot),
+    };
+}
+function createDescriptorBoot(proto) {
+    assert(proto.extension.length == 0);
+    assert(!proto.oneofDecl.length);
+    assert(!proto.options);
+    const b = {
+        name: proto.name,
+    };
+    if (proto.field.length) {
+        b.field = proto.field.map(createFieldDescriptorBoot);
+    }
+    if (proto.nestedType.length) {
+        b.nestedType = proto.nestedType.map(createDescriptorBoot);
+    }
+    if (proto.enumType.length) {
+        b.enumType = proto.enumType.map(createEnumDescriptorBoot);
+    }
+    if (proto.extensionRange.length) {
+        b.extensionRange = proto.extensionRange.map((r) => {
+            assert(!r.options);
+            return { start: r.start, end: r.end };
+        });
+    }
+    return b;
+}
+function createFieldDescriptorBoot(proto) {
+    assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.name));
+    assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.number));
+    assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.type));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.oneofIndex));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.jsonName) ||
+        proto.jsonName === (0, names_js_1.protoCamelCase)(proto.name));
+    const b = {
+        name: proto.name,
+        number: proto.number,
+        type: proto.type,
+    };
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.label)) {
+        b.label = proto.label;
+    }
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.typeName)) {
+        b.typeName = proto.typeName;
+    }
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.extendee)) {
+        b.extendee = proto.extendee;
+    }
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.defaultValue)) {
+        b.defaultValue = proto.defaultValue;
+    }
+    if (proto.options) {
+        b.options = createFieldOptionsBoot(proto.options);
+    }
+    return b;
+}
+function createFieldOptionsBoot(proto) {
+    const b = {};
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.ctype));
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.packed)) {
+        b.packed = proto.packed;
+    }
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.jstype));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.lazy));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.unverifiedLazy));
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.deprecated)) {
+        b.deprecated = proto.deprecated;
+    }
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.weak));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.debugRedact));
+    if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.retention)) {
+        b.retention = proto.retention;
+    }
+    if (proto.targets.length) {
+        b.targets = proto.targets;
+    }
+    if (proto.editionDefaults.length) {
+        b.editionDefaults = proto.editionDefaults.map((d) => ({
+            value: d.value,
+            edition: d.edition,
+        }));
+    }
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.features));
+    assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.uninterpretedOption));
+    return b;
+}
+function createEnumDescriptorBoot(proto) {
+    assert(!proto.options);
+    return {
+        name: proto.name,
+        value: proto.value.map((v) => {
+            assert(!v.options);
+            return {
+                name: v.name,
+                number: v.number,
+            };
+        }),
+    };
+}
+/**
+ * Assert that condition is truthy or throw error.
+ */
+function assert(condition) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
+    if (!condition) {
+        throw new Error();
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.d.ts
@@ -0,0 +1,18 @@
+import type { DescEnum, DescFile } from "../descriptors.js";
+import type { GenEnum } from "./types.js";
+import type { JsonValue } from "../json-value.js";
+/**
+ * Hydrate an enum descriptor.
+ *
+ * @private
+ */
+export declare function enumDesc<Shape extends number, JsonType extends JsonValue = JsonValue>(file: DescFile, path: number, ...paths: number[]): GenEnum<Shape, JsonType>;
+/**
+ * Construct a TypeScript enum object at runtime from a descriptor.
+ */
+export declare function tsEnum(desc: DescEnum): enumObject;
+type enumObject = {
+    [key: number]: string;
+    [k: string]: number | string;
+};
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.js
@@ -0,0 +1,40 @@
+"use strict";
+// Copyright 2021-2024 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.enumDesc = enumDesc;
+exports.tsEnum = tsEnum;
+/**
+ * Hydrate an enum descriptor.
+ *
+ * @private
+ */
+function enumDesc(file, path, ...paths) {
+    if (paths.length == 0) {
+        return file.enums[path];
+    }
+    const e = paths.pop(); // we checked length above
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e];
+}
+/**
+ * Construct a TypeScript enum object at runtime from a descriptor.
+ */
+function tsEnum(desc) {
+    const enumObject = {};
+    for (const value of desc.values) {
+        enumObject[value.localName] = value.number;
+        enumObject[value.number] = value.localName;
+    }
+    return enumObject;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.d.ts
@@ -0,0 +1,9 @@
+import type { Message } from "../types.js";
+import type { DescFile } from "../descriptors.js";
+import type { GenExtension } from "./types.js";
+/**
+ * Hydrate an extension descriptor.
+ *
+ * @private
+ */
+export declare function extDesc<Extendee extends Message, Value>(file: DescFile, path: number, ...paths: number[]): GenExtension<Extendee, Value>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.js
@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2021-2024 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.extDesc = extDesc;
+/**
+ * Hydrate an extension descriptor.
+ *
+ * @private
+ */
+function extDesc(file, path, ...paths) {
+    if (paths.length == 0) {
+        return file.extensions[path];
+    }
+    const e = paths.pop(); // we checked length above
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e];
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.d.ts
@@ -0,0 +1,7 @@
+import type { DescFile } from "../descriptors.js";
+/**
+ * Hydrate a file descriptor.
+ *
+ * @private
+ */
+export declare function fileDesc(b64: string, imports?: DescFile[]): DescFile;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.js
@@ -0,0 +1,35 @@
+"use strict";
+// Copyright 2021-2024 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.fileDesc = fileDesc;
+const base64_encoding_js_1 = require("../wire/base64-encoding.js");
+const descriptor_pb_js_1 = require("../wkt/gen/google/protobuf/descriptor_pb.js");
+const registry_js_1 = require("../registry.js");
+const restore_json_names_js_1 = require("./restore-json-names.js");
+const from_binary_js_1 = require("../from-binary.js");
+/**
+ * Hydrate a file descriptor.
+ *
+ * @private
+ */
+function fileDesc(b64, imports) {
+    var _a;
+    const root = (0, from_binary_js_1.fromBinary)(descriptor_pb_js_1.FileDescriptorProtoSchema, (0, base64_encoding_js_1.base64Decode)(b64));
+    root.messageType.forEach(restore_json_names_js_1.restoreJsonNames);
+    root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : [];
+    const reg = (0, registry_js_1.createFileRegistry)(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName));
+    // non-null assertion because we just created the registry from the file we look up
+    return reg.getFile(root.name);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.d.ts
@@ -0,0 +1,10 @@
+export * from "./boot.js";
+export * from "./embed.js";
+export * from "./enum.js";
+export * from "./extension.js";
+export * from "./file.js";
+export * from "./message.js";
+export * from "./service.js";
+export * from "./symbols.js";
+export * from "./scalar.js";
+export * from "./types.js";
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.js
@@ -0,0 +1,39 @@
+"use strict";
+// Copyright 2021-2024 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 });
+__exportStar(require("./boot.js"), exports);
+__exportStar(require("./embed.js"), exports);
+__exportStar(require("./enum.js"), exports);
+__exportStar(require("./extension.js"), exports);
+__exportStar(require("./file.js"), exports);
+__exportStar(require("./message.js"), exports);
+__exportStar(require("./service.js"), exports);
+__exportStar(require("./symbols.js"), exports);
+__exportStar(require("./scalar.js"), exports);
+__exportStar(require("./types.js"), exports);
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.d.ts
@@ -0,0 +1,10 @@
+import type { Message } from "../types.js";
+import type { DescFile } from "../descriptors.js";
+import type { GenMessage } from "./types.js";
+import type { JsonValue } from "../json-value.js";
+/**
+ * Hydrate a message descriptor.
+ *
+ * @private
+ */
+export declare function messageDesc<Shape extends Message, JsonType extends JsonValue = JsonValue>(file: DescFile, path: number, ...paths: number[]): GenMessage<Shape, JsonType>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.js
@@ -0,0 +1,24 @@
+"use strict";
+// Copyright 2021-2024 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.messageDesc = messageDesc;
+/**
+ * Hydrate a message descriptor.
+ *
+ * @private
+ */
+function messageDesc(file, path, ...paths) {
+    return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/restore-json-names.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/restore-json-names.d.ts
@@ -0,0 +1,5 @@
+import type { DescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+/**
+ * @private
+ */
+export declare function restoreJsonNames(message: DescriptorProto): void;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/restore-json-names.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/restore-json-names.js
@@ -0,0 +1,29 @@
+"use strict";
+// Copyright 2021-2024 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.restoreJsonNames = restoreJsonNames;
+const names_js_1 = require("../reflect/names.js");
+const unsafe_js_1 = require("../reflect/unsafe.js");
+/**
+ * @private
+ */
+function restoreJsonNames(message) {
+    for (const f of message.field) {
+        if (!(0, unsafe_js_1.unsafeIsSetExplicit)(f, "jsonName")) {
+            f.jsonName = (0, names_js_1.protoCamelCase)(f.name);
+        }
+    }
+    message.nestedType.forEach(restoreJsonNames);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/scalar.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/scalar.d.ts
@@ -0,0 +1,9 @@
+import { ScalarType } from "../descriptors.js";
+/**
+ * Return the TypeScript type (as a string) for the given scalar type.
+ */
+export declare function scalarTypeScriptType(scalar: ScalarType, longAsString: boolean): "string" | "boolean" | "bigint" | "bigint | string" | "Uint8Array" | "number";
+/**
+ * Return the JSON type (as a string) for the given scalar type.
+ */
+export declare function scalarJsonType(scalar: ScalarType): "string" | "boolean" | "number" | `number | "NaN" | "Infinity" | "-Infinity"`;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/scalar.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/scalar.js
@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2021-2024 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.scalarTypeScriptType = scalarTypeScriptType;
+exports.scalarJsonType = scalarJsonType;
+const descriptors_js_1 = require("../descriptors.js");
+/**
+ * Return the TypeScript type (as a string) for the given scalar type.
+ */
+function scalarTypeScriptType(scalar, longAsString) {
+    switch (scalar) {
+        case descriptors_js_1.ScalarType.STRING:
+            return "string";
+        case descriptors_js_1.ScalarType.BOOL:
+            return "boolean";
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+        case descriptors_js_1.ScalarType.INT64:
+            return longAsString ? "string" : "bigint";
+        case descriptors_js_1.ScalarType.BYTES:
+            return "Uint8Array";
+        default:
+            return "number";
+    }
+}
+/**
+ * Return the JSON type (as a string) for the given scalar type.
+ */
+function scalarJsonType(scalar) {
+    switch (scalar) {
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            return `number | "NaN" | "Infinity" | "-Infinity"`;
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+        case descriptors_js_1.ScalarType.INT64:
+            return "string";
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+            return "number";
+        case descriptors_js_1.ScalarType.STRING:
+            return "string";
+        case descriptors_js_1.ScalarType.BOOL:
+            return "boolean";
+        case descriptors_js_1.ScalarType.BYTES:
+            return "string";
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.d.ts
@@ -0,0 +1,8 @@
+import type { GenService, GenServiceMethods } from "./types.js";
+import type { DescFile } from "../descriptors.js";
+/**
+ * Hydrate a service descriptor.
+ *
+ * @private
+ */
+export declare function serviceDesc<T extends GenServiceMethods>(file: DescFile, path: number, ...paths: number[]): GenService<T>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.js
@@ -0,0 +1,27 @@
+"use strict";
+// Copyright 2021-2024 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.serviceDesc = serviceDesc;
+/**
+ * Hydrate a service descriptor.
+ *
+ * @private
+ */
+function serviceDesc(file, path, ...paths) {
+    if (paths.length > 0) {
+        throw new Error();
+    }
+    return file.services[path];
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.d.ts
@@ -0,0 +1,135 @@
+/**
+ * @private
+ */
+export declare const packageName = "@bufbuild/protobuf";
+/**
+ * @private
+ */
+export declare const wktPublicImportPaths: Readonly<Record<string, string>>;
+/**
+ * @private
+ */
+export declare const symbols: {
+    readonly isMessage: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../is-message.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly Message: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../types.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly create: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../create.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromJson: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromJsonString: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly fromBinary: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../from-binary.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toBinary: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-binary.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toJson: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly toJsonString: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../to-json.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly protoInt64: {
+        readonly typeOnly: false;
+        readonly bootstrapWktFrom: "../../proto-int64.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly JsonValue: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../json-value.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly JsonObject: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../json-value.js";
+        readonly from: "@bufbuild/protobuf";
+    };
+    readonly codegen: {
+        readonly boot: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/boot.js";
+            readonly from: string;
+        };
+        readonly fileDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/file.js";
+            readonly from: string;
+        };
+        readonly enumDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/enum.js";
+            readonly from: string;
+        };
+        readonly extDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/extension.js";
+            readonly from: string;
+        };
+        readonly messageDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/message.js";
+            readonly from: string;
+        };
+        readonly serviceDesc: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/service.js";
+            readonly from: string;
+        };
+        readonly tsEnum: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv1/enum.js";
+            readonly from: string;
+        };
+        readonly GenFile: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenEnum: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenExtension: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenMessage: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+        readonly GenService: {
+            readonly typeOnly: true;
+            readonly bootstrapWktFrom: "../../codegenv1/types.js";
+            readonly from: string;
+        };
+    };
+};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.js
@@ -0,0 +1,69 @@
+"use strict";
+// Copyright 2021-2024 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.symbols = exports.wktPublicImportPaths = exports.packageName = void 0;
+/**
+ * @private
+ */
+exports.packageName = "@bufbuild/protobuf";
+/**
+ * @private
+ */
+exports.wktPublicImportPaths = {
+    "google/protobuf/compiler/plugin.proto": exports.packageName + "/wkt",
+    "google/protobuf/any.proto": exports.packageName + "/wkt",
+    "google/protobuf/api.proto": exports.packageName + "/wkt",
+    "google/protobuf/descriptor.proto": exports.packageName + "/wkt",
+    "google/protobuf/duration.proto": exports.packageName + "/wkt",
+    "google/protobuf/empty.proto": exports.packageName + "/wkt",
+    "google/protobuf/field_mask.proto": exports.packageName + "/wkt",
+    "google/protobuf/source_context.proto": exports.packageName + "/wkt",
+    "google/protobuf/struct.proto": exports.packageName + "/wkt",
+    "google/protobuf/timestamp.proto": exports.packageName + "/wkt",
+    "google/protobuf/type.proto": exports.packageName + "/wkt",
+    "google/protobuf/wrappers.proto": exports.packageName + "/wkt",
+};
+/**
+ * @private
+ */
+// prettier-ignore
+exports.symbols = {
+    isMessage: { typeOnly: false, bootstrapWktFrom: "../../is-message.js", from: exports.packageName },
+    Message: { typeOnly: true, bootstrapWktFrom: "../../types.js", from: exports.packageName },
+    create: { typeOnly: false, bootstrapWktFrom: "../../create.js", from: exports.packageName },
+    fromJson: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: exports.packageName },
+    fromJsonString: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: exports.packageName },
+    fromBinary: { typeOnly: false, bootstrapWktFrom: "../../from-binary.js", from: exports.packageName },
+    toBinary: { typeOnly: false, bootstrapWktFrom: "../../to-binary.js", from: exports.packageName },
+    toJson: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: exports.packageName },
+    toJsonString: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: exports.packageName },
+    protoInt64: { typeOnly: false, bootstrapWktFrom: "../../proto-int64.js", from: exports.packageName },
+    JsonValue: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: exports.packageName },
+    JsonObject: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: exports.packageName },
+    codegen: {
+        boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/boot.js", from: exports.packageName + "/codegenv1" },
+        fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/file.js", from: exports.packageName + "/codegenv1" },
+        enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: exports.packageName + "/codegenv1" },
+        extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/extension.js", from: exports.packageName + "/codegenv1" },
+        messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/message.js", from: exports.packageName + "/codegenv1" },
+        serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/service.js", from: exports.packageName + "/codegenv1" },
+        tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: exports.packageName + "/codegenv1" },
+        GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" },
+        GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" },
+        GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" },
+        GenMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" },
+        GenService: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" },
+    },
+};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.d.ts
@@ -0,0 +1,74 @@
+import type { Message } from "../types.js";
+import type { DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js";
+import type { JsonValue } from "../json-value.js";
+/**
+ * Describes a protobuf source file.
+ *
+ * @private
+ */
+export type GenFile = DescFile;
+/**
+ * Describes a message declaration in a protobuf source file.
+ *
+ * This type is identical to DescMessage, but carries additional type
+ * information.
+ *
+ * @private
+ */
+export type GenMessage<RuntimeShape extends Message, JsonType = JsonValue> = Omit<DescMessage, "field"> & {
+    field: Record<MessageFieldNames<RuntimeShape>, DescField>;
+} & brandv1<RuntimeShape, JsonType>;
+/**
+ * Describes an enumeration in a protobuf source file.
+ *
+ * This type is identical to DescEnum, but carries additional type
+ * information.
+ *
+ * @private
+ */
+export type GenEnum<RuntimeShape extends number, JsonType extends JsonValue = JsonValue> = Omit<DescEnum, "value"> & {
+    value: Record<RuntimeShape, DescEnumValue>;
+} & brandv1<RuntimeShape, JsonType>;
+/**
+ * Describes an extension in a protobuf source file.
+ *
+ * This type is identical to DescExtension, but carries additional type
+ * information.
+ *
+ * @private
+ */
+export type GenExtension<Extendee extends Message = Message, RuntimeShape = unknown> = DescExtension & brandv1<Extendee, RuntimeShape>;
+/**
+ * Describes a service declaration in a protobuf source file.
+ *
+ * This type is identical to DescService, but carries additional type
+ * information.
+ *
+ * @private
+ */
+export type GenService<RuntimeShape extends GenServiceMethods> = Omit<DescService, "method"> & {
+    method: {
+        [K in keyof RuntimeShape]: RuntimeShape[K] & DescMethod;
+    };
+};
+/**
+ * @private
+ */
+export type GenServiceMethods = Record<string, Pick<DescMethod, "input" | "output" | "methodKind">>;
+declare class brandv1<A, B = unknown> {
+    protected v: "codegenv1";
+    protected a: A | boolean;
+    protected b: B | boolean;
+}
+/**
+ * Union of the property names of all fields, including oneof members.
+ * For an anonymous message (no generated message shape), it's simply a string.
+ */
+type MessageFieldNames<T extends Message> = Message extends T ? string : Exclude<keyof {
+    [P in keyof T as P extends ("$typeName" | "$unknown") ? never : T[P] extends Oneof<infer K> ? K : P]-?: true;
+}, number | symbol>;
+type Oneof<K extends string> = {
+    case: K | undefined;
+    value?: unknown;
+};
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.js
@@ -0,0 +1,22 @@
+"use strict";
+// Copyright 2021-2024 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 });
+class brandv1 {
+    constructor() {
+        this.v = "codegenv1";
+        this.a = false;
+        this.b = false;
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/create.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/create.d.ts
@@ -0,0 +1,9 @@
+import { type DescMessage } from "./descriptors.js";
+import type { MessageInitShape, MessageShape } from "./types.js";
+/**
+ * Create a new message instance.
+ *
+ * The second argument is an optional initializer object, where all fields are
+ * optional.
+ */
+export declare function create<Desc extends DescMessage>(schema: Desc, init?: MessageInitShape<Desc>): MessageShape<Desc>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/create.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/create.js
@@ -0,0 +1,260 @@
+"use strict";
+// Copyright 2021-2024 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.create = create;
+const is_message_js_1 = require("./is-message.js");
+const descriptors_js_1 = require("./descriptors.js");
+const scalar_js_1 = require("./reflect/scalar.js");
+const guard_js_1 = require("./reflect/guard.js");
+const unsafe_js_1 = require("./reflect/unsafe.js");
+const wrappers_js_1 = require("./wkt/wrappers.js");
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number;
+const EDITION_PROTO3 = 999;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
+const EDITION_PROTO2 = 998;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const IMPLICIT = 2;
+/**
+ * Create a new message instance.
+ *
+ * The second argument is an optional initializer object, where all fields are
+ * optional.
+ */
+function create(schema, init) {
+    if ((0, is_message_js_1.isMessage)(init, schema)) {
+        return init;
+    }
+    const message = createZeroMessage(schema);
+    if (init !== undefined) {
+        initMessage(schema, message, init);
+    }
+    return message;
+}
+/**
+ * Sets field values from a MessageInitShape on a zero message.
+ */
+function initMessage(messageDesc, message, init) {
+    for (const member of messageDesc.members) {
+        let value = init[member.localName];
+        if (value == null) {
+            // intentionally ignore undefined and null
+            continue;
+        }
+        let field;
+        if (member.kind == "oneof") {
+            const oneofField = (0, unsafe_js_1.unsafeOneofCase)(init, member);
+            if (!oneofField) {
+                continue;
+            }
+            field = oneofField;
+            value = (0, unsafe_js_1.unsafeGet)(init, oneofField);
+        }
+        else {
+            field = member;
+        }
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- no need to convert enum
+        switch (field.fieldKind) {
+            case "message":
+                value = toMessage(field, value);
+                break;
+            case "scalar":
+                value = initScalar(field, value);
+                break;
+            case "list":
+                value = initList(field, value);
+                break;
+            case "map":
+                value = initMap(field, value);
+                break;
+        }
+        (0, unsafe_js_1.unsafeSet)(message, field, value);
+    }
+    return message;
+}
+function initScalar(field, value) {
+    if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
+        return toU8Arr(value);
+    }
+    return value;
+}
+function initMap(field, value) {
+    if ((0, guard_js_1.isObject)(value)) {
+        if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
+            return convertObjectValues(value, toU8Arr);
+        }
+        if (field.mapKind == "message") {
+            return convertObjectValues(value, (val) => toMessage(field, val));
+        }
+    }
+    return value;
+}
+function initList(field, value) {
+    if (Array.isArray(value)) {
+        if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
+            return value.map(toU8Arr);
+        }
+        if (field.listKind == "message") {
+            return value.map((item) => toMessage(field, item));
+        }
+    }
+    return value;
+}
+function toMessage(field, value) {
+    if (field.fieldKind == "message" &&
+        !field.oneof &&
+        (0, wrappers_js_1.isWrapperDesc)(field.message)) {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return initScalar(field.message.fields[0], value);
+    }
+    if ((0, guard_js_1.isObject)(value)) {
+        if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName !== "google.protobuf.Value") {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            return value;
+        }
+        if (!(0, is_message_js_1.isMessage)(value, field.message)) {
+            return create(field.message, value);
+        }
+    }
+    return value;
+}
+// converts any ArrayLike<number> to Uint8Array if necessary.
+function toU8Arr(value) {
+    return Array.isArray(value) ? new Uint8Array(value) : value;
+}
+function convertObjectValues(obj, fn) {
+    const ret = {};
+    for (const entry of Object.entries(obj)) {
+        ret[entry[0]] = fn(entry[1]);
+    }
+    return ret;
+}
+const tokenZeroMessageField = Symbol();
+const messagePrototypes = new WeakMap();
+/**
+ * Create a zero message.
+ */
+function createZeroMessage(desc) {
+    let msg;
+    if (!needsPrototypeChain(desc)) {
+        msg = {
+            $typeName: desc.typeName,
+        };
+        for (const member of desc.members) {
+            if (member.kind == "oneof" || member.presence == IMPLICIT) {
+                msg[member.localName] = createZeroField(member);
+            }
+        }
+    }
+    else {
+        // Support default values and track presence via the prototype chain
+        const cached = messagePrototypes.get(desc);
+        let prototype;
+        let members;
+        if (cached) {
+            ({ prototype, members } = cached);
+        }
+        else {
+            prototype = {};
+            members = new Set();
+            for (const member of desc.members) {
+                if (member.kind == "oneof") {
+                    // we can only put immutable values on the prototype,
+                    // oneof ADTs are mutable
+                    continue;
+                }
+                if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
+                    // only scalar and enum values are immutable, map, list, and message
+                    // are not
+                    continue;
+                }
+                if (member.presence == IMPLICIT) {
+                    // implicit presence tracks field presence by zero values - e.g. 0, false, "", are unset, 1, true, "x" are set.
+                    // message, map, list fields are mutable, and also have IMPLICIT presence.
+                    continue;
+                }
+                members.add(member);
+                prototype[member.localName] = createZeroField(member);
+            }
+            messagePrototypes.set(desc, { prototype, members });
+        }
+        msg = Object.create(prototype);
+        msg.$typeName = desc.typeName;
+        for (const member of desc.members) {
+            if (members.has(member)) {
+                continue;
+            }
+            if (member.kind == "field") {
+                if (member.fieldKind == "message") {
+                    continue;
+                }
+                if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
+                    if (member.presence != IMPLICIT) {
+                        continue;
+                    }
+                }
+            }
+            msg[member.localName] = createZeroField(member);
+        }
+    }
+    return msg;
+}
+/**
+ * Do we need the prototype chain to track field presence?
+ */
+function needsPrototypeChain(desc) {
+    switch (desc.file.edition) {
+        case EDITION_PROTO3:
+            // proto3 always uses implicit presence, we never need the prototype chain.
+            return false;
+        case EDITION_PROTO2:
+            // proto2 never uses implicit presence, we always need the prototype chain.
+            return true;
+        default:
+            // If a message uses scalar or enum fields with explicit presence, we need
+            // the prototype chain to track presence. This rule does not apply to fields
+            // in a oneof group - they use a different mechanism to track presence.
+            return desc.fields.some((f) => f.presence != IMPLICIT && f.fieldKind != "message" && !f.oneof);
+    }
+}
+/**
+ * Returns a zero value for oneof groups, and for every field kind except
+ * messages. Scalar and enum fields can have default values.
+ */
+function createZeroField(field) {
+    if (field.kind == "oneof") {
+        return { case: undefined };
+    }
+    if (field.fieldKind == "list") {
+        return [];
+    }
+    if (field.fieldKind == "map") {
+        return {}; // Object.create(null) would be desirable here, but is unsupported by react https://react.dev/reference/react/use-server#serializable-parameters-and-return-values
+    }
+    if (field.fieldKind == "message") {
+        return tokenZeroMessageField;
+    }
+    const defaultValue = field.getDefaultValue();
+    if (defaultValue !== undefined) {
+        return field.fieldKind == "scalar" && field.longAsString
+            ? defaultValue.toString()
+            : defaultValue;
+    }
+    return field.fieldKind == "scalar"
+        ? (0, scalar_js_1.scalarZeroValue)(field.scalar, field.longAsString)
+        : field.enum.values[0].number;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.d.ts
@@ -0,0 +1,627 @@
+import type { DescriptorProto, Edition, EnumDescriptorProto, EnumValueDescriptorProto, FeatureSet_FieldPresence, FieldDescriptorProto, FileDescriptorProto, MethodDescriptorProto, MethodOptions_IdempotencyLevel, OneofDescriptorProto, ServiceDescriptorProto } from "./wkt/gen/google/protobuf/descriptor_pb.js";
+import type { ScalarValue } from "./reflect/scalar.js";
+export type SupportedEdition = Extract<Edition, Edition.EDITION_PROTO2 | Edition.EDITION_PROTO3 | Edition.EDITION_2023>;
+type SupportedFieldPresence = Extract<FeatureSet_FieldPresence, FeatureSet_FieldPresence.EXPLICIT | FeatureSet_FieldPresence.IMPLICIT | FeatureSet_FieldPresence.LEGACY_REQUIRED>;
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    BYTES = 12,
+    UINT32 = 13,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,// Uses ZigZag encoding.
+    SINT64 = 18
+}
+/**
+ * A union of all descriptors, discriminated by a `kind` property.
+ */
+export type AnyDesc = DescFile | DescEnum | DescEnumValue | DescMessage | DescField | DescExtension | DescOneof | DescService | DescMethod;
+/**
+ * Describes a protobuf source file.
+ */
+export interface DescFile {
+    readonly kind: "file";
+    /**
+     * The edition of the protobuf file. Will be EDITION_PROTO2 for syntax="proto2",
+     * EDITION_PROTO3 for syntax="proto3";
+     */
+    readonly edition: SupportedEdition;
+    /**
+     * The name of the file, excluding the .proto suffix.
+     * For a protobuf file `foo/bar.proto`, this is `foo/bar`.
+     */
+    readonly name: string;
+    /**
+     * Files imported by this file.
+     */
+    readonly dependencies: DescFile[];
+    /**
+     * Top-level enumerations declared in this file.
+     * Note that more enumerations might be declared within message declarations.
+     */
+    readonly enums: DescEnum[];
+    /**
+     * Top-level messages declared in this file.
+     * Note that more messages might be declared within message declarations.
+     */
+    readonly messages: DescMessage[];
+    /**
+     * Top-level extensions declared in this file.
+     * Note that more extensions might be declared within message declarations.
+     */
+    readonly extensions: DescExtension[];
+    /**
+     * Services declared in this file.
+     */
+    readonly services: DescService[];
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: FileDescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes an enumeration in a protobuf source file.
+ */
+export interface DescEnum {
+    readonly kind: "enum";
+    /**
+     * The fully qualified name of the enumeration. (We omit the leading dot.)
+     */
+    readonly typeName: string;
+    /**
+     * The name of the enumeration, as declared in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * The file this enumeration was declared in.
+     */
+    readonly file: DescFile;
+    /**
+     * The parent message, if this enumeration was declared inside a message declaration.
+     */
+    readonly parent: DescMessage | undefined;
+    /**
+     * Enumerations can be open or closed.
+     * See https://protobuf.dev/programming-guides/enum/
+     */
+    readonly open: boolean;
+    /**
+     * Values declared for this enumeration.
+     */
+    readonly values: DescEnumValue[];
+    /**
+     * All values of this enum by their number.
+     */
+    readonly value: Record<number, DescEnumValue>;
+    /**
+     * A prefix shared by all enum values.
+     * For example, `my_enum_` for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`
+     */
+    readonly sharedPrefix?: string;
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: EnumDescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes an individual value of an enumeration in a protobuf source file.
+ */
+export interface DescEnumValue {
+    readonly kind: "enum_value";
+    /**
+     * The name of the enumeration value, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * A safe and idiomatic name for the value in a TypeScript enum.
+     */
+    readonly localName: string;
+    /**
+     * The enumeration this value belongs to.
+     */
+    readonly parent: DescEnum;
+    /**
+     * The numeric enumeration value, as specified in the protobuf source.
+     */
+    readonly number: number;
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: EnumValueDescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes a message declaration in a protobuf source file.
+ */
+export interface DescMessage {
+    readonly kind: "message";
+    /**
+     * The fully qualified name of the message. (We omit the leading dot.)
+     */
+    readonly typeName: string;
+    /**
+     * The name of the message, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * The file this message was declared in.
+     */
+    readonly file: DescFile;
+    /**
+     * The parent message, if this message was declared inside a message declaration.
+     */
+    readonly parent: DescMessage | undefined;
+    /**
+     * Fields declared for this message, including fields declared in a oneof
+     * group.
+     */
+    readonly fields: DescField[];
+    /**
+     * All fields of this message by their "localName".
+     */
+    readonly field: Record<string, DescField>;
+    /**
+     * Oneof groups declared for this message.
+     * This does not include synthetic oneofs for proto3 optionals.
+     */
+    readonly oneofs: DescOneof[];
+    /**
+     * Fields and oneof groups for this message, ordered by their appearance in the
+     * protobuf source.
+     */
+    readonly members: (DescField | DescOneof)[];
+    /**
+     * Enumerations declared within the message, if any.
+     */
+    readonly nestedEnums: DescEnum[];
+    /**
+     * Messages declared within the message, if any.
+     * This does not include synthetic messages like map entries.
+     */
+    readonly nestedMessages: DescMessage[];
+    /**
+     * Extensions declared within the message, if any.
+     */
+    readonly nestedExtensions: DescExtension[];
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: DescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes a field declaration in a protobuf source file.
+ */
+export type DescField = (descFieldScalar & descFieldCommon) | (descFieldList & descFieldCommon) | (descFieldMessage & descFieldCommon) | (descFieldEnum & descFieldCommon) | (descFieldMap & descFieldCommon);
+type descFieldCommon = descFieldAndExtensionShared & {
+    readonly kind: "field";
+    /**
+     * The message this field is declared on.
+     */
+    readonly parent: DescMessage;
+    /**
+     * A safe and idiomatic name for the field as a property in ECMAScript.
+     */
+    readonly localName: string;
+};
+/**
+ * Describes an extension in a protobuf source file.
+ */
+export type DescExtension = (Omit<descFieldScalar, "oneof"> & descExtensionCommon) | (Omit<descFieldEnum, "oneof"> & descExtensionCommon) | (Omit<descFieldMessage, "oneof"> & descExtensionCommon) | (descFieldList & descExtensionCommon);
+type descExtensionCommon = descFieldAndExtensionShared & {
+    readonly kind: "extension";
+    /**
+     * The fully qualified name of the extension.
+     */
+    readonly typeName: string;
+    /**
+     * The file this extension was declared in.
+     */
+    readonly file: DescFile;
+    /**
+     * The parent message, if this extension was declared inside a message declaration.
+     */
+    readonly parent: DescMessage | undefined;
+    /**
+     * The message that this extension extends.
+     */
+    readonly extendee: DescMessage;
+    /**
+     * The `oneof` group this field belongs to, if any.
+     */
+    readonly oneof: undefined;
+};
+interface descFieldAndExtensionShared {
+    /**
+     * The field name, as specified in the protobuf source
+     */
+    readonly name: string;
+    /**
+     * The field number, as specified in the protobuf source.
+     */
+    readonly number: number;
+    /**
+     * The field name in JSON.
+     */
+    readonly jsonName: string;
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * Presence of the field.
+     * See https://protobuf.dev/programming-guides/field_presence/
+     */
+    readonly presence: SupportedFieldPresence;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: FieldDescriptorProto;
+    /**
+     * Get the edition features for this protobuf element.
+     */
+    toString(): string;
+}
+type descFieldSingularCommon = {
+    /**
+     * The `oneof` group this field belongs to, if any.
+     *
+     * This does not include synthetic oneofs for proto3 optionals.
+     */
+    readonly oneof: DescOneof | undefined;
+};
+type descFieldScalar<T extends ScalarType = ScalarType> = T extends T ? {
+    readonly fieldKind: "scalar";
+    /**
+     * Scalar type, if it is a scalar field.
+     */
+    readonly scalar: T;
+    /**
+     * By default, 64-bit integral types (int64, uint64, sint64, fixed64,
+     * sfixed64) are represented with BigInt.
+     *
+     * If the field option `jstype = JS_STRING` is set, this property
+     * is true, and 64-bit integral types are represented with String.
+     */
+    readonly longAsString: boolean;
+    /**
+     * The message type, if it is a message field.
+     */
+    readonly message: undefined;
+    /**
+     * The enum type, if it is an enum field.
+     */
+    readonly enum: undefined;
+    /**
+     * Return the default value specified in the protobuf source.
+     */
+    getDefaultValue(): ScalarValue<T> | undefined;
+} & descFieldSingularCommon : never;
+type descFieldMessage = {
+    readonly fieldKind: "message";
+    /**
+     * Scalar type, if it is a scalar field.
+     */
+    readonly scalar: undefined;
+    /**
+     * The message type, if it is a message field.
+     */
+    readonly message: DescMessage;
+    /**
+     * Encode the message delimited (a.k.a. proto2 group encoding), or
+     * length-prefixed?
+     */
+    readonly delimitedEncoding: boolean;
+    /**
+     * The enum type, if it is an enum field.
+     */
+    readonly enum: undefined;
+    /**
+     * Return the default value specified in the protobuf source.
+     */
+    getDefaultValue(): undefined;
+} & descFieldSingularCommon;
+type descFieldEnum = {
+    readonly fieldKind: "enum";
+    /**
+     * Scalar type, if it is a scalar field.
+     */
+    readonly scalar: undefined;
+    /**
+     * The message type, if it is a message field.
+     */
+    readonly message: undefined;
+    /**
+     * The enum type, if it is an enum field.
+     */
+    readonly enum: DescEnum;
+    /**
+     * Return the default value specified in the protobuf source.
+     */
+    getDefaultValue(): number | undefined;
+} & descFieldSingularCommon;
+type descFieldList = (descFieldListScalar & descFieldListCommon) | (descFieldListEnum & descFieldListCommon) | (descFieldListMessage & descFieldListCommon);
+type descFieldListCommon = {
+    readonly fieldKind: "list";
+    /**
+     * Pack this repeated field? Only valid for repeated enum fields, and
+     * for repeated scalar fields except BYTES and STRING.
+     */
+    readonly packed: boolean;
+    /**
+     * The `oneof` group this field belongs to, if any.
+     */
+    readonly oneof: undefined;
+};
+type descFieldListScalar<T extends ScalarType = ScalarType> = T extends T ? {
+    readonly listKind: "scalar";
+    /**
+     * The enum list element type.
+     */
+    readonly enum: undefined;
+    /**
+     * The message list element type.
+     */
+    readonly message: undefined;
+    /**
+     * Scalar list element type.
+     */
+    readonly scalar: T;
+    /**
+     * By default, 64-bit integral types (int64, uint64, sint64, fixed64,
+     * sfixed64) are represented with BigInt.
+     *
+     * If the field option `jstype = JS_STRING` is set, this property
+     * is true, and 64-bit integral types are represented with String.
+     */
+    readonly longAsString: boolean;
+} : never;
+type descFieldListEnum = {
+    readonly listKind: "enum";
+    /**
+     * The enum list element type.
+     */
+    readonly enum: DescEnum;
+    /**
+     * The message list element type.
+     */
+    readonly message: undefined;
+    /**
+     * Scalar list element type.
+     */
+    readonly scalar: undefined;
+};
+type descFieldListMessage = {
+    readonly listKind: "message";
+    /**
+     * The enum list element type.
+     */
+    readonly enum: undefined;
+    /**
+     * The message list element type.
+     */
+    readonly message: DescMessage;
+    /**
+     * Scalar list element type.
+     */
+    readonly scalar: undefined;
+    /**
+     * Encode the message delimited (a.k.a. proto2 group encoding), or
+     * length-prefixed?
+     */
+    readonly delimitedEncoding: boolean;
+};
+type descFieldMap = (descFieldMapScalar & descFieldMapCommon) | (descFieldMapEnum & descFieldMapCommon) | (descFieldMapMessage & descFieldMapCommon);
+type descFieldMapCommon<T extends ScalarType = ScalarType> = T extends Exclude<ScalarType, ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES> ? {
+    readonly fieldKind: "map";
+    /**
+     * The scalar map key type.
+     */
+    readonly mapKey: T;
+    /**
+     * The `oneof` group this field belongs to, if any.
+     */
+    readonly oneof: undefined;
+    /**
+     * Encode the map entry message delimited (a.k.a. proto2 group encoding),
+     * or length-prefixed? As of Edition 2023, this is always false for map fields,
+     * and also applies to map values, if they are messages.
+     */
+    readonly delimitedEncoding: false;
+} : never;
+type descFieldMapScalar<T extends ScalarType = ScalarType> = T extends T ? {
+    readonly mapKind: "scalar";
+    /**
+     * The enum map value type.
+     */
+    readonly enum: undefined;
+    /**
+     * The message map value type.
+     */
+    readonly message: undefined;
+    /**
+     * Scalar map value type.
+     */
+    readonly scalar: T;
+} : never;
+type descFieldMapEnum = {
+    readonly mapKind: "enum";
+    /**
+     * The enum map value type.
+     */
+    readonly enum: DescEnum;
+    /**
+     * The message map value type.
+     */
+    readonly message: undefined;
+    /**
+     * Scalar map value type.
+     */
+    readonly scalar: undefined;
+};
+type descFieldMapMessage = {
+    readonly mapKind: "message";
+    /**
+     * The enum map value type.
+     */
+    readonly enum: undefined;
+    /**
+     * The message map value type.
+     */
+    readonly message: DescMessage;
+    /**
+     * Scalar map value type.
+     */
+    readonly scalar: undefined;
+};
+/**
+ * Describes a oneof group in a protobuf source file.
+ */
+export interface DescOneof {
+    readonly kind: "oneof";
+    /**
+     * The name of the oneof group, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * A safe and idiomatic name for the oneof group as a property in ECMAScript.
+     */
+    readonly localName: string;
+    /**
+     * The message this oneof group was declared in.
+     */
+    readonly parent: DescMessage;
+    /**
+     * The fields declared in this oneof group.
+     */
+    readonly fields: DescField[];
+    /**
+     * Marked as deprecated in the protobuf source.
+     * Note that oneof groups cannot be marked as deprecated, this property
+     * only exists for consistency and will always be false.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: OneofDescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes a service declaration in a protobuf source file.
+ */
+export interface DescService {
+    readonly kind: "service";
+    /**
+     * The fully qualified name of the service. (We omit the leading dot.)
+     */
+    readonly typeName: string;
+    /**
+     * The name of the service, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * The file this service was declared in.
+     */
+    readonly file: DescFile;
+    /**
+     * The RPCs this service declares.
+     */
+    readonly methods: DescMethod[];
+    /**
+     * All methods of this service by their "localName".
+     */
+    readonly method: Record<string, DescMethod>;
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: ServiceDescriptorProto;
+    toString(): string;
+}
+/**
+ * Describes an RPC declaration in a protobuf source file.
+ */
+export interface DescMethod {
+    readonly kind: "rpc";
+    /**
+     * The name of the RPC, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * A safe and idiomatic name for the RPC as a method in ECMAScript.
+     */
+    readonly localName: string;
+    /**
+     * The parent service.
+     */
+    readonly parent: DescService;
+    /**
+     * One of the four available method types.
+     */
+    readonly methodKind: "unary" | "server_streaming" | "client_streaming" | "bidi_streaming";
+    /**
+     * The message type for requests.
+     */
+    readonly input: DescMessage;
+    /**
+     * The message type for responses.
+     */
+    readonly output: DescMessage;
+    /**
+     * The idempotency level declared in the protobuf source, if any.
+     */
+    readonly idempotency: MethodOptions_IdempotencyLevel;
+    /**
+     * Marked as deprecated in the protobuf source.
+     */
+    readonly deprecated: boolean;
+    /**
+     * The compiler-generated descriptor.
+     */
+    readonly proto: MethodDescriptorProto;
+    toString(): string;
+}
+/**
+ * Comments on an element in a protobuf source file.
+ */
+export interface DescComments {
+    readonly leadingDetached: readonly string[];
+    readonly leading?: string;
+    readonly trailing?: string;
+    readonly sourcePath: readonly number[];
+}
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.js
@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2021-2024 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.ScalarType = void 0;
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+var ScalarType;
+(function (ScalarType) {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
+    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT64"] = 3] = "INT64";
+    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    ScalarType[ScalarType["INT32"] = 5] = "INT32";
+    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
+    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
+    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
+    ScalarType[ScalarType["STRING"] = 9] = "STRING";
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    // TYPE_GROUP = 10,
+    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
+    // New in version 2.
+    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
+    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
+    // TYPE_ENUM = 14,
+    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
+    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
+    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
+    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
+})(ScalarType || (exports.ScalarType = ScalarType = {}));
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/equals.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/equals.d.ts
@@ -0,0 +1,41 @@
+import type { MessageShape } from "./types.js";
+import { type DescMessage } from "./descriptors.js";
+import type { Registry } from "./registry.js";
+interface EqualsOptions {
+    /**
+     * A registry to look up extensions, and messages packed in Any.
+     *
+     * @private Experimental API, does not follow semantic versioning.
+     */
+    registry: Registry;
+    /**
+     * Unpack google.protobuf.Any before comparing.
+     * If a type is not in the registry, comparison falls back to comparing the
+     * fields of Any.
+     *
+     * @private Experimental API, does not follow semantic versioning.
+     */
+    unpackAny?: boolean;
+    /**
+     * Consider extensions when comparing.
+     *
+     * @private Experimental API, does not follow semantic versioning.
+     */
+    extensions?: boolean;
+    /**
+     * Consider unknown fields when comparing.
+     * The registry is used to distinguish between extensions, and unknown fields
+     * caused by schema changes.
+     *
+     * @private Experimental API, does not follow semantic versioning.
+     */
+    unknown?: boolean;
+}
+/**
+ * Compare two messages of the same type.
+ *
+ * Note that this function disregards extensions and unknown fields, and that
+ * NaN is not equal NaN, following the IEEE standard.
+ */
+export declare function equals<Desc extends DescMessage>(schema: Desc, a: MessageShape<Desc>, b: MessageShape<Desc>, options?: EqualsOptions): boolean;
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/equals.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/equals.js
@@ -0,0 +1,203 @@
+"use strict";
+// Copyright 2021-2024 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.equals = equals;
+const scalar_js_1 = require("./reflect/scalar.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const descriptors_js_1 = require("./descriptors.js");
+const index_js_1 = require("./wkt/index.js");
+const extensions_js_1 = require("./extensions.js");
+/**
+ * Compare two messages of the same type.
+ *
+ * Note that this function disregards extensions and unknown fields, and that
+ * NaN is not equal NaN, following the IEEE standard.
+ */
+function equals(schema, a, b, options) {
+    if (a.$typeName != schema.typeName || b.$typeName != schema.typeName) {
+        return false;
+    }
+    if (a === b) {
+        return true;
+    }
+    return reflectEquals((0, reflect_js_1.reflect)(schema, a), (0, reflect_js_1.reflect)(schema, b), options);
+}
+function reflectEquals(a, b, opts) {
+    if (a.desc.typeName === "google.protobuf.Any" && (opts === null || opts === void 0 ? void 0 : opts.unpackAny) == true) {
+        return anyUnpackedEquals(a.message, b.message, opts);
+    }
+    for (const f of a.fields) {
+        if (!fieldEquals(f, a, b, opts)) {
+            return false;
+        }
+    }
+    if ((opts === null || opts === void 0 ? void 0 : opts.unknown) == true && !unknownEquals(a, b, opts.registry)) {
+        return false;
+    }
+    if ((opts === null || opts === void 0 ? void 0 : opts.extensions) == true && !extensionsEquals(a, b, opts)) {
+        return false;
+    }
+    return true;
+}
+// TODO(tstamm) add an option to consider NaN equal to NaN?
+function fieldEquals(f, a, b, opts) {
+    if (!a.isSet(f) && !b.isSet(f)) {
+        return true;
+    }
+    if (!a.isSet(f) || !b.isSet(f)) {
+        return false;
+    }
+    switch (f.fieldKind) {
+        case "scalar":
+            return (0, scalar_js_1.scalarEquals)(f.scalar, a.get(f), b.get(f));
+        case "enum":
+            return a.get(f) === b.get(f);
+        case "message":
+            return reflectEquals(a.get(f), b.get(f), opts);
+        case "map": {
+            // TODO(tstamm) can't we compare sizes first?
+            const mapA = a.get(f);
+            const mapB = b.get(f);
+            const keys = [];
+            for (const k of mapA.keys()) {
+                if (!mapB.has(k)) {
+                    return false;
+                }
+                keys.push(k);
+            }
+            for (const k of mapB.keys()) {
+                if (!mapA.has(k)) {
+                    return false;
+                }
+            }
+            for (const key of keys) {
+                const va = mapA.get(key);
+                const vb = mapB.get(key);
+                if (va === vb) {
+                    continue;
+                }
+                switch (f.mapKind) {
+                    case "enum":
+                        return false;
+                    case "message":
+                        if (!reflectEquals(va, vb, opts)) {
+                            return false;
+                        }
+                        break;
+                    case "scalar":
+                        if (!(0, scalar_js_1.scalarEquals)(f.scalar, va, vb)) {
+                            return false;
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+        case "list": {
+            const listA = a.get(f);
+            const listB = b.get(f);
+            if (listA.size != listB.size) {
+                return false;
+            }
+            for (let i = 0; i < listA.size; i++) {
+                const va = listA.get(i);
+                const vb = listB.get(i);
+                if (va === vb) {
+                    continue;
+                }
+                switch (f.listKind) {
+                    case "enum":
+                        return false;
+                    case "message":
+                        if (!reflectEquals(va, vb, opts)) {
+                            return false;
+                        }
+                        break;
+                    case "scalar":
+                        if (!(0, scalar_js_1.scalarEquals)(f.scalar, va, vb)) {
+                            return false;
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+    }
+    return true;
+}
+function anyUnpackedEquals(a, b, opts) {
+    if (a.typeUrl !== b.typeUrl) {
+        return false;
+    }
+    const unpackedA = (0, index_js_1.anyUnpack)(a, opts.registry);
+    const unpackedB = (0, index_js_1.anyUnpack)(b, opts.registry);
+    if (unpackedA && unpackedB) {
+        const schema = opts.registry.getMessage(unpackedA.$typeName);
+        if (schema) {
+            return equals(schema, unpackedA, unpackedB, opts);
+        }
+    }
+    return (0, scalar_js_1.scalarEquals)(descriptors_js_1.ScalarType.BYTES, a.value, b.value);
+}
+function unknownEquals(a, b, registry) {
+    function getTrulyUnknown(msg, registry) {
+        var _a;
+        const u = (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : [];
+        return registry
+            ? u.filter((uf) => !registry.getExtensionFor(msg.desc, uf.no))
+            : u;
+    }
+    const unknownA = getTrulyUnknown(a, registry);
+    const unknownB = getTrulyUnknown(b, registry);
+    if (unknownA.length != unknownB.length) {
+        return false;
+    }
+    for (let i = 0; i < unknownA.length; i++) {
+        const a = unknownA[i], b = unknownB[i];
+        if (a.no != b.no) {
+            return false;
+        }
+        if (a.wireType != b.wireType) {
+            return false;
+        }
+        if (!(0, scalar_js_1.scalarEquals)(descriptors_js_1.ScalarType.BYTES, a.data, b.data)) {
+            return false;
+        }
+    }
+    return true;
+}
+function extensionsEquals(a, b, opts) {
+    function getSetExtensions(msg, registry) {
+        var _a;
+        return ((_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : [])
+            .map((uf) => registry.getExtensionFor(msg.desc, uf.no))
+            .filter((e) => e != undefined)
+            .filter((e, index, arr) => arr.indexOf(e) === index);
+    }
+    const extensionsA = getSetExtensions(a, opts.registry);
+    const extensionsB = getSetExtensions(b, opts.registry);
+    if (extensionsA.length != extensionsB.length ||
+        extensionsA.some((e) => !extensionsB.includes(e))) {
+        return false;
+    }
+    for (const extension of extensionsA) {
+        const [containerA, field] = (0, extensions_js_1.createExtensionContainer)(extension, (0, extensions_js_1.getExtension)(a.message, extension));
+        const [containerB] = (0, extensions_js_1.createExtensionContainer)(extension, (0, extensions_js_1.getExtension)(b.message, extension));
+        if (!fieldEquals(field, containerA, containerB, opts)) {
+            return false;
+        }
+    }
+    return true;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/extensions.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/extensions.d.ts
@@ -0,0 +1,59 @@
+import type { AnyDesc, DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService } from "./descriptors.js";
+import type { ReflectMessage } from "./reflect/reflect-types.js";
+import type { Extendee, ExtensionValueShape } from "./types.js";
+import type { EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, OneofOptions, ServiceOptions } from "./wkt/gen/google/protobuf/descriptor_pb.js";
+/**
+ * Retrieve an extension value from a message.
+ *
+ * The function never returns undefined. Use hasExtension() to check whether an
+ * extension is set. If the extension is not set, this function returns the
+ * default value (if one was specified in the protobuf source), or the zero value
+ * (for example `0` for numeric types, `[]` for repeated extension fields, and
+ * an empty message instance for message fields).
+ *
+ * Extensions are stored as unknown fields on a message. To mutate an extension
+ * value, make sure to store the new value with setExtension() after mutating.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export declare function getExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): ExtensionValueShape<Desc>;
+/**
+ * Set an extension value on a message. If the message already has a value for
+ * this extension, the value is replaced.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export declare function setExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc, value: ExtensionValueShape<Desc>): void;
+/**
+ * Remove an extension value from a message.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+export declare function clearExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): void;
+/**
+ * Check whether an extension is set on a message.
+ */
+export declare function hasExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): boolean;
+/**
+ * Check whether an option is set on a descriptor.
+ *
+ * Options are extensions to the `google.protobuf.*Options` messages defined in
+ * google/protobuf/descriptor.proto. This function gets the option message from
+ * the descriptor, and calls hasExtension().
+ */
+export declare function hasOption<Ext extends DescExtension, Desc extends DescForOptionExtension<Ext>>(element: Desc, option: Ext): boolean;
+/**
+ * Retrieve an option value from a descriptor.
+ *
+ * Options are extensions to the `google.protobuf.*Options` messages defined in
+ * google/protobuf/descriptor.proto. This function gets the option message from
+ * the descriptor, and calls getExtension(). Same as getExtension(), this
+ * function never returns undefined.
+ */
+export declare function getOption<Ext extends DescExtension, Desc extends DescForOptionExtension<Ext>>(element: Desc, option: Ext): ExtensionValueShape<Ext>;
+type DescForOptionExtension<Ext extends DescExtension> = Extendee<Ext> extends FileOptions ? DescFile : Extendee<Ext> extends EnumOptions ? DescEnum : Extendee<Ext> extends EnumValueOptions ? DescEnumValue : Extendee<Ext> extends MessageOptions ? DescMessage : Extendee<Ext> extends MessageOptions ? DescEnum : Extendee<Ext> extends FieldOptions ? DescField | DescExtension : Extendee<Ext> extends OneofOptions ? DescOneof : Extendee<Ext> extends ServiceOptions ? DescService : Extendee<Ext> extends EnumOptions ? DescEnum : Extendee<Ext> extends MethodOptions ? DescMethod : AnyDesc;
+/**
+ * @private
+ */
+export declare function createExtensionContainer<Desc extends DescExtension>(extension: Desc, value?: ExtensionValueShape<Desc>): [ReflectMessage, DescField, () => ExtensionValueShape<Desc>];
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/extensions.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/extensions.js
@@ -0,0 +1,169 @@
+"use strict";
+// Copyright 2021-2024 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.getExtension = getExtension;
+exports.setExtension = setExtension;
+exports.clearExtension = clearExtension;
+exports.hasExtension = hasExtension;
+exports.hasOption = hasOption;
+exports.getOption = getOption;
+exports.createExtensionContainer = createExtensionContainer;
+const create_js_1 = require("./create.js");
+const from_binary_js_1 = require("./from-binary.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const scalar_js_1 = require("./reflect/scalar.js");
+const to_binary_js_1 = require("./to-binary.js");
+const binary_encoding_js_1 = require("./wire/binary-encoding.js");
+const wrappers_js_1 = require("./wkt/wrappers.js");
+/**
+ * Retrieve an extension value from a message.
+ *
+ * The function never returns undefined. Use hasExtension() to check whether an
+ * extension is set. If the extension is not set, this function returns the
+ * default value (if one was specified in the protobuf source), or the zero value
+ * (for example `0` for numeric types, `[]` for repeated extension fields, and
+ * an empty message instance for message fields).
+ *
+ * Extensions are stored as unknown fields on a message. To mutate an extension
+ * value, make sure to store the new value with setExtension() after mutating.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+function getExtension(message, extension) {
+    assertExtendee(extension, message);
+    const ufs = filterUnknownFields(message.$unknown, extension);
+    const [container, field, get] = createExtensionContainer(extension);
+    for (const uf of ufs) {
+        (0, from_binary_js_1.readField)(container, new binary_encoding_js_1.BinaryReader(uf.data), field, uf.wireType, {
+            readUnknownFields: false,
+        });
+    }
+    return get();
+}
+/**
+ * Set an extension value on a message. If the message already has a value for
+ * this extension, the value is replaced.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+function setExtension(message, extension, value) {
+    var _a;
+    assertExtendee(extension, message);
+    const ufs = ((_a = message.$unknown) !== null && _a !== void 0 ? _a : []).filter((uf) => uf.no !== extension.number);
+    const [container, field] = createExtensionContainer(extension, value);
+    const writer = new binary_encoding_js_1.BinaryWriter();
+    (0, to_binary_js_1.writeField)(writer, { writeUnknownFields: false }, container, field);
+    const reader = new binary_encoding_js_1.BinaryReader(writer.finish());
+    while (reader.pos < reader.len) {
+        const [no, wireType] = reader.tag();
+        const data = reader.skip(wireType, no);
+        ufs.push({ no, wireType, data });
+    }
+    message.$unknown = ufs;
+}
+/**
+ * Remove an extension value from a message.
+ *
+ * If the extension does not extend the given message, an error is raised.
+ */
+function clearExtension(message, extension) {
+    assertExtendee(extension, message);
+    if (message.$unknown === undefined) {
+        return;
+    }
+    message.$unknown = message.$unknown.filter((uf) => uf.no !== extension.number);
+}
+/**
+ * Check whether an extension is set on a message.
+ */
+function hasExtension(message, extension) {
+    var _a;
+    return (extension.extendee.typeName === message.$typeName &&
+        !!((_a = message.$unknown) === null || _a === void 0 ? void 0 : _a.find((uf) => uf.no === extension.number)));
+}
+/**
+ * Check whether an option is set on a descriptor.
+ *
+ * Options are extensions to the `google.protobuf.*Options` messages defined in
+ * google/protobuf/descriptor.proto. This function gets the option message from
+ * the descriptor, and calls hasExtension().
+ */
+function hasOption(element, option) {
+    const message = element.proto.options;
+    if (!message) {
+        return false;
+    }
+    return hasExtension(message, option);
+}
+/**
+ * Retrieve an option value from a descriptor.
+ *
+ * Options are extensions to the `google.protobuf.*Options` messages defined in
+ * google/protobuf/descriptor.proto. This function gets the option message from
+ * the descriptor, and calls getExtension(). Same as getExtension(), this
+ * function never returns undefined.
+ */
+function getOption(element, option) {
+    const message = element.proto.options;
+    if (!message) {
+        const [, , get] = createExtensionContainer(option);
+        return get();
+    }
+    return getExtension(message, option);
+}
+function filterUnknownFields(unknownFields, extension) {
+    if (unknownFields === undefined)
+        return [];
+    if (extension.fieldKind === "enum" || extension.fieldKind === "scalar") {
+        // singular scalar fields do not merge, we pick the last
+        for (let i = unknownFields.length - 1; i >= 0; --i) {
+            if (unknownFields[i].no == extension.number) {
+                return [unknownFields[i]];
+            }
+        }
+        return [];
+    }
+    return unknownFields.filter((uf) => uf.no === extension.number);
+}
+/**
+ * @private
+ */
+function createExtensionContainer(extension, value) {
+    const localName = extension.typeName;
+    const field = Object.assign(Object.assign({}, extension), { kind: "field", parent: extension.extendee, localName });
+    const desc = Object.assign(Object.assign({}, extension.extendee), { fields: [field], members: [field], oneofs: [] });
+    const container = (0, create_js_1.create)(desc, value !== undefined ? { [localName]: value } : undefined);
+    return [
+        (0, reflect_js_1.reflect)(desc, container),
+        field,
+        () => {
+            const value = container[localName];
+            if (value === undefined) {
+                // Only message fields are undefined, rest will have a zero value.
+                const desc = extension.message;
+                if ((0, wrappers_js_1.isWrapperDesc)(desc)) {
+                    return (0, scalar_js_1.scalarZeroValue)(desc.fields[0].scalar, desc.fields[0].longAsString);
+                }
+                return (0, create_js_1.create)(desc);
+            }
+            return value;
+        },
+    ];
+}
+function assertExtendee(extension, message) {
+    if (extension.extendee.typeName != message.$typeName) {
+        throw new Error(`extension ${extension.typeName} can only be applied to message ${extension.extendee.typeName}`);
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/fields.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/fields.d.ts
@@ -0,0 +1,23 @@
+import type { MessageShape } from "./types.js";
+import type { DescField, DescMessage } from "./descriptors.js";
+/**
+ * Returns true if the field is set.
+ *
+ * - Scalar and enum fields with implicit presence (proto3):
+ *   Set if not a zero value.
+ *
+ * - Scalar and enum fields with explicit presence (proto2, oneof):
+ *   Set if a value was set when creating or parsing the message, or when a
+ *   value was assigned to the field's property.
+ *
+ * - Message fields:
+ *   Set if the property is not undefined.
+ *
+ * - List and map fields:
+ *   Set if not empty.
+ */
+export declare function isFieldSet<Desc extends DescMessage>(message: MessageShape<Desc>, field: DescField): boolean;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField<Desc extends DescMessage>(message: MessageShape<Desc>, field: DescField): void;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/fields.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/fields.js
@@ -0,0 +1,45 @@
+"use strict";
+// Copyright 2021-2024 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.isFieldSet = isFieldSet;
+exports.clearField = clearField;
+const unsafe_js_1 = require("./reflect/unsafe.js");
+/**
+ * Returns true if the field is set.
+ *
+ * - Scalar and enum fields with implicit presence (proto3):
+ *   Set if not a zero value.
+ *
+ * - Scalar and enum fields with explicit presence (proto2, oneof):
+ *   Set if a value was set when creating or parsing the message, or when a
+ *   value was assigned to the field's property.
+ *
+ * - Message fields:
+ *   Set if the property is not undefined.
+ *
+ * - List and map fields:
+ *   Set if not empty.
+ */
+function isFieldSet(message, field) {
+    return (field.parent.typeName == message.$typeName && (0, unsafe_js_1.unsafeIsSet)(message, field));
+}
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+function clearField(message, field) {
+    if (field.parent.typeName == message.$typeName) {
+        (0, unsafe_js_1.unsafeClear)(message, field);
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.d.ts
@@ -0,0 +1,34 @@
+import { type DescField, type DescMessage } from "./descriptors.js";
+import type { MessageShape } from "./types.js";
+import type { ReflectMessage } from "./reflect/index.js";
+import { BinaryReader, WireType } from "./wire/binary-encoding.js";
+/**
+ * Options for parsing binary data.
+ */
+export interface BinaryReadOptions {
+    /**
+     * Retain unknown fields during parsing? The default behavior is to retain
+     * unknown fields and include them in the serialized output.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    readUnknownFields: boolean;
+}
+/**
+ * Parse serialized binary data.
+ */
+export declare function fromBinary<Desc extends DescMessage>(schema: Desc, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+/**
+ * Parse from binary data, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromBinary<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+/**
+ * @private
+ */
+export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, options: BinaryReadOptions): void;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.js
@@ -0,0 +1,213 @@
+"use strict";
+// Copyright 2021-2024 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.fromBinary = fromBinary;
+exports.mergeFromBinary = mergeFromBinary;
+exports.readField = readField;
+const descriptors_js_1 = require("./descriptors.js");
+const scalar_js_1 = require("./reflect/scalar.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const binary_encoding_js_1 = require("./wire/binary-encoding.js");
+// Default options for parsing binary data.
+const readDefaults = {
+    readUnknownFields: true,
+};
+function makeReadOptions(options) {
+    return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+}
+/**
+ * Parse serialized binary data.
+ */
+function fromBinary(schema, bytes, options) {
+    const msg = (0, reflect_js_1.reflect)(schema, undefined, false);
+    readMessage(msg, new binary_encoding_js_1.BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    return msg.message;
+}
+/**
+ * Parse from binary data, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+function mergeFromBinary(schema, target, bytes, options) {
+    readMessage((0, reflect_js_1.reflect)(schema, target, false), new binary_encoding_js_1.BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    return target;
+}
+/**
+ * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`.
+ *
+ * If `delimited` is true, read until an EndGroup tag. `lengthOrDelimitedFieldNo`
+ * is the expected field number.
+ *
+ * @private
+ */
+function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+    var _a;
+    const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+    let fieldNo, wireType;
+    const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+    while (reader.pos < end) {
+        [fieldNo, wireType] = reader.tag();
+        if (delimited && wireType == binary_encoding_js_1.WireType.EndGroup) {
+            break;
+        }
+        const field = message.findNumber(fieldNo);
+        if (!field) {
+            const data = reader.skip(wireType, fieldNo);
+            if (options.readUnknownFields) {
+                unknownFields.push({ no: fieldNo, wireType, data });
+            }
+            continue;
+        }
+        readField(message, reader, field, wireType, options);
+    }
+    if (delimited) {
+        if (wireType != binary_encoding_js_1.WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+            throw new Error(`invalid end group tag`);
+        }
+    }
+    if (unknownFields.length > 0) {
+        message.setUnknown(unknownFields);
+    }
+}
+/**
+ * @private
+ */
+function readField(message, reader, field, wireType, options) {
+    switch (field.fieldKind) {
+        case "scalar":
+            message.set(field, readScalar(reader, field.scalar));
+            break;
+        case "enum":
+            message.set(field, readScalar(reader, descriptors_js_1.ScalarType.INT32));
+            break;
+        case "message":
+            message.set(field, readMessageField(reader, options, field, message.get(field)));
+            break;
+        case "list":
+            readListField(reader, wireType, message.get(field), options);
+            break;
+        case "map":
+            readMapEntry(reader, message.get(field), options);
+            break;
+    }
+}
+// Read a map field, expecting key field = 1, value field = 2
+function readMapEntry(reader, map, options) {
+    const field = map.field();
+    let key, val;
+    const end = reader.pos + reader.uint32();
+    while (reader.pos < end) {
+        const [fieldNo] = reader.tag();
+        switch (fieldNo) {
+            case 1:
+                key = readScalar(reader, field.mapKey);
+                break;
+            case 2:
+                switch (field.mapKind) {
+                    case "scalar":
+                        val = readScalar(reader, field.scalar);
+                        break;
+                    case "enum":
+                        val = reader.int32();
+                        break;
+                    case "message":
+                        val = readMessageField(reader, options, field);
+                        break;
+                }
+                break;
+        }
+    }
+    if (key === undefined) {
+        key = (0, scalar_js_1.scalarZeroValue)(field.mapKey, false);
+    }
+    if (val === undefined) {
+        switch (field.mapKind) {
+            case "scalar":
+                val = (0, scalar_js_1.scalarZeroValue)(field.scalar, false);
+                break;
+            case "enum":
+                val = field.enum.values[0].number;
+                break;
+            case "message":
+                val = (0, reflect_js_1.reflect)(field.message, undefined, false);
+                break;
+        }
+    }
+    map.set(key, val);
+}
+function readListField(reader, wireType, list, options) {
+    var _a;
+    const field = list.field();
+    if (field.listKind === "message") {
+        list.add(readMessageField(reader, options, field));
+        return;
+    }
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32;
+    const packed = wireType == binary_encoding_js_1.WireType.LengthDelimited &&
+        scalarType != descriptors_js_1.ScalarType.STRING &&
+        scalarType != descriptors_js_1.ScalarType.BYTES;
+    if (!packed) {
+        list.add(readScalar(reader, scalarType));
+        return;
+    }
+    const e = reader.uint32() + reader.pos;
+    while (reader.pos < e) {
+        list.add(readScalar(reader, scalarType));
+    }
+}
+function readMessageField(reader, options, field, mergeMessage) {
+    const delimited = field.delimitedEncoding;
+    const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : (0, reflect_js_1.reflect)(field.message, undefined, false);
+    readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+    return message;
+}
+function readScalar(reader, type) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            return reader.string();
+        case descriptors_js_1.ScalarType.BOOL:
+            return reader.bool();
+        case descriptors_js_1.ScalarType.DOUBLE:
+            return reader.double();
+        case descriptors_js_1.ScalarType.FLOAT:
+            return reader.float();
+        case descriptors_js_1.ScalarType.INT32:
+            return reader.int32();
+        case descriptors_js_1.ScalarType.INT64:
+            return reader.int64();
+        case descriptors_js_1.ScalarType.UINT64:
+            return reader.uint64();
+        case descriptors_js_1.ScalarType.FIXED64:
+            return reader.fixed64();
+        case descriptors_js_1.ScalarType.BYTES:
+            return reader.bytes();
+        case descriptors_js_1.ScalarType.FIXED32:
+            return reader.fixed32();
+        case descriptors_js_1.ScalarType.SFIXED32:
+            return reader.sfixed32();
+        case descriptors_js_1.ScalarType.SFIXED64:
+            return reader.sfixed64();
+        case descriptors_js_1.ScalarType.SINT64:
+            return reader.sint64();
+        case descriptors_js_1.ScalarType.UINT32:
+            return reader.uint32();
+        case descriptors_js_1.ScalarType.SINT32:
+            return reader.sint32();
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-json.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-json.d.ts
@@ -0,0 +1,56 @@
+import { type DescEnum, type DescMessage } from "./descriptors.js";
+import type { JsonValue } from "./json-value.js";
+import type { Registry } from "./registry.js";
+import type { EnumJsonType, EnumShape, MessageShape } from "./types.js";
+/**
+ * Options for parsing JSON data.
+ */
+export interface JsonReadOptions {
+    /**
+     * Ignore unknown fields: Proto3 JSON parser should reject unknown fields
+     * by default. This option ignores unknown fields in parsing, as well as
+     * unrecognized enum string representations.
+     */
+    ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any` and extensions
+     * from JSON format.
+     */
+    registry?: Registry;
+}
+/**
+ * Parse a message from a JSON string.
+ */
+export declare function fromJsonString<Desc extends DescMessage>(schema: Desc, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON string, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromJsonString<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value.
+ */
+export declare function fromJson<Desc extends DescMessage>(schema: Desc, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export declare function mergeFromJson<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parses an enum value from JSON.
+ */
+export declare function enumFromJson<Desc extends DescEnum>(descEnum: Desc, json: EnumJsonType<Desc>): EnumShape<Desc>;
+/**
+ * Is the given value a JSON enum value?
+ */
+export declare function isEnumJson<Desc extends DescEnum>(descEnum: Desc, value: unknown): value is EnumJsonType<Desc>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-json.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/from-json.js
@@ -0,0 +1,624 @@
+"use strict";
+// Copyright 2021-2024 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.fromJsonString = fromJsonString;
+exports.mergeFromJsonString = mergeFromJsonString;
+exports.fromJson = fromJson;
+exports.mergeFromJson = mergeFromJson;
+exports.enumFromJson = enumFromJson;
+exports.isEnumJson = isEnumJson;
+/* eslint-disable no-case-declarations,@typescript-eslint/restrict-template-expressions */
+const descriptors_js_1 = require("./descriptors.js");
+const proto_int64_js_1 = require("./proto-int64.js");
+const create_js_1 = require("./create.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const error_js_1 = require("./reflect/error.js");
+const reflect_check_js_1 = require("./reflect/reflect-check.js");
+const scalar_js_1 = require("./reflect/scalar.js");
+const base64_encoding_js_1 = require("./wire/base64-encoding.js");
+const index_js_1 = require("./wkt/index.js");
+const extensions_js_1 = require("./extensions.js");
+// Default options for parsing JSON.
+const jsonReadDefaults = {
+    ignoreUnknownFields: false,
+};
+function makeReadOptions(options) {
+    return options ? Object.assign(Object.assign({}, jsonReadDefaults), options) : jsonReadDefaults;
+}
+/**
+ * Parse a message from a JSON string.
+ */
+function fromJsonString(schema, json, options) {
+    return fromJson(schema, parseJsonString(json, schema.typeName), options);
+}
+/**
+ * Parse a message from a JSON string, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+function mergeFromJsonString(schema, target, json, options) {
+    return mergeFromJson(schema, target, parseJsonString(json, schema.typeName), options);
+}
+/**
+ * Parse a message from a JSON value.
+ */
+function fromJson(schema, json, options) {
+    const msg = (0, reflect_js_1.reflect)(schema);
+    try {
+        readMessage(msg, json, makeReadOptions(options));
+    }
+    catch (e) {
+        if ((0, error_js_1.isFieldError)(e)) {
+            // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+            throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        throw e;
+    }
+    return msg.message;
+}
+/**
+ * Parse a message from a JSON value, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+function mergeFromJson(schema, target, json, options) {
+    try {
+        readMessage((0, reflect_js_1.reflect)(schema, target), json, makeReadOptions(options));
+    }
+    catch (e) {
+        if ((0, error_js_1.isFieldError)(e)) {
+            // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+            throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        throw e;
+    }
+    return target;
+}
+/**
+ * Parses an enum value from JSON.
+ */
+function enumFromJson(descEnum, json) {
+    const val = readEnum(descEnum, json, false, false);
+    if (val === tokenIgnoredUnknownEnum) {
+        throw new Error(`cannot decode ${String(descEnum)} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    return val;
+}
+/**
+ * Is the given value a JSON enum value?
+ */
+function isEnumJson(descEnum, value) {
+    return undefined !== descEnum.values.find((v) => v.name === value);
+}
+function readMessage(msg, json, opts) {
+    var _a;
+    if (tryWktFromJson(msg, json, opts)) {
+        return;
+    }
+    if (json == null || Array.isArray(json) || typeof json != "object") {
+        throw new Error(`cannot decode ${msg.desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    const oneofSeen = new Map();
+    const jsonNames = new Map();
+    for (const field of msg.desc.fields) {
+        jsonNames.set(field.name, field).set(field.jsonName, field);
+    }
+    for (const [jsonKey, jsonValue] of Object.entries(json)) {
+        const field = jsonNames.get(jsonKey);
+        if (field) {
+            if (field.oneof) {
+                if (jsonValue === null && field.fieldKind == "scalar") {
+                    // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+                    continue;
+                }
+                const seen = oneofSeen.get(field.oneof);
+                if (seen !== undefined) {
+                    throw new error_js_1.FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
+                }
+                oneofSeen.set(field.oneof, field);
+            }
+            readField(msg, field, jsonValue, opts);
+        }
+        else {
+            let extension = undefined;
+            if (jsonKey.startsWith("[") &&
+                jsonKey.endsWith("]") &&
+                (extension = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))) &&
+                extension.extendee.typeName === msg.desc.typeName) {
+                const [container, field, get] = (0, extensions_js_1.createExtensionContainer)(extension);
+                readField(container, field, jsonValue, opts);
+                (0, extensions_js_1.setExtension)(msg.message, extension, get());
+            }
+            if (!extension && !opts.ignoreUnknownFields) {
+                throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`);
+            }
+        }
+    }
+}
+function readField(msg, field, json, opts) {
+    switch (field.fieldKind) {
+        case "scalar":
+            readScalarField(msg, field, json);
+            break;
+        case "enum":
+            readEnumField(msg, field, json, opts);
+            break;
+        case "message":
+            readMessageField(msg, field, json, opts);
+            break;
+        case "list":
+            readListField(msg.get(field), json, opts);
+            break;
+        case "map":
+            readMapField(msg.get(field), json, opts);
+            break;
+    }
+}
+function readMapField(map, json, opts) {
+    if (json === null) {
+        return;
+    }
+    const field = map.field();
+    if (typeof json != "object" || Array.isArray(json)) {
+        throw new error_js_1.FieldError(field, "expected object, got " + (0, reflect_check_js_1.formatVal)(json));
+    }
+    for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) {
+        if (jsonMapValue === null) {
+            throw new error_js_1.FieldError(field, "map value must not be null");
+        }
+        let value;
+        switch (field.mapKind) {
+            case "message":
+                const msgValue = (0, reflect_js_1.reflect)(field.message);
+                readMessage(msgValue, jsonMapValue, opts);
+                value = msgValue;
+                break;
+            case "enum":
+                value = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true);
+                if (value === tokenIgnoredUnknownEnum) {
+                    return;
+                }
+                break;
+            case "scalar":
+                value = scalarFromJson(field, jsonMapValue, true);
+                break;
+        }
+        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
+        map.set(key, value);
+    }
+}
+function readListField(list, json, opts) {
+    if (json === null) {
+        return;
+    }
+    const field = list.field();
+    if (!Array.isArray(json)) {
+        throw new error_js_1.FieldError(field, "expected Array, got " + (0, reflect_check_js_1.formatVal)(json));
+    }
+    for (const jsonItem of json) {
+        if (jsonItem === null) {
+            throw new error_js_1.FieldError(field, "list item must not be null");
+        }
+        switch (field.listKind) {
+            case "message":
+                const msgValue = (0, reflect_js_1.reflect)(field.message);
+                readMessage(msgValue, jsonItem, opts);
+                list.add(msgValue);
+                break;
+            case "enum":
+                const enumValue = readEnum(field.enum, jsonItem, opts.ignoreUnknownFields, true);
+                if (enumValue !== tokenIgnoredUnknownEnum) {
+                    list.add(enumValue);
+                }
+                break;
+            case "scalar":
+                list.add(scalarFromJson(field, jsonItem, true));
+                break;
+        }
+    }
+}
+function readMessageField(msg, field, json, opts) {
+    if (json === null && field.message.typeName != "google.protobuf.Value") {
+        msg.clear(field);
+        return;
+    }
+    const msgValue = msg.isSet(field) ? msg.get(field) : (0, reflect_js_1.reflect)(field.message);
+    readMessage(msgValue, json, opts);
+    msg.set(field, msgValue);
+}
+function readEnumField(msg, field, json, opts) {
+    const enumValue = readEnum(field.enum, json, opts.ignoreUnknownFields, false);
+    if (enumValue === tokenNull) {
+        msg.clear(field);
+    }
+    else if (enumValue !== tokenIgnoredUnknownEnum) {
+        msg.set(field, enumValue);
+    }
+}
+function readScalarField(msg, field, json) {
+    const scalarValue = scalarFromJson(field, json, false);
+    if (scalarValue === tokenNull) {
+        msg.clear(field);
+    }
+    else {
+        msg.set(field, scalarValue);
+    }
+}
+const tokenIgnoredUnknownEnum = Symbol();
+function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
+    if (json === null) {
+        if (desc.typeName == "google.protobuf.NullValue") {
+            return 0; // google.protobuf.NullValue.NULL_VALUE = 0
+        }
+        return nullAsZeroValue ? desc.values[0].number : tokenNull;
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (typeof json) {
+        case "number":
+            if (Number.isInteger(json)) {
+                return json;
+            }
+            break;
+        case "string":
+            const value = desc.values.find((ev) => ev.name === json);
+            if (value !== undefined) {
+                return value.number;
+            }
+            if (ignoreUnknownFields) {
+                return tokenIgnoredUnknownEnum;
+            }
+            break;
+    }
+    throw new Error(`cannot decode ${desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+}
+const tokenNull = Symbol();
+function scalarFromJson(field, json, nullAsZeroValue) {
+    if (json === null) {
+        if (nullAsZeroValue) {
+            return (0, scalar_js_1.scalarZeroValue)(field.scalar, false);
+        }
+        return tokenNull;
+    }
+    // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number.
+    // string, bool: Supported by reflect.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+        // Either numbers or strings are accepted. Exponent notation is also accepted.
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            if (json === "NaN")
+                return NaN;
+            if (json === "Infinity")
+                return Number.POSITIVE_INFINITY;
+            if (json === "-Infinity")
+                return Number.NEGATIVE_INFINITY;
+            if (typeof json == "number") {
+                if (isNaN(json)) {
+                    // NaN must be encoded with string constants
+                    throw new error_js_1.FieldError(field, "unexpected NaN number");
+                }
+                if (!isFinite(json)) {
+                    // Infinity must be encoded with string constants
+                    throw new error_js_1.FieldError(field, "unexpected infinite number");
+                }
+                break;
+            }
+            if (typeof json == "string") {
+                if (json === "") {
+                    // empty string is not a number
+                    break;
+                }
+                if (json.trim().length !== json.length) {
+                    // extra whitespace
+                    break;
+                }
+                const float = Number(json);
+                if (!isFinite(float)) {
+                    // Infinity and NaN must be encoded with string constants
+                    break;
+                }
+                return float;
+            }
+            break;
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.UINT32:
+            return int32FromJson(json);
+        // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+        // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+        case descriptors_js_1.ScalarType.BYTES:
+            if (typeof json == "string") {
+                if (json === "") {
+                    return new Uint8Array(0);
+                }
+                try {
+                    return (0, base64_encoding_js_1.base64Decode)(json);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    throw new error_js_1.FieldError(field, message);
+                }
+            }
+            break;
+    }
+    return json;
+}
+/**
+ * Try to parse a JSON value to a map key for the reflect API.
+ *
+ * Returns the input if the JSON value cannot be converted.
+ */
+function mapKeyFromJson(type, json) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.BOOL:
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (json) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+            }
+            return json;
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+            return int32FromJson(json);
+        default:
+            return json;
+    }
+}
+/**
+ * Try to parse a JSON value to a 32-bit integer for the reflect API.
+ *
+ * Returns the input if the JSON value cannot be converted.
+ */
+function int32FromJson(json) {
+    if (typeof json == "string") {
+        if (json === "") {
+            // empty string is not a number
+            return json;
+        }
+        if (json.trim().length !== json.length) {
+            // extra whitespace
+            return json;
+        }
+        const num = Number(json);
+        if (Number.isNaN(num)) {
+            // not a number
+            return json;
+        }
+        return num;
+    }
+    return json;
+}
+function parseJsonString(jsonString, typeName) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`cannot decode message ${typeName} from JSON: ${message}`, 
+        // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+        { cause: e });
+    }
+}
+function tryWktFromJson(msg, jsonValue, opts) {
+    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
+        return false;
+    }
+    switch (msg.desc.typeName) {
+        case "google.protobuf.Any":
+            anyFromJson(msg.message, jsonValue, opts);
+            return true;
+        case "google.protobuf.Timestamp":
+            timestampFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.Duration":
+            durationFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.FieldMask":
+            fieldMaskFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.Struct":
+            structFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.Value":
+            valueFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.ListValue":
+            listValueFromJson(msg.message, jsonValue);
+            return true;
+        default:
+            if ((0, index_js_1.isWrapperDesc)(msg.desc)) {
+                const valueField = msg.desc.fields[0];
+                if (jsonValue === null) {
+                    msg.clear(valueField);
+                }
+                else {
+                    msg.set(valueField, scalarFromJson(valueField, jsonValue, true));
+                }
+                return true;
+            }
+            return false;
+    }
+}
+function anyFromJson(any, json, opts) {
+    var _a;
+    if (json === null || Array.isArray(json) || typeof json != "object") {
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: expected object but got ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    if (Object.keys(json).length == 0) {
+        return;
+    }
+    const typeUrl = json["@type"];
+    if (typeof typeUrl != "string" || typeUrl == "") {
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is empty`);
+    }
+    const typeName = typeUrl.includes("/")
+        ? typeUrl.substring(typeUrl.lastIndexOf("/") + 1)
+        : typeUrl;
+    if (!typeName.length) {
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is invalid`);
+    }
+    const desc = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getMessage(typeName);
+    if (!desc) {
+        throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`);
+    }
+    const msg = (0, reflect_js_1.reflect)(desc);
+    if (typeName.startsWith("google.protobuf.") &&
+        Object.prototype.hasOwnProperty.call(json, "value")) {
+        const value = json["value"];
+        readMessage(msg, value, opts);
+    }
+    else {
+        const copy = Object.assign({}, json);
+        delete copy["@type"];
+        readMessage(msg, copy, opts);
+    }
+    (0, index_js_1.anyPack)(msg.desc, msg.message, any);
+}
+function timestampFromJson(timestamp, json) {
+    if (typeof json !== "string") {
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+    if (!matches) {
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
+    }
+    const ms = Date.parse(
+    //prettier-ignore
+    matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+    if (Number.isNaN(ms)) {
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
+    }
+    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
+        ms > Date.parse("9999-12-31T23:59:59Z")) {
+        throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+    }
+    timestamp.seconds = proto_int64_js_1.protoInt64.parse(ms / 1000);
+    timestamp.nanos = 0;
+    if (matches[7]) {
+        timestamp.nanos =
+            parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) -
+                1000000000;
+    }
+}
+function durationFromJson(duration, json) {
+    if (typeof json !== "string") {
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
+    if (match === null) {
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    const longSeconds = Number(match[1]);
+    if (longSeconds > 315576000000 || longSeconds < -315576000000) {
+        throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    duration.seconds = proto_int64_js_1.protoInt64.parse(longSeconds);
+    if (typeof match[2] !== "string") {
+        return;
+    }
+    const nanosStr = match[2] + "0".repeat(9 - match[2].length);
+    duration.nanos = parseInt(nanosStr);
+    if (longSeconds < 0 || Object.is(longSeconds, -0)) {
+        duration.nanos = -duration.nanos;
+    }
+}
+function fieldMaskFromJson(fieldMask, json) {
+    if (typeof json !== "string") {
+        throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    if (json === "") {
+        return;
+    }
+    function camelToSnake(str) {
+        if (str.includes("_")) {
+            throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`);
+        }
+        const sc = str.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
+        return sc[0] === "_" ? sc.substring(1) : sc;
+    }
+    fieldMask.paths = json.split(",").map(camelToSnake);
+}
+function structFromJson(struct, json) {
+    if (typeof json != "object" || json == null || Array.isArray(json)) {
+        throw new Error(`cannot decode message ${struct.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    for (const [k, v] of Object.entries(json)) {
+        const parsedV = (0, create_js_1.create)(index_js_1.ValueSchema);
+        valueFromJson(parsedV, v);
+        struct.fields[k] = parsedV;
+    }
+}
+function valueFromJson(value, json) {
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                value.kind = { case: "nullValue", value: index_js_1.NullValue.NULL_VALUE };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = (0, create_js_1.create)(index_js_1.ListValueSchema);
+                listValueFromJson(listValue, json);
+                value.kind = { case: "listValue", value: listValue };
+            }
+            else {
+                const struct = (0, create_js_1.create)(index_js_1.StructSchema);
+                structFromJson(struct, json);
+                value.kind = { case: "structValue", value: struct };
+            }
+            break;
+        default:
+            throw new Error(`cannot decode message ${value.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    return value;
+}
+function listValueFromJson(listValue, json) {
+    if (!Array.isArray(json)) {
+        throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`);
+    }
+    for (const e of json) {
+        const value = (0, create_js_1.create)(index_js_1.ValueSchema);
+        valueFromJson(value, e);
+        listValue.values.push(value);
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/index.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/index.d.ts
@@ -0,0 +1,17 @@
+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 { hasExtension, getExtension, setExtension, clearExtension, hasOption, getOption, } from "./extensions.js";
+export * from "./proto-int64.js";
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/index.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/index.js
@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2021-2024 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);
+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);
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/is-message.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/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>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/is-message.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/is-message.js
@@ -0,0 +1,33 @@
+"use strict";
+// Copyright 2021-2024 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;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/json-value.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/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;
+};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/json-value.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/json-value.js
@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2021-2024 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 });
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/package.json
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/package.json
@@ -0,0 +1 @@
+{"type":"commonjs"}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/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 {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.js
@@ -0,0 +1,126 @@
+"use strict";
+// Copyright 2021-2024 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" &&
+        (typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
+    if (ok) {
+        const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), 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);
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/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 {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.js
@@ -0,0 +1,36 @@
+"use strict";
+// Copyright 2021-2024 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");
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/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;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.js
@@ -0,0 +1,77 @@
+"use strict";
+// Copyright 2021-2024 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, 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));
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.d.ts
@@ -0,0 +1,7 @@
+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 { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.js
@@ -0,0 +1,40 @@
+"use strict";
+// Copyright 2021-2024 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.isReflectMessage = exports.isReflectMap = exports.isReflectList = void 0;
+__exportStar(require("./error.js"), exports);
+__exportStar(require("./names.js"), exports);
+__exportStar(require("./nested-types.js"), exports);
+__exportStar(require("./reflect.js"), exports);
+__exportStar(require("./reflect-types.js"), exports);
+__exportStar(require("./scalar.js"), exports);
+var guard_js_1 = require("./guard.js");
+Object.defineProperty(exports, "isReflectList", { enumerable: true, get: function () { return guard_js_1.isReflectList; } });
+Object.defineProperty(exports, "isReflectMap", { enumerable: true, get: function () { return guard_js_1.isReflectMap; } });
+Object.defineProperty(exports, "isReflectMessage", { enumerable: true, get: function () { return guard_js_1.isReflectMessage; } });
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.d.ts
@@ -0,0 +1,11 @@
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+export declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
+ */
+export declare function safeObjectProperty(name: string): string;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.js
@@ -0,0 +1,73 @@
+"use strict";
+// Copyright 2021-2024 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.protoCamelCase = protoCamelCase;
+exports.safeObjectProperty = safeObjectProperty;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
+ */
+function safeObjectProperty(name) {
+    return reservedObjectProperties.has(name) ? name + "$" : name;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.d.ts
@@ -0,0 +1,12 @@
+import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js";
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+export declare function nestedTypes(desc: DescFile | DescMessage): Iterable<DescMessage | DescEnum | DescExtension | DescService>;
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+export declare function parentTypes(desc: AnyDesc): Parent[];
+type Parent = DescFile | DescEnum | DescMessage | DescService;
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.js
@@ -0,0 +1,70 @@
+"use strict";
+// Copyright 2021-2024 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.nestedTypes = nestedTypes;
+exports.parentTypes = parentTypes;
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+function* nestedTypes(desc) {
+    switch (desc.kind) {
+        case "file":
+            for (const message of desc.messages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.enums;
+            yield* desc.services;
+            yield* desc.extensions;
+            break;
+        case "message":
+            for (const message of desc.nestedMessages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.nestedEnums;
+            yield* desc.nestedExtensions;
+            break;
+    }
+}
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+function parentTypes(desc) {
+    const parents = [];
+    while (desc.kind !== "file") {
+        const p = parent(desc);
+        desc = p;
+        parents.push(p);
+    }
+    return parents;
+}
+function parent(desc) {
+    var _a;
+    switch (desc.kind) {
+        case "enum_value":
+        case "field":
+        case "oneof":
+        case "rpc":
+            return desc.parent;
+        case "service":
+            return desc.file;
+        case "extension":
+        case "enum":
+        case "message":
+            return (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file;
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.d.ts
@@ -0,0 +1,19 @@
+import { type DescField } from "../descriptors.js";
+import { FieldError } from "./error.js";
+/**
+ * Check whether the given field value is valid for the reflect API.
+ */
+export declare function checkField(field: DescField, value: unknown): FieldError | undefined;
+/**
+ * Check whether the given list item is valid for the reflect API.
+ */
+export declare function checkListItem(field: DescField & {
+    fieldKind: "list";
+}, index: number, value: unknown): FieldError | undefined;
+/**
+ * Check whether the given map key and value are valid for the reflect API.
+ */
+export declare function checkMapEntry(field: DescField & {
+    fieldKind: "map";
+}, key: unknown, value: unknown): FieldError | undefined;
+export declare function formatVal(val: unknown): string;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.js
@@ -0,0 +1,266 @@
+"use strict";
+// Copyright 2021-2024 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.checkField = checkField;
+exports.checkListItem = checkListItem;
+exports.checkMapEntry = checkMapEntry;
+exports.formatVal = formatVal;
+const descriptors_js_1 = require("../descriptors.js");
+const is_message_js_1 = require("../is-message.js");
+const error_js_1 = require("./error.js");
+const guard_js_1 = require("./guard.js");
+const binary_encoding_js_1 = require("../wire/binary-encoding.js");
+const text_encoding_js_1 = require("../wire/text-encoding.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+/**
+ * Check whether the given field value is valid for the reflect API.
+ */
+function checkField(field, value) {
+    const check = field.fieldKind == "list"
+        ? (0, guard_js_1.isReflectList)(value, field)
+        : field.fieldKind == "map"
+            ? (0, guard_js_1.isReflectMap)(value, field)
+            : checkSingular(field, value);
+    if (check === true) {
+        return undefined;
+    }
+    let reason;
+    switch (field.fieldKind) {
+        case "list":
+            reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`;
+            break;
+        case "map":
+            reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`;
+            break;
+        default: {
+            reason = reasonSingular(field, value, check);
+        }
+    }
+    return new error_js_1.FieldError(field, reason);
+}
+/**
+ * Check whether the given list item is valid for the reflect API.
+ */
+function checkListItem(field, index, value) {
+    const check = checkSingular(field, value);
+    if (check !== true) {
+        return new error_js_1.FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+    }
+    return undefined;
+}
+/**
+ * Check whether the given map key and value are valid for the reflect API.
+ */
+function checkMapEntry(field, key, value) {
+    const checkKey = checkScalarValue(key, field.mapKey);
+    if (checkKey !== true) {
+        return new error_js_1.FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+    }
+    const checkVal = checkSingular(field, value);
+    if (checkVal !== true) {
+        return new error_js_1.FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+    }
+    return undefined;
+}
+function checkSingular(field, value) {
+    if (field.scalar !== undefined) {
+        return checkScalarValue(value, field.scalar);
+    }
+    if (field.enum !== undefined) {
+        if (field.enum.open) {
+            return Number.isInteger(value);
+        }
+        return field.enum.values.some((v) => v.number === value);
+    }
+    return (0, guard_js_1.isReflectMessage)(value, field.message);
+}
+function checkScalarValue(value, scalar) {
+    switch (scalar) {
+        case descriptors_js_1.ScalarType.DOUBLE:
+            return typeof value == "number";
+        case descriptors_js_1.ScalarType.FLOAT:
+            if (typeof value != "number") {
+                return false;
+            }
+            if (Number.isNaN(value) || !Number.isFinite(value)) {
+                return true;
+            }
+            if (value > binary_encoding_js_1.FLOAT32_MAX || value < binary_encoding_js_1.FLOAT32_MIN) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+            // signed
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            if (value > binary_encoding_js_1.INT32_MAX || value < binary_encoding_js_1.INT32_MIN) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+            // unsigned
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            if (value > binary_encoding_js_1.UINT32_MAX || value < 0) {
+                return `${value.toFixed()} out of range`;
+            }
+            return true;
+        case descriptors_js_1.ScalarType.BOOL:
+            return typeof value == "boolean";
+        case descriptors_js_1.ScalarType.STRING:
+            if (typeof value != "string") {
+                return false;
+            }
+            return (0, text_encoding_js_1.getTextEncoding)().checkUtf8(value) || "invalid UTF8";
+        case descriptors_js_1.ScalarType.BYTES:
+            return value instanceof Uint8Array;
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            // signed
+            if (typeof value != "string" &&
+                typeof value !== "bigint" &&
+                typeof value !== "number") {
+                return false;
+            }
+            try {
+                proto_int64_js_1.protoInt64.parse(value);
+            }
+            catch (e) {
+                return `${value} out of range`;
+            }
+            return true;
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+            // unsigned
+            if (typeof value != "string" &&
+                typeof value !== "bigint" &&
+                typeof value !== "number") {
+                return false;
+            }
+            try {
+                proto_int64_js_1.protoInt64.uParse(value);
+            }
+            catch (e) {
+                return `${value} out of range`;
+            }
+            return true;
+    }
+}
+function reasonSingular(field, val, details) {
+    details =
+        typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
+    if (field.scalar !== undefined) {
+        return `expected ${scalarTypeDescription(field.scalar)}` + details;
+    }
+    else if (field.enum !== undefined) {
+        return `expected ${field.enum.toString()}` + details;
+    }
+    return `expected ${formatReflectMessage(field.message)}` + details;
+}
+function formatVal(val) {
+    switch (typeof val) {
+        case "object":
+            if (val === null) {
+                return "null";
+            }
+            if (val instanceof Uint8Array) {
+                return `Uint8Array(${val.length})`;
+            }
+            if (Array.isArray(val)) {
+                return `Array(${val.length})`;
+            }
+            if ((0, guard_js_1.isReflectList)(val)) {
+                return formatReflectList(val.field());
+            }
+            if ((0, guard_js_1.isReflectMap)(val)) {
+                return formatReflectMap(val.field());
+            }
+            if ((0, guard_js_1.isReflectMessage)(val)) {
+                return formatReflectMessage(val.desc);
+            }
+            if ((0, is_message_js_1.isMessage)(val)) {
+                return `message ${val.$typeName}`;
+            }
+            return "object";
+        case "string":
+            return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`;
+        case "boolean":
+            return String(val);
+        case "number":
+            return String(val);
+        case "bigint":
+            return String(val) + "n";
+        default:
+            // "symbol" | "undefined" | "object" | "function"
+            return typeof val;
+    }
+}
+function formatReflectMessage(desc) {
+    return `ReflectMessage (${desc.typeName})`;
+}
+function formatReflectList(field) {
+    switch (field.listKind) {
+        case "message":
+            return `ReflectList (${field.message.toString()})`;
+        case "enum":
+            return `ReflectList (${field.enum.toString()})`;
+        case "scalar":
+            return `ReflectList (${descriptors_js_1.ScalarType[field.scalar]})`;
+    }
+}
+function formatReflectMap(field) {
+    switch (field.mapKind) {
+        case "message":
+            return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${field.message.toString()})`;
+        case "enum":
+            return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${field.enum.toString()})`;
+        case "scalar":
+            return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${descriptors_js_1.ScalarType[field.scalar]})`;
+    }
+}
+function scalarTypeDescription(scalar) {
+    switch (scalar) {
+        case descriptors_js_1.ScalarType.STRING:
+            return "string";
+        case descriptors_js_1.ScalarType.BOOL:
+            return "boolean";
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SINT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+            return "bigint (int64)";
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+            return "bigint (uint64)";
+        case descriptors_js_1.ScalarType.BYTES:
+            return "Uint8Array";
+        case descriptors_js_1.ScalarType.DOUBLE:
+            return "number (float64)";
+        case descriptors_js_1.ScalarType.FLOAT:
+            return "number (float32)";
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+            return "number (uint32)";
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+            return "number (int32)";
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.d.ts
@@ -0,0 +1,217 @@
+import { type DescField, type DescMessage, type DescOneof } from "../descriptors.js";
+import { unsafeLocal } from "./unsafe.js";
+import type { Message, UnknownField } from "../types.js";
+import type { ScalarValue } from "./scalar.js";
+/**
+ * ReflectMessage provides dynamic access and manipulation of a message.
+ */
+export interface ReflectMessage {
+    /**
+     * The underlying message instance.
+     */
+    readonly message: Message;
+    /**
+     * The descriptor for the message.
+     */
+    readonly desc: DescMessage;
+    /**
+     * The fields of the message. This is a shortcut to message.fields.
+     */
+    readonly fields: readonly DescField[];
+    /**
+     * The fields of the message, sorted by field number ascending.
+     */
+    readonly sortedFields: readonly DescField[];
+    /**
+     * Oneof groups of the message. This is a shortcut to message.oneofs.
+     */
+    readonly oneofs: readonly DescOneof[];
+    /**
+     * Fields and oneof groups for this message. This is a shortcut to message.members.
+     */
+    readonly members: readonly (DescField | DescOneof)[];
+    /**
+     * Find a field by number.
+     */
+    findNumber(number: number): DescField | undefined;
+    /**
+     * Returns true if the field is set.
+     *
+     * - Scalar and enum fields with implicit presence (proto3):
+     *   Set if not a zero value.
+     *
+     * - Scalar and enum fields with explicit presence (proto2, oneof):
+     *   Set if a value was set when creating or parsing the message, or when a
+     *   value was assigned to the field's property.
+     *
+     * - Message fields:
+     *   Set if the property is not undefined.
+     *
+     * - List and map fields:
+     *   Set if not empty.
+     */
+    isSet(field: DescField): boolean;
+    /**
+     * Resets the field, so that isSet() will return false.
+     */
+    clear(field: DescField): void;
+    /**
+     * Return the selected field of a oneof group.
+     */
+    oneofCase(oneof: DescOneof): DescField | undefined;
+    /**
+     * Returns the field value. Values are converted or wrapped to make it easier
+     * to manipulate messages.
+     *
+     * - Scalar fields:
+     *   Returns the value, but converts 64-bit integer fields with the option
+     *   `jstype=JS_STRING` to a bigint value.
+     *   If the field is not set, the default value is returned. If no default
+     *   value is set, the zero value is returned.
+     *
+     * - Enum fields:
+     *   Returns the numeric value. If the field is not set, the default value is
+     *   returned. If no default value is set, the zero value is returned.
+     *
+     * - Message fields:
+     *   Returns a ReflectMessage. If the field is not set, a new message is
+     *   returned, but not set on the field.
+     *
+     * - List fields:
+     *   Returns a ReflectList object.
+     *
+     * - Map fields:
+     *   Returns a ReflectMap object.
+     *
+     * Note that get() never returns `undefined`. To determine whether a field is
+     * set, use isSet().
+     */
+    get<Field extends DescField>(field: Field): ReflectMessageGet<Field>;
+    /**
+     * Set a field value.
+     *
+     * Expects values in the same form that get() returns:
+     *
+     * - Scalar fields:
+     *   64-bit integer fields with the option `jstype=JS_STRING` as a bigint value.
+     *
+     * - Message fields:
+     *   ReflectMessage.
+     *
+     * - List fields:
+     *   ReflectList.
+     *
+     * - Map fields:
+     *   ReflectMap.
+     *
+     * Throws an error if the value is invalid for the field. `undefined` is not
+     * a valid value. To reset a field, use clear().
+     */
+    set<Field extends DescField>(field: Field, value: unknown): void;
+    /**
+     * Returns the unknown fields of the message.
+     */
+    getUnknown(): UnknownField[] | undefined;
+    /**
+     * Sets the unknown fields of the message, overwriting any previous values.
+     */
+    setUnknown(value: UnknownField[]): void;
+    [unsafeLocal]: Message;
+}
+/**
+ * ReflectList provides dynamic access and manipulation of a list field on a
+ * message.
+ *
+ * ReflectList is iterable - you can loop through all items with a for...of loop.
+ *
+ * Values are converted or wrapped to make it easier to manipulate them:
+ * - Scalar 64-bit integer fields with the option `jstype=JS_STRING` are
+ *   converted to bigint.
+ * - Messages are wrapped in a ReflectMessage.
+ */
+export interface ReflectList<V = unknown> extends Iterable<V> {
+    /**
+     * Returns the list field.
+     */
+    field(): DescField & {
+        fieldKind: "list";
+    };
+    /**
+     * The size of the list.
+     */
+    readonly size: number;
+    /**
+     * Retrieves the item at the specified index, or undefined if the index
+     * is out of range.
+     */
+    get(index: number): V | undefined;
+    /**
+     * Adds an item at the end of the list.
+     * Throws an error if an item is invalid for this list.
+     */
+    add(item: V): void;
+    /**
+     * Replaces the item at the specified index with the specified item.
+     * Throws an error if the index is out of range (index < 0 || index >= size).
+     * Throws an error if the item is invalid for this list.
+     */
+    set(index: number, item: V): void;
+    /**
+     * Removes all items from the list.
+     */
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<V>;
+    entries(): IterableIterator<[number, V]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<V>;
+    [unsafeLocal]: unknown[];
+}
+/**
+ * ReflectMap provides dynamic access and manipulation of a map field on a
+ * message.
+ *
+ * ReflectMap is iterable - you can loop through all entries with a for...of loop.
+ *
+ * Keys and values are converted or wrapped to make it easier to manipulate them:
+ * - A map field is a record object on a message, where keys are always strings.
+ *   ReflectMap converts keys to their closest possible type in TypeScript.
+ * - Messages are wrapped in a ReflectMessage.
+ */
+export interface ReflectMap<K = unknown, V = unknown> extends ReadonlyMap<K, V> {
+    /**
+     * Returns the map field.
+     */
+    field(): DescField & {
+        fieldKind: "map";
+    };
+    /**
+     * Removes the entry for the specified key.
+     * Returns false if the key is unknown.
+     */
+    delete(key: K): boolean;
+    /**
+     * Sets or replaces the item at the specified key with the specified value.
+     * Throws an error if the key or value is invalid for this map.
+     */
+    set(key: K, value: V): this;
+    /**
+     * Removes all entries from the map.
+     */
+    clear(): void;
+    [unsafeLocal]: Record<string, unknown>;
+}
+/**
+ * The return type of ReflectMessage.get()
+ */
+export type ReflectMessageGet<Field extends DescField = DescField> = (Field extends {
+    fieldKind: "map";
+} ? ReflectMap : Field extends {
+    fieldKind: "list";
+} ? ReflectList : Field extends {
+    fieldKind: "enum";
+} ? number : Field extends {
+    fieldKind: "message";
+} ? ReflectMessage : Field extends {
+    fieldKind: "scalar";
+    scalar: infer T;
+} ? ScalarValue<T> : never);
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.js
@@ -0,0 +1,16 @@
+"use strict";
+// Copyright 2021-2024 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 });
+const unsafe_js_1 = require("./unsafe.js");
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.d.ts
@@ -0,0 +1,43 @@
+import { type DescField, type DescMessage } from "../descriptors.js";
+import type { MessageShape } from "../types.js";
+import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
+/**
+ * Create a ReflectMessage.
+ */
+export declare function reflect<Desc extends DescMessage>(messageDesc: Desc, message?: MessageShape<Desc>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMessage;
+/**
+ * Create a ReflectList.
+ */
+export declare function reflectList<V>(field: DescField & {
+    fieldKind: "list";
+}, unsafeInput?: unknown[], 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectList<V>;
+/**
+ * Create a ReflectMap.
+ */
+export declare function reflectMap<K = unknown, V = unknown>(field: DescField & {
+    fieldKind: "map";
+}, unsafeInput?: Record<string, unknown>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMap<K, V>;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.js
@@ -0,0 +1,539 @@
+"use strict";
+// Copyright 2021-2024 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.reflect = reflect;
+exports.reflectList = reflectList;
+exports.reflectMap = reflectMap;
+const descriptors_js_1 = require("../descriptors.js");
+const reflect_check_js_1 = require("./reflect-check.js");
+const error_js_1 = require("./error.js");
+const unsafe_js_1 = require("./unsafe.js");
+const create_js_1 = require("../create.js");
+const wrappers_js_1 = require("../wkt/wrappers.js");
+const scalar_js_1 = require("./scalar.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+const guard_js_1 = require("./guard.js");
+/**
+ * Create a ReflectMessage.
+ */
+function reflect(messageDesc, message, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectMessageImpl(messageDesc, message, check);
+}
+class ReflectMessageImpl {
+    get sortedFields() {
+        var _a;
+        return ((_a = this._sortedFields) !== null && _a !== void 0 ? _a : (this._sortedFields = this.desc.fields
+            .concat()
+            .sort((a, b) => a.number - b.number)));
+    }
+    constructor(messageDesc, message, check = true) {
+        this.lists = new Map();
+        this.maps = new Map();
+        this.check = check;
+        this.desc = messageDesc;
+        this.message = this[unsafe_js_1.unsafeLocal] = message !== null && message !== void 0 ? message : (0, create_js_1.create)(messageDesc);
+        this.fields = messageDesc.fields;
+        this.oneofs = messageDesc.oneofs;
+        this.members = messageDesc.members;
+    }
+    findNumber(number) {
+        if (!this._fieldsByNumber) {
+            this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+        }
+        return this._fieldsByNumber.get(number);
+    }
+    oneofCase(oneof) {
+        assertOwn(this.message, oneof);
+        return (0, unsafe_js_1.unsafeOneofCase)(this.message, oneof);
+    }
+    isSet(field) {
+        assertOwn(this.message, field);
+        return (0, unsafe_js_1.unsafeIsSet)(this.message, field);
+    }
+    clear(field) {
+        assertOwn(this.message, field);
+        (0, unsafe_js_1.unsafeClear)(this.message, field);
+    }
+    get(field) {
+        assertOwn(this.message, field);
+        const value = (0, unsafe_js_1.unsafeGet)(this.message, field);
+        switch (field.fieldKind) {
+            case "list":
+                // eslint-disable-next-line no-case-declarations
+                let list = this.lists.get(field);
+                if (!list || list[unsafe_js_1.unsafeLocal] !== value) {
+                    this.lists.set(field, (list = new ReflectListImpl(field, value, this.check)));
+                }
+                return list;
+            case "map":
+                // eslint-disable-next-line no-case-declarations
+                let map = this.maps.get(field);
+                if (!map || map[unsafe_js_1.unsafeLocal] !== value) {
+                    this.maps.set(field, (map = new ReflectMapImpl(field, value, this.check)));
+                }
+                return map;
+            case "message":
+                return messageToReflect(field, value, this.check);
+            case "scalar":
+                return (value === undefined
+                    ? (0, scalar_js_1.scalarZeroValue)(field.scalar, false)
+                    : longToReflect(field, value));
+            case "enum":
+                return (value !== null && value !== void 0 ? value : field.enum.values[0].number);
+        }
+    }
+    set(field, value) {
+        assertOwn(this.message, field);
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkField)(field, value);
+            if (err) {
+                throw err;
+            }
+        }
+        let local;
+        if (field.fieldKind == "message") {
+            local = messageToLocal(field, value);
+        }
+        else if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
+            local = value[unsafe_js_1.unsafeLocal];
+        }
+        else {
+            local = longToLocal(field, value);
+        }
+        (0, unsafe_js_1.unsafeSet)(this.message, field, local);
+    }
+    getUnknown() {
+        return this.message.$unknown;
+    }
+    setUnknown(value) {
+        this.message.$unknown = value;
+    }
+}
+function assertOwn(owner, member) {
+    if (member.parent.typeName !== owner.$typeName) {
+        throw new error_js_1.FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+    }
+}
+/**
+ * Create a ReflectList.
+ */
+function reflectList(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
+}
+class ReflectListImpl {
+    field() {
+        return this._field;
+    }
+    get size() {
+        return this._arr.length;
+    }
+    constructor(field, unsafeInput, check) {
+        this._field = field;
+        this._arr = this[unsafe_js_1.unsafeLocal] = unsafeInput;
+        this.check = check;
+    }
+    get(index) {
+        const item = this._arr[index];
+        return item === undefined
+            ? undefined
+            : listItemToReflect(this._field, item, this.check);
+    }
+    set(index, item) {
+        if (index < 0 || index >= this._arr.length) {
+            throw new error_js_1.FieldError(this._field, `list item #${index + 1}: out of range`);
+        }
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkListItem)(this._field, index, item);
+            if (err) {
+                throw err;
+            }
+        }
+        this._arr[index] = listItemToLocal(this._field, item);
+    }
+    add(item) {
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkListItem)(this._field, this._arr.length, item);
+            if (err) {
+                throw err;
+            }
+        }
+        this._arr.push(listItemToLocal(this._field, item));
+        return undefined;
+    }
+    clear() {
+        this._arr.splice(0, this._arr.length);
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    keys() {
+        return this._arr.keys();
+    }
+    *values() {
+        for (const item of this._arr) {
+            yield listItemToReflect(this._field, item, this.check);
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._arr.length; i++) {
+            yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+        }
+    }
+}
+/**
+ * Create a ReflectMap.
+ */
+function reflectMap(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectMapImpl(field, unsafeInput, check);
+}
+class ReflectMapImpl {
+    constructor(field, unsafeInput, check = true) {
+        this.obj = this[unsafe_js_1.unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+        this.check = check;
+        this._field = field;
+    }
+    field() {
+        return this._field;
+    }
+    set(key, value) {
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkMapEntry)(this._field, key, value);
+            if (err) {
+                throw err;
+            }
+        }
+        this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+        return this;
+    }
+    delete(key) {
+        const k = mapKeyToLocal(key);
+        const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+        if (has) {
+            delete this.obj[k];
+        }
+        return has;
+    }
+    clear() {
+        for (const key of Object.keys(this.obj)) {
+            delete this.obj[key];
+        }
+    }
+    get(key) {
+        let val = this.obj[mapKeyToLocal(key)];
+        if (val !== undefined) {
+            val = mapValueToReflect(this._field, val, this.check);
+        }
+        return val;
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+    }
+    *keys() {
+        for (const objKey of Object.keys(this.obj)) {
+            yield mapKeyToReflect(objKey, this._field.mapKey);
+        }
+    }
+    *entries() {
+        for (const objEntry of Object.entries(this.obj)) {
+            yield [
+                mapKeyToReflect(objEntry[0], this._field.mapKey),
+                mapValueToReflect(this._field, objEntry[1], this.check),
+            ];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get size() {
+        return Object.keys(this.obj).length;
+    }
+    *values() {
+        for (const val of Object.values(this.obj)) {
+            yield mapValueToReflect(this._field, val, this.check);
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        for (const mapEntry of this.entries()) {
+            callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+        }
+    }
+}
+function messageToLocal(field, value) {
+    if (!(0, guard_js_1.isReflectMessage)(value)) {
+        return value;
+    }
+    if ((0, wrappers_js_1.isWrapper)(value.message) &&
+        !field.oneof &&
+        field.fieldKind == "message") {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return value.message.value;
+    }
+    if (value.desc.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value") {
+        // google.protobuf.Struct is represented with JsonObject when used in a
+        // field, except when used in google.protobuf.Value.
+        return wktStructToLocal(value.message);
+    }
+    return value.message;
+}
+function messageToReflect(field, value, check) {
+    if (value !== undefined) {
+        if ((0, wrappers_js_1.isWrapperDesc)(field.message) &&
+            !field.oneof &&
+            field.fieldKind == "message") {
+            // Types from google/protobuf/wrappers.proto are unwrapped when used in
+            // a singular field that is not part of a oneof group.
+            value = {
+                $typeName: field.message.typeName,
+                value: longToReflect(field.message.fields[0], value),
+            };
+        }
+        else if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName != "google.protobuf.Value" &&
+            (0, guard_js_1.isObject)(value)) {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            value = wktStructToReflect(value);
+        }
+    }
+    return new ReflectMessageImpl(field.message, value, check);
+}
+function listItemToLocal(field, value) {
+    if (field.listKind == "message") {
+        return messageToLocal(field, value);
+    }
+    return longToLocal(field, value);
+}
+function listItemToReflect(field, value, check) {
+    if (field.listKind == "message") {
+        return messageToReflect(field, value, check);
+    }
+    return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+    if (field.mapKind == "message") {
+        return messageToLocal(field, value);
+    }
+    return longToLocal(field, value);
+}
+function mapValueToReflect(field, value, check) {
+    if (field.mapKind == "message") {
+        return messageToReflect(field, value, check);
+    }
+    return value;
+}
+function mapKeyToLocal(key) {
+    return typeof key == "string" || typeof key == "number" ? key : String(key);
+}
+/**
+ * Converts a map key (any scalar value except float, double, or bytes) from its
+ * representation in a message (string or number, the only possible object key
+ * types) to the closest possible type in ECMAScript.
+ */
+function mapKeyToReflect(key, type) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            return key;
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32: {
+            const n = Number.parseInt(key);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+            break;
+        }
+        case descriptors_js_1.ScalarType.BOOL:
+            switch (key) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+            }
+            break;
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+            try {
+                return proto_int64_js_1.protoInt64.uParse(key);
+            }
+            catch (_a) {
+                //
+            }
+            break;
+        default:
+            // INT64, SFIXED64, SINT64
+            try {
+                return proto_int64_js_1.protoInt64.parse(key);
+            }
+            catch (_b) {
+                //
+            }
+            break;
+    }
+    return key;
+}
+function longToReflect(field, value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if ("longAsString" in field &&
+                field.longAsString &&
+                typeof value == "string") {
+                value = proto_int64_js_1.protoInt64.parse(value);
+            }
+            break;
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+            if ("longAsString" in field &&
+                field.longAsString &&
+                typeof value == "string") {
+                value = proto_int64_js_1.protoInt64.uParse(value);
+            }
+            break;
+    }
+    return value;
+}
+function longToLocal(field, value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if ("longAsString" in field && field.longAsString) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = proto_int64_js_1.protoInt64.parse(value);
+            }
+            break;
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+            if ("longAsString" in field && field.longAsString) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = proto_int64_js_1.protoInt64.uParse(value);
+            }
+            break;
+    }
+    return value;
+}
+function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if ((0, guard_js_1.isObject)(json)) {
+        for (const [k, v] of Object.entries(json)) {
+            struct.fields[k] = wktValueToReflect(v);
+        }
+    }
+    return struct;
+}
+function wktStructToLocal(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = wktValueToLocal(v);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- invalid input is unselected kind
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                const nullValue = 0;
+                value.kind = { case: "nullValue", value: nullValue };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.d.ts
@@ -0,0 +1,21 @@
+import { ScalarType } from "../descriptors.js";
+/**
+ * ScalarValue maps from a scalar field type to a TypeScript value type.
+ */
+export type ScalarValue<T = ScalarType, LongAsString extends boolean = false> = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SFIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.UINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.FIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never;
+/**
+ * Returns true if both scalar values are equal.
+ */
+export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean;
+/**
+ * Returns the zero value for the given scalar type.
+ */
+export declare function scalarZeroValue<T extends ScalarType, LongAsString extends boolean>(type: T, longAsString: LongAsString): ScalarValue<T, LongAsString>;
+/**
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.js
@@ -0,0 +1,103 @@
+"use strict";
+// Copyright 2021-2024 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.scalarEquals = scalarEquals;
+exports.scalarZeroValue = scalarZeroValue;
+exports.isScalarZeroValue = isScalarZeroValue;
+const proto_int64_js_1 = require("../proto-int64.js");
+const descriptors_js_1 = require("../descriptors.js");
+/**
+ * Returns true if both scalar values are equal.
+ */
+function scalarEquals(type, a, b) {
+    if (a === b) {
+        // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
+        return true;
+    }
+    // Special case BYTES - we need to compare each byte individually
+    if (type == descriptors_js_1.ScalarType.BYTES) {
+        if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+            return false;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Special case 64-bit integers - we support number, string and bigint representation.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (type) {
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            // Loose comparison will match between 0n, 0 and "0".
+            return a == b;
+    }
+    // Anything that hasn't been caught by strict comparison or special cased
+    // BYTES and 64-bit integers is not equal.
+    return false;
+}
+/**
+ * Returns the zero value for the given scalar type.
+ */
+function scalarZeroValue(type, longAsString) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            return "";
+        case descriptors_js_1.ScalarType.BOOL:
+            return false;
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return 0;
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            return 0.0;
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            return (longAsString ? "0" : proto_int64_js_1.protoInt64.zero);
+        case descriptors_js_1.ScalarType.BYTES:
+            return new Uint8Array(0);
+    }
+}
+/**
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+function isScalarZeroValue(type, value) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.BOOL:
+            return value === false;
+        case descriptors_js_1.ScalarType.STRING:
+            return value === "";
+        case descriptors_js_1.ScalarType.BYTES:
+            return value instanceof Uint8Array && !value.byteLength;
+        default:
+            return value == 0; // Loose comparison matches 0n, 0 and "0"
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.d.ts
@@ -0,0 +1,42 @@
+import type { DescField, DescOneof } from "../descriptors.js";
+export declare const unsafeLocal: unique symbol;
+/**
+ * Return the selected field of a oneof group.
+ *
+ * @private
+ */
+export declare function unsafeOneofCase(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+oneof: DescOneof): DescField | undefined;
+/**
+ * Returns true if the field is set.
+ *
+ * @private
+ */
+export declare function unsafeIsSet(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+field: DescField): boolean;
+/**
+ * Returns true if the field is set, but only for singular fields with explicit
+ * presence (proto2).
+ *
+ * @private
+ */
+export declare function unsafeIsSetExplicit(target: object, localName: string): boolean;
+/**
+ * Return a field value, respecting oneof groups.
+ *
+ * @private
+ */
+export declare function unsafeGet(target: Record<string, unknown>, field: DescField): unknown;
+/**
+ * Set a field value, respecting oneof groups.
+ *
+ * @private
+ */
+export declare function unsafeSet(target: Record<string, unknown>, field: DescField, value: unknown): void;
+/**
+ * Resets the field, so that unsafeIsSet() will return false.
+ *
+ * @private
+ */
+export declare function unsafeClear(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+field: DescField): void;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.js
@@ -0,0 +1,148 @@
+"use strict";
+// Copyright 2021-2024 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.unsafeLocal = void 0;
+exports.unsafeOneofCase = unsafeOneofCase;
+exports.unsafeIsSet = unsafeIsSet;
+exports.unsafeIsSetExplicit = unsafeIsSetExplicit;
+exports.unsafeGet = unsafeGet;
+exports.unsafeSet = unsafeSet;
+exports.unsafeClear = unsafeClear;
+const scalar_js_1 = require("./scalar.js");
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const IMPLICIT = 2;
+exports.unsafeLocal = Symbol.for("reflect unsafe local");
+/**
+ * Return the selected field of a oneof group.
+ *
+ * @private
+ */
+function unsafeOneofCase(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+oneof) {
+    const c = target[oneof.localName].case;
+    if (c === undefined) {
+        return c;
+    }
+    return oneof.fields.find((f) => f.localName === c);
+}
+/**
+ * Returns true if the field is set.
+ *
+ * @private
+ */
+function unsafeIsSet(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+field) {
+    const name = field.localName;
+    if (field.oneof) {
+        return target[field.oneof.localName].case === name; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+    }
+    if (field.presence != IMPLICIT) {
+        // Fields with explicit presence have properties on the prototype chain
+        // for default / zero values (except for proto3).
+        return (target[name] !== undefined &&
+            Object.prototype.hasOwnProperty.call(target, name));
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.fieldKind) {
+        case "list":
+            return target[name].length > 0;
+        case "map":
+            return Object.keys(target[name]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        case "scalar":
+            return !(0, scalar_js_1.isScalarZeroValue)(field.scalar, target[name]);
+        case "enum":
+            return target[name] !== field.enum.values[0].number;
+    }
+    throw new Error("message field with implicit presence");
+}
+/**
+ * Returns true if the field is set, but only for singular fields with explicit
+ * presence (proto2).
+ *
+ * @private
+ */
+function unsafeIsSetExplicit(target, localName) {
+    return (Object.prototype.hasOwnProperty.call(target, localName) &&
+        target[localName] !== undefined);
+}
+/**
+ * Return a field value, respecting oneof groups.
+ *
+ * @private
+ */
+function unsafeGet(target, field) {
+    if (field.oneof) {
+        const oneof = target[field.oneof.localName];
+        if (oneof.case === field.localName) {
+            return oneof.value;
+        }
+        return undefined;
+    }
+    return target[field.localName];
+}
+/**
+ * Set a field value, respecting oneof groups.
+ *
+ * @private
+ */
+function unsafeSet(target, field, value) {
+    if (field.oneof) {
+        target[field.oneof.localName] = {
+            case: field.localName,
+            value: value,
+        };
+    }
+    else {
+        target[field.localName] = value;
+    }
+}
+/**
+ * Resets the field, so that unsafeIsSet() will return false.
+ *
+ * @private
+ */
+function unsafeClear(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+field) {
+    const name = field.localName;
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        if (target[oneofLocalName].case === name) {
+            target[oneofLocalName] = { case: undefined };
+        }
+    }
+    else if (field.presence != IMPLICIT) {
+        // Fields with explicit presence have properties on the prototype chain
+        // for default / zero values (except for proto3). By deleting their own
+        // property, the field is reset.
+        delete target[name];
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (field.fieldKind) {
+            case "map":
+                target[name] = {};
+                break;
+            case "list":
+                target[name] = [];
+                break;
+            case "enum":
+                target[name] = field.enum.values[0].number;
+                break;
+            case "scalar":
+                target[name] = (0, scalar_js_1.scalarZeroValue)(field.scalar, field.longAsString);
+                break;
+        }
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/registry.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/registry.d.ts
@@ -0,0 +1,98 @@
+import type { FileDescriptorProto, FileDescriptorSet } from "./wkt/gen/google/protobuf/descriptor_pb.js";
+import { type DescEnum, type DescExtension, type DescFile, type DescMessage, type DescService, type SupportedEdition } from "./descriptors.js";
+/**
+ * A set of descriptors for messages, enumerations, extensions,
+ * and services.
+ */
+export interface Registry {
+    readonly kind: "registry";
+    /**
+     * All types (message, enumeration, extension, or service) contained
+     * in this registry.
+     */
+    [Symbol.iterator](): IterableIterator<DescMessage | DescEnum | DescExtension | DescService>;
+    /**
+     * Look up a type (message, enumeration, extension, or service) by
+     * its fully qualified name.
+     */
+    get(typeName: string): DescMessage | DescEnum | DescExtension | DescService | undefined;
+    /**
+     * Look up a message descriptor by its fully qualified name.
+     */
+    getMessage(typeName: string): DescMessage | undefined;
+    /**
+     * Look up an enumeration descriptor by its fully qualified name.
+     */
+    getEnum(typeName: string): DescEnum | undefined;
+    /**
+     * Look up an extension descriptor by its fully qualified name.
+     */
+    getExtension(typeName: string): DescExtension | undefined;
+    /**
+     * Look up an extension by the extendee - the message it extends - and
+     * the extension number.
+     */
+    getExtensionFor(extendee: DescMessage, no: number): DescExtension | undefined;
+    /**
+     * Look up a service descriptor by its fully qualified name.
+     */
+    getService(typeName: string): DescService | undefined;
+}
+/**
+ * A registry that allows adding and removing descriptors.
+ */
+export interface MutableRegistry extends Registry {
+    /**
+     * Adds the given descriptor - but not types nested within - to the registry.
+     */
+    add(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+    /**
+     * Remove the given descriptor - but not types nested within - from the registry.
+     */
+    remove(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+}
+/**
+ * A registry that includes files.
+ */
+export interface FileRegistry extends Registry {
+    /**
+     * All files in this registry.
+     */
+    readonly files: Iterable<DescFile>;
+    /**
+     * Look up a file descriptor by file name.
+     */
+    getFile(fileName: string): DescFile | undefined;
+}
+/**
+ * Create a registry from the given inputs.
+ *
+ * An input can be:
+ * - Any message, enum, service, or extension descriptor, which adds just the
+ *   descriptor for this type.
+ * - A file descriptor, which adds all typed defined in this file.
+ * - A registry, which adds all types from the registry.
+ *
+ * For duplicate descriptors (same type name), the one given last wins.
+ */
+export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry;
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry;
+/**
+ * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet
+ * message.
+ */
+export declare function createFileRegistry(fileDescriptorSet: FileDescriptorSet): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorProto
+ * message. For every import, the given resolver function is called.
+ */
+export declare function createFileRegistry(fileDescriptorProto: FileDescriptorProto, resolve: (protoFileName: string) => FileDescriptorProto | DescFile | undefined): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from one or more registries,
+ * merging them.
+ */
+export declare function createFileRegistry(...registries: FileRegistry[]): FileRegistry;
+export declare const minimumEdition: SupportedEdition, maximumEdition: SupportedEdition;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/registry.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/registry.js
@@ -0,0 +1,911 @@
+"use strict";
+// Copyright 2021-2024 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.maximumEdition = exports.minimumEdition = void 0;
+exports.createRegistry = createRegistry;
+exports.createMutableRegistry = createMutableRegistry;
+exports.createFileRegistry = createFileRegistry;
+const descriptors_js_1 = require("./descriptors.js");
+const text_format_js_1 = require("./wire/text-format.js");
+const nested_types_js_1 = require("./reflect/nested-types.js");
+const unsafe_js_1 = require("./reflect/unsafe.js");
+const names_js_1 = require("./reflect/names.js");
+/**
+ * Create a registry from the given inputs.
+ *
+ * An input can be:
+ * - Any message, enum, service, or extension descriptor, which adds just the
+ *   descriptor for this type.
+ * - A file descriptor, which adds all typed defined in this file.
+ * - A registry, which adds all types from the registry.
+ *
+ * For duplicate descriptors (same type name), the one given last wins.
+ */
+function createRegistry(...input) {
+    return initBaseRegistry(input);
+}
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+function createMutableRegistry(...input) {
+    const reg = initBaseRegistry(input);
+    return Object.assign(Object.assign({}, reg), { remove(desc) {
+            var _a;
+            if (desc.kind == "extension") {
+                (_a = reg.extendees.get(desc.extendee.typeName)) === null || _a === void 0 ? void 0 : _a.delete(desc.number);
+            }
+            reg.types.delete(desc.typeName);
+        } });
+}
+function createFileRegistry(...args) {
+    const registry = createBaseRegistry();
+    if (!args.length) {
+        return registry;
+    }
+    if ("$typeName" in args[0] &&
+        args[0].$typeName == "google.protobuf.FileDescriptorSet") {
+        for (const file of args[0].file) {
+            addFile(file, registry);
+        }
+        return registry;
+    }
+    if ("$typeName" in args[0]) {
+        const input = args[0];
+        const resolve = args[1];
+        const seen = new Set();
+        // eslint-disable-next-line no-inner-declarations
+        function recurseDeps(file) {
+            const deps = [];
+            for (const protoFileName of file.dependency) {
+                if (registry.getFile(protoFileName) != undefined) {
+                    continue;
+                }
+                if (seen.has(protoFileName)) {
+                    continue;
+                }
+                const dep = resolve(protoFileName);
+                if (!dep) {
+                    throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
+                }
+                if ("kind" in dep) {
+                    registry.addFile(dep, false, true);
+                }
+                else {
+                    seen.add(dep.name);
+                    deps.push(dep);
+                }
+            }
+            return deps.concat(...deps.map(recurseDeps));
+        }
+        for (const file of [input, ...recurseDeps(input)].reverse()) {
+            addFile(file, registry);
+        }
+    }
+    else {
+        for (const fileReg of args) {
+            for (const file of fileReg.files) {
+                registry.addFile(file);
+            }
+        }
+    }
+    return registry;
+}
+/**
+ * @private
+ */
+function createBaseRegistry() {
+    const types = new Map();
+    const extendees = new Map();
+    const files = new Map();
+    return {
+        kind: "registry",
+        types,
+        extendees,
+        [Symbol.iterator]() {
+            return types.values();
+        },
+        get files() {
+            return files.values();
+        },
+        addFile(file, skipTypes, withDeps) {
+            files.set(file.proto.name, file);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (!skipTypes) {
+                for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
+                    this.add(type);
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (withDeps) {
+                for (const f of file.dependencies) {
+                    this.addFile(f, skipTypes, withDeps);
+                }
+            }
+        },
+        add(desc) {
+            if (desc.kind == "extension") {
+                let numberToExt = extendees.get(desc.extendee.typeName);
+                if (!numberToExt) {
+                    extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
+                }
+                numberToExt.set(desc.number, desc);
+            }
+            types.set(desc.typeName, desc);
+        },
+        get(typeName) {
+            return types.get(typeName);
+        },
+        getFile(fileName) {
+            return files.get(fileName);
+        },
+        getMessage(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : undefined;
+        },
+        getEnum(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : undefined;
+        },
+        getExtension(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : undefined;
+        },
+        getExtensionFor(extendee, no) {
+            var _a;
+            return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no);
+        },
+        getService(typeName) {
+            const t = types.get(typeName);
+            return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : undefined;
+        },
+    };
+}
+/**
+ * @private
+ */
+function initBaseRegistry(inputs) {
+    const registry = createBaseRegistry();
+    for (const input of inputs) {
+        switch (input.kind) {
+            case "registry":
+                for (const n of input) {
+                    registry.add(n);
+                }
+                break;
+            case "file":
+                registry.addFile(input);
+                break;
+            default:
+                registry.add(input);
+                break;
+        }
+    }
+    return registry;
+}
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
+const EDITION_PROTO2 = 998;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number;
+const EDITION_PROTO3 = 999;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_STRING: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_STRING = 9;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_GROUP = 10;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_MESSAGE = 11;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_BYTES = 12;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM: const $name: FieldDescriptorProto_Type.$localName = $number;
+const TYPE_ENUM = 14;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_REPEATED = 3;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_REQUIRED = 2;
+// bootstrap-inject google.protobuf.FieldOptions.JSType.JS_STRING: const $name: FieldOptions_JSType.$localName = $number;
+const JS_STRING = 1;
+// bootstrap-inject google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN: const $name: MethodOptions_IdempotencyLevel.$localName = $number;
+const IDEMPOTENCY_UNKNOWN = 0;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.EXPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const EXPLICIT = 1;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const IMPLICIT = 2;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// bootstrap-inject google.protobuf.FeatureSet.RepeatedFieldEncoding.PACKED: const $name: FeatureSet_RepeatedFieldEncoding.$localName = $number;
+const PACKED = 1;
+// bootstrap-inject google.protobuf.FeatureSet.MessageEncoding.DELIMITED: const $name: FeatureSet_MessageEncoding.$localName = $number;
+const DELIMITED = 2;
+// bootstrap-inject google.protobuf.FeatureSet.EnumType.OPEN: const $name: FeatureSet_EnumType.$localName = $number;
+const OPEN = 1;
+// prettier-ignore
+// bootstrap-inject defaults: EDITION_PROTO2 to EDITION_2023: export const minimumEdition: SupportedEdition = $minimumEdition, maximumEdition: SupportedEdition = $maximumEdition;
+// generated from protoc v28.3
+exports.minimumEdition = 998, exports.maximumEdition = 1000;
+const featureDefaults = {
+    // EDITION_PROTO2
+    998: {
+        fieldPresence: 1, // EXPLICIT,
+        enumType: 2, // CLOSED,
+        repeatedFieldEncoding: 2, // EXPANDED,
+        utf8Validation: 3, // NONE,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 2, // LEGACY_BEST_EFFORT,
+    },
+    // EDITION_PROTO3
+    999: {
+        fieldPresence: 2, // IMPLICIT,
+        enumType: 1, // OPEN,
+        repeatedFieldEncoding: 1, // PACKED,
+        utf8Validation: 2, // VERIFY,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 1, // ALLOW,
+    },
+    // EDITION_2023
+    1000: {
+        fieldPresence: 1, // EXPLICIT,
+        enumType: 1, // OPEN,
+        repeatedFieldEncoding: 1, // PACKED,
+        utf8Validation: 2, // VERIFY,
+        messageEncoding: 1, // LENGTH_PREFIXED,
+        jsonFormat: 1, // ALLOW,
+    },
+};
+/**
+ * Create a descriptor for a file, add it to the registry.
+ */
+function addFile(proto, reg) {
+    var _a, _b;
+    const file = {
+        kind: "file",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        edition: getFileEdition(proto),
+        name: proto.name.replace(/\.proto$/, ""),
+        dependencies: findFileDependencies(proto, reg),
+        enums: [],
+        messages: [],
+        extensions: [],
+        services: [],
+        toString() {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+            return `file ${proto.name}`;
+        },
+    };
+    const mapEntriesStore = new Map();
+    const mapEntries = {
+        get(typeName) {
+            return mapEntriesStore.get(typeName);
+        },
+        add(desc) {
+            var _a;
+            assert(((_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) === true);
+            mapEntriesStore.set(desc.typeName, desc);
+        },
+    };
+    for (const enumProto of proto.enumType) {
+        addEnum(enumProto, file, undefined, reg);
+    }
+    for (const messageProto of proto.messageType) {
+        addMessage(messageProto, file, undefined, reg, mapEntries);
+    }
+    for (const serviceProto of proto.service) {
+        addService(serviceProto, file, reg);
+    }
+    addExtensions(file, reg);
+    for (const mapEntry of mapEntriesStore.values()) {
+        // to create a map field, we need access to the map entry's fields
+        addFields(mapEntry, reg, mapEntries);
+    }
+    for (const message of file.messages) {
+        addFields(message, reg, mapEntries);
+        addExtensions(message, reg);
+    }
+    reg.addFile(file, true);
+}
+/**
+ * Create descriptors for extensions, and add them to the message / file,
+ * and to our cart.
+ * Recurses into nested types.
+ */
+function addExtensions(desc, reg) {
+    switch (desc.kind) {
+        case "file":
+            for (const proto of desc.proto.extension) {
+                const ext = newField(proto, desc, reg);
+                desc.extensions.push(ext);
+                reg.add(ext);
+            }
+            break;
+        case "message":
+            for (const proto of desc.proto.extension) {
+                const ext = newField(proto, desc, reg);
+                desc.nestedExtensions.push(ext);
+                reg.add(ext);
+            }
+            for (const message of desc.nestedMessages) {
+                addExtensions(message, reg);
+            }
+            break;
+    }
+}
+/**
+ * Create descriptors for fields and oneof groups, and add them to the message.
+ * Recurses into nested types.
+ */
+function addFields(message, reg, mapEntries) {
+    const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message));
+    const oneofsSeen = new Set();
+    for (const proto of message.proto.field) {
+        const oneof = findOneof(proto, allOneofs);
+        const field = newField(proto, message, reg, oneof, mapEntries);
+        message.fields.push(field);
+        message.field[field.localName] = field;
+        if (oneof === undefined) {
+            message.members.push(field);
+        }
+        else {
+            oneof.fields.push(field);
+            if (!oneofsSeen.has(oneof)) {
+                oneofsSeen.add(oneof);
+                message.members.push(oneof);
+            }
+        }
+    }
+    for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) {
+        message.oneofs.push(oneof);
+    }
+    for (const child of message.nestedMessages) {
+        addFields(child, reg, mapEntries);
+    }
+}
+/**
+ * Create a descriptor for an enumeration, and add it our cart and to the
+ * parent type, if any.
+ */
+function addEnum(proto, file, parent, reg) {
+    var _a, _b, _c;
+    const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value);
+    const desc = {
+        kind: "enum",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        parent,
+        open: true,
+        name: proto.name,
+        typeName: makeTypeName(proto, parent, file),
+        value: {},
+        values: [],
+        sharedPrefix,
+        toString() {
+            return `enum ${this.typeName}`;
+        },
+    };
+    desc.open = isEnumOpen(desc);
+    reg.add(desc);
+    proto.value.forEach((proto) => {
+        var _a, _b;
+        const name = proto.name;
+        desc.values.push((desc.value[proto.number] = {
+            kind: "enum_value",
+            proto,
+            deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+            parent: desc,
+            name,
+            localName: (0, names_js_1.safeObjectProperty)(sharedPrefix == undefined
+                ? name
+                : name.substring(sharedPrefix.length)),
+            number: proto.number,
+            toString() {
+                return `enum value ${desc.typeName}.${name}`;
+            },
+        }));
+    });
+    ((_c = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _c !== void 0 ? _c : file.enums).push(desc);
+}
+/**
+ * Create a descriptor for a message, including nested types, and add it to our
+ * cart. Note that this does not create descriptors fields.
+ */
+function addMessage(proto, file, parent, reg, mapEntries) {
+    var _a, _b, _c, _d;
+    const desc = {
+        kind: "message",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        parent,
+        name: proto.name,
+        typeName: makeTypeName(proto, parent, file),
+        fields: [],
+        field: {},
+        oneofs: [],
+        members: [],
+        nestedEnums: [],
+        nestedMessages: [],
+        nestedExtensions: [],
+        toString() {
+            return `message ${this.typeName}`;
+        },
+    };
+    if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) {
+        mapEntries.add(desc);
+    }
+    else {
+        ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc);
+        reg.add(desc);
+    }
+    for (const enumProto of proto.enumType) {
+        addEnum(enumProto, file, desc, reg);
+    }
+    for (const messageProto of proto.nestedType) {
+        addMessage(messageProto, file, desc, reg, mapEntries);
+    }
+}
+/**
+ * Create a descriptor for a service, including methods, and add it to our
+ * cart.
+ */
+function addService(proto, file, reg) {
+    var _a, _b;
+    const desc = {
+        kind: "service",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        file,
+        name: proto.name,
+        typeName: makeTypeName(proto, undefined, file),
+        methods: [],
+        method: {},
+        toString() {
+            return `service ${this.typeName}`;
+        },
+    };
+    file.services.push(desc);
+    reg.add(desc);
+    for (const methodProto of proto.method) {
+        const method = newMethod(methodProto, desc, reg);
+        desc.methods.push(method);
+        desc.method[method.localName] = method;
+    }
+}
+/**
+ * Create a descriptor for a method.
+ */
+function newMethod(proto, parent, reg) {
+    var _a, _b, _c, _d;
+    let methodKind;
+    if (proto.clientStreaming && proto.serverStreaming) {
+        methodKind = "bidi_streaming";
+    }
+    else if (proto.clientStreaming) {
+        methodKind = "client_streaming";
+    }
+    else if (proto.serverStreaming) {
+        methodKind = "server_streaming";
+    }
+    else {
+        methodKind = "unary";
+    }
+    const input = reg.getMessage(trimLeadingDot(proto.inputType));
+    const output = reg.getMessage(trimLeadingDot(proto.outputType));
+    assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`);
+    assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`);
+    const name = proto.name;
+    return {
+        kind: "rpc",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        parent,
+        name,
+        localName: (0, names_js_1.safeObjectProperty)(name.length
+            ? (0, names_js_1.safeObjectProperty)(name[0].toLowerCase() + name.substring(1))
+            : name),
+        methodKind,
+        input,
+        output,
+        idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN,
+        toString() {
+            return `rpc ${parent.typeName}.${name}`;
+        },
+    };
+}
+/**
+ * Create a descriptor for a oneof group.
+ */
+function newOneof(proto, parent) {
+    return {
+        kind: "oneof",
+        proto,
+        deprecated: false,
+        parent,
+        fields: [],
+        name: proto.name,
+        localName: (0, names_js_1.safeObjectProperty)((0, names_js_1.protoCamelCase)(proto.name)),
+        toString() {
+            return `oneof ${parent.typeName}.${this.name}`;
+        },
+    };
+}
+function newField(proto, parentOrFile, reg, oneof, mapEntries) {
+    var _a, _b, _c;
+    const isExtension = mapEntries === undefined;
+    const field = {
+        kind: "field",
+        proto,
+        deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false,
+        name: proto.name,
+        number: proto.number,
+        scalar: undefined,
+        message: undefined,
+        enum: undefined,
+        presence: getFieldPresence(proto, oneof, isExtension, parentOrFile),
+        listKind: undefined,
+        mapKind: undefined,
+        mapKey: undefined,
+        delimitedEncoding: undefined,
+        packed: undefined,
+        longAsString: false,
+        getDefaultValue: undefined,
+    };
+    if (isExtension) {
+        // extension field
+        const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
+        const parent = parentOrFile.kind == "file" ? undefined : parentOrFile;
+        const typeName = makeTypeName(proto, parent, file);
+        field.kind = "extension";
+        field.file = file;
+        field.parent = parent;
+        field.oneof = undefined;
+        field.typeName = typeName;
+        field.jsonName = `[${typeName}]`; // option json_name is not allowed on extension fields
+        field.toString = () => `extension ${typeName}`;
+        const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
+        assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
+        field.extendee = extendee;
+    }
+    else {
+        // regular field
+        const parent = parentOrFile;
+        assert(parent.kind == "message");
+        field.parent = parent;
+        field.oneof = oneof;
+        field.localName = oneof
+            ? (0, names_js_1.protoCamelCase)(proto.name)
+            : (0, names_js_1.safeObjectProperty)((0, names_js_1.protoCamelCase)(proto.name));
+        field.jsonName = proto.jsonName;
+        field.toString = () => `field ${parent.typeName}.${proto.name}`;
+    }
+    const label = proto.label;
+    const type = proto.type;
+    const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;
+    if (label === LABEL_REPEATED) {
+        // list or map field
+        const mapEntry = type == TYPE_MESSAGE
+            ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName))
+            : undefined;
+        if (mapEntry) {
+            // map field
+            field.fieldKind = "map";
+            const { key, value } = findMapEntryFields(mapEntry);
+            field.mapKey = key.scalar;
+            field.mapKind = value.fieldKind;
+            field.message = value.message;
+            field.delimitedEncoding = false; // map fields are always LENGTH_PREFIXED
+            field.enum = value.enum;
+            field.scalar = value.scalar;
+            return field;
+        }
+        // list field
+        field.fieldKind = "list";
+        switch (type) {
+            case TYPE_MESSAGE:
+            case TYPE_GROUP:
+                field.listKind = "message";
+                field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                assert(field.message);
+                field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+                break;
+            case TYPE_ENUM:
+                field.listKind = "enum";
+                field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                assert(field.enum);
+                break;
+            default:
+                field.listKind = "scalar";
+                field.scalar = type;
+                field.longAsString = jstype == JS_STRING;
+                break;
+        }
+        field.packed = isPackedField(proto, parentOrFile);
+        return field;
+    }
+    // singular
+    switch (type) {
+        case TYPE_MESSAGE:
+        case TYPE_GROUP:
+            field.fieldKind = "message";
+            field.message = reg.getMessage(trimLeadingDot(proto.typeName));
+            assert(
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile);
+            field.getDefaultValue = () => undefined;
+            break;
+        case TYPE_ENUM: {
+            const enumeration = reg.getEnum(trimLeadingDot(proto.typeName));
+            assert(enumeration !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`);
+            field.fieldKind = "enum";
+            field.enum = reg.getEnum(trimLeadingDot(proto.typeName));
+            field.getDefaultValue = () => {
+                return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue")
+                    ? (0, text_format_js_1.parseTextFormatEnumValue)(enumeration, proto.defaultValue)
+                    : undefined;
+            };
+            break;
+        }
+        default: {
+            field.fieldKind = "scalar";
+            field.scalar = type;
+            field.longAsString = jstype == JS_STRING;
+            field.getDefaultValue = () => {
+                return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue")
+                    ? (0, text_format_js_1.parseTextFormatScalarValue)(type, proto.defaultValue)
+                    : undefined;
+            };
+            break;
+        }
+    }
+    return field;
+}
+/**
+ * Parse the "syntax" and "edition" fields, returning one of the supported
+ * editions.
+ */
+function getFileEdition(proto) {
+    switch (proto.syntax) {
+        case "":
+        case "proto2":
+            return EDITION_PROTO2;
+        case "proto3":
+            return EDITION_PROTO3;
+        case "editions":
+            if (proto.edition in featureDefaults) {
+                return proto.edition;
+            }
+            throw new Error(`${proto.name}: unsupported edition`);
+        default:
+            throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`);
+    }
+}
+/**
+ * Resolve dependencies of FileDescriptorProto to DescFile.
+ */
+function findFileDependencies(proto, reg) {
+    return proto.dependency.map((wantName) => {
+        const dep = reg.getFile(wantName);
+        if (!dep) {
+            throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`);
+        }
+        return dep;
+    });
+}
+/**
+ * Finds a prefix shared by enum values, for example `my_enum_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+function findEnumSharedPrefix(enumName, values) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const value of values) {
+        if (!value.name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = value.name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
+    }
+    return prefix;
+}
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+/**
+ * Create a fully qualified name for a protobuf type or extension field.
+ *
+ * The fully qualified name for messages, enumerations, and services is
+ * constructed by concatenating the package name (if present), parent
+ * message names (for nested types), and the type name. We omit the leading
+ * dot added by protobuf compilers. Examples:
+ * - mypackage.MyMessage
+ * - mypackage.MyMessage.NestedMessage
+ *
+ * The fully qualified name for extension fields is constructed by
+ * concatenating the package name (if present), parent message names (for
+ * extensions declared within a message), and the field name. Examples:
+ * - mypackage.extfield
+ * - mypackage.MyMessage.extfield
+ */
+function makeTypeName(proto, parent, file) {
+    let typeName;
+    if (parent) {
+        typeName = `${parent.typeName}.${proto.name}`;
+    }
+    else if (file.proto.package.length > 0) {
+        typeName = `${file.proto.package}.${proto.name}`;
+    }
+    else {
+        typeName = `${proto.name}`;
+    }
+    return typeName;
+}
+/**
+ * Remove the leading dot from a fully qualified type name.
+ */
+function trimLeadingDot(typeName) {
+    return typeName.startsWith(".") ? typeName.substring(1) : typeName;
+}
+/**
+ * Did the user put the field in a oneof group?
+ * Synthetic oneofs for proto3 optionals are ignored.
+ */
+function findOneof(proto, allOneofs) {
+    if (!(0, unsafe_js_1.unsafeIsSetExplicit)(proto, "oneofIndex")) {
+        return undefined;
+    }
+    if (proto.proto3Optional) {
+        return undefined;
+    }
+    const oneof = allOneofs[proto.oneofIndex];
+    assert(
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`);
+    return oneof;
+}
+/**
+ * Presence of the field.
+ * See https://protobuf.dev/programming-guides/field_presence/
+ */
+function getFieldPresence(proto, oneof, isExtension, parent) {
+    if (proto.label == LABEL_REQUIRED) {
+        // proto2 required is LEGACY_REQUIRED
+        return LEGACY_REQUIRED;
+    }
+    if (proto.label == LABEL_REPEATED) {
+        // repeated fields (including maps) do not track presence
+        return IMPLICIT;
+    }
+    if (!!oneof || proto.proto3Optional) {
+        // oneof is always explicit
+        return EXPLICIT;
+    }
+    if (proto.type == TYPE_MESSAGE) {
+        // singular message field cannot be implicit
+        return EXPLICIT;
+    }
+    if (isExtension) {
+        // extensions always track presence
+        return EXPLICIT;
+    }
+    return resolveFeature("fieldPresence", { proto, parent });
+}
+/**
+ * Pack this repeated field?
+ */
+function isPackedField(proto, parent) {
+    if (proto.label != LABEL_REPEATED) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (proto.type) {
+        case TYPE_STRING:
+        case TYPE_BYTES:
+        case TYPE_GROUP:
+        case TYPE_MESSAGE:
+            // length-delimited types cannot be packed
+            return false;
+    }
+    const o = proto.options;
+    if (o && (0, unsafe_js_1.unsafeIsSetExplicit)(o, "packed")) {
+        // prefer the field option over edition features
+        return o.packed;
+    }
+    return (PACKED ==
+        resolveFeature("repeatedFieldEncoding", {
+            proto,
+            parent,
+        }));
+}
+/**
+ * Find the key and value fields of a synthetic map entry message.
+ */
+function findMapEntryFields(mapEntry) {
+    const key = mapEntry.fields.find((f) => f.number === 1);
+    const value = mapEntry.fields.find((f) => f.number === 2);
+    assert(key &&
+        key.fieldKind == "scalar" &&
+        key.scalar != descriptors_js_1.ScalarType.BYTES &&
+        key.scalar != descriptors_js_1.ScalarType.FLOAT &&
+        key.scalar != descriptors_js_1.ScalarType.DOUBLE &&
+        value &&
+        value.fieldKind != "list" &&
+        value.fieldKind != "map");
+    return { key, value };
+}
+/**
+ * Enumerations can be open or closed.
+ * See https://protobuf.dev/programming-guides/enum/
+ */
+function isEnumOpen(desc) {
+    var _a;
+    return (OPEN ==
+        resolveFeature("enumType", {
+            proto: desc.proto,
+            parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file,
+        }));
+}
+/**
+ * Encode the message delimited (a.k.a. proto2 group encoding), or
+ * length-prefixed?
+ */
+function isDelimitedEncoding(proto, parent) {
+    if (proto.type == TYPE_GROUP) {
+        return true;
+    }
+    return (DELIMITED ==
+        resolveFeature("messageEncoding", {
+            proto,
+            parent,
+        }));
+}
+function resolveFeature(name, ref) {
+    var _a, _b;
+    const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features;
+    if (featureSet) {
+        const val = featureSet[name];
+        if (val != 0) {
+            return val;
+        }
+    }
+    if ("kind" in ref) {
+        if (ref.kind == "message") {
+            return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file);
+        }
+        const editionDefaults = featureDefaults[ref.edition];
+        if (!editionDefaults) {
+            throw new Error(`feature default for edition ${ref.edition} not found`);
+        }
+        return editionDefaults[name];
+    }
+    return resolveFeature(name, ref.parent);
+}
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+function assert(condition, msg) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
+    if (!condition) {
+        throw new Error(msg);
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.d.ts
@@ -0,0 +1,24 @@
+import type { MessageShape } from "./types.js";
+import { BinaryWriter } from "./wire/binary-encoding.js";
+import { type DescField, type DescMessage } from "./descriptors.js";
+import type { ReflectMessage } from "./reflect/index.js";
+/**
+ * Options for serializing to binary data.
+ *
+ * V1 also had the option `readerFactory` for using a custom implementation to
+ * encode to binary.
+ */
+export interface BinaryWriteOptions {
+    /**
+     * Include unknown fields in the serialized output? The default behavior
+     * is to retain unknown fields and include them in the serialized output.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    writeUnknownFields: boolean;
+}
+export declare function toBinary<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array;
+/**
+ * @private
+ */
+export declare function writeField(writer: BinaryWriter, opts: BinaryWriteOptions, msg: ReflectMessage, field: DescField): void;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.js
@@ -0,0 +1,191 @@
+"use strict";
+// Copyright 2021-2024 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.toBinary = toBinary;
+exports.writeField = writeField;
+const reflect_js_1 = require("./reflect/reflect.js");
+const binary_encoding_js_1 = require("./wire/binary-encoding.js");
+const descriptors_js_1 = require("./descriptors.js");
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// Default options for serializing binary data.
+const writeDefaults = {
+    writeUnknownFields: true,
+};
+function makeWriteOptions(options) {
+    return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
+}
+function toBinary(schema, message, options) {
+    return writeFields(new binary_encoding_js_1.BinaryWriter(), makeWriteOptions(options), (0, reflect_js_1.reflect)(schema, message)).finish();
+}
+function writeFields(writer, opts, msg) {
+    var _a;
+    for (const f of msg.sortedFields) {
+        if (!msg.isSet(f)) {
+            if (f.presence == LEGACY_REQUIRED) {
+                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to binary: required field not set`);
+            }
+            continue;
+        }
+        writeField(writer, opts, msg, f);
+    }
+    if (opts.writeUnknownFields) {
+        for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
+            writer.tag(no, wireType).raw(data);
+        }
+    }
+    return writer;
+}
+/**
+ * @private
+ */
+function writeField(writer, opts, msg, field) {
+    var _a;
+    switch (field.fieldKind) {
+        case "scalar":
+        case "enum":
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, field.number, msg.get(field));
+            break;
+        case "list":
+            writeListField(writer, opts, field, msg.get(field));
+            break;
+        case "message":
+            writeMessageField(writer, opts, field, msg.get(field));
+            break;
+        case "map":
+            for (const [key, val] of msg.get(field)) {
+                writeMapEntry(writer, opts, field, key, val);
+            }
+            break;
+    }
+}
+function writeScalar(writer, scalarType, fieldNo, value) {
+    writeScalarValue(writer.tag(fieldNo, writeTypeOfScalar(scalarType)), scalarType, value);
+}
+function writeMessageField(writer, opts, field, message) {
+    if (field.delimitedEncoding) {
+        writeFields(writer.tag(field.number, binary_encoding_js_1.WireType.StartGroup), opts, message).tag(field.number, binary_encoding_js_1.WireType.EndGroup);
+    }
+    else {
+        writeFields(writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork(), opts, message).join();
+    }
+}
+function writeListField(writer, opts, field, list) {
+    var _a;
+    if (field.listKind == "message") {
+        for (const item of list) {
+            writeMessageField(writer, opts, field, item);
+        }
+        return;
+    }
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32;
+    if (field.packed) {
+        if (!list.size) {
+            return;
+        }
+        writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork();
+        for (const item of list) {
+            writeScalarValue(writer, scalarType, item);
+        }
+        writer.join();
+        return;
+    }
+    for (const item of list) {
+        writeScalar(writer, scalarType, field.number, item);
+    }
+}
+function writeMapEntry(writer, opts, field, key, value) {
+    var _a;
+    writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork();
+    // write key, expecting key field number = 1
+    writeScalar(writer, field.mapKey, 1, key);
+    // write value, expecting value field number = 2
+    switch (field.mapKind) {
+        case "scalar":
+        case "enum":
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, 2, value);
+            break;
+        case "message":
+            writeFields(writer.tag(2, binary_encoding_js_1.WireType.LengthDelimited).fork(), opts, value).join();
+            break;
+    }
+    writer.join();
+}
+function writeScalarValue(writer, type, value) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            writer.string(value);
+            break;
+        case descriptors_js_1.ScalarType.BOOL:
+            writer.bool(value);
+            break;
+        case descriptors_js_1.ScalarType.DOUBLE:
+            writer.double(value);
+            break;
+        case descriptors_js_1.ScalarType.FLOAT:
+            writer.float(value);
+            break;
+        case descriptors_js_1.ScalarType.INT32:
+            writer.int32(value);
+            break;
+        case descriptors_js_1.ScalarType.INT64:
+            writer.int64(value);
+            break;
+        case descriptors_js_1.ScalarType.UINT64:
+            writer.uint64(value);
+            break;
+        case descriptors_js_1.ScalarType.FIXED64:
+            writer.fixed64(value);
+            break;
+        case descriptors_js_1.ScalarType.BYTES:
+            writer.bytes(value);
+            break;
+        case descriptors_js_1.ScalarType.FIXED32:
+            writer.fixed32(value);
+            break;
+        case descriptors_js_1.ScalarType.SFIXED32:
+            writer.sfixed32(value);
+            break;
+        case descriptors_js_1.ScalarType.SFIXED64:
+            writer.sfixed64(value);
+            break;
+        case descriptors_js_1.ScalarType.SINT64:
+            writer.sint64(value);
+            break;
+        case descriptors_js_1.ScalarType.UINT32:
+            writer.uint32(value);
+            break;
+        case descriptors_js_1.ScalarType.SINT32:
+            writer.sint32(value);
+            break;
+    }
+}
+function writeTypeOfScalar(type) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.BYTES:
+        case descriptors_js_1.ScalarType.STRING:
+            return binary_encoding_js_1.WireType.LengthDelimited;
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+            return binary_encoding_js_1.WireType.Bit64;
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.FLOAT:
+            return binary_encoding_js_1.WireType.Bit32;
+        default:
+            return binary_encoding_js_1.WireType.Varint;
+    }
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-json.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-json.d.ts
@@ -0,0 +1,61 @@
+import { type DescEnum, type DescMessage } from "./descriptors.js";
+import type { JsonValue } from "./json-value.js";
+import type { Registry } from "./registry.js";
+import type { EnumJsonType, EnumShape, MessageJsonType, MessageShape } from "./types.js";
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteOptions {
+    /**
+     * By default, fields with implicit presence are not serialized if they are
+     * unset. For example, an empty list field or a proto3 int32 field with 0 is
+     * not serialized. With this option enabled, such fields are included in the
+     * output.
+     */
+    alwaysEmitImplicit: boolean;
+    /**
+     * Emit enum values as integers instead of strings: The name of an enum
+     * value is used by default in JSON output. An option may be provided to
+     * use the numeric value of the enum value instead.
+     */
+    enumAsInteger: boolean;
+    /**
+     * Use proto field name instead of lowerCamelCase name: By default proto3
+     * JSON printer should convert the field name to lowerCamelCase and use
+     * that as the JSON name. An implementation may provide an option to use
+     * proto field name as the JSON name instead. Proto3 JSON parsers are
+     * required to accept both the converted lowerCamelCase name and the proto
+     * field name.
+     */
+    useProtoFieldName: boolean;
+    /**
+     * This option is required to write `google.protobuf.Any` and extensions
+     * to JSON format.
+     */
+    registry?: Registry;
+}
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteStringOptions extends JsonWriteOptions {
+    prettySpaces: number;
+}
+/**
+ * Serialize the message to a JSON value, a JavaScript value that can be
+ * passed to JSON.stringify().
+ */
+export declare function toJson<Desc extends DescMessage, Opts extends Partial<JsonWriteOptions> | undefined = undefined>(schema: Desc, message: MessageShape<Desc>, options?: Opts): ToJson<Desc, Opts>;
+type ToJson<Desc extends DescMessage, Opts extends undefined | Partial<JsonWriteOptions>> = Opts extends undefined | {
+    alwaysEmitImplicit?: false;
+    enumAsInteger?: false;
+    useProtoFieldName?: false;
+} ? MessageJsonType<Desc> : JsonValue;
+/**
+ * Serialize the message to a JSON string.
+ */
+export declare function toJsonString<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteStringOptions>): string;
+/**
+ * Serialize a single enum value to JSON.
+ */
+export declare function enumToJson<Desc extends DescEnum>(descEnum: Desc, value: EnumShape<Desc>): EnumJsonType<Desc>;
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-json.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/to-json.js
@@ -0,0 +1,389 @@
+"use strict";
+// Copyright 2021-2024 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.toJson = toJson;
+exports.toJsonString = toJsonString;
+exports.enumToJson = enumToJson;
+const descriptors_js_1 = require("./descriptors.js");
+const names_js_1 = require("./reflect/names.js");
+const reflect_js_1 = require("./reflect/reflect.js");
+const index_js_1 = require("./wkt/index.js");
+const wrappers_js_1 = require("./wkt/wrappers.js");
+const index_js_2 = require("./wire/index.js");
+const extensions_js_1 = require("./extensions.js");
+const reflect_check_js_1 = require("./reflect/reflect-check.js");
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const IMPLICIT = 2;
+// Default options for serializing to JSON.
+const jsonWriteDefaults = {
+    alwaysEmitImplicit: false,
+    enumAsInteger: false,
+    useProtoFieldName: false,
+};
+function makeWriteOptions(options) {
+    return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
+}
+/**
+ * Serialize the message to a JSON value, a JavaScript value that can be
+ * passed to JSON.stringify().
+ */
+function toJson(schema, message, options) {
+    return reflectToJson((0, reflect_js_1.reflect)(schema, message), makeWriteOptions(options));
+}
+/**
+ * Serialize the message to a JSON string.
+ */
+function toJsonString(schema, message, options) {
+    var _a;
+    const jsonValue = toJson(schema, message, options);
+    return JSON.stringify(jsonValue, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
+}
+/**
+ * Serialize a single enum value to JSON.
+ */
+function enumToJson(descEnum, value) {
+    var _a;
+    if (descEnum.typeName == "google.protobuf.NullValue") {
+        return null;
+    }
+    const name = (_a = descEnum.value[value]) === null || _a === void 0 ? void 0 : _a.name;
+    if (name === undefined) {
+        throw new Error(`${String(value)} is not a value in ${descEnum.toString()}`);
+    }
+    return name;
+}
+function reflectToJson(msg, opts) {
+    var _a;
+    const wktJson = tryWktToJson(msg, opts);
+    if (wktJson !== undefined)
+        return wktJson;
+    const json = {};
+    for (const f of msg.sortedFields) {
+        if (!msg.isSet(f)) {
+            if (f.presence == LEGACY_REQUIRED) {
+                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to JSON: required field not set`);
+            }
+            if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) {
+                // Fields with implicit presence omit zero values (e.g. empty string) by default
+                continue;
+            }
+        }
+        const jsonValue = fieldToJson(f, msg.get(f), opts);
+        if (jsonValue !== undefined) {
+            json[jsonName(f, opts)] = jsonValue;
+        }
+    }
+    if (opts.registry) {
+        const tagSeen = new Set();
+        for (const uf of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
+            // Same tag can appear multiple times, so we
+            // keep track and skip identical ones.
+            if (tagSeen.has(uf.no)) {
+                continue;
+            }
+            const extension = opts.registry.getExtensionFor(msg.desc, uf.no);
+            if (!extension) {
+                continue;
+            }
+            const value = (0, extensions_js_1.getExtension)(msg.message, extension);
+            const [container, field] = (0, extensions_js_1.createExtensionContainer)(extension, value);
+            const jsonValue = fieldToJson(field, container.get(field), opts);
+            if (jsonValue !== undefined) {
+                json[extension.jsonName] = jsonValue;
+            }
+        }
+    }
+    return json;
+}
+function fieldToJson(f, val, opts) {
+    switch (f.fieldKind) {
+        case "scalar":
+            return scalarToJson(f, val);
+        case "message":
+            return reflectToJson(val, opts);
+        case "enum":
+            return enumToJsonInternal(f.enum, val, opts.enumAsInteger);
+        case "list":
+            return listToJson(val, opts);
+        case "map":
+            return mapToJson(val, opts);
+    }
+}
+function mapToJson(map, opts) {
+    const f = map.field();
+    const jsonObj = {};
+    switch (f.mapKind) {
+        case "scalar":
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = scalarToJson(f, entryValue);
+            }
+            break;
+        case "message":
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = reflectToJson(entryValue, opts);
+            }
+            break;
+        case "enum":
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = enumToJsonInternal(f.enum, entryValue, opts.enumAsInteger);
+            }
+            break;
+    }
+    return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined;
+}
+function listToJson(list, opts) {
+    const f = list.field();
+    const jsonArr = [];
+    switch (f.listKind) {
+        case "scalar":
+            for (const item of list) {
+                jsonArr.push(scalarToJson(f, item));
+            }
+            break;
+        case "enum":
+            for (const item of list) {
+                jsonArr.push(enumToJsonInternal(f.enum, item, opts.enumAsInteger));
+            }
+            break;
+        case "message":
+            for (const item of list) {
+                jsonArr.push(reflectToJson(item, opts));
+            }
+            break;
+    }
+    return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined;
+}
+function enumToJsonInternal(desc, value, enumAsInteger) {
+    var _a;
+    if (typeof value != "number") {
+        throw new Error(`cannot encode ${desc} to JSON: expected number, got ${(0, reflect_check_js_1.formatVal)(value)}`);
+    }
+    if (desc.typeName == "google.protobuf.NullValue") {
+        return null;
+    }
+    if (enumAsInteger) {
+        return value;
+    }
+    const val = desc.value[value];
+    return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
+}
+function scalarToJson(field, value) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (field.scalar) {
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+            if (typeof value != "number") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_a = (0, reflect_check_js_1.checkField)(field, value)) === null || _a === void 0 ? void 0 : _a.message}`);
+            }
+            return value;
+        // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+        // Either numbers or strings are accepted. Exponent notation is also accepted.
+        case descriptors_js_1.ScalarType.FLOAT:
+        case descriptors_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+            if (typeof value != "number") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_b = (0, reflect_check_js_1.checkField)(field, value)) === null || _b === void 0 ? void 0 : _b.message}`);
+            }
+            if (isNaN(value))
+                return "NaN";
+            if (value === Number.POSITIVE_INFINITY)
+                return "Infinity";
+            if (value === Number.NEGATIVE_INFINITY)
+                return "-Infinity";
+            return value;
+        // string:
+        case descriptors_js_1.ScalarType.STRING:
+            if (typeof value != "string") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_c = (0, reflect_check_js_1.checkField)(field, value)) === null || _c === void 0 ? void 0 : _c.message}`);
+            }
+            return value;
+        // bool:
+        case descriptors_js_1.ScalarType.BOOL:
+            if (typeof value != "boolean") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_d = (0, reflect_check_js_1.checkField)(field, value)) === null || _d === void 0 ? void 0 : _d.message}`);
+            }
+            return value;
+        // JSON value will be a decimal string. Either numbers or strings are accepted.
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if (typeof value != "bigint" && typeof value != "string") {
+                throw new Error(`cannot encode ${field} to JSON: ${(_e = (0, reflect_check_js_1.checkField)(field, value)) === null || _e === void 0 ? void 0 : _e.message}`);
+            }
+            return value.toString();
+        // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+        // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+        case descriptors_js_1.ScalarType.BYTES:
+            if (value instanceof Uint8Array) {
+                return (0, index_js_2.base64Encode)(value);
+            }
+            throw new Error(`cannot encode ${field} to JSON: ${(_f = (0, reflect_check_js_1.checkField)(field, value)) === null || _f === void 0 ? void 0 : _f.message}`);
+    }
+}
+function jsonName(f, opts) {
+    return opts.useProtoFieldName ? f.name : f.jsonName;
+}
+// returns a json value if wkt, otherwise returns undefined.
+function tryWktToJson(msg, opts) {
+    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
+        return undefined;
+    }
+    switch (msg.desc.typeName) {
+        case "google.protobuf.Any":
+            return anyToJson(msg.message, opts);
+        case "google.protobuf.Timestamp":
+            return timestampToJson(msg.message);
+        case "google.protobuf.Duration":
+            return durationToJson(msg.message);
+        case "google.protobuf.FieldMask":
+            return fieldMaskToJson(msg.message);
+        case "google.protobuf.Struct":
+            return structToJson(msg.message);
+        case "google.protobuf.Value":
+            return valueToJson(msg.message);
+        case "google.protobuf.ListValue":
+            return listValueToJson(msg.message);
+        default:
+            if ((0, wrappers_js_1.isWrapperDesc)(msg.desc)) {
+                const valueField = msg.desc.fields[0];
+                return scalarToJson(valueField, msg.get(valueField));
+            }
+            return undefined;
+    }
+}
+function anyToJson(val, opts) {
+    if (val.typeUrl === "") {
+        return {};
+    }
+    const { registry } = opts;
+    let message;
+    let desc;
+    if (registry) {
+        message = (0, index_js_1.anyUnpack)(val, registry);
+        if (message) {
+            desc = registry.getMessage(message.$typeName);
+        }
+    }
+    if (!desc || !message) {
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: "${val.typeUrl}" is not in the type registry`);
+    }
+    let json = reflectToJson((0, reflect_js_1.reflect)(desc, message), opts);
+    if (desc.typeName.startsWith("google.protobuf.") ||
+        json === null ||
+        Array.isArray(json) ||
+        typeof json !== "object") {
+        json = { value: json };
+    }
+    json["@type"] = val.typeUrl;
+    return json;
+}
+function durationToJson(val) {
+    if (Number(val.seconds) > 315576000000 ||
+        Number(val.seconds) < -315576000000) {
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`);
+    }
+    let text = val.seconds.toString();
+    if (val.nanos !== 0) {
+        let nanosStr = Math.abs(val.nanos).toString();
+        nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;
+        if (nanosStr.substring(3) === "000000") {
+            nanosStr = nanosStr.substring(0, 3);
+        }
+        else if (nanosStr.substring(6) === "000") {
+            nanosStr = nanosStr.substring(0, 6);
+        }
+        text += "." + nanosStr;
+        if (val.nanos < 0 && Number(val.seconds) == 0) {
+            text = "-" + text;
+        }
+    }
+    return text + "s";
+}
+function fieldMaskToJson(val) {
+    return val.paths
+        .map((p) => {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {
+            throw new Error(`cannot encode message ${val.$typeName} to JSON: lowerCamelCase of path name "` +
+                p +
+                '" is irreversible');
+        }
+        return (0, names_js_1.protoCamelCase)(p);
+    })
+        .join(",");
+}
+function structToJson(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = valueToJson(v);
+    }
+    return json;
+}
+function valueToJson(val) {
+    switch (val.kind.case) {
+        case "nullValue":
+            return null;
+        case "numberValue":
+            if (!Number.isFinite(val.kind.value)) {
+                throw new Error(`${val.$typeName} cannot be NaN or Infinity`);
+            }
+            return val.kind.value;
+        case "boolValue":
+            return val.kind.value;
+        case "stringValue":
+            return val.kind.value;
+        case "structValue":
+            return structToJson(val.kind.value);
+        case "listValue":
+            return listValueToJson(val.kind.value);
+        default:
+            throw new Error(`${val.$typeName} must have a value`);
+    }
+}
+function listValueToJson(val) {
+    return val.values.map(valueToJson);
+}
+function timestampToJson(val) {
+    const ms = Number(val.seconds) * 1000;
+    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
+        ms > Date.parse("9999-12-31T23:59:59Z")) {
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+    }
+    if (val.nanos < 0) {
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: nanos must not be negative`);
+    }
+    let z = "Z";
+    if (val.nanos > 0) {
+        const nanosStr = (val.nanos + 1000000000).toString().substring(1);
+        if (nanosStr.substring(3) === "000000") {
+            z = "." + nanosStr.substring(0, 3) + "Z";
+        }
+        else if (nanosStr.substring(6) === "000") {
+            z = "." + nanosStr.substring(0, 6) + "Z";
+        }
+        else {
+            z = "." + nanosStr + "Z";
+        }
+    }
+    return new Date(ms).toISOString().replace(".000Z", z);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/types.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/types.d.ts
@@ -0,0 +1,111 @@
+import type { GenEnum, GenExtension, GenMessage } from "./codegenv1/types.js";
+import type { DescEnum, DescExtension, DescMessage, DescMethod } from "./descriptors.js";
+import type { OneofADT } from "./reflect/guard.js";
+import type { WireType } from "./wire/index.js";
+import type { JsonValue } from "./json-value.js";
+/**
+ * The type `Message` contains the properties shared by all messages.
+ */
+export type Message<TypeName extends string = string> = {
+    /**
+     * The fully qualified Protobuf type-name of the message.
+     */
+    readonly $typeName: TypeName;
+    /**
+     * Unknown fields and extensions stored on the message.
+     */
+    $unknown?: UnknownField[];
+};
+/**
+ * Extract the message type from a message descriptor.
+ */
+export type MessageShape<Desc extends DescMessage> = Desc extends GenMessage<infer RuntimeShape> ? RuntimeShape : Message;
+/**
+ * Extract the message JSON type from a message descriptor.
+ */
+export type MessageJsonType<Desc extends DescMessage> = Desc extends GenMessage<Message, infer JsonType> ? JsonType : JsonValue;
+/**
+ * Extract the init type from a message descriptor.
+ * The init type is accepted by the function create().
+ */
+export type MessageInitShape<Desc extends DescMessage> = Desc extends GenMessage<infer RuntimeShape> ? MessageInit<RuntimeShape> : Record<string, unknown>;
+/**
+ * Extract the enum type of from an enum descriptor.
+ */
+export type EnumShape<Desc extends DescEnum> = Desc extends GenEnum<infer RuntimeShape> ? RuntimeShape : number;
+/**
+ * Extract the enum JSON type from a enum descriptor.
+ */
+export type EnumJsonType<Desc extends DescEnum> = Desc extends GenEnum<number, infer JsonType> ? JsonType : string | null;
+/**
+ * Extract the value type from an extension descriptor.
+ */
+export type ExtensionValueShape<Desc extends DescExtension> = Desc extends GenExtension<Message, infer RuntimeShape> ? RuntimeShape : unknown;
+/**
+ * Extract the type of the extended message from an extension descriptor.
+ */
+export type Extendee<Desc extends DescExtension> = Desc extends GenExtension<infer Extendee> ? Extendee : Message;
+/**
+ * Unknown fields are fields that were not recognized during parsing, or
+ * extension.
+ */
+export type UnknownField = {
+    readonly no: number;
+    readonly wireType: WireType;
+    readonly data: Uint8Array;
+};
+/**
+ * Describes a streaming RPC declaration.
+ */
+export type DescMethodStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodClientStreaming<I, O> | DescMethodServerStreaming<I, O> | DescMethodBiDiStreaming<I, O>;
+/**
+ * Describes a unary RPC declaration.
+ */
+export type DescMethodUnary<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"unary", I, O>;
+/**
+ * Describes a server streaming RPC declaration.
+ */
+export type DescMethodServerStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"server_streaming", I, O>;
+/**
+ * Describes a client streaming RPC declaration.
+ */
+export type DescMethodClientStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"client_streaming", I, O>;
+/**
+ * Describes a bidi streaming RPC declaration.
+ */
+export type DescMethodBiDiStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"bidi_streaming", I, O>;
+/**
+ * The init type for a message, which makes all fields optional.
+ * The init type is accepted by the function create().
+ */
+type MessageInit<T extends Message> = T | {
+    [P in keyof T as P extends "$unknown" ? never : P]?: P extends "$typeName" ? never : FieldInit<T[P]>;
+};
+type FieldInit<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<FieldInit<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<FieldInit<U>> : F extends Message ? MessageInit<F> : F extends OneofSelectedMessage<infer C, infer V> ? {
+    case: C;
+    value: MessageInit<V>;
+} : F extends OneofADT ? F : F extends MapWithMessage<infer V> ? {
+    [key: string | number]: MessageInit<V>;
+} : F;
+type MapWithMessage<V extends Message> = {
+    [key: string | number]: V;
+};
+type OneofSelectedMessage<K extends string, M extends Message> = {
+    case: K;
+    value: M;
+};
+type DescMethodTyped<K extends DescMethod["methodKind"], I extends DescMessage, O extends DescMessage> = Omit<DescMethod, "methodKind" | "input" | "output"> & {
+    /**
+     * One of the four available method types.
+     */
+    readonly methodKind: K;
+    /**
+     * The message type for requests.
+     */
+    readonly input: I;
+    /**
+     * The message type for responses.
+     */
+    readonly output: O;
+};
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/types.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/types.js
@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2021-2024 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 });
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.d.ts
@@ -0,0 +1,23 @@
+/**
+ * Decodes a base64 string to a byte array.
+ *
+ * - ignores white-space, including line breaks and tabs
+ * - allows inner padding (can decode concatenated base64 strings)
+ * - does not require padding
+ * - understands base64url encoding:
+ *   "-" instead of "+",
+ *   "_" instead of "/",
+ *   no padding
+ */
+export declare function base64Decode(base64Str: string): Uint8Array;
+/**
+ * Encode a byte array to a base64 string.
+ *
+ * By default, this function uses the standard base64 encoding with padding.
+ *
+ * To encode without padding, use encoding = "std_raw".
+ *
+ * To encode with the URL encoding, use encoding = "url", which replaces the
+ * characters +/ by their URL-safe counterparts -_, and omits padding.
+ */
+export declare function base64Encode(bytes: Uint8Array, encoding?: "std" | "std_raw" | "url"): string;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.js
@@ -0,0 +1,155 @@
+"use strict";
+// Copyright 2021-2024 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.base64Decode = base64Decode;
+exports.base64Encode = base64Encode;
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
+/**
+ * Decodes a base64 string to a byte array.
+ *
+ * - ignores white-space, including line breaks and tabs
+ * - allows inner padding (can decode concatenated base64 strings)
+ * - does not require padding
+ * - understands base64url encoding:
+ *   "-" instead of "+",
+ *   "_" instead of "/",
+ *   no padding
+ */
+function base64Decode(base64Str) {
+    const table = getDecodeTable();
+    // estimate byte size, not accounting for inner padding and whitespace
+    let es = (base64Str.length * 3) / 4;
+    if (base64Str[base64Str.length - 2] == "=")
+        es -= 2;
+    else if (base64Str[base64Str.length - 1] == "=")
+        es -= 1;
+    let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
+    groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // previous byte
+    for (let i = 0; i < base64Str.length; i++) {
+        b = table[base64Str.charCodeAt(i)];
+        if (b === undefined) {
+            switch (base64Str[i]) {
+                // @ts-expect-error TS7029: Fallthrough case in switch
+                case "=":
+                    groupPos = 0; // reset state when padding found
+                // eslint-disable-next-line no-fallthrough
+                case "\n":
+                case "\r":
+                case "\t":
+                case " ":
+                    continue; // skip white-space, and padding
+                default:
+                    throw Error("invalid base64 string");
+            }
+        }
+        switch (groupPos) {
+            case 0:
+                p = b;
+                groupPos = 1;
+                break;
+            case 1:
+                bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
+                p = b;
+                groupPos = 2;
+                break;
+            case 2:
+                bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
+                p = b;
+                groupPos = 3;
+                break;
+            case 3:
+                bytes[bytePos++] = ((p & 3) << 6) | b;
+                groupPos = 0;
+                break;
+        }
+    }
+    if (groupPos == 1)
+        throw Error("invalid base64 string");
+    return bytes.subarray(0, bytePos);
+}
+/**
+ * Encode a byte array to a base64 string.
+ *
+ * By default, this function uses the standard base64 encoding with padding.
+ *
+ * To encode without padding, use encoding = "std_raw".
+ *
+ * To encode with the URL encoding, use encoding = "url", which replaces the
+ * characters +/ by their URL-safe counterparts -_, and omits padding.
+ */
+function base64Encode(bytes, encoding = "std") {
+    const table = getEncodeTable(encoding);
+    const pad = encoding == "std";
+    let base64 = "", groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // carry over from previous byte
+    for (let i = 0; i < bytes.length; i++) {
+        b = bytes[i];
+        switch (groupPos) {
+            case 0:
+                base64 += table[b >> 2];
+                p = (b & 3) << 4;
+                groupPos = 1;
+                break;
+            case 1:
+                base64 += table[p | (b >> 4)];
+                p = (b & 15) << 2;
+                groupPos = 2;
+                break;
+            case 2:
+                base64 += table[p | (b >> 6)];
+                base64 += table[b & 63];
+                groupPos = 0;
+                break;
+        }
+    }
+    // add output padding
+    if (groupPos) {
+        base64 += table[p];
+        if (pad) {
+            base64 += "=";
+            if (groupPos == 1)
+                base64 += "=";
+        }
+    }
+    return base64;
+}
+// lookup table from base64 character to byte
+let encodeTableStd;
+let encodeTableUrl;
+// lookup table from base64 character *code* to byte because lookup by number is fast
+let decodeTable;
+function getEncodeTable(encoding) {
+    if (!encodeTableStd) {
+        encodeTableStd =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+        encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_");
+    }
+    return encoding == "url" ? encodeTableUrl : encodeTableStd;
+}
+function getDecodeTable() {
+    if (!decodeTable) {
+        decodeTable = [];
+        const encodeTable = getEncodeTable("std");
+        for (let i = 0; i < encodeTable.length; i++)
+            decodeTable[encodeTable[i].charCodeAt(0)] = i;
+        // support base64url variants
+        decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+");
+        decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/");
+    }
+    return decodeTable;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.d.ts
@@ -0,0 +1,264 @@
+/**
+ * Protobuf binary format wire types.
+ *
+ * A wire type provides just enough information to find the length of the
+ * following value.
+ *
+ * See https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+export declare enum WireType {
+    /**
+     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
+     */
+    Varint = 0,
+    /**
+     * Used for fixed64, sfixed64, double.
+     * Always 8 bytes with little-endian byte order.
+     */
+    Bit64 = 1,
+    /**
+     * Used for string, bytes, embedded messages, packed repeated fields
+     *
+     * Only repeated numeric types (types which use the varint, 32-bit,
+     * or 64-bit wire types) can be packed. In proto3, such fields are
+     * packed by default.
+     */
+    LengthDelimited = 2,
+    /**
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
+     */
+    StartGroup = 3,
+    /**
+     * End of a tag-delimited aggregate.
+     */
+    EndGroup = 4,
+    /**
+     * Used for fixed32, sfixed32, float.
+     * Always 4 bytes with little-endian byte order.
+     */
+    Bit32 = 5
+}
+/**
+ * Maximum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+export declare const FLOAT32_MAX = 3.4028234663852886e+38;
+/**
+ * Minimum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+export declare const FLOAT32_MIN = -3.4028234663852886e+38;
+/**
+ * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32).
+ */
+export declare const UINT32_MAX = 4294967295;
+/**
+ * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+export declare const INT32_MAX = 2147483647;
+/**
+ * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+export declare const INT32_MIN = -2147483648;
+export declare class BinaryWriter {
+    private readonly encodeUtf8;
+    /**
+     * We cannot allocate a buffer for the entire output
+     * because we don't know it's size.
+     *
+     * So we collect smaller chunks of known size and
+     * concat them later.
+     *
+     * Use `raw()` to push data to this array. It will flush
+     * `buf` first.
+     */
+    private chunks;
+    /**
+     * A growing buffer for byte values. If you don't know
+     * the size of the data you are writing, push to this
+     * array.
+     */
+    protected buf: number[];
+    /**
+     * Previous fork states.
+     */
+    private stack;
+    constructor(encodeUtf8?: (text: string) => Uint8Array);
+    /**
+     * Return all bytes written and reset this writer.
+     */
+    finish(): Uint8Array;
+    /**
+     * Start a new fork for length-delimited data like a message
+     * or a packed repeated field.
+     *
+     * Must be joined later with `join()`.
+     */
+    fork(): this;
+    /**
+     * Join the last fork. Write its length and bytes, then
+     * return to the previous state.
+     */
+    join(): this;
+    /**
+     * Writes a tag (field number and wire type).
+     *
+     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+     *
+     * Generated code should compute the tag ahead of time and call `uint32()`.
+     */
+    tag(fieldNo: number, type: WireType): this;
+    /**
+     * Write a chunk of raw bytes.
+     */
+    raw(chunk: Uint8Array): this;
+    /**
+     * Write a `uint32` value, an unsigned 32 bit varint.
+     */
+    uint32(value: number): this;
+    /**
+     * Write a `int32` value, a signed 32 bit varint.
+     */
+    int32(value: number): this;
+    /**
+     * Write a `bool` value, a variant.
+     */
+    bool(value: boolean): this;
+    /**
+     * Write a `bytes` value, length-delimited arbitrary data.
+     */
+    bytes(value: Uint8Array): this;
+    /**
+     * Write a `string` value, length-delimited data converted to UTF-8 text.
+     */
+    string(value: string): this;
+    /**
+     * Write a `float` value, 32-bit floating point number.
+     */
+    float(value: number): this;
+    /**
+     * Write a `double` value, a 64-bit floating point number.
+     */
+    double(value: number): this;
+    /**
+     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(value: number): this;
+    /**
+     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(value: number): this;
+    /**
+     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(value: number): this;
+    /**
+     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(value: string | number | bigint): this;
+    /**
+     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(value: string | number | bigint): this;
+    /**
+     * Write a `int64` value, a signed 64-bit varint.
+     */
+    int64(value: string | number | bigint): this;
+    /**
+     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(value: string | number | bigint): this;
+    /**
+     * Write a `uint64` value, an unsigned 64-bit varint.
+     */
+    uint64(value: string | number | bigint): this;
+}
+export declare class BinaryReader {
+    private readonly decodeUtf8;
+    /**
+     * Current position.
+     */
+    pos: number;
+    /**
+     * Number of bytes available in this reader.
+     */
+    readonly len: number;
+    protected readonly buf: Uint8Array;
+    private readonly view;
+    constructor(buf: Uint8Array, decodeUtf8?: (bytes: Uint8Array) => string);
+    /**
+     * Reads a tag - field number and wire type.
+     */
+    tag(): [number, WireType];
+    /**
+     * Skip one element and return the skipped data.
+     *
+     * When skipping StartGroup, provide the tags field number to check for
+     * matching field number in the EndGroup tag.
+     */
+    skip(wireType: WireType, fieldNo?: number): Uint8Array;
+    protected varint64: () => [number, number];
+    /**
+     * Throws error if position in byte array is out of range.
+     */
+    protected assertBounds(): void;
+    /**
+     * Read a `uint32` field, an unsigned 32 bit varint.
+     */
+    uint32: () => number;
+    /**
+     * Read a `int32` field, a signed 32 bit varint.
+     */
+    int32(): number;
+    /**
+     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(): number;
+    /**
+     * Read a `int64` field, a signed 64-bit varint.
+     */
+    int64(): bigint | string;
+    /**
+     * Read a `uint64` field, an unsigned 64-bit varint.
+     */
+    uint64(): bigint | string;
+    /**
+     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(): bigint | string;
+    /**
+     * Read a `bool` field, a variant.
+     */
+    bool(): boolean;
+    /**
+     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(): number;
+    /**
+     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(): number;
+    /**
+     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(): bigint | string;
+    /**
+     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(): bigint | string;
+    /**
+     * Read a `float` field, 32-bit floating point number.
+     */
+    float(): number;
+    /**
+     * Read a `double` field, a 64-bit floating point number.
+     */
+    double(): number;
+    /**
+     * Read a `bytes` field, length-delimited arbitrary data.
+     */
+    bytes(): Uint8Array;
+    /**
+     * Read a `string` field, length-delimited data converted to UTF-8 text.
+     */
+    string(): string;
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.js
@@ -0,0 +1,514 @@
+"use strict";
+// Copyright 2021-2024 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.BinaryReader = exports.BinaryWriter = exports.INT32_MIN = exports.INT32_MAX = exports.UINT32_MAX = exports.FLOAT32_MIN = exports.FLOAT32_MAX = exports.WireType = void 0;
+const varint_js_1 = require("./varint.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+const text_encoding_js_1 = require("./text-encoding.js");
+/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
+/**
+ * Protobuf binary format wire types.
+ *
+ * A wire type provides just enough information to find the length of the
+ * following value.
+ *
+ * See https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+var WireType;
+(function (WireType) {
+    /**
+     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
+     */
+    WireType[WireType["Varint"] = 0] = "Varint";
+    /**
+     * Used for fixed64, sfixed64, double.
+     * Always 8 bytes with little-endian byte order.
+     */
+    WireType[WireType["Bit64"] = 1] = "Bit64";
+    /**
+     * Used for string, bytes, embedded messages, packed repeated fields
+     *
+     * Only repeated numeric types (types which use the varint, 32-bit,
+     * or 64-bit wire types) can be packed. In proto3, such fields are
+     * packed by default.
+     */
+    WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
+    /**
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
+     */
+    WireType[WireType["StartGroup"] = 3] = "StartGroup";
+    /**
+     * End of a tag-delimited aggregate.
+     */
+    WireType[WireType["EndGroup"] = 4] = "EndGroup";
+    /**
+     * Used for fixed32, sfixed32, float.
+     * Always 4 bytes with little-endian byte order.
+     */
+    WireType[WireType["Bit32"] = 5] = "Bit32";
+})(WireType || (exports.WireType = WireType = {}));
+/**
+ * Maximum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+exports.FLOAT32_MAX = 3.4028234663852886e38;
+/**
+ * Minimum value for a 32-bit floating point value (Protobuf FLOAT).
+ */
+exports.FLOAT32_MIN = -3.4028234663852886e38;
+/**
+ * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32).
+ */
+exports.UINT32_MAX = 0xffffffff;
+/**
+ * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+exports.INT32_MAX = 0x7fffffff;
+/**
+ * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
+ */
+exports.INT32_MIN = -0x80000000;
+class BinaryWriter {
+    constructor(encodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().encodeUtf8) {
+        this.encodeUtf8 = encodeUtf8;
+        /**
+         * Previous fork states.
+         */
+        this.stack = [];
+        this.chunks = [];
+        this.buf = [];
+    }
+    /**
+     * Return all bytes written and reset this writer.
+     */
+    finish() {
+        if (this.buf.length) {
+            this.chunks.push(new Uint8Array(this.buf)); // flush the buffer
+            this.buf = [];
+        }
+        let len = 0;
+        for (let i = 0; i < this.chunks.length; i++)
+            len += this.chunks[i].length;
+        let bytes = new Uint8Array(len);
+        let offset = 0;
+        for (let i = 0; i < this.chunks.length; i++) {
+            bytes.set(this.chunks[i], offset);
+            offset += this.chunks[i].length;
+        }
+        this.chunks = [];
+        return bytes;
+    }
+    /**
+     * Start a new fork for length-delimited data like a message
+     * or a packed repeated field.
+     *
+     * Must be joined later with `join()`.
+     */
+    fork() {
+        this.stack.push({ chunks: this.chunks, buf: this.buf });
+        this.chunks = [];
+        this.buf = [];
+        return this;
+    }
+    /**
+     * Join the last fork. Write its length and bytes, then
+     * return to the previous state.
+     */
+    join() {
+        // get chunk of fork
+        let chunk = this.finish();
+        // restore previous state
+        let prev = this.stack.pop();
+        if (!prev)
+            throw new Error("invalid state, fork stack empty");
+        this.chunks = prev.chunks;
+        this.buf = prev.buf;
+        // write length of chunk as varint
+        this.uint32(chunk.byteLength);
+        return this.raw(chunk);
+    }
+    /**
+     * Writes a tag (field number and wire type).
+     *
+     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+     *
+     * Generated code should compute the tag ahead of time and call `uint32()`.
+     */
+    tag(fieldNo, type) {
+        return this.uint32(((fieldNo << 3) | type) >>> 0);
+    }
+    /**
+     * Write a chunk of raw bytes.
+     */
+    raw(chunk) {
+        if (this.buf.length) {
+            this.chunks.push(new Uint8Array(this.buf));
+            this.buf = [];
+        }
+        this.chunks.push(chunk);
+        return this;
+    }
+    /**
+     * Write a `uint32` value, an unsigned 32 bit varint.
+     */
+    uint32(value) {
+        assertUInt32(value);
+        // write value as varint 32, inlined for speed
+        while (value > 0x7f) {
+            this.buf.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        this.buf.push(value);
+        return this;
+    }
+    /**
+     * Write a `int32` value, a signed 32 bit varint.
+     */
+    int32(value) {
+        assertInt32(value);
+        (0, varint_js_1.varint32write)(value, this.buf);
+        return this;
+    }
+    /**
+     * Write a `bool` value, a variant.
+     */
+    bool(value) {
+        this.buf.push(value ? 1 : 0);
+        return this;
+    }
+    /**
+     * Write a `bytes` value, length-delimited arbitrary data.
+     */
+    bytes(value) {
+        this.uint32(value.byteLength); // write length of chunk as varint
+        return this.raw(value);
+    }
+    /**
+     * Write a `string` value, length-delimited data converted to UTF-8 text.
+     */
+    string(value) {
+        let chunk = this.encodeUtf8(value);
+        this.uint32(chunk.byteLength); // write length of chunk as varint
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `float` value, 32-bit floating point number.
+     */
+    float(value) {
+        assertFloat32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setFloat32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `double` value, a 64-bit floating point number.
+     */
+    double(value) {
+        let chunk = new Uint8Array(8);
+        new DataView(chunk.buffer).setFloat64(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(value) {
+        assertUInt32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setUint32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(value) {
+        assertInt32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setInt32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(value) {
+        assertInt32(value);
+        // zigzag encode
+        value = ((value << 1) ^ (value >> 31)) >>> 0;
+        (0, varint_js_1.varint32write)(value, this.buf);
+        return this;
+    }
+    /**
+     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(value) {
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.enc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(value) {
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.uEnc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `int64` value, a signed 64-bit varint.
+     */
+    int64(value) {
+        let tc = proto_int64_js_1.protoInt64.enc(value);
+        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        return this;
+    }
+    /**
+     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(value) {
+        let tc = proto_int64_js_1.protoInt64.enc(value), 
+        // zigzag encode
+        sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
+        (0, varint_js_1.varint64write)(lo, hi, this.buf);
+        return this;
+    }
+    /**
+     * Write a `uint64` value, an unsigned 64-bit varint.
+     */
+    uint64(value) {
+        let tc = proto_int64_js_1.protoInt64.uEnc(value);
+        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        return this;
+    }
+}
+exports.BinaryWriter = BinaryWriter;
+class BinaryReader {
+    constructor(buf, decodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().decodeUtf8) {
+        this.decodeUtf8 = decodeUtf8;
+        this.varint64 = varint_js_1.varint64read; // dirty cast for `this`
+        /**
+         * Read a `uint32` field, an unsigned 32 bit varint.
+         */
+        this.uint32 = varint_js_1.varint32read;
+        this.buf = buf;
+        this.len = buf.length;
+        this.pos = 0;
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    /**
+     * Reads a tag - field number and wire type.
+     */
+    tag() {
+        let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+        if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+            throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+        return [fieldNo, wireType];
+    }
+    /**
+     * Skip one element and return the skipped data.
+     *
+     * When skipping StartGroup, provide the tags field number to check for
+     * matching field number in the EndGroup tag.
+     */
+    skip(wireType, fieldNo) {
+        let start = this.pos;
+        switch (wireType) {
+            case WireType.Varint:
+                while (this.buf[this.pos++] & 0x80) {
+                    // ignore
+                }
+                break;
+            // eslint-disable-next-line
+            // @ts-expect-error TS7029: Fallthrough case in switch
+            case WireType.Bit64:
+                this.pos += 4;
+            // eslint-disable-next-line no-fallthrough
+            case WireType.Bit32:
+                this.pos += 4;
+                break;
+            case WireType.LengthDelimited:
+                let len = this.uint32();
+                this.pos += len;
+                break;
+            case WireType.StartGroup:
+                for (;;) {
+                    const [fn, wt] = this.tag();
+                    if (wt === WireType.EndGroup) {
+                        if (fieldNo !== undefined && fn !== fieldNo) {
+                            throw new Error("invalid end group tag");
+                        }
+                        break;
+                    }
+                    this.skip(wt, fn);
+                }
+                break;
+            default:
+                throw new Error("cant skip wire type " + wireType);
+        }
+        this.assertBounds();
+        return this.buf.subarray(start, this.pos);
+    }
+    /**
+     * Throws error if position in byte array is out of range.
+     */
+    assertBounds() {
+        if (this.pos > this.len)
+            throw new RangeError("premature EOF");
+    }
+    /**
+     * Read a `int32` field, a signed 32 bit varint.
+     */
+    int32() {
+        return this.uint32() | 0;
+    }
+    /**
+     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32() {
+        let zze = this.uint32();
+        // decode zigzag
+        return (zze >>> 1) ^ -(zze & 1);
+    }
+    /**
+     * Read a `int64` field, a signed 64-bit varint.
+     */
+    int64() {
+        return proto_int64_js_1.protoInt64.dec(...this.varint64());
+    }
+    /**
+     * Read a `uint64` field, an unsigned 64-bit varint.
+     */
+    uint64() {
+        return proto_int64_js_1.protoInt64.uDec(...this.varint64());
+    }
+    /**
+     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64() {
+        let [lo, hi] = this.varint64();
+        // decode zig zag
+        let s = -(lo & 1);
+        lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
+        hi = (hi >>> 1) ^ s;
+        return proto_int64_js_1.protoInt64.dec(lo, hi);
+    }
+    /**
+     * Read a `bool` field, a variant.
+     */
+    bool() {
+        let [lo, hi] = this.varint64();
+        return lo !== 0 || hi !== 0;
+    }
+    /**
+     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32() {
+        return this.view.getUint32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32() {
+        return this.view.getInt32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64() {
+        return proto_int64_js_1.protoInt64.uDec(this.sfixed32(), this.sfixed32());
+    }
+    /**
+     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64() {
+        return proto_int64_js_1.protoInt64.dec(this.sfixed32(), this.sfixed32());
+    }
+    /**
+     * Read a `float` field, 32-bit floating point number.
+     */
+    float() {
+        return this.view.getFloat32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `double` field, a 64-bit floating point number.
+     */
+    double() {
+        return this.view.getFloat64((this.pos += 8) - 8, true);
+    }
+    /**
+     * Read a `bytes` field, length-delimited arbitrary data.
+     */
+    bytes() {
+        let len = this.uint32(), start = this.pos;
+        this.pos += len;
+        this.assertBounds();
+        return this.buf.subarray(start, start + len);
+    }
+    /**
+     * Read a `string` field, length-delimited data converted to UTF-8 text.
+     */
+    string() {
+        return this.decodeUtf8(this.bytes());
+    }
+}
+exports.BinaryReader = BinaryReader;
+/**
+ * Assert a valid signed protobuf 32-bit integer as a number or string.
+ */
+function assertInt32(arg) {
+    if (typeof arg == "string") {
+        arg = Number(arg);
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid int32: " + typeof arg);
+    }
+    if (!Number.isInteger(arg) ||
+        arg > exports.INT32_MAX ||
+        arg < exports.INT32_MIN)
+        throw new Error("invalid int32: " + arg);
+}
+/**
+ * Assert a valid unsigned protobuf 32-bit integer as a number or string.
+ */
+function assertUInt32(arg) {
+    if (typeof arg == "string") {
+        arg = Number(arg);
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid uint32: " + typeof arg);
+    }
+    if (!Number.isInteger(arg) ||
+        arg > exports.UINT32_MAX ||
+        arg < 0)
+        throw new Error("invalid uint32: " + arg);
+}
+/**
+ * Assert a valid protobuf float value as a number or string.
+ */
+function assertFloat32(arg) {
+    if (typeof arg == "string") {
+        const o = arg;
+        arg = Number(arg);
+        if (isNaN(arg) && o !== "NaN") {
+            throw new Error("invalid float32: " + o);
+        }
+    }
+    else if (typeof arg != "number") {
+        throw new Error("invalid float32: " + typeof arg);
+    }
+    if (Number.isFinite(arg) &&
+        (arg > exports.FLOAT32_MAX || arg < exports.FLOAT32_MIN))
+        throw new Error("invalid float32: " + arg);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.d.ts
@@ -0,0 +1,5 @@
+export * from "./binary-encoding.js";
+export * from "./base64-encoding.js";
+export * from "./text-encoding.js";
+export * from "./text-format.js";
+export * from "./size-delimited.js";
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.js
@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2021-2024 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 });
+__exportStar(require("./binary-encoding.js"), exports);
+__exportStar(require("./base64-encoding.js"), exports);
+__exportStar(require("./text-encoding.js"), exports);
+__exportStar(require("./text-format.js"), exports);
+__exportStar(require("./size-delimited.js"), exports);
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.d.ts
@@ -0,0 +1,51 @@
+import type { DescMessage } from "../descriptors.js";
+import type { BinaryWriteOptions } from "../to-binary.js";
+import type { MessageShape } from "../types.js";
+import type { BinaryReadOptions } from "../from-binary.js";
+/**
+ * Serialize a message, prefixing it with its size.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+export declare function sizeDelimitedEncode<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: BinaryWriteOptions): Uint8Array;
+/**
+ * Parse a stream of size-delimited messages.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+export declare function sizeDelimitedDecodeStream<Desc extends DescMessage>(messageDesc: Desc, iterable: AsyncIterable<Uint8Array>, options?: BinaryReadOptions): AsyncIterableIterator<MessageShape<Desc>>;
+/**
+ * Decodes the size from the given size-delimited message, which may be
+ * incomplete.
+ *
+ * Returns an object with the following properties:
+ * - size: The size of the delimited message in bytes
+ * - offset: The offset in the given byte array where the message starts
+ * - eof: true
+ *
+ * If the size-delimited data does not include all bytes of the varint size,
+ * the following object is returned:
+ * - size: null
+ * - offset: null
+ * - eof: false
+ *
+ * This function can be used to implement parsing of size-delimited messages
+ * from a stream.
+ */
+export declare function sizeDelimitedPeek(data: Uint8Array): {
+    readonly eof: false;
+    readonly size: number;
+    readonly offset: number;
+} | {
+    readonly eof: true;
+    readonly size: null;
+    readonly offset: null;
+};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.js
@@ -0,0 +1,153 @@
+"use strict";
+// Copyright 2021-2024 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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeDelimitedEncode = sizeDelimitedEncode;
+exports.sizeDelimitedDecodeStream = sizeDelimitedDecodeStream;
+exports.sizeDelimitedPeek = sizeDelimitedPeek;
+const to_binary_js_1 = require("../to-binary.js");
+const binary_encoding_js_1 = require("./binary-encoding.js");
+const from_binary_js_1 = require("../from-binary.js");
+/**
+ * Serialize a message, prefixing it with its size.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+function sizeDelimitedEncode(messageDesc, message, options) {
+    const writer = new binary_encoding_js_1.BinaryWriter();
+    writer.bytes((0, to_binary_js_1.toBinary)(messageDesc, message, options));
+    return writer.finish();
+}
+/**
+ * Parse a stream of size-delimited messages.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+function sizeDelimitedDecodeStream(messageDesc, iterable, options) {
+    return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() {
+        var _a, e_1, _b, _c;
+        // append chunk to buffer, returning updated buffer
+        function append(buffer, chunk) {
+            const n = new Uint8Array(buffer.byteLength + chunk.byteLength);
+            n.set(buffer);
+            n.set(chunk, buffer.length);
+            return n;
+        }
+        let buffer = new Uint8Array(0);
+        try {
+            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+                _c = iterable_1_1.value;
+                _d = false;
+                const chunk = _c;
+                buffer = append(buffer, chunk);
+                for (;;) {
+                    const size = sizeDelimitedPeek(buffer);
+                    if (size.eof) {
+                        // size is incomplete, buffer more data
+                        break;
+                    }
+                    if (size.offset + size.size > buffer.byteLength) {
+                        // message is incomplete, buffer more data
+                        break;
+                    }
+                    yield yield __await((0, from_binary_js_1.fromBinary)(messageDesc, buffer.subarray(size.offset, size.offset + size.size), options));
+                    buffer = buffer.subarray(size.offset + size.size);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (buffer.byteLength > 0) {
+            throw new Error("incomplete data");
+        }
+    });
+}
+/**
+ * Decodes the size from the given size-delimited message, which may be
+ * incomplete.
+ *
+ * Returns an object with the following properties:
+ * - size: The size of the delimited message in bytes
+ * - offset: The offset in the given byte array where the message starts
+ * - eof: true
+ *
+ * If the size-delimited data does not include all bytes of the varint size,
+ * the following object is returned:
+ * - size: null
+ * - offset: null
+ * - eof: false
+ *
+ * This function can be used to implement parsing of size-delimited messages
+ * from a stream.
+ */
+function sizeDelimitedPeek(data) {
+    const sizeEof = { eof: true, size: null, offset: null };
+    for (let i = 0; i < 10; i++) {
+        if (i > data.byteLength) {
+            return sizeEof;
+        }
+        if ((data[i] & 0x80) == 0) {
+            const reader = new binary_encoding_js_1.BinaryReader(data);
+            let size;
+            try {
+                size = reader.uint32();
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    return sizeEof;
+                }
+                throw e;
+            }
+            return {
+                eof: false,
+                size,
+                offset: reader.pos,
+            };
+        }
+    }
+    throw new Error("invalid varint");
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.d.ts
@@ -0,0 +1,26 @@
+interface TextEncoding {
+    /**
+     * Verify that the given text is valid UTF-8.
+     */
+    checkUtf8: (text: string) => boolean;
+    /**
+     * Encode UTF-8 text to binary.
+     */
+    encodeUtf8: (text: string) => Uint8Array;
+    /**
+     * Decode UTF-8 text from binary.
+     */
+    decodeUtf8: (bytes: Uint8Array) => string;
+}
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+export declare function configureTextEncoding(textEncoding: TextEncoding): void;
+export declare function getTextEncoding(): TextEncoding;
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.js
@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2021-2024 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.configureTextEncoding = configureTextEncoding;
+exports.getTextEncoding = getTextEncoding;
+const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+function configureTextEncoding(textEncoding) {
+    globalThis[symbol] = textEncoding;
+}
+function getTextEncoding() {
+    if (globalThis[symbol] == undefined) {
+        const te = new globalThis.TextEncoder();
+        const td = new globalThis.TextDecoder();
+        globalThis[symbol] = {
+            encodeUtf8(text) {
+                return te.encode(text);
+            },
+            decodeUtf8(bytes) {
+                return td.decode(bytes);
+            },
+            checkUtf8(text) {
+                try {
+                    encodeURIComponent(text);
+                    return true;
+                }
+                catch (e) {
+                    return false;
+                }
+            },
+        };
+    }
+    return globalThis[symbol];
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.d.ts
@@ -0,0 +1,13 @@
+import { type DescEnum, ScalarType } from "../descriptors.js";
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.js
@@ -0,0 +1,200 @@
+"use strict";
+// Copyright 2021-2024 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.parseTextFormatEnumValue = parseTextFormatEnumValue;
+exports.parseTextFormatScalarValue = parseTextFormatScalarValue;
+const descriptors_js_1 = require("../descriptors.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
+function parseTextFormatEnumValue(descEnum, value) {
+    const enumValue = descEnum.values.find((v) => v.name === value);
+    if (!enumValue) {
+        throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+    }
+    return enumValue.number;
+}
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
+function parseTextFormatScalarValue(type, value) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            return value;
+        case descriptors_js_1.ScalarType.BYTES: {
+            const u = unescapeBytesDefaultValue(value);
+            if (u === false) {
+                throw new Error(`cannot parse ${descriptors_js_1.ScalarType[type]} default value: ${value}`);
+            }
+            return u;
+        }
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            return proto_int64_js_1.protoInt64.parse(value);
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+            return proto_int64_js_1.protoInt64.uParse(value);
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            switch (value) {
+                case "inf":
+                    return Number.POSITIVE_INFINITY;
+                case "-inf":
+                    return Number.NEGATIVE_INFINITY;
+                case "nan":
+                    return Number.NaN;
+                default:
+                    return parseFloat(value);
+            }
+        case descriptors_js_1.ScalarType.BOOL:
+            return value === "true";
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SINT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+            return parseInt(value, 10);
+    }
+}
+/**
+ * Parses a text-encoded default value (proto2) of a BYTES field.
+ */
+function unescapeBytesDefaultValue(str) {
+    const b = [];
+    const input = {
+        tail: str,
+        c: "",
+        next() {
+            if (this.tail.length == 0) {
+                return false;
+            }
+            this.c = this.tail[0];
+            this.tail = this.tail.substring(1);
+            return true;
+        },
+        take(n) {
+            if (this.tail.length >= n) {
+                const r = this.tail.substring(0, n);
+                this.tail = this.tail.substring(n);
+                return r;
+            }
+            return false;
+        },
+    };
+    while (input.next()) {
+        switch (input.c) {
+            case "\\":
+                if (input.next()) {
+                    switch (input.c) {
+                        case "\\":
+                            b.push(input.c.charCodeAt(0));
+                            break;
+                        case "b":
+                            b.push(0x08);
+                            break;
+                        case "f":
+                            b.push(0x0c);
+                            break;
+                        case "n":
+                            b.push(0x0a);
+                            break;
+                        case "r":
+                            b.push(0x0d);
+                            break;
+                        case "t":
+                            b.push(0x09);
+                            break;
+                        case "v":
+                            b.push(0x0b);
+                            break;
+                        case "0":
+                        case "1":
+                        case "2":
+                        case "3":
+                        case "4":
+                        case "5":
+                        case "6":
+                        case "7": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 8);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "x": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "u": {
+                            const s = input.c;
+                            const t = input.take(4);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            const chunk = new Uint8Array(4);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, n, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+                            break;
+                        }
+                        case "U": {
+                            const s = input.c;
+                            const t = input.take(8);
+                            if (t === false) {
+                                return false;
+                            }
+                            const tc = proto_int64_js_1.protoInt64.uEnc(s + t);
+                            const chunk = new Uint8Array(8);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, tc.lo, true);
+                            view.setInt32(4, tc.hi, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b.push(input.c.charCodeAt(0));
+        }
+    }
+    return new Uint8Array(b);
+}
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.d.ts
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.d.ts
@@ -0,0 +1,70 @@
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export declare function varint64read<T extends ReaderLike>(this: T): [number, number];
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64ToString(lo: number, hi: number): string;
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read<T extends ReaderLike>(this: T): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+export {};
--- a/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.js
+++ b/MasterOK/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.js
@@ -0,0 +1,323 @@
+"use strict";
+// Copyright 2008 Google Inc.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Code generated by the Protocol Buffer compiler is owned by the owner
+// of the input file used when generating it.  This code is not
+// standalone and requires a support library to be linked with it.  This
+// support library is itself covered by the above license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varint64read = varint64read;
+exports.varint64write = varint64write;
+exports.int64FromString = int64FromString;
+exports.int64ToString = int64ToString;
+exports.uInt64ToString = uInt64ToString;
+exports.varint32write = varint32write;
+exports.varint32read = varint32read;
+/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+function varint64read() {
+    let lowBits = 0;
+    let highBits = 0;
+    for (let shift = 0; shift < 28; shift += 7) {
+        let b = this.buf[this.pos++];
+        lowBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    let middleByte = this.buf[this.pos++];
+    // last four bits of the first 32 bit number
+    lowBits |= (middleByte & 0x0f) << 28;
+    // 3 upper bits are part of the next 32 bit number
+    highBits = (middleByte & 0x70) >> 4;
+    if ((middleByte & 0x80) == 0) {
+        this.assertBounds();
+        return [lowBits, highBits];
+    }
+    for (let shift = 3; shift <= 31; shift += 7) {
+        let b = this.buf[this.pos++];
+        highBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    throw new Error("invalid varint");
+}
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+function varint64write(lo, hi, bytes) {
+    for (let i = 0; i < 28; i = i + 7) {
+        const shift = lo >>> i;
+        const hasNext = !(shift >>> 7 == 0 && hi == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+    const hasMoreBits = !(hi >> 3 == 0);
+    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+    if (!hasMoreBits) {
+        return;
+    }
+    for (let i = 3; i < 31; i = i + 7) {
+        const shift = hi >>> i;
+        const hasNext = !(shift >>> 7 == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    bytes.push((hi >>> 31) & 0x01);
+}
+// constants for binary math
+const TWO_PWR_32_DBL = 0x100000000;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+function int64FromString(dec) {
+    // Check for minus sign.
+    const minus = dec[0] === "-";
+    if (minus) {
+        dec = dec.slice(1);
+    }
+    // Work 6 decimal digits at a time, acting like we're converting base 1e6
+    // digits to binary. This is safe to do with floating point math because
+    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
+    const base = 1e6;
+    let lowBits = 0;
+    let highBits = 0;
+    function add1e6digit(begin, end) {
+        // Note: Number('') is 0.
+        const digit1e6 = Number(dec.slice(begin, end));
+        highBits *= base;
+        lowBits = lowBits * base + digit1e6;
+        // Carry bits from lowBits to
+        if (lowBits >= TWO_PWR_32_DBL) {
+            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+            lowBits = lowBits % TWO_PWR_32_DBL;
+        }
+    }
+    add1e6digit(-24, -18);
+    add1e6digit(-18, -12);
+    add1e6digit(-12, -6);
+    add1e6digit(-6);
+    return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+function int64ToString(lo, hi) {
+    let bits = newBits(lo, hi);
+    // If we're treating the input as a signed value and the high bit is set, do
+    // a manual two's complement conversion before the decimal conversion.
+    const negative = bits.hi & 0x80000000;
+    if (negative) {
+        bits = negate(bits.lo, bits.hi);
+    }
+    const result = uInt64ToString(bits.lo, bits.hi);
+    return negative ? "-" + result : result;
+}
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+function uInt64ToString(lo, hi) {
+    ({ lo, hi } = toUnsigned(lo, hi));
+    // Skip the expensive conversion if the number is small enough to use the
+    // built-in conversions.
+    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
+    // highBits <= 0x1FFFFF can be safely expressed with a double and retain
+    // integer precision.
+    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
+    if (hi <= 0x1fffff) {
+        return String(TWO_PWR_32_DBL * hi + lo);
+    }
+    // What this code is doing is essentially converting the input number from
+    // base-2 to base-1e7, which allows us to represent the 64-bit range with
+    // only 3 (very large) digits. Those digits are then trivial to convert to
+    // a base-10 string.
+    // The magic numbers used here are -
+    // 2^24 = 16777216 = (1,6777216) in base-1e7.
+    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
+    // Split 32:32 representation into 16:24:24 representation so our
+    // intermediate digits don't overflow.
+    const low = lo & 0xffffff;
+    const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff;
+    const high = (hi >> 16) & 0xffff;
+    // Assemble our three base-1e7 digits, ignoring carries. The maximum
+    // value in a digit at this step is representable as a 48-bit integer, which
+    // can be stored in a 64-bit floating point number.
+    let digitA = low + mid * 6777216 + high * 6710656;
+    let digitB = mid + high * 8147497;
+    let digitC = high * 2;
+    // Apply carries from A to B and from B to C.
+    const base = 10000000;
+    if (digitA >= base) {
+        digitB += Math.floor(digitA / base);
+        digitA %= base;
+    }
+    if (digitB >= base) {
+        digitC += Math.floor(digitB / base);
+        digitB %= base;
+    }
+    // If digitC is 0, then we should have returned in the trivial code path
+    // at the top for non-safe integers. Given this, we can assume both digitB
+    // and digitA need leading zeros.
+    return (digitC.toString() +
+        decimalFrom1e7WithLeadingZeros(digitB) +
+        decimalFrom1e7WithLeadingZeros(digitA));
+}
+function toUnsigned(lo, hi) {
+    return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+    return { lo: lo | 0, hi: hi | 0 };
+}
+/**
+ * Returns two's compliment negation of input.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
+ */
+function negate(lowBits, highBits) {
+    highBits = ~highBits;
+    if (lowBits) {
+        lowBits = ~lowBits + 1;
+    }
+    else {
+        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
+        // adding 1 to that, results in 0x100000000, which leaves
+        // the low bits 0x0 and simply adds one to the high bits.
+        highBits += 1;
+    }
+    return newBits(lowBits, highBits);
+}
+/**
+ * Returns decimal representation of digit1e7 with leading zeros.
+ */
+const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+    const partial = String(digit1e7);
+    return "0000000".slice(partial.length) + partial;
+};
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+function varint32write(value, bytes) {
+    if (value >= 0) {
+        // write value as varint 32
+        while (value > 0x7f) {
+            bytes.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        bytes.push(value);
+    }
+    else {
+        for (let i = 0; i < 9; i++) {
+            bytes.push((value & 127) | 128);
+            value = value >> 7;
+        }
+        bytes.push(1);
+    }
+}
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+function varint32read() {
+    let b = this.buf[this.pos++];
+    let result = b & 0x7f;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 7;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 14;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 21;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    // Extract only last 4 bits
+    b = this.buf[this.pos++];
+    result |= (b & 0x0f) << 28;
+    for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+        b = this.buf[this.pos++];
+    if ((b & 0x80) != 0)
+        throw new Error("invalid varint");
+    this.assertBounds();
+    // Result can have 32 bits, convert it to unsigned
+    return result >>> 0;
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
xom9k	9d7637251b	измененный отчет	2025-05-23 11:43:13 +04:00
slavaxom9k	53659c9344	Удалить MasterOK/src/.DS_Store	2025-02-09 16:10:51 +04:00
slavaxom9k	45c5819bd3	Удалить MasterOK/.DS_Store	2025-02-09 16:10:32 +04:00
xom9k	d148ee005e	добавление отчета	2025-02-09 16:08:54 +04:00
xom9k	2348f75d70	первая лаба	2025-02-09 15:50:52 +04:00