@ariestools/cli 0.1.10 → 0.1.12

package/dist/bin/daemons/datalake-dev.mjs

@@ -1471,10 +1471,10 @@ var $ZodRegistry = class {
 		return this._map.has(schema);
 	}
 };
-function registry$1() {
+function registry$2() {
 	return new $ZodRegistry();
 }
-(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry$1());
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry$2());
 globalThis.__zod_globalRegistry;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/api.js
@@ -6118,13 +6118,13 @@ function algorithmFromAddress(address) {
 var JwtAlg = Enum({ ES256K: "ES256K" });
 var JwtTyp = Enum({ JWT: "JWT" });
 var JwtSchema = Enum({ Signin: "network.xyo.auth.signin" });
-var registry = {};
+var registry$1 = {};
 function registerVerifier(algorithm, fn) {
-	registry[algorithm] = fn;
+	registry$1[algorithm] = fn;
 }
 async function verifySignature(address, hash, signature) {
 	const algorithm = algorithmFromAddress(address);
-	const fn = registry[algorithm];
+	const fn = registry$1[algorithm];
 	if (!fn) throw new Error(`No verifier registered for algorithm [${algorithm}]. Did you import the account package?`);
 	return await fn(address, hash, signature);
 }
@@ -56402,7 +56402,7 @@ function multicast(coldObservable) {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@ariestools+threads@8.1.2_@opentelemetry+api@1.9.1_observable-fns@0.6.1_supports-color@10.2.2_zod@4.4.3/node_modules/@ariestools/threads/dist/node/master/index-node.mjs
+//#region ../../node_modules/.pnpm/@ariestools+threads@8.1.3_@opentelemetry+api@1.9.1_observable-fns@0.6.1_supports-color@10.2.2_zod@4.4.3/node_modules/@ariestools/threads/dist/node/master/index-node.mjs
 cpus().length;
 function resolveScriptPath(scriptPath, baseURL) {
 	const makeAbsolute = (filePath) => {
@@ -56410,8 +56410,11 @@ function resolveScriptPath(scriptPath, baseURL) {
 	};
 	return makeAbsolute(scriptPath);
 }
+var registry = {
+	allWorkers: [],
+	signalHandlers: /* @__PURE__ */ new Map()
+};
 function initWorkerThreadsWorker() {
-	let allWorkers = [];
 	class Worker3 extends Worker {
 		mappedEventListeners;
 		constructor(scriptPath, options) {
@@ -56422,7 +56425,10 @@ function initWorkerThreadsWorker() {
 			});
 			else super(resolvedScriptPath, options);
 			this.mappedEventListeners = /* @__PURE__ */ new WeakMap();
-			allWorkers.push(this);
+			registry.allWorkers.push(this);
+			this.once("exit", () => {
+				registry.allWorkers = registry.allWorkers.filter((worker) => worker !== this);
+			});
 		}
 		addEventListener(eventName, rawListener) {
 			const listener = (message) => {
@@ -56436,19 +56442,6 @@ function initWorkerThreadsWorker() {
 			this.off(eventName, listener);
 		}
 	}
-	const terminateWorkersAndMaster = () => {
-		(async () => {
-			try {
-				await Promise.all(allWorkers.map((worker) => worker.terminate()));
-				process.exit(0);
-			} catch {
-				process.exit(1);
-			}
-		})();
-		allWorkers = [];
-	};
-	process.on("SIGINT", () => terminateWorkersAndMaster());
-	process.on("SIGTERM", () => terminateWorkersAndMaster());
 	class BlobWorker2 extends Worker3 {
 		constructor(blob, options) {
 			super(Buffer.from(blob).toString("utf-8"), {
@@ -69483,8 +69476,8 @@ var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.3/node_modules/fast-uri/lib/utils.js
-var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/lib/utils.js
+var require_utils$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/** @type {(value: string) => boolean} */
 	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
 	/** @type {(value: string) => boolean} */
@@ -69855,9 +69848,9 @@ var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.3/node_modules/fast-uri/lib/schemes.js
-var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { isUUID } = require_utils$2();
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/lib/schemes.js
+var require_schemes$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { isUUID } = require_utils$3();
 	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
 	const supportedSchemeNames = [
 		"http",
@@ -70038,10 +70031,10 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-uri@3.1.3/node_modules/fast-uri/index.js
-var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils$2();
-	const { SCHEMES, getSchemeHandler } = require_schemes();
+//#region ../../node_modules/.pnpm/fast-uri@3.1.4/node_modules/fast-uri/index.js
+var require_fast_uri$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils$3();
+	const { SCHEMES, getSchemeHandler } = require_schemes$1();
 	/**
 	* @template {import('./types/index').URIComponent|string} T
 	* @param {T} uri
@@ -70177,6 +70170,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return uriTokens.join("");
 	}
 	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
 	/**
 	* @param {import('./types/index').URIComponent} parsed
 	* @param {RegExpMatchArray} matches
@@ -70207,6 +70201,11 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		let isIP = false;
 		if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
 		else uri = "//" + uri;
+		const authorityMatch = uri.match(AUTHORITY_PREFIX);
+		if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+			parsed.error = "URI authority must not contain a literal backslash.";
+			malformedAuthorityOrPort = true;
+		}
 		const matches = uri.match(URI_PARSE);
 		if (matches) {
 			parsed.scheme = matches[1];
@@ -70316,7 +70315,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
 var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const uri = require_fast_uri();
+	const uri = require_fast_uri$1();
 	uri.code = "require(\"ajv/dist/runtime/uri\").default";
 	exports.default = uri;
 }));
@@ -81353,7 +81352,7 @@ var require_error$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports.createError = createError;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/errors.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/errors.js
 var require_errors$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { createError } = require_error$1();
 	module.exports = {
@@ -81368,7 +81367,7 @@ var require_errors$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/symbols.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/symbols.js
 var require_symbols$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		kAvvio: Symbol("avvio.Boot"),
@@ -81383,7 +81382,7 @@ var require_symbols$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/time-tree.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/time-tree.js
 var require_time_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { kUntrackNode, kTrackNode, kGetParent, kGetNode, kAddNode } = require_symbols$2();
 	/**
@@ -81546,13 +81545,13 @@ var require_time_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = { TimeTree };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/debug.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/debug.js
 var require_debug$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { debuglog } = __require$1("node:util");
 	module.exports = { debug: debuglog("avvio") };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/create-promise.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/create-promise.js
 var require_create_promise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* @callback PromiseResolve
@@ -81591,7 +81590,7 @@ var require_create_promise = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	module.exports = { createPromise };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/get-plugin-name.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/get-plugin-name.js
 var require_get_plugin_name = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { kPluginMeta } = require_symbols$2();
 	/**
@@ -81609,7 +81608,7 @@ var require_get_plugin_name = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	module.exports = { getPluginName };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/is-promise-like.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/is-promise-like.js
 var require_is_promise_like = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* @param {any} maybePromiseLike
@@ -81621,7 +81620,7 @@ var require_is_promise_like = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	module.exports = { isPromiseLike };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/plugin.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/plugin.js
 var require_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { EventEmitter: EventEmitter$10 } = __require$1("node:events");
 	const { inherits: inherits$2 } = __require$1("node:util");
@@ -81826,7 +81825,7 @@ var require_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = { Plugin };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/validate-plugin.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/validate-plugin.js
 var require_validate_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { AVV_ERR_PLUGIN_NOT_VALID } = require_errors$2();
 	/**
@@ -81843,7 +81842,7 @@ var require_validate_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	module.exports = { validatePlugin };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/is-bundled-or-typescript-plugin.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/is-bundled-or-typescript-plugin.js
 var require_is_bundled_or_typescript_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* bundled or typescript plugin
@@ -81860,7 +81859,7 @@ var require_is_bundled_or_typescript_plugin = /* @__PURE__ */ __commonJSMin(((ex
 	module.exports = { isBundledOrTypescriptPlugin };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/thenify.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/thenify.js
 var require_thenify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { debug } = require_debug$1();
 	const { kThenifyDoNotWrap } = require_symbols$2();
@@ -81903,7 +81902,7 @@ var require_thenify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = { thenify };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/lib/execute-with-thenable.js
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/lib/execute-with-thenable.js
 var require_execute_with_thenable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { isPromiseLike } = require_is_promise_like();
 	const { kAvvio } = require_symbols$2();
@@ -81931,8 +81930,8 @@ var require_execute_with_thenable = /* @__PURE__ */ __commonJSMin(((exports, mod
 	module.exports = { executeWithThenable };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/avvio@9.2.0/node_modules/avvio/boot.js
-var require_boot = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.pnpm/avvio@9.3.0/node_modules/avvio/index.js
+var require_avvio = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const fastq = require_queue();
 	const EE = __require$1("node:events").EventEmitter;
 	const inherits$1 = __require$1("node:util").inherits;
@@ -82231,9 +82230,12 @@ var require_boot = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			executeWithThenable(func, [], cb);
 		} else if (func.length === 1) executeWithThenable(func, [err], cb);
 		else if (this._opts.timeout === 0) {
+			let completed = false;
 			const wrapCb = (err) => {
+				if (completed) return;
+				completed = true;
 				this._error = err;
-				cb(this._error);
+				process.nextTick(cb, this._error);
 			};
 			if (func.length === 2) func(err, wrapCb);
 			else func(err, context, wrapCb);
@@ -82255,8 +82257,9 @@ var require_boot = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		function timeoutCb(err) {
 			if (timer) {
 				clearTimeout(timer);
+				timer = null;
 				this._error = err;
-				cb(this._error);
+				process.nextTick(cb, this._error);
 			}
 		}
 	}
@@ -89871,7 +89874,7 @@ var require_schemas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/serializer.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/serializer.js
 var require_serializer$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
 	module.exports = class Serializer {
@@ -94414,7 +94417,7 @@ var require_jtd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/@fastify+ajv-compiler@4.0.5/node_modules/@fastify/ajv-compiler/lib/default-ajv-options.js
 var require_default_ajv_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const fastUri = require_fast_uri();
+	const fastUri = require_fast_uri$1();
 	module.exports = Object.freeze({
 		coerceTypes: "array",
 		useDefaults: true,
@@ -95171,7 +95174,934 @@ var require_json_schema_ref_resolver = /* @__PURE__ */ __commonJSMin(((exports,
 	module.exports = { RefResolver };
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/validator.js
+//#region ../../node_modules/.pnpm/fast-uri@4.1.1/node_modules/fast-uri/lib/utils.js
+var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/** @type {(value: string) => boolean} */
+	const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+	/** @type {(value: string) => boolean} */
+	const isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+	/** @type {(value: string) => boolean} */
+	const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/?]$/iu);
+	/**
+	* @param {Array<string>} input
+	* @returns {string}
+	*/
+	function stringArrayToHexStripped(input) {
+		let acc = "";
+		let code = 0;
+		let i = 0;
+		for (i = 0; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (code === 48) continue;
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+			break;
+		}
+		for (i += 1; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+		}
+		return acc;
+	}
+	/**
+	* @typedef {Object} GetIPV6Result
+	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	* @property {string} address - The parsed IPv6 address.
+	* @property {string} [zone] - The zone identifier, if present.
+	*/
+	/**
+	* @param {string} value
+	* @returns {boolean}
+	*/
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	/**
+	* @param {Array<string>} buffer
+	* @returns {boolean}
+	*/
+	function consumeIsZone(buffer) {
+		buffer.length = 0;
+		return true;
+	}
+	/**
+	* @param {Array<string>} buffer
+	* @param {Array<string>} address
+	* @param {GetIPV6Result} output
+	* @returns {boolean}
+	*/
+	function consumeHextets(buffer, address, output) {
+		if (buffer.length) {
+			const hex = stringArrayToHexStripped(buffer);
+			if (hex !== "") address.push(hex);
+			else {
+				output.error = true;
+				return false;
+			}
+			buffer.length = 0;
+		}
+		return true;
+	}
+	/**
+	* @param {string} input
+	* @returns {GetIPV6Result}
+	*/
+	function getIPV6(input) {
+		let tokenCount = 0;
+		const output = {
+			error: false,
+			address: "",
+			zone: ""
+		};
+		/** @type {Array<string>} */
+		const address = [];
+		/** @type {Array<string>} */
+		const buffer = [];
+		let endipv6Encountered = false;
+		let endIpv6 = false;
+		let consume = consumeHextets;
+		for (let i = 0; i < input.length; i++) {
+			const cursor = input[i];
+			if (cursor === "[" || cursor === "]") continue;
+			if (cursor === ":") {
+				if (endipv6Encountered === true) endIpv6 = true;
+				if (!consume(buffer, address, output)) break;
+				if (++tokenCount > 7) {
+					output.error = true;
+					break;
+				}
+				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
+				address.push(":");
+				continue;
+			} else if (cursor === "%") {
+				if (!consume(buffer, address, output)) break;
+				consume = consumeIsZone;
+			} else {
+				buffer.push(cursor);
+				continue;
+			}
+		}
+		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
+		else if (endIpv6) address.push(buffer.join(""));
+		else address.push(stringArrayToHexStripped(buffer));
+		output.address = address.join("");
+		return output;
+	}
+	/**
+	* @typedef {Object} NormalizeIPv6Result
+	* @property {string} host - The normalized host.
+	* @property {string} [escapedHost] - The escaped host.
+	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	*/
+	/**
+	* @param {string} host
+	* @returns {NormalizeIPv6Result}
+	*/
+	function normalizeIPv6(host) {
+		if (findToken(host, ":") < 2) return {
+			host,
+			isIPV6: false
+		};
+		const ipv6 = getIPV6(host);
+		if (!ipv6.error) {
+			let newHost = ipv6.address;
+			let escapedHost = ipv6.address;
+			if (ipv6.zone) {
+				newHost += "%" + ipv6.zone;
+				escapedHost += "%25" + ipv6.zone;
+			}
+			return {
+				host: newHost,
+				isIPV6: true,
+				escapedHost
+			};
+		} else return {
+			host,
+			isIPV6: false
+		};
+	}
+	/**
+	* @param {string} str
+	* @param {string} token
+	* @returns {number}
+	*/
+	function findToken(str, token) {
+		let ind = 0;
+		for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+		return ind;
+	}
+	/**
+	* @param {string} path
+	* @returns {string}
+	*
+	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	*/
+	function removeDotSegments(path) {
+		let input = path;
+		const output = [];
+		let nextSlash = -1;
+		let len = 0;
+		while (len = input.length) {
+			if (len === 1) if (input === ".") break;
+			else if (input === "/") {
+				output.push("/");
+				break;
+			} else {
+				output.push(input);
+				break;
+			}
+			else if (len === 2) {
+				if (input[0] === ".") {
+					if (input[1] === ".") break;
+					else if (input[1] === "/") {
+						input = input.slice(2);
+						continue;
+					}
+				} else if (input[0] === "/") {
+					if (input[1] === ".") {
+						output.push("/");
+						break;
+					}
+				}
+			} else if (len === 3) {
+				if (input === "/..") {
+					if (output.length !== 0) output.pop();
+					output.push("/");
+					break;
+				}
+			}
+			if (input[0] === ".") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(3);
+						continue;
+					}
+				} else if (input[1] === "/") {
+					input = input.slice(2);
+					continue;
+				}
+			} else if (input[0] === "/") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(2);
+						continue;
+					} else if (input[2] === ".") {
+						if (input[3] === "/") {
+							input = input.slice(3);
+							if (output.length !== 0) output.pop();
+							continue;
+						}
+					}
+				}
+			}
+			if ((nextSlash = input.indexOf("/", 1)) === -1) {
+				output.push(input);
+				break;
+			} else {
+				output.push(input.slice(0, nextSlash));
+				input = input.slice(nextSlash);
+			}
+		}
+		return output.join("");
+	}
+	/**
+	* Re-escape RFC 3986 gen-delims that must not appear literally in the host.
+	* After the URI regex parses, these characters cannot be literal in the host
+	* field, so any that appear after decoding came from percent-encoding and
+	* must be restored to prevent authority structure changes.
+	*
+	* @param {string} host
+	* @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
+	* @returns {string}
+	*/
+	const HOST_DELIMS = {
+		"@": "%40",
+		"/": "%2F",
+		"?": "%3F",
+		"#": "%23",
+		":": "%3A"
+	};
+	const HOST_DELIM_RE = /[@/?#:]/g;
+	const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+	function reescapeHostDelimiters(host, isIP) {
+		const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+		re.lastIndex = 0;
+		return host.replace(re, (ch) => HOST_DELIMS[ch]);
+	}
+	/**
+	* Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
+	* Reserved delimiters such as `%2F` and `%2E` stay escaped.
+	*
+	* @param {string} input
+	* @param {boolean} [decodeUnreserved=false]
+	* @returns {string}
+	*/
+	function normalizePercentEncoding(input, decodeUnreserved = false) {
+		if (input.indexOf("%") === -1) return input;
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decodeUnreserved && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			output += input[i];
+		}
+		return output;
+	}
+	/** Pre-built `%XX` strings for every byte. Avoids per-call hex math/concat. */
+	const BYTE_HEX = new Array(256);
+	{
+		const HEX_DIGITS = "0123456789ABCDEF";
+		for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+	}
+	/**
+	* Mirrors the pass-through set of the deprecated `escape()` global:
+	* `A-Z a-z 0-9 * + - . / @ _`. Keeps drop-in semantics for ASCII input.
+	*
+	* @param {number} cp
+	* @returns {boolean}
+	*/
+	function isEscapeSafe(cp) {
+		return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+	}
+	/**
+	* RFC 3986 percent-encode a non-ASCII Unicode code point as UTF-8 bytes.
+	* Caller handles the ASCII branch inline for speed.
+	*
+	* @param {number} cp - Unicode code point (>= 0x80, <= 0x10FFFF)
+	* @returns {string}
+	*/
+	function percentEncodeNonAscii(cp) {
+		if (cp < 2048) return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+		if (cp < 65536) return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+		return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+	}
+	/**
+	* Normalizes path data without turning reserved escapes into live path syntax.
+	* Valid escapes are uppercased, raw unsafe characters are escaped, and only
+	* unreserved bytes that are not `.` are decoded.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizePathEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decoded !== "." && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isPathCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Normalizes the percent-encoding of a query or fragment component.
+	*
+	* Like `normalizePathEncoding`, but uses the query/fragment character set
+	* (which additionally allows `?`) and decodes `.` since it has no dot-segment
+	* meaning outside of a path.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizeQueryFragmentEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isQueryFragmentCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Escapes a component while preserving existing valid percent escapes.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function escapePreservingEscapes(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			const code = input.charCodeAt(i);
+			if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+			else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+			else if (code <= 56319 && i + 1 < input.length) {
+				const low = input.charCodeAt(i + 1);
+				if (low >= 56320 && low <= 57343) {
+					output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+					i++;
+				} else output += percentEncodeNonAscii(65533);
+			} else output += percentEncodeNonAscii(65533);
+		}
+		return output;
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @returns {string|undefined}
+	*/
+	function recomposeAuthority(component) {
+		const uriTokens = [];
+		if (component.userinfo !== void 0) {
+			uriTokens.push(component.userinfo);
+			uriTokens.push("@");
+		}
+		if (component.host !== void 0) {
+			let host = unescape(component.host);
+			if (!isIPv4(host)) {
+				const ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				else host = reescapeHostDelimiters(host, false);
+			}
+			uriTokens.push(host);
+		}
+		if (typeof component.port === "number" || typeof component.port === "string") {
+			uriTokens.push(":");
+			uriTokens.push(String(component.port));
+		}
+		return uriTokens.length ? uriTokens.join("") : void 0;
+	}
+	module.exports = {
+		nonSimpleDomain,
+		recomposeAuthority,
+		reescapeHostDelimiters,
+		normalizePercentEncoding,
+		normalizePathEncoding,
+		normalizeQueryFragmentEncoding,
+		escapePreservingEscapes,
+		removeDotSegments,
+		isIPv4,
+		isUUID,
+		normalizeIPv6,
+		stringArrayToHexStripped
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fast-uri@4.1.1/node_modules/fast-uri/lib/schemes.js
+var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { isUUID } = require_utils$2();
+	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+	const supportedSchemeNames = [
+		"http",
+		"https",
+		"ws",
+		"wss",
+		"urn",
+		"urn:uuid"
+	];
+	/** @typedef {supportedSchemeNames[number]} SchemeName */
+	/**
+	* @param {string} name
+	* @returns {name is SchemeName}
+	*/
+	function isValidSchemeName(name) {
+		return supportedSchemeNames.indexOf(name) !== -1;
+	}
+	/**
+	* @callback SchemeFn
+	* @param {import('../types/index').URIComponent} component
+	* @param {import('../types/index').Options} options
+	* @returns {import('../types/index').URIComponent}
+	*/
+	/**
+	* @typedef {Object} SchemeHandler
+	* @property {SchemeName} scheme - The scheme name.
+	* @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
+	* @property {SchemeFn} parse - Function to parse the URI component for this scheme.
+	* @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
+	* @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
+	* @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
+	* @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
+	*/
+	/**
+	* @param {import('../types/index').URIComponent} wsComponent
+	* @returns {boolean}
+	*/
+	function wsIsSecure(wsComponent) {
+		if (wsComponent.secure === true) return true;
+		else if (wsComponent.secure === false) return false;
+		else if (wsComponent.scheme) return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
+		else return false;
+	}
+	/** @type {SchemeFn} */
+	function httpParse(component) {
+		if (!component.host) component.error = component.error || "HTTP URIs must have a host.";
+		return component;
+	}
+	/** @type {SchemeFn} */
+	function httpSerialize(component) {
+		const secure = String(component.scheme).toLowerCase() === "https";
+		if (component.port === (secure ? 443 : 80) || component.port === "") component.port = void 0;
+		if (!component.path) component.path = "/";
+		return component;
+	}
+	/** @type {SchemeFn} */
+	function wsParse(wsComponent) {
+		wsComponent.secure = wsIsSecure(wsComponent);
+		wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
+		wsComponent.path = void 0;
+		wsComponent.query = void 0;
+		return wsComponent;
+	}
+	/** @type {SchemeFn} */
+	function wsSerialize(wsComponent) {
+		if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") wsComponent.port = void 0;
+		if (typeof wsComponent.secure === "boolean") {
+			wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
+			wsComponent.secure = void 0;
+		}
+		if (wsComponent.resourceName) {
+			const [path, query] = wsComponent.resourceName.split("?");
+			wsComponent.path = path && path !== "/" ? path : void 0;
+			wsComponent.query = query;
+			wsComponent.resourceName = void 0;
+		}
+		wsComponent.fragment = void 0;
+		return wsComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnParse(urnComponent, options) {
+		if (!urnComponent.path) {
+			urnComponent.error = "URN can not be parsed";
+			return urnComponent;
+		}
+		const matches = urnComponent.path.match(URN_REG);
+		if (matches) {
+			const scheme = options.scheme || urnComponent.scheme || "urn";
+			urnComponent.nid = matches[1].toLowerCase();
+			urnComponent.nss = matches[2];
+			const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || urnComponent.nid}`);
+			urnComponent.path = void 0;
+			if (schemeHandler) urnComponent = schemeHandler.parse(urnComponent, options);
+		} else urnComponent.error = urnComponent.error || "URN can not be parsed.";
+		return urnComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnSerialize(urnComponent, options) {
+		if (urnComponent.nid === void 0) throw new Error("URN without nid cannot be serialized");
+		const scheme = options.scheme || urnComponent.scheme || "urn";
+		const nid = urnComponent.nid.toLowerCase();
+		const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || nid}`);
+		if (schemeHandler) urnComponent = schemeHandler.serialize(urnComponent, options);
+		const uriComponent = urnComponent;
+		const nss = urnComponent.nss;
+		uriComponent.path = `${nid || options.nid}:${nss}`;
+		options.skipEscape = true;
+		return uriComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnuuidParse(urnComponent, options) {
+		const uuidComponent = urnComponent;
+		uuidComponent.uuid = uuidComponent.nss;
+		uuidComponent.nss = void 0;
+		if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) uuidComponent.error = uuidComponent.error || "UUID is not valid.";
+		return uuidComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnuuidSerialize(uuidComponent) {
+		const urnComponent = uuidComponent;
+		urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
+		return urnComponent;
+	}
+	const http = {
+		scheme: "http",
+		domainHost: true,
+		parse: httpParse,
+		serialize: httpSerialize
+	};
+	const https = {
+		scheme: "https",
+		domainHost: http.domainHost,
+		parse: httpParse,
+		serialize: httpSerialize
+	};
+	const ws = {
+		scheme: "ws",
+		domainHost: true,
+		parse: wsParse,
+		serialize: wsSerialize
+	};
+	const SCHEMES = {
+		http,
+		https,
+		ws,
+		wss: {
+			scheme: "wss",
+			domainHost: ws.domainHost,
+			parse: ws.parse,
+			serialize: ws.serialize
+		},
+		urn: {
+			scheme: "urn",
+			parse: urnParse,
+			serialize: urnSerialize,
+			skipNormalize: true
+		},
+		"urn:uuid": {
+			scheme: "urn:uuid",
+			parse: urnuuidParse,
+			serialize: urnuuidSerialize,
+			skipNormalize: true
+		}
+	};
+	Object.setPrototypeOf(SCHEMES, null);
+	/**
+	* @param {string|undefined} scheme
+	* @returns {SchemeHandler|undefined}
+	*/
+	function getSchemeHandler(scheme) {
+		return scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()]) || void 0;
+	}
+	module.exports = {
+		wsIsSecure,
+		SCHEMES,
+		isValidSchemeName,
+		getSchemeHandler
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fast-uri@4.1.1/node_modules/fast-uri/index.js
+var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, normalizeQueryFragmentEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils$2();
+	const { SCHEMES, getSchemeHandler } = require_schemes();
+	/**
+	* @template {import('./types/index').URIComponent|string} T
+	* @param {T} uri
+	* @param {import('./types/index').Options} [options]
+	* @returns {T}
+	*/
+	function normalize(uri, options) {
+		if (typeof uri === "string") uri = normalizeString(uri, options);
+		else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
+		return uri;
+	}
+	/**
+	* @param {string} baseURI
+	* @param {string} relativeURI
+	* @param {import('./types/index').Options} [options]
+	* @returns {string}
+	*/
+	function resolve(baseURI, relativeURI, options) {
+		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
+		const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+		schemelessOptions.skipEscape = true;
+		return serialize(resolved, schemelessOptions);
+	}
+	/**
+	* @param {import ('./types/index').URIComponent} base
+	* @param {import ('./types/index').URIComponent} relative
+	* @param {import('./types/index').Options} [options]
+	* @param {boolean} [skipNormalization=false]
+	* @returns {import ('./types/index').URIComponent}
+	*/
+	function resolveComponent(base, relative, options, skipNormalization) {
+		/** @type {import('./types/index').URIComponent} */
+		const target = {};
+		if (!skipNormalization) {
+			base = parse(serialize(base, options), options);
+			relative = parse(serialize(relative, options), options);
+		}
+		options = options || {};
+		if (!options.tolerant && relative.scheme) {
+			target.scheme = relative.scheme;
+			target.userinfo = relative.userinfo;
+			target.host = relative.host;
+			target.port = relative.port;
+			target.path = removeDotSegments(relative.path || "");
+			target.query = relative.query;
+		} else {
+			if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+				target.userinfo = relative.userinfo;
+				target.host = relative.host;
+				target.port = relative.port;
+				target.path = removeDotSegments(relative.path || "");
+				target.query = relative.query;
+			} else {
+				if (!relative.path) {
+					target.path = base.path;
+					if (relative.query !== void 0) target.query = relative.query;
+					else target.query = base.query;
+				} else {
+					if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
+					else {
+						if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
+						else if (!base.path) target.path = relative.path;
+						else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+						target.path = removeDotSegments(target.path);
+					}
+					target.query = relative.query;
+				}
+				target.userinfo = base.userinfo;
+				target.host = base.host;
+				target.port = base.port;
+			}
+			target.scheme = base.scheme;
+		}
+		target.fragment = relative.fragment;
+		return target;
+	}
+	/**
+	* @param {import ('./types/index').URIComponent|string} uriA
+	* @param {import ('./types/index').URIComponent|string} uriB
+	* @param {import ('./types/index').Options} options
+	* @returns {boolean}
+	*/
+	function equal(uriA, uriB, options) {
+		const normalizedA = normalizeComparableURI(uriA, options);
+		const normalizedB = normalizeComparableURI(uriB, options);
+		return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+	}
+	/**
+	* @param {Readonly<import('./types/index').URIComponent>} cmpts
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string}
+	*/
+	function serialize(cmpts, opts) {
+		const component = {
+			host: cmpts.host,
+			scheme: cmpts.scheme,
+			userinfo: cmpts.userinfo,
+			port: cmpts.port,
+			path: cmpts.path,
+			query: cmpts.query,
+			nid: cmpts.nid,
+			nss: cmpts.nss,
+			uuid: cmpts.uuid,
+			fragment: cmpts.fragment,
+			reference: cmpts.reference,
+			resourceName: cmpts.resourceName,
+			secure: cmpts.secure,
+			error: ""
+		};
+		const options = Object.assign({}, opts);
+		const uriTokens = [];
+		const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
+		if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+		if (component.path !== void 0) if (!options.skipEscape) {
+			component.path = escapePreservingEscapes(component.path);
+			if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
+		} else component.path = normalizePercentEncoding(component.path);
+		if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
+		const authority = recomposeAuthority(component);
+		if (authority !== void 0) {
+			if (options.reference !== "suffix") uriTokens.push("//");
+			uriTokens.push(authority);
+			if (component.path && component.path[0] !== "/") uriTokens.push("/");
+		}
+		if (component.path !== void 0) {
+			let s = component.path;
+			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
+			if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
+			uriTokens.push(s);
+		}
+		if (component.query !== void 0) uriTokens.push("?", component.query);
+		if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
+		return uriTokens.join("");
+	}
+	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {RegExpMatchArray} matches
+	* @returns {string|undefined}
+	*/
+	function getParseError(parsed, matches) {
+		if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") return "URI path must start with \"/\" when authority is present.";
+		if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) return "URI port is malformed.";
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean }}
+	*/
+	function parseWithStatus(uri, opts) {
+		const options = Object.assign({}, opts);
+		/** @type {import('./types/index').URIComponent} */
+		const parsed = {
+			scheme: void 0,
+			userinfo: void 0,
+			host: "",
+			port: void 0,
+			path: "",
+			query: void 0,
+			fragment: void 0
+		};
+		let malformedAuthorityOrPort = false;
+		let isIP = false;
+		if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
+		else uri = "//" + uri;
+		const authorityMatch = uri.match(AUTHORITY_PREFIX);
+		if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+			parsed.error = "URI authority must not contain a literal backslash.";
+			malformedAuthorityOrPort = true;
+		}
+		const matches = uri.match(URI_PARSE);
+		if (matches) {
+			parsed.scheme = matches[1] === void 0 ? void 0 : matches[1].toLowerCase();
+			parsed.userinfo = matches[3];
+			parsed.host = matches[4];
+			parsed.port = parseInt(matches[5], 10);
+			parsed.path = matches[6] || "";
+			parsed.query = matches[7];
+			parsed.fragment = matches[8];
+			if (isNaN(parsed.port)) parsed.port = matches[5];
+			const parseError = getParseError(parsed, matches);
+			if (parseError !== void 0) {
+				parsed.error = parsed.error || parseError;
+				malformedAuthorityOrPort = true;
+			}
+			if (parsed.host) if (isIPv4(parsed.host) === false) {
+				const ipv6result = normalizeIPv6(parsed.host);
+				parsed.host = ipv6result.host.toLowerCase();
+				isIP = ipv6result.isIPV6;
+			} else isIP = true;
+			if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
+			else if (parsed.scheme === void 0) parsed.reference = "relative";
+			else if (parsed.fragment === void 0) parsed.reference = "absolute";
+			else parsed.reference = "uri";
+			if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
+			const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
+			if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+				if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
+					parsed.host = new URL("http://" + parsed.host).hostname;
+				} catch (e) {
+					parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+				}
+			}
+			if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
+				if (uri.indexOf("%") !== -1) {
+					if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
+					if (parsed.host !== void 0) parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+				}
+				if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
+				if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+				if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
+			}
+			if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
+		} else parsed.error = parsed.error || "URI can not be parsed.";
+		return {
+			parsed,
+			malformedAuthorityOrPort
+		};
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns
+	*/
+	function parse(uri, opts) {
+		return parseWithStatus(uri, opts).parsed;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string}
+	*/
+	function normalizeString(uri, opts) {
+		return normalizeStringWithStatus(uri, opts).normalized;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {{ normalized: string, malformedAuthorityOrPort: boolean }}
+	*/
+	function normalizeStringWithStatus(uri, opts) {
+		const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+		return {
+			normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+			malformedAuthorityOrPort
+		};
+	}
+	/**
+	* @param {import ('./types/index').URIComponent|string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string|undefined}
+	*/
+	function normalizeComparableURI(uri, opts) {
+		if (typeof uri === "string") {
+			const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+			return malformedAuthorityOrPort ? void 0 : normalized;
+		}
+		if (typeof uri === "object") return serialize(uri, opts);
+	}
+	const fastUri = {
+		SCHEMES,
+		normalize,
+		resolve,
+		resolveComponent,
+		equal,
+		serialize,
+		parse
+	};
+	module.exports = fastUri;
+	module.exports.default = fastUri;
+	module.exports.fastUri = fastUri;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/validator.js
 var require_validator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const Ajv = require_ajv();
 	const fastUri = require_fast_uri();
@@ -95236,7 +96166,7 @@ var require_validator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/location.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/location.js
 var require_location = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = class Location {
 		constructor(schema, schemaId, jsonPointer = "#") {
@@ -95253,7 +96183,7 @@ var require_location = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/schema-validator.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/schema-validator.js
 var require_schema_validator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = validate10;
 	module.exports.default = validate10;
@@ -97046,7 +97976,7 @@ var require_merge_json_schemas = /* @__PURE__ */ __commonJSMin(((exports, module
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/merge-schemas.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/merge-schemas.js
 var require_merge_schemas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { mergeSchemas: _mergeSchemas } = require_merge_json_schemas();
 	function mergeSchemas(schemas) {
@@ -97055,7 +97985,7 @@ var require_merge_schemas = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	module.exports = mergeSchemas;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/lib/standalone.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/lib/standalone.js
 var require_standalone$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function buildStandaloneCode(contextFunc, context, serializer, validator) {
 		let ajvDependencyCode = "";
@@ -97083,7 +98013,7 @@ var require_standalone$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.0/node_modules/fast-json-stringify/index.js
+//#region ../../node_modules/.pnpm/fast-json-stringify@7.0.1/node_modules/fast-json-stringify/index.js
 var require_fast_json_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { RefResolver } = require_json_schema_ref_resolver();
 	const Serializer = require_serializer$1();
@@ -97091,7 +98021,6 @@ var require_fast_json_stringify = /* @__PURE__ */ __commonJSMin(((exports, modul
 	const Location = require_location();
 	const validate = require_schema_validator();
 	const mergeSchemas = require_merge_schemas();
-	const SINGLE_TICK = /'/g;
 	let largeArraySize = 2e4;
 	let largeArrayMechanism = "default";
 	const serializerFns = `
@@ -97340,7 +98269,7 @@ const asInteger = serializer.asInteger.bind(serializer)
 		code += "json += JSON_STR_BEGIN_OBJECT\n";
 		const localUid = context.uid++;
 		let addComma = "";
-		if (requiredProperties.length > 0) {
+		if (propertiesKeys.length > 0 && requiredProperties.includes(propertiesKeys[0])) {
 			for (let i = 0; i < propertiesKeys.length; i++) {
 				const key = propertiesKeys[i];
 				const propertyLocation = propertiesLocation.getPropertyLocation(key);
@@ -97832,7 +98761,7 @@ const asInteger = serializer.asInteger.bind(serializer)
         json += JSON_STR_NULL
       } else {
     `;
-		code += `json += '${JSON.stringify(schema.const).replace(SINGLE_TICK, "\\'")}'`;
+		code += `json += ${JSON.stringify(JSON.stringify(schema.const))}`;
 		if (hasNullType) code += `
       }
     `;
@@ -105177,7 +106106,7 @@ var require_light_my_request = /* @__PURE__ */ __commonJSMin(((exports, module)
 //#region ../../node_modules/.pnpm/fastify@5.10.0/node_modules/fastify/fastify.js
 var require_fastify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const VERSION = "5.10.0";
-	const Avvio = require_boot();
+	const Avvio = require_avvio();
 	const http$1 = __require$1("node:http");
 	const diagnostics = __require$1("node:diagnostics_channel");
 	let lightMyRequest;