@camstack/system 1.2.380 → 1.2.382

package/dist/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-Cc6KOdY-.js");
-const require_jwt_signing_key = require("./jwt-signing-key-C2rE3wH6.js");
+const require_dist = require("./dist-tnAO12ak.js");
+const require_jwt_signing_key = require("./jwt-signing-key-Dgf8sIXY.js");
 const require_builtins_alerts_alerts_addon = require("./builtins/alerts/alerts.addon.js");
 require("./builtins/alerts/index.js");
 const require_builtins_calendars_calendars_addon = require("./builtins/calendars/calendars.addon.js");
@@ -24,19 +24,20 @@ const require_builtins_native_metrics_native_metrics_addon = require("./builtins
 const require_builtins_sqlite_storage_filesystem_storage_addon = require("./builtins/sqlite-storage/filesystem-storage.addon.js");
 const require_builtins_sqlite_storage_sqlite_settings_addon = require("./builtins/sqlite-storage/sqlite-settings.addon.js");
 const require_builtins_sqlite_storage_index = require("./builtins/sqlite-storage/index.js");
-const require_hub_cap_forward = require("./hub-cap-forward-COCmYaup.js");
+const require_hub_cap_forward = require("./hub-cap-forward-W8oEm4ME.js");
 const require_builtins_storage_orchestrator_storage_orchestrator_addon = require("./builtins/storage-orchestrator/storage-orchestrator.addon.js");
 require("./builtins/storage-orchestrator/index.js");
-const require_cluster_secret = require("./cluster-secret-Dg0OOOSr.js");
+const require_cluster_secret = require("./cluster-secret-BEPLh3LL.js");
 const require_builtins_system_config_system_config_addon = require("./builtins/system-config/system-config.addon.js");
 require("./builtins/system-config/index.js");
 const require_builtins_winston_logging_index = require("./builtins/winston-logging/index.js");
-const require_event_loop_stall_monitor = require("./event-loop-stall-monitor-mk6WGxir.js");
-const require_tls$1 = require("./tls-CCMX7MjX.js");
-const require_child_cap_dispatch = require("./child-cap-dispatch-CZeRUgYF.js");
+const require_event_loop_stall_monitor = require("./event-loop-stall-monitor-9kR0sAPS.js");
+const require_tls$1 = require("./tls-CljF057D.js");
+const require_child_cap_dispatch = require("./child-cap-dispatch-BrMdKHfp.js");
 const require_platform_key_source = require("./platform-key-source-Di7HrlGR.js");
 const require_resource_monitor = require("./resource-monitor-BgWGRxN5.js");
 const require_custom_action_registry = require("./custom-action-registry-acBY3mHA.js");
+const require_restore_archive = require("./restore-archive-CbvrfPuB.js");
 let zod = require("zod");
 let node_crypto = require("node:crypto");
 let _camstack_types_node = require("@camstack/types/node");
@@ -10476,8 +10477,8 @@ function createStoreSettingsView(addonId, cm) {
 *
 * So a bootstrap-owned section is answered from env + config.yaml ONLY, and
 * the store may add exactly the keys in {@link STORE_READABLE_BOOTSTRAP_KEYS}:
-* today `auth.tokenExpiry`, the one value the operator edits in the UI
-* (System → Authentication). Widening this list is a security decision, not a
+* the values the operator edits on System → Authentication (`auth.tokenExpiry`,
+* `auth.accessTokenExpiry`, `auth.trustedProxies`). Widening this list is a security decision, not a
 * convenience.
 */
 /** Top-level sections whose authority is env + config.yaml (`bootstrapSchema`). */
@@ -10492,7 +10493,12 @@ var BOOTSTRAP_OWNED_SECTIONS = new Set([
 	"keychain"
 ]);
 /** The only keys under a bootstrap-owned section the store may answer. */
-var STORE_READABLE_BOOTSTRAP_KEYS = new Set(["auth.tokenExpiry"]);
+var STORE_READABLE_BOOTSTRAP_KEYS = new Set([
+	"auth.tokenExpiry",
+	"auth.accessTokenExpiry",
+	"auth.trustedProxies",
+	"auth.trustedNetworks"
+]);
 /** May the settings store answer `key`, or is it env + config.yaml only? */
 function storeMayAnswer(key) {
 	const dot = key.indexOf(".");
@@ -10511,9 +10517,15 @@ function storeMayAnswer(key) {
 var PRELOADED_SYSTEM_PREFIXES = ["capabilities."];
 /**
 * Single keys loaded the same way. `auth.tokenExpiry` is read synchronously on
-* every mint by the hub's `AuthService` (`AuthManager.signToken`).
+* every mint by the hub's `AuthService` (`AuthManager.signToken`), and
+* `auth.trustedProxies` on every public auth request (`auth-network-policy.ts`).
 */
-var PRELOADED_SYSTEM_KEYS = ["auth.tokenExpiry"];
+var PRELOADED_SYSTEM_KEYS = [
+	"auth.tokenExpiry",
+	"auth.accessTokenExpiry",
+	"auth.trustedProxies",
+	"auth.trustedNetworks"
+];
 /** Is `key` served from the boot-time mirror when the engine is isolated? */
 function isPreloadedSystemKey(key) {
 	if (PRELOADED_SYSTEM_KEYS.includes(key)) return true;
@@ -31002,8 +31014,8 @@ var require_kleur = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, modul
 var require_utils$3 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	var kleur = require_kleur();
 	var os$19 = require("os");
-	var path$39 = require("path");
-	var fs$18 = require("fs");
+	var path$40 = require("path");
+	var fs$20 = require("fs");
 	var { TimeoutError } = require_errors$2();
 	var lut = [];
 	for (let i = 0; i < 256; i++) lut[i] = (i < 16 ? "0" : "") + i.toString(16);
@@ -31276,8 +31288,8 @@ var require_utils$3 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, mod
 		* @param {*} value
 		* @returns {Object}
 		*/
-		dotSet(obj, path$43, value) {
-			const parts = path$43.split(".");
+		dotSet(obj, path$44, value) {
+			const parts = path$44.split(".");
 			const part = parts.shift();
 			if (part && parts.length > 0) {
 				if (!Object.prototype.hasOwnProperty.call(obj, part)) obj[part] = {};
@@ -31286,7 +31298,7 @@ var require_utils$3 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, mod
 				obj[part] = utils.dotSet(obj[part], parts.join("."), value);
 				return obj;
 			}
-			obj[path$43] = value;
+			obj[path$44] = value;
 			return obj;
 		},
 		/**
@@ -31294,9 +31306,9 @@ var require_utils$3 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, mod
 		* @param {String} p - directory path
 		*/
 		makeDirs(p) {
-			p.split(path$39.sep).reduce((prevPath, folder) => {
-				const currentPath = path$39.join(prevPath, folder, path$39.sep);
-				if (!fs$18.existsSync(currentPath)) fs$18.mkdirSync(currentPath);
+			p.split(path$40.sep).reduce((prevPath, folder) => {
+				const currentPath = path$40.join(prevPath, folder, path$40.sep);
+				if (!fs$20.existsSync(currentPath)) fs$20.mkdirSync(currentPath);
 				return currentPath;
 			}, "");
 		},
@@ -32521,8 +32533,8 @@ var require_csv = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module)
 	var BaseReporter = require_base$8();
 	var { makeDirs } = require_utils$3();
 	var _ = require_lodash();
-	var path$38 = require("path");
-	var fs$17 = require("fs");
+	var path$39 = require("path");
+	var fs$19 = require("fs");
 	var METRIC = require_constants$6();
 	var MODE_METRIC = "metric";
 	var MODE_LABEL = "label";
@@ -32575,7 +32587,7 @@ var require_csv = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module)
 				this.timer = setInterval(() => this.flush(), this.opts.interval * 1e3);
 				this.timer.unref();
 			}
-			this.folder = path$38.resolve(this.opts.folder);
+			this.folder = path$39.resolve(this.opts.folder);
 			makeDirs(this.folder);
 		}
 		/**
@@ -32600,10 +32612,10 @@ var require_csv = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module)
 			const metricName = this.formatMetricName(metric.name);
 			if (this.opts.filenameFormatter) return this.opts.filenameFormatter.call(this, metricName, metric, item);
 			switch (this.opts.mode) {
-				case MODE_METRIC: return path$38.join(this.folder, `${metricName}.csv`);
+				case MODE_METRIC: return path$39.join(this.folder, `${metricName}.csv`);
 				case MODE_LABEL: {
 					const labelStr = this.labelsToStr(item.labels);
-					return path$38.join(this.folder, metricName, `${metricName}${labelStr ? "--" + labelStr : ""}.csv`);
+					return path$39.join(this.folder, metricName, `${metricName}${labelStr ? "--" + labelStr : ""}.csv`);
 				}
 			}
 		}
@@ -32624,7 +32636,7 @@ var require_csv = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module)
 				metric.values.forEach((item) => {
 					if (!this.lastChanges.has([metric.name, this.labelsToStr(item.labels)].join("|"))) return;
 					const filename = this.getFilename(metric, item);
-					makeDirs(path$38.dirname(filename));
+					makeDirs(path$39.dirname(filename));
 					const metricName = this.formatMetricName(metric.name);
 					let headers = ["Timestamp", "Metric"];
 					let data = [item.timestamp, metricName];
@@ -32681,8 +32693,8 @@ var require_csv = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module)
 		*/
 		writeRow(filename, headers, fields) {
 			try {
-				if (!fs$17.existsSync(filename)) fs$17.writeFileSync(filename, headers.join(this.opts.delimiter) + this.opts.rowDelimiter);
-				fs$17.appendFileSync(filename, fields.join(this.opts.delimiter) + this.opts.rowDelimiter);
+				if (!fs$19.existsSync(filename)) fs$19.writeFileSync(filename, headers.join(this.opts.delimiter) + this.opts.rowDelimiter);
+				fs$19.appendFileSync(filename, fields.join(this.opts.delimiter) + this.opts.rowDelimiter);
 			} catch (err) {
 				/* istanbul ignore next */
 				this.logger.error(`Unable to write metrics values to the '${filename}' file. Error: ${err.message}`, fields, err);
@@ -37684,7 +37696,7 @@ var require_inherits = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, mo
 }));
 //#endregion
 //#region ../../node_modules/util-deprecate/node.js
-var require_node$2 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+var require_node$3 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	/**
 	* For Node.js, simply re-export the core `util.deprecate` function.
 	*/
@@ -37704,7 +37716,7 @@ var require__stream_writable = /* @__PURE__ */ require_chunk.__commonJSMin(((exp
 	}
 	var Duplex;
 	Writable.WritableState = WritableState;
-	var internalUtil = { deprecate: require_node$2() };
+	var internalUtil = { deprecate: require_node$3() };
 	var Stream = require_stream$1();
 	var Buffer$13 = require("buffer").Buffer;
 	var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
@@ -40691,12 +40703,2609 @@ var require_notepack = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, mo
 	module.exports = NotepackSerializer;
 }));
 //#endregion
-//#region __vite-optional-peer-dep:cbor-x:moleculer
-var __vite_optional_peer_dep_cbor_x_moleculer_exports = /* @__PURE__ */ require_chunk.__exportAll({ default: () => __vite_optional_peer_dep_cbor_x_moleculer_default });
-var __vite_optional_peer_dep_cbor_x_moleculer_default;
-var init___vite_optional_peer_dep_cbor_x_moleculer = require_chunk.__esmMin((() => {
-	__vite_optional_peer_dep_cbor_x_moleculer_default = {};
-	throw new Error(`Could not resolve "cbor-x" imported by "moleculer". Is it installed?`);
+//#region ../../node_modules/detect-libc/lib/process.js
+var require_process$1 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var isLinux = () => process.platform === "linux";
+	var report = null;
+	var getReport = () => {
+		if (!report)
+ /* istanbul ignore next */
+		if (isLinux() && process.report) {
+			const orig = process.report.excludeNetwork;
+			process.report.excludeNetwork = true;
+			report = process.report.getReport();
+			process.report.excludeNetwork = orig;
+		} else report = {};
+		return report;
+	};
+	module.exports = {
+		isLinux,
+		getReport
+	};
+}));
+//#endregion
+//#region ../../node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var fs$18 = require("fs");
+	var LDD_PATH = "/usr/bin/ldd";
+	var SELF_PATH = "/proc/self/exe";
+	var MAX_LENGTH = 2048;
+	/**
+	* Read the content of a file synchronous
+	*
+	* @param {string} path
+	* @returns {Buffer}
+	*/
+	var readFileSync = (path) => {
+		const fd = fs$18.openSync(path, "r");
+		const buffer = Buffer.alloc(MAX_LENGTH);
+		const bytesRead = fs$18.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+		fs$18.close(fd, () => {});
+		return buffer.subarray(0, bytesRead);
+	};
+	/**
+	* Read the content of a file
+	*
+	* @param {string} path
+	* @returns {Promise<Buffer>}
+	*/
+	var readFile = (path) => new Promise((resolve, reject) => {
+		fs$18.open(path, "r", (err, fd) => {
+			if (err) reject(err);
+			else {
+				const buffer = Buffer.alloc(MAX_LENGTH);
+				fs$18.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+					resolve(buffer.subarray(0, bytesRead));
+					fs$18.close(fd, () => {});
+				});
+			}
+		});
+	});
+	module.exports = {
+		LDD_PATH,
+		SELF_PATH,
+		readFileSync,
+		readFile
+	};
+}));
+//#endregion
+//#region ../../node_modules/detect-libc/lib/elf.js
+var require_elf = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var interpreterPath = (elf) => {
+		if (elf.length < 64) return null;
+		if (elf.readUInt32BE(0) !== 2135247942) return null;
+		if (elf.readUInt8(4) !== 2) return null;
+		if (elf.readUInt8(5) !== 1) return null;
+		const offset = elf.readUInt32LE(32);
+		const size = elf.readUInt16LE(54);
+		const count = elf.readUInt16LE(56);
+		for (let i = 0; i < count; i++) {
+			const headerOffset = offset + i * size;
+			if (elf.readUInt32LE(headerOffset) === 3) {
+				const fileOffset = elf.readUInt32LE(headerOffset + 8);
+				const fileSize = elf.readUInt32LE(headerOffset + 32);
+				return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+			}
+		}
+		return null;
+	};
+	module.exports = { interpreterPath };
+}));
+//#endregion
+//#region ../../node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var childProcess = require("child_process");
+	var { isLinux, getReport } = require_process$1();
+	var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
+	var { interpreterPath } = require_elf();
+	var cachedFamilyInterpreter;
+	var cachedFamilyFilesystem;
+	var cachedVersionFilesystem;
+	var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+	var commandOut = "";
+	var safeCommand = () => {
+		if (!commandOut) return new Promise((resolve) => {
+			childProcess.exec(command, (err, out) => {
+				commandOut = err ? " " : out;
+				resolve(commandOut);
+			});
+		});
+		return commandOut;
+	};
+	var safeCommandSync = () => {
+		if (!commandOut) try {
+			commandOut = childProcess.execSync(command, { encoding: "utf8" });
+		} catch (_err) {
+			commandOut = " ";
+		}
+		return commandOut;
+	};
+	/**
+	* A String constant containing the value `glibc`.
+	* @type {string}
+	* @public
+	*/
+	var GLIBC = "glibc";
+	/**
+	* A Regexp constant to get the GLIBC Version.
+	* @type {string}
+	*/
+	var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+	/**
+	* A String constant containing the value `musl`.
+	* @type {string}
+	* @public
+	*/
+	var MUSL = "musl";
+	var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+	var familyFromReport = () => {
+		const report = getReport();
+		if (report.header && report.header.glibcVersionRuntime) return GLIBC;
+		if (Array.isArray(report.sharedObjects)) {
+			if (report.sharedObjects.some(isFileMusl)) return MUSL;
+		}
+		return null;
+	};
+	var familyFromCommand = (out) => {
+		const [getconf, ldd1] = out.split(/[\r\n]+/);
+		if (getconf && getconf.includes(GLIBC)) return GLIBC;
+		if (ldd1 && ldd1.includes(MUSL)) return MUSL;
+		return null;
+	};
+	var familyFromInterpreterPath = (path) => {
+		if (path) {
+			if (path.includes("/ld-musl-")) return MUSL;
+			else if (path.includes("/ld-linux-")) return GLIBC;
+		}
+		return null;
+	};
+	var getFamilyFromLddContent = (content) => {
+		content = content.toString();
+		if (content.includes("musl")) return MUSL;
+		if (content.includes("GNU C Library")) return GLIBC;
+		return null;
+	};
+	var familyFromFilesystem = async () => {
+		if (cachedFamilyFilesystem !== void 0) return cachedFamilyFilesystem;
+		cachedFamilyFilesystem = null;
+		try {
+			cachedFamilyFilesystem = getFamilyFromLddContent(await readFile(LDD_PATH));
+		} catch (e) {}
+		return cachedFamilyFilesystem;
+	};
+	var familyFromFilesystemSync = () => {
+		if (cachedFamilyFilesystem !== void 0) return cachedFamilyFilesystem;
+		cachedFamilyFilesystem = null;
+		try {
+			cachedFamilyFilesystem = getFamilyFromLddContent(readFileSync(LDD_PATH));
+		} catch (e) {}
+		return cachedFamilyFilesystem;
+	};
+	var familyFromInterpreter = async () => {
+		if (cachedFamilyInterpreter !== void 0) return cachedFamilyInterpreter;
+		cachedFamilyInterpreter = null;
+		try {
+			cachedFamilyInterpreter = familyFromInterpreterPath(interpreterPath(await readFile(SELF_PATH)));
+		} catch (e) {}
+		return cachedFamilyInterpreter;
+	};
+	var familyFromInterpreterSync = () => {
+		if (cachedFamilyInterpreter !== void 0) return cachedFamilyInterpreter;
+		cachedFamilyInterpreter = null;
+		try {
+			cachedFamilyInterpreter = familyFromInterpreterPath(interpreterPath(readFileSync(SELF_PATH)));
+		} catch (e) {}
+		return cachedFamilyInterpreter;
+	};
+	/**
+	* Resolves with the libc family when it can be determined, `null` otherwise.
+	* @returns {Promise<?string>}
+	*/
+	var family = async () => {
+		let family = null;
+		if (isLinux()) {
+			family = await familyFromInterpreter();
+			if (!family) {
+				family = await familyFromFilesystem();
+				if (!family) family = familyFromReport();
+				if (!family) family = familyFromCommand(await safeCommand());
+			}
+		}
+		return family;
+	};
+	/**
+	* Returns the libc family when it can be determined, `null` otherwise.
+	* @returns {?string}
+	*/
+	var familySync = () => {
+		let family = null;
+		if (isLinux()) {
+			family = familyFromInterpreterSync();
+			if (!family) {
+				family = familyFromFilesystemSync();
+				if (!family) family = familyFromReport();
+				if (!family) family = familyFromCommand(safeCommandSync());
+			}
+		}
+		return family;
+	};
+	/**
+	* Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
+	* @returns {Promise<boolean>}
+	*/
+	var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+	/**
+	* Returns `true` only when the platform is Linux and the libc family is not `glibc`.
+	* @returns {boolean}
+	*/
+	var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+	var versionFromFilesystem = async () => {
+		if (cachedVersionFilesystem !== void 0) return cachedVersionFilesystem;
+		cachedVersionFilesystem = null;
+		try {
+			const versionMatch = (await readFile(LDD_PATH)).match(RE_GLIBC_VERSION);
+			if (versionMatch) cachedVersionFilesystem = versionMatch[1];
+		} catch (e) {}
+		return cachedVersionFilesystem;
+	};
+	var versionFromFilesystemSync = () => {
+		if (cachedVersionFilesystem !== void 0) return cachedVersionFilesystem;
+		cachedVersionFilesystem = null;
+		try {
+			const versionMatch = readFileSync(LDD_PATH).match(RE_GLIBC_VERSION);
+			if (versionMatch) cachedVersionFilesystem = versionMatch[1];
+		} catch (e) {}
+		return cachedVersionFilesystem;
+	};
+	var versionFromReport = () => {
+		const report = getReport();
+		if (report.header && report.header.glibcVersionRuntime) return report.header.glibcVersionRuntime;
+		return null;
+	};
+	var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+	var versionFromCommand = (out) => {
+		const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+		if (getconf && getconf.includes(GLIBC)) return versionSuffix(getconf);
+		if (ldd1 && ldd2 && ldd1.includes(MUSL)) return versionSuffix(ldd2);
+		return null;
+	};
+	/**
+	* Resolves with the libc version when it can be determined, `null` otherwise.
+	* @returns {Promise<?string>}
+	*/
+	var version = async () => {
+		let version = null;
+		if (isLinux()) {
+			version = await versionFromFilesystem();
+			if (!version) version = versionFromReport();
+			if (!version) version = versionFromCommand(await safeCommand());
+		}
+		return version;
+	};
+	/**
+	* Returns the libc version when it can be determined, `null` otherwise.
+	* @returns {?string}
+	*/
+	var versionSync = () => {
+		let version = null;
+		if (isLinux()) {
+			version = versionFromFilesystemSync();
+			if (!version) version = versionFromReport();
+			if (!version) version = versionFromCommand(safeCommandSync());
+		}
+		return version;
+	};
+	module.exports = {
+		GLIBC,
+		MUSL,
+		family,
+		familySync,
+		isNonGlibcLinux,
+		isNonGlibcLinuxSync,
+		version,
+		versionSync
+	};
+}));
+//#endregion
+//#region ../../node_modules/node-gyp-build-optional-packages/index.js
+var require_node_gyp_build_optional_packages = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var fs$17 = require("fs");
+	var path$38 = require("path");
+	var url$2 = require("url");
+	var vars = process.config && process.config.variables || {};
+	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+	var versions = process.versions;
+	var abi = versions.modules;
+	if (versions.deno || process.isBun) abi = "unsupported";
+	var runtime = isElectron() ? "electron" : "node";
+	var arch = process.arch;
+	var platform = process.platform;
+	var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
+	var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+	var uv = (versions.uv || "").split(".")[0];
+	module.exports = load;
+	function load(dir) {
+		if (typeof __webpack_require__ === "function") return __non_webpack_require__(load.path(dir));
+		else return require(load.path(dir));
+	}
+	load.path = function(dir) {
+		dir = path$38.resolve(dir || ".");
+		var packageName = "";
+		try {
+			if (typeof __webpack_require__ === "function") packageName = __non_webpack_require__(path$38.join(dir, "package.json")).name;
+			else packageName = require(path$38.join(dir, "package.json")).name;
+			var varName = packageName.toUpperCase().replace(/-/g, "_") + "_PREBUILD";
+			if (process.env[varName]) dir = process.env[varName];
+		} catch (err) {}
+		if (!prebuildsOnly) {
+			var release = getFirst(path$38.join(dir, "build/Release"), matchBuild);
+			if (release) return release;
+			var debug = getFirst(path$38.join(dir, "build/Debug"), matchBuild);
+			if (debug) return debug;
+		}
+		var prebuild = resolve(dir);
+		if (prebuild) return prebuild;
+		var nearby = resolve(path$38.dirname(process.execPath));
+		if (nearby) return nearby;
+		var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
+		try {
+			return resolveFile(path$38.dirname(require("module").createRequire(url$2.pathToFileURL(path$38.join(dir, "package.json"))).resolve(platformPackage)));
+		} catch (error) {}
+		var target = [
+			"platform=" + platform,
+			"arch=" + arch,
+			"runtime=" + runtime,
+			"abi=" + abi,
+			"uv=" + uv,
+			armv ? "armv=" + armv : "",
+			"libc=" + libc,
+			"node=" + process.versions.node,
+			process.versions.electron ? "electron=" + process.versions.electron : "",
+			typeof __webpack_require__ === "function" ? "webpack=true" : ""
+		].filter(Boolean).join(" ");
+		throw new Error("No native build was found for " + target + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
+		function resolve(dir) {
+			var tuple = readdirSync(path$38.join(dir, "prebuilds")).map(parseTuple).filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+			if (!tuple) return;
+			return resolveFile(path$38.join(dir, "prebuilds", tuple.name));
+		}
+		function resolveFile(prebuilds) {
+			var winner = readdirSync(prebuilds).map(parseTags).filter(matchTags(runtime, abi)).sort(compareTags(runtime))[0];
+			if (winner) return path$38.join(prebuilds, winner.file);
+		}
+	};
+	function readdirSync(dir) {
+		try {
+			return fs$17.readdirSync(dir);
+		} catch (err) {
+			return [];
+		}
+	}
+	function getFirst(dir, filter) {
+		var files = readdirSync(dir).filter(filter);
+		return files[0] && path$38.join(dir, files[0]);
+	}
+	function matchBuild(name) {
+		return /\.node$/.test(name);
+	}
+	function parseTuple(name) {
+		var arr = name.split("-");
+		if (arr.length !== 2) return;
+		var platform = arr[0];
+		var architectures = arr[1].split("+");
+		if (!platform) return;
+		if (!architectures.length) return;
+		if (!architectures.every(Boolean)) return;
+		return {
+			name,
+			platform,
+			architectures
+		};
+	}
+	function matchTuple(platform, arch) {
+		return function(tuple) {
+			if (tuple == null) return false;
+			if (tuple.platform !== platform) return false;
+			return tuple.architectures.includes(arch);
+		};
+	}
+	function compareTuples(a, b) {
+		return a.architectures.length - b.architectures.length;
+	}
+	function parseTags(file) {
+		var arr = file.split(".");
+		var extension = arr.pop();
+		var tags = {
+			file,
+			specificity: 0
+		};
+		if (extension !== "node") return;
+		for (var i = 0; i < arr.length; i++) {
+			var tag = arr[i];
+			if (tag === "node" || tag === "electron" || tag === "node-webkit") tags.runtime = tag;
+			else if (tag === "napi") tags.napi = true;
+			else if (tag.slice(0, 3) === "abi") tags.abi = tag.slice(3);
+			else if (tag.slice(0, 2) === "uv") tags.uv = tag.slice(2);
+			else if (tag.slice(0, 4) === "armv") tags.armv = tag.slice(4);
+			else if (tag === "glibc" || tag === "musl") tags.libc = tag;
+			else continue;
+			tags.specificity++;
+		}
+		return tags;
+	}
+	function matchTags(runtime, abi) {
+		return function(tags) {
+			if (tags == null) return false;
+			if (tags.runtime !== runtime && !runtimeAgnostic(tags)) return false;
+			if (tags.abi !== abi && !tags.napi) return false;
+			if (tags.uv && tags.uv !== uv) return false;
+			if (tags.armv && tags.armv !== armv) return false;
+			if (tags.libc && tags.libc !== libc) return false;
+			return true;
+		};
+	}
+	function runtimeAgnostic(tags) {
+		return tags.runtime === "node" && tags.napi;
+	}
+	function compareTags(runtime) {
+		return function(a, b) {
+			if (a.runtime !== b.runtime) return a.runtime === runtime ? -1 : 1;
+			else if (a.abi !== b.abi) return a.abi ? -1 : 1;
+			else if (a.specificity !== b.specificity) return a.specificity > b.specificity ? -1 : 1;
+			else return 0;
+		};
+	}
+	function isElectron() {
+		if (process.versions && process.versions.electron) return true;
+		if (process.env.ELECTRON_RUN_AS_NODE) return true;
+		return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+	}
+	function isMusl(platform) {
+		if (platform !== "linux") return false;
+		const { familySync, MUSL } = require_detect_libc();
+		return familySync() === MUSL;
+	}
+	load.parseTags = parseTags;
+	load.matchTags = matchTags;
+	load.compareTags = compareTags;
+	load.parseTuple = parseTuple;
+	load.matchTuple = matchTuple;
+	load.compareTuples = compareTuples;
+}));
+//#endregion
+//#region ../../node_modules/cbor-extract/index.js
+var require_cbor_extract = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	module.exports = require_node_gyp_build_optional_packages()(__dirname);
+}));
+//#endregion
+//#region ../../node_modules/cbor-x/dist/node.cjs
+var require_node$2 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
+	var stream$1 = require("stream");
+	var module$1$1 = require("module");
+	var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+	var decoder;
+	try {
+		decoder = new TextDecoder();
+	} catch (error) {}
+	var src;
+	var srcEnd;
+	var position$1 = 0;
+	var EMPTY_ARRAY = [];
+	var LEGACY_RECORD_INLINE_ID = 105;
+	var RECORD_DEFINITIONS_ID = 57342;
+	var RECORD_INLINE_ID = 57343;
+	var BUNDLED_STRINGS_ID = 57337;
+	var PACKED_REFERENCE_TAG_ID = 6;
+	var STOP_CODE = {};
+	var maxArraySize = 11281e4;
+	var maxMapSize = 1681e4;
+	var strings = EMPTY_ARRAY;
+	var stringPosition = 0;
+	var currentDecoder = {};
+	var currentStructures;
+	var srcString;
+	var srcStringStart = 0;
+	var srcStringEnd = 0;
+	var bundledStrings$1;
+	var referenceMap;
+	var currentExtensions = [];
+	var currentExtensionRanges = [];
+	var packedValues;
+	var dataView;
+	var restoreMapsAsObject;
+	var defaultOptions = {
+		useRecords: false,
+		mapsAsObjects: true
+	};
+	var sequentialMode = false;
+	var inlineObjectReadThreshold = 2;
+	try {
+		new Function("");
+	} catch (error) {
+		inlineObjectReadThreshold = Infinity;
+	}
+	var Decoder = class Decoder {
+		constructor(options) {
+			if (options) {
+				if ((options.keyMap || options._keyMap) && !options.useRecords) {
+					options.useRecords = false;
+					options.mapsAsObjects = true;
+				}
+				if (options.useRecords === false && options.mapsAsObjects === void 0) options.mapsAsObjects = true;
+				if (options.getStructures) options.getShared = options.getStructures;
+				if (options.getShared && !options.structures) (options.structures = []).uninitialized = true;
+				if (options.keyMap) {
+					this.mapKey = /* @__PURE__ */ new Map();
+					for (let [k, v] of Object.entries(options.keyMap)) this.mapKey.set(v, k);
+				}
+			}
+			Object.assign(this, options);
+		}
+		decodeKey(key) {
+			return this.keyMap ? this.mapKey.get(key) || key : key;
+		}
+		encodeKey(key) {
+			return this.keyMap && this.keyMap.hasOwnProperty(key) ? this.keyMap[key] : key;
+		}
+		encodeKeys(rec) {
+			if (!this._keyMap) return rec;
+			let map = /* @__PURE__ */ new Map();
+			for (let [k, v] of Object.entries(rec)) map.set(this._keyMap.hasOwnProperty(k) ? this._keyMap[k] : k, v);
+			return map;
+		}
+		decodeKeys(map) {
+			if (!this._keyMap || map.constructor.name != "Map") return map;
+			if (!this._mapKey) {
+				this._mapKey = /* @__PURE__ */ new Map();
+				for (let [k, v] of Object.entries(this._keyMap)) this._mapKey.set(v, k);
+			}
+			let res = {};
+			map.forEach((v, k) => res[safeKey(this._mapKey.has(k) ? this._mapKey.get(k) : k)] = v);
+			return res;
+		}
+		mapDecode(source, end) {
+			let res = this.decode(source);
+			if (this._keyMap) switch (res.constructor.name) {
+				case "Array": return res.map((r) => this.decodeKeys(r));
+			}
+			return res;
+		}
+		decode(source, end) {
+			if (src) return saveState(() => {
+				clearSource();
+				return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end);
+			});
+			srcEnd = end > -1 ? end : source.length;
+			position$1 = 0;
+			stringPosition = 0;
+			srcStringEnd = 0;
+			srcString = null;
+			strings = EMPTY_ARRAY;
+			bundledStrings$1 = null;
+			src = source;
+			try {
+				dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
+			} catch (error) {
+				src = null;
+				if (source instanceof Uint8Array) throw error;
+				throw new Error("Source must be a Uint8Array or Buffer but was a " + (source && typeof source == "object" ? source.constructor.name : typeof source));
+			}
+			if (this instanceof Decoder) {
+				currentDecoder = this;
+				packedValues = this.sharedValues && (this.pack ? new Array(this.maxPrivatePackedValues || 16).concat(this.sharedValues) : this.sharedValues);
+				if (this.structures) {
+					currentStructures = this.structures;
+					return checkedRead();
+				} else if (!currentStructures || currentStructures.length > 0) currentStructures = [];
+			} else {
+				currentDecoder = defaultOptions;
+				if (!currentStructures || currentStructures.length > 0) currentStructures = [];
+				packedValues = null;
+			}
+			return checkedRead();
+		}
+		decodeMultiple(source, forEach) {
+			let values, lastPosition = 0;
+			try {
+				let size = source.length;
+				sequentialMode = true;
+				let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
+				if (forEach) {
+					if (forEach(value) === false) return;
+					while (position$1 < size) {
+						lastPosition = position$1;
+						if (forEach(checkedRead()) === false) return;
+					}
+				} else {
+					values = [value];
+					while (position$1 < size) {
+						lastPosition = position$1;
+						values.push(checkedRead());
+					}
+					return values;
+				}
+			} catch (error) {
+				error.lastPosition = lastPosition;
+				error.values = values;
+				throw error;
+			} finally {
+				sequentialMode = false;
+				clearSource();
+			}
+		}
+	};
+	function checkedRead() {
+		try {
+			let result = read();
+			if (bundledStrings$1) {
+				if (position$1 >= bundledStrings$1.postBundlePosition) {
+					let error = /* @__PURE__ */ new Error("Unexpected bundle position");
+					error.incomplete = true;
+					throw error;
+				}
+				position$1 = bundledStrings$1.postBundlePosition;
+				bundledStrings$1 = null;
+			}
+			if (position$1 == srcEnd) {
+				currentStructures = null;
+				src = null;
+				if (referenceMap) referenceMap = null;
+			} else if (position$1 > srcEnd) {
+				let error = /* @__PURE__ */ new Error("Unexpected end of CBOR data");
+				error.incomplete = true;
+				throw error;
+			} else if (!sequentialMode) throw new Error("Data read, but end of buffer not reached");
+			return result;
+		} catch (error) {
+			clearSource();
+			if (error instanceof RangeError || error.message.startsWith("Unexpected end of buffer")) error.incomplete = true;
+			throw error;
+		}
+	}
+	function endOfCBORError() {
+		let error = /* @__PURE__ */ new Error("Unexpected end of CBOR data");
+		error.incomplete = true;
+		return error;
+	}
+	function read() {
+		if (!(position$1 < srcEnd)) throw endOfCBORError();
+		let token = src[position$1++];
+		let majorType = token >> 5;
+		token = token & 31;
+		if (token > 23) switch (token) {
+			case 24:
+				if (position$1 >= srcEnd) throw endOfCBORError();
+				token = src[position$1++];
+				break;
+			case 25:
+				if (majorType == 7) return getFloat16();
+				token = dataView.getUint16(position$1);
+				position$1 += 2;
+				break;
+			case 26:
+				if (majorType == 7) {
+					let value = dataView.getFloat32(position$1);
+					if (currentDecoder.useFloat32 > 2) {
+						let multiplier = mult10[(src[position$1] & 127) << 1 | src[position$1 + 1] >> 7];
+						position$1 += 4;
+						return (multiplier * value + (value > 0 ? .5 : -.5) >> 0) / multiplier;
+					}
+					position$1 += 4;
+					return value;
+				}
+				token = dataView.getUint32(position$1);
+				position$1 += 4;
+				if (majorType === 1) return -1 - token;
+				break;
+			case 27:
+				if (majorType == 7) {
+					let value = dataView.getFloat64(position$1);
+					position$1 += 8;
+					return value;
+				}
+				if (majorType > 1) {
+					if (dataView.getUint32(position$1) > 0) throw new Error("JavaScript does not support arrays, maps, or strings with length over 4294967295");
+					token = dataView.getUint32(position$1 + 4);
+				} else if (currentDecoder.int64AsNumber) {
+					token = dataView.getUint32(position$1) * 4294967296;
+					token += dataView.getUint32(position$1 + 4);
+				} else token = dataView.getBigUint64(position$1);
+				position$1 += 8;
+				break;
+			case 31: switch (majorType) {
+				case 2:
+				case 3: throw new Error("Indefinite length not supported for byte or text strings");
+				case 4:
+					let array = [];
+					let value, i = 0;
+					while ((value = read()) != STOP_CODE) {
+						if (i >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`);
+						array[i++] = value;
+					}
+					return majorType == 4 ? array : majorType == 3 ? array.join("") : Buffer.concat(array);
+				case 5:
+					let key;
+					if (currentDecoder.mapsAsObjects) {
+						let object = {};
+						let i = 0;
+						if (currentDecoder.keyMap) while ((key = read()) != STOP_CODE) {
+							if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`);
+							object[safeKey(currentDecoder.decodeKey(key))] = read();
+						}
+						else while ((key = read()) != STOP_CODE) {
+							if (i++ >= maxMapSize) throw new Error(`Property count exceeds ${maxMapSize}`);
+							object[safeKey(key)] = read();
+						}
+						return object;
+					} else {
+						if (restoreMapsAsObject) {
+							currentDecoder.mapsAsObjects = true;
+							restoreMapsAsObject = false;
+						}
+						let map = /* @__PURE__ */ new Map();
+						if (currentDecoder.keyMap) {
+							let i = 0;
+							while ((key = read()) != STOP_CODE) {
+								if (i++ >= maxMapSize) throw new Error(`Map size exceeds ${maxMapSize}`);
+								map.set(currentDecoder.decodeKey(key), read());
+							}
+						} else {
+							let i = 0;
+							while ((key = read()) != STOP_CODE) {
+								if (i++ >= maxMapSize) throw new Error(`Map size exceeds ${maxMapSize}`);
+								map.set(key, read());
+							}
+						}
+						return map;
+					}
+				case 7: return STOP_CODE;
+				default: throw new Error("Invalid major type for indefinite length " + majorType);
+			}
+			default: throw new Error("Unknown token " + token);
+		}
+		switch (majorType) {
+			case 0: return token;
+			case 1: return ~token;
+			case 2: return readBin(token);
+			case 3:
+				if (srcStringEnd >= position$1) return srcString.slice(position$1 - srcStringStart, (position$1 += token) - srcStringStart);
+				if (srcStringEnd == 0 && srcEnd < 140 && token < 32) {
+					let string = token < 16 ? shortStringInJS(token) : longStringInJS(token);
+					if (string != null) return string;
+				}
+				return readFixedString(token);
+			case 4:
+				if (token >= maxArraySize) throw new Error(`Array length exceeds ${maxArraySize}`);
+				if (token > srcEnd - position$1) throw endOfCBORError();
+				let array = new Array(token);
+				for (let i = 0; i < token; i++) array[i] = read();
+				return array;
+			case 5:
+				if (token >= maxMapSize) throw new Error(`Map size exceeds ${maxArraySize}`);
+				if (token > (srcEnd - position$1) / 2) throw endOfCBORError();
+				if (currentDecoder.mapsAsObjects) {
+					let object = {};
+					if (currentDecoder.keyMap) for (let i = 0; i < token; i++) object[safeKey(currentDecoder.decodeKey(read()))] = read();
+					else for (let i = 0; i < token; i++) object[safeKey(read())] = read();
+					return object;
+				} else {
+					if (restoreMapsAsObject) {
+						currentDecoder.mapsAsObjects = true;
+						restoreMapsAsObject = false;
+					}
+					let map = /* @__PURE__ */ new Map();
+					if (currentDecoder.keyMap) for (let i = 0; i < token; i++) map.set(currentDecoder.decodeKey(read()), read());
+					else for (let i = 0; i < token; i++) map.set(read(), read());
+					return map;
+				}
+			case 6:
+				if (token >= BUNDLED_STRINGS_ID) {
+					let structure = currentStructures[token & 8191];
+					if (structure) {
+						if (!structure.read) structure.read = createStructureReader(structure);
+						return structure.read();
+					}
+					if (token < 65536) {
+						if (token == RECORD_INLINE_ID) {
+							let length = readJustLength();
+							let id = read();
+							let structure = read();
+							recordDefinition(id, structure);
+							let object = {};
+							if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
+								let key = currentDecoder.decodeKey(structure[i - 2]);
+								object[safeKey(key)] = read();
+							}
+							else for (let i = 2; i < length; i++) {
+								let key = structure[i - 2];
+								object[safeKey(key)] = read();
+							}
+							return object;
+						} else if (token == RECORD_DEFINITIONS_ID) {
+							let length = readJustLength();
+							let id = read();
+							for (let i = 2; i < length; i++) recordDefinition(id++, read());
+							return read();
+						} else if (token == BUNDLED_STRINGS_ID) return readBundleExt();
+						if (currentDecoder.getShared) {
+							loadShared();
+							structure = currentStructures[token & 8191];
+							if (structure) {
+								if (!structure.read) structure.read = createStructureReader(structure);
+								return structure.read();
+							}
+						}
+					}
+				}
+				let extension = currentExtensions[token];
+				if (extension) if (extension.handlesRead) return extension(read);
+				else return extension(read());
+				else {
+					let input = read();
+					for (let i = 0; i < currentExtensionRanges.length; i++) {
+						let value = currentExtensionRanges[i](token, input);
+						if (value !== void 0) return value;
+					}
+					return new Tag(input, token);
+				}
+			case 7: switch (token) {
+				case 20: return false;
+				case 21: return true;
+				case 22: return null;
+				case 23: return;
+				default:
+					let packedValue = (packedValues || getPackedValues())[token];
+					if (packedValue !== void 0) return packedValue;
+					throw new Error("Unknown token " + token);
+			}
+			default:
+				if (isNaN(token)) throw endOfCBORError();
+				throw new Error("Unknown CBOR token " + token);
+		}
+	}
+	var validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
+	function createStructureReader(structure) {
+		if (!structure) throw new Error("Structure is required in record definition");
+		function readObject() {
+			let length = src[position$1++];
+			length = length & 31;
+			if (length > 23) switch (length) {
+				case 24:
+					length = src[position$1++];
+					break;
+				case 25:
+					length = dataView.getUint16(position$1);
+					position$1 += 2;
+					break;
+				case 26:
+					length = dataView.getUint32(position$1);
+					position$1 += 4;
+					break;
+				default: throw new Error("Expected array header, but got " + src[position$1 - 1]);
+			}
+			let compiledReader = this.compiledReader;
+			while (compiledReader) {
+				if (compiledReader.propertyCount === length) return compiledReader(read);
+				compiledReader = compiledReader.next;
+			}
+			if (this.slowReads++ >= inlineObjectReadThreshold) {
+				let array = this.length == length ? this : this.slice(0, length);
+				compiledReader = currentDecoder.keyMap ? new Function("r", "return {" + array.map((k) => currentDecoder.decodeKey(k)).map((k) => validName.test(k) ? safeKey(k) + ":r()" : "[" + JSON.stringify(k) + "]:r()").join(",") + "}") : new Function("r", "return {" + array.map((key) => validName.test(key) ? safeKey(key) + ":r()" : "[" + JSON.stringify(key) + "]:r()").join(",") + "}");
+				if (this.compiledReader) compiledReader.next = this.compiledReader;
+				compiledReader.propertyCount = length;
+				this.compiledReader = compiledReader;
+				return compiledReader(read);
+			}
+			let object = {};
+			if (currentDecoder.keyMap) for (let i = 0; i < length; i++) object[safeKey(currentDecoder.decodeKey(this[i]))] = read();
+			else for (let i = 0; i < length; i++) object[safeKey(this[i])] = read();
+			return object;
+		}
+		structure.slowReads = 0;
+		return readObject;
+	}
+	function safeKey(key) {
+		if (typeof key === "string") return key === "__proto__" ? "__proto_" : key;
+		if (typeof key === "number" || typeof key === "boolean" || typeof key === "bigint") return key.toString();
+		if (key == null) return key + "";
+		throw new Error("Invalid property name type " + typeof key);
+	}
+	var readFixedString = readStringJS;
+	exports.isNativeAccelerationEnabled = false;
+	function setExtractor(extractStrings) {
+		exports.isNativeAccelerationEnabled = true;
+		readFixedString = readString();
+		function readString(headerLength) {
+			return function readString(length) {
+				let string = strings[stringPosition++];
+				if (string == null) {
+					if (bundledStrings$1) return readStringJS(length);
+					let extraction = extractStrings(position$1, srcEnd, length, src);
+					if (typeof extraction == "string") {
+						string = extraction;
+						strings = EMPTY_ARRAY;
+					} else {
+						strings = extraction;
+						stringPosition = 1;
+						srcStringEnd = 1;
+						string = strings[0];
+						if (string === void 0) throw new Error("Unexpected end of buffer");
+					}
+				}
+				let srcStringLength = string.length;
+				if (srcStringLength <= length) {
+					position$1 += length;
+					return string;
+				}
+				srcString = string;
+				srcStringStart = position$1;
+				srcStringEnd = position$1 + srcStringLength;
+				position$1 += length;
+				return string.slice(0, length);
+			};
+		}
+	}
+	function readStringJS(length) {
+		let result;
+		if (length < 16) {
+			if (result = shortStringInJS(length)) return result;
+		}
+		if (length > 64 && decoder) return decoder.decode(src.subarray(position$1, position$1 += length));
+		const end = position$1 + length;
+		const units = [];
+		result = "";
+		while (position$1 < end) {
+			const byte1 = src[position$1++];
+			if ((byte1 & 128) === 0) units.push(byte1);
+			else if ((byte1 & 224) === 192) if (byte1 < 194 || position$1 >= end || (src[position$1] & 192) !== 128) units.push(65533);
+			else {
+				const byte2 = src[position$1++] & 63;
+				units.push((byte1 & 31) << 6 | byte2);
+			}
+			else if ((byte1 & 240) === 224) {
+				const byte2 = position$1 < end ? src[position$1] : 0;
+				if (position$1 >= end || (byte2 & 192) !== 128 || byte1 === 224 && byte2 < 160 || byte1 === 237 && byte2 >= 160) units.push(65533);
+				else {
+					position$1++;
+					if (position$1 >= end || (src[position$1] & 192) !== 128) units.push(65533);
+					else {
+						const byte3 = src[position$1++] & 63;
+						units.push((byte1 & 31) << 12 | (byte2 & 63) << 6 | byte3);
+					}
+				}
+			} else if ((byte1 & 248) === 240) {
+				const byte2 = position$1 < end ? src[position$1] : 0;
+				if (byte1 > 244 || position$1 >= end || (byte2 & 192) !== 128 || byte1 === 240 && byte2 < 144 || byte1 === 244 && byte2 >= 144) units.push(65533);
+				else {
+					position$1++;
+					if (position$1 >= end || (src[position$1] & 192) !== 128) units.push(65533);
+					else {
+						const byte3 = src[position$1++] & 63;
+						if (position$1 >= end || (src[position$1] & 192) !== 128) units.push(65533);
+						else {
+							const byte4 = src[position$1++] & 63;
+							let unit = (byte1 & 7) << 18 | (byte2 & 63) << 12 | byte3 << 6 | byte4;
+							unit -= 65536;
+							units.push(unit >>> 10 & 1023 | 55296);
+							units.push(56320 | unit & 1023);
+						}
+					}
+				}
+			} else units.push(65533);
+			if (units.length >= 4096) {
+				result += fromCharCode.apply(String, units);
+				units.length = 0;
+			}
+		}
+		if (units.length > 0) result += fromCharCode.apply(String, units);
+		return result;
+	}
+	var fromCharCode = String.fromCharCode;
+	function longStringInJS(length) {
+		let start = position$1;
+		let bytes = new Array(length);
+		for (let i = 0; i < length; i++) {
+			const byte = src[position$1++];
+			if ((byte & 128) > 0) {
+				position$1 = start;
+				return;
+			}
+			bytes[i] = byte;
+		}
+		return fromCharCode.apply(String, bytes);
+	}
+	function shortStringInJS(length) {
+		if (length < 4) if (length < 2) if (length === 0) return "";
+		else {
+			let a = src[position$1++];
+			if ((a & 128) > 1) {
+				position$1 -= 1;
+				return;
+			}
+			return fromCharCode(a);
+		}
+		else {
+			let a = src[position$1++];
+			let b = src[position$1++];
+			if ((a & 128) > 0 || (b & 128) > 0) {
+				position$1 -= 2;
+				return;
+			}
+			if (length < 3) return fromCharCode(a, b);
+			let c = src[position$1++];
+			if ((c & 128) > 0) {
+				position$1 -= 3;
+				return;
+			}
+			return fromCharCode(a, b, c);
+		}
+		else {
+			let a = src[position$1++];
+			let b = src[position$1++];
+			let c = src[position$1++];
+			let d = src[position$1++];
+			if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
+				position$1 -= 4;
+				return;
+			}
+			if (length < 6) if (length === 4) return fromCharCode(a, b, c, d);
+			else {
+				let e = src[position$1++];
+				if ((e & 128) > 0) {
+					position$1 -= 5;
+					return;
+				}
+				return fromCharCode(a, b, c, d, e);
+			}
+			else if (length < 8) {
+				let e = src[position$1++];
+				let f = src[position$1++];
+				if ((e & 128) > 0 || (f & 128) > 0) {
+					position$1 -= 6;
+					return;
+				}
+				if (length < 7) return fromCharCode(a, b, c, d, e, f);
+				let g = src[position$1++];
+				if ((g & 128) > 0) {
+					position$1 -= 7;
+					return;
+				}
+				return fromCharCode(a, b, c, d, e, f, g);
+			} else {
+				let e = src[position$1++];
+				let f = src[position$1++];
+				let g = src[position$1++];
+				let h = src[position$1++];
+				if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
+					position$1 -= 8;
+					return;
+				}
+				if (length < 10) if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
+				else {
+					let i = src[position$1++];
+					if ((i & 128) > 0) {
+						position$1 -= 9;
+						return;
+					}
+					return fromCharCode(a, b, c, d, e, f, g, h, i);
+				}
+				else if (length < 12) {
+					let i = src[position$1++];
+					let j = src[position$1++];
+					if ((i & 128) > 0 || (j & 128) > 0) {
+						position$1 -= 10;
+						return;
+					}
+					if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+					let k = src[position$1++];
+					if ((k & 128) > 0) {
+						position$1 -= 11;
+						return;
+					}
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+				} else {
+					let i = src[position$1++];
+					let j = src[position$1++];
+					let k = src[position$1++];
+					let l = src[position$1++];
+					if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
+						position$1 -= 12;
+						return;
+					}
+					if (length < 14) if (length === 12) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+					else {
+						let m = src[position$1++];
+						if ((m & 128) > 0) {
+							position$1 -= 13;
+							return;
+						}
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+					}
+					else {
+						let m = src[position$1++];
+						let n = src[position$1++];
+						if ((m & 128) > 0 || (n & 128) > 0) {
+							position$1 -= 14;
+							return;
+						}
+						if (length < 15) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+						let o = src[position$1++];
+						if ((o & 128) > 0) {
+							position$1 -= 15;
+							return;
+						}
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+					}
+				}
+			}
+		}
+	}
+	function readBin(length) {
+		return currentDecoder.copyBuffers ? Uint8Array.prototype.slice.call(src, position$1, position$1 += length) : src.subarray(position$1, position$1 += length);
+	}
+	var f32Array = new Float32Array(1);
+	var u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+	function getFloat16() {
+		let byte0 = src[position$1++];
+		let byte1 = src[position$1++];
+		let exponent = (byte0 & 127) >> 2;
+		if (exponent === 31) {
+			if (byte1 || byte0 & 3) return NaN;
+			return byte0 & 128 ? -Infinity : Infinity;
+		}
+		if (exponent === 0) {
+			let abs = ((byte0 & 3) << 8 | byte1) / (1 << 24);
+			return byte0 & 128 ? -abs : abs;
+		}
+		u8Array[3] = byte0 & 128 | (exponent >> 1) + 56;
+		u8Array[2] = (byte0 & 7) << 5 | byte1 >> 3;
+		u8Array[1] = byte1 << 5;
+		u8Array[0] = 0;
+		return f32Array[0];
+	}
+	new Array(4096);
+	var Tag = class {
+		constructor(value, tag) {
+			this.value = value;
+			this.tag = tag;
+		}
+	};
+	currentExtensions[0] = (dateString) => {
+		return new Date(dateString);
+	};
+	currentExtensions[1] = (epochSec) => {
+		return new Date(Math.round(epochSec * 1e3));
+	};
+	currentExtensions[2] = (buffer) => {
+		let value = BigInt(0);
+		for (let i = 0, l = buffer.byteLength; i < l; i++) value = BigInt(buffer[i]) + (value << BigInt(8));
+		return value;
+	};
+	currentExtensions[3] = (buffer) => {
+		return BigInt(-1) - currentExtensions[2](buffer);
+	};
+	currentExtensions[4] = (fraction) => {
+		return +(fraction[1] + "e" + fraction[0]);
+	};
+	currentExtensions[5] = (fraction) => {
+		return fraction[1] * Math.exp(fraction[0] * Math.log(2));
+	};
+	var recordDefinition = (id, structure) => {
+		id = id - 57344;
+		let existingStructure = currentStructures[id];
+		if (existingStructure && existingStructure.isShared) (currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
+		currentStructures[id] = structure;
+		structure.read = createStructureReader(structure);
+	};
+	currentExtensions[LEGACY_RECORD_INLINE_ID] = (data) => {
+		let length = data.length;
+		let structure = data[1];
+		recordDefinition(data[0], structure);
+		let object = {};
+		for (let i = 2; i < length; i++) {
+			let key = structure[i - 2];
+			object[safeKey(key)] = data[i];
+		}
+		return object;
+	};
+	currentExtensions[14] = (value) => {
+		if (bundledStrings$1) return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 += value);
+		return new Tag(value, 14);
+	};
+	currentExtensions[15] = (value) => {
+		if (bundledStrings$1) return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value);
+		return new Tag(value, 15);
+	};
+	var glbl = {
+		Error,
+		RegExp
+	};
+	currentExtensions[27] = (data) => {
+		return (glbl[data[0]] || Error)(data[1], data[2]);
+	};
+	var packedTable = (read) => {
+		if (src[position$1++] != 132) {
+			let error = /* @__PURE__ */ new Error("Packed values structure must be followed by a 4 element array");
+			if (src.length < position$1) error.incomplete = true;
+			throw error;
+		}
+		let newPackedValues = read();
+		if (!newPackedValues || !newPackedValues.length) {
+			let error = /* @__PURE__ */ new Error("Packed values structure must be followed by a 4 element array");
+			error.incomplete = true;
+			throw error;
+		}
+		packedValues = packedValues ? newPackedValues.concat(packedValues.slice(newPackedValues.length)) : newPackedValues;
+		packedValues.prefixes = read();
+		packedValues.suffixes = read();
+		return read();
+	};
+	packedTable.handlesRead = true;
+	currentExtensions[51] = packedTable;
+	currentExtensions[PACKED_REFERENCE_TAG_ID] = (data) => {
+		if (!packedValues) if (currentDecoder.getShared) loadShared();
+		else return new Tag(data, PACKED_REFERENCE_TAG_ID);
+		if (typeof data == "number") return packedValues[16 + (data >= 0 ? 2 * data : -2 * data - 1)];
+		let error = /* @__PURE__ */ new Error("No support for non-integer packed references yet");
+		if (data === void 0) error.incomplete = true;
+		throw error;
+	};
+	currentExtensions[28] = (read) => {
+		if (!referenceMap) {
+			referenceMap = /* @__PURE__ */ new Map();
+			referenceMap.id = 0;
+		}
+		let id = referenceMap.id++;
+		let startingPosition = position$1;
+		let token = src[position$1];
+		let target;
+		if (token >> 5 == 4) target = [];
+		else target = {};
+		let refEntry = { target };
+		referenceMap.set(id, refEntry);
+		let targetProperties = read();
+		if (refEntry.used) {
+			if (Object.getPrototypeOf(target) !== Object.getPrototypeOf(targetProperties)) {
+				position$1 = startingPosition;
+				target = targetProperties;
+				referenceMap.set(id, { target });
+				targetProperties = read();
+			}
+			return Object.assign(target, targetProperties);
+		}
+		refEntry.target = targetProperties;
+		return targetProperties;
+	};
+	currentExtensions[28].handlesRead = true;
+	currentExtensions[29] = (id) => {
+		let refEntry = referenceMap.get(id);
+		refEntry.used = true;
+		return refEntry.target;
+	};
+	currentExtensions[258] = (array) => new Set(array);
+	(currentExtensions[259] = (read) => {
+		if (currentDecoder.mapsAsObjects) {
+			currentDecoder.mapsAsObjects = false;
+			restoreMapsAsObject = true;
+		}
+		return read();
+	}).handlesRead = true;
+	function combine(a, b) {
+		if (typeof a === "string") return a + b;
+		if (a instanceof Array) return a.concat(b);
+		return Object.assign({}, a, b);
+	}
+	function getPackedValues() {
+		if (!packedValues) if (currentDecoder.getShared) loadShared();
+		else throw new Error("No packed values available");
+		return packedValues;
+	}
+	var SHARED_DATA_TAG_ID = 1399353956;
+	currentExtensionRanges.push((tag, input) => {
+		if (tag >= 225 && tag <= 255) return combine(getPackedValues().prefixes[tag - 224], input);
+		if (tag >= 28704 && tag <= 32767) return combine(getPackedValues().prefixes[tag - 28672], input);
+		if (tag >= 1879052288 && tag <= 2147483647) return combine(getPackedValues().prefixes[tag - 1879048192], input);
+		if (tag >= 216 && tag <= 223) return combine(input, getPackedValues().suffixes[tag - 216]);
+		if (tag >= 27647 && tag <= 28671) return combine(input, getPackedValues().suffixes[tag - 27639]);
+		if (tag >= 1811940352 && tag <= 1879048191) return combine(input, getPackedValues().suffixes[tag - 1811939328]);
+		if (tag == SHARED_DATA_TAG_ID) return {
+			packedValues,
+			structures: currentStructures.slice(0),
+			version: input
+		};
+		if (tag == 55799) return input;
+	});
+	var isLittleEndianMachine$1 = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+	var typedArrays = [
+		Uint8Array,
+		Uint8ClampedArray,
+		Uint16Array,
+		Uint32Array,
+		typeof BigUint64Array == "undefined" ? { name: "BigUint64Array" } : BigUint64Array,
+		Int8Array,
+		Int16Array,
+		Int32Array,
+		typeof BigInt64Array == "undefined" ? { name: "BigInt64Array" } : BigInt64Array,
+		Float32Array,
+		Float64Array
+	];
+	var typedArrayTags = [
+		64,
+		68,
+		69,
+		70,
+		71,
+		72,
+		77,
+		78,
+		79,
+		85,
+		86
+	];
+	for (let i = 0; i < typedArrays.length; i++) registerTypedArray(typedArrays[i], typedArrayTags[i]);
+	function registerTypedArray(TypedArray, tag) {
+		let dvMethod = "get" + TypedArray.name.slice(0, -5);
+		let bytesPerElement;
+		if (typeof TypedArray === "function") bytesPerElement = TypedArray.BYTES_PER_ELEMENT;
+		else TypedArray = null;
+		for (let littleEndian = 0; littleEndian < 2; littleEndian++) {
+			if (!littleEndian && bytesPerElement == 1) continue;
+			let sizeShift = bytesPerElement == 2 ? 1 : bytesPerElement == 4 ? 2 : bytesPerElement == 8 ? 3 : 0;
+			currentExtensions[littleEndian ? tag : tag - 4] = bytesPerElement == 1 || littleEndian == isLittleEndianMachine$1 ? (buffer) => {
+				if (!TypedArray) throw new Error("Could not find typed array for code " + tag);
+				if (!currentDecoder.copyBuffers) {
+					if (bytesPerElement === 1 || bytesPerElement === 2 && !(buffer.byteOffset & 1) || bytesPerElement === 4 && !(buffer.byteOffset & 3) || bytesPerElement === 8 && !(buffer.byteOffset & 7)) return new TypedArray(buffer.buffer, buffer.byteOffset, buffer.byteLength >> sizeShift);
+				}
+				return new TypedArray(Uint8Array.prototype.slice.call(buffer, 0).buffer);
+			} : (buffer) => {
+				if (!TypedArray) throw new Error("Could not find typed array for code " + tag);
+				let dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+				let elements = buffer.length >> sizeShift;
+				let ta = new TypedArray(elements);
+				let method = dv[dvMethod];
+				for (let i = 0; i < elements; i++) ta[i] = method.call(dv, i << sizeShift, littleEndian);
+				return ta;
+			};
+		}
+	}
+	function readBundleExt() {
+		let length = readJustLength();
+		let bundlePosition = position$1 + read();
+		for (let i = 2; i < length; i++) {
+			let bundleLength = readJustLength();
+			position$1 += bundleLength;
+		}
+		let dataPosition = position$1;
+		position$1 = bundlePosition;
+		bundledStrings$1 = [readStringJS(readJustLength()), readStringJS(readJustLength())];
+		bundledStrings$1.position0 = 0;
+		bundledStrings$1.position1 = 0;
+		bundledStrings$1.postBundlePosition = position$1;
+		position$1 = dataPosition;
+		return read();
+	}
+	function readJustLength() {
+		if (!(position$1 < srcEnd)) throw endOfCBORError();
+		let token = src[position$1++] & 31;
+		if (token > 23) switch (token) {
+			case 24:
+				if (position$1 >= srcEnd) throw endOfCBORError();
+				token = src[position$1++];
+				break;
+			case 25:
+				token = dataView.getUint16(position$1);
+				position$1 += 2;
+				break;
+			case 26:
+				token = dataView.getUint32(position$1);
+				position$1 += 4;
+				break;
+		}
+		return token;
+	}
+	function loadShared() {
+		if (currentDecoder.getShared) {
+			let sharedData = saveState(() => {
+				src = null;
+				return currentDecoder.getShared();
+			}) || {};
+			let updatedStructures = sharedData.structures || [];
+			currentDecoder.sharedVersion = sharedData.version;
+			packedValues = currentDecoder.sharedValues = sharedData.packedValues;
+			if (currentStructures === true) currentDecoder.structures = currentStructures = updatedStructures;
+			else currentStructures.splice.apply(currentStructures, [0, updatedStructures.length].concat(updatedStructures));
+		}
+	}
+	function saveState(callback) {
+		let savedSrcEnd = srcEnd;
+		let savedPosition = position$1;
+		let savedStringPosition = stringPosition;
+		let savedSrcStringStart = srcStringStart;
+		let savedSrcStringEnd = srcStringEnd;
+		let savedSrcString = srcString;
+		let savedStrings = strings;
+		let savedReferenceMap = referenceMap;
+		let savedBundledStrings = bundledStrings$1;
+		let savedSrc = new Uint8Array(src.slice(0, srcEnd));
+		let savedStructures = currentStructures;
+		let savedDecoder = currentDecoder;
+		let savedSequentialMode = sequentialMode;
+		let value = callback();
+		srcEnd = savedSrcEnd;
+		position$1 = savedPosition;
+		stringPosition = savedStringPosition;
+		srcStringStart = savedSrcStringStart;
+		srcStringEnd = savedSrcStringEnd;
+		srcString = savedSrcString;
+		strings = savedStrings;
+		referenceMap = savedReferenceMap;
+		bundledStrings$1 = savedBundledStrings;
+		src = savedSrc;
+		sequentialMode = savedSequentialMode;
+		currentStructures = savedStructures;
+		currentDecoder = savedDecoder;
+		dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+		return value;
+	}
+	function clearSource() {
+		src = null;
+		referenceMap = null;
+		currentStructures = null;
+	}
+	function addExtension$1(extension) {
+		currentExtensions[extension.tag] = extension.decode;
+	}
+	function setSizeLimits(limits) {
+		if (limits.maxMapSize) maxMapSize = limits.maxMapSize;
+		if (limits.maxArraySize) maxArraySize = limits.maxArraySize;
+		if (limits.maxObjectSize) limits.maxObjectSize;
+	}
+	var mult10 = new Array(147);
+	for (let i = 0; i < 256; i++) mult10[i] = +("1e" + Math.floor(45.15 - i * .30103));
+	var defaultDecoder = new Decoder({ useRecords: false });
+	var decode = defaultDecoder.decode;
+	var decodeMultiple = defaultDecoder.decodeMultiple;
+	var FLOAT32_OPTIONS = {
+		NEVER: 0,
+		ALWAYS: 1,
+		DECIMAL_ROUND: 3,
+		DECIMAL_FIT: 4
+	};
+	function roundFloat32(float32Number) {
+		f32Array[0] = float32Number;
+		let multiplier = mult10[(u8Array[3] & 127) << 1 | u8Array[2] >> 7];
+		return (multiplier * float32Number + (float32Number > 0 ? .5 : -.5) >> 0) / multiplier;
+	}
+	var textEncoder;
+	try {
+		textEncoder = new TextEncoder();
+	} catch (error) {}
+	var extensions, extensionClasses;
+	var Buffer$1 = typeof globalThis === "object" && globalThis.Buffer;
+	var hasNodeBuffer = typeof Buffer$1 !== "undefined";
+	var ByteArrayAllocate = hasNodeBuffer ? Buffer$1.allocUnsafeSlow : Uint8Array;
+	var ByteArray = hasNodeBuffer ? Buffer$1 : Uint8Array;
+	var MAX_STRUCTURES = 256;
+	var MAX_BUFFER_SIZE = hasNodeBuffer ? 4294967296 : 2144337920;
+	var throwOnIterable;
+	var target;
+	var targetView;
+	var position = 0;
+	var safeEnd;
+	var bundledStrings = null;
+	var MAX_BUNDLE_SIZE = 61440;
+	var hasNonLatin = /[\u0080-\uFFFF]/;
+	var RECORD_SYMBOL = Symbol("record-id");
+	var Encoder = class extends Decoder {
+		constructor(options) {
+			super(options);
+			this.offset = 0;
+			let start;
+			let sharedStructures;
+			let hasSharedUpdate;
+			let structures;
+			let referenceMap;
+			options = options || {};
+			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
+				return target.utf8Write(string, position, target.byteLength - position);
+			} : textEncoder && textEncoder.encodeInto ? function(string, position) {
+				return textEncoder.encodeInto(string, target.subarray(position)).written;
+			} : false;
+			let encoder = this;
+			let hasSharedStructures = options.structures || options.saveStructures;
+			let maxSharedStructures = options.maxSharedStructures;
+			if (maxSharedStructures == null) maxSharedStructures = hasSharedStructures ? 128 : 0;
+			if (maxSharedStructures > 8190) throw new Error("Maximum maxSharedStructure is 8190");
+			let isSequential = options.sequential;
+			if (isSequential) maxSharedStructures = 0;
+			if (!this.structures) this.structures = [];
+			if (this.saveStructures) this.saveShared = this.saveStructures;
+			let samplingPackedValues, packedObjectMap, sharedValues = options.sharedValues;
+			let sharedPackedObjectMap;
+			if (sharedValues) {
+				sharedPackedObjectMap = Object.create(null);
+				for (let i = 0, l = sharedValues.length; i < l; i++) sharedPackedObjectMap[sharedValues[i]] = i;
+			}
+			let recordIdsToRemove = [];
+			let transitionsCount = 0;
+			let serializationsSinceTransitionRebuild = 0;
+			this.mapEncode = function(value, encodeOptions) {
+				if (this._keyMap && !this._mapped) switch (value.constructor.name) {
+					case "Array":
+						value = value.map((r) => this.encodeKeys(r));
+						break;
+				}
+				return this.encode(value, encodeOptions);
+			};
+			this.encode = function(value, encodeOptions) {
+				if (!target) {
+					target = new ByteArrayAllocate(8192);
+					targetView = new DataView(target.buffer, 0, 8192);
+					position = 0;
+				}
+				safeEnd = target.length - 10;
+				if (safeEnd - position < 2048) {
+					target = new ByteArrayAllocate(target.length);
+					targetView = new DataView(target.buffer, 0, target.length);
+					safeEnd = target.length - 10;
+					position = 0;
+				} else if (encodeOptions === REUSE_BUFFER_MODE) position = position + 7 & 2147483640;
+				start = position;
+				if (encoder.useSelfDescribedHeader) {
+					targetView.setUint32(position, 3654940416);
+					position += 3;
+				}
+				referenceMap = encoder.structuredClone ? /* @__PURE__ */ new Map() : null;
+				if (encoder.bundleStrings && typeof value !== "string") {
+					bundledStrings = [];
+					bundledStrings.size = Infinity;
+				} else bundledStrings = null;
+				sharedStructures = encoder.structures;
+				if (sharedStructures) {
+					if (sharedStructures.uninitialized) {
+						let sharedData = encoder.getShared() || {};
+						encoder.structures = sharedStructures = sharedData.structures || [];
+						encoder.sharedVersion = sharedData.version;
+						let sharedValues = encoder.sharedValues = sharedData.packedValues;
+						if (sharedValues) {
+							sharedPackedObjectMap = {};
+							for (let i = 0, l = sharedValues.length; i < l; i++) sharedPackedObjectMap[sharedValues[i]] = i;
+						}
+					}
+					let sharedStructuresLength = sharedStructures.length;
+					if (sharedStructuresLength > maxSharedStructures && !isSequential) sharedStructuresLength = maxSharedStructures;
+					if (!sharedStructures.transitions) {
+						sharedStructures.transitions = Object.create(null);
+						for (let i = 0; i < sharedStructuresLength; i++) {
+							let keys = sharedStructures[i];
+							if (!keys) continue;
+							let nextTransition, transition = sharedStructures.transitions;
+							for (let j = 0, l = keys.length; j < l; j++) {
+								if (transition[RECORD_SYMBOL] === void 0) transition[RECORD_SYMBOL] = i;
+								let key = keys[j];
+								nextTransition = transition[key];
+								if (!nextTransition) nextTransition = transition[key] = Object.create(null);
+								transition = nextTransition;
+							}
+							transition[RECORD_SYMBOL] = i | 1048576;
+						}
+					}
+					if (!isSequential) sharedStructures.nextId = sharedStructuresLength;
+				}
+				if (hasSharedUpdate) hasSharedUpdate = false;
+				structures = sharedStructures || [];
+				packedObjectMap = sharedPackedObjectMap;
+				if (options.pack) {
+					let packedValues = /* @__PURE__ */ new Map();
+					packedValues.values = [];
+					packedValues.encoder = encoder;
+					packedValues.maxValues = options.maxPrivatePackedValues || (sharedPackedObjectMap ? 16 : Infinity);
+					packedValues.objectMap = sharedPackedObjectMap || false;
+					packedValues.samplingPackedValues = samplingPackedValues;
+					findRepetitiveStrings(value, packedValues);
+					if (packedValues.values.length > 0) {
+						target[position++] = 216;
+						target[position++] = 51;
+						writeArrayHeader(4);
+						let valuesArray = packedValues.values;
+						encode(valuesArray);
+						writeArrayHeader(0);
+						writeArrayHeader(0);
+						packedObjectMap = Object.create(sharedPackedObjectMap || null);
+						for (let i = 0, l = valuesArray.length; i < l; i++) packedObjectMap[valuesArray[i]] = i;
+					}
+				}
+				throwOnIterable = encodeOptions & THROW_ON_ITERABLE;
+				try {
+					if (throwOnIterable) return;
+					encode(value);
+					if (bundledStrings) writeBundles(start, encode);
+					encoder.offset = position;
+					if (referenceMap && referenceMap.idsToInsert) {
+						position += referenceMap.idsToInsert.length * 2;
+						if (position > safeEnd) makeRoom(position);
+						encoder.offset = position;
+						let serialized = insertIds(target.subarray(start, position), referenceMap.idsToInsert);
+						referenceMap = null;
+						return serialized;
+					}
+					if (encodeOptions & REUSE_BUFFER_MODE) {
+						target.start = start;
+						target.end = position;
+						return target;
+					}
+					return target.subarray(start, position);
+				} finally {
+					if (sharedStructures) {
+						if (serializationsSinceTransitionRebuild < 10) serializationsSinceTransitionRebuild++;
+						if (sharedStructures.length > maxSharedStructures) sharedStructures.length = maxSharedStructures;
+						if (transitionsCount > 1e4) {
+							sharedStructures.transitions = null;
+							serializationsSinceTransitionRebuild = 0;
+							transitionsCount = 0;
+							if (recordIdsToRemove.length > 0) recordIdsToRemove = [];
+						} else if (recordIdsToRemove.length > 0 && !isSequential) {
+							for (let i = 0, l = recordIdsToRemove.length; i < l; i++) recordIdsToRemove[i][RECORD_SYMBOL] = void 0;
+							recordIdsToRemove = [];
+						}
+					}
+					if (hasSharedUpdate && encoder.saveShared) {
+						if (encoder.structures.length > maxSharedStructures) encoder.structures = encoder.structures.slice(0, maxSharedStructures);
+						let returnBuffer = target.subarray(start, position);
+						if (encoder.updateSharedData() === false) return encoder.encode(value);
+						return returnBuffer;
+					}
+					if (encodeOptions & RESET_BUFFER_MODE) position = start;
+				}
+			};
+			this.findCommonStringsToPack = () => {
+				samplingPackedValues = /* @__PURE__ */ new Map();
+				if (!sharedPackedObjectMap) sharedPackedObjectMap = Object.create(null);
+				return (options) => {
+					let threshold = options && options.threshold || 4;
+					let position = this.pack ? options.maxPrivatePackedValues || 16 : 0;
+					if (!sharedValues) sharedValues = this.sharedValues = [];
+					for (let [key, status] of samplingPackedValues) if (status.count > threshold) {
+						sharedPackedObjectMap[key] = position++;
+						sharedValues.push(key);
+						hasSharedUpdate = true;
+					}
+					while (this.saveShared && this.updateSharedData() === false);
+					samplingPackedValues = null;
+				};
+			};
+			const encode = (value) => {
+				if (position > safeEnd) target = makeRoom(position);
+				var type = typeof value;
+				var length;
+				if (type === "string") {
+					if (packedObjectMap) {
+						let packedPosition = packedObjectMap[value];
+						if (packedPosition >= 0) {
+							if (packedPosition < 16) target[position++] = packedPosition + 224;
+							else {
+								target[position++] = 198;
+								if (packedPosition & 1) encode(15 - packedPosition >> 1);
+								else encode(packedPosition - 16 >> 1);
+							}
+							return;
+						} else if (samplingPackedValues && !options.pack) {
+							let status = samplingPackedValues.get(value);
+							if (status) status.count++;
+							else samplingPackedValues.set(value, { count: 1 });
+						}
+					}
+					let strLength = value.length;
+					if (bundledStrings && strLength >= 4 && strLength < 1024) {
+						if ((bundledStrings.size += strLength) > MAX_BUNDLE_SIZE) {
+							let extStart;
+							let maxBytes = (bundledStrings[0] ? bundledStrings[0].length * 3 + bundledStrings[1].length : 0) + 10;
+							if (position + maxBytes > safeEnd) target = makeRoom(position + maxBytes);
+							target[position++] = 217;
+							target[position++] = 223;
+							target[position++] = 249;
+							target[position++] = bundledStrings.position ? 132 : 130;
+							target[position++] = 26;
+							extStart = position - start;
+							position += 4;
+							if (bundledStrings.position) writeBundles(start, encode);
+							bundledStrings = ["", ""];
+							bundledStrings.size = 0;
+							bundledStrings.position = extStart;
+						}
+						let twoByte = hasNonLatin.test(value);
+						bundledStrings[twoByte ? 0 : 1] += value;
+						target[position++] = twoByte ? 206 : 207;
+						encode(strLength);
+						return;
+					}
+					let headerSize;
+					if (strLength < 32) headerSize = 1;
+					else if (strLength < 256) headerSize = 2;
+					else if (strLength < 65536) headerSize = 3;
+					else headerSize = 5;
+					let maxBytes = strLength * 3;
+					if (position + maxBytes > safeEnd) target = makeRoom(position + maxBytes);
+					if (strLength < 64 || !encodeUtf8) {
+						let i, c1, c2, strPosition = position + headerSize;
+						for (i = 0; i < strLength; i++) {
+							c1 = value.charCodeAt(i);
+							if (c1 < 128) target[strPosition++] = c1;
+							else if (c1 < 2048) {
+								target[strPosition++] = c1 >> 6 | 192;
+								target[strPosition++] = c1 & 63 | 128;
+							} else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
+								c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+								i++;
+								target[strPosition++] = c1 >> 18 | 240;
+								target[strPosition++] = c1 >> 12 & 63 | 128;
+								target[strPosition++] = c1 >> 6 & 63 | 128;
+								target[strPosition++] = c1 & 63 | 128;
+							} else {
+								target[strPosition++] = c1 >> 12 | 224;
+								target[strPosition++] = c1 >> 6 & 63 | 128;
+								target[strPosition++] = c1 & 63 | 128;
+							}
+						}
+						length = strPosition - position - headerSize;
+					} else length = encodeUtf8(value, position + headerSize, maxBytes);
+					if (length < 24) target[position++] = 96 | length;
+					else if (length < 256) {
+						if (headerSize < 2) target.copyWithin(position + 2, position + 1, position + 1 + length);
+						target[position++] = 120;
+						target[position++] = length;
+					} else if (length < 65536) {
+						if (headerSize < 3) target.copyWithin(position + 3, position + 2, position + 2 + length);
+						target[position++] = 121;
+						target[position++] = length >> 8;
+						target[position++] = length & 255;
+					} else {
+						if (headerSize < 5) target.copyWithin(position + 5, position + 3, position + 3 + length);
+						target[position++] = 122;
+						targetView.setUint32(position, length);
+						position += 4;
+					}
+					position += length;
+				} else if (type === "number") if (!this.alwaysUseFloat && value >>> 0 === value) if (value < 24) target[position++] = value;
+				else if (value < 256) {
+					target[position++] = 24;
+					target[position++] = value;
+				} else if (value < 65536) {
+					target[position++] = 25;
+					target[position++] = value >> 8;
+					target[position++] = value & 255;
+				} else {
+					target[position++] = 26;
+					targetView.setUint32(position, value);
+					position += 4;
+				}
+				else if (!this.alwaysUseFloat && value >> 0 === value) if (value >= -24) target[position++] = 31 - value;
+				else if (value >= -256) {
+					target[position++] = 56;
+					target[position++] = ~value;
+				} else if (value >= -65536) {
+					target[position++] = 57;
+					targetView.setUint16(position, ~value);
+					position += 2;
+				} else {
+					target[position++] = 58;
+					targetView.setUint32(position, ~value);
+					position += 4;
+				}
+				else if (!this.alwaysUseFloat && value < 0 && value >= -4294967296 && Math.floor(value) === value) {
+					target[position++] = 58;
+					targetView.setUint32(position, -1 - value);
+					position += 4;
+				} else {
+					let useFloat32;
+					if ((useFloat32 = this.useFloat32) > 0 && value < 4294967296 && value >= -2147483648) {
+						target[position++] = 250;
+						targetView.setFloat32(position, value);
+						let xShifted;
+						if (useFloat32 < 4 || (xShifted = value * mult10[(target[position] & 127) << 1 | target[position + 1] >> 7]) >> 0 === xShifted) {
+							position += 4;
+							return;
+						} else position--;
+					}
+					target[position++] = 251;
+					targetView.setFloat64(position, value);
+					position += 8;
+				}
+				else if (type === "object") if (!value) target[position++] = 246;
+				else {
+					if (referenceMap) {
+						let referee = referenceMap.get(value);
+						if (referee) {
+							target[position++] = 216;
+							target[position++] = 29;
+							target[position++] = 25;
+							if (!referee.references) {
+								let idsToInsert = referenceMap.idsToInsert || (referenceMap.idsToInsert = []);
+								referee.references = [];
+								idsToInsert.push(referee);
+							}
+							referee.references.push(position - start);
+							position += 2;
+							return;
+						} else referenceMap.set(value, { offset: position - start });
+					}
+					let constructor = value.constructor;
+					if (constructor === Object) {
+						if (this.skipFunction === true) value = Object.fromEntries([...Object.keys(value).filter((x) => typeof value[x] !== "function").map((x) => [x, value[x]])]);
+						writeObject(value);
+					} else if (constructor === Array) {
+						length = value.length;
+						if (length < 24) target[position++] = 128 | length;
+						else writeArrayHeader(length);
+						for (let i = 0; i < length; i++) encode(value[i]);
+					} else if (constructor === Map) {
+						if (this.mapsAsObjects ? this.useTag259ForMaps !== false : this.useTag259ForMaps) {
+							target[position++] = 217;
+							target[position++] = 1;
+							target[position++] = 3;
+						}
+						length = value.size;
+						if (length < 24) target[position++] = 160 | length;
+						else if (length < 256) {
+							target[position++] = 184;
+							target[position++] = length;
+						} else if (length < 65536) {
+							target[position++] = 185;
+							target[position++] = length >> 8;
+							target[position++] = length & 255;
+						} else {
+							target[position++] = 186;
+							targetView.setUint32(position, length);
+							position += 4;
+						}
+						if (encoder.keyMap) for (let [key, entryValue] of value) {
+							encode(encoder.encodeKey(key));
+							encode(entryValue);
+						}
+						else for (let [key, entryValue] of value) {
+							encode(key);
+							encode(entryValue);
+						}
+					} else {
+						for (let i = 0, l = extensions.length; i < l; i++) {
+							let extensionClass = extensionClasses[i];
+							if (value instanceof extensionClass) {
+								let extension = extensions[i];
+								let tag = extension.tag;
+								if (tag == void 0) tag = extension.getTag && extension.getTag.call(this, value);
+								if (tag < 24) target[position++] = 192 | tag;
+								else if (tag < 256) {
+									target[position++] = 216;
+									target[position++] = tag;
+								} else if (tag < 65536) {
+									target[position++] = 217;
+									target[position++] = tag >> 8;
+									target[position++] = tag & 255;
+								} else if (tag > -1) {
+									target[position++] = 218;
+									targetView.setUint32(position, tag);
+									position += 4;
+								}
+								extension.encode.call(this, value, encode, makeRoom);
+								return;
+							}
+						}
+						if (value[Symbol.iterator]) {
+							if (throwOnIterable) {
+								let error = /* @__PURE__ */ new Error("Iterable should be serialized as iterator");
+								error.iteratorNotHandled = true;
+								throw error;
+							}
+							target[position++] = 159;
+							for (let entry of value) encode(entry);
+							target[position++] = 255;
+							return;
+						}
+						if (value[Symbol.asyncIterator] || isBlob(value)) {
+							let error = /* @__PURE__ */ new Error("Iterable/blob should be serialized as iterator");
+							error.iteratorNotHandled = true;
+							throw error;
+						}
+						if (this.useToJSON && value.toJSON) {
+							const json = value.toJSON();
+							if (json !== value) return encode(json);
+						}
+						writeObject(value);
+					}
+				}
+				else if (type === "boolean") target[position++] = value ? 245 : 244;
+				else if (type === "bigint") {
+					if (value < BigInt(1) << BigInt(64) && value >= 0) {
+						target[position++] = 27;
+						targetView.setBigUint64(position, value);
+					} else if (value > -(BigInt(1) << BigInt(64)) && value < 0) {
+						target[position++] = 59;
+						targetView.setBigUint64(position, -value - BigInt(1));
+					} else if (this.largeBigIntToFloat) {
+						target[position++] = 251;
+						targetView.setFloat64(position, Number(value));
+					} else {
+						if (value >= BigInt(0)) target[position++] = 194;
+						else {
+							target[position++] = 195;
+							value = BigInt(-1) - value;
+						}
+						let bytes = [];
+						while (value) {
+							bytes.push(Number(value & BigInt(255)));
+							value >>= BigInt(8);
+						}
+						writeBuffer(new Uint8Array(bytes.reverse()), makeRoom);
+						return;
+					}
+					position += 8;
+				} else if (type === "undefined") target[position++] = 247;
+				else throw new Error("Unknown type: " + type);
+			};
+			const writeObject = this.useRecords === false ? this.variableMapSize ? (object) => {
+				let keys = Object.keys(object);
+				let vals = Object.values(object);
+				let length = keys.length;
+				if (length < 24) target[position++] = 160 | length;
+				else if (length < 256) {
+					target[position++] = 184;
+					target[position++] = length;
+				} else if (length < 65536) {
+					target[position++] = 185;
+					target[position++] = length >> 8;
+					target[position++] = length & 255;
+				} else {
+					target[position++] = 186;
+					targetView.setUint32(position, length);
+					position += 4;
+				}
+				if (encoder.keyMap) for (let i = 0; i < length; i++) {
+					encode(encoder.encodeKey(keys[i]));
+					encode(vals[i]);
+				}
+				else for (let i = 0; i < length; i++) {
+					encode(keys[i]);
+					encode(vals[i]);
+				}
+			} : (object) => {
+				target[position++] = 185;
+				let objectOffset = position - start;
+				position += 2;
+				let size = 0;
+				if (encoder.keyMap) {
+					for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+						encode(encoder.encodeKey(key));
+						encode(object[key]);
+						size++;
+					}
+				} else for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+					encode(key);
+					encode(object[key]);
+					size++;
+				}
+				target[objectOffset++ + start] = size >> 8;
+				target[objectOffset + start] = size & 255;
+			} : (object, skipValues) => {
+				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+				let newTransitions = 0;
+				let length = 0;
+				let parentRecordId;
+				let keys;
+				if (this.keyMap) {
+					keys = Object.keys(object).map((k) => this.encodeKey(k));
+					length = keys.length;
+					for (let i = 0; i < length; i++) {
+						let key = keys[i];
+						nextTransition = transition[key];
+						if (!nextTransition) {
+							nextTransition = transition[key] = Object.create(null);
+							newTransitions++;
+						}
+						transition = nextTransition;
+					}
+				} else for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+					nextTransition = transition[key];
+					if (!nextTransition) {
+						if (transition[RECORD_SYMBOL] & 1048576) parentRecordId = transition[RECORD_SYMBOL] & 65535;
+						nextTransition = transition[key] = Object.create(null);
+						newTransitions++;
+					}
+					transition = nextTransition;
+					length++;
+				}
+				let recordId = transition[RECORD_SYMBOL];
+				if (recordId !== void 0) {
+					recordId &= 65535;
+					target[position++] = 217;
+					target[position++] = recordId >> 8 | 224;
+					target[position++] = recordId & 255;
+				} else {
+					if (!keys) keys = transition.__keys__ || (transition.__keys__ = Object.keys(object));
+					if (parentRecordId === void 0) {
+						recordId = structures.nextId++;
+						if (!recordId) {
+							recordId = 0;
+							structures.nextId = 1;
+						}
+						if (recordId >= MAX_STRUCTURES) structures.nextId = (recordId = maxSharedStructures) + 1;
+					} else recordId = parentRecordId;
+					structures[recordId] = keys;
+					if (recordId < maxSharedStructures) {
+						target[position++] = 217;
+						target[position++] = recordId >> 8 | 224;
+						target[position++] = recordId & 255;
+						transition = structures.transitions;
+						for (let i = 0; i < length; i++) {
+							if (transition[RECORD_SYMBOL] === void 0 || transition[RECORD_SYMBOL] & 1048576) transition[RECORD_SYMBOL] = recordId;
+							transition = transition[keys[i]];
+						}
+						transition[RECORD_SYMBOL] = recordId | 1048576;
+						hasSharedUpdate = true;
+					} else {
+						transition[RECORD_SYMBOL] = recordId;
+						targetView.setUint32(position, 3655335680);
+						position += 3;
+						if (newTransitions) transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
+						if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures) recordIdsToRemove.shift()[RECORD_SYMBOL] = void 0;
+						recordIdsToRemove.push(transition);
+						writeArrayHeader(length + 2);
+						encode(57344 + recordId);
+						encode(keys);
+						if (skipValues) return;
+						for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) encode(object[key]);
+						return;
+					}
+				}
+				if (length < 24) target[position++] = 128 | length;
+				else writeArrayHeader(length);
+				if (skipValues) return;
+				for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) encode(object[key]);
+			};
+			const makeRoom = (end) => {
+				let newSize;
+				if (end > 16777216) {
+					if (end - start > MAX_BUFFER_SIZE) throw new Error("Encoded buffer would be larger than maximum buffer size");
+					newSize = Math.min(MAX_BUFFER_SIZE, Math.round(Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096) * 4096);
+				} else newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
+				let newBuffer = new ByteArrayAllocate(newSize);
+				targetView = new DataView(newBuffer.buffer, 0, newSize);
+				if (target.copy) target.copy(newBuffer, 0, start, end);
+				else newBuffer.set(target.slice(start, end));
+				position -= start;
+				start = 0;
+				safeEnd = newBuffer.length - 10;
+				return target = newBuffer;
+			};
+			let chunkThreshold = 100;
+			let continuedChunkThreshold = 1e3;
+			this.encodeAsIterable = function(value, options) {
+				return startEncoding(value, options, encodeObjectAsIterable);
+			};
+			this.encodeAsAsyncIterable = function(value, options) {
+				return startEncoding(value, options, encodeObjectAsAsyncIterable);
+			};
+			function* encodeObjectAsIterable(object, iterateProperties, finalIterable) {
+				let constructor = object.constructor;
+				if (constructor === Object) {
+					let useRecords = encoder.useRecords !== false;
+					if (useRecords) writeObject(object, true);
+					else writeEntityLength(Object.keys(object).length, 160);
+					for (let key in object) {
+						let value = object[key];
+						if (!useRecords) encode(key);
+						if (value && typeof value === "object") if (iterateProperties[key]) yield* encodeObjectAsIterable(value, iterateProperties[key]);
+						else yield* tryEncode(value, iterateProperties, key);
+						else encode(value);
+					}
+				} else if (constructor === Array) {
+					let length = object.length;
+					writeArrayHeader(length);
+					for (let i = 0; i < length; i++) {
+						let value = object[i];
+						if (value && (typeof value === "object" || position - start > chunkThreshold)) if (iterateProperties.element) yield* encodeObjectAsIterable(value, iterateProperties.element);
+						else yield* tryEncode(value, iterateProperties, "element");
+						else encode(value);
+					}
+				} else if (object[Symbol.iterator] && !object.buffer) {
+					target[position++] = 159;
+					for (let value of object) if (value && (typeof value === "object" || position - start > chunkThreshold)) if (iterateProperties.element) yield* encodeObjectAsIterable(value, iterateProperties.element);
+					else yield* tryEncode(value, iterateProperties, "element");
+					else encode(value);
+					target[position++] = 255;
+				} else if (isBlob(object)) {
+					writeEntityLength(object.size, 64);
+					yield target.subarray(start, position);
+					yield object;
+					restartEncoding();
+				} else if (object[Symbol.asyncIterator]) {
+					target[position++] = 159;
+					yield target.subarray(start, position);
+					yield object;
+					restartEncoding();
+					target[position++] = 255;
+				} else encode(object);
+				if (finalIterable && position > start) yield target.subarray(start, position);
+				else if (position - start > chunkThreshold) {
+					yield target.subarray(start, position);
+					restartEncoding();
+				}
+			}
+			function* tryEncode(value, iterateProperties, key) {
+				let restart = position - start;
+				try {
+					encode(value);
+					if (position - start > chunkThreshold) {
+						yield target.subarray(start, position);
+						restartEncoding();
+					}
+				} catch (error) {
+					if (error.iteratorNotHandled) {
+						iterateProperties[key] = {};
+						position = start + restart;
+						yield* encodeObjectAsIterable.call(this, value, iterateProperties[key]);
+					} else throw error;
+				}
+			}
+			function restartEncoding() {
+				chunkThreshold = continuedChunkThreshold;
+				encoder.encode(null, THROW_ON_ITERABLE);
+			}
+			function startEncoding(value, options, encodeIterable) {
+				if (options && options.chunkThreshold) chunkThreshold = continuedChunkThreshold = options.chunkThreshold;
+				else chunkThreshold = 100;
+				if (value && typeof value === "object") {
+					encoder.encode(null, THROW_ON_ITERABLE);
+					return encodeIterable(value, encoder.iterateProperties || (encoder.iterateProperties = {}), true);
+				}
+				return [encoder.encode(value)];
+			}
+			async function* encodeObjectAsAsyncIterable(value, iterateProperties) {
+				for (let encodedValue of encodeObjectAsIterable(value, iterateProperties, true)) {
+					let constructor = encodedValue.constructor;
+					if (constructor === ByteArray || constructor === Uint8Array) yield encodedValue;
+					else if (isBlob(encodedValue)) {
+						let reader = encodedValue.stream().getReader();
+						let next;
+						while (!(next = await reader.read()).done) yield next.value;
+					} else if (encodedValue[Symbol.asyncIterator]) for await (let asyncValue of encodedValue) {
+						restartEncoding();
+						if (asyncValue) yield* encodeObjectAsAsyncIterable(asyncValue, iterateProperties.async || (iterateProperties.async = {}));
+						else yield encoder.encode(asyncValue);
+					}
+					else yield encodedValue;
+				}
+			}
+		}
+		useBuffer(buffer) {
+			target = buffer;
+			targetView = new DataView(target.buffer, target.byteOffset, target.byteLength);
+			position = 0;
+		}
+		clearSharedData() {
+			if (this.structures) this.structures = [];
+			if (this.sharedValues) this.sharedValues = void 0;
+		}
+		updateSharedData() {
+			let lastVersion = this.sharedVersion || 0;
+			this.sharedVersion = lastVersion + 1;
+			let structuresCopy = this.structures.slice(0);
+			let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion);
+			let saveResults = this.saveShared(sharedData, (existingShared) => (existingShared && existingShared.version || 0) == lastVersion);
+			if (saveResults === false) {
+				sharedData = this.getShared() || {};
+				this.structures = sharedData.structures || [];
+				this.sharedValues = sharedData.packedValues;
+				this.sharedVersion = sharedData.version;
+				this.structures.nextId = this.structures.length;
+			} else structuresCopy.forEach((structure, i) => this.structures[i] = structure);
+			return saveResults;
+		}
+	};
+	function writeEntityLength(length, majorValue) {
+		if (length < 24) target[position++] = majorValue | length;
+		else if (length < 256) {
+			target[position++] = majorValue | 24;
+			target[position++] = length;
+		} else if (length < 65536) {
+			target[position++] = majorValue | 25;
+			target[position++] = length >> 8;
+			target[position++] = length & 255;
+		} else {
+			target[position++] = majorValue | 26;
+			targetView.setUint32(position, length);
+			position += 4;
+		}
+	}
+	var SharedData = class {
+		constructor(structures, values, version) {
+			this.structures = structures;
+			this.packedValues = values;
+			this.version = version;
+		}
+	};
+	function writeArrayHeader(length) {
+		if (length < 24) target[position++] = 128 | length;
+		else if (length < 256) {
+			target[position++] = 152;
+			target[position++] = length;
+		} else if (length < 65536) {
+			target[position++] = 153;
+			target[position++] = length >> 8;
+			target[position++] = length & 255;
+		} else {
+			target[position++] = 154;
+			targetView.setUint32(position, length);
+			position += 4;
+		}
+	}
+	var BlobConstructor = typeof Blob === "undefined" ? function() {} : Blob;
+	function isBlob(object) {
+		if (object instanceof BlobConstructor) return true;
+		let tag = object[Symbol.toStringTag];
+		return tag === "Blob" || tag === "File";
+	}
+	function findRepetitiveStrings(value, packedValues) {
+		switch (typeof value) {
+			case "string":
+				if (value.length > 3) {
+					if (packedValues.objectMap[value] > -1 || packedValues.values.length >= packedValues.maxValues) return;
+					let packedStatus = packedValues.get(value);
+					if (packedStatus) {
+						if (++packedStatus.count == 2) packedValues.values.push(value);
+					} else {
+						packedValues.set(value, { count: 1 });
+						if (packedValues.samplingPackedValues) {
+							let status = packedValues.samplingPackedValues.get(value);
+							if (status) status.count++;
+							else packedValues.samplingPackedValues.set(value, { count: 1 });
+						}
+					}
+				}
+				break;
+			case "object":
+				if (value) if (value instanceof Array) for (let i = 0, l = value.length; i < l; i++) findRepetitiveStrings(value[i], packedValues);
+				else {
+					let includeKeys = !packedValues.encoder.useRecords;
+					for (var key in value) if (value.hasOwnProperty(key)) {
+						if (includeKeys) findRepetitiveStrings(key, packedValues);
+						findRepetitiveStrings(value[key], packedValues);
+					}
+				}
+				break;
+			case "function": console.log(value);
+		}
+	}
+	var isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+	extensionClasses = [
+		Date,
+		Set,
+		Error,
+		RegExp,
+		Tag,
+		ArrayBuffer,
+		Uint8Array,
+		Uint8ClampedArray,
+		Uint16Array,
+		Uint32Array,
+		typeof BigUint64Array == "undefined" ? function() {} : BigUint64Array,
+		Int8Array,
+		Int16Array,
+		Int32Array,
+		typeof BigInt64Array == "undefined" ? function() {} : BigInt64Array,
+		Float32Array,
+		Float64Array,
+		SharedData
+	];
+	extensions = [
+		{
+			tag: 1,
+			encode(date, encode) {
+				let seconds = date.getTime() / 1e3;
+				if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 4294967296) {
+					target[position++] = 26;
+					targetView.setUint32(position, seconds);
+					position += 4;
+				} else {
+					target[position++] = 251;
+					targetView.setFloat64(position, seconds);
+					position += 8;
+				}
+			}
+		},
+		{
+			tag: 258,
+			encode(set, encode) {
+				encode(Array.from(set));
+			}
+		},
+		{
+			tag: 27,
+			encode(error, encode) {
+				encode([error.name, error.message]);
+			}
+		},
+		{
+			tag: 27,
+			encode(regex, encode) {
+				encode([
+					"RegExp",
+					regex.source,
+					regex.flags
+				]);
+			}
+		},
+		{
+			getTag(tag) {
+				return tag.tag;
+			},
+			encode(tag, encode) {
+				encode(tag.value);
+			}
+		},
+		{ encode(arrayBuffer, encode, makeRoom) {
+			writeBuffer(arrayBuffer, makeRoom);
+		} },
+		{
+			getTag(typedArray) {
+				if (typedArray.constructor === Uint8Array) {
+					if (this.tagUint8Array || hasNodeBuffer && this.tagUint8Array !== false) return 64;
+				}
+			},
+			encode(typedArray, encode, makeRoom) {
+				writeBuffer(typedArray, makeRoom);
+			}
+		},
+		typedArrayEncoder(68, 1),
+		typedArrayEncoder(69, 2),
+		typedArrayEncoder(70, 4),
+		typedArrayEncoder(71, 8),
+		typedArrayEncoder(72, 1),
+		typedArrayEncoder(77, 2),
+		typedArrayEncoder(78, 4),
+		typedArrayEncoder(79, 8),
+		typedArrayEncoder(85, 4),
+		typedArrayEncoder(86, 8),
+		{ encode(sharedData, encode) {
+			let packedValues = sharedData.packedValues || [];
+			let sharedStructures = sharedData.structures || [];
+			if (packedValues.values.length > 0) {
+				target[position++] = 216;
+				target[position++] = 51;
+				writeArrayHeader(4);
+				let valuesArray = packedValues.values;
+				encode(valuesArray);
+				writeArrayHeader(0);
+				writeArrayHeader(0);
+				packedObjectMap = Object.create(sharedPackedObjectMap || null);
+				for (let i = 0, l = valuesArray.length; i < l; i++) packedObjectMap[valuesArray[i]] = i;
+			}
+			if (sharedStructures) {
+				targetView.setUint32(position, 3655335424);
+				position += 3;
+				let definitions = sharedStructures.slice(0);
+				definitions.unshift(57344);
+				definitions.push(new Tag(sharedData.version, 1399353956));
+				encode(definitions);
+			} else encode(new Tag(sharedData.version, 1399353956));
+		} }
+	];
+	function typedArrayEncoder(tag, size) {
+		if (!isLittleEndianMachine && size > 1) tag -= 4;
+		return {
+			tag,
+			encode: function writeExtBuffer(typedArray, encode) {
+				let length = typedArray.byteLength;
+				let offset = typedArray.byteOffset || 0;
+				let buffer = typedArray.buffer || typedArray;
+				encode(hasNodeBuffer ? Buffer$1.from(buffer, offset, length) : new Uint8Array(buffer, offset, length));
+			}
+		};
+	}
+	function writeBuffer(buffer, makeRoom) {
+		let length = buffer.byteLength;
+		if (length < 24) target[position++] = 64 + length;
+		else if (length < 256) {
+			target[position++] = 88;
+			target[position++] = length;
+		} else if (length < 65536) {
+			target[position++] = 89;
+			target[position++] = length >> 8;
+			target[position++] = length & 255;
+		} else {
+			target[position++] = 90;
+			targetView.setUint32(position, length);
+			position += 4;
+		}
+		if (position + length >= target.length) makeRoom(position + length);
+		target.set(buffer.buffer ? buffer : new Uint8Array(buffer), position);
+		position += length;
+	}
+	function insertIds(serialized, idsToInsert) {
+		let nextId;
+		let distanceToMove = idsToInsert.length * 2;
+		let lastEnd = serialized.length - distanceToMove;
+		idsToInsert.sort((a, b) => a.offset > b.offset ? 1 : -1);
+		for (let id = 0; id < idsToInsert.length; id++) {
+			let referee = idsToInsert[id];
+			referee.id = id;
+			for (let position of referee.references) {
+				serialized[position++] = id >> 8;
+				serialized[position] = id & 255;
+			}
+		}
+		while (nextId = idsToInsert.pop()) {
+			let offset = nextId.offset;
+			serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
+			distanceToMove -= 2;
+			let position = offset + distanceToMove;
+			serialized[position++] = 216;
+			serialized[position++] = 28;
+			lastEnd = offset;
+		}
+		return serialized;
+	}
+	function writeBundles(start, encode) {
+		targetView.setUint32(bundledStrings.position + start, position - bundledStrings.position - start + 1);
+		let writeStrings = bundledStrings;
+		bundledStrings = null;
+		encode(writeStrings[0]);
+		encode(writeStrings[1]);
+	}
+	function addExtension(extension) {
+		if (extension.Class) {
+			if (!extension.encode) throw new Error("Extension has no encode function");
+			extensionClasses.unshift(extension.Class);
+			extensions.unshift(extension);
+		}
+		addExtension$1(extension);
+	}
+	var defaultEncoder = new Encoder({ useRecords: false });
+	var encode = defaultEncoder.encode;
+	var encodeAsIterable = defaultEncoder.encodeAsIterable;
+	var encodeAsAsyncIterable = defaultEncoder.encodeAsAsyncIterable;
+	var { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
+	var REUSE_BUFFER_MODE = 512;
+	var RESET_BUFFER_MODE = 1024;
+	var THROW_ON_ITERABLE = 2048;
+	var EncoderStream = class extends stream$1.Transform {
+		constructor(options) {
+			if (!options) options = {};
+			options.writableObjectMode = true;
+			super(options);
+			options.sequential = true;
+			this.encoder = options.encoder || new Encoder(options);
+		}
+		async _transform(value, encoding, callback) {
+			try {
+				for await (let chunk of this.encoder.encodeAsAsyncIterable(value)) this.push(chunk);
+				callback();
+			} catch (error) {
+				callback(error);
+			}
+		}
+	};
+	var DecoderStream = class extends stream$1.Transform {
+		constructor(options) {
+			if (!options) options = {};
+			options.objectMode = true;
+			super(options);
+			options.structures = [];
+			this.decoder = options.decoder || new Decoder(options);
+		}
+		_transform(chunk, encoding, callback) {
+			if (this.incompleteBuffer) {
+				chunk = Buffer.concat([this.incompleteBuffer, chunk]);
+				this.incompleteBuffer = null;
+			}
+			let values;
+			try {
+				values = this.decoder.decodeMultiple(chunk);
+			} catch (error) {
+				if (error.incomplete) {
+					this.incompleteBuffer = chunk.slice(error.lastPosition);
+					values = error.values;
+				} else return callback(error);
+			} finally {
+				for (let value of values || []) {
+					if (value === null) value = this.getNullValue();
+					this.push(value);
+				}
+			}
+			callback();
+		}
+		getNullValue() {
+			return Symbol.for(null);
+		}
+	};
+	/**
+	* Given an Iterable first argument, returns an Iterable where each value is encoded as a Buffer
+	* If the argument is only Async Iterable, the return value will be an Async Iterable.
+	* @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
+	* @param {options} [options] - cbor-x Encoder options
+	* @returns {IterableIterator|Promise.<AsyncIterableIterator>}
+	*/
+	function encodeIter(objectIterator, options = {}) {
+		if (!objectIterator || typeof objectIterator !== "object") throw new Error("first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable");
+		else if (typeof objectIterator[Symbol.iterator] === "function") return encodeIterSync(objectIterator, options);
+		else if (typeof objectIterator.then === "function" || typeof objectIterator[Symbol.asyncIterator] === "function") return encodeIterAsync(objectIterator, options);
+		else throw new Error("first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise");
+	}
+	function* encodeIterSync(objectIterator, options) {
+		const encoder = new Encoder(options);
+		for (const value of objectIterator) yield encoder.encode(value);
+	}
+	async function* encodeIterAsync(objectIterator, options) {
+		const encoder = new Encoder(options);
+		for await (const value of objectIterator) yield encoder.encode(value);
+	}
+	/**
+	* Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
+	* Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
+	* @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
+	* @param {object} [options] - Decoder options
+	* @returns {IterableIterator|Promise.<AsyncIterableIterator}
+	*/
+	function decodeIter(bufferIterator, options = {}) {
+		if (!bufferIterator || typeof bufferIterator !== "object") throw new Error("first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise");
+		const decoder = new Decoder(options);
+		let incomplete;
+		const parser = (chunk) => {
+			let yields;
+			if (incomplete) {
+				chunk = Buffer.concat([incomplete, chunk]);
+				incomplete = void 0;
+			}
+			try {
+				yields = decoder.decodeMultiple(chunk);
+			} catch (err) {
+				if (err.incomplete) {
+					incomplete = chunk.slice(err.lastPosition);
+					yields = err.values;
+				} else throw err;
+			}
+			return yields;
+		};
+		if (typeof bufferIterator[Symbol.iterator] === "function") return (function* iter() {
+			for (const value of bufferIterator) yield* parser(value);
+		})();
+		else if (typeof bufferIterator[Symbol.asyncIterator] === "function") return (async function* iter() {
+			for await (const value of bufferIterator) yield* parser(value);
+		})();
+	}
+	var useRecords = false;
+	var mapsAsObjects = true;
+	if (!(process.env.CBOR_NATIVE_ACCELERATION_DISABLED !== void 0 && process.env.CBOR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === "true")) {
+		let extractor;
+		try {
+			if (typeof require == "function") extractor = require_cbor_extract();
+			else extractor = module$1$1.createRequire(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("node.cjs", document.baseURI).href)("cbor-extract");
+			if (extractor) setExtractor(extractor.extractStrings);
+		} catch (error) {}
+	}
+	exports.ALWAYS = ALWAYS;
+	exports.DECIMAL_FIT = DECIMAL_FIT;
+	exports.DECIMAL_ROUND = DECIMAL_ROUND;
+	exports.Decoder = Decoder;
+	exports.DecoderStream = DecoderStream;
+	exports.Encoder = Encoder;
+	exports.EncoderStream = EncoderStream;
+	exports.FLOAT32_OPTIONS = FLOAT32_OPTIONS;
+	exports.NEVER = NEVER;
+	exports.REUSE_BUFFER_MODE = REUSE_BUFFER_MODE;
+	exports.Tag = Tag;
+	exports.addExtension = addExtension;
+	exports.clearSource = clearSource;
+	exports.decode = decode;
+	exports.decodeIter = decodeIter;
+	exports.decodeMultiple = decodeMultiple;
+	exports.encode = encode;
+	exports.encodeAsAsyncIterable = encodeAsAsyncIterable;
+	exports.encodeAsIterable = encodeAsIterable;
+	exports.encodeIter = encodeIter;
+	exports.mapsAsObjects = mapsAsObjects;
+	exports.roundFloat32 = roundFloat32;
+	exports.setSizeLimits = setSizeLimits;
+	exports.useRecords = useRecords;
 }));
 //#endregion
 //#region ../../node_modules/moleculer/src/serializers/cbor.js
@@ -40746,7 +43355,7 @@ var require_cbor = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module
 		init(broker) {
 			super.init(broker);
 			try {
-				const Cbor = (init___vite_optional_peer_dep_cbor_x_moleculer(), require_chunk.__toCommonJS(__vite_optional_peer_dep_cbor_x_moleculer_exports));
+				const Cbor = require_node$2();
 				this.encoder = new Cbor.Encoder(this.opts);
 			} catch (err) {
 				/* istanbul ignore next */
@@ -46334,13 +48943,13 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 		module.exports = patch(fs$15);
 		fs$15.__patched = true;
 	}
-	function patch(fs$23) {
-		polyfills(fs$23);
-		fs$23.gracefulify = patch;
-		fs$23.createReadStream = createReadStream;
-		fs$23.createWriteStream = createWriteStream;
-		var fs$readFile = fs$23.readFile;
-		fs$23.readFile = readFile;
+	function patch(fs$25) {
+		polyfills(fs$25);
+		fs$25.gracefulify = patch;
+		fs$25.createReadStream = createReadStream;
+		fs$25.createWriteStream = createWriteStream;
+		var fs$readFile = fs$25.readFile;
+		fs$25.readFile = readFile;
 		function readFile(path, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
 			return go$readFile(path, options, cb);
@@ -46361,8 +48970,8 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 				});
 			}
 		}
-		var fs$writeFile = fs$23.writeFile;
-		fs$23.writeFile = writeFile;
+		var fs$writeFile = fs$25.writeFile;
+		fs$25.writeFile = writeFile;
 		function writeFile(path, data, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
 			return go$writeFile(path, data, options, cb);
@@ -46384,8 +48993,8 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 				});
 			}
 		}
-		var fs$appendFile = fs$23.appendFile;
-		if (fs$appendFile) fs$23.appendFile = appendFile;
+		var fs$appendFile = fs$25.appendFile;
+		if (fs$appendFile) fs$25.appendFile = appendFile;
 		function appendFile(path, data, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
 			return go$appendFile(path, data, options, cb);
@@ -46407,8 +49016,8 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 				});
 			}
 		}
-		var fs$copyFile = fs$23.copyFile;
-		if (fs$copyFile) fs$23.copyFile = copyFile;
+		var fs$copyFile = fs$25.copyFile;
+		if (fs$copyFile) fs$25.copyFile = copyFile;
 		function copyFile(src, dest, flags, cb) {
 			if (typeof flags === "function") {
 				cb = flags;
@@ -46433,8 +49042,8 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 				});
 			}
 		}
-		var fs$readdir = fs$23.readdir;
-		fs$23.readdir = readdir;
+		var fs$readdir = fs$25.readdir;
+		fs$25.readdir = readdir;
 		var noReaddirOptionVersions = /^v[0-5]\./;
 		function readdir(path, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
@@ -46465,21 +49074,21 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			}
 		}
 		if (process.version.substr(0, 4) === "v0.8") {
-			var legStreams = legacy(fs$23);
+			var legStreams = legacy(fs$25);
 			ReadStream = legStreams.ReadStream;
 			WriteStream = legStreams.WriteStream;
 		}
-		var fs$ReadStream = fs$23.ReadStream;
+		var fs$ReadStream = fs$25.ReadStream;
 		if (fs$ReadStream) {
 			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
 			ReadStream.prototype.open = ReadStream$open;
 		}
-		var fs$WriteStream = fs$23.WriteStream;
+		var fs$WriteStream = fs$25.WriteStream;
 		if (fs$WriteStream) {
 			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
 			WriteStream.prototype.open = WriteStream$open;
 		}
-		Object.defineProperty(fs$23, "ReadStream", {
+		Object.defineProperty(fs$25, "ReadStream", {
 			get: function() {
 				return ReadStream;
 			},
@@ -46489,7 +49098,7 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			enumerable: true,
 			configurable: true
 		});
-		Object.defineProperty(fs$23, "WriteStream", {
+		Object.defineProperty(fs$25, "WriteStream", {
 			get: function() {
 				return WriteStream;
 			},
@@ -46500,7 +49109,7 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			configurable: true
 		});
 		var FileReadStream = ReadStream;
-		Object.defineProperty(fs$23, "FileReadStream", {
+		Object.defineProperty(fs$25, "FileReadStream", {
 			get: function() {
 				return FileReadStream;
 			},
@@ -46511,7 +49120,7 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			configurable: true
 		});
 		var FileWriteStream = WriteStream;
-		Object.defineProperty(fs$23, "FileWriteStream", {
+		Object.defineProperty(fs$25, "FileWriteStream", {
 			get: function() {
 				return FileWriteStream;
 			},
@@ -46555,13 +49164,13 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			});
 		}
 		function createReadStream(path, options) {
-			return new fs$23.ReadStream(path, options);
+			return new fs$25.ReadStream(path, options);
 		}
 		function createWriteStream(path, options) {
-			return new fs$23.WriteStream(path, options);
+			return new fs$25.WriteStream(path, options);
 		}
-		var fs$open = fs$23.open;
-		fs$23.open = open;
+		var fs$open = fs$25.open;
+		fs$25.open = open;
 		function open(path, flags, mode, cb) {
 			if (typeof mode === "function") cb = mode, mode = null;
 			return go$open(path, flags, mode, cb);
@@ -46583,7 +49192,7 @@ var require_graceful_fs = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 				});
 			}
 		}
-		return fs$23;
+		return fs$25;
 	}
 	function enqueue(elem) {
 		debug("ENQUEUE", elem[0].name, elem[1]);
@@ -46872,8 +49481,8 @@ var require_utimes = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, modu
 		else if (timestamp instanceof Date) return /* @__PURE__ */ new Date(Math.floor(timestamp.getTime() / 1e3) * 1e3);
 		else throw new Error("fs-extra: timeRemoveMillis() unknown parameter type");
 	}
-	function utimesMillis(path$41, atime, mtime, callback) {
-		fs.open(path$41, "r+", (err, fd) => {
+	function utimesMillis(path$42, atime, mtime, callback) {
+		fs.open(path$42, "r+", (err, fd) => {
 			if (err) return callback(err);
 			fs.futimes(fd, atime, mtime, (futimesErr) => {
 				fs.close(fd, (closeErr) => {
@@ -46882,8 +49491,8 @@ var require_utimes = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, modu
 			});
 		});
 	}
-	function utimesMillisSync(path$42, atime, mtime) {
-		const fd = fs.openSync(path$42, "r+");
+	function utimesMillisSync(path$43, atime, mtime) {
+		const fd = fs.openSync(path$43, "r+");
 		fs.futimesSync(fd, atime, mtime);
 		return fs.closeSync(fd);
 	}
@@ -47886,10 +50495,10 @@ var require_jsonfile$1 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 		}
 		if (typeof options === "string") options = { encoding: options };
 		options = options || {};
-		var fs$19 = options.fs || _fs;
+		var fs$21 = options.fs || _fs;
 		var shouldThrow = true;
 		if ("throws" in options) shouldThrow = options.throws;
-		fs$19.readFile(file, options, function(err, data) {
+		fs$21.readFile(file, options, function(err, data) {
 			if (err) return callback(err);
 			data = stripBom(data);
 			var obj;
@@ -47907,11 +50516,11 @@ var require_jsonfile$1 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 	function readFileSync(file, options) {
 		options = options || {};
 		if (typeof options === "string") options = { encoding: options };
-		var fs$20 = options.fs || _fs;
+		var fs$22 = options.fs || _fs;
 		var shouldThrow = true;
 		if ("throws" in options) shouldThrow = options.throws;
 		try {
-			var content = fs$20.readFileSync(file, options);
+			var content = fs$22.readFileSync(file, options);
 			content = stripBom(content);
 			return JSON.parse(content, options.reviver);
 		} catch (err) {
@@ -47936,7 +50545,7 @@ var require_jsonfile$1 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			options = {};
 		}
 		options = options || {};
-		var fs$21 = options.fs || _fs;
+		var fs$23 = options.fs || _fs;
 		var str = "";
 		try {
 			str = stringify(obj, options);
@@ -47944,13 +50553,13 @@ var require_jsonfile$1 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports,
 			if (callback) callback(err, null);
 			return;
 		}
-		fs$21.writeFile(file, str, options, callback);
+		fs$23.writeFile(file, str, options, callback);
 	}
 	function writeFileSync(file, obj, options) {
 		options = options || {};
-		var fs$22 = options.fs || _fs;
+		var fs$24 = options.fs || _fs;
 		var str = stringify(obj, options);
-		return fs$22.writeFileSync(file, str, options);
+		return fs$24.writeFileSync(file, str, options);
 	}
 	function stripBom(content) {
 		if (Buffer.isBuffer(content)) content = content.toString("utf8");
@@ -90581,11 +93190,11 @@ var require_main = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module
 		}
 		let lastError;
 		const parsedAll = {};
-		for (const path$40 of optionPaths) try {
-			const parsed = DotenvModule.parse(fs$4.readFileSync(path$40, { encoding }));
+		for (const path$41 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$4.readFileSync(path$41, { encoding }));
 			DotenvModule.populate(parsedAll, parsed, options);
 		} catch (e) {
-			if (debug) _debug(`failed to load ${path$40} ${e.message}`);
+			if (debug) _debug(`failed to load ${path$41} ${e.message}`);
 			lastError = e;
 		}
 		const populated = DotenvModule.populate(processEnv, parsedAll, options);
@@ -94358,6 +96967,17 @@ import_moleculer.default.Validator;
 import_moleculer.default.Validators;
 //#endregion
 //#region src/kernel/moleculer/broker-factory.ts
+/**
+* How many UDP discovery packets an agent in discovery mode sends (D802).
+*
+* Discovery exists so an agent finds the hub without an address: the HUB
+* broadcasts `<namespace>|hub|<port>` every 5 s and an agent that hears it
+* dials that address over TCP — the hub then learns the agent from the TCP
+* handshake, not from the agent's own broadcast. Nothing needs an agent to
+* announce itself on the LAN every 5 s forever, so it sends a few packets at
+* start (enough to be seen by a hub that is already up) and stops.
+*/
+var AGENT_UDP_MAX_DISCOVERY = 3;
 /** Default fixed TCP port for hub-agent cluster traffic. */
 var DEFAULT_HUB_TCP_PORT = 6e3;
 var DEFAULT_UDP_PORT = 4445;
@@ -94455,6 +97075,7 @@ function createBroker(config) {
 				debug: false
 			}
 		},
+		...config.middlewares !== void 0 ? { middlewares: [...config.middlewares] } : {},
 		logger: {
 			type: "Console",
 			options: { level: {
@@ -94481,6 +97102,7 @@ function createBroker(config) {
 		tcpOptions.udpDiscovery = true;
 		tcpOptions.udpPort = udpPort;
 		tcpOptions.udpPeriod = 5;
+		tcpOptions.udpMaxDiscovery = AGENT_UDP_MAX_DISCOVERY;
 	}
 	return new ServiceBroker({
 		nodeID,
@@ -94489,6 +97111,7 @@ function createBroker(config) {
 			type: "TCP",
 			options: tcpOptions
 		},
+		...config.middlewares !== void 0 ? { middlewares: [...config.middlewares] } : {},
 		logger: {
 			type: "Console",
 			options: { level: {
@@ -94642,6 +97265,9 @@ var HubLogForwarder = class {
 };
 //#endregion
 //#region src/kernel/moleculer/hub-service.ts
+function senderOf$1(ctx) {
+	return typeof ctx.nodeID === "string" ? ctx.nodeID : "";
+}
 function createHubService(deps) {
 	return {
 		name: "$hub",
@@ -94663,7 +97289,20 @@ function createHubService(deps) {
 				deps.onSetLogLevel?.(ctx.params.level);
 				return true;
 			} },
+			joinChallenge: { handler(ctx) {
+				if (deps.meshAuth === void 0) throw new Errors.MoleculerClientError("mesh join is not enabled on this node", 404);
+				return deps.meshAuth.issueChallenge(senderOf$1(ctx));
+			} },
+			authenticateNode: { handler(ctx) {
+				if (deps.meshAuth === void 0) throw new Errors.MoleculerClientError("mesh join is not enabled on this node", 404);
+				return deps.meshAuth.authenticate(senderOf$1(ctx), ctx.params);
+			} },
 			registerNode: { handler(ctx) {
+				if (deps.meshAuth !== void 0) {
+					deps.meshAuth.admitRegistration(senderOf$1(ctx), ctx.params);
+					deps.onRegisterNode?.(ctx.params);
+					return { ok: true };
+				}
 				const verdict = require_cluster_secret.checkClusterSecret(deps.clusterSecretGate?.() ?? { kind: "off" }, ctx.params.clusterSecretHash);
 				if (verdict === "mismatch") throw new Errors.MoleculerError(`cluster secret mismatch — node "${ctx.params.nodeId}" rejected`, 403, require_cluster_secret.CLUSTER_SECRET_MISMATCH_TYPE);
 				if (verdict === "unavailable") throw new Errors.MoleculerRetryableError(`the hub cannot read its cluster secret yet — node "${ctx.params.nodeId}" must retry`, 503, require_cluster_secret.CLUSTER_SECRET_UNAVAILABLE_TYPE);
@@ -94882,6 +97521,580 @@ async function callRegisterNodeWithRetry(broker, params, opts) {
 	}
 }
 //#endregion
+//#region src/kernel/moleculer/mesh-join-proof.ts
+/**
+* Mesh join — the challenge–response that authenticates a node to the hub
+* (D802). Shared by the hub (`$hub.joinChallenge` / `$hub.authenticateNode`)
+* and the agent (`MeshJoinClient`).
+*
+* The exchange, over the clear-text Moleculer transport:
+*
+*   agent → hub   `$hub.joinChallenge {}`                        → { nonce }
+*   agent → hub   `$hub.authenticateNode { nodeId, nonce,
+*                                          clientNonce, proof }`  → { hubProof }
+*
+*   proof    = HMAC-SHA256(K, "camstack-mesh-join/v1|node|<nodeId>|<nonce>")
+*   hubProof = HMAC-SHA256(K, "camstack-mesh-join/v1|hub|<nodeId>|<nonce>|<clientNonce>")
+*   K        = SHA-256(cluster secret)   — the value each side already holds
+*
+* What it buys over the D797 hash (`clusterSecretHash` in `registerNode`):
+*  - nothing reusable crosses the wire: the nonce is the hub's, single use,
+*    short-lived and bound to the SENDER node id, so a sniffed proof answers a
+*    challenge that no longer exists;
+*  - the agent authenticates the HUB too (`hubProof` over the agent's own
+*    nonce): a rogue node answering to `hub` on the LAN — found through UDP
+*    discovery — cannot prove it knows the secret, and the agent refuses it.
+*
+* What it does NOT buy: the transport stays clear text, and the sender node id
+* of every later packet is self-declared. A LAN host that watches a node join
+* can still spoof that node id afterwards. Only mutual TLS (the next step,
+* `docs/design/2026-10-09-mesh-mtls-plan.md`) closes that.
+*/
+/** Protocol version carried by the challenge; the agent refuses one it does not speak. */
+var MESH_JOIN_PROTOCOL = 1;
+var DOMAIN = "camstack-mesh-join/v1";
+/** The hub's action that hands out a single-use nonce. */
+var MESH_JOIN_CHALLENGE_ACTION = "$hub.joinChallenge";
+/** The hub's action that verifies a node's proof and answers with its own. */
+var MESH_JOIN_AUTHENTICATE_ACTION = "$hub.authenticateNode";
+/** Moleculer error `type`: the sender has not authenticated and the hub enforces it. */
+var MESH_NODE_UNAUTHENTICATED_TYPE = "MESH_NODE_UNAUTHENTICATED";
+/** Moleculer error `type`: the action is never callable from another node. */
+var MESH_ACTION_FORBIDDEN_TYPE = "MESH_ACTION_FORBIDDEN";
+/** Moleculer error `type`: the challenge is unknown, used or expired — ask for a new one. */
+var MESH_JOIN_CHALLENGE_INVALID_TYPE = "MESH_JOIN_CHALLENGE_INVALID";
+/** A fresh 32-byte nonce, hex. */
+function createMeshNonce() {
+	return (0, node_crypto.randomBytes)(32).toString("hex");
+}
+function hmacHex(secretHash, message) {
+	return (0, node_crypto.createHmac)("sha256", Buffer.from(secretHash, "utf8")).update(message, "utf8").digest("hex");
+}
+/** The node's answer to the hub's nonce. `secretHash` is `hashClusterSecret(secret)`. */
+function computeNodeJoinProof(secretHash, nodeId, nonce) {
+	return hmacHex(secretHash, `${DOMAIN}|node|${nodeId}|${nonce}`);
+}
+/** The hub's answer to the node's nonce — proves the hub holds the same secret. */
+function computeHubJoinProof(secretHash, nodeId, nonce, clientNonce) {
+	return hmacHex(secretHash, `${DOMAIN}|hub|${nodeId}|${nonce}|${clientNonce}`);
+}
+/** Constant-time comparison of two hex proofs; any shape mismatch is `false`. */
+function proofsEqual(expected, presented) {
+	if (typeof presented !== "string" || presented.length !== expected.length) return false;
+	return (0, node_crypto.timingSafeEqual)(Buffer.from(expected, "utf8"), Buffer.from(presented, "utf8"));
+}
+/** Reads a Moleculer error's `type`, including after an RPC round-trip. */
+function meshErrorType(err) {
+	if (typeof err !== "object" || err === null || !("type" in err)) return null;
+	const { type } = err;
+	return typeof type === "string" ? type : null;
+}
+//#endregion
+//#region src/kernel/moleculer/mesh-authenticator.ts
+/**
+* MeshAuthenticator — the hub's record of WHICH node is calling, and whether
+* it proved it (D802).
+*
+* Every remote Moleculer action and event reaching the hub passes through
+* {@link MeshAuthenticator.admitCall} (wired as a broker middleware,
+* `mesh-access-middleware.ts`). The sender node id Moleculer reports is
+* self-declared; this class binds it to a proof:
+*
+*  - `$hub.joinChallenge` → a single-use nonce bound to the sender;
+*  - `$hub.authenticateNode` → the node's HMAC over that nonce and its own id
+*    (`mesh-join-proof.ts`). Success marks the node `authenticated` until its
+*    connection drops (`forget`, on `$node.disconnected`).
+*
+* Policy, per remote action:
+*  - the join actions and `registerNode` are open (they ARE the
+*    authentication; `registerNode` applies its own rule below);
+*  - {@link isRemoteForbiddenAction}: never from another node, whoever it is;
+*  - otherwise an authenticated (or, in `transition`, legacy) node is allowed;
+*    an unauthenticated one is refused in `enforced` and tolerated — with a
+*    warning and a row on System → Cluster — in `transition`.
+*
+* `registerNode` (`admitRegistration`): a node registers only itself; an
+* authenticated node always may; the D797 hash is accepted as `legacy` in
+* `transition` only; no proof at all is tolerated in `transition` only.
+*/
+/** A challenge is answered within this window or not at all. */
+var MESH_JOIN_CHALLENGE_TTL_MS = 6e4;
+/** Outstanding challenges kept at most — a flood of fake node ids evicts the oldest. */
+var MAX_PENDING_CHALLENGES = 256;
+/** Unauthenticated senders remembered for the status page — bounded the same way. */
+var MAX_TRACKED_NODES = 256;
+/** Actions any node may call before it has authenticated. */
+var PRE_AUTH_ACTIONS = new Set([
+	MESH_JOIN_CHALLENGE_ACTION,
+	MESH_JOIN_AUTHENTICATE_ACTION,
+	"$hub.registerNode"
+]);
+/**
+* Services and actions no other node ever calls on the hub. `$process` spawns
+* runners with an arbitrary environment (code execution); `$node` is
+* Moleculer's introspection; `setLogLevel` is an operator action the hub
+* issues itself. Nothing in the cluster calls them remotely, so refusing them
+* costs nothing and closes the cheapest routes to the hub.
+*/
+var REMOTE_FORBIDDEN_SERVICES = new Set(["$process", "$node"]);
+var REMOTE_FORBIDDEN_ACTIONS = new Set(["$hub.setLogLevel"]);
+function isRemoteForbiddenAction(action) {
+	if (REMOTE_FORBIDDEN_ACTIONS.has(action)) return true;
+	const dot = action.indexOf(".");
+	return dot > 0 && REMOTE_FORBIDDEN_SERVICES.has(action.slice(0, dot));
+}
+function refuse(message, type, code = 403) {
+	return new Errors.MoleculerClientError(message, code, type);
+}
+var MeshAuthenticator = class {
+	deps;
+	challenges = /* @__PURE__ */ new Map();
+	nodes = /* @__PURE__ */ new Map();
+	/** Completed the challenge–response at least once since the hub started. */
+	everAuthenticated = /* @__PURE__ */ new Set();
+	/** Let in WITHOUT the challenge–response at least once since the hub started. */
+	everTolerated = /* @__PURE__ */ new Set();
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? Date.now;
+	}
+	issueChallenge(sender) {
+		const nonce = createMeshNonce();
+		this.challenges.delete(sender);
+		if (this.challenges.size >= MAX_PENDING_CHALLENGES) {
+			const oldest = this.challenges.keys().next().value;
+			if (oldest !== void 0) this.challenges.delete(oldest);
+		}
+		this.challenges.set(sender, {
+			nonce,
+			expiresAt: this.now() + MESH_JOIN_CHALLENGE_TTL_MS
+		});
+		return {
+			protocol: 1,
+			nonce
+		};
+	}
+	authenticate(sender, params) {
+		if (params.nodeId !== sender) throw refuse(`mesh join refused: node "${sender}" presented a proof for "${String(params.nodeId)}"`, MESH_NODE_UNAUTHENTICATED_TYPE);
+		const pending = this.challenges.get(sender);
+		this.challenges.delete(sender);
+		if (pending === void 0 || pending.expiresAt < this.now() || typeof params.nonce !== "string" || !proofsEqual(pending.nonce, params.nonce)) throw refuse(`mesh join refused: no live challenge for node "${sender}" — ask for a new one`, MESH_JOIN_CHALLENGE_INVALID_TYPE);
+		const hash = this.secretHashOrThrow(sender);
+		if (!proofsEqual(computeNodeJoinProof(hash, sender, pending.nonce), params.proof)) throw refuse(`cluster secret mismatch — node "${sender}" rejected`, require_cluster_secret.CLUSTER_SECRET_MISMATCH_TYPE);
+		this.record(sender, "authenticated");
+		this.everAuthenticated.add(sender);
+		this.deps.onAuthenticated?.(sender);
+		const clientNonce = typeof params.clientNonce === "string" ? params.clientNonce : "";
+		return {
+			ok: true,
+			hubProof: computeHubJoinProof(hash, sender, pending.nonce, clientNonce)
+		};
+	}
+	/** The node's connection dropped: it authenticates again when it returns. */
+	forget(nodeId) {
+		this.nodes.delete(nodeId);
+		this.challenges.delete(nodeId);
+	}
+	admitCall(sender, action) {
+		if (sender === this.deps.ownNodeId) return { verdict: "allow" };
+		if (isRemoteForbiddenAction(action)) return {
+			verdict: "deny",
+			errorType: MESH_ACTION_FORBIDDEN_TYPE,
+			message: `"${action}" is not callable from another node (caller "${sender}")`
+		};
+		if (PRE_AUTH_ACTIONS.has(action)) return { verdict: "allow" };
+		return this.admitSender(sender, action);
+	}
+	/** Same rule as a call, for an inbound event. */
+	admitEvent(sender, eventName) {
+		if (sender === this.deps.ownNodeId) return { verdict: "allow" };
+		return this.admitSender(sender, `event:${eventName}`);
+	}
+	admitSender(sender, what) {
+		const state = this.stateOf(sender);
+		if (state === "authenticated") return { verdict: "allow" };
+		if (this.deps.mode() === "enforced") return {
+			verdict: "deny",
+			errorType: MESH_NODE_UNAUTHENTICATED_TYPE,
+			message: `node "${sender}" has not authenticated to this hub — enter the hub cluster secret (System → Cluster) in the agent and restart it`
+		};
+		if (state === "legacy") return { verdict: "allow" };
+		if (!this.nodes.has(sender)) {
+			this.record(sender, "unauthenticated");
+			this.noteTolerated(sender);
+			this.deps.onTolerated?.(sender, what);
+		}
+		return { verdict: "tolerate" };
+	}
+	/** Throws when `sender` may not register `params`; returns when it may. */
+	admitRegistration(sender, params) {
+		if (sender === this.deps.ownNodeId) return;
+		if (params.nodeId !== sender) throw refuse(`registration refused: node "${sender}" may register only itself, not "${params.nodeId}"`, MESH_NODE_UNAUTHENTICATED_TYPE);
+		if (this.stateOf(sender) === "authenticated") return;
+		if (this.deps.mode() === "enforced") throw refuse(`cluster secret mismatch — node "${sender}" rejected: this hub requires agents to authenticate with the cluster secret (System → Cluster); update the agent and enter it`, require_cluster_secret.CLUSTER_SECRET_MISMATCH_TYPE);
+		if (params.clusterSecretHash === void 0) {
+			this.admitSender(sender, "$hub.registerNode");
+			return;
+		}
+		const verdict = require_cluster_secret.checkClusterSecret(this.deps.gate(), params.clusterSecretHash);
+		if (verdict === "mismatch") throw refuse(`cluster secret mismatch — node "${sender}" rejected`, require_cluster_secret.CLUSTER_SECRET_MISMATCH_TYPE);
+		if (verdict === "unavailable") throw new Errors.MoleculerRetryableError(`the hub cannot read its cluster secret yet — node "${sender}" must retry`, 503, require_cluster_secret.CLUSTER_SECRET_UNAVAILABLE_TYPE);
+		this.record(sender, this.deps.gate().kind === "on" ? "legacy" : "unauthenticated");
+		this.noteTolerated(sender);
+	}
+	noteTolerated(nodeId) {
+		if (this.everTolerated.size >= MAX_TRACKED_NODES) return;
+		this.everTolerated.add(nodeId);
+	}
+	stateOf(nodeId) {
+		return this.nodes.get(nodeId)?.state ?? "unauthenticated";
+	}
+	/** Node ids that completed the challenge–response on their current connection. */
+	authenticatedNodeIds() {
+		return [...this.nodes].filter(([, r]) => r.state === "authenticated").map(([id]) => id);
+	}
+	/** Node ids that ever completed the challenge–response since the hub started. */
+	everAuthenticatedNodeIds() {
+		return this.everAuthenticated;
+	}
+	/**
+	* Node ids let in without the challenge–response since the hub started.
+	* Bounded: past {@link MAX_TRACKED_NODES} a flood of fake ids stops adding,
+	* and the ones already here keep the transition open (the operator can still
+	* switch to `enforced` by hand).
+	*/
+	everToleratedNodeIds() {
+		return [...this.everTolerated];
+	}
+	snapshot() {
+		const nodes = [...this.nodes].map(([nodeId, r]) => ({
+			nodeId,
+			state: r.state,
+			since: r.since
+		})).toSorted((a, b) => a.nodeId.localeCompare(b.nodeId));
+		return {
+			mode: this.deps.mode(),
+			nodes
+		};
+	}
+	record(nodeId, state) {
+		this.nodes.delete(nodeId);
+		if (this.nodes.size >= MAX_TRACKED_NODES) {
+			const oldestTolerated = [...this.nodes].find(([, r]) => r.state === "unauthenticated");
+			if (oldestTolerated !== void 0) this.nodes.delete(oldestTolerated[0]);
+		}
+		this.nodes.set(nodeId, {
+			state,
+			since: this.now()
+		});
+	}
+	secretHashOrThrow(sender) {
+		const gate = this.deps.gate();
+		if (gate.kind === "on") return gate.hash;
+		throw new Errors.MoleculerRetryableError(gate.kind === "off" ? `the hub has no cluster secret yet — node "${sender}" must retry` : `the hub cannot read its cluster secret yet — node "${sender}" must retry`, 503, require_cluster_secret.CLUSTER_SECRET_UNAVAILABLE_TYPE);
+	}
+};
+//#endregion
+//#region src/kernel/moleculer/mesh-access-middleware.ts
+/**
+* The hub broker's mesh gate (D802): a Moleculer middleware wrapping every
+* LOCAL action and event handler, so it sees each request another node sends
+* to the hub with `ctx.nodeID` = the sender.
+*
+* For a request from another node it:
+*  1. asks {@link MeshAuthenticator.admitCall} — refuse, tolerate or allow;
+*  2. strips a forged identity from the params ({@link stripForgedIdentity}).
+*
+* Calls the hub makes to itself (`ctx.nodeID` = the hub) pass untouched: a
+* hub-local runner reaches the hub over UDS, and the hub's own code is the
+* trust boundary (D787).
+*/
+/** Identity fields only the hub's own router / transport may set (D787, D-1). */
+var IDENTITY_KEYS = ["caller", "callerAddonId"];
+function withoutIdentity(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+	if (!IDENTITY_KEYS.some((k) => Object.prototype.hasOwnProperty.call(value, k))) return value;
+	const rest = {};
+	for (const [key, v] of Object.entries(value)) if (!IDENTITY_KEYS.includes(key)) rest[key] = v;
+	return rest;
+}
+/**
+* The params of a request from another node, with every identity it claimed
+* removed:
+*  - a cap action's input loses `caller` (the user identity the hub's tRPC
+*    router injects for `caller: 'required'` methods — `keychainAdmin.reveal`
+*    reads it) and `callerAddonId` (the transport's addon stamp the keychain
+*    owner-checks);
+*  - `$hub-cap-fwd.forward` keeps its envelope `callerAddonId` — the forward
+*    service checks it against the sender's registered manifest — but the
+*    forwarded `args` lose both.
+*/
+function stripForgedIdentity(action, params) {
+	if (action === require_hub_cap_forward.HUB_CAP_FWD_ACTION) {
+		if (params === null || typeof params !== "object" || Array.isArray(params)) return params;
+		const args = Reflect.get(params, "args");
+		const cleaned = withoutIdentity(args);
+		return cleaned === args ? params : {
+			...params,
+			args: cleaned
+		};
+	}
+	return withoutIdentity(params);
+}
+function senderOf(ctx) {
+	const nodeID = ctx.nodeID;
+	return typeof nodeID === "string" && nodeID.length > 0 ? nodeID : null;
+}
+function paramNodeId(params) {
+	return params !== null && typeof params === "object" ? Reflect.get(params, "nodeId") : void 0;
+}
+/**
+* Build the middleware. Pass it in `ServiceBroker({ middlewares: [...] })`
+* so it wraps every service, including the ones Moleculer creates itself.
+*/
+function createMeshAccessMiddleware(options) {
+	const { ownNodeId, authenticator, logger } = options;
+	return {
+		name: "CamstackMeshAccess",
+		localAction(next, action) {
+			const name = action.name ?? "";
+			return function meshGatedAction(ctx) {
+				const sender = senderOf(ctx);
+				if (sender === null || sender === ownNodeId) return next.call(this, ctx);
+				const verdict = authenticator.admitCall(sender, name);
+				if (verdict.verdict === "deny") {
+					logger?.warn("mesh call refused", {
+						sender,
+						action: name,
+						reason: verdict.errorType
+					});
+					return Promise.reject(new Errors.MoleculerClientError(verdict.message, 403, verdict.errorType));
+				}
+				if (name === "$hub.unregisterNode" && paramNodeId(ctx.params) !== sender) return Promise.reject(new Errors.MoleculerClientError(`node "${sender}" may unregister only itself`, 403, MESH_ACTION_FORBIDDEN_TYPE));
+				ctx.params = stripForgedIdentity(name, ctx.params);
+				return next.call(this, ctx);
+			};
+		},
+		localEvent(next, event) {
+			const name = event.name ?? "";
+			return function meshGatedEvent(ctx) {
+				const sender = senderOf(ctx);
+				if (sender === null || sender === ownNodeId) return next.call(this, ctx);
+				if (authenticator.admitEvent(sender, name).verdict === "deny") return void 0;
+				return next.call(this, ctx);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/kernel/moleculer/mesh-join-client.ts
+/** States in which a call to the hub is refused locally. */
+var BLOCKING = new Set(["secret-mismatch", "hub-unverified"]);
+/** Error `type`s meaning "the hub has no such action": it predates D802. */
+var UNSUPPORTED = new Set(["SERVICE_NOT_FOUND", "SERVICE_NOT_AVAILABLE"]);
+function errText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function errCode(err) {
+	if (typeof err !== "object" || err === null || !("code" in err)) return null;
+	const { code } = err;
+	return typeof code === "number" ? code : null;
+}
+function readString(value, key) {
+	if (value === null || typeof value !== "object") return null;
+	const v = Reflect.get(value, key);
+	return typeof v === "string" ? v : null;
+}
+var MeshJoinClient = class {
+	opts;
+	current = "pending";
+	settledWaiters = [];
+	inFlight = null;
+	hubNodeId;
+	constructor(opts) {
+		this.opts = opts;
+		this.hubNodeId = opts.hubNodeId ?? "hub";
+	}
+	get state() {
+		return this.current;
+	}
+	/** Did this agent prove itself on the current connection? */
+	get authenticated() {
+		return this.current === "authenticated";
+	}
+	/**
+	* Run the join. Concurrent callers share one attempt. Resolves with the
+	* settled state; never rejects.
+	*/
+	join() {
+		if (this.inFlight !== null) return this.inFlight;
+		const attempt = this.runJoin().then((state) => {
+			this.inFlight = null;
+			this.settle(state);
+			return state;
+		});
+		this.inFlight = attempt;
+		return attempt;
+	}
+	/** The hub connection dropped: the next connection authenticates again. */
+	reset() {
+		this.current = "pending";
+	}
+	/** Resolves when a call to the hub may go out; rejects when it must not. */
+	async whenCallable() {
+		if (this.current === "pending") {
+			let timer;
+			const settled = await Promise.race([new Promise((resolve) => this.settledWaiters.push(() => resolve(true))), new Promise((resolve) => {
+				timer = setTimeout(() => resolve(false), this.opts.pendingWaitMs ?? 3e4);
+				timer.unref?.();
+			})]);
+			if (timer !== void 0) clearTimeout(timer);
+			if (!settled) throw new Error(`the mesh join with "${this.hubNodeId}" has not completed — the call was not sent`);
+		}
+		if (!BLOCKING.has(this.current)) return;
+		if (this.current === "secret-mismatch") throw new Error("the hub refused this agent: cluster secret mismatch — copy the cluster secret from the hub's System → Cluster page into this agent's setup");
+		throw new Error(`the node answering as "${this.hubNodeId}" could not prove it holds the cluster secret — refusing to talk to it (check the hub address and the secret)`);
+	}
+	/**
+	* Moleculer middleware for the AGENT broker: every call to the hub node waits
+	* for the join; a hub answer "not authenticated" (the hub restarted and lost
+	* us) triggers a new join.
+	*/
+	middleware(onUnauthenticated) {
+		const hubNodeId = this.hubNodeId;
+		const whenCallable = () => this.whenCallable();
+		const secretPresent = () => this.secretPresent();
+		return {
+			name: "CamstackMeshJoin",
+			remoteAction(next, action) {
+				const name = action.name ?? "";
+				if (name === "$hub.joinChallenge" || name === "$hub.authenticateNode") return next;
+				return async function meshJoinGated(ctx) {
+					if (ctx.nodeID !== hubNodeId) return next.call(this, ctx);
+					await whenCallable();
+					try {
+						return await next.call(this, ctx);
+					} catch (err) {
+						if (meshErrorType(err) === "MESH_NODE_UNAUTHENTICATED" && secretPresent()) onUnauthenticated?.();
+						throw err;
+					}
+				};
+			}
+		};
+	}
+	secretPresent() {
+		const s = this.opts.secret();
+		return s !== null && s.length > 0;
+	}
+	settle(state) {
+		this.current = state;
+		this.opts.onSettled?.(state);
+		const waiters = this.settledWaiters;
+		this.settledWaiters = [];
+		for (const w of waiters) w();
+	}
+	async runJoin() {
+		const secret = this.opts.secret();
+		if (secret === null || secret.length === 0) return "no-secret";
+		const hash = require_cluster_secret.hashClusterSecret(secret);
+		const maxAttempts = this.opts.maxAttempts ?? 5;
+		let last = "unavailable";
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			const outcome = await this.attempt(hash);
+			if (outcome !== "retry") return outcome;
+			last = "unavailable";
+			await new Promise((r) => setTimeout(r, (this.opts.retryDelayMs ?? 1e3) * attempt));
+		}
+		return last;
+	}
+	async attempt(hash) {
+		const callOpts = {
+			nodeID: this.hubNodeId,
+			timeout: this.opts.callTimeoutMs ?? 1e4
+		};
+		const nodeId = this.opts.nodeId;
+		try {
+			const challenge = await this.opts.call(MESH_JOIN_CHALLENGE_ACTION, {}, callOpts);
+			const nonce = readString(challenge, "nonce");
+			const protocol = challenge !== null && typeof challenge === "object" ? Reflect.get(challenge, "protocol") : void 0;
+			if (nonce === null || protocol !== 1) {
+				this.opts.log?.(`[mesh-join] the hub sent a challenge this agent does not speak`);
+				return "unsupported";
+			}
+			const clientNonce = createMeshNonce();
+			const answer = await this.opts.call(MESH_JOIN_AUTHENTICATE_ACTION, {
+				nodeId,
+				nonce,
+				clientNonce,
+				proof: computeNodeJoinProof(hash, nodeId, nonce)
+			}, callOpts);
+			if (!proofsEqual(computeHubJoinProof(hash, nodeId, nonce, clientNonce), readString(answer, "hubProof"))) {
+				this.opts.log?.(`[mesh-join] the hub could not prove it holds the cluster secret — refused`);
+				return "hub-unverified";
+			}
+			this.opts.log?.(`[mesh-join] authenticated to the hub (mutual)`);
+			return "authenticated";
+		} catch (err) {
+			const type = meshErrorType(err);
+			if (type === "CLUSTER_SECRET_MISMATCH") {
+				this.opts.log?.(`[mesh-join] the hub refused our proof: cluster secret mismatch`);
+				return "secret-mismatch";
+			}
+			if (type !== null && UNSUPPORTED.has(type) || errCode(err) === 404) {
+				this.opts.log?.(`[mesh-join] the hub predates the mesh join — legacy registration`);
+				return "unsupported";
+			}
+			this.opts.log?.(`[mesh-join] join attempt failed (${type ?? "error"}): ${errText(err)}`);
+			return "retry";
+		}
+	}
+};
+//#endregion
+//#region src/kernel/moleculer/mesh-auto-enforce.ts
+/** Boot grace before an empty or partial roster can end the transition. */
+var MESH_AUTO_ENFORCE_GRACE_MS = 5 * 6e4;
+function isAgentId(id, ownNodeId) {
+	return id !== ownNodeId && !id.includes("/");
+}
+function decideMeshAutoEnforce(input) {
+	if (input.mode !== "transition") return {
+		enforce: false,
+		waitingFor: [],
+		why: "not in transition"
+	};
+	if (input.gate !== "on") return {
+		enforce: false,
+		waitingFor: [],
+		why: "no readable cluster secret"
+	};
+	if (input.knownAgents === null) return {
+		enforce: false,
+		waitingFor: [],
+		why: "the cluster-node history has not answered"
+	};
+	if (input.uptimeMs < (input.graceMs ?? 3e5)) return {
+		enforce: false,
+		waitingFor: [],
+		why: "boot grace period"
+	};
+	const known = new Set([
+		...input.knownAgents,
+		...input.connected,
+		...input.toleratedEver
+	].filter((id) => isAgentId(id, input.ownNodeId)));
+	const waitingFor = [...known].filter((id) => !input.authenticatedEver.has(id)).toSorted();
+	if (waitingFor.length > 0) return {
+		enforce: false,
+		waitingFor,
+		why: "agents have not authenticated yet"
+	};
+	return {
+		enforce: true,
+		reason: known.size === 0 ? "no agent has ever joined this hub" : `every known agent has authenticated (${[...known].toSorted().join(", ")})`
+	};
+}
+//#endregion
 //#region src/kernel/moleculer/readiness-service.ts
 /**
 * Service name AGENTS register their own readiness snapshot under.
@@ -96439,6 +99652,8 @@ var LifecycleJobEngine = class {
 	}
 };
 //#endregion
+exports.ADMIN_TOKEN_MAX_LIFETIME_MS = require_builtins_local_auth_local_auth_addon.ADMIN_TOKEN_MAX_LIFETIME_MS;
+exports.ADMIN_TOKEN_PREFIX = require_builtins_local_auth_local_auth_addon.ADMIN_TOKEN_PREFIX;
 exports.AGENT_CAP_FWD_ACTION = require_child_cap_dispatch.AGENT_CAP_FWD_ACTION;
 exports.AGENT_CAP_FWD_SERVICE = require_child_cap_dispatch.AGENT_CAP_FWD_SERVICE;
 exports.AGENT_READINESS_SERVICE_NAME = AGENT_READINESS_SERVICE_NAME;
@@ -96455,9 +99670,15 @@ exports.AddonInstaller = AddonInstaller;
 exports.AddonLoader = AddonLoader;
 exports.AddonManifest = AddonManifest;
 exports.AddonRouteRegistry = AddonRouteRegistry;
+exports.AdminTokenManager = require_builtins_local_auth_local_auth_addon.AdminTokenManager;
 exports.AlertCenterAddon = require_builtins_alerts_alerts_addon.AlertCenterAddon;
 exports.ApiKeyManager = require_builtins_local_auth_local_auth_addon.ApiKeyManager;
+exports.AuthAuditLog = require_builtins_local_auth_local_auth_addon.AuthAuditLog;
 exports.AuthManager = require_builtins_local_auth_local_auth_addon.AuthManager;
+exports.BackupDecryptError = require_restore_archive.BackupDecryptError;
+exports.BackupKeyFormatError = require_restore_archive.BackupKeyFormatError;
+exports.BackupKeyMismatchError = require_restore_archive.BackupKeyMismatchError;
+exports.BackupKeyRequiredError = require_restore_archive.BackupKeyRequiredError;
 exports.CAP_ACTION_OVERFLOW_LABEL = require_child_cap_dispatch.CAP_ACTION_OVERFLOW_LABEL;
 exports.CAP_ACTION_UNLABELLED = require_child_cap_dispatch.CAP_ACTION_UNLABELLED;
 exports.CAP_METHOD_NOT_IMPLEMENTED = require_child_cap_dispatch.CAP_METHOD_NOT_IMPLEMENTED;
@@ -96541,12 +99762,24 @@ exports.LocalChildRegistry = require_child_cap_dispatch.LocalChildRegistry;
 exports.LogManager = LogManager;
 exports.LogRingBuffer = LogRingBuffer;
 exports.LoggingGate = LoggingGate;
+exports.LoginSessionManager = require_builtins_local_auth_local_auth_addon.LoginSessionManager;
 exports.LokiDestination = require_builtins_loki_logging_index.LokiDestination$1;
 exports.LokiLoggingAddon = require_builtins_loki_logging_index.LokiLoggingAddon$1;
 exports.MAX_CAP_ACTIONS_PER_PEER = require_child_cap_dispatch.MAX_CAP_ACTIONS_PER_PEER;
 exports.MAX_LEAF_VALIDITY_DAYS = require_tls$1.MAX_LEAF_VALIDITY_DAYS;
+exports.MESH_ACTION_FORBIDDEN_TYPE = MESH_ACTION_FORBIDDEN_TYPE;
+exports.MESH_AUTH_MODE_FIELD = require_builtins_system_config_system_config_addon.MESH_AUTH_MODE_FIELD;
+exports.MESH_AUTO_ENFORCE_GRACE_MS = MESH_AUTO_ENFORCE_GRACE_MS;
+exports.MESH_JOIN_AUTHENTICATE_ACTION = MESH_JOIN_AUTHENTICATE_ACTION;
+exports.MESH_JOIN_CHALLENGE_ACTION = MESH_JOIN_CHALLENGE_ACTION;
+exports.MESH_JOIN_CHALLENGE_INVALID_TYPE = MESH_JOIN_CHALLENGE_INVALID_TYPE;
+exports.MESH_JOIN_CHALLENGE_TTL_MS = MESH_JOIN_CHALLENGE_TTL_MS;
+exports.MESH_JOIN_PROTOCOL = MESH_JOIN_PROTOCOL;
+exports.MESH_NODE_UNAUTHENTICATED_TYPE = MESH_NODE_UNAUTHENTICATED_TYPE;
 exports.MESH_QUEUE_TOP_N = require_child_cap_dispatch.MESH_QUEUE_TOP_N;
 exports.METHOD_ACCESS_MAP = require_dist.METHOD_ACCESS_MAP;
+exports.MeshAuthenticator = MeshAuthenticator;
+exports.MeshJoinClient = MeshJoinClient;
 exports.ModelDownloadService = require_event_loop_stall_monitor.ModelDownloadService;
 exports.NATIVE_PROVIDER_SERVICE_INFIX = require_child_cap_dispatch.NATIVE_PROVIDER_SERVICE_INFIX;
 exports.NATIVE_SCAN_DEPTH = NATIVE_SCAN_DEPTH;
@@ -96569,6 +99802,7 @@ exports.PipelineRunner = PipelineRunner;
 exports.PipelineValidator = PipelineValidator;
 exports.PythonEnvManager = PythonEnvManager;
 exports.QUARANTINE_DIRNAME = QUARANTINE_DIRNAME;
+exports.REFRESH_TOKEN_PREFIX = require_builtins_local_auth_local_auth_addon.REFRESH_TOKEN_PREFIX;
 exports.RESTART_MARKER_FILE = RESTART_MARKER_FILE;
 exports.RSS_BUDGET_REANNOUNCE_MIN_MS = require_child_cap_dispatch.RSS_BUDGET_REANNOUNCE_MIN_MS;
 exports.RSS_BUDGET_RELEASE_RATIO = require_child_cap_dispatch.RSS_BUDGET_RELEASE_RATIO;
@@ -96597,6 +99831,7 @@ exports.StorageLocationManager = StorageLocationManager;
 exports.StorageManager = StorageManager;
 exports.StorageOrchestratorAddon = require_builtins_storage_orchestrator_storage_orchestrator_addon.StorageOrchestratorAddon;
 exports.StorageOrchestratorService = require_builtins_storage_orchestrator_storage_orchestrator_addon.StorageOrchestratorService;
+exports.SystemBackupService = require_restore_archive.SystemBackupService;
 exports.SystemConfigAddon = require_builtins_system_config_system_config_addon.SystemConfigAddon;
 exports.SystemEventBus = SystemEventBus;
 exports.TRADITIONAL_NATIVE_PACKAGES = TRADITIONAL_NATIVE_PACKAGES;
@@ -96604,6 +99839,7 @@ exports.ToastService = ToastService;
 exports.UDS_NO_ROUTE_PREFIX = require_child_cap_dispatch.UDS_NO_ROUTE_PREFIX;
 exports.UNCLAIMED = UNCLAIMED;
 exports.UPLOADED_CA_FILE = require_tls$1.UPLOADED_CA_FILE;
+exports.USER_MANAGEMENT_INTERNAL = require_builtins_local_auth_local_auth_addon.USER_MANAGEMENT_INTERNAL;
 exports.UdsLocalTransportClient = require_child_cap_dispatch.UdsLocalTransportClient;
 exports.UdsLocalTransportServer = require_child_cap_dispatch.UdsLocalTransportServer;
 exports.UserManager = require_builtins_local_auth_local_auth_addon.UserManager;
@@ -96620,6 +99856,7 @@ exports.allFamiliesListenHost = require_tls$1.allFamiliesListenHost;
 exports.answerClaimedGetStatus = require_child_cap_dispatch.answerClaimedGetStatus;
 exports.applyCertificateToListener = require_tls$1.applyCertificateToListener;
 exports.applyLanHttp = require_tls$1.applyLanHttp;
+exports.attachUserManagementInternal = require_builtins_local_auth_local_auth_addon.attachUserManagementInternal;
 exports.attributeStall = require_event_loop_stall_monitor.attributeStall;
 exports.bindPendingLanHttp = require_tls$1.bindPendingLanHttp;
 exports.bootstrapSchema = bootstrapSchema;
@@ -96658,6 +99895,8 @@ exports.clusterEventTopic = require_child_cap_dispatch.clusterEventTopic;
 exports.clusterSecretMatches = require_cluster_secret.clusterSecretMatches;
 exports.collectCertIdentity = require_tls$1.collectCertIdentity;
 exports.collectModelFiles = require_event_loop_stall_monitor.collectModelFiles;
+exports.computeHubJoinProof = computeHubJoinProof;
+exports.computeNodeJoinProof = computeNodeJoinProof;
 exports.contentTypeFor = require_event_loop_stall_monitor.contentTypeFor;
 exports.copyDirRecursive = copyDirRecursive;
 exports.copyExtraFileDirs = copyExtraFileDirs;
@@ -96670,6 +99909,7 @@ exports.createAuthenticatedFileServer = require_event_loop_stall_monitor.createA
 exports.createBroker = createBroker;
 exports.createBrokerDeviceManagerApi = require_child_cap_dispatch.createBrokerDeviceManagerApi;
 exports.createCapActionCensus = require_child_cap_dispatch.createCapActionCensus;
+exports.createCidrMatcher = require_builtins_system_config_system_config_addon.createCidrMatcher;
 exports.createCoreCapService = createCoreCapService;
 exports.createDeferredHeapWatchSink = require_child_cap_dispatch.createDeferredHeapWatchSink;
 exports.createDoorSettingsView = createDoorSettingsView;
@@ -96682,6 +99922,7 @@ exports.createInspectorArrayBufferCensus = require_child_cap_dispatch.createInsp
 exports.createKernelHwAccel = require_child_cap_dispatch.createKernelHwAccel;
 exports.createLocalTransport = require_child_cap_dispatch.createLocalTransport;
 exports.createLoopDelayMeter = require_child_cap_dispatch.createLoopDelayMeter;
+exports.createMeshAccessMiddleware = createMeshAccessMiddleware;
 exports.createMeshQueueReader = require_child_cap_dispatch.createMeshQueueReader;
 exports.createOutboundQueueGate = require_child_cap_dispatch.createOutboundQueueGate;
 exports.createParentUnownedCallHandler = require_child_cap_dispatch.createParentUnownedCallHandler;
@@ -96699,6 +99940,7 @@ exports.createUdsEventBus = require_child_cap_dispatch.createUdsEventBus;
 exports.createUdsLogger = require_child_cap_dispatch.createUdsLogger;
 exports.createUdsLoggerWithControl = require_child_cap_dispatch.createUdsLoggerWithControl;
 exports.createV8Reclaimer = require_child_cap_dispatch.createV8Reclaimer;
+exports.decideMeshAutoEnforce = decideMeshAutoEnforce;
 exports.deleteModelFromDisk = require_event_loop_stall_monitor.deleteModelFromDisk;
 exports.deriveAgentListenPort = deriveAgentListenPort;
 exports.describeProviderKindDrift = describeProviderKindDrift;
@@ -96760,6 +100002,7 @@ exports.formatLogLine = require_formatter.formatLogLine;
 exports.formatMeshQueue = require_child_cap_dispatch.formatMeshQueue;
 exports.formatOutboundQueueVerdict = require_child_cap_dispatch.formatOutboundQueueVerdict;
 exports.formatSocketPlane = require_child_cap_dispatch.formatSocketPlane;
+exports.generateBackupKeyPair = require_restore_archive.generateBackupKeyPair;
 exports.getBrokerEventBus = require_child_cap_dispatch.getBrokerEventBus;
 exports.getCapUsageRegistry = require_child_cap_dispatch.getCapUsageRegistry;
 Object.defineProperty(exports, "getFfmpegDownloadUrl", {
@@ -96783,6 +100026,8 @@ Object.defineProperty(exports, "getPlatformInfo", {
 exports.getPlatformKeychainKey = require_platform_key_source.getPlatformKeychainKey;
 exports.getProcessClusterSecretGate = require_cluster_secret.getProcessClusterSecretGate;
 exports.getProcessJwtSigningKeyState = require_jwt_signing_key.getProcessJwtSigningKeyState;
+exports.getProcessMeshAuthMode = require_builtins_system_config_system_config_addon.getProcessMeshAuthMode;
+exports.getProcessMeshAuthStatus = require_builtins_system_config_system_config_addon.getProcessMeshAuthStatus;
 Object.defineProperty(exports, "getPythonDownloadUrl", {
 	enumerable: true,
 	get: function() {
@@ -96791,6 +100036,7 @@ Object.defineProperty(exports, "getPythonDownloadUrl", {
 });
 exports.getRestartMarkerPath = getRestartMarkerPath;
 exports.getSinglePidStats = require_resource_monitor.getSinglePidStats;
+exports.getUserManagementInternal = require_builtins_local_auth_local_auth_addon.getUserManagementInternal;
 exports.getWorkerDeviceRegistry = require_child_cap_dispatch.getWorkerDeviceRegistry;
 exports.hasDotNode = hasDotNode;
 exports.hashClusterSecret = require_cluster_secret.hashClusterSecret;
@@ -96821,7 +100067,9 @@ exports.isClusterSecretMismatchError = require_cluster_secret.isClusterSecretMis
 exports.isCollectionArrayMethod = require_dist.isCollectionArrayMethod;
 exports.isCredentialKeyName = require_child_cap_dispatch.isCredentialKeyName;
 exports.isInfraCapability = isInfraCapability;
+exports.isMeshAuthMode = require_builtins_system_config_system_config_addon.isMeshAuthMode;
 exports.isModelDownloaded = require_event_loop_stall_monitor.isModelDownloaded;
+exports.isRemoteForbiddenAction = isRemoteForbiddenAction;
 exports.isSettingsReadUnavailable = require_builtins_local_auth_local_auth_addon.isSettingsReadUnavailable;
 exports.isSourceNewer = isSourceNewer;
 exports.isolatedBuiltinPhase = isolatedBuiltinPhase;
@@ -96829,18 +100077,26 @@ exports.leafFingerprintOf = require_tls$1.leafFingerprintOf;
 exports.loadTlsCert = require_tls$1.loadTlsCert;
 exports.localEndpointPath = require_child_cap_dispatch.localEndpointPath;
 exports.localProviderLink = require_child_cap_dispatch.localProviderLink;
+exports.meshErrorType = meshErrorType;
 exports.mountNativeCapService = require_child_cap_dispatch.mountNativeCapService;
 exports.nextRssBudgetState = require_child_cap_dispatch.nextRssBudgetState;
+exports.normalizeIp = require_builtins_system_config_system_config_addon.normalizeIp;
 exports.overlayGetStatus = overlayGetStatus;
 exports.parseCapAction = require_child_cap_dispatch.parseCapAction;
+exports.parseCidrList = require_builtins_system_config_system_config_addon.parseCidrList;
+exports.parseMeshAuthMode = require_builtins_system_config_system_config_addon.parseMeshAuthMode;
 exports.parseRangeHeader = require_event_loop_stall_monitor.parseRangeHeader;
 exports.parseRssBudgetMb = require_child_cap_dispatch.parseRssBudgetMb;
+exports.parseTokenExpiry = require_builtins_local_auth_local_auth_addon.parseTokenExpiry;
 exports.parseTokenizedUrl = require_event_loop_stall_monitor.parseTokenizedUrl;
 exports.partitionIsolatedBuiltinIds = partitionIsolatedBuiltinIds;
 exports.prepareBootTls = require_tls$1.prepareBootTls;
+exports.prepareRestoreArchive = require_restore_archive.prepareRestoreArchive;
 exports.processJwtSigningKey = require_jwt_signing_key.processJwtSigningKey;
 exports.proxyToUpstream = proxyToUpstream;
 exports.quarantineAddonResidue = quarantineAddonResidue;
+exports.readBackupEncryptionHeader = require_restore_archive.readBackupEncryptionHeader;
+exports.readCidrSetting = require_builtins_system_config_system_config_addon.readCidrSetting;
 exports.readExtraSans = require_tls$1.readExtraSans;
 exports.readHeapSpaces = require_child_cap_dispatch.readHeapSpaces;
 exports.readLanHttpState = require_tls$1.readLanHttpState;
@@ -96860,6 +100116,7 @@ exports.registerHttpsListener = require_tls$1.registerHttpsListener;
 exports.registerLanHttpHandler = require_tls$1.registerLanHttpHandler;
 exports.reissueTlsLeaf = require_tls$1.reissueTlsLeaf;
 exports.reloadHttpsListener = require_tls$1.reloadHttpsListener;
+exports.requestProcessMeshEnforcement = require_builtins_system_config_system_config_addon.requestProcessMeshEnforcement;
 exports.resolveFilePath = require_event_loop_stall_monitor.resolveFilePath;
 exports.resolveFormatRevision = require_event_loop_stall_monitor.resolveFormatRevision;
 exports.resolveHwAccel = require_child_cap_dispatch.resolveHwAccel;
@@ -96881,6 +100138,9 @@ exports.setHubConnected = require_child_cap_dispatch.setHubConnected;
 exports.setNodeEventInterest = require_child_cap_dispatch.setNodeEventInterest;
 exports.setPlatformKeychainKey = require_platform_key_source.setPlatformKeychainKey;
 exports.setProcessClusterSecretGate = require_cluster_secret.setProcessClusterSecretGate;
+exports.setProcessMeshAuthMode = require_builtins_system_config_system_config_addon.setProcessMeshAuthMode;
+exports.setProcessMeshAuthStatusSource = require_builtins_system_config_system_config_addon.setProcessMeshAuthStatusSource;
+exports.setProcessMeshEnforcer = require_builtins_system_config_system_config_addon.setProcessMeshEnforcer;
 exports.setWrapperActive = require_builtins_device_manager_device_manager_addon.setWrapperActive;
 exports.shouldReclaim = require_child_cap_dispatch.shouldReclaim;
 exports.signalAllRunnerGroups = require_child_cap_dispatch.signalAllRunnerGroups;
@@ -96896,6 +100156,8 @@ exports.storeMayAnswer = storeMayAnswer;
 exports.storeUploadedCertificate = require_tls$1.storeUploadedCertificate;
 exports.strandedMb = require_child_cap_dispatch.strandedMb;
 exports.stripCamstackDeps = stripCamstackDeps;
+exports.stripForgedIdentity = stripForgedIdentity;
+exports.stripForwardedCaller = require_hub_cap_forward.stripForwardedCaller;
 exports.subscribePassthrough = require_child_cap_dispatch.subscribePassthrough;
 exports.udsChildLogToWorkerEntry = require_child_cap_dispatch.udsChildLogToWorkerEntry;
 exports.validateProviderRegistrations = require_child_cap_dispatch.validateProviderRegistrations;