dsh-plugin-shop 0.8.0-beta.1 → 0.8.0-beta.2

package/lib/client.js

@@ -4,6 +4,9 @@ window.__ModuleLoader__.load({
 		var module = { exports: {} };
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region \0rolldown/runtime.js
+		var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+		//#endregion
 		let react = require("react");
 		let react_jsx_runtime = require("react/jsx-runtime");
 		//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -2842,7 +2845,7 @@ window.__ModuleLoader__.load({
 				external: params?.external ?? void 0
 			};
 		}
-		function process(schema, ctx, _params = {
+		function process$1(schema, ctx, _params = {
 			path: [],
 			schemaPath: []
 		}) {
@@ -2879,7 +2882,7 @@ window.__ModuleLoader__.load({
 				const parent = schema._zod.parent;
 				if (parent) {
 					if (!result.ref) result.ref = parent;
-					process(parent, ctx, params);
+					process$1(parent, ctx, params);
 					ctx.seen.get(parent).isParent = true;
 				}
 			}
@@ -3101,7 +3104,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				...params,
 				processors
 			});
-			process(schema, ctx);
+			process$1(schema, ctx);
 			extractDefs(ctx, schema);
 			return finalize(ctx, schema);
 		};
@@ -3113,7 +3116,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				io,
 				processors
 			});
-			process(schema, ctx);
+			process$1(schema, ctx);
 			extractDefs(ctx, schema);
 			return finalize(ctx, schema);
 		};
@@ -3220,7 +3223,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			if (typeof minimum === "number") json.minItems = minimum;
 			if (typeof maximum === "number") json.maxItems = maximum;
 			json.type = "array";
-			json.items = process(def.element, ctx, {
+			json.items = process$1(def.element, ctx, {
 				...params,
 				path: [...params.path, "items"]
 			});
@@ -3231,7 +3234,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			json.type = "object";
 			json.properties = {};
 			const shape = def.shape;
-			for (const key in shape) json.properties[key] = process(shape[key], ctx, {
+			for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
 				...params,
 				path: [
 					...params.path,
@@ -3249,7 +3252,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 			else if (!def.catchall) {
 				if (ctx.io === "output") json.additionalProperties = false;
-			} else if (def.catchall) json.additionalProperties = process(def.catchall, ctx, {
+			} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
 				...params,
 				path: [...params.path, "additionalProperties"]
 			});
@@ -3257,7 +3260,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		const unionProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
 			const isExclusive = def.inclusive === false;
-			const options = def.options.map((x, i) => process(x, ctx, {
+			const options = def.options.map((x, i) => process$1(x, ctx, {
 				...params,
 				path: [
 					...params.path,
@@ -3270,7 +3273,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		};
 		const intersectionProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			const a = process(def.left, ctx, {
+			const a = process$1(def.left, ctx, {
 				...params,
 				path: [
 					...params.path,
@@ -3278,7 +3281,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					0
 				]
 			});
-			const b = process(def.right, ctx, {
+			const b = process$1(def.right, ctx, {
 				...params,
 				path: [
 					...params.path,
@@ -3296,7 +3299,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const keyType = def.keyType;
 			const patterns = keyType._zod.bag?.patterns;
 			if (def.mode === "loose" && patterns && patterns.size > 0) {
-				const valueSchema = process(def.valueType, ctx, {
+				const valueSchema = process$1(def.valueType, ctx, {
 					...params,
 					path: [
 						...params.path,
@@ -3307,11 +3310,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				json.patternProperties = {};
 				for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
 			} else {
-				if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process(def.keyType, ctx, {
+				if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$1(def.keyType, ctx, {
 					...params,
 					path: [...params.path, "propertyNames"]
 				});
-				json.additionalProperties = process(def.valueType, ctx, {
+				json.additionalProperties = process$1(def.valueType, ctx, {
 					...params,
 					path: [...params.path, "additionalProperties"]
 				});
@@ -3324,7 +3327,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		};
 		const nullableProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			const inner = process(def.innerType, ctx, params);
+			const inner = process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			if (ctx.target === "openapi-3.0") {
 				seen.ref = def.innerType;
@@ -3333,27 +3336,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		};
 		const nonoptionalProcessor = (schema, ctx, _json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 		};
 		const defaultProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 			json.default = JSON.parse(JSON.stringify(def.defaultValue));
 		};
 		const prefaultProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 			if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 		};
 		const catchProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 			let catchValue;
@@ -3368,20 +3371,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const def = schema._zod.def;
 			const inIsTransform = def.in._zod.traits.has("$ZodTransform");
 			const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-			process(innerType, ctx, params);
+			process$1(innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = innerType;
 		};
 		const readonlyProcessor = (schema, ctx, json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 			json.readOnly = true;
 		};
 		const optionalProcessor = (schema, ctx, _json, params) => {
 			const def = schema._zod.def;
-			process(def.innerType, ctx, params);
+			process$1(def.innerType, ctx, params);
 			const seen = ctx.seen.get(schema);
 			seen.ref = def.innerType;
 		};
@@ -4332,6 +4335,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"outdated": boolean(),
 			"enabled": boolean()
 		}));
+		const dsh_plugin_shop_shop_installedSpecs_result$schema = union([literal(null), record(string(), string())]);
 		const dsh_plugin_shop_shop_installStart_parameter_0$schema = object({
 			"name": string(),
 			"version": string(),
@@ -4359,7 +4363,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				literal("version-mismatch"),
 				literal("needs-acknowledgement"),
 				literal("tarball-integrity"),
-				literal("ambiguous-identity")
+				literal("ambiguous-identity"),
+				literal("name-taken")
 			]),
 			"detail": string()
 		})]);
@@ -4448,7 +4453,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 678,
+						"line": 733,
 						"column": 9
 					}
 				},
@@ -4466,7 +4471,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 863,
+						"line": 966,
+						"column": 9
+					}
+				},
+				{
+					id: "dsh-plugin-shop#shop/installedSpecs",
+					service: "shop",
+					namespace: "shop",
+					method: "installedSpecs",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-plugin-shop#shop/installedSpecs:result",
+						schema: dsh_plugin_shop_shop_installedSpecs_result$schema
+					},
+					sourceLocation: {
+						"file": "packages/dsh-plugin-shop/src/host/index.ts",
+						"line": 957,
 						"column": 9
 					}
 				},
@@ -4494,7 +4517,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 726,
+						"line": 781,
 						"column": 9
 					}
 				},
@@ -4521,7 +4544,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 852,
+						"line": 933,
 						"column": 3
 					}
 				},
@@ -4539,7 +4562,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 1021,
+						"line": 1124,
 						"column": 9
 					}
 				},
@@ -4566,7 +4589,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 535,
+						"line": 590,
 						"column": 9
 					}
 				},
@@ -4594,7 +4617,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 956,
+						"line": 1059,
 						"column": 9
 					}
 				},
@@ -4621,7 +4644,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 1106,
+						"line": 1209,
 						"column": 9
 					}
 				},
@@ -4639,7 +4662,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					},
 					sourceLocation: {
 						"file": "packages/dsh-plugin-shop/src/host/index.ts",
-						"line": 1089,
+						"line": 1192,
 						"column": 9
 					}
 				}
@@ -4720,15 +4743,1489 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return hasPlugin || SHOP_KEYWORDS.includes(segments.at(-1));
 		}
 		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+		var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			module.exports = {
+				MAX_LENGTH: 256,
+				MAX_SAFE_COMPONENT_LENGTH: 16,
+				MAX_SAFE_BUILD_LENGTH: 250,
+				MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 
+				/* istanbul ignore next */ 9007199254740991,
+				RELEASE_TYPES: [
+					"major",
+					"premajor",
+					"minor",
+					"preminor",
+					"patch",
+					"prepatch",
+					"prerelease"
+				],
+				SEMVER_SPEC_VERSION: "2.0.0",
+				FLAG_INCLUDE_PRERELEASE: 1,
+				FLAG_LOOSE: 2
+			};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
+		var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
+		var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
+			const debug = require_debug();
+			exports = module.exports = {};
+			const re = exports.re = [];
+			const safeRe = exports.safeRe = [];
+			const src = exports.src = [];
+			const safeSrc = exports.safeSrc = [];
+			const t = exports.t = {};
+			let R = 0;
+			const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+			const safeRegexReplacements = [
+				["\\s", 1],
+				["\\d", MAX_LENGTH],
+				[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+			];
+			const makeSafeRegex = (value) => {
+				for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+				return value;
+			};
+			const createToken = (name, value, isGlobal) => {
+				const safe = makeSafeRegex(value);
+				const index = R++;
+				debug(name, index, value);
+				t[name] = index;
+				src[index] = value;
+				safeSrc[index] = safe;
+				re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+				safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+			};
+			createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+			createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+			createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+			createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+			createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+			createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+			createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+			createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+			createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+			createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+			createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+			createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+			createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+			createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+			createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+			createToken("GTLT", "((?:<|>)?=?)");
+			createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+			createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+			createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+			createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+			createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+			createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+			createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+			createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+			createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+			createToken("COERCERTL", src[t.COERCE], true);
+			createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+			createToken("LONETILDE", "(?:~>?)");
+			createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+			exports.tildeTrimReplace = "$1~";
+			createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+			createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+			createToken("LONECARET", "(?:\\^)");
+			createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+			exports.caretTrimReplace = "$1^";
+			createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+			createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+			createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+			createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+			createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+			exports.comparatorTrimReplace = "$1$2$3";
+			createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+			createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+			createToken("STAR", "(<|>)?=?\\s*\\*");
+			createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+			createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
+		var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const looseOption = Object.freeze({ loose: true });
+			const emptyOpts = Object.freeze({});
+			const parseOptions = (options) => {
+				if (!options) return emptyOpts;
+				if (typeof options !== "object") return looseOption;
+				return options;
+			};
+			module.exports = parseOptions;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
+		var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const numeric = /^[0-9]+$/;
+			const compareIdentifiers = (a, b) => {
+				if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+				const anum = numeric.test(a);
+				const bnum = numeric.test(b);
+				if (anum && bnum) {
+					a = +a;
+					b = +b;
+				}
+				return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+			};
+			const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+			module.exports = {
+				compareIdentifiers,
+				rcompareIdentifiers
+			};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
+		var require_semver$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const debug = require_debug();
+			const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+			const { safeRe: re, t } = require_re();
+			const parseOptions = require_parse_options();
+			const { compareIdentifiers } = require_identifiers();
+			const isPrereleaseIdentifier = (prerelease, identifier) => {
+				const identifiers = identifier.split(".");
+				if (identifiers.length > prerelease.length) return false;
+				for (let i = 0; i < identifiers.length; i++) if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) return false;
+				return true;
+			};
+			module.exports = class SemVer {
+				constructor(version, options) {
+					options = parseOptions(options);
+					if (version instanceof SemVer) {
+						if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
+						else version = version.version;
+					} else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+					if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+					debug("SemVer", version, options);
+					this.options = options;
+					this.loose = !!options.loose;
+					this.includePrerelease = !!options.includePrerelease;
+					const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+					if (!m) throw new TypeError(`Invalid Version: ${version}`);
+					this.raw = version;
+					this.major = +m[1];
+					this.minor = +m[2];
+					this.patch = +m[3];
+					if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
+					if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
+					if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
+					if (!m[4]) this.prerelease = [];
+					else this.prerelease = m[4].split(".").map((id) => {
+						if (/^[0-9]+$/.test(id)) {
+							const num = +id;
+							if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+						}
+						return id;
+					});
+					this.build = m[5] ? m[5].split(".") : [];
+					this.format();
+				}
+				format() {
+					this.version = `${this.major}.${this.minor}.${this.patch}`;
+					if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+					return this.version;
+				}
+				toString() {
+					return this.version;
+				}
+				compare(other) {
+					debug("SemVer.compare", this.version, this.options, other);
+					if (!(other instanceof SemVer)) {
+						if (typeof other === "string" && other === this.version) return 0;
+						other = new SemVer(other, this.options);
+					}
+					if (other.version === this.version) return 0;
+					return this.compareMain(other) || this.comparePre(other);
+				}
+				compareMain(other) {
+					if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+					if (this.major < other.major) return -1;
+					if (this.major > other.major) return 1;
+					if (this.minor < other.minor) return -1;
+					if (this.minor > other.minor) return 1;
+					if (this.patch < other.patch) return -1;
+					if (this.patch > other.patch) return 1;
+					return 0;
+				}
+				comparePre(other) {
+					if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+					if (this.prerelease.length && !other.prerelease.length) return -1;
+					else if (!this.prerelease.length && other.prerelease.length) return 1;
+					else if (!this.prerelease.length && !other.prerelease.length) return 0;
+					let i = 0;
+					do {
+						const a = this.prerelease[i];
+						const b = other.prerelease[i];
+						debug("prerelease compare", i, a, b);
+						if (a === void 0 && b === void 0) return 0;
+						else if (b === void 0) return 1;
+						else if (a === void 0) return -1;
+						else if (a === b) continue;
+						else return compareIdentifiers(a, b);
+					} while (++i);
+				}
+				compareBuild(other) {
+					if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+					let i = 0;
+					do {
+						const a = this.build[i];
+						const b = other.build[i];
+						debug("build compare", i, a, b);
+						if (a === void 0 && b === void 0) return 0;
+						else if (b === void 0) return 1;
+						else if (a === void 0) return -1;
+						else if (a === b) continue;
+						else return compareIdentifiers(a, b);
+					} while (++i);
+				}
+				inc(release, identifier, identifierBase) {
+					if (release.startsWith("pre")) {
+						if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
+						if (identifier) {
+							const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+							if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
+						}
+					}
+					switch (release) {
+						case "premajor":
+							this.prerelease.length = 0;
+							this.patch = 0;
+							this.minor = 0;
+							this.major++;
+							this.inc("pre", identifier, identifierBase);
+							break;
+						case "preminor":
+							this.prerelease.length = 0;
+							this.patch = 0;
+							this.minor++;
+							this.inc("pre", identifier, identifierBase);
+							break;
+						case "prepatch":
+							this.prerelease.length = 0;
+							this.inc("patch", identifier, identifierBase);
+							this.inc("pre", identifier, identifierBase);
+							break;
+						case "prerelease":
+							if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
+							this.inc("pre", identifier, identifierBase);
+							break;
+						case "release":
+							if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
+							this.prerelease.length = 0;
+							break;
+						case "major":
+							if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+							this.minor = 0;
+							this.patch = 0;
+							this.prerelease = [];
+							break;
+						case "minor":
+							if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+							this.patch = 0;
+							this.prerelease = [];
+							break;
+						case "patch":
+							if (this.prerelease.length === 0) this.patch++;
+							this.prerelease = [];
+							break;
+						case "pre": {
+							const base = Number(identifierBase) ? 1 : 0;
+							if (this.prerelease.length === 0) this.prerelease = [base];
+							else {
+								let i = this.prerelease.length;
+								while (--i >= 0) if (typeof this.prerelease[i] === "number") {
+									this.prerelease[i]++;
+									i = -2;
+								}
+								if (i === -1) {
+									if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
+									this.prerelease.push(base);
+								}
+							}
+							if (identifier) {
+								let prerelease = [identifier, base];
+								if (identifierBase === false) prerelease = [identifier];
+								if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+									const prereleaseBase = this.prerelease[identifier.split(".").length];
+									if (isNaN(prereleaseBase)) this.prerelease = prerelease;
+								} else this.prerelease = prerelease;
+							}
+							break;
+						}
+						default: throw new Error(`invalid increment argument: ${release}`);
+					}
+					this.raw = this.format();
+					if (this.build.length) this.raw += `+${this.build.join(".")}`;
+					return this;
+				}
+			};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
+		var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const parse = (version, options, throwErrors = false) => {
+				if (version instanceof SemVer) return version;
+				try {
+					return new SemVer(version, options);
+				} catch (er) {
+					if (!throwErrors) return null;
+					throw er;
+				}
+			};
+			module.exports = parse;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
+		var require_valid$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const parse = require_parse();
+			const valid = (version, options) => {
+				const v = parse(version, options);
+				return v ? v.version : null;
+			};
+			module.exports = valid;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js
+		var require_clean = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const parse = require_parse();
+			const clean = (version, options) => {
+				const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+				return s ? s.version : null;
+			};
+			module.exports = clean;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/inc.js
+		var require_inc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const inc = (version, release, options, identifier, identifierBase) => {
+				if (typeof options === "string") {
+					identifierBase = identifier;
+					identifier = options;
+					options = void 0;
+				}
+				try {
+					return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
+				} catch (er) {
+					return null;
+				}
+			};
+			module.exports = inc;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/diff.js
+		var require_diff = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const parse = require_parse();
+			const diff = (version1, version2) => {
+				const v1 = parse(version1, null, true);
+				const v2 = parse(version2, null, true);
+				const comparison = v1.compare(v2);
+				if (comparison === 0) return null;
+				const v1Higher = comparison > 0;
+				const highVersion = v1Higher ? v1 : v2;
+				const lowVersion = v1Higher ? v2 : v1;
+				const highHasPre = !!highVersion.prerelease.length;
+				if (!!lowVersion.prerelease.length && !highHasPre) {
+					if (!lowVersion.patch && !lowVersion.minor) return "major";
+					if (lowVersion.compareMain(highVersion) === 0) {
+						if (lowVersion.minor && !lowVersion.patch) return "minor";
+						return "patch";
+					}
+				}
+				const prefix = highHasPre ? "pre" : "";
+				if (v1.major !== v2.major) return prefix + "major";
+				if (v1.minor !== v2.minor) return prefix + "minor";
+				if (v1.patch !== v2.patch) return prefix + "patch";
+				return "prerelease";
+			};
+			module.exports = diff;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/major.js
+		var require_major = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const major = (a, loose) => new SemVer(a, loose).major;
+			module.exports = major;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/minor.js
+		var require_minor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const minor = (a, loose) => new SemVer(a, loose).minor;
+			module.exports = minor;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/patch.js
+		var require_patch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const patch = (a, loose) => new SemVer(a, loose).patch;
+			module.exports = patch;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js
+		var require_prerelease = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const parse = require_parse();
+			const prerelease = (version, options) => {
+				const parsed = parse(version, options);
+				return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+			};
+			module.exports = prerelease;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
+		var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+			module.exports = compare;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js
+		var require_rcompare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const rcompare = (a, b, loose) => compare(b, a, loose);
+			module.exports = rcompare;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-loose.js
+		var require_compare_loose = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const compareLoose = (a, b) => compare(a, b, true);
+			module.exports = compareLoose;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-build.js
+		var require_compare_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const compareBuild = (a, b, loose) => {
+				const versionA = new SemVer(a, loose);
+				const versionB = new SemVer(b, loose);
+				return versionA.compare(versionB) || versionA.compareBuild(versionB);
+			};
+			module.exports = compareBuild;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/sort.js
+		var require_sort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compareBuild = require_compare_build();
+			const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+			module.exports = sort;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rsort.js
+		var require_rsort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compareBuild = require_compare_build();
+			const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+			module.exports = rsort;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
+		var require_gt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const gt = (a, b, loose) => compare(a, b, loose) > 0;
+			module.exports = gt;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
+		var require_lt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const lt = (a, b, loose) => compare(a, b, loose) < 0;
+			module.exports = lt;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
+		var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const eq = (a, b, loose) => compare(a, b, loose) === 0;
+			module.exports = eq;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
+		var require_neq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const neq = (a, b, loose) => compare(a, b, loose) !== 0;
+			module.exports = neq;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
+		var require_gte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+			module.exports = gte;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
+		var require_lte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const compare = require_compare();
+			const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+			module.exports = lte;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
+		var require_cmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const eq = require_eq();
+			const neq = require_neq();
+			const gt = require_gt();
+			const gte = require_gte();
+			const lt = require_lt();
+			const lte = require_lte();
+			const cmp = (a, op, b, loose) => {
+				switch (op) {
+					case "===":
+						if (typeof a === "object") a = a.version;
+						if (typeof b === "object") b = b.version;
+						return a === b;
+					case "!==":
+						if (typeof a === "object") a = a.version;
+						if (typeof b === "object") b = b.version;
+						return a !== b;
+					case "":
+					case "=":
+					case "==": return eq(a, b, loose);
+					case "!=": return neq(a, b, loose);
+					case ">": return gt(a, b, loose);
+					case ">=": return gte(a, b, loose);
+					case "<": return lt(a, b, loose);
+					case "<=": return lte(a, b, loose);
+					default: throw new TypeError(`Invalid operator: ${op}`);
+				}
+			};
+			module.exports = cmp;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/coerce.js
+		var require_coerce = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const parse = require_parse();
+			const { safeRe: re, t } = require_re();
+			const coerce = (version, options) => {
+				if (version instanceof SemVer) return version;
+				if (typeof version === "number") version = String(version);
+				if (typeof version !== "string") return null;
+				options = options || {};
+				let match = null;
+				if (!options.rtl) match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+				else {
+					const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+					let next;
+					while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+						if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+						coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+					}
+					coerceRtlRegex.lastIndex = -1;
+				}
+				if (match === null) return null;
+				const major = match[2];
+				const minor = match[3] || "0";
+				const patch = match[4] || "0";
+				const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+				const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+				return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+			};
+			module.exports = coerce;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/truncate.js
+		var require_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const parse = require_parse();
+			const constants = require_constants();
+			const SemVer = require_semver$1();
+			const truncate = (version, truncation, options) => {
+				if (!constants.RELEASE_TYPES.includes(truncation)) return null;
+				const clonedVersion = cloneInputVersion(version, options);
+				return clonedVersion && doTruncation(clonedVersion, truncation);
+			};
+			const cloneInputVersion = (version, options) => {
+				const versionStringToParse = version instanceof SemVer ? version.version : version;
+				return parse(versionStringToParse, options);
+			};
+			const doTruncation = (version, truncation) => {
+				if (isPrerelease(truncation)) return version.version;
+				version.prerelease = [];
+				switch (truncation) {
+					case "major":
+						version.minor = 0;
+						version.patch = 0;
+						break;
+					case "minor": version.patch = 0;
+				}
+				return version.format();
+			};
+			const isPrerelease = (type) => {
+				return type.startsWith("pre");
+			};
+			module.exports = truncate;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
+		var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			var LRUCache = class {
+				constructor() {
+					this.max = 1e3;
+					this.map = /* @__PURE__ */ new Map();
+				}
+				get(key) {
+					const value = this.map.get(key);
+					if (value === void 0) return;
+					else {
+						this.map.delete(key);
+						this.map.set(key, value);
+						return value;
+					}
+				}
+				delete(key) {
+					return this.map.delete(key);
+				}
+				set(key, value) {
+					if (!this.delete(key) && value !== void 0) {
+						if (this.map.size >= this.max) {
+							const firstKey = this.map.keys().next().value;
+							this.delete(firstKey);
+						}
+						this.map.set(key, value);
+					}
+					return this;
+				}
+			};
+			module.exports = LRUCache;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
+		var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SPACE_CHARACTERS = /\s+/g;
+			module.exports = class Range {
+				constructor(range, options) {
+					options = parseOptions(options);
+					if (range instanceof Range) {
+						if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+						else return new Range(range.raw, options);
+					}
+					if (range instanceof Comparator) {
+						this.raw = range.value;
+						this.set = [[range]];
+						this.formatted = void 0;
+						return this;
+					}
+					this.options = options;
+					this.loose = !!options.loose;
+					this.includePrerelease = !!options.includePrerelease;
+					this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+					this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+					if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+					if (this.set.length > 1) {
+						const first = this.set[0];
+						this.set = this.set.filter((c) => !isNullSet(c[0]));
+						if (this.set.length === 0) this.set = [first];
+						else if (this.set.length > 1) {
+							for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
+								this.set = [c];
+								break;
+							}
+						}
+					}
+					this.formatted = void 0;
+				}
+				get range() {
+					if (this.formatted === void 0) {
+						this.formatted = "";
+						for (let i = 0; i < this.set.length; i++) {
+							if (i > 0) this.formatted += "||";
+							const comps = this.set[i];
+							for (let k = 0; k < comps.length; k++) {
+								if (k > 0) this.formatted += " ";
+								this.formatted += comps[k].toString().trim();
+							}
+						}
+					}
+					return this.formatted;
+				}
+				format() {
+					return this.range;
+				}
+				toString() {
+					return this.range;
+				}
+				parseRange(range) {
+					range = range.replace(BUILDSTRIPRE, "");
+					const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
+					const cached = cache.get(memoKey);
+					if (cached) return cached;
+					const loose = this.options.loose;
+					const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+					range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+					debug("hyphen replace", range);
+					range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+					debug("comparator trim", range);
+					range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+					debug("tilde trim", range);
+					range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+					debug("caret trim", range);
+					let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+					if (loose) rangeList = rangeList.filter((comp) => {
+						debug("loose invalid filter", comp, this.options);
+						return !!comp.match(re[t.COMPARATORLOOSE]);
+					});
+					debug("range list", rangeList);
+					const rangeMap = /* @__PURE__ */ new Map();
+					const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+					for (const comp of comparators) {
+						if (isNullSet(comp)) return [comp];
+						rangeMap.set(comp.value, comp);
+					}
+					if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+					const result = [...rangeMap.values()];
+					cache.set(memoKey, result);
+					return result;
+				}
+				intersects(range, options) {
+					if (!(range instanceof Range)) throw new TypeError("a Range is required");
+					return this.set.some((thisComparators) => {
+						return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+							return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+								return rangeComparators.every((rangeComparator) => {
+									return thisComparator.intersects(rangeComparator, options);
+								});
+							});
+						});
+					});
+				}
+				test(version) {
+					if (!version) return false;
+					if (typeof version === "string") try {
+						version = new SemVer(version, this.options);
+					} catch (er) {
+						return false;
+					}
+					for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
+					return false;
+				}
+			};
+			const cache = new (require_lrucache())();
+			const parseOptions = require_parse_options();
+			const Comparator = require_comparator();
+			const debug = require_debug();
+			const SemVer = require_semver$1();
+			const { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+			const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+			const BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
+			const isNullSet = (c) => c.value === "<0.0.0-0";
+			const isAny = (c) => c.value === "";
+			const isSatisfiable = (comparators, options) => {
+				let result = true;
+				const remainingComparators = comparators.slice();
+				let testComparator = remainingComparators.pop();
+				while (result && remainingComparators.length) {
+					result = remainingComparators.every((otherComparator) => {
+						return testComparator.intersects(otherComparator, options);
+					});
+					testComparator = remainingComparators.pop();
+				}
+				return result;
+			};
+			const parseComparator = (comp, options) => {
+				comp = comp.replace(re[t.BUILD], "");
+				debug("comp", comp, options);
+				comp = replaceCarets(comp, options);
+				debug("caret", comp);
+				comp = replaceTildes(comp, options);
+				debug("tildes", comp);
+				comp = replaceXRanges(comp, options);
+				debug("xrange", comp);
+				comp = replaceStars(comp, options);
+				debug("stars", comp);
+				return comp;
+			};
+			const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+			const invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
+			const replaceTildes = (comp, options) => {
+				return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+			};
+			const replaceTilde = (comp, options) => {
+				const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+				const z = options.includePrerelease ? "-0" : "";
+				return comp.replace(r, (_, M, m, p, pr) => {
+					debug("tilde", comp, _, M, m, p, pr);
+					let ret;
+					if (isX(M)) ret = "";
+					else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+					else if (isX(p)) ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+					else if (pr) {
+						debug("replaceTilde pr", pr);
+						ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+					} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+					debug("tilde return", ret);
+					return ret;
+				});
+			};
+			const replaceCarets = (comp, options) => {
+				return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+			};
+			const replaceCaret = (comp, options) => {
+				debug("caret", comp, options);
+				const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+				const z = options.includePrerelease ? "-0" : "";
+				return comp.replace(r, (_, M, m, p, pr) => {
+					debug("caret", comp, _, M, m, p, pr);
+					let ret;
+					if (isX(M)) ret = "";
+					else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+					else if (isX(p)) {
+						if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+						else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+					} else if (pr) {
+						debug("replaceCaret pr", pr);
+						if (M === "0") {
+							if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+							else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+						} else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+					} else {
+						debug("no pr");
+						if (M === "0") {
+							if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+							else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+						} else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+					}
+					debug("caret return", ret);
+					return ret;
+				});
+			};
+			const replaceXRanges = (comp, options) => {
+				debug("replaceXRanges", comp, options);
+				return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+			};
+			const replaceXRange = (comp, options) => {
+				comp = comp.trim();
+				const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+				return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+					debug("xRange", comp, ret, gtlt, M, m, p, pr);
+					if (invalidXRangeOrder(M, m, p)) return comp;
+					const xM = isX(M);
+					const xm = xM || isX(m);
+					const xp = xm || isX(p);
+					const anyX = xp;
+					if (gtlt === "=" && anyX) gtlt = "";
+					pr = options.includePrerelease ? "-0" : "";
+					if (xM) {
+						if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+						else ret = "*";
+					} else if (gtlt && anyX) {
+						if (xm) m = 0;
+						p = 0;
+						if (gtlt === ">") {
+							gtlt = ">=";
+							if (xm) {
+								M = +M + 1;
+								m = 0;
+								p = 0;
+							} else {
+								m = +m + 1;
+								p = 0;
+							}
+						} else if (gtlt === "<=") {
+							gtlt = "<";
+							if (xm) M = +M + 1;
+							else m = +m + 1;
+						}
+						if (gtlt === "<") pr = "-0";
+						ret = `${gtlt + M}.${m}.${p}${pr}`;
+					} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+					else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+					debug("xRange return", ret);
+					return ret;
+				});
+			};
+			const replaceStars = (comp, options) => {
+				debug("replaceStars", comp, options);
+				return comp.trim().replace(re[t.STAR], "");
+			};
+			const replaceGTE0 = (comp, options) => {
+				debug("replaceGTE0", comp, options);
+				return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+			};
+			const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+				if (isX(fM)) from = "";
+				else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+				else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+				else if (fpr) from = `>=${from}`;
+				else from = `>=${from}${incPr ? "-0" : ""}`;
+				if (isX(tM)) to = "";
+				else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
+				else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
+				else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
+				else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
+				else to = `<=${to}`;
+				return `${from} ${to}`.trim();
+			};
+			const testSet = (set, version, options) => {
+				for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
+				if (version.prerelease.length && !options.includePrerelease) {
+					for (let i = 0; i < set.length; i++) {
+						debug(set[i].semver);
+						if (set[i].semver === Comparator.ANY) continue;
+						if (set[i].semver.prerelease.length > 0) {
+							const allowed = set[i].semver;
+							if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+						}
+					}
+					return false;
+				}
+				return true;
+			};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
+		var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const ANY = Symbol("SemVer ANY");
+			module.exports = class Comparator {
+				static get ANY() {
+					return ANY;
+				}
+				constructor(comp, options) {
+					options = parseOptions(options);
+					if (comp instanceof Comparator) {
+						if (comp.loose === !!options.loose) return comp;
+						else comp = comp.value;
+					}
+					comp = comp.trim().split(/\s+/).join(" ");
+					debug("comparator", comp, options);
+					this.options = options;
+					this.loose = !!options.loose;
+					this.parse(comp);
+					if (this.semver === ANY) this.value = "";
+					else this.value = this.operator + this.semver.version;
+					debug("comp", this);
+				}
+				parse(comp) {
+					const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+					const m = comp.match(r);
+					if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+					this.operator = m[1] !== void 0 ? m[1] : "";
+					if (this.operator === "=") this.operator = "";
+					if (!m[2]) this.semver = ANY;
+					else this.semver = new SemVer(m[2], this.options.loose);
+				}
+				toString() {
+					return this.value;
+				}
+				test(version) {
+					debug("Comparator.test", version, this.options.loose);
+					if (this.semver === ANY || version === ANY) return true;
+					if (typeof version === "string") try {
+						version = new SemVer(version, this.options);
+					} catch (er) {
+						return false;
+					}
+					return cmp(version, this.operator, this.semver, this.options);
+				}
+				intersects(comp, options) {
+					if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
+					if (this.operator === "") {
+						if (this.value === "") return true;
+						return new Range(comp.value, options).test(this.value);
+					} else if (comp.operator === "") {
+						if (comp.value === "") return true;
+						return new Range(this.value, options).test(comp.semver);
+					}
+					options = parseOptions(options);
+					if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
+					if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+					if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+					if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+					if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+					if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+					if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+					return false;
+				}
+			};
+			const parseOptions = require_parse_options();
+			const { safeRe: re, t } = require_re();
+			const cmp = require_cmp();
+			const debug = require_debug();
+			const SemVer = require_semver$1();
+			const Range = require_range();
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
+		var require_satisfies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const Range = require_range();
+			const satisfies = (version, range, options) => {
+				try {
+					range = new Range(range, options);
+				} catch (er) {
+					return false;
+				}
+				return range.test(version);
+			};
+			module.exports = satisfies;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/to-comparators.js
+		var require_to_comparators = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const Range = require_range();
+			const toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+			module.exports = toComparators;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/max-satisfying.js
+		var require_max_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const Range = require_range();
+			const maxSatisfying = (versions, range, options) => {
+				let max = null;
+				let maxSV = null;
+				let rangeObj = null;
+				try {
+					rangeObj = new Range(range, options);
+				} catch (er) {
+					return null;
+				}
+				versions.forEach((v) => {
+					if (rangeObj.test(v)) {
+						if (!max || maxSV.compare(v) === -1) {
+							max = v;
+							maxSV = new SemVer(max, options);
+						}
+					}
+				});
+				return max;
+			};
+			module.exports = maxSatisfying;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-satisfying.js
+		var require_min_satisfying = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const Range = require_range();
+			const minSatisfying = (versions, range, options) => {
+				let min = null;
+				let minSV = null;
+				let rangeObj = null;
+				try {
+					rangeObj = new Range(range, options);
+				} catch (er) {
+					return null;
+				}
+				versions.forEach((v) => {
+					if (rangeObj.test(v)) {
+						if (!min || minSV.compare(v) === 1) {
+							min = v;
+							minSV = new SemVer(min, options);
+						}
+					}
+				});
+				return min;
+			};
+			module.exports = minSatisfying;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js
+		var require_min_version = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const Range = require_range();
+			const gt = require_gt();
+			const minVersion = (range, loose) => {
+				range = new Range(range, loose);
+				let minver = new SemVer("0.0.0");
+				if (range.test(minver)) return minver;
+				minver = new SemVer("0.0.0-0");
+				if (range.test(minver)) return minver;
+				minver = null;
+				for (let i = 0; i < range.set.length; ++i) {
+					const comparators = range.set[i];
+					let setMin = null;
+					comparators.forEach((comparator) => {
+						const compver = new SemVer(comparator.semver.version);
+						switch (comparator.operator) {
+							case ">":
+								if (compver.prerelease.length === 0) compver.patch++;
+								else compver.prerelease.push(0);
+								compver.raw = compver.format();
+							case "":
+							case ">=":
+								if (!setMin || gt(compver, setMin)) setMin = compver;
+								break;
+							case "<":
+							case "<=": break;
+							/* istanbul ignore next */
+							default: throw new Error(`Unexpected operation: ${comparator.operator}`);
+						}
+					});
+					if (setMin && (!minver || gt(minver, setMin))) minver = setMin;
+				}
+				if (minver && range.test(minver)) return minver;
+				return null;
+			};
+			module.exports = minVersion;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
+		var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const Range = require_range();
+			const validRange = (range, options) => {
+				try {
+					return new Range(range, options).range || "*";
+				} catch (er) {
+					return null;
+				}
+			};
+			module.exports = validRange;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/outside.js
+		var require_outside = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const SemVer = require_semver$1();
+			const Comparator = require_comparator();
+			const { ANY } = Comparator;
+			const Range = require_range();
+			const satisfies = require_satisfies();
+			const gt = require_gt();
+			const lt = require_lt();
+			const lte = require_lte();
+			const gte = require_gte();
+			const outside = (version, range, hilo, options) => {
+				version = new SemVer(version, options);
+				range = new Range(range, options);
+				let gtfn, ltefn, ltfn, comp, ecomp;
+				switch (hilo) {
+					case ">":
+						gtfn = gt;
+						ltefn = lte;
+						ltfn = lt;
+						comp = ">";
+						ecomp = ">=";
+						break;
+					case "<":
+						gtfn = lt;
+						ltefn = gte;
+						ltfn = gt;
+						comp = "<";
+						ecomp = "<=";
+						break;
+					default: throw new TypeError("Must provide a hilo val of \"<\" or \">\"");
+				}
+				if (satisfies(version, range, options)) return false;
+				for (let i = 0; i < range.set.length; ++i) {
+					const comparators = range.set[i];
+					let high = null;
+					let low = null;
+					comparators.forEach((comparator) => {
+						if (comparator.semver === ANY) comparator = new Comparator(">=0.0.0");
+						high = high || comparator;
+						low = low || comparator;
+						if (gtfn(comparator.semver, high.semver, options)) high = comparator;
+						else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
+					});
+					if (high.operator === comp || high.operator === ecomp) return false;
+					if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;
+					else if (low.operator === ecomp && ltfn(version, low.semver)) return false;
+				}
+				return true;
+			};
+			module.exports = outside;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/gtr.js
+		var require_gtr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const outside = require_outside();
+			const gtr = (version, range, options) => outside(version, range, ">", options);
+			module.exports = gtr;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/ltr.js
+		var require_ltr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const outside = require_outside();
+			const ltr = (version, range, options) => outside(version, range, "<", options);
+			module.exports = ltr;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/intersects.js
+		var require_intersects = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const Range = require_range();
+			const intersects = (r1, r2, options) => {
+				r1 = new Range(r1, options);
+				r2 = new Range(r2, options);
+				return r1.intersects(r2, options);
+			};
+			module.exports = intersects;
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/simplify.js
+		var require_simplify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const satisfies = require_satisfies();
+			const compare = require_compare();
+			module.exports = (versions, range, options) => {
+				const set = [];
+				let first = null;
+				let prev = null;
+				const v = versions.sort((a, b) => compare(a, b, options));
+				for (const version of v) if (satisfies(version, range, options)) {
+					prev = version;
+					if (!first) first = version;
+				} else {
+					if (prev) set.push([first, prev]);
+					prev = null;
+					first = null;
+				}
+				if (first) set.push([first, null]);
+				const ranges = [];
+				for (const [min, max] of set) if (min === max) ranges.push(min);
+				else if (!max && min === v[0]) ranges.push("*");
+				else if (!max) ranges.push(`>=${min}`);
+				else if (min === v[0]) ranges.push(`<=${max}`);
+				else ranges.push(`${min} - ${max}`);
+				const simplified = ranges.join(" || ");
+				const original = typeof range.raw === "string" ? range.raw : String(range);
+				return simplified.length < original.length ? simplified : range;
+			};
+		}));
+		//#endregion
+		//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/subset.js
+		var require_subset = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const Range = require_range();
+			const Comparator = require_comparator();
+			const { ANY } = Comparator;
+			const satisfies = require_satisfies();
+			const compare = require_compare();
+			const subset = (sub, dom, options = {}) => {
+				if (sub === dom) return true;
+				sub = new Range(sub, options);
+				dom = new Range(dom, options);
+				let sawNonNull = false;
+				OUTER: for (const simpleSub of sub.set) {
+					for (const simpleDom of dom.set) {
+						const isSub = simpleSubset(simpleSub, simpleDom, options);
+						sawNonNull = sawNonNull || isSub !== null;
+						if (isSub) continue OUTER;
+					}
+					if (sawNonNull) return false;
+				}
+				return true;
+			};
+			const minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+			const minimumVersion = [new Comparator(">=0.0.0")];
+			const simpleSubset = (sub, dom, options) => {
+				if (sub === dom) return true;
+				if (sub.length === 1 && sub[0].semver === ANY) {
+					if (dom.length === 1 && dom[0].semver === ANY) return true;
+					else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
+					else sub = minimumVersion;
+				}
+				if (dom.length === 1 && dom[0].semver === ANY) {
+					if (options.includePrerelease) return true;
+					else dom = minimumVersion;
+				}
+				const eqSet = /* @__PURE__ */ new Set();
+				let gt, lt;
+				for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt = higherGT(gt, c, options);
+				else if (c.operator === "<" || c.operator === "<=") lt = lowerLT(lt, c, options);
+				else eqSet.add(c.semver);
+				if (eqSet.size > 1) return null;
+				let gtltComp;
+				if (gt && lt) {
+					gtltComp = compare(gt.semver, lt.semver, options);
+					if (gtltComp > 0) return null;
+					else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) return null;
+				}
+				for (const eq of eqSet) {
+					if (gt && !satisfies(eq, String(gt), options)) return null;
+					if (lt && !satisfies(eq, String(lt), options)) return null;
+					for (const c of dom) if (!satisfies(eq, String(c), options)) return false;
+					return true;
+				}
+				let higher, lower;
+				let hasDomLT, hasDomGT;
+				let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+				let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+				if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;
+				for (const c of dom) {
+					hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+					hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+					if (gt) {
+						if (needDomGTPre) {
+							if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
+						}
+						if (c.operator === ">" || c.operator === ">=") {
+							higher = higherGT(gt, c, options);
+							if (higher === c && higher !== gt) return false;
+						} else if (gt.operator === ">=" && !c.test(gt.semver)) return false;
+					}
+					if (lt) {
+						if (needDomLTPre) {
+							if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
+						}
+						if (c.operator === "<" || c.operator === "<=") {
+							lower = lowerLT(lt, c, options);
+							if (lower === c && lower !== lt) return false;
+						} else if (lt.operator === "<=" && !c.test(lt.semver)) return false;
+					}
+					if (!c.operator && (lt || gt) && gtltComp !== 0) return false;
+				}
+				if (gt && hasDomLT && !lt && gtltComp !== 0) return false;
+				if (lt && hasDomGT && !gt && gtltComp !== 0) return false;
+				if (needDomGTPre || needDomLTPre) return false;
+				return true;
+			};
+			const higherGT = (a, b, options) => {
+				if (!a) return b;
+				const comp = compare(a.semver, b.semver, options);
+				return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+			};
+			const lowerLT = (a, b, options) => {
+				if (!a) return b;
+				const comp = compare(a.semver, b.semver, options);
+				return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+			};
+			module.exports = subset;
+		}));
+		//#endregion
 		//#region src/shared/identity.ts
+		var import_semver = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const internalRe = require_re();
+			const constants = require_constants();
+			const SemVer = require_semver$1();
+			const identifiers = require_identifiers();
+			module.exports = {
+				parse: require_parse(),
+				valid: require_valid$1(),
+				clean: require_clean(),
+				inc: require_inc(),
+				diff: require_diff(),
+				major: require_major(),
+				minor: require_minor(),
+				patch: require_patch(),
+				prerelease: require_prerelease(),
+				compare: require_compare(),
+				rcompare: require_rcompare(),
+				compareLoose: require_compare_loose(),
+				compareBuild: require_compare_build(),
+				sort: require_sort(),
+				rsort: require_rsort(),
+				gt: require_gt(),
+				lt: require_lt(),
+				eq: require_eq(),
+				neq: require_neq(),
+				gte: require_gte(),
+				lte: require_lte(),
+				cmp: require_cmp(),
+				coerce: require_coerce(),
+				truncate: require_truncate(),
+				Comparator: require_comparator(),
+				Range: require_range(),
+				satisfies: require_satisfies(),
+				toComparators: require_to_comparators(),
+				maxSatisfying: require_max_satisfying(),
+				minSatisfying: require_min_satisfying(),
+				minVersion: require_min_version(),
+				validRange: require_valid(),
+				outside: require_outside(),
+				gtr: require_gtr(),
+				ltr: require_ltr(),
+				intersects: require_intersects(),
+				simplifyRange: require_simplify(),
+				subset: require_subset(),
+				SemVer,
+				re: internalRe.re,
+				src: internalRe.src,
+				tokens: internalRe.t,
+				SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+				RELEASE_TYPES: constants.RELEASE_TYPES,
+				compareIdentifiers: identifiers.compareIdentifiers,
+				rcompareIdentifiers: identifiers.rcompareIdentifiers
+			};
+		})))();
 		/** The registry's uniqueness rule, shared with the presentation layer. */
 		function identityKey(identity) {
 			return identity.source === "npm" ? `npm:${identity.name}` : `github:${identity.repo ?? identity.name}#${identity.subdir ?? ""}`;
 		}
-		/** `owner/slug`, lowercased, or null when this is not a repository reference. */
+		/** `owner/slug` inside a GitHub reference. */
 		const REPO = "([\\w.-]+)\\/([\\w.-]+?)";
-		new RegExp(`^github:${REPO}(?:[#&].*)?$`);
-		new RegExp(`^(?:git\\+)?https?:\\/\\/(?:www\\.)?github\\.com\\/${REPO}(?:\\.git)?(?:[\\/?#].*)?$`);
+		const GITHUB_SHORTHAND = new RegExp(`^github:${REPO}(?:[#&].*)?$`);
+		const GITHUB_URL = new RegExp(`^(?:git\\+)?https?:\\/\\/(?:www\\.)?github\\.com\\/${REPO}(?:\\.git)?(?:[\\/?#].*)?$`);
+		/**
+		* Attribute a profile dependency spec to where its package came from.
+		*
+		* The single parse: every other function here reads its answer rather than
+		* re-applying the regexes, so the grammar cannot be widened in one place and
+		* not the other.
+		*
+		* `null` means this spec is a form the grammar does not cover — `git+ssh://`,
+		* `git@github.com:`, a `file:`/`link:` checkout, `workspace:*`, an `npm:`
+		* alias to a different package, a non-GitHub URL. Attribution is POSITIVE on
+		* both arms and null is never guessed away: reading an unattributable spec as
+		* npm is what let an npm entry silently replace a git install, and what
+		* printed "already installed from the npm package X" about a local checkout.
+		*/
+		function parseSpec(spec) {
+			if (spec.trim() === "") return null;
+			const shorthand = GITHUB_SHORTHAND.exec(spec);
+			if (shorthand?.[1] !== void 0 && shorthand[2] !== void 0) return {
+				kind: "github",
+				repo: `${shorthand[1]}/${shorthand[2]}`
+			};
+			const url = GITHUB_URL.exec(spec);
+			if (url?.[1] !== void 0 && url[2] !== void 0) return {
+				kind: "github",
+				repo: `${url[1]}/${url[2]}`
+			};
+			return (0, import_semver.validRange)(spec) !== null ? { kind: "npm" } : null;
+		}
+		/**
+		* Whether two identities of the SAME bundle name are the same install.
+		*
+		* Deliberately coarser than `identityKey`: a profile records a dependency
+		* spec, which carries the repository but not the subdirectory, so this is the
+		* finest distinction the installed state can actually support. It ignores
+		* `name` — every caller has already matched on it — and answers only "is the
+		* thing under that name this one, or a different one?".
+		*/
+		function sameInstall(a, b) {
+			if (a.source !== b.source) return false;
+			if (a.source === "npm") return true;
+			return a.repo !== void 0 && a.repo.toLowerCase() === b.repo?.toLowerCase();
+		}
+		function specVerdict(entry, spec) {
+			const origin = parseSpec(spec);
+			if (origin === null) return "unknown";
+			return sameInstall(entry, origin.kind === "npm" ? {
+				source: "npm",
+				name: entry.name
+			} : {
+				source: "github",
+				name: entry.name,
+				repo: origin.repo
+			}) ? "same" : "different";
+		}
+		/** How long a raw spec may be when it is quoted back to a reader as the thing
+		* holding a name. A profile manifest is not ours; a pathological value must
+		* not become a wall of text in a rejection detail or a card. */
+		const HOLDER_SPEC_CAP = 80;
+		/**
+		* The token naming whatever holds a bundle name, for someone deciding what to
+		* do about it.
+		*
+		* One function for both halves. The host's refusal and the card's badge wrap
+		* it in their own sentence — the host in English prose, the card in the
+		* reader's language — but the token itself is identical, so the two surfaces
+		* can never name one plugin two ways. It is language-neutral for that reason:
+		* a github holder is its repository (the only thing that tells it apart from
+		* the entry it blocks), an npm holder is `npm:<name>`, and a spec we cannot
+		* attribute is quoted verbatim, because saying which string is in the way is
+		* the only honest thing left to say about it.
+		*/
+		function holderLabel(spec, name) {
+			const origin = parseSpec(spec);
+			if (origin?.kind === "github") return origin.repo;
+			if (origin?.kind === "npm") return `npm:${name}`;
+			if (spec.trim() === "") return "\"\"";
+			return spec.length > HOLDER_SPEC_CAP ? `${spec.slice(0, 79)}…` : spec;
+		}
 		//#endregion
 		//#region src/client/present.ts
 		/** Hot-mount reason code → locale key, so the notice reads in the language
@@ -4759,6 +6256,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		function missingPeersOf(incompatible, key) {
 			return incompatible[key] ?? [];
 		}
+		/**
+		* The plugin already holding this entry's bundle name, if a DIFFERENT one is,
+		* named the way the host's refusal names it.
+		*
+		* `specs` is the profile manifest's dependencies exactly as the install gate
+		* reads them (`installedSpecs`), and the verdict is the gate's own function.
+		* One rule on one input, so the badge and the refusal cannot disagree. The
+		* first version of this derived the answer from `installed()`, which drops
+		* every dependency no catalog entry matches — so a fork, a hand install or a
+		* delisted holder was invisible here while the host still refused, and the
+		* card showed a plain Install button for an install that could not proceed.
+		*
+		* `undefined` specs means the host could not read the manifest. The answer is
+		* undefined there too: the card makes no claim rather than promising a clean
+		* install it cannot vouch for.
+		*/
+		function heldBy(entry, specs) {
+			if (specs === void 0 || !Object.hasOwn(specs, entry.name)) return void 0;
+			const spec = specs[entry.name];
+			if (spec === void 0) return void 0;
+			return specVerdict(entry, spec) === "same" ? void 0 : holderLabel(spec, entry.name);
+		}
 		/** Spec §9.3 verbatim — the community-tier acknowledgement. The zh dictionary
 		* states the same facts in its own register; never soften this wording. */
 		const ACKNOWLEDGEMENT_EN = "Once installed, this plugin holds the same privileges as a built-in one: reading and writing your files, running shell commands, and reading and modifying the requests sent to the model. It has not been reviewed.";
@@ -4774,6 +6293,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				case "needs-acknowledgement": return "needsAcknowledgementCode";
 				case "tarball-integrity": return "tarballIntegrityCode";
 				case "ambiguous-identity": return "ambiguousIdentityCode";
+				case "name-taken": return "nameTakenCode";
 			}
 		}
 		/** The version a card displays: full for npm, the short commit for github. */
@@ -4837,7 +6357,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					};
 					if (status.state === "done") return {
 						kind: "done",
-						needsRestart: !!status.needsRestart,
+						needsRestart: status.needsRestart ?? true,
 						log: status.log,
 						...status.restartReason !== void 0 ? { restartReason: status.restartReason } : {}
 					};
@@ -4947,9 +6467,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* identity (registry `emit.ts` assertCatalogInvariants): `npm:<name>` for an
 		* npm entry, `github:<repo>#<subdir>` for a repo one — so two GitHub
 		* repositories publishing the same `package.json` name are two legitimate
-		* entries under one name, as are two subpackages of one monorepo. The live
-		* catalog holds 151 such names over 243 entries, five of them cookiecutter
-		* templates that all name themselves `{{PKG_NAME}}`.
+		* entries under one name, as are two subpackages of one monorepo. How many
+		* such names the catalog holds is kept in ONE place — `validateInstall`'s
+		* docstring in host/install.ts, with the way to re-derive it — because the
+		* copy that stood here had drifted to less than half the real figure.
 		*
 		* Keying the shelf by name handed React duplicate keys, and React could then
 		* no longer match a card to its DOM node: changing the filter left every
@@ -5040,7 +6561,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			hotHostUnsupportedNotice: "当前环境不支持热挂载；重启 dsh 后生效",
 			hotTimeoutNotice: "热挂载超时；重启 dsh 后生效",
 			hotMountFailedNotice: "热挂载失败；重启 dsh 后生效",
-			installedNoRestartNotice: "已安装，但 profile 未变化——目录可能已过期，请刷新后重试",
+			installedNoRestartNotice: "已安装并热挂载；现在即可使用，无需重启",
 			installFailed: "安装失败",
 			installTransportFailed: "安装请求未能送达。请稍后重试。",
 			refresh: "刷新",
@@ -5061,6 +6582,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			needsAcknowledgementCode: "需要确认",
 			tarballIntegrityCode: "压缩包完整性校验失败",
 			ambiguousIdentityCode: "无法确定是哪一个条目",
+			nameTakenCode: "同名的另一个插件已安装",
+			nameTakenBadge: "名称被占用",
+			nameTakenDetail: "已安装同名的另一个插件（{holder}）。\n两个同名插件声明相同的加载项 id，无法共存；安装它会替换掉已装的那个。",
 			npmSource: "npm 包",
 			githubSource: "源码在 GitHub",
 			installedSection: "已安装",
@@ -5130,7 +6654,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			hotHostUnsupportedNotice: "this harness cannot hot-mount; restart dsh to activate",
 			hotTimeoutNotice: "hot-mount timed out; restart dsh to activate",
 			hotMountFailedNotice: "hot-mount failed; restart dsh to activate",
-			installedNoRestartNotice: "installed, but the profile did not change — the catalog may be stale; refresh and try again",
+			installedNoRestartNotice: "installed and hot-mounted; running now, no restart needed",
 			installFailed: "Install failed",
 			installTransportFailed: "The install request could not be delivered. Please retry.",
 			refresh: "Refresh",
@@ -5151,6 +6675,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			needsAcknowledgementCode: "Acknowledgement required",
 			tarballIntegrityCode: "tarball integrity check failed",
 			ambiguousIdentityCode: "Ambiguous entry",
+			nameTakenCode: "Another plugin holds this name",
+			nameTakenBadge: "Name taken",
+			nameTakenDetail: "A different plugin of this name is installed ({holder}).\nTwo plugins of one name declare the same loader entry id and cannot both load; installing this one would replace it.",
 			npmSource: "npm package",
 			githubSource: "source on GitHub",
 			installedSection: "Installed",
@@ -5516,8 +7043,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* install controls. An installed plugin's card carries its installed row:
 		* current → the non-interactive installed label, behind → the update button;
 		* uninstalled → the install button. */
-		const EntryCard = (0, react.memo)(function EntryCard({ entry, stars, installed, missing, t, flowFor, installStatus, uninstall, restart, restartSupported, setEnabled, onSettled }) {
+		const EntryCard = (0, react.memo)(function EntryCard({ entry, stars, installed, missing, nameTakenBy, t, flowFor, installStatus, uninstall, restart, restartSupported, setEnabled, onSettled }) {
 			const [open, setOpen] = (0, react.useState)(false);
+			const blockers = blockersOf(missing, nameTakenBy, t);
 			const detailId = (0, react.useId)();
 			const summary = entry.catalog?.summary;
 			const npmUrl = npmPageUrl(entry);
@@ -5622,11 +7150,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 								className: open ? `${_dsh_plugin_shop_css_e3675a89_default.summaryZh} ${_dsh_plugin_shop_css_e3675a89_default.summaryZhExpanded}` : _dsh_plugin_shop_css_e3675a89_default.summaryZh,
 								children: summary.zh
 							}),
-							missing.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							blockers.map((blocker) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 								className: _dsh_plugin_shop_css_e3675a89_default.incompatibleDetail,
 								"data-shop-incompatible-detail": true,
-								children: t("incompatibleDetail", { modules: missing.join(", ") })
-							}),
+								children: blocker.text
+							}, blocker.kind)),
 							open && entry.catalog !== void 0 && entry.catalog.capabilities.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 								className: _dsh_plugin_shop_css_e3675a89_default.capabilitiesBlock,
 								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -5687,6 +7215,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 							target: installTarget,
 							tier: entry.tier,
 							missing,
+							blockers,
 							missingStated: true,
 							flow,
 							t,
@@ -5698,6 +7227,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 								tier: entry.tier,
 								variant: installed.outdated ? "update" : "install",
 								missing,
+								blockers,
 								missingStated: true,
 								flow,
 								t,
@@ -5707,8 +7237,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 								className: _dsh_plugin_shop_css_e3675a89_default.installedLabel,
 								"data-shop-installed": true,
 								children: t("installed")
-							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IncompatibleBadge, {
-								missing,
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BlockerBadge, {
+								blockers,
 								t
 							})] }),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(EnabledSwitch, {
@@ -5734,22 +7264,42 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				]
 			});
 		});
+		/**
+		* Everything standing in this entry's way, already localized.
+		*
+		* The two are independent and both can hold at once, so this is a list and
+		* every surface renders the same list. The name conflict reads first: it is
+		* about a plugin the reader chose and would lose.
+		*/
+		function blockersOf(missing, nameTakenBy, t) {
+			const blockers = [];
+			if (nameTakenBy !== void 0) blockers.push({
+				kind: "name-taken",
+				text: t("nameTakenDetail", { holder: nameTakenBy })
+			});
+			if (missing.length > 0) blockers.push({
+				kind: "missing-peers",
+				text: t("incompatibleDetail", { modules: missing.join(", ") })
+			});
+			return blockers;
+		}
 		/** The harness-compatibility verdict, rendered beside the control it
 		* qualifies. It answers "what happens if I press this", not "what is this",
 		* so it belongs to the action row and not among the identity badges in the
 		* header — where it also sat inside a <button>, competing with that button's
 		* own hit area for the tooltip. Renders nothing when the harness provides
 		* everything. */
-		function IncompatibleBadge({ missing, t }) {
-			if (missing.length === 0) return null;
-			const detail = t("incompatibleDetail", { modules: missing.join(", ") });
+		function BlockerBadge({ blockers, t }) {
+			if (blockers.length === 0) return null;
+			const detail = blockers.map((blocker) => blocker.text).join("\n");
+			const taken = blockers.some((blocker) => blocker.kind === "name-taken");
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 				className: _dsh_plugin_shop_css_e3675a89_default.incompatibleBadge,
-				"data-shop-incompatible": true,
+				"data-shop-blocker": taken ? "name-taken" : "missing-peers",
 				role: "img",
 				"aria-label": detail,
 				title: detail,
-				children: t("incompatibleBadge")
+				children: t(taken ? "nameTakenBadge" : "incompatibleBadge")
 			});
 		}
 		/** One entry's install flow: the button, the §9.3 acknowledgement gate for
@@ -5757,7 +7307,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* failure detail, rejection detail — driven by `useInstall`. Shared by the
 		* catalog cards (`variant: 'install'`) and the outdated rows' update button
 		* (`variant: 'update'`, which drives the same install flow for `name@latest`). */
-		function InstallPanel({ target, tier, missing, missingStated = false, variant = "install", flow, t, restart, restartSupported }) {
+		function InstallPanel({ target, tier, missing, blockers, missingStated = false, variant = "install", flow, t, restart, restartSupported }) {
 			const [gateOpen, setGateOpen] = (0, react.useState)(false);
 			const { view, start } = flow;
 			if (view.kind === "running") return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
@@ -5840,11 +7390,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						className: _dsh_plugin_shop_css_e3675a89_default.gateBody,
 						children: t("acknowledgementBody")
 					}),
-					missing.length > 0 && !missingStated && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					!missingStated && blockersOf(missing, void 0, t).map((blocker) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 						className: _dsh_plugin_shop_css_e3675a89_default.gateWarning,
 						"data-shop-incompatible-warning": true,
-						children: t("incompatibleDetail", { modules: missing.join(", ") })
-					}),
+						children: blocker.text
+					}, blocker.kind)),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 						className: _dsh_plugin_shop_css_e3675a89_default.gateActions,
 						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
@@ -5869,9 +7419,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				]
 			});
 			const update = variant === "update";
+			const refused = blockers.some((blocker) => blocker.kind === "name-taken");
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 				type: "button",
 				className: _dsh_plugin_shop_css_e3675a89_default.installButton,
+				disabled: refused,
+				...refused ? { "data-shop-refused": true } : {},
 				...update ? { "data-shop-update": true } : { "data-shop-install": true },
 				onClick: () => {
 					if (tier === "verified") start({
@@ -5881,8 +7434,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					else setGateOpen(true);
 				},
 				children: t(update ? "update" : "install")
-			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IncompatibleBadge, {
-				missing,
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BlockerBadge, {
+				blockers,
 				t
 			})] });
 		}
@@ -6156,6 +7709,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						tier,
 						variant: "update",
 						missing,
+						blockers: blockersOf(missing, void 0, t),
 						flow: flowFor(identityKey(row)),
 						t,
 						restart,
@@ -6204,9 +7758,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** The shop tab root: browse, search, refresh, and render one card per
 		* entry. Data attributes on the e2e-relevant nodes follow the Task 3 list. */
 		function ShopTab(props) {
-			const { t, catalog, install, installStatus, setEnabled, installed, uninstall, restart, version, updateStart } = props;
+			const { t, catalog, install, installStatus, setEnabled, installed, installedSpecs, uninstall, restart, version, updateStart } = props;
 			const [catalogState, setCatalogState] = (0, react.useState)({ kind: "loading" });
 			const [installedState, setInstalledState] = (0, react.useState)({ kind: "loading" });
+			/** The install gate's own input, or undefined while it is unknown — loading,
+			* failed, or answered `null` by a host that could not read the manifest.
+			* Undefined is never read as "nothing is installed": a card makes no claim
+			* about a conflict it could not check. */
+			const [specs, setSpecs] = (0, react.useState)(void 0);
 			const [selfVersion, setSelfVersion] = (0, react.useState)(null);
 			const restartSupported = selfVersion?.restartSupported ?? true;
 			const [selfRestartGate, setSelfRestartGate] = (0, react.useState)(false);
@@ -6284,13 +7843,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				let cancelled = false;
 				const load = async () => {
 					try {
-						const entries = await installed();
-						if (!cancelled) setInstalledState({
+						const [entries, held] = await Promise.all([installed(), installedSpecs()]);
+						if (cancelled) return;
+						setInstalledState({
 							kind: "ready",
 							entries
 						});
+						setSpecs(held ?? void 0);
 					} catch {
-						if (!cancelled) setInstalledState({ kind: "error" });
+						if (cancelled) return;
+						setInstalledState({ kind: "error" });
+						setSpecs(void 0);
 					}
 				};
 				load();
@@ -6299,6 +7862,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				};
 			}, [
 				installed,
+				installedSpecs,
 				request,
 				mutations
 			]);
@@ -6370,6 +7934,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				if (catalogState.kind === "ready") for (const entry of catalogState.result.plugins) map.set(entryKey(entry), missingPeersOf(catalogState.result.incompatible, entryKey(entry)));
 				return map;
 			}, [catalogState]);
+			const nameTakenByKey = (0, react.useMemo)(() => {
+				const map = /* @__PURE__ */ new Map();
+				if (catalogState.kind !== "ready") return map;
+				for (const entry of catalogState.result.plugins) {
+					const holder = heldBy(entry, specs);
+					if (holder !== void 0) map.set(entryKey(entry), holder);
+				}
+				return map;
+			}, [catalogState, specs]);
 			if (catalogState.kind === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: _dsh_plugin_shop_css_e3675a89_default.panel,
 				"data-shop-tab": true,
@@ -6627,20 +8200,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						children: t("emptySearch")
 					}) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("ul", {
 						className: _dsh_plugin_shop_css_e3675a89_default.cards,
-						children: [visible.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(EntryCard, {
-							entry,
-							stars: starsOf(entry, stars),
-							installed: installedByKey.get(entryKey(entry)),
-							missing: missingByKey.get(entryKey(entry)) ?? [],
-							t,
-							flowFor: flows.flowFor,
-							installStatus,
-							uninstall,
-							restart,
-							restartSupported,
-							setEnabled,
-							onSettled: noteMutation
-						}) }, entryKey(entry))), incremental && visibleCount < filtered.length && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+						children: [visible.map((entry) => {
+							const key = entryKey(entry);
+							return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(EntryCard, {
+								entry,
+								stars: starsOf(entry, stars),
+								installed: installedByKey.get(key),
+								missing: missingByKey.get(key) ?? [],
+								nameTakenBy: nameTakenByKey.get(key),
+								t,
+								flowFor: flows.flowFor,
+								installStatus,
+								uninstall,
+								restart,
+								restartSupported,
+								setEnabled,
+								onSettled: noteMutation
+							}) }, key);
+						}), incremental && visibleCount < filtered.length && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
 							ref: sentinelRef,
 							className: _dsh_plugin_shop_css_e3675a89_default.cardsSentry,
 							"data-shop-sentry": true,
@@ -6746,6 +8323,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				installStatus: async (args) => unwrap(await ns.installStatus(args)),
 				setEnabled: async (args) => unwrap(await ns.setEnabled(args)),
 				installed: async () => unwrap(await ns.installed()),
+				installedSpecs: async () => unwrap(await ns.installedSpecs()),
 				uninstall: async (args) => unwrap(await ns.uninstallStart(args)),
 				restart: async () => unwrap(await ns.restart()),
 				version: async () => unwrap(await ns.version()),