@caplets/core 0.28.1 → 0.29.1

package/dist/index.js

@@ -1,9 +1,10 @@
-import { $ as redactCodeModeLogText, $n as getParseErrorMessage, $t as readTokenBundle, A as resolveRemoteMode, An as GetPromptRequestSchema, At as loadProjectConfig, Bn as LoggingLevelSchema, Bt as discoverCapletFiles, C as CapletsCloudClient, Cn as CreateMessageResultSchema, Ct as ServerRegistry, D as normalizeRemoteProfileHostUrl, Dn as ElicitResultSchema, Dt as loadConfigWithSources, E as isCapletsCloudUrl, Et as loadConfig, F as resolveCapletsServer, Fn as ListPromptsRequestSchema, Ft as FileVaultStore, G as runCodeMode, Gn as assertCompleteRequestPrompt, Gt as markdownStructuredContent, H as codeModeRunInputSchema, Hn as ReadResourceRequestSchema, Ht as loadCapletFilesFromMap, I as nativeCapletPromptGuidance, In as ListResourceTemplatesRequestSchema, It as VAULT_MAX_VALUE_BYTES, J as diagnoseCodeModeTypeScript, Jn as isJSONRPCErrorResponse, Jt as runOAuthFlow, K as CodeModeSessionManager, Kn as assertCompleteRequestResourceTemplate, Kt as refreshOAuthTokenBundle, L as nativeCapletToolDescription, Ln as ListResourcesRequestSchema, Lt as validateVaultKeyName, M as controlUrlForBase, Mn as InitializedNotificationSchema, Mt as vaultBootstrapResolver, N as isLoopbackHost, Nn as JSONRPCMessageSchema, Nt as vaultResolverForAuthDir, O as resolveCapletsRemote, On as EmptyResultSchema, Ot as loadGlobalConfig, P as parseServerBaseUrl, Pn as LATEST_PROTOCOL_VERSION, Pt as vaultStoreForAuthDir, Q as CodeModeLogStore, Qn as getObjectShape, Qt as isTokenBundleExpired, R as nativeCapletToolName, Rn as ListRootsResultSchema, Rt as decryptVaultValue, S as buildProjectSyncManifest, Sn as CompleteRequestSchema, St as handleServerTool, T as hostedCloudWorkspaceFromRemoteUrl, Tn as CreateTaskResultSchema, Tt as GoogleDiscoveryManager, U as codeModeRunParamsSchema, Un as SUPPORTED_PROTOCOL_VERSIONS, Ut as hasRenderableStructuredContent, Vn as McpError, Vt as validateCapletFile, W as emptyCodeModeRunMeta, Wn as SetLevelRequestSchema, Wt as markdownCallToolResultContent, X as listCodeModeCallableCaplets, Xn as isJSONRPCResultResponse, Xt as startOAuthFlow, Y as createCodeModeCapletsApi, Yn as isJSONRPCRequest, Yt as startGenericOAuthFlow, Z as CodeModeJournalStore, Zn as getLiteralValue, Zt as deleteTokenBundle, _ as attachErrorResponse, _n as Protocol, _t as rotateTelemetryIdentity, a as CloudAuthStore, an as defaultConfigPath, ar as safeParse, at as version, b as invokeAttachExport, bn as CallToolRequestSchema, bt as findProjectRoot, c as redactedCloudAuthStatus, cn as resolveCapletsRoot, ct as buildProductTelemetryEvent, d as projectBindingError, dn as resolveProjectConfigPath, dt as maybePrintTelemetryNotice, en as DEFAULT_AUTH_DIR, er as getSchemaDescription, et as codeModeDeclarationHash, f as projectBindingRecovery, fn as ReadBuffer, ft as resolveTelemetryState, g as CAPLETS_ATTACH_SESSION_HEADER, gn as AjvJsonSchemaValidator, gt as readTelemetryNotice, hn as assertToolsCallTaskCapability, ht as readTelemetryIdentity, i as createRemoteProfileStore, in as defaultConfigBaseDir, ir as objectFromShape, it as CapletsEngine, j as appendBasePath, jn as InitializeRequestSchema, jt as parseConfig, k as resolveHostedCloudRemote, kn as ErrorCode, kt as loadLocalOverlayConfigWithSources, l as PROJECT_BINDING_ERROR_CODES, ln as resolveConfigPath, lt as buildReliabilityTelemetryEvent, mn as assertClientRequestTaskCapability, mt as readTelemetryDeliveryHealth, n as resolveRemoteSelection, nn as DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR, nr as isZ4Schema, nt as generateCodeModeRunToolDescription, o as cloudAuthPath, on as defaultStateBaseDir, or as safeParseAsync, ot as createTelemetryDispatcher, p as CloudAuthClient, pn as serializeMessage, pt as deleteTelemetryIdentity, q as QuickJsCodeModeSandbox, qn as isInitializeRequest, qt as runGenericOAuthFlow, r as cloudCredentialsFromRemoteProfile, rn as defaultCacheBaseDir, rr as normalizeObjectSchema, rt as minifyCodeModeDeclarationText, s as migrateCredentials, sn as defaultTelemetryStateDir, st as TelemetryDebugSink, t as createNativeCapletsService, tr as isSchemaOptional, tt as generateCodeModeDeclarations, u as ProjectBindingError, un as resolveProjectCapletsRoot, ut as durationBucket, v as buildAttachProjection, vn as mergeCapabilities, vt as resolveExposure, wn as CreateMessageResultWithToolsSchema, wt as capabilityDescription, x as invokeNativeAttachExport, xn as CallToolResultSchema, xt as fingerprintProjectRoot, y as buildNativeAttachProjection, yn as toJsonSchemaCompat, yt as decodeDirectResourceUri, zn as ListToolsRequestSchema, zt as encryptVaultValue } from "./service-B6YvNthO.js";
+import { t as __commonJSMin } from "./rolldown-runtime-CE-6LUnI.js";
+import { $ as redactCodeModeLogText, $n as isJSONRPCRequest, $t as readTokenBundle, A as resolveRemoteMode, At as loadProjectConfig, Bn as ListResourceTemplatesRequestSchema, Bt as discoverCapletFiles, C as CapletsCloudClient, Cn as toJsonSchemaCompat, Ct as ServerRegistry, D as normalizeRemoteProfileHostUrl, Dn as CreateMessageResultSchema, Dt as loadConfigWithSources, E as isCapletsCloudUrl, En as CompleteRequestSchema, Et as loadConfig, F as resolveCapletsServer, Fn as InitializeRequestSchema, Ft as FileVaultStore, G as runCodeMode, Gn as McpError, Gt as markdownStructuredContent, H as codeModeRunInputSchema, Hn as ListRootsResultSchema, Ht as loadCapletFilesFromMap, I as nativeCapletPromptGuidance, In as InitializedNotificationSchema, It as VAULT_MAX_VALUE_BYTES, J as diagnoseCodeModeTypeScript, Jn as SetLevelRequestSchema, Jt as runOAuthFlow, K as CodeModeSessionManager, Kn as ReadResourceRequestSchema, Kt as refreshOAuthTokenBundle, L as nativeCapletToolDescription, Ln as JSONRPCMessageSchema, Lt as validateVaultKeyName, M as controlUrlForBase, Mn as EmptyResultSchema, Mt as vaultBootstrapResolver, N as isLoopbackHost, Nn as ErrorCode, Nt as vaultResolverForAuthDir, O as resolveCapletsRemote, On as CreateMessageResultWithToolsSchema, Ot as loadGlobalConfig, P as parseServerBaseUrl, Pn as GetPromptRequestSchema, Pt as vaultStoreForAuthDir, Q as CodeModeLogStore, Qn as isJSONRPCErrorResponse, Qt as isTokenBundleExpired, R as nativeCapletToolName, Rn as LATEST_PROTOCOL_VERSION, Rt as decryptVaultValue, S as buildProjectSyncManifest, Sn as mergeCapabilities, St as handleServerTool, T as hostedCloudWorkspaceFromRemoteUrl, Tn as CallToolResultSchema, Tt as GoogleDiscoveryManager, U as codeModeRunParamsSchema, Un as ListToolsRequestSchema, Ut as hasRenderableStructuredContent, Vn as ListResourcesRequestSchema, Vt as validateCapletFile, W as emptyCodeModeRunMeta, Wn as LoggingLevelSchema, Wt as markdownCallToolResultContent, X as listCodeModeCallableCaplets, Xn as assertCompleteRequestResourceTemplate, Xt as startOAuthFlow, Y as createCodeModeCapletsApi, Yn as assertCompleteRequestPrompt, Yt as startGenericOAuthFlow, Z as CodeModeJournalStore, Zn as isInitializeRequest, Zt as deleteTokenBundle, _ as attachErrorResponse, _n as serializeMessage, _t as rotateTelemetryIdentity, a as CloudAuthStore, an as defaultCacheBaseDir, ar as isSchemaOptional, at as version, b as invokeAttachExport, bn as AjvJsonSchemaValidator, bt as findProjectRoot, c as redactedCloudAuthStatus, cn as defaultStateBaseDir, cr as objectFromShape, ct as buildProductTelemetryEvent, d as projectBindingError, dn as defaultUpdateCheckStateDir, dt as maybePrintTelemetryNotice, en as DEFAULT_AUTH_DIR, er as isJSONRPCResultResponse, et as codeModeDeclarationHash, f as projectBindingRecovery, fn as resolveCapletsRoot, ft as resolveTelemetryState, g as CAPLETS_ATTACH_SESSION_HEADER, gn as ReadBuffer, gt as readTelemetryNotice, hn as resolveProjectConfigPath, ht as readTelemetryIdentity, i as createRemoteProfileStore, in as DEFAULT_UPDATE_CHECK_STATE_DIR, ir as getSchemaDescription, it as CapletsEngine, j as appendBasePath, jn as ElicitResultSchema, jt as parseConfig, k as resolveHostedCloudRemote, kn as CreateTaskResultSchema, kt as loadLocalOverlayConfigWithSources, l as PROJECT_BINDING_ERROR_CODES, ln as defaultTelemetryStateDir, lr as safeParse, lt as buildReliabilityTelemetryEvent, mn as resolveProjectCapletsRoot, mt as readTelemetryDeliveryHealth, n as resolveRemoteSelection, nn as DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR, nr as getObjectShape, nt as generateCodeModeRunToolDescription, o as cloudAuthPath, on as defaultConfigBaseDir, or as isZ4Schema, ot as createTelemetryDispatcher, p as CloudAuthClient, pn as resolveConfigPath, pt as deleteTelemetryIdentity, q as QuickJsCodeModeSandbox, qn as SUPPORTED_PROTOCOL_VERSIONS, qt as runGenericOAuthFlow, r as cloudCredentialsFromRemoteProfile, rn as DEFAULT_UPDATE_CHECK_CACHE_DIR, rr as getParseErrorMessage, rt as minifyCodeModeDeclarationText, s as migrateCredentials, sn as defaultConfigPath, sr as normalizeObjectSchema, st as TelemetryDebugSink, t as createNativeCapletsService, tr as getLiteralValue, tt as generateCodeModeDeclarations, u as ProjectBindingError, un as defaultUpdateCheckCacheDir, ur as safeParseAsync, ut as durationBucket, v as buildAttachProjection, vn as assertClientRequestTaskCapability, vt as resolveExposure, wn as CallToolRequestSchema, wt as capabilityDescription, x as invokeNativeAttachExport, xn as Protocol, xt as fingerprintProjectRoot, y as buildNativeAttachProjection, yn as assertToolsCallTaskCapability, yt as decodeDirectResourceUri, zn as ListPromptsRequestSchema, zt as encryptVaultValue } from "./service-DxPo2KUs.js";
 import { _ as record, b as unknown, d as literal, m as object, n as ZodOptional, o as array, p as number, r as _enum, s as boolean, v as string, x as url } from "./schemas-BoqMu4MG.js";
 import { a as SERVER_ID_PATTERN, d as CapletsError, m as toSafeError, p as redactSecrets$1, u as CAPLETS_ERROR_CODES } from "./validation-CWzd2gtn.js";
 import { generatedToolInputSchema, generatedToolInputSchemaForCaplet } from "./generated-tool-input-schema.js";
 import { f as observedOutputShapeKey, i as observeOutputShape, u as FileObservedOutputShapeStore } from "./observed-output-shapes-DuP7mJQf.js";
-import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-D9253pYs.js";
+import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-CcNgCYzl.js";
 import { n as normalizeCapletSourcePath, t as FilesystemCapletSource } from "./filesystem-Kkg32TOJ.js";
 import { parseConfig as parseConfig$1 } from "./config-runtime.js";
 import fs, { accessSync, chmodSync, closeSync, constants, copyFileSync, cpSync, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync, writeSync } from "node:fs";
@@ -5895,7 +5896,7 @@ function daemonHostPath(path) {
 //#endregion
 //#region src/daemon/config.ts
 function readDaemonConfig(paths) {
-	return readJson(paths.configFile);
+	return readJson$1(paths.configFile);
 }
 function writeDaemonConfig(paths, config) {
 	writeJson(paths.configFile, config);
@@ -5932,7 +5933,7 @@ function mergeDaemonEnv(existing, install) {
 function validateEnvName(value) {
 	if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(value)) throw new CapletsError("REQUEST_INVALID", `Invalid environment variable name: ${value}`);
 }
-function readJson(path) {
+function readJson$1(path) {
 	const hostPath = daemonHostPath(path);
 	try {
 		return JSON.parse(readFileSync(hostPath, "utf8"));
@@ -6103,11 +6104,7 @@ function shellQuote(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function serviceCommand(config) {
-	const direct = [
-		process.execPath,
-		config.command.executable,
-		...config.command.args
-	];
+	const direct = [config.command.executable, ...config.command.args];
 	if (!config.command.shell) return {
 		executable: direct[0],
 		args: direct.slice(1),
@@ -7050,6 +7047,15 @@ function nonEmpty$2(value, label) {
 	return trimmed;
 }
 //#endregion
+//#region src/update-check/control.ts
+const DISABLE_UPDATE_CHECK_ENV = "CAPLETS_DISABLE_UPDATE_CHECK";
+function isUpdateCheckDisabled(env = process.env) {
+	return env["CAPLETS_DISABLE_UPDATE_CHECK"] === "1" || env["CAPLETS_DISABLE_UPDATE_CHECK"] === "true";
+}
+function isUpdateNoticeStderrOptIn(env = process.env) {
+	return env["CAPLETS_UPDATE_NOTICE_STDERR"] === "1" || env["CAPLETS_UPDATE_NOTICE_STDERR"] === "true";
+}
+//#endregion
 //#region src/daemon/env.ts
 function resolveDaemonShell(options) {
 	const platform = options.platform ?? process.platform;
@@ -7139,20 +7145,26 @@ function daemonServeArgs(options) {
 }
 function buildDaemonCommandPlan(options) {
 	const platform = options.operation.platform ?? process.platform;
-	const executable = resolveDaemonExecutable(process.argv[1]);
-	const args = daemonServeArgs(options.serve);
+	const command = resolveDaemonCommand({
+		env: options.operation.env ?? process.env,
+		platform,
+		scriptPath: process.argv[1],
+		serveArgs: daemonServeArgs(options.serve)
+	});
 	const workingDirectory = options.operation.home ?? homedir();
+	const serviceEnv = daemonServiceEnv({
+		explicitEnv: options.explicitEnv ?? {},
+		operation: options.operation,
+		platform,
+		serve: options.serve,
+		workingDirectory
+	});
+	if (command.pathEnv && serviceEnv.PATH === void 0 && serviceEnv.Path === void 0 && serviceEnv.path === void 0) serviceEnv.PATH = command.pathEnv;
 	const base = {
-		executable,
-		args,
+		executable: command.executable,
+		args: command.args,
 		workingDirectory,
-		env: daemonServiceEnv({
-			explicitEnv: options.explicitEnv ?? {},
-			operation: options.operation,
-			platform,
-			serve: options.serve,
-			workingDirectory
-		}),
+		env: serviceEnv,
 		inheritEnv: options.inheritEnv ?? false,
 		stdoutLog: options.paths.stdoutLog,
 		stderrLog: options.paths.stderrLog
@@ -7173,6 +7185,7 @@ function daemonServiceEnv(options) {
 		...options.explicitEnv
 	};
 	if (options.serve.publicOrigin && serviceEnv.CAPLETS_SERVER_URL === void 0) serviceEnv.CAPLETS_SERVER_URL = options.serve.publicOrigin;
+	serviceEnv[DISABLE_UPDATE_CHECK_ENV] = "1";
 	return serviceEnv;
 }
 function configSelectionEnv(env, home, platform) {
@@ -7195,7 +7208,20 @@ function configSelectionEnvKeys(platform) {
 		"XDG_CACHE_HOME"
 	];
 }
-function resolveDaemonExecutable(scriptPath) {
+function resolveDaemonCommand(options) {
+	const stableCommand = resolvePathCommand("caplets", options.env, options.platform);
+	if (stableCommand) return {
+		executable: stableCommand,
+		args: options.serveArgs,
+		pathEnv: pathEnvValue(options.env)
+	};
+	const script = resolveDaemonCliScript(options.scriptPath);
+	return {
+		executable: process.execPath,
+		args: [script, ...options.serveArgs]
+	};
+}
+function resolveDaemonCliScript(scriptPath) {
 	if (!scriptPath) throw new CapletsError("REQUEST_INVALID", "Cannot install the daemon because the Caplets CLI path could not be resolved.");
 	const executable = isAbsolute(scriptPath) ? scriptPath : resolve(scriptPath);
 	if (!existsSync(executable)) throw new CapletsError("REQUEST_INVALID", `Cannot install the daemon because the Caplets CLI path does not exist: ${executable}`);
@@ -7203,6 +7229,48 @@ function resolveDaemonExecutable(scriptPath) {
 	if (isTransientRunnerPath(executable) || isTransientRunnerPath(realExecutable)) throw new CapletsError("REQUEST_INVALID", "Cannot install the daemon from a temporary runner such as npx or pnpm dlx. Install caplets first, then rerun caplets daemon install.");
 	return executable;
 }
+function resolvePathCommand(command, env, platform) {
+	const path = pathEnvValue(env);
+	if (!path) return void 0;
+	const delimiter = platform === "win32" ? ";" : ":";
+	for (const entry of path.split(delimiter)) {
+		const directory = entry.trim();
+		if (!directory) continue;
+		for (const candidate of pathCommandCandidates(directory, command, env, platform)) {
+			if (!isRunnableCommand(candidate, platform)) continue;
+			const realCandidate = safeRealpath(candidate);
+			if (isTransientRunnerPath(candidate) || isTransientRunnerPath(realCandidate)) throw new CapletsError("REQUEST_INVALID", "Cannot install the daemon from a temporary runner such as npx or pnpm dlx. Install caplets first, then rerun caplets daemon install.");
+			return candidate;
+		}
+	}
+}
+function pathCommandCandidates(directory, command, env, platform) {
+	const resolved = isAbsolute(directory) ? directory : resolve(directory);
+	if (platform !== "win32") return [resolve(resolved, command)];
+	const lower = command.toLocaleLowerCase();
+	if (/\.[^.\\/]+$/u.test(lower)) return [resolve(resolved, command)];
+	return (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((value) => value.trim()).filter(Boolean).map((extension) => resolve(resolved, `${command}${extension}`));
+}
+function pathEnvValue(env) {
+	return env.PATH ?? env.Path ?? env.path;
+}
+function isRunnableCommand(path, platform) {
+	try {
+		if (!statSync(path).isFile()) return false;
+		if (platform === "win32") return true;
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function safeRealpath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
 function isTransientRunnerPath(path) {
 	const normalized = path.replaceAll("\\", "/");
 	return /(?:^|\/)_npx(?:\/|$)/u.test(normalized) || /(?:^|\/)dlx-[^/]+(?:\/|$)/u.test(normalized);
@@ -12837,11 +12905,28 @@ function healthUrl(config, port = config.serve.port) {
 }
 function validationSpawnCommand(config) {
 	const planned = serviceCommand(config);
+	if (isWindowsCommandShim(planned.executable)) {
+		const shell = {
+			executable: "cmd.exe",
+			args: [
+				"/d",
+				"/s",
+				"/c"
+			]
+		};
+		return {
+			command: shell.executable,
+			args: [...shell.args, shellCommandLine(shell, [planned.executable, ...planned.args])]
+		};
+	}
 	return {
 		command: planned.executable,
 		args: planned.args
 	};
 }
+function isWindowsCommandShim(path) {
+	return /\.(?:bat|cmd)$/iu.test(path);
+}
 async function sleep$2(ms) {
 	await new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -13366,9 +13451,10 @@ async function doctorJsonReport(options = {}) {
 			authMode: remoteLogin.authenticated ? remoteLogin.kind === "cloud" ? "hosted_cloud" : "self_hosted_remote" : remote.configured || remoteLogin.configured ? "remote_login_required" : "unconfigured",
 			selectedWorkspace: remoteLogin.selectedWorkspace ?? remote.workspace ?? null,
 			webSocketUrl: remote.webSocketUrl,
+			sessionSupport: remoteLogin.kind === "self-hosted" ? "unsupported" : "unknown",
 			lease: null,
 			lastUpgradeError: null,
-			recoveryCommand: remoteLogin.authenticated ? "caplets attach --once" : remote.configured || remoteLogin.configured ? `caplets remote login ${remoteLogin.hostUrl ?? "<url>"}` : "caplets remote login <url>"
+			recoveryCommand: projectBindingRecovery$1(remoteLogin, remote)
 		},
 		sync: {
 			state: options.syncStatus?.state ?? "idle",
@@ -13409,6 +13495,7 @@ async function formatDoctorReport(options = {}) {
 		`  Auth mode: ${report.projectBinding.authMode}`,
 		`  Selected Workspace: ${report.projectBinding.selectedWorkspace ?? "none"}`,
 		`  Binding Session: ${report.projectBinding.state}`,
+		...report.projectBinding.sessionSupport !== "unknown" ? [`  Session support: ${report.projectBinding.sessionSupport}`] : [],
 		`  Recovery: ${report.projectBinding.recoveryCommand}`,
 		"",
 		"Project sync",
@@ -13483,6 +13570,11 @@ function vaultIssueFromWarning(message, path) {
 		recoveryCommand
 	};
 }
+function projectBindingRecovery$1(remoteLogin, remote) {
+	if (remoteLogin.authenticated) return remoteLogin.kind === "self-hosted" ? "Self-hosted Project Binding sessions are not implemented by this runtime." : "caplets attach --once";
+	if (remote.configured || remoteLogin.configured) return `caplets remote login ${remoteLogin.hostUrl ?? "<url>"}`;
+	return "caplets remote login <url>";
+}
 async function resolveDaemonSection(env, options) {
 	try {
 		const status = await daemonStatus({
@@ -15406,9 +15498,1813 @@ function nativeAttachSession(service) {
 	};
 }
 //#endregion
+//#region src/update-check/eligibility.ts
+function classifyUpdateNoticeEligibility(input) {
+	const env = input.env ?? process.env;
+	const args = input.args;
+	const command = args[0] ?? "";
+	const optedIn = isUpdateNoticeStderrOptIn(env);
+	if (isUpdateCheckDisabled(env)) return {
+		eligible: false,
+		reason: "disabled"
+	};
+	if (args.length === 0) return {
+		eligible: false,
+		reason: "no_args"
+	};
+	if (isHelpOrVersion(args)) return {
+		eligible: false,
+		reason: "help_or_version"
+	};
+	if (command === "completion" || command === "__complete") return {
+		eligible: false,
+		reason: "completion"
+	};
+	if (isOutputProduct(args)) return {
+		eligible: false,
+		reason: "output_product"
+	};
+	if (command === "daemon") return {
+		eligible: false,
+		reason: "daemon"
+	};
+	if (command === "code-mode") return {
+		eligible: false,
+		reason: "code_mode"
+	};
+	if (isCi(env) && !optedIn) return {
+		eligible: false,
+		reason: "ci"
+	};
+	if (!input.stderrIsTTY && !optedIn) return {
+		eligible: false,
+		reason: "noninteractive"
+	};
+	if (command === "attach") return optedIn ? {
+		eligible: true,
+		command
+	} : {
+		eligible: false,
+		reason: "stdio"
+	};
+	if (command === "serve") {
+		const transport = optionValue(args, "--transport");
+		const daemonSubcommand = args[1] && !args[1].startsWith("-") ? args[1] : void 0;
+		if (daemonSubcommand === "start" || daemonSubcommand === "enable") return {
+			eligible: false,
+			reason: "daemon"
+		};
+		if (transport === "http" || transport === "sse") return {
+			eligible: true,
+			command
+		};
+		return optedIn ? {
+			eligible: true,
+			command
+		} : {
+			eligible: false,
+			reason: "stdio"
+		};
+	}
+	return {
+		eligible: true,
+		command
+	};
+}
+function isHelpOrVersion(args) {
+	return args.some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-V");
+}
+function isOutputProduct(args) {
+	if (args.some((arg) => arg === "--json" || arg.toLowerCase() === "--format=json")) return true;
+	if (optionValue(args, "--format")?.toLowerCase() === "json") return true;
+	if (args[0] === "config" && (args[1] === "path" || args[1] === "paths")) return true;
+	if (args[0] === "telemetry" && args[1] === "debug") return true;
+	return false;
+}
+function isCi(env) {
+	return isTruthyEnv(env.CI) || isTruthyEnv(env.GITHUB_ACTIONS) || isTruthyEnv(env.BUILDKITE);
+}
+function isTruthyEnv(value) {
+	return value === "1" || value === "true";
+}
+function optionValue(args, name) {
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === name) return args[index + 1];
+		if (arg?.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+	}
+}
+//#endregion
+//#region src/update-check/state.ts
+const UPDATE_CHECK_PACKAGE_NAME = "caplets";
+const UPDATE_CHECK_REGISTRY_URL = "https://registry.npmjs.org/caplets";
+const UPDATE_CHECK_ACCEPT_HEADER = "application/vnd.npm.install-v1+json";
+const UPDATE_CHECK_CACHE_TTL_MS = 1440 * 60 * 1e3;
+const UPDATE_CHECK_MAX_STALE_MS = 10080 * 60 * 1e3;
+const UPDATE_CHECK_NEGATIVE_TTL_MS = 3600 * 1e3;
+const UPDATE_CHECK_MAX_RESPONSE_BYTES = 1024 * 1024;
+function updateCheckCacheDir(options = {}) {
+	return options.cacheDir ?? DEFAULT_UPDATE_CHECK_CACHE_DIR;
+}
+function updateCheckStateDir(options = {}) {
+	return options.stateDir ?? DEFAULT_UPDATE_CHECK_STATE_DIR;
+}
+function updateMetadataCachePath(options = {}) {
+	return join(updateCheckCacheDir(options), "metadata.json");
+}
+function updateRefreshLockPath(options = {}) {
+	return join(updateCheckCacheDir(options), "refresh.lock");
+}
+function updateNoticeStatePath(options = {}) {
+	return join(updateCheckStateDir(options), "notice.json");
+}
+function readUpdateMetadataCache(options = {}) {
+	const now = options.now ?? Date.now();
+	const parsed = readJson(updateMetadataCachePath(options));
+	if (!parsed) return void 0;
+	if (parsed.status === "positive" && isPackageMetadata(parsed.metadata)) return {
+		...parsed,
+		fresh: now <= parsed.expiresAt,
+		usable: now <= parsed.staleUntil
+	};
+	if (parsed.status === "negative" && typeof parsed.reason === "string") return {
+		...parsed,
+		fresh: now <= parsed.expiresAt,
+		usable: now <= parsed.expiresAt
+	};
+}
+function writeUpdateMetadataCache(entry, options = {}) {
+	return writePrivateJson(updateMetadataCachePath(options), entry);
+}
+function readUpdateNoticeState(options = {}) {
+	const parsed = readJson(updateNoticeStatePath(options));
+	if (!parsed?.shown || typeof parsed.shown !== "object" || Array.isArray(parsed.shown)) return { shown: {} };
+	const shown = {};
+	for (const [version, value] of Object.entries(parsed.shown)) if (typeof version === "string" && value && typeof value === "object" && !Array.isArray(value) && typeof value.shownAt === "number") shown[version] = { shownAt: value.shownAt };
+	return { shown };
+}
+function shouldShowUpdateNotice(version, options = {}) {
+	const now = options.now ?? Date.now();
+	const shownAt = readUpdateNoticeState(options).shown[version]?.shownAt;
+	return shownAt === void 0 || now - shownAt >= 6048e5;
+}
+function recordUpdateNoticeShown(version, options = {}) {
+	const now = options.now ?? Date.now();
+	const state = readUpdateNoticeState(options);
+	state.shown[version] = { shownAt: now };
+	return writePrivateJson(updateNoticeStatePath(options), state);
+}
+function acquireUpdateRefreshLock(options = {}) {
+	const now = options.now ?? Date.now();
+	const path = updateRefreshLockPath(options);
+	if (createUpdateRefreshLock(path, now)) return true;
+	const existing = readJson(path);
+	if (typeof existing?.lockedAt === "number" && now - existing.lockedAt < 6e4) return false;
+	if (!existing && !existsSync(path)) return false;
+	try {
+		rmSync(path, { force: true });
+	} catch {
+		return false;
+	}
+	return createUpdateRefreshLock(path, now);
+}
+function releaseUpdateRefreshLock(options = {}) {
+	try {
+		rmSync(updateRefreshLockPath(options), { force: true });
+	} catch {}
+}
+function writePrivateJson(path, value) {
+	try {
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		renameSync(tmp, path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function createUpdateRefreshLock(path, now) {
+	let fd;
+	try {
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		fd = openSync(path, "wx", 384);
+		writeFileSync(fd, `${JSON.stringify({ lockedAt: now }, null, 2)}\n`);
+		return true;
+	} catch {
+		return false;
+	} finally {
+		if (fd !== void 0) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+function readJson(path) {
+	if (!existsSync(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function isPackageMetadata(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value) && value.packageName === "caplets" && typeof value.distTags === "object" && !Array.isArray(value.distTags) && Array.isArray(value.versions);
+}
+//#endregion
+//#region src/update-check/registry.ts
+var UpdateRegistryError = class extends Error {
+	reason;
+	constructor(message, reason) {
+		super(message);
+		this.reason = reason;
+		this.name = "UpdateRegistryError";
+	}
+};
+async function fetchPublicCapletsMetadata(options) {
+	const fetcher = options.fetcher ?? fetch;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+	const abort = () => controller.abort();
+	if (options.signal?.aborted) abort();
+	options.signal?.addEventListener("abort", abort, { once: true });
+	try {
+		const response = await fetcher(UPDATE_CHECK_REGISTRY_URL, {
+			headers: { accept: UPDATE_CHECK_ACCEPT_HEADER },
+			signal: controller.signal,
+			redirect: "error"
+		});
+		if (!response.ok) throw new UpdateRegistryError(`registry responded with ${response.status}`, "http");
+		const text = await readBoundedText(response, options.maxResponseBytes);
+		return parsePackageMetadata(JSON.parse(text));
+	} catch (error) {
+		if (error instanceof UpdateRegistryError) throw error;
+		if (error instanceof DOMException && error.name === "AbortError") throw new UpdateRegistryError("registry refresh timed out", "timeout");
+		if (error instanceof SyntaxError) throw new UpdateRegistryError("registry response was not valid JSON", "invalid");
+		throw new UpdateRegistryError("registry refresh failed", "network");
+	} finally {
+		clearTimeout(timeout);
+		options.signal?.removeEventListener("abort", abort);
+	}
+}
+function parsePackageMetadata(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new UpdateRegistryError("registry metadata was not an object", "invalid");
+	const record = value;
+	if (record.name !== "caplets") throw new UpdateRegistryError("registry metadata package did not match caplets", "invalid");
+	if (!record["dist-tags"] || typeof record["dist-tags"] !== "object") throw new UpdateRegistryError("registry metadata did not include dist-tags", "invalid");
+	const distTags = Object.fromEntries(Object.entries(record["dist-tags"]).filter((entry) => typeof entry[1] === "string"));
+	if (typeof distTags.latest !== "string") throw new UpdateRegistryError("registry metadata did not include dist-tags.latest", "invalid");
+	if (!record.versions || typeof record.versions !== "object" || Array.isArray(record.versions)) throw new UpdateRegistryError("registry metadata did not include versions", "invalid");
+	const versions = Object.keys(record.versions);
+	if (versions.length === 0) throw new UpdateRegistryError("registry metadata included no versions", "invalid");
+	return {
+		packageName: UPDATE_CHECK_PACKAGE_NAME,
+		distTags,
+		versions
+	};
+}
+async function readBoundedText(response, maxBytes = UPDATE_CHECK_MAX_RESPONSE_BYTES) {
+	const contentLength = response.headers.get("content-length");
+	const contentLengthNum = Number(contentLength);
+	if (contentLength && Number.isFinite(contentLengthNum) && contentLengthNum > maxBytes) throw new UpdateRegistryError("registry response was too large", "too_large");
+	if (!response.body) {
+		const text = await response.text();
+		if (new TextEncoder().encode(text).byteLength > maxBytes) throw new UpdateRegistryError("registry response was too large", "too_large");
+		return text;
+	}
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		if (value) {
+			total += value.byteLength;
+			if (total > maxBytes) {
+				await reader.cancel().catch(() => void 0);
+				throw new UpdateRegistryError("registry response was too large", "too_large");
+			}
+			chunks.push(value);
+		}
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(bytes);
+}
+//#endregion
+//#region src/update-check/refresh.ts
+async function refreshUpdateMetadata(options = {}) {
+	const now = options.now ?? Date.now();
+	if (!acquireUpdateRefreshLock({
+		...options,
+		now
+	})) return "skipped";
+	try {
+		const metadata = await fetchPublicCapletsMetadata({
+			fetcher: options.fetcher,
+			signal: options.signal,
+			timeoutMs: options.timeoutMs ?? 250,
+			maxResponseBytes: options.maxResponseBytes ?? 1048576
+		});
+		writeUpdateMetadataCache({
+			status: "positive",
+			fetchedAt: now,
+			expiresAt: now + UPDATE_CHECK_CACHE_TTL_MS,
+			staleUntil: now + UPDATE_CHECK_CACHE_TTL_MS + UPDATE_CHECK_MAX_STALE_MS,
+			source: UPDATE_CHECK_REGISTRY_URL,
+			metadata
+		}, options);
+		return "refreshed";
+	} catch (error) {
+		const existing = readUpdateMetadataCache({
+			...options,
+			now
+		});
+		if (existing?.status === "positive" && existing.usable) return "failed";
+		writeUpdateMetadataCache({
+			status: "negative",
+			fetchedAt: now,
+			expiresAt: now + UPDATE_CHECK_NEGATIVE_TTL_MS,
+			reason: error instanceof UpdateRegistryError ? error.reason : "error"
+		}, options);
+		return "failed";
+	} finally {
+		releaseUpdateRefreshLock(options);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SEMVER_SPEC_VERSION = "2.0.0";
+	const MAX_LENGTH = 256;
+	const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+	module.exports = {
+		MAX_LENGTH,
+		MAX_SAFE_COMPONENT_LENGTH: 16,
+		MAX_SAFE_BUILD_LENGTH: MAX_LENGTH - 6,
+		MAX_SAFE_INTEGER,
+		RELEASE_TYPES: [
+			"major",
+			"premajor",
+			"minor",
+			"preminor",
+			"patch",
+			"prepatch",
+			"prerelease"
+		],
+		SEMVER_SPEC_VERSION,
+		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];
+		return parse(`${major}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, 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) => {
+		return parse(version instanceof SemVer ? version.version : version, 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;
+				break;
+		}
+		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/update-check/version.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
+	};
+})))();
+function findAvailableUpdate(runningVersion, metadata) {
+	const normalizedRunning = runningVersion ? (0, import_semver.valid)(runningVersion) : null;
+	if (!normalizedRunning) return {
+		available: false,
+		reason: "invalid-running-version"
+	};
+	const runningPrerelease = (0, import_semver.prerelease)(normalizedRunning);
+	const latestVersion = (runningPrerelease && runningPrerelease.length > 0 ? prereleaseCandidates(normalizedRunning, metadata.versions) : stableCandidates(metadata)).find((candidate) => (0, import_semver.gt)(candidate, normalizedRunning));
+	if (!latestVersion) return {
+		available: false,
+		reason: "no-eligible-version"
+	};
+	return {
+		available: true,
+		runningVersion: normalizedRunning,
+		latestVersion
+	};
+}
+function stableCandidates(metadata) {
+	const versions = /* @__PURE__ */ new Set();
+	const latest = (0, import_semver.valid)(metadata.distTags.latest);
+	if (latest && !(0, import_semver.prerelease)(latest)) versions.add(latest);
+	for (const version of metadata.versions) {
+		const normalized = (0, import_semver.valid)(version);
+		if (normalized && !(0, import_semver.prerelease)(normalized)) versions.add(normalized);
+	}
+	return [...versions].sort(import_semver.rcompare);
+}
+function prereleaseCandidates(runningVersion, versions) {
+	const running = (0, import_semver.parse)(runningVersion);
+	const runningPrerelease = (0, import_semver.prerelease)(runningVersion);
+	if (!running || !runningPrerelease?.length) return [];
+	const runningIdentifier = String(runningPrerelease[0]);
+	return versions.map((version) => (0, import_semver.valid)(version)).filter((version) => Boolean(version)).filter((version) => {
+		const candidate = (0, import_semver.parse)(version);
+		const candidatePrerelease = (0, import_semver.prerelease)(version);
+		return Boolean(candidate) && candidate.major === running.major && candidate.minor === running.minor && candidate.patch === running.patch && candidatePrerelease?.length !== void 0 && candidatePrerelease.length > 0 && String(candidatePrerelease[0]) === runningIdentifier;
+	}).sort(import_semver.rcompare);
+}
+//#endregion
+//#region src/update-check/notice.ts
+async function maybePrintUpdateNotice(options) {
+	const now = options.now ?? Date.now();
+	const eligibility = classifyUpdateNoticeEligibility({
+		args: options.args,
+		env: options.env,
+		stderrIsTTY: options.stderrIsTTY
+	});
+	if (!options.version) return;
+	const cache = readUpdateMetadataCache({
+		...options,
+		now
+	});
+	if (eligibility.eligible && cache?.status === "positive" && cache.usable) {
+		const update = findAvailableUpdate(options.version, cache.metadata);
+		if (update.available && shouldShowUpdateNotice(update.latestVersion, {
+			...options,
+			now
+		})) try {
+			const line = `Update available: caplets ${update.runningVersion} -> ${update.latestVersion}. Update with your package manager.\n`;
+			if (options.writeErr) options.writeErr(line);
+			else process.stderr.write(line);
+			recordUpdateNoticeShown(update.latestVersion, {
+				...options,
+				now
+			});
+		} catch {}
+	}
+	if ((eligibility.eligible || eligibility.reason === "stdio") && options.refreshForLater && (!cache || cache.status === "positive" && !cache.fresh || cache.status === "negative" && !cache.fresh)) refreshUpdateMetadata({
+		...options,
+		now,
+		fetcher: options.fetcher,
+		signal: options.signal
+	}).catch(() => void 0);
+}
+//#endregion
 //#region src/cli.ts
 async function runCli(args, io = {}) {
 	let observedExitCode = 0;
+	let updateNoticeHandled = false;
 	const wrappedIo = {
 		...io,
 		setExitCode: (code) => {
@@ -15417,6 +17313,22 @@ async function runCli(args, io = {}) {
 			else process.exitCode = code;
 		}
 	};
+	wrappedIo.maybePrintUpdateNotice = async () => {
+		if (updateNoticeHandled) return;
+		updateNoticeHandled = true;
+		await maybePrintUpdateNotice({
+			args,
+			env: wrappedIo.env,
+			version: wrappedIo.version,
+			fetcher: wrappedIo.fetch,
+			signal: wrappedIo.signal,
+			stderrIsTTY: wrappedIo.stderrIsTTY ?? process.stderr.isTTY === true,
+			writeErr: wrappedIo.writeErr,
+			cacheDir: wrappedIo.updateCheckCacheDir ?? defaultUpdateCheckCacheDir(wrappedIo.env),
+			stateDir: wrappedIo.updateCheckStateDir ?? defaultUpdateCheckStateDir(wrappedIo.env),
+			refreshForLater: shouldRefreshUpdateMetadataForLater(args)
+		}).catch(() => void 0);
+	};
 	const program = createProgram(wrappedIo);
 	const trackedCommand = telemetryCommandFamilyFromArgs(args);
 	const startedAt = Date.now();
@@ -15432,6 +17344,7 @@ async function runCli(args, io = {}) {
 			"caplets",
 			...args
 		]);
+		await wrappedIo.maybePrintUpdateNotice();
 		if (trackedCommand) await captureCliTelemetry(telemetryContext, {
 			debugSink: wrappedIo.telemetryDebugSink,
 			dispatcher,
@@ -15463,6 +17376,12 @@ async function runCli(args, io = {}) {
 		await dispatcher.shutdown();
 	}
 }
+function shouldRefreshUpdateMetadataForLater(args) {
+	const command = args[0];
+	if (command === cliCommands$1.serve) return true;
+	if (command !== cliCommands$1.attach) return false;
+	return !args.some((arg) => arg === "--once");
+}
 function normalizeCompletionWords(words) {
 	return words.map((word) => word === "__CAPLETS_TRAILING_SPACE__" ? "" : word);
 }
@@ -16272,6 +18191,7 @@ function createProgram(io = {}) {
 				...io,
 				env: {
 					...env,
+					CAPLETS_DISABLE_UPDATE_CHECK: "1",
 					CAPLETS_TELEMETRY_DEBUG: "1"
 				},
 				telemetryDebugSink: sink,
@@ -16345,7 +18265,7 @@ function createProgram(io = {}) {
 		printTelemetryNotice("serve");
 		const resolved = resolveServeOptions(options);
 		const configPath = currentConfigPath();
-		await (io.serve ?? ((serveOptions) => serveResolvedCaplets(serveOptions, {
+		const runner = io.serve ?? ((serveOptions) => serveResolvedCaplets(serveOptions, {
 			...configPath ? { configPath } : {},
 			...io.authDir ? { authDir: io.authDir } : {},
 			telemetryEnv: env,
@@ -16353,7 +18273,9 @@ function createProgram(io = {}) {
 			telemetrySurface: "serve",
 			telemetryVisibility: "visible",
 			telemetryRuntimeMode: runtimeModeForEnv(env)
-		}, writeErr)))(resolved);
+		}, writeErr));
+		await io.maybePrintUpdateNotice?.();
+		await runner(resolved);
 	});
 	const daemonOptions = () => ({
 		env,
@@ -16489,6 +18411,7 @@ function createProgram(io = {}) {
 			};
 			if (!options.once) {
 				const resolved = await resolveAttachServeOptions(attachOptions, env);
+				await io.maybePrintUpdateNotice?.();
 				await (io.attachServe ?? ((serveOptions) => attachResolvedCaplets(serveOptions, { writeErr })))(resolved);
 				return;
 			}
@@ -16876,17 +18799,16 @@ function createProgram(io = {}) {
 		writeOut(await runSetup(integration, setupOptions));
 	});
 	program.command(cliCommands$1.doctor).description("Diagnose Caplets local, remote, and project-sync configuration.").option("--json", "print JSON output").action(async (options) => {
+		const doctorOptions = {
+			env,
+			...io.authDir ? { authDir: io.authDir } : {},
+			...io.daemon ? { daemon: io.daemon } : {}
+		};
 		if (options.json) {
-			writeOut(`${JSON.stringify(await doctorJsonReport({
-				env,
-				...io.daemon ? { daemon: io.daemon } : {}
-			}), null, 2)}\n`);
+			writeOut(`${JSON.stringify(await doctorJsonReport(doctorOptions), null, 2)}\n`);
 			return;
 		}
-		writeOut(await formatDoctorReport({
-			env,
-			...io.daemon ? { daemon: io.daemon } : {}
-		}));
+		writeOut(await formatDoctorReport(doctorOptions));
 	});
 	const vault = program.command(cliCommands$1.vault).description("Manage Caplets Vault values.");
 	vault.command("set").description("Set a local/global Vault value.").argument("<name>", "Vault key name").option("-g, --global", "target the local/global Vault").option("--remote", "target the selected remote Vault").option("--force", "overwrite an existing Vault value").option("--grant <capletId>", "grant this key to a configured Caplet after setting it").option("--as <referenceName>", "reference name the Caplet uses in config").option("--json", "print JSON output").action(async (name, options) => {