omnius 1.0.899 → 1.0.901

package/dist/update-worker-runtime.js

@@ -57172,7 +57172,7 @@ var require_util = __commonJS({
       return path3;
     }
     exports.normalize = normalize;
-    function join20(aRoot, aPath) {
+    function join22(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -57204,7 +57204,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join20;
+    exports.join = join22;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -57377,7 +57377,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join20(urlGenerate(parsed), sourceURL);
+        sourceURL = join22(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -64716,7 +64716,7 @@ ${lanes.join("\n")}
                 recursionIdentityMap.set(recursionIdentity, recursionToken);
               }
             }
-            const descriptor = {
+            const descriptor2 = {
               id: type.id,
               intrinsicName: type.intrinsicName,
               symbolName: (symbol == null ? void 0 : symbol.escapedName) && unescapeLeadingUnderscores(symbol.escapedName),
@@ -64737,7 +64737,7 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs.writeSync(typesFd, JSON.stringify(descriptor));
+            fs.writeSync(typesFd, JSON.stringify(descriptor2));
             if (i < numTypes - 1) {
               fs.writeSync(typesFd, ",\n");
             }
@@ -67864,7 +67864,7 @@ ${lanes.join("\n")}
             writeOutputIsTTY() {
               return process.stdout.isTTY;
             },
-            readFile,
+            readFile: readFile2,
             writeFile: writeFile2,
             watchFile: watchFile2,
             watchDirectory,
@@ -68070,7 +68070,7 @@ ${lanes.join("\n")}
               callback
             );
           }
-          function readFile(fileName, _encoding) {
+          function readFile2(fileName, _encoding) {
             let buffer;
             try {
               buffer = _fs.readFileSync(fileName);
@@ -90487,7 +90487,7 @@ ${lanes.join("\n")}
             /* AdviseOnEmitNode */
           );
         }
-        function createDecorateHelper(decoratorExpressions, target, memberName, descriptor) {
+        function createDecorateHelper(decoratorExpressions, target, memberName, descriptor2) {
           context.requestEmitHelper(decorateHelper);
           const argumentsArray = [];
           argumentsArray.push(factory2.createArrayLiteralExpression(
@@ -90498,8 +90498,8 @@ ${lanes.join("\n")}
           argumentsArray.push(target);
           if (memberName) {
             argumentsArray.push(memberName);
-            if (descriptor) {
-              argumentsArray.push(descriptor);
+            if (descriptor2) {
+              argumentsArray.push(descriptor2);
             }
           }
           return factory2.createCallExpression(
@@ -104753,7 +104753,7 @@ ${lanes.join("\n")}
         const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
         return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
       }
-      function parseCommandLineWorker(diagnostics, commandLine, readFile) {
+      function parseCommandLineWorker(diagnostics, commandLine, readFile2) {
         const options = {};
         let watchOptions;
         const fileNames = [];
@@ -104801,7 +104801,7 @@ ${lanes.join("\n")}
           }
         }
         function parseResponseFile(fileName) {
-          const text2 = tryReadFile(fileName, readFile || ((fileName2) => sys.readFile(fileName2)));
+          const text2 = tryReadFile(fileName, readFile2 || ((fileName2) => sys.readFile(fileName2)));
           if (!isString(text2)) {
             errors.push(text2);
             return;
@@ -104904,8 +104904,8 @@ ${lanes.join("\n")}
         unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
         optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
       };
-      function parseCommandLine(commandLine, readFile) {
-        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
+      function parseCommandLine(commandLine, readFile2) {
+        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile2);
       }
       function getOptionFromName(optionName, allowShort) {
         return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -104987,8 +104987,8 @@ ${lanes.join("\n")}
           watchOptionsToExtend
         );
       }
-      function readConfigFile(fileName, readFile) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile);
+      function readConfigFile(fileName, readFile2) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile2);
         return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
       }
       function parseConfigFileTextToJson(fileName, jsonText) {
@@ -105003,14 +105003,14 @@ ${lanes.join("\n")}
           error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
         };
       }
-      function readJsonConfigFile(fileName, readFile) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile);
+      function readJsonConfigFile(fileName, readFile2) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile2);
         return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
       }
-      function tryReadFile(fileName, readFile) {
+      function tryReadFile(fileName, readFile2) {
         let text2;
         try {
-          text2 = readFile(fileName);
+          text2 = readFile2(fileName);
         } catch (e) {
           return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
         }
@@ -105292,7 +105292,7 @@ ${lanes.join("\n")}
         const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
         const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
         const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
-        const config = {
+        const config2 = {
           compilerOptions: {
             ...optionMapToObject(optionMap),
             showConfig: void 0,
@@ -105326,8 +105326,8 @@ ${lanes.join("\n")}
             }
           }
         }
-        assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
-        return config;
+        assign(config2.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
+        return config2;
       }
       function optionDependsOn(option, dependsOn) {
         const seen = /* @__PURE__ */ new Set();
@@ -105941,8 +105941,8 @@ ${lanes.join("\n")}
       function shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles, resolutionStack) {
         return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0);
       }
-      function isSolutionConfig(config) {
-        return !config.fileNames.length && hasProperty(config.raw, "references");
+      function isSolutionConfig(config2) {
+        return !config2.fileNames.length && hasProperty(config2.raw, "references");
       }
       function canJsonReportNoInputFiles(raw) {
         return !hasProperty(raw, "files") && !hasProperty(raw, "references");
@@ -169059,8 +169059,8 @@ ${lanes.join("\n")}
             return expression;
           } else {
             const name = isComputedPropertyName(propertyName) ? propertyName.expression : isIdentifier(propertyName) ? factory2.createStringLiteral(unescapeLeadingUnderscores(propertyName.escapedText)) : propertyName;
-            const descriptor = factory2.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
-            return factory2.createObjectDefinePropertyCall(receiver, name, descriptor);
+            const descriptor2 = factory2.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
+            return factory2.createObjectDefinePropertyCall(receiver, name, descriptor2);
           }
         }
         function enableSubstitutionForClassAliases() {
@@ -170384,12 +170384,12 @@ ${lanes.join("\n")}
               /* Ambient */
             )
           );
-          const descriptor = isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull();
+          const descriptor2 = isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull();
           const helper = emitHelpers().createDecorateHelper(
             decoratorExpressions,
             prefix,
             memberName,
-            descriptor
+            descriptor2
           );
           setEmitFlags(
             helper,
@@ -171576,13 +171576,13 @@ ${lanes.join("\n")}
             if (isMethodOrAccessor(member)) {
               const methodExtraInitializersName = isStatic(member) ? classInfo2.staticMethodExtraInitializersName : classInfo2.instanceMethodExtraInitializersName;
               Debug.assertIsDefined(methodExtraInitializersName);
-              let descriptor;
+              let descriptor2;
               if (isPrivateIdentifierClassElementDeclaration(member) && createDescriptor) {
-                descriptor = createDescriptor(member, visitNodes2(modifiers, (node) => tryCast(node, isAsyncModifier), isModifier));
+                descriptor2 = createDescriptor(member, visitNodes2(modifiers, (node) => tryCast(node, isAsyncModifier), isModifier));
                 memberInfo.memberDescriptorName = descriptorName = createHelperVariable(member, "descriptor");
-                descriptor = factory2.createAssignment(descriptorName, descriptor);
+                descriptor2 = factory2.createAssignment(descriptorName, descriptor2);
               }
-              const esDecorateExpression = emitHelpers().createESDecorateHelper(factory2.createThis(), descriptor ?? factory2.createNull(), memberDecoratorsName, context2, factory2.createNull(), methodExtraInitializersName);
+              const esDecorateExpression = emitHelpers().createESDecorateHelper(factory2.createThis(), descriptor2 ?? factory2.createNull(), memberDecoratorsName, context2, factory2.createNull(), methodExtraInitializersName);
               const esDecorateStatement = factory2.createExpressionStatement(esDecorateExpression);
               setSourceMapRange(esDecorateStatement, moveRangePastDecorators(member));
               statements.push(esDecorateStatement);
@@ -171592,19 +171592,19 @@ ${lanes.join("\n")}
               if (isStatic(member)) {
                 thisArg = classInfo2.classThis;
               }
-              let descriptor;
+              let descriptor2;
               if (isPrivateIdentifierClassElementDeclaration(member) && hasAccessorModifier(member) && createDescriptor) {
-                descriptor = createDescriptor(
+                descriptor2 = createDescriptor(
                   member,
                   /*modifiers*/
                   void 0
                 );
                 memberInfo.memberDescriptorName = descriptorName = createHelperVariable(member, "descriptor");
-                descriptor = factory2.createAssignment(descriptorName, descriptor);
+                descriptor2 = factory2.createAssignment(descriptorName, descriptor2);
               }
               const esDecorateExpression = emitHelpers().createESDecorateHelper(
                 isAutoAccessorPropertyDeclaration(member) ? factory2.createThis() : factory2.createNull(),
-                descriptor ?? factory2.createNull(),
+                descriptor2 ?? factory2.createNull(),
                 memberDecoratorsName,
                 context2,
                 initializersName,
@@ -195112,12 +195112,12 @@ ${lanes.join("\n")}
       function createCompilerHost(options, setParentNodes) {
         return createCompilerHostWorker(options, setParentNodes);
       }
-      function createGetSourceFile(readFile, setParentNodes) {
+      function createGetSourceFile(readFile2, setParentNodes) {
         return (fileName, languageVersionOrOptions, onError) => {
           let text2;
           try {
             mark("beforeIORead");
-            text2 = readFile(fileName);
+            text2 = readFile2(fileName);
             mark("afterIORead");
             measure("I/O Read", "beforeIORead", "afterIORead");
           } catch (e) {
@@ -196021,7 +196021,7 @@ ${lanes.join("\n")}
           getRedirectFromOutput,
           forEachResolvedProjectReference: forEachResolvedProjectReference2
         });
-        const readFile = host.readFile.bind(host);
+        const readFile2 = host.readFile.bind(host);
         (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
         (_f = tracing) == null ? void 0 : _f.pop();
@@ -196242,7 +196242,7 @@ ${lanes.join("\n")}
           shouldTransformImportCall,
           emitBuildInfo,
           fileExists,
-          readFile,
+          readFile: readFile2,
           directoryExists,
           getSymlinkCache,
           realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
@@ -203302,12 +203302,12 @@ ${lanes.join("\n")}
             missingFilesMap = void 0;
           }
           if (parsedConfigs) {
-            clearMap(parsedConfigs, (config) => {
+            clearMap(parsedConfigs, (config2) => {
               var _a3;
-              (_a3 = config.watcher) == null ? void 0 : _a3.close();
-              config.watcher = void 0;
-              if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
-              config.watchedDirectories = void 0;
+              (_a3 = config2.watcher) == null ? void 0 : _a3.close();
+              config2.watcher = void 0;
+              if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
+              config2.watchedDirectories = void 0;
             });
             parsedConfigs = void 0;
           }
@@ -203380,8 +203380,8 @@ ${lanes.join("\n")}
               watchConfigFileWildCardDirectories();
               if (configFileName) updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
             } else {
-              const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
-              if (config) watchReferencedProject(configFile, configPath, config);
+              const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
+              if (config2) watchReferencedProject(configFile, configPath, config2);
             }
           });
           staleWatches = void 0;
@@ -203625,30 +203625,30 @@ ${lanes.join("\n")}
         }
         function getParsedCommandLine(configFileName2) {
           const configPath = toPath3(configFileName2);
-          let config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
-          if (config) {
-            if (!config.updateLevel) return config.parsedCommandLine;
-            if (config.parsedCommandLine && config.updateLevel === 1 && !host.getParsedCommandLine) {
+          let config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
+          if (config2) {
+            if (!config2.updateLevel) return config2.parsedCommandLine;
+            if (config2.parsedCommandLine && config2.updateLevel === 1 && !host.getParsedCommandLine) {
               writeLog("Reloading new file names and options");
               Debug.assert(compilerOptions);
               const fileNames = getFileNamesFromConfigSpecs(
-                config.parsedCommandLine.options.configFile.configFileSpecs,
+                config2.parsedCommandLine.options.configFile.configFileSpecs,
                 getNormalizedAbsolutePath(getDirectoryPath(configFileName2), currentDirectory),
                 compilerOptions,
                 parseConfigFileHost
               );
-              config.parsedCommandLine = { ...config.parsedCommandLine, fileNames };
-              config.updateLevel = void 0;
-              return config.parsedCommandLine;
+              config2.parsedCommandLine = { ...config2.parsedCommandLine, fileNames };
+              config2.updateLevel = void 0;
+              return config2.parsedCommandLine;
             }
           }
           writeLog(`Loading config file: ${configFileName2}`);
           const parsedCommandLine = host.getParsedCommandLine ? host.getParsedCommandLine(configFileName2) : getParsedCommandLineFromConfigFileHost(configFileName2);
-          if (config) {
-            config.parsedCommandLine = parsedCommandLine;
-            config.updateLevel = void 0;
+          if (config2) {
+            config2.parsedCommandLine = parsedCommandLine;
+            config2.updateLevel = void 0;
           } else {
-            (parsedConfigs || (parsedConfigs = /* @__PURE__ */ new Map())).set(configPath, config = { parsedCommandLine });
+            (parsedConfigs || (parsedConfigs = /* @__PURE__ */ new Map())).set(configPath, config2 = { parsedCommandLine });
           }
           (staleWatches ?? (staleWatches = /* @__PURE__ */ new Map())).set(configPath, configFileName2);
           return parsedCommandLine;
@@ -203670,11 +203670,11 @@ ${lanes.join("\n")}
         function onReleaseParsedCommandLine(fileName) {
           var _a3;
           const path3 = toPath3(fileName);
-          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path3);
-          if (!config) return;
+          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path3);
+          if (!config2) return;
           parsedConfigs.delete(path3);
-          if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
-          (_a3 = config.watcher) == null ? void 0 : _a3.close();
+          if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
+          (_a3 = config2.watcher) == null ? void 0 : _a3.close();
           clearSharedExtendedConfigFileWatcher(path3, sharedExtendedConfigFileWatchers);
         }
         function watchFilePath(path3, file, callback, pollingInterval, options, watchType) {
@@ -203770,8 +203770,8 @@ ${lanes.join("\n")}
                   if (configFileName && toPath3(configFileName) === projectPath) {
                     updateLevel = 2;
                   } else {
-                    const config = parsedConfigs == null ? void 0 : parsedConfigs.get(projectPath);
-                    if (config) config.updateLevel = 2;
+                    const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(projectPath);
+                    if (config2) config2.updateLevel = 2;
                     resolutionCache.removeResolutionsFromProjectReferenceRedirects(projectPath);
                   }
                   scheduleProgramUpdate();
@@ -203790,8 +203790,8 @@ ${lanes.join("\n")}
             configFileName2,
             (_fileName, eventKind) => {
               updateCachedSystemWithFile(configFileName2, configPath, eventKind);
-              const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
-              if (config) config.updateLevel = 2;
+              const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
+              if (config2) config2.updateLevel = 2;
               resolutionCache.removeResolutionsFromProjectReferenceRedirects(configPath);
               scheduleProgramUpdate();
             },
@@ -203812,22 +203812,22 @@ ${lanes.join("\n")}
                     cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
                   }
                   nextSourceFileVersion(fileOrDirectoryPath);
-                  const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
-                  if (!(config == null ? void 0 : config.parsedCommandLine)) return;
+                  const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
+                  if (!(config2 == null ? void 0 : config2.parsedCommandLine)) return;
                   if (isIgnoredFileFromWildCardWatching({
                     watchedDirPath: toPath3(directory),
                     fileOrDirectory,
                     fileOrDirectoryPath,
                     configFileName: configFileName2,
-                    options: config.parsedCommandLine.options,
-                    program: config.parsedCommandLine.fileNames,
+                    options: config2.parsedCommandLine.options,
+                    program: config2.parsedCommandLine.fileNames,
                     currentDirectory,
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
                     writeLog,
                     toPath: toPath3
                   })) return;
-                  if (config.updateLevel !== 2) {
-                    config.updateLevel = 1;
+                  if (config2.updateLevel !== 2) {
+                    config2.updateLevel = 1;
                     scheduleProgramUpdate();
                   }
                 },
@@ -204318,29 +204318,29 @@ ${lanes.join("\n")}
         state.projectPendingBuild.delete(projectPath);
         return state.diagnostics.has(projectPath) ? 1 : 0;
       }
-      function createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder) {
+      function createUpdateOutputFileStampsProject(state, project, projectPath, config2, buildOrder) {
         let updateOutputFileStampsPending = true;
         return {
           kind: 1,
           project,
           projectPath,
           buildOrder,
-          getCompilerOptions: () => config.options,
+          getCompilerOptions: () => config2.options,
           getCurrentDirectory: () => state.compilerHost.getCurrentDirectory(),
           updateOutputFileStatmps: () => {
-            updateOutputTimestamps(state, config, projectPath);
+            updateOutputTimestamps(state, config2, projectPath);
             updateOutputFileStampsPending = false;
           },
           done: () => {
             if (updateOutputFileStampsPending) {
-              updateOutputTimestamps(state, config, projectPath);
+              updateOutputTimestamps(state, config2, projectPath);
             }
             mark("SolutionBuilder::Timestamps only updates");
             return doneInvalidatedProject(state, projectPath);
           }
         };
       }
-      function createBuildOrUpdateInvalidedProject(state, project, projectPath, projectIndex, config, status, buildOrder) {
+      function createBuildOrUpdateInvalidedProject(state, project, projectPath, projectIndex, config2, status, buildOrder) {
         let step = 0;
         let program;
         let buildResult;
@@ -204349,7 +204349,7 @@ ${lanes.join("\n")}
           project,
           projectPath,
           buildOrder,
-          getCompilerOptions: () => config.options,
+          getCompilerOptions: () => config2.options,
           getCurrentDirectory: () => state.compilerHost.getCurrentDirectory(),
           getBuilderProgram: () => withProgramOrUndefined(identity),
           getProgram: () => withProgramOrUndefined(
@@ -204421,23 +204421,23 @@ ${lanes.join("\n")}
             return;
           }
           if (state.options.verbose) reportStatus(state, Diagnostics.Building_project_0, project);
-          if (config.fileNames.length === 0) {
-            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
+          if (config2.fileNames.length === 0) {
+            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config2));
             buildResult = 0;
             step = 2;
             return;
           }
           const { host, compilerHost } = state;
-          state.projectCompilerOptions = config.options;
-          (_a3 = state.moduleResolutionCache) == null ? void 0 : _a3.update(config.options);
-          (_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config.options);
+          state.projectCompilerOptions = config2.options;
+          (_a3 = state.moduleResolutionCache) == null ? void 0 : _a3.update(config2.options);
+          (_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config2.options);
           program = host.createProgram(
-            config.fileNames,
-            config.options,
+            config2.fileNames,
+            config2.options,
             compilerHost,
-            getOldProgram(state, projectPath, config),
-            getConfigFileParsingDiagnostics(config),
-            config.projectReferences
+            getOldProgram(state, projectPath, config2),
+            getConfigFileParsingDiagnostics(config2),
+            config2.projectReferences
           );
           if (state.watch) {
             const internalMap = (_c = state.moduleResolutionCache) == null ? void 0 : _c.getPackageJsonInfoCache().getInternalMap();
@@ -204512,7 +204512,7 @@ ${lanes.join("\n")}
             customTransformers || ((_b = (_a3 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a3, project))
           );
           if ((!options.noEmitOnError || !diagnostics.length) && (emittedOutputs.size || status.type !== 8)) {
-            updateOutputTimestampsWorker(state, config, projectPath, Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
+            updateOutputTimestampsWorker(state, config2, projectPath, Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
           }
           state.projectErrorsReported.set(projectPath, true);
           buildResult = ((_c = program.hasChangedEmitSignature) == null ? void 0 : _c.call(program)) ? 0 : 2;
@@ -204520,7 +204520,7 @@ ${lanes.join("\n")}
             state.diagnostics.delete(projectPath);
             state.projectStatus.set(projectPath, {
               type: 1,
-              oldestOutputFileName: firstOrUndefinedIterator(emittedOutputs.values()) ?? getFirstProjectOutput(config, !host.useCaseSensitiveFileNames())
+              oldestOutputFileName: firstOrUndefinedIterator(emittedOutputs.values()) ?? getFirstProjectOutput(config2, !host.useCaseSensitiveFileNames())
             });
           } else {
             state.diagnostics.set(projectPath, diagnostics);
@@ -204542,7 +204542,7 @@ ${lanes.join("\n")}
                 emit(writeFile2, cancellationToken, customTransformers);
                 break;
               case 2:
-                queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
+                queueReferencingProjects(state, project, projectPath, projectIndex, config2, buildOrder, Debug.checkDefined(buildResult));
                 step++;
                 break;
               // Should never be done
@@ -204567,35 +204567,35 @@ ${lanes.join("\n")}
             reportQueue = false;
             reportBuildQueue(state, buildOrder);
           }
-          const config = parseConfigFile(state, project, projectPath);
-          if (!config) {
+          const config2 = parseConfigFile(state, project, projectPath);
+          if (!config2) {
             reportParseConfigFileDiagnostic(state, projectPath);
             projectPendingBuild.delete(projectPath);
             continue;
           }
           if (updateLevel === 2) {
-            watchConfigFile(state, project, projectPath, config);
-            watchExtendedConfigFiles(state, projectPath, config);
-            watchWildCardDirectories(state, project, projectPath, config);
-            watchInputFiles(state, project, projectPath, config);
-            watchPackageJsonFiles(state, project, projectPath, config);
+            watchConfigFile(state, project, projectPath, config2);
+            watchExtendedConfigFiles(state, projectPath, config2);
+            watchWildCardDirectories(state, project, projectPath, config2);
+            watchInputFiles(state, project, projectPath, config2);
+            watchPackageJsonFiles(state, project, projectPath, config2);
           } else if (updateLevel === 1) {
-            config.fileNames = getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, getDirectoryPath(project), config.options, state.parseConfigFileHost);
+            config2.fileNames = getFileNamesFromConfigSpecs(config2.options.configFile.configFileSpecs, getDirectoryPath(project), config2.options, state.parseConfigFileHost);
             updateErrorForNoInputFiles(
-              config.fileNames,
+              config2.fileNames,
               project,
-              config.options.configFile.configFileSpecs,
-              config.errors,
-              canJsonReportNoInputFiles(config.raw)
+              config2.options.configFile.configFileSpecs,
+              config2.errors,
+              canJsonReportNoInputFiles(config2.raw)
             );
-            watchInputFiles(state, project, projectPath, config);
-            watchPackageJsonFiles(state, project, projectPath, config);
+            watchInputFiles(state, project, projectPath, config2);
+            watchPackageJsonFiles(state, project, projectPath, config2);
           }
-          const status = getUpToDateStatus(state, config, projectPath);
+          const status = getUpToDateStatus(state, config2, projectPath);
           if (!options.force) {
             if (status.type === 1) {
               verboseReportProjectStatus(state, project, status);
-              reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
+              reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config2));
               projectPendingBuild.delete(projectPath);
               if (options.dry) {
                 reportStatus(state, Diagnostics.Project_0_is_up_to_date, project);
@@ -204603,20 +204603,20 @@ ${lanes.join("\n")}
               continue;
             }
             if (status.type === 2 || status.type === 15) {
-              reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
+              reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config2));
               return {
                 kind: 1,
                 status,
                 project,
                 projectPath,
                 projectIndex,
-                config
+                config: config2
               };
             }
           }
           if (status.type === 12) {
             verboseReportProjectStatus(state, project, status);
-            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
+            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config2));
             projectPendingBuild.delete(projectPath);
             if (options.verbose) {
               reportStatus(
@@ -204630,7 +204630,7 @@ ${lanes.join("\n")}
           }
           if (status.type === 16) {
             verboseReportProjectStatus(state, project, status);
-            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
+            reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config2));
             projectPendingBuild.delete(projectPath);
             continue;
           }
@@ -204640,7 +204640,7 @@ ${lanes.join("\n")}
             project,
             projectPath,
             projectIndex,
-            config
+            config: config2
           };
         }
         return void 0;
@@ -205078,9 +205078,9 @@ ${lanes.join("\n")}
           oldestOutputFileName: getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
         });
       }
-      function queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, buildResult) {
+      function queueReferencingProjects(state, project, projectPath, projectIndex, config2, buildOrder, buildResult) {
         if (state.options.stopBuildOnErrors && buildResult & 4) return;
-        if (!config.options.composite) return;
+        if (!config2.options.composite) return;
         for (let index = projectIndex + 1; index < buildOrder.length; index++) {
           const nextProject = buildOrder[index];
           const nextProjectPath = toResolvedConfigFilePath(state, nextProject);
@@ -206442,8 +206442,8 @@ ${lanes.join("\n")}
       function createReportErrorSummary(sys2, options) {
         return shouldBePretty(sys2, options) ? (errorCount, filesInError) => sys2.write(getErrorSummaryText(errorCount, filesInError, sys2.newLine, sys2)) : void 0;
       }
-      function performCompilation(sys2, cb, reportDiagnostic, config) {
-        const { fileNames, options, projectReferences } = config;
+      function performCompilation(sys2, cb, reportDiagnostic, config2) {
+        const { fileNames, options, projectReferences } = config2;
         const host = createCompilerHostWorker(
           options,
           /*setParentNodes*/
@@ -206465,7 +206465,7 @@ ${lanes.join("\n")}
           options,
           projectReferences,
           host,
-          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config)
+          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config2)
         };
         const program = createProgram(programOptions);
         const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
@@ -206483,8 +206483,8 @@ ${lanes.join("\n")}
         cb(program);
         return sys2.exit(exitStatus);
       }
-      function performIncrementalCompilation2(sys2, cb, reportDiagnostic, config) {
-        const { options, fileNames, projectReferences } = config;
+      function performIncrementalCompilation2(sys2, cb, reportDiagnostic, config2) {
+        const { options, fileNames, projectReferences } = config2;
         enableStatisticsAndTracing(
           sys2,
           options,
@@ -206498,7 +206498,7 @@ ${lanes.join("\n")}
           system: sys2,
           rootNames: fileNames,
           options,
-          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config),
+          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config2),
           projectReferences,
           reportDiagnostic,
           reportErrorSummary: createReportErrorSummary(sys2, options),
@@ -220150,37 +220150,37 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             return containingFunction ? [containingFunction, containingClass] : [containingClass];
           }
         }
-        const scopes = [];
+        const scopes2 = [];
         while (true) {
           current = current.parent;
           if (current.kind === 170) {
             current = findAncestor(current, (parent2) => isFunctionLikeDeclaration(parent2)).parent;
           }
           if (isScope(current)) {
-            scopes.push(current);
+            scopes2.push(current);
             if (current.kind === 308) {
-              return scopes;
+              return scopes2;
             }
           }
         }
       }
       function getFunctionExtractionAtIndex(targetRange, context, requestedChangesIndex) {
-        const { scopes, readsAndWrites: { target, usagesPerScope, functionErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
+        const { scopes: scopes2, readsAndWrites: { target, usagesPerScope, functionErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
         Debug.assert(!functionErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
         context.cancellationToken.throwIfCancellationRequested();
-        return extractFunctionInScope(target, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], exposedVariableDeclarations, targetRange, context);
+        return extractFunctionInScope(target, scopes2[requestedChangesIndex], usagesPerScope[requestedChangesIndex], exposedVariableDeclarations, targetRange, context);
       }
       function getConstantExtractionAtIndex(targetRange, context, requestedChangesIndex) {
-        const { scopes, readsAndWrites: { target, usagesPerScope, constantErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
+        const { scopes: scopes2, readsAndWrites: { target, usagesPerScope, constantErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
         Debug.assert(!constantErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
         Debug.assert(exposedVariableDeclarations.length === 0, "Extract constant accepted a range containing a variable declaration?");
         context.cancellationToken.throwIfCancellationRequested();
         const expression = isExpression(target) ? target : target.statements[0].expression;
-        return extractConstantInScope(expression, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], targetRange.facts, context);
+        return extractConstantInScope(expression, scopes2[requestedChangesIndex], usagesPerScope[requestedChangesIndex], targetRange.facts, context);
       }
       function getPossibleExtractions(targetRange, context) {
-        const { scopes, affectedTextRange, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
-        const extractions = scopes.map((scope, i) => {
+        const { scopes: scopes2, affectedTextRange, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
+        const extractions = scopes2.map((scope, i) => {
           const functionDescriptionPart = getDescriptionForFunctionInScope(scope);
           const constantDescriptionPart = getDescriptionForConstantInScope(scope);
           const scopeDescription = isFunctionLikeDeclaration(scope) ? getDescriptionForFunctionLikeDeclaration(scope) : isClassLike(scope) ? getDescriptionForClassLikeDeclaration(scope) : getDescriptionForModuleLikeDeclaration(scope);
@@ -220214,17 +220214,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       function getPossibleExtractionsWorker(targetRange, context) {
         const { file: sourceFile } = context;
-        const scopes = collectEnclosingScopes(targetRange);
+        const scopes2 = collectEnclosingScopes(targetRange);
         const enclosingTextRange = getEnclosingTextRange(targetRange, sourceFile);
         const readsAndWrites = collectReadsAndWrites(
           targetRange,
-          scopes,
+          scopes2,
           enclosingTextRange,
           sourceFile,
           context.program.getTypeChecker(),
           context.cancellationToken
         );
-        return { scopes, affectedTextRange: enclosingTextRange, readsAndWrites };
+        return { scopes: scopes2, affectedTextRange: enclosingTextRange, readsAndWrites };
       }
       function getDescriptionForFunctionInScope(scope) {
         return isFunctionLikeDeclaration(scope) ? "inner function" : isClassLike(scope) ? "method" : "function";
@@ -221018,7 +221018,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getEnclosingTextRange(targetRange, sourceFile) {
         return isReadonlyArray(targetRange.range) ? { pos: first(targetRange.range).getStart(sourceFile), end: last(targetRange.range).getEnd() } : targetRange.range;
       }
-      function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, checker, cancellationToken) {
+      function collectReadsAndWrites(targetRange, scopes2, enclosingTextRange, sourceFile, checker, cancellationToken) {
         const allTypeParameterUsages = /* @__PURE__ */ new Map();
         const usagesPerScope = [];
         const substitutionsPerScope = [];
@@ -221038,7 +221038,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         } else if (checker.getTypeAtLocation(expression).flags & (16 | 262144)) {
           expressionDiagnostic = createDiagnosticForNode(expression, Messages.uselessConstantType);
         }
-        for (const scope of scopes) {
+        for (const scope of scopes2) {
           usagesPerScope.push({ usages: /* @__PURE__ */ new Map(), typeParameterUsages: /* @__PURE__ */ new Map(), substitutions: /* @__PURE__ */ new Map() });
           substitutionsPerScope.push(/* @__PURE__ */ new Map());
           functionErrorsPerScope.push([]);
@@ -221066,8 +221066,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (allTypeParameterUsages.size > 0) {
           const seenTypeParameterUsages = /* @__PURE__ */ new Map();
           let i = 0;
-          for (let curr = unmodifiedNode; curr !== void 0 && i < scopes.length; curr = curr.parent) {
-            if (curr === scopes[i]) {
+          for (let curr = unmodifiedNode; curr !== void 0 && i < scopes2.length; curr = curr.parent) {
+            if (curr === scopes2[i]) {
               seenTypeParameterUsages.forEach((typeParameter, id2) => {
                 usagesPerScope[i].typeParameterUsages.set(id2, typeParameter);
               });
@@ -221082,19 +221082,19 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               }
             }
           }
-          Debug.assert(i === scopes.length, "Should have iterated all scopes");
+          Debug.assert(i === scopes2.length, "Should have iterated all scopes");
         }
         if (visibleDeclarationsInExtractedRange.length) {
-          const containingLexicalScopeOfExtraction = isBlockScope(scopes[0], scopes[0].parent) ? scopes[0] : getEnclosingBlockScopeContainer(scopes[0]);
+          const containingLexicalScopeOfExtraction = isBlockScope(scopes2[0], scopes2[0].parent) ? scopes2[0] : getEnclosingBlockScopeContainer(scopes2[0]);
           forEachChild(containingLexicalScopeOfExtraction, checkForUsedDeclarations);
         }
-        for (let i = 0; i < scopes.length; i++) {
+        for (let i = 0; i < scopes2.length; i++) {
           const scopeUsages = usagesPerScope[i];
           if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) {
             const errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range;
             constantErrorsPerScope[i].push(createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes));
           }
-          if (targetRange.facts & 16 && isClassLike(scopes[i])) {
+          if (targetRange.facts & 16 && isClassLike(scopes2[i])) {
             functionErrorsPerScope[i].push(createDiagnosticForNode(targetRange.thisNode, Messages.cannotExtractFunctionsContainingThisToMethod));
           }
           let hasWrite = false;
@@ -221185,7 +221185,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         function recordUsage(n, usage, isTypeNode2) {
           const symbolId = recordUsagebySymbol(n, usage, isTypeNode2);
           if (symbolId) {
-            for (let i = 0; i < scopes.length; i++) {
+            for (let i = 0; i < scopes2.length; i++) {
               const substitution = substitutionsPerScope[i].get(symbolId);
               if (substitution) {
                 usagesPerScope[i].substitutions.set(getNodeId(n).toString(), substitution);
@@ -221230,8 +221230,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               errors.push(diag2);
             }
           }
-          for (let i = 0; i < scopes.length; i++) {
-            const scope = scopes[i];
+          for (let i = 0; i < scopes2.length; i++) {
+            const scope = scopes2[i];
             const resolvedSymbol = checker.resolveName(
               symbol.name,
               scope,
@@ -223856,36 +223856,36 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const range2 = ts_formatting_exports.getRangeOfEnclosingComment(sourceFile, position);
           return range2 && (!onlyMultiLine || range2.kind === 3) ? createTextSpanFromRange(range2) : void 0;
         }
-        function getTodoComments(fileName, descriptors) {
+        function getTodoComments(fileName, descriptors2) {
           synchronizeHostData();
           const sourceFile = getValidSourceFile(fileName);
           cancellationToken.throwIfCancellationRequested();
           const fileContents = sourceFile.text;
           const result = [];
-          if (descriptors.length > 0 && !isNodeModulesFile(sourceFile.fileName)) {
+          if (descriptors2.length > 0 && !isNodeModulesFile(sourceFile.fileName)) {
             const regExp = getTodoCommentsRegExp();
             let matchArray;
             while (matchArray = regExp.exec(fileContents)) {
               cancellationToken.throwIfCancellationRequested();
               const firstDescriptorCaptureIndex = 3;
-              Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
+              Debug.assert(matchArray.length === descriptors2.length + firstDescriptorCaptureIndex);
               const preamble = matchArray[1];
               const matchPosition = matchArray.index + preamble.length;
               if (!isInComment(sourceFile, matchPosition)) {
                 continue;
               }
-              let descriptor;
-              for (let i = 0; i < descriptors.length; i++) {
+              let descriptor2;
+              for (let i = 0; i < descriptors2.length; i++) {
                 if (matchArray[i + firstDescriptorCaptureIndex]) {
-                  descriptor = descriptors[i];
+                  descriptor2 = descriptors2[i];
                 }
               }
-              if (descriptor === void 0) return Debug.fail();
-              if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
+              if (descriptor2 === void 0) return Debug.fail();
+              if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor2.text.length))) {
                 continue;
               }
               const message = matchArray[2];
-              result.push({ descriptor, message, position: matchPosition });
+              result.push({ descriptor: descriptor2, message, position: matchPosition });
             }
           }
           return result;
@@ -223897,7 +223897,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             const multiLineCommentStart = /(?:\/\*+\s*)/.source;
             const anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
             const preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
-            const literals = "(?:" + map(descriptors, (d) => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
+            const literals = "(?:" + map(descriptors2, (d) => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
             const endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
             const messageRemainder = /(?:.*?)/.source;
             const messagePortion = "(" + literals + messageRemainder + ")";
@@ -225273,8 +225273,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       function getFixes(context) {
         const diagnostics = getDiagnostics(context);
-        const registrations = errorCodeToFixes.get(String(context.errorCode));
-        return flatMap(registrations, (f) => map(f.getCodeActions(context), removeFixIdIfFixAllUnavailable(f, diagnostics)));
+        const registrations2 = errorCodeToFixes.get(String(context.errorCode));
+        return flatMap(registrations2, (f) => map(f.getCodeActions(context), removeFixIdIfFixAllUnavailable(f, diagnostics)));
       }
       function getAllFixes(context) {
         return fixIdToRegistration.get(cast(context.fixId, isString)).getAllCodeActions(context);
@@ -262727,18 +262727,18 @@ ${options.prefix}` : "\n" : options.prefix
         /**
          * This is to watch whenever files are added or removed to the wildcard directories
          */
-        watchWildcardDirectory(directory, flags, configFileName, config) {
+        watchWildcardDirectory(directory, flags, configFileName, config2) {
           let watcher = this.watchFactory.watchDirectory(
             directory,
             (fileOrDirectory) => this.onWildCardDirectoryWatcherInvoke(
               directory,
               configFileName,
-              config,
+              config2,
               result,
               fileOrDirectory
             ),
             flags,
-            this.getWatchOptionsFromProjectWatchOptions(config.parsedCommandLine.watchOptions, getDirectoryPath(configFileName)),
+            this.getWatchOptionsFromProjectWatchOptions(config2.parsedCommandLine.watchOptions, getDirectoryPath(configFileName)),
             WatchType.WildcardDirectory,
             configFileName
           );
@@ -262759,9 +262759,9 @@ ${options.prefix}` : "\n" : options.prefix
           };
           return result;
         }
-        onWildCardDirectoryWatcherInvoke(directory, configFileName, config, wildCardWatcher, fileOrDirectory) {
+        onWildCardDirectoryWatcherInvoke(directory, configFileName, config2, wildCardWatcher, fileOrDirectory) {
           const fileOrDirectoryPath = this.toPath(fileOrDirectory);
-          const fsResult = config.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
+          const fsResult = config2.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
           if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) && (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectory))) {
             const file = this.getNormalizedAbsolutePath(fileOrDirectory);
             this.logger.info(`Config: ${configFileName} Detected new package.json: ${file}`);
@@ -262779,15 +262779,15 @@ ${options.prefix}` : "\n" : options.prefix
             configFileName,
             extraFileExtensions: this.hostConfiguration.extraFileExtensions,
             currentDirectory: this.currentDirectory,
-            options: config.parsedCommandLine.options,
-            program: (configuredProjectForConfig == null ? void 0 : configuredProjectForConfig.getCurrentProgram()) || config.parsedCommandLine.fileNames,
+            options: config2.parsedCommandLine.options,
+            program: (configuredProjectForConfig == null ? void 0 : configuredProjectForConfig.getCurrentProgram()) || config2.parsedCommandLine.fileNames,
             useCaseSensitiveFileNames: this.host.useCaseSensitiveFileNames,
             writeLog: (s) => this.logger.info(s),
             toPath: (s) => this.toPath(s),
             getScriptKind: configuredProjectForConfig ? ((fileName) => configuredProjectForConfig.getScriptKind(fileName)) : void 0
           })) return;
-          if (config.updateLevel !== 2) config.updateLevel = 1;
-          config.projects.forEach((watchWildcardDirectories, projectCanonicalPath) => {
+          if (config2.updateLevel !== 2) config2.updateLevel = 1;
+          config2.projects.forEach((watchWildcardDirectories, projectCanonicalPath) => {
             var _a3;
             if (!watchWildcardDirectories) return;
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
@@ -263251,9 +263251,9 @@ ${options.prefix}` : "\n" : options.prefix
         /** Caches the configFilename for script info or ancestor of open script info */
         setConfigFileNameForFileInCache(info, configFileName) {
           if (!this.openFiles.has(info.path)) return;
-          const config = configFileName || false;
+          const config2 = configFileName || false;
           if (!isAncestorConfigFileInfo(info)) {
-            this.configFileForOpenFiles.set(info.path, config);
+            this.configFileForOpenFiles.set(info.path, config2);
           } else {
             let configFileForOpenFile = this.configFileForOpenFiles.get(info.path);
             if (!configFileForOpenFile || isString(configFileForOpenFile)) {
@@ -263262,7 +263262,7 @@ ${options.prefix}` : "\n" : options.prefix
                 configFileForOpenFile = (/* @__PURE__ */ new Map()).set(false, configFileForOpenFile)
               );
             }
-            configFileForOpenFile.set(info.fileName, config);
+            configFileForOpenFile.set(info.fileName, config2);
           }
         }
         /**
@@ -263585,22 +263585,22 @@ ${options.prefix}` : "\n" : options.prefix
           return configFileExistenceInfo;
         }
         /** @internal */
-        watchWildcards(configFileName, { exists, config }, forProject) {
-          config.projects.set(forProject.canonicalConfigFilePath, true);
+        watchWildcards(configFileName, { exists, config: config2 }, forProject) {
+          config2.projects.set(forProject.canonicalConfigFilePath, true);
           if (exists) {
-            if (config.watchedDirectories && !config.watchedDirectoriesStale) return;
-            config.watchedDirectoriesStale = false;
+            if (config2.watchedDirectories && !config2.watchedDirectoriesStale) return;
+            config2.watchedDirectoriesStale = false;
             updateWatchingWildcardDirectories(
-              config.watchedDirectories || (config.watchedDirectories = /* @__PURE__ */ new Map()),
-              config.parsedCommandLine.wildcardDirectories,
+              config2.watchedDirectories || (config2.watchedDirectories = /* @__PURE__ */ new Map()),
+              config2.parsedCommandLine.wildcardDirectories,
               // Create new directory watcher
-              (directory, flags) => this.watchWildcardDirectory(directory, flags, configFileName, config)
+              (directory, flags) => this.watchWildcardDirectory(directory, flags, configFileName, config2)
             );
           } else {
-            config.watchedDirectoriesStale = false;
-            if (!config.watchedDirectories) return;
-            clearMap(config.watchedDirectories, closeFileWatcherOf);
-            config.watchedDirectories = void 0;
+            config2.watchedDirectoriesStale = false;
+            if (!config2.watchedDirectories) return;
+            clearMap(config2.watchedDirectories, closeFileWatcherOf);
+            config2.watchedDirectories = void 0;
           }
         }
         /** @internal */
@@ -263700,11 +263700,11 @@ ${options.prefix}` : "\n" : options.prefix
          * @internal
          */
         reloadFileNamesOfConfiguredProject(project) {
-          const config = this.reloadFileNamesOfParsedConfig(project.getConfigFilePath(), this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath).config);
-          project.updateErrorOnNoInputFiles(config);
+          const config2 = this.reloadFileNamesOfParsedConfig(project.getConfigFilePath(), this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath).config);
+          project.updateErrorOnNoInputFiles(config2);
           this.updateNonInferredProjectFiles(
             project,
-            config.fileNames.concat(project.getExternalFiles(
+            config2.fileNames.concat(project.getExternalFiles(
               1
               /* RootNamesAndUpdate */
             )),
@@ -263713,23 +263713,23 @@ ${options.prefix}` : "\n" : options.prefix
           project.markAsDirty();
           return project.updateGraph();
         }
-        reloadFileNamesOfParsedConfig(configFileName, config) {
-          if (config.updateLevel === void 0) return config.parsedCommandLine;
+        reloadFileNamesOfParsedConfig(configFileName, config2) {
+          if (config2.updateLevel === void 0) return config2.parsedCommandLine;
           Debug.assert(
-            config.updateLevel === 1
+            config2.updateLevel === 1
             /* RootNamesAndUpdate */
           );
-          const configFileSpecs = config.parsedCommandLine.options.configFile.configFileSpecs;
+          const configFileSpecs = config2.parsedCommandLine.options.configFile.configFileSpecs;
           const fileNames = getFileNamesFromConfigSpecs(
             configFileSpecs,
             getDirectoryPath(configFileName),
-            config.parsedCommandLine.options,
-            config.cachedDirectoryStructureHost,
+            config2.parsedCommandLine.options,
+            config2.cachedDirectoryStructureHost,
             this.hostConfiguration.extraFileExtensions
           );
-          config.parsedCommandLine = { ...config.parsedCommandLine, fileNames };
-          config.updateLevel = void 0;
-          return config.parsedCommandLine;
+          config2.parsedCommandLine = { ...config2.parsedCommandLine, fileNames };
+          config2.updateLevel = void 0;
+          return config2.parsedCommandLine;
         }
         /** @internal */
         setFileNamesOfAutoImportProviderOrAuxillaryProject(project, fileNames) {
@@ -264735,14 +264735,14 @@ Dynamic files must always be opened with service's current directory or service
             reloadedProjects
           );
         }
-        isMatchedByConfig(configFileName, config, info) {
-          if (config.fileNames.some((rootName) => this.toPath(rootName) === info.path)) return true;
+        isMatchedByConfig(configFileName, config2, info) {
+          if (config2.fileNames.some((rootName) => this.toPath(rootName) === info.path)) return true;
           if (isSupportedSourceFileName(
             info.fileName,
-            config.options,
+            config2.options,
             this.hostConfiguration.extraFileExtensions
           )) return false;
-          const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = config.options.configFile.configFileSpecs;
+          const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = config2.options.configFile.configFileSpecs;
           const basePath = toNormalizedPath(getNormalizedAbsolutePath(getDirectoryPath(configFileName), this.currentDirectory));
           if (validatedFilesSpec == null ? void 0 : validatedFilesSpec.some((fileSpec) => this.toPath(getNormalizedAbsolutePath(fileSpec, basePath)) === info.path)) return true;
           if (!(validatedIncludeSpecs == null ? void 0 : validatedIncludeSpecs.length)) return false;
@@ -264959,7 +264959,7 @@ Dynamic files must always be opened with service's current directory or service
           this.removeOrphanScriptInfos();
         }
         tryInvokeWildCardDirectories(info) {
-          this.configFileExistenceInfoCache.forEach((configFileExistenceInfo, config) => {
+          this.configFileExistenceInfoCache.forEach((configFileExistenceInfo, config2) => {
             var _a3, _b;
             if (!((_a3 = configFileExistenceInfo.config) == null ? void 0 : _a3.parsedCommandLine) || contains(
               configFileExistenceInfo.config.parsedCommandLine.fileNames,
@@ -264970,10 +264970,10 @@ Dynamic files must always be opened with service's current directory or service
             }
             (_b = configFileExistenceInfo.config.watchedDirectories) == null ? void 0 : _b.forEach((watcher, directory) => {
               if (containsPath(directory, info.fileName, !this.host.useCaseSensitiveFileNames)) {
-                this.logger.info(`Invoking ${config}:: wildcard for open scriptInfo:: ${info.fileName}`);
+                this.logger.info(`Invoking ${config2}:: wildcard for open scriptInfo:: ${info.fileName}`);
                 this.onWildCardDirectoryWatcherInvoke(
                   directory,
-                  config,
+                  config2,
                   configFileExistenceInfo.config,
                   watcher.watcher,
                   info.fileName
@@ -265661,8 +265661,8 @@ Dynamic files must always be opened with service's current directory or service
           }
         };
       }
-      function isConfigFile(config) {
-        return config.kind !== void 0;
+      function isConfigFile(config2) {
+        return config2.kind !== void 0;
       }
       function printProjectWithoutFileNames(project) {
         project.print(
@@ -268366,7 +268366,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
               }
             }
           });
-          (_a3 = result.seenConfigs) == null ? void 0 : _a3.forEach((config) => (notMatchedByConfig ?? (notMatchedByConfig = [])).push(config));
+          (_a3 = result.seenConfigs) == null ? void 0 : _a3.forEach((config2) => (notMatchedByConfig ?? (notMatchedByConfig = [])).push(config2));
           return {
             notMatchedByConfig,
             notInProject,
@@ -272790,7 +272790,7 @@ var require_path_browserify = __commonJS({
         assertPath(path3);
         return path3.length > 0 && path3.charCodeAt(0) === 47;
       },
-      join: function join20() {
+      join: function join22() {
         if (arguments.length === 0)
           return ".";
         var joined;
@@ -273665,7 +273665,7 @@ var require_scan = __commonJS({
 var require_parse = __commonJS({
   "node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js"(exports, module) {
     "use strict";
-    var constants3 = require_constants();
+    var constants4 = require_constants();
     var utils = require_utils();
     var {
       MAX_LENGTH,
@@ -273673,7 +273673,7 @@ var require_parse = __commonJS({
       REGEX_NON_SPECIAL_CHARS,
       REGEX_SPECIAL_CHARS_BACKREF,
       REPLACEMENTS
-    } = constants3;
+    } = constants4;
     var expandRange = (args, options) => {
       if (typeof options.expandRange === "function") {
         return options.expandRange(...args, options);
@@ -273879,7 +273879,7 @@ var require_parse = __commonJS({
       if (options.maxExtglobRecursion === false) {
         return { risky: false };
       }
-      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants3.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants4.DEFAULT_MAX_EXTGLOB_RECURSION;
       const branches = splitTopLevel(body).map((branch) => branch.trim());
       if (branches.length > 1) {
         if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
@@ -273911,8 +273911,8 @@ var require_parse = __commonJS({
       const bos = { type: "bos", value: "", output: opts.prepend || "" };
       const tokens = [bos];
       const capture = opts.capture ? "" : "?:";
-      const PLATFORM_CHARS = constants3.globChars(opts.windows);
-      const EXTGLOB_CHARS = constants3.extglobChars(PLATFORM_CHARS);
+      const PLATFORM_CHARS = constants4.globChars(opts.windows);
+      const EXTGLOB_CHARS = constants4.extglobChars(PLATFORM_CHARS);
       const {
         DOT_LITERAL,
         PLUS_LITERAL,
@@ -274607,7 +274607,7 @@ var require_parse = __commonJS({
         NO_DOTS_SLASH,
         STAR,
         START_ANCHOR
-      } = constants3.globChars(opts.windows);
+      } = constants4.globChars(opts.windows);
       const nodot = opts.dot ? NO_DOTS : NO_DOT;
       const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
       const capture = opts.capture ? "" : "?:";
@@ -274665,7 +274665,7 @@ var require_picomatch = __commonJS({
     var scan = require_scan();
     var parse2 = require_parse();
     var utils = require_utils();
-    var constants3 = require_constants();
+    var constants4 = require_constants();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
     var picomatch = (glob2, options, returnState = false) => {
       if (Array.isArray(glob2)) {
@@ -274793,7 +274793,7 @@ var require_picomatch = __commonJS({
         return /$^/;
       }
     };
-    picomatch.constants = constants3;
+    picomatch.constants = constants4;
     module.exports = picomatch;
   }
 });
@@ -278624,7 +278624,7 @@ ${nodeLocation}` : message;
       }
       var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
       var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-      var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+      var descriptor2 = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
       var _, done = false;
       for (var i = decorators.length - 1; i >= 0; i--) {
         var context = {};
@@ -278634,19 +278634,19 @@ ${nodeLocation}` : message;
           if (done) throw new TypeError("Cannot add initializers after decoration has completed");
           extraInitializers.push(accept(f || null));
         };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor2.get, set: descriptor2.set } : descriptor2[key], context);
         if (kind === "accessor") {
           if (result === void 0) continue;
           if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-          if (_ = accept(result.get)) descriptor.get = _;
-          if (_ = accept(result.set)) descriptor.set = _;
+          if (_ = accept(result.get)) descriptor2.get = _;
+          if (_ = accept(result.set)) descriptor2.set = _;
           if (_ = accept(result.init)) initializers.unshift(_);
         } else if (_ = accept(result)) {
           if (kind === "field") initializers.unshift(_);
-          else descriptor[key] = _;
+          else descriptor2[key] = _;
         }
       }
-      if (target) Object.defineProperty(target, contextIn.name, descriptor);
+      if (target) Object.defineProperty(target, contextIn.name, descriptor2);
       done = true;
     }
     function __runInitializers(thisArg, initializers, value) {
@@ -288151,7 +288151,7 @@ Node text: ${this.#forgottenText}`;
       }
       var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
       var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-      var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+      var descriptor2 = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
       var _, done = false;
       for (var i = decorators.length - 1; i >= 0; i--) {
         var context = {};
@@ -288161,19 +288161,19 @@ Node text: ${this.#forgottenText}`;
           if (done) throw new TypeError("Cannot add initializers after decoration has completed");
           extraInitializers.push(accept(f || null));
         };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor2.get, set: descriptor2.set } : descriptor2[key], context);
         if (kind === "accessor") {
           if (result === void 0) continue;
           if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-          if (_ = accept(result.get)) descriptor.get = _;
-          if (_ = accept(result.set)) descriptor.set = _;
+          if (_ = accept(result.get)) descriptor2.get = _;
+          if (_ = accept(result.set)) descriptor2.set = _;
           if (_ = accept(result.init)) initializers.unshift(_);
         } else if (_ = accept(result)) {
           if (kind === "field") initializers.unshift(_);
-          else descriptor[key] = _;
+          else descriptor2[key] = _;
         }
       }
-      if (target) Object.defineProperty(target, contextIn.name, descriptor);
+      if (target) Object.defineProperty(target, contextIn.name, descriptor2);
       done = true;
     }
     function __runInitializers(thisArg, initializers, value) {
@@ -303239,7 +303239,7 @@ import {
   writeSync as writeSync2
 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { dirname as dirname10, isAbsolute as isAbsolute8, join as join17, relative as relative2, resolve as resolve12 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute8, join as join18, relative as relative2, resolve as resolve12 } from "node:path";
 
 // packages/cli/src/service-version.ts
 var OmniusVersionError = class extends Error {
@@ -303294,11 +303294,41 @@ function compareOmniusVersions(left, right) {
   return 0;
 }
 
+// packages/cli/src/npm-recovery-retention.ts
+import { lstat, readdir, readFile, rm } from "node:fs/promises";
+import { join as join16 } from "node:path";
+var RECOVERY_NAME = /^\.omnius-update-recovery-[a-f0-9-]{36}$/;
+async function pruneStaleUpdateRecoveries(modulesRoot, options = {}) {
+  const keep = Math.max(0, options.keep ?? 1);
+  const minAgeMs = options.minAgeMs ?? 60 * 60 * 1e3;
+  const now = options.now ?? Date.now();
+  const uid = process.getuid?.();
+  const candidates = [];
+  for (const name of await readdir(modulesRoot)) {
+    if (!RECOVERY_NAME.test(name)) continue;
+    const path3 = join16(modulesRoot, name);
+    if (options.exclude?.has(path3)) continue;
+    const metadata = await lstat(path3).catch(() => void 0);
+    if (!metadata?.isDirectory() || metadata.isSymbolicLink() || uid !== void 0 && metadata.uid !== uid) continue;
+    if (now - metadata.mtimeMs < minAgeMs) continue;
+    const manifest = await readFile(join16(path3, "package.json"), "utf8").then((text2) => JSON.parse(text2), () => null);
+    candidates.push({ path: path3, mtimeMs: metadata.mtimeMs, restorable: manifest?.name === "omnius" && typeof manifest.version === "string" });
+  }
+  const kept = new Set(candidates.filter((item) => item.restorable).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, keep).map((item) => item.path));
+  const removed = [];
+  for (const item of candidates) {
+    if (kept.has(item.path)) continue;
+    await rm(item.path, { recursive: true, force: true });
+    removed.push(item.path);
+  }
+  return removed;
+}
+
 // packages/cli/src/npm-install-recovery.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { closeSync as closeSync3, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, openSync as openSync3, readFileSync as readFileSync7, readdirSync, readSync as readSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { chmod, cp, lstat, mkdir, readdir, realpath, rename, rm } from "node:fs/promises";
-import { basename as basename8, dirname as dirname9, isAbsolute as isAbsolute7, join as join16, resolve as resolve11 } from "node:path";
+import { chmod, cp, lstat as lstat2, mkdir, readdir as readdir2, realpath, rename, rm as rm2 } from "node:fs/promises";
+import { basename as basename8, dirname as dirname9, isAbsolute as isAbsolute7, join as join17, resolve as resolve11 } from "node:path";
 var NpmInstallBusyError = class extends Error {
   code = "NPM_INSTALL_BUSY";
   constructor(message = "Another installer owns this npm modules directory. Wait for it to settle before retrying.") {
@@ -303324,7 +303354,7 @@ function parseNpmRenameCollision(diagnostic) {
 }
 function retiredNpmPackagePath(packagePath) {
   const suffix = createHash2("sha1").update(packagePath).digest("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8);
-  return join16(dirname9(packagePath), `.${basename8(packagePath)}-${suffix}`);
+  return join17(dirname9(packagePath), `.${basename8(packagePath)}-${suffix}`);
 }
 function assertNotCancelled(signal) {
   signal?.throwIfAborted();
@@ -303340,7 +303370,7 @@ function assertOwnedDirectory(metadata, label) {
 async function recoverNpmRetirementCollision(collision, modulesRoot, options = {}) {
   assertNotCancelled(options.signal);
   if (collision.code !== "ENOTEMPTY" && collision.code !== "EEXIST" || collision.syscall !== "rename" || !isAbsolute7(modulesRoot) || /[\x00-\x1f\x7f]/.test(modulesRoot + collision.path + collision.dest)) return null;
-  const root = resolve11(modulesRoot), source = join16(root, "omnius"), retired = retiredNpmPackagePath(source);
+  const root = resolve11(modulesRoot), source = join17(root, "omnius"), retired = retiredNpmPackagePath(source);
   if (collision.path !== source || collision.dest !== retired || dirname9(retired) !== root) return null;
   return prepareNpmRetirementSlot(root, options);
 }
@@ -303352,30 +303382,30 @@ async function prepareNpmRetirementSlot(modulesRoot, options = {}) {
   };
   current();
   if (!isAbsolute7(modulesRoot) || /[\x00-\x1f\x7f]/.test(modulesRoot)) throw new Error("npm modules root must be an absolute directory path.");
-  const root = resolve11(modulesRoot), retired = retiredNpmPackagePath(join16(root, "omnius"));
-  const rootBefore = await lstat(root);
+  const root = resolve11(modulesRoot), retired = retiredNpmPackagePath(join17(root, "omnius"));
+  const rootBefore = await lstat2(root);
   assertOwnedDirectory(rootBefore, "global modules root");
   const canonicalRoot = await realpath(root);
   let before;
   try {
-    before = await lstat(retired);
+    before = await lstat2(retired);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
   assertOwnedDirectory(before, "retired package");
-  const backup = join16(root, `.omnius-update-recovery-${randomUUID2()}`);
+  const backup = join17(root, `.omnius-update-recovery-${randomUUID2()}`);
   const receipt = { modulesRoot: root, retiredPath: retired, backupPath: backup, device: before.dev, inode: before.ino };
   current();
   await options.onPrepare?.({ ...receipt });
   current();
   try {
-    await lstat(backup);
+    await lstat2(backup);
     throw new Error("The planned npm retirement backup is already occupied; no directory was moved.");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  const [rootNow, candidateNow] = await Promise.all([lstat(root), lstat(retired)]);
+  const [rootNow, candidateNow] = await Promise.all([lstat2(root), lstat2(retired)]);
   if (!sameIdentity(rootBefore, rootNow) || !sameIdentity(before, candidateNow) || await realpath(root) !== canonicalRoot) throw new Error("npm retirement directory changed before recovery; no cleanup was attempted.");
   assertOwnedDirectory(rootNow, "global modules root");
   assertOwnedDirectory(candidateNow, "retired package");
@@ -303481,12 +303511,12 @@ function provedAbsent(owner) {
 async function acquireNpmInstallLease(modulesRoot, options = {}) {
   assertNotCancelled(options.signal);
   if (!isAbsolute7(modulesRoot) || /[\x00-\x1f\x7f]/.test(modulesRoot) || options.operationId !== void 0 && !/^[a-zA-Z0-9_-]{1,128}$/.test(options.operationId)) throw new Error("Invalid npm install scope.");
-  const logical = resolve11(modulesRoot), logicalMetadata = await lstat(logical);
+  const logical = resolve11(modulesRoot), logicalMetadata = await lstat2(logical);
   assertOwnedDirectory(logicalMetadata, "global modules root");
-  const root = await realpath(logical), rootMetadata = await lstat(root);
+  const root = await realpath(logical), rootMetadata = await lstat2(root);
   assertOwnedDirectory(rootMetadata, "global modules root");
   if (!sameIdentity(logicalMetadata, rootMetadata)) throw new Error("npm modules root changed before installer admission.");
-  const lockPath = join16(root, ".omnius-install.lock"), guardPath = lockPath + ".guard", nonce = randomUUID2();
+  const lockPath = join17(root, ".omnius-install.lock"), guardPath = lockPath + ".guard", nonce = randomUUID2();
   const assertRoot = () => {
     const current = lstatSync(root);
     assertOwnedDirectory(current, "global modules root");
@@ -303628,21 +303658,21 @@ function inspectRuntimeDirectory(canonical, root) {
   const before = lstatSync(canonical);
   assertOwnedDirectory(lstatSync(root), "global modules root");
   assertOwnedDirectory(before, "Omnius package");
-  assertOwnedDirectory(lstatSync(join16(canonical, "dist")), "Omnius runtime");
+  assertOwnedDirectory(lstatSync(join17(canonical, "dist")), "Omnius runtime");
   const files = {};
-  for (const file of REQUIRED_OMNIUS_RUNTIME_FILES) files[file] = hashOwnedFile(join16(canonical, file));
-  const manifest = JSON.parse(readFileSync7(join16(canonical, "package.json"), "utf8"));
+  for (const file of REQUIRED_OMNIUS_RUNTIME_FILES) files[file] = hashOwnedFile(join17(canonical, file));
+  const manifest = JSON.parse(readFileSync7(join17(canonical, "package.json"), "utf8"));
   if (manifest.name !== "omnius" || typeof manifest.version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(manifest.version))
     throw new Error("Omnius runtime manifest is invalid.");
   const binTarget = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.omnius;
   if (typeof binTarget !== "string" || !/^[A-Za-z0-9_./-]+$/.test(binTarget) || isAbsolute7(binTarget) || binTarget.split("/").some((part) => !part || part === ".." || part === "."))
     throw new Error("Omnius runtime manifest has no safe declared omnius executable.");
-  for (const directory of binTarget.split("/").slice(0, -1).reduce((paths, part) => [...paths, join16(paths.at(-1) ?? canonical, part)], []))
+  for (const directory of binTarget.split("/").slice(0, -1).reduce((paths, part) => [...paths, join17(paths.at(-1) ?? canonical, part)], []))
     assertOwnedDirectory(lstatSync(directory), "Omnius executable directory");
-  files[binTarget] ??= hashOwnedFile(join16(canonical, binTarget));
-  if (!readFileSync7(join16(canonical, "dist/update-worker.js"), "utf8").includes("omnius.update-worker-bootstrap.v2"))
+  files[binTarget] ??= hashOwnedFile(join17(canonical, binTarget));
+  if (!readFileSync7(join17(canonical, "dist/update-worker.js"), "utf8").includes("omnius.update-worker-bootstrap.v2"))
     throw new Error("Omnius runtime has no compatible update worker bootstrap.");
-  if (hashOwnedFile(join16(canonical, "package.json")) !== files["package.json"] || !sameIdentity(before, lstatSync(canonical)))
+  if (hashOwnedFile(join17(canonical, "package.json")) !== files["package.json"] || !sameIdentity(before, lstatSync(canonical)))
     throw new Error("Omnius package changed during runtime verification.");
   return {
     modulesRoot: root,
@@ -303656,7 +303686,7 @@ function inspectRuntimeDirectory(canonical, root) {
   };
 }
 async function preserveVerifiedNpmInstallation(snapshot, options) {
-  const root = resolve11(snapshot.modulesRoot), source = join16(root, "omnius");
+  const root = resolve11(snapshot.modulesRoot), source = join17(root, "omnius");
   const current = () => {
     options.lease.assertOwnedForRecovery();
     options.assertOwned();
@@ -303666,18 +303696,18 @@ async function preserveVerifiedNpmInstallation(snapshot, options) {
   if (root !== options.lease.modulesRoot) throw new Error("Package preservation belongs to a different npm lease.");
   const before = inspectNpmRuntimeInstallation(source);
   if (before.device !== snapshot.device || before.inode !== snapshot.inode || before.packageHash !== snapshot.packageHash || JSON.stringify(before.files) !== JSON.stringify(snapshot.files)) throw new Error("Prior runtime changed before preservation.");
-  const backupPath = join16(root, `.omnius-update-recovery-${randomUUID2()}`);
+  const backupPath = join17(root, `.omnius-update-recovery-${randomUUID2()}`);
   await mkdir(backupPath, { mode: 448 });
-  const metadata = await lstat(backupPath);
+  const metadata = await lstat2(backupPath);
   const backup = { modulesRoot: root, retiredPath: retiredNpmPackagePath(source), backupPath, device: metadata.dev, inode: metadata.ino };
   await options.onPrepare?.({ ...backup });
   assertNotCancelled(options.signal);
   current();
-  for (const name of await readdir(source)) {
+  for (const name of await readdir2(source)) {
     assertNotCancelled(options.signal);
     current();
-    if (!sameIdentity(metadata, await lstat(backupPath))) throw new Error("Package preservation directory changed during copying.");
-    await cp(join16(source, name), join16(backupPath, name), {
+    if (!sameIdentity(metadata, await lstat2(backupPath))) throw new Error("Package preservation directory changed during copying.");
+    await cp(join17(source, name), join17(backupPath, name), {
       recursive: true,
       errorOnExist: true,
       force: false,
@@ -303703,14 +303733,14 @@ async function preserveVerifiedNpmInstallation(snapshot, options) {
   return { backup, installation };
 }
 async function restoreVerifiedNpmInstallation(snapshot, options) {
-  const root = resolve11(snapshot.modulesRoot), canonical = join16(root, "omnius");
+  const root = resolve11(snapshot.modulesRoot), canonical = join17(root, "omnius");
   const current = () => {
     options.lease.assertOwnedForRecovery();
     options.assertOwned();
   };
   current();
   if (root !== options.lease.modulesRoot || !isAbsolute7(snapshot.modulesRoot)) throw new Error("Package recovery belongs to a different npm lease.");
-  const rootBefore = await lstat(root);
+  const rootBefore = await lstat2(root);
   assertOwnedDirectory(rootBefore, "global modules root");
   const validPath = (path3) => path3 === canonical || path3 === retiredNpmPackagePath(canonical) || options.backups?.some((backup) => backup.modulesRoot === root && backup.backupPath === path3 && dirname9(path3) === root && /^\.omnius-update-recovery-[a-f0-9-]{36}$/.test(basename8(path3)));
   const matches = (path3) => {
@@ -303724,11 +303754,11 @@ async function restoreVerifiedNpmInstallation(snapshot, options) {
     }
     if (metadata.dev !== snapshot.device || metadata.ino !== snapshot.inode) return false;
     assertOwnedDirectory(metadata, "prior Omnius package");
-    assertOwnedDirectory(lstatSync(join16(path3, "dist")), "prior Omnius runtime");
+    assertOwnedDirectory(lstatSync(join17(path3, "dist")), "prior Omnius runtime");
     for (const [file, digest] of Object.entries(snapshot.files)) {
-      if (!/^[A-Za-z0-9_./-]+$/.test(file) || isAbsolute7(file) || file.split("/").some((part) => !part || part === "." || part === "..") || hashOwnedFile(join16(path3, file)) !== digest) throw new Error("Prior Omnius runtime changed; restoration was held.");
+      if (!/^[A-Za-z0-9_./-]+$/.test(file) || isAbsolute7(file) || file.split("/").some((part) => !part || part === "." || part === "..") || hashOwnedFile(join17(path3, file)) !== digest) throw new Error("Prior Omnius runtime changed; restoration was held.");
     }
-    for (const directory of snapshot.binTarget.split("/").slice(0, -1).reduce((paths, part) => [...paths, join16(paths.at(-1) ?? path3, part)], []))
+    for (const directory of snapshot.binTarget.split("/").slice(0, -1).reduce((paths, part) => [...paths, join17(paths.at(-1) ?? path3, part)], []))
       assertOwnedDirectory(lstatSync(directory), "prior Omnius executable directory");
     return true;
   };
@@ -303744,20 +303774,20 @@ async function restoreVerifiedNpmInstallation(snapshot, options) {
   if (source === canonical) return recovery;
   let partial;
   try {
-    partial = await lstat(canonical);
+    partial = await lstat2(canonical);
     assertOwnedDirectory(partial, "failed Omnius replacement");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  if (partial) recovery.partialPath = join16(root, `.omnius-update-recovery-${randomUUID2()}`);
+  if (partial) recovery.partialPath = join17(root, `.omnius-update-recovery-${randomUUID2()}`);
   await options.onPrepare?.({ ...recovery });
   current();
-  if (!sameIdentity(rootBefore, await lstat(root)) || !matches(source)) throw new Error("npm recovery identity changed before restoration.");
+  if (!sameIdentity(rootBefore, await lstat2(root)) || !matches(source)) throw new Error("npm recovery identity changed before restoration.");
   if (partial) {
-    const now = await lstat(canonical);
+    const now = await lstat2(canonical);
     if (!sameIdentity(partial, now)) throw new Error("Failed Omnius replacement changed before preservation.");
     try {
-      await lstat(recovery.partialPath);
+      await lstat2(recovery.partialPath);
       throw new Error("Failed-package preservation path is already occupied.");
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -303767,7 +303797,7 @@ async function restoreVerifiedNpmInstallation(snapshot, options) {
   }
   current();
   try {
-    await lstat(canonical);
+    await lstat2(canonical);
     throw new Error("Canonical Omnius path changed before restoration.");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -303790,17 +303820,17 @@ async function restoreVerifiedNpmInstallation(snapshot, options) {
 }
 async function removeVerifiedNpmRetirementBackup(backup) {
   const root = resolve11(backup.modulesRoot);
-  if (!isAbsolute7(backup.modulesRoot) || dirname9(backup.backupPath) !== root || !/^\.omnius-update-recovery-[a-f0-9-]{36}$/.test(basename8(backup.backupPath)) || backup.retiredPath !== retiredNpmPackagePath(join16(root, "omnius"))) {
+  if (!isAbsolute7(backup.modulesRoot) || dirname9(backup.backupPath) !== root || !/^\.omnius-update-recovery-[a-f0-9-]{36}$/.test(basename8(backup.backupPath)) || backup.retiredPath !== retiredNpmPackagePath(join17(root, "omnius"))) {
     throw new Error("Refusing cleanup outside the preserved npm retirement directory.");
   }
-  const rootMetadata = await lstat(root);
+  const rootMetadata = await lstat2(root);
   assertOwnedDirectory(rootMetadata, "global modules root");
-  const metadata = await lstat(backup.backupPath);
+  const metadata = await lstat2(backup.backupPath);
   assertOwnedDirectory(metadata, "preserved retirement directory");
   if (metadata.dev !== backup.device || metadata.ino !== backup.inode) {
     throw new Error("Preserved npm retirement directory identity changed; its contents were retained.");
   }
-  await rm(backup.backupPath, { recursive: true });
+  await rm2(backup.backupPath, { recursive: true });
 }
 
 // packages/cli/src/update-service.ts
@@ -303814,7 +303844,7 @@ var UpdateOwnershipBusyError = class extends Error {
 };
 function cancellationPath(operationId, paths) {
   if (!/^[a-zA-Z0-9_-]{1,128}$/.test(operationId)) throw new Error("Invalid update operation identity");
-  return join17(paths.stateDir, `cancel-${operationId}.json`);
+  return join18(paths.stateDir, `cancel-${operationId}.json`);
 }
 function watchUpdateCancellation(operationId, paths = resolveUpdatePaths()) {
   const controller = new AbortController();
@@ -303842,16 +303872,16 @@ function watchUpdateCancellation(operationId, paths = resolveUpdatePaths()) {
   } };
 }
 function resolveUpdatePaths(env = process.env, platform2 = process.platform, home = homedir16()) {
-  const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join17(home, "AppData", "Local") : platform2 === "darwin" ? join17(home, "Library", "Application Support") : env["XDG_STATE_HOME"] || join17(home, ".local", "state");
-  const cacheBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join17(home, "AppData", "Local") : platform2 === "darwin" ? join17(home, "Library", "Caches") : env["XDG_CACHE_HOME"] || join17(home, ".cache");
-  const stateDir = join17(stateBase, platform2 === "win32" ? "Omnius" : "omnius", "update");
-  const cacheDir = join17(cacheBase, platform2 === "win32" ? "Omnius" : "omnius", "npm-update");
+  const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join18(home, "AppData", "Local") : platform2 === "darwin" ? join18(home, "Library", "Application Support") : env["XDG_STATE_HOME"] || join18(home, ".local", "state");
+  const cacheBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join18(home, "AppData", "Local") : platform2 === "darwin" ? join18(home, "Library", "Caches") : env["XDG_CACHE_HOME"] || join18(home, ".cache");
+  const stateDir = join18(stateBase, platform2 === "win32" ? "Omnius" : "omnius", "update");
+  const cacheDir = join18(cacheBase, platform2 === "win32" ? "Omnius" : "omnius", "npm-update");
   return {
     stateDir,
     cacheDir,
-    stateFile: join17(stateDir, "state.json"),
-    lockFile: join17(stateDir, "update.lock"),
-    logFile: join17(stateDir, "update.log")
+    stateFile: join18(stateDir, "state.json"),
+    lockFile: join18(stateDir, "update.lock"),
+    logFile: join18(stateDir, "update.log")
   };
 }
 function ensurePrivateDirectories(paths) {
@@ -304032,7 +304062,7 @@ function assertExactUpdateTarget(targetVersion, fromVersion) {
 }
 function npmCandidates(execPath = process.execPath) {
   const nodeDir = dirname10(execPath);
-  return process.platform === "win32" ? [join17(nodeDir, "npm.cmd"), join17(nodeDir, "npm.exe"), "npm.cmd", "npm"] : [join17(nodeDir, "npm"), "/usr/local/bin/npm", "/usr/bin/npm", "npm"];
+  return process.platform === "win32" ? [join18(nodeDir, "npm.cmd"), join18(nodeDir, "npm.exe"), "npm.cmd", "npm"] : [join18(nodeDir, "npm"), "/usr/local/bin/npm", "/usr/bin/npm", "npm"];
 }
 function runnableCommand(candidate) {
   return candidate.includes("/") || candidate.includes("\\") ? existsSync7(candidate) : true;
@@ -304160,10 +304190,10 @@ async function runUpdateCommand(command, args, options = {}) {
 }
 var runCommand = runUpdateCommand;
 function globalPackageCandidates(prefix) {
-  return process.platform === "win32" ? [join17(prefix, "node_modules", "omnius", "package.json"), join17(prefix, "omnius", "package.json")] : [join17(prefix, "lib", "node_modules", "omnius", "package.json"), join17(prefix, "node_modules", "omnius", "package.json")];
+  return process.platform === "win32" ? [join18(prefix, "node_modules", "omnius", "package.json"), join18(prefix, "omnius", "package.json")] : [join18(prefix, "lib", "node_modules", "omnius", "package.json"), join18(prefix, "node_modules", "omnius", "package.json")];
 }
 function globalExecutableCandidates(prefix) {
-  return process.platform === "win32" ? [join17(prefix, "omnius.cmd"), join17(prefix, "omnius.exe"), join17(prefix, "bin", "omnius.cmd")] : [join17(prefix, "bin", "omnius")];
+  return process.platform === "win32" ? [join18(prefix, "omnius.cmd"), join18(prefix, "omnius.exe"), join18(prefix, "bin", "omnius.cmd")] : [join18(prefix, "bin", "omnius")];
 }
 async function inspectGlobalOmniusInstall(expectedVersion, options = {}) {
   const npmPath = options.npmPath ?? resolveNpmPath();
@@ -304255,7 +304285,7 @@ async function installGlobalPackageStreaming(input) {
 }
 function restoreOmniusExecutableLink(prefix, installation) {
   const executable = globalExecutableCandidates(prefix)[0];
-  const target = join17(installation.modulesRoot, "omnius", installation.binTarget);
+  const target = join18(installation.modulesRoot, "omnius", installation.binTarget);
   if (process.platform === "win32") {
     if (!existsSync7(executable)) throw new Error("The restored Omnius Windows executable shim is missing.");
     return;
@@ -304362,14 +304392,19 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     const rootProbe = await runCommand(npmPath, ["root", "-g"], { env, cwd, timeout: 1e4, signal: dependencies.signal });
     throwIfCancelled();
     const npmRoot = rootProbe.stdout.trim();
-    const expectedRoot = process.platform === "win32" ? join17(npmPrefix, "node_modules") : join17(npmPrefix, "lib", "node_modules");
+    const expectedRoot = process.platform === "win32" ? join18(npmPrefix, "node_modules") : join18(npmPrefix, "lib", "node_modules");
     if (rootProbe.status !== 0 || !isAbsolute8(npmRoot) || resolve12(npmRoot) !== resolve12(expectedRoot)) throw new Error("Could not verify the selected npm global modules directory; no package was changed.");
     state = await transition(state, { npm_path: npmPath, npm_prefix: npmPrefix, npm_modules_root: npmRoot }, paths);
     installLease = await acquireNpmInstallLease(npmRoot, { signal: dependencies.signal, operationId: state.operation_id });
     state = await transition(state, { npm_modules_root: installLease.modulesRoot }, paths);
     assertOwned();
     try {
-      previousInstallation = inspectNpmRuntimeInstallation(join17(installLease.modulesRoot, "omnius"));
+      await pruneStaleUpdateRecoveries(installLease.modulesRoot);
+    } catch (error) {
+      state = await transition(state, { npm_cleanup_warning: error instanceof Error ? error.message : String(error) }, paths);
+    }
+    try {
+      previousInstallation = inspectNpmRuntimeInstallation(join18(installLease.modulesRoot, "omnius"));
     } catch {
     }
     await preserveRetirement("before_install");
@@ -304478,6 +304513,13 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
       );
     }
     daemonQuiesced = false;
+    if ((dependencies.stabilityWindowMs ?? 0) > 0) {
+      await new Promise((resolve13) => setTimeout(resolve13, dependencies.stabilityWindowMs));
+      throwIfCancelled();
+      const settled = await dependencies.observeDaemon();
+      if (settled?.bootVersion !== target || settled.bootPackageHash !== evidence.packageHash)
+        throw new Error(`The updated daemon did not stay up for ${Math.round(dependencies.stabilityWindowMs / 1e3)}s after restart (observed ${settled?.bootVersion ?? "unreachable"})`);
+    }
     state = await transition(state, {
       phase: "runtime_verified",
       daemon_version: daemon.bootVersion,
@@ -304538,6 +304580,7 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     let recoveryNote;
     let packageRecoveryNote;
     let restoredPackageVerified = false;
+    let rolledBack = false;
     if (installStarted && installerSettled && !packageVerified && installLease && previousInstallation) {
       state = await transition(state, { phase: "recovering" }, paths);
       const journal = (recovery) => ({
@@ -304590,11 +304633,60 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
         packageRecoveryNote = `Package recovery could not be verified: ${detail}`;
       }
     }
-    if (daemonQuiesced && dependencies.recoverDaemon && installerSettled && (!installStarted || packageVerified || restoredPackageVerified)) {
+    if (!cancelled && packageVerified && installerSettled && installLease && previousInstallation && previousInstallationCopy) {
+      state = await transition(state, { phase: "rolling_back" }, paths);
+      try {
+        const recovered = await restoreVerifiedNpmInstallation(previousInstallationCopy, {
+          lease: installLease,
+          backups: retirementBackups,
+          assertOwned: assertRecoveryOwned,
+          async onPrepare(recovery) {
+            state = await transition(state, { package_recovery: {
+              status: "planned",
+              version: recovery.version,
+              package_hash: recovery.packageHash,
+              source_path: recovery.sourcePath,
+              ...recovery.partialPath ? { partial_path: recovery.partialPath } : {}
+            } }, paths);
+          }
+        });
+        if (!recovered) throw new Error("the preserved prior installation was no longer available");
+        assertRecoveryOwned();
+        restoreOmniusExecutableLink(state.npm_prefix, previousInstallation);
+        const verified = await inspectGlobalOmniusInstall(previousInstallation.version, { npmPath, env, cwd });
+        if (verified.packageHash !== previousInstallation.packageHash) throw new Error("the restored manifest differs from the pre-install verification");
+        restoredPackageVerified = rolledBack = true;
+        state = await transition(state, {
+          rolled_back_to: verified.installedVersion,
+          package_recovery: {
+            status: "restored",
+            version: recovered.version,
+            package_hash: recovered.packageHash,
+            source_path: recovered.sourcePath,
+            ...recovered.partialPath ? { partial_path: recovered.partialPath } : {}
+          },
+          npm_recoveries: state.npm_recoveries?.map((item) => item.backup_path === recovered.sourcePath ? { ...item, status: "restored" } : item),
+          package_json_path: verified.packageJsonPath,
+          global_executable: verified.executablePath,
+          installed_version: verified.installedVersion,
+          executable_version: verified.executableVersion,
+          installed_package_hash: verified.packageHash
+        }, paths);
+        packageRecoveryNote = `Rolled back to the previous verified Omnius v${verified.installedVersion}.${recovered.partialPath ? ` The failed v${target} files remain at ${recovered.partialPath}.` : ""}`;
+      } catch (rollbackError) {
+        const detail = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+        state = await transition(state, { package_recovery: { ...state.package_recovery, status: "failed", error: detail } }, paths);
+        packageRecoveryNote = `Rollback could not be verified: ${detail}`;
+      }
+    }
+    if ((daemonQuiesced || rolledBack) && dependencies.recoverDaemon && installerSettled && (!installStarted || packageVerified || restoredPackageVerified)) {
       state = await transition(state, { phase: "recovering" }, paths);
       try {
         const recovered = await dependencies.recoverDaemon();
         recoveryNote = recovered ? "The daemon was restarted after the interrupted update." : "The daemon could not be recovered automatically after the failed update.";
+        if (rolledBack && state.tray_was_running && dependencies.restartTray && state.global_executable) {
+          recoveryNote += await dependencies.restartTray(state.global_executable).catch(() => false) ? " The indicator was relaunched on the restored version." : " The indicator could not be relaunched on the restored version.";
+        }
       } catch (recoveryError) {
         recoveryNote = `Daemon recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`;
       }
@@ -304628,20 +304720,31 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
 // packages/cli/src/tray.ts
 import { spawn as spawn4 } from "node:child_process";
 import {
-  closeSync as closeSync5,
+  closeSync as closeSync6,
   chmodSync as chmodSync2,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync7,
-  openSync as openSync5,
-  readFileSync as readFileSync9,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync8,
+  openSync as openSync6,
+  readFileSync as readFileSync10,
   realpathSync as realpathSync2,
-  renameSync as renameSync6,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync7,
+  renameSync as renameSync7,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync8,
   writeSync as writeSync3
 } from "node:fs";
-import { homedir as homedir17, tmpdir as tmpdir6 } from "node:os";
-import { basename as basename9, delimiter, dirname as dirname11, join as join19 } from "node:path";
+import { homedir as homedir18, tmpdir as tmpdir6 } from "node:os";
+import { basename as basename9, delimiter, dirname as dirname11, join as join21 } from "node:path";
+
+// packages/cli/src/config-home.ts
+import { homedir as homedir17 } from "node:os";
+import { join as join19 } from "node:path";
+function omniusConfigDir(...parts) {
+  return join19(
+    process.env["OMNIUS_CONFIG_HOME"] ?? homedir17(),
+    ".omnius",
+    ...parts
+  );
+}
 
 // packages/cli/src/tray-menu.ts
 import { execFile as execFile4 } from "node:child_process";
@@ -304668,30 +304771,686 @@ var run = promisify4(execFile4);
 init_daemon();
 
 // packages/cli/src/updater.ts
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 var UPDATE_CHECK_INTERVAL_MS = 60 * 1e3;
 var CACHE_DIR = resolveUpdatePaths().stateDir;
-var CACHE_FILE = join18(CACHE_DIR, "registry-check.json");
+var CACHE_FILE = join20(CACHE_DIR, "registry-check.json");
+
+// packages/backend-vllm/dist/providerRegistry.js
+var CHAT_CAPABILITIES = [
+  "chat",
+  "streaming",
+  "models",
+  "tools",
+  "structured-output"
+];
+var OPENAI_CAPABILITIES = [
+  ...CHAT_CAPABILITIES,
+  "embeddings"
+];
+var bearerAuth = (required, keyPrefix, staticHeaders) => ({
+  strategy: "bearer",
+  required,
+  ...keyPrefix ? { keyPrefix } : {},
+  ...staticHeaders ? { staticHeaders } : {}
+});
+var descriptor = (value) => Object.freeze({
+  ...value,
+  aliases: Object.freeze([...value.aliases]),
+  paths: Object.freeze({ ...value.paths }),
+  auth: Object.freeze({
+    ...value.auth,
+    ...value.auth.staticHeaders ? { staticHeaders: Object.freeze({ ...value.auth.staticHeaders }) } : {}
+  }),
+  capabilities: Object.freeze([...value.capabilities]),
+  ...value.availability ? { availability: Object.freeze({ ...value.availability }) } : {}
+});
+var registrations = [
+  {
+    descriptor: descriptor({
+      id: "mesh",
+      aliases: [],
+      label: "Sponsored inference mesh",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: { chat: "/v1/chat/completions", models: "/v1/models" },
+      auth: bearerAuth(true),
+      capabilities: CHAT_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:11436/v1",
+      description: "Opt-in remote sponsor inference through your private authenticated mesh gateway."
+    }),
+    // A loopback port is not provider identity. Select this transport explicitly.
+    match: () => false
+  },
+  {
+    descriptor: descriptor({
+      id: "anthropic",
+      aliases: ["claude"],
+      label: "Anthropic (Claude)",
+      protocol: "anthropic-messages",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/messages",
+        models: "/v1/models"
+      },
+      auth: {
+        strategy: "anthropic-api-key",
+        required: true,
+        keyPrefix: "sk-ant-",
+        staticHeaders: { "anthropic-version": "2023-06-01" }
+      },
+      capabilities: CHAT_CAPABILITIES,
+      defaultUrl: "https://api.anthropic.com/v1",
+      apiKeyUrl: "https://console.anthropic.com/settings/keys",
+      docsUrl: "https://docs.anthropic.com/en/api",
+      description: "Claude through Anthropic's native Messages API."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.anthropic.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "gemini",
+      aliases: ["google", "google-ai"],
+      label: "Google Gemini",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1beta/openai",
+      paths: {
+        chat: "/v1beta/openai/chat/completions",
+        models: "/v1beta/openai/models",
+        embeddings: "/v1beta/openai/embeddings"
+      },
+      auth: bearerAuth(true, void 0, {
+        "x-goog-api-client": "omnius/{version}"
+      }),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+      apiKeyUrl: "https://aistudio.google.com/app/apikey",
+      docsUrl: "https://ai.google.dev/gemini-api/docs/openai",
+      description: "Gemini through Google's official OpenAI-compatible API."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "generativelanguage.googleapis.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "openai",
+      aliases: [],
+      label: "OpenAI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "sk-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.openai.com/v1",
+      apiKeyUrl: "https://platform.openai.com/api-keys",
+      docsUrl: "https://platform.openai.com/docs/api-reference",
+      description: "OpenAI API models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.openai.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "openrouter",
+      aliases: [],
+      label: "OpenRouter",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "sk-or-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://openrouter.ai/api/v1",
+      apiKeyUrl: "https://openrouter.ai/keys",
+      docsUrl: "https://openrouter.ai/docs",
+      description: "OpenAI-compatible routing across hosted models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "openrouter.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "groq",
+      aliases: [],
+      label: "Groq",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/openai/v1",
+      paths: {
+        chat: "/openai/v1/chat/completions",
+        models: "/openai/v1/models",
+        embeddings: "/openai/v1/embeddings"
+      },
+      auth: bearerAuth(true, "gsk_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.groq.com/openai/v1",
+      apiKeyUrl: "https://console.groq.com/keys",
+      docsUrl: "https://console.groq.com/docs",
+      description: "Groq OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.groq.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "deepinfra",
+      aliases: [],
+      label: "DeepInfra",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1/openai",
+      paths: {
+        chat: "/v1/openai/chat/completions",
+        models: "/v1/openai/models",
+        embeddings: "/v1/openai/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.deepinfra.com/v1/openai",
+      apiKeyUrl: "https://deepinfra.com/dash/api_keys",
+      docsUrl: "https://deepinfra.com/docs/openai_api",
+      description: "DeepInfra OpenAI-compatible hosted models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.deepinfra.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "fireworks",
+      aliases: ["fireworks-ai"],
+      label: "Fireworks AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/inference/v1",
+      paths: {
+        chat: "/inference/v1/chat/completions",
+        models: "/inference/v1/models",
+        embeddings: "/inference/v1/embeddings"
+      },
+      auth: bearerAuth(true, "fw_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.fireworks.ai/inference/v1",
+      apiKeyUrl: "https://fireworks.ai/account/api-keys",
+      docsUrl: "https://docs.fireworks.ai",
+      description: "Fireworks OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.fireworks.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "together",
+      aliases: ["together-ai"],
+      label: "Together AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.together.ai/v1",
+      apiKeyUrl: "https://api.together.xyz/settings/api-keys",
+      docsUrl: "https://docs.together.ai",
+      description: "Together OpenAI-compatible inference."
+    }),
+    match: (url) => ["api.together.ai", "api.together.xyz"].includes(url.hostname.toLowerCase())
+  },
+  {
+    descriptor: descriptor({
+      id: "chutes",
+      aliases: ["chutes-ai"],
+      label: "Chutes AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "cpk_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://llm.chutes.ai/v1",
+      apiKeyUrl: "https://chutes.ai/app/api",
+      docsUrl: "https://docs.chutes.ai",
+      description: "Chutes OpenAI-compatible model endpoint."
+    }),
+    match: (url) => ["llm.chutes.ai", "chutes.ai"].includes(url.hostname.toLowerCase())
+  },
+  {
+    descriptor: descriptor({
+      id: "mistral",
+      aliases: ["mistral-ai"],
+      label: "Mistral AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.mistral.ai/v1",
+      apiKeyUrl: "https://console.mistral.ai/api-keys",
+      docsUrl: "https://docs.mistral.ai",
+      description: "Mistral hosted model endpoint."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.mistral.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "cerebras",
+      aliases: [],
+      label: "Cerebras",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "csk-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.cerebras.ai/v1",
+      apiKeyUrl: "https://cloud.cerebras.ai/platform",
+      docsUrl: "https://inference-docs.cerebras.ai",
+      description: "Cerebras OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.cerebras.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "sambanova",
+      aliases: ["samba-nova"],
+      label: "SambaNova",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.sambanova.ai/v1",
+      apiKeyUrl: "https://cloud.sambanova.ai/apis",
+      docsUrl: "https://docs.sambanova.ai",
+      description: "SambaNova OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.sambanova.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "nvidia",
+      aliases: ["nvidia-nim", "nim"],
+      label: "NVIDIA NIM",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "nvapi-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://integrate.api.nvidia.com/v1",
+      apiKeyUrl: "https://build.nvidia.com",
+      docsUrl: "https://docs.api.nvidia.com/nim",
+      description: "NVIDIA-hosted NIM models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "integrate.api.nvidia.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "hyperbolic",
+      aliases: [],
+      label: "Hyperbolic",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.hyperbolic.xyz/v1",
+      apiKeyUrl: "https://app.hyperbolic.xyz/settings",
+      docsUrl: "https://docs.hyperbolic.xyz",
+      description: "Retired Hyperbolic serverless API. Explicit custom deployments require their own URL.",
+      availability: { state: "retired", reason: "Hyperbolic's serverless inference API has been retired; old serverless models no longer accept requests, including with valid keys.", docsUrl: "https://www.hyperbolic.ai/docs/faq/inference-models" }
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.hyperbolic.xyz"
+  },
+  {
+    descriptor: descriptor({
+      id: "ollama",
+      aliases: [],
+      label: "Ollama (local)",
+      protocol: "ollama",
+      local: true,
+      apiPrefix: "",
+      paths: {
+        chat: "/v1/chat/completions",
+        nativeChat: "/api/chat",
+        models: "/api/tags",
+        embeddings: "/api/embed",
+        health: "/api/tags"
+      },
+      auth: bearerAuth(false),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:11434",
+      docsUrl: "https://docs.ollama.com/api",
+      description: "Local Ollama runtime."
+    }),
+    match: (url) => url.port === "11434"
+  },
+  {
+    descriptor: descriptor({
+      id: "lmstudio",
+      aliases: ["lm-studio"],
+      label: "LM Studio (local)",
+      protocol: "openai-chat",
+      local: true,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(false),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:1234/v1",
+      docsUrl: "https://lmstudio.ai/docs",
+      description: "Local LM Studio OpenAI-compatible server."
+    }),
+    match: (url) => url.port === "1234"
+  },
+  {
+    descriptor: descriptor({
+      id: "vllm",
+      aliases: ["v-llm"],
+      label: "vLLM (local)",
+      protocol: "openai-chat",
+      local: true,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings",
+        health: "/health"
+      },
+      auth: bearerAuth(false),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:8000/v1",
+      docsUrl: "https://docs.vllm.ai",
+      description: "Self-hosted vLLM OpenAI-compatible endpoint."
+    }),
+    match: (url) => url.port === "8000"
+  }
+];
+var descriptors = registrations.map((entry) => entry.descriptor);
+function listProviderDescriptors() {
+  return [...descriptors].sort((left, right) => Number(right.local) - Number(left.local)).map((entry) => ({
+    ...entry,
+    aliases: [...entry.aliases],
+    paths: { ...entry.paths },
+    auth: {
+      ...entry.auth,
+      ...entry.auth.staticHeaders ? { staticHeaders: { ...entry.auth.staticHeaders } } : {}
+    },
+    capabilities: [...entry.capabilities],
+    ...entry.availability ? { availability: { ...entry.availability } } : {}
+  }));
+}
+
+// packages/backend-vllm/dist/normalizeUrl.js
+function normalizeBaseUrl(url) {
+  let value = url.trim().replace(/\/+$/, "");
+  value = value.replace(/\/chat\/completions$/, "");
+  value = value.replace(/\/completions$/, "");
+  value = value.replace(/\/embeddings$/, "");
+  value = value.replace(/\/models(?:\/.*)?$/, "");
+  value = value.replace(/\/+$/, "");
+  value = value.replace(/\/v1\/openai$/, "");
+  value = value.replace(/\/+$/, "");
+  value = value.replace(/\/v1$/, "");
+  return value.replace(/\/+$/, "");
+}
+function toProviderInfo(provider) {
+  const normalizedDefault = provider.defaultUrl ? normalizeBaseUrl(provider.defaultUrl) : "";
+  const absoluteModelsUrl = provider.defaultUrl && provider.paths.models ? `${new URL(provider.defaultUrl).origin}${provider.paths.models}` : "";
+  const modelsPath = normalizedDefault && absoluteModelsUrl.startsWith(normalizedDefault) ? absoluteModelsUrl.slice(normalizedDefault.length) || "/models" : provider.paths.models ?? `${provider.apiPrefix}/models`;
+  return {
+    id: provider.id,
+    label: provider.label,
+    local: provider.local,
+    authRequired: provider.auth.required,
+    ...provider.auth.keyPrefix ? { keyPrefix: provider.auth.keyPrefix } : {},
+    // Compatibility path relative to normalizeBaseUrl(defaultUrl). New code
+    // should use resolveProviderTransport().urls.models directly.
+    modelsPath,
+    ...provider.defaultUrl ? { defaultUrl: provider.defaultUrl } : {},
+    ...provider.apiKeyUrl ? { apiKeyUrl: provider.apiKeyUrl } : {},
+    ...provider.docsUrl ? { docsUrl: provider.docsUrl } : {},
+    description: provider.description,
+    protocol: provider.protocol,
+    apiPrefix: provider.apiPrefix,
+    aliases: provider.aliases
+  };
+}
+var PROVIDER_PRESETS = [
+  ...listProviderDescriptors().filter((provider) => provider.availability?.state !== "retired").map(toProviderInfo),
+  {
+    id: "custom",
+    label: "Custom endpoint",
+    local: false,
+    authRequired: false,
+    modelsPath: "/v1/models",
+    description: "Custom endpoint; an explicit ollama, openai-chat, or anthropic-messages protocol is required."
+  }
+];
+
+// packages/cli/src/provider-credentials.ts
+import { constants as constants3, closeSync as closeSync5, existsSync as existsSync8, fstatSync as fstatSync3, fsyncSync as fsyncSync3, lstatSync as lstatSync3, mkdirSync as mkdirSync7, openSync as openSync5, readFileSync as readFileSync9, readdirSync as readdirSync2, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "node:fs";
+var NOFOLLOW = constants3.O_NOFOLLOW ?? 0;
+
+// packages/cli/src/config.ts
+var DEFAULT_CONFIG2 = Object.freeze({
+  backendUrl: "http://127.0.0.1:11434",
+  model: "",
+  backendType: "ollama",
+  apiKey: "",
+  maxRetries: 3,
+  timeoutMs: 3e5,
+  dryRun: false,
+  verbose: false,
+  debug: false,
+  thinking: false,
+  dbPath: omniusConfigDir("memory.db")
+});
+var LEGACY_LOCAL_INFERENCE = Object.freeze({
+  backendUrl: "http://127.0.0.1:11434",
+  backendType: "ollama",
+  model: ""
+});
+
+// packages/cli/src/redact/secret-redactor.ts
+var _PREFIX_PATTERNS = [
+  "sk-[A-Za-z0-9_-]{10,}",
+  // OpenAI / OpenRouter / Anthropic (sk-ant-*)
+  "ghp_[A-Za-z0-9]{10,}",
+  // GitHub PAT (classic)
+  "github_pat_[A-Za-z0-9_]{10,}",
+  // GitHub PAT (fine-grained)
+  "xox[baprs]-[A-Za-z0-9-]{10,}",
+  // Slack tokens
+  "AIza[A-Za-z0-9_-]{30,}",
+  // Google API keys
+  "pplx-[A-Za-z0-9]{10,}",
+  // Perplexity
+  "fal_[A-Za-z0-9_-]{10,}",
+  // Fal.ai
+  "fc-[A-Za-z0-9]{10,}",
+  // Firecrawl
+  "bb_live_[A-Za-z0-9_-]{10,}",
+  // BrowserBase
+  "gAAAA[A-Za-z0-9_=-]{20,}",
+  // Codex encrypted tokens
+  "AKIA[A-Z0-9]{16}",
+  // AWS Access Key ID
+  "sk_live_[A-Za-z0-9]{10,}",
+  // Stripe secret key (live)
+  "sk_test_[A-Za-z0-9]{10,}",
+  // Stripe secret key (test)
+  "rk_live_[A-Za-z0-9]{10,}",
+  // Stripe restricted key
+  "SG\\.[A-Za-z0-9_-]{10,}",
+  // SendGrid API key
+  "hf_[A-Za-z0-9]{10,}",
+  // HuggingFace token
+  "r8_[A-Za-z0-9]{10,}",
+  // Replicate API token
+  "npm_[A-Za-z0-9]{10,}",
+  // npm access token
+  "pypi-[A-Za-z0-9_-]{10,}",
+  // PyPI API token
+  "dop_v1_[A-Za-z0-9]{10,}",
+  // DigitalOcean PAT
+  "doo_v1_[A-Za-z0-9]{10,}",
+  // DigitalOcean OAuth
+  "am_[A-Za-z0-9_-]{10,}"
+  // AgentMail API key
+];
+var _SECRET_ENV_NAMES = "(?:API_?KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH)";
+var _JSON_KEY_NAMES = "(?:api_?[Kk]ey|token|secret|password|access_token|refresh_token|auth_token|bearer|secret_value|raw_secret|secret_input|key_material)";
+var _PREFIX_RE = new RegExp(
+  "(?<![A-Za-z0-9_-])(" + _PREFIX_PATTERNS.join("|") + ")(?![A-Za-z0-9_-])",
+  "g"
+);
+var _ENV_ASSIGN_RE = new RegExp(
+  "(?<![A-Z_])([A-Z_]*" + _SECRET_ENV_NAMES + `[A-Z_]*)\\s*=\\s*(['"]?)(\\S+)\\2`,
+  "gi"
+);
+var _JSON_FIELD_RE = new RegExp(
+  '("' + _JSON_KEY_NAMES + '")\\s*:\\s*"([^"]+)"',
+  "gi"
+);
+
+// packages/cli/src/tui/omnius-directory.ts
+init_dist5();
+
+// packages/cli/src/tui/theme.ts
+var TERMINAL_DEFAULTS = {
+  mode: "system",
+  bg: -1,
+  accent: -1,
+  textPrimary: -1,
+  textDim: -1,
+  boxColor: -1
+};
+var config = { ...TERMINAL_DEFAULTS };
+
+// packages/cli/src/tui/native/output-scope.ts
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
+var scopes = new AsyncLocalStorage5();
+
+// packages/cli/src/ui/brand-palette.ts
+var OMNIUS_EARTH_HEX = Object.freeze({
+  ink: "#101310",
+  void: "#080a08",
+  canvas: "#0d100d",
+  backdropTop: "#171813",
+  backdropBottom: "#2a2019",
+  panel: "#111510",
+  panelRaised: "#1d241e",
+  panelHover: "#29322a",
+  paper: "#f3f2ec",
+  ground: "#d4d1c3",
+  moss: "#506a55",
+  sage: "#91aa93",
+  muted: "#b8bcb5",
+  lichen: "#d8ed9d",
+  bark: "#936658",
+  soil: "#2a1d17",
+  clay: "#d27b61",
+  ochre: "#dfbd73",
+  success: "#7fd48b"
+});
+var OMNIUS_EARTH_256 = Object.freeze({
+  background: 233,
+  surface: 234,
+  surfaceRaised: 235,
+  accent: 108,
+  accentDim: 65,
+  textPrimary: 254,
+  textDim: 145,
+  ground: 187,
+  focus: 193,
+  success: 114,
+  warning: 180,
+  error: 173,
+  info: 108,
+  bark: 137
+});
+
+// packages/cli/src/tui/text-selection.ts
+var SEL_BG = OMNIUS_EARTH_256.accent;
+var SEL_FG = 30;
+var SEL_START = `\x1B[${SEL_FG}m\x1B[48;5;${SEL_BG}m`;
+
+// packages/cli/src/tui/task-complete-box.ts
+var TASK_COMPLETE_GREEN_256 = 114;
+var GREEN = `\x1B[38;5;${TASK_COMPLETE_GREEN_256}m`;
+var FG_BORDER = `\x1B[38;5;${TASK_COMPLETE_GREEN_256}m`;
+var FG_TITLE = `\x1B[1;38;5;${TASK_COMPLETE_GREEN_256}m`;
+var wrapGraphemes = new Intl.Segmenter(void 0, {
+  granularity: "grapheme"
+});
+
+// packages/cli/src/tui/omnius-directory.ts
+var MAX_CONTEXT_LEDGER_BYTES = 512 * 1024;
+var SAME_TASK_REPLACE_WINDOW_MS = 12 * 60 * 60 * 1e3;
+
+// packages/cli/src/service-auto-update.ts
+var SERVICE_AUTO_UPDATE_INTERVAL_MS = 60 * 60 * 1e3;
+var FAILED_TARGET_RETRY_MS = 24 * 60 * 60 * 1e3;
 
 // packages/cli/src/tray.ts
 var DEFAULT_ENDPOINT = "http://127.0.0.1:11435";
 function uidSuffix() {
   return typeof process.getuid === "function" ? String(process.getuid()) : "user";
 }
-function resolveTrayPaths(env = process.env, platform2 = process.platform, home = homedir17()) {
-  const runtimeBase = env["XDG_RUNTIME_DIR"] || join19(tmpdir6(), `omnius-${uidSuffix()}`);
-  const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join19(home, "AppData", "Local") : env["XDG_STATE_HOME"] || join19(home, ".local", "state");
-  const configBase = platform2 === "win32" ? env["APPDATA"] || join19(home, "AppData", "Roaming") : env["XDG_CONFIG_HOME"] || join19(home, ".config");
-  const runtimeDir = join19(runtimeBase, "omnius");
-  const stateDir = platform2 === "win32" ? join19(stateBase, "Omnius") : join19(stateBase, "omnius");
-  const autostartFile = platform2 === "darwin" ? join19(home, "Library", "LaunchAgents", "ai.omnius.tray.plist") : platform2 === "win32" ? join19(configBase, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "omnius-tray.cmd") : join19(configBase, "autostart", "omnius-tray.desktop");
+function resolveTrayPaths(env = process.env, platform2 = process.platform, home = homedir18()) {
+  const runtimeBase = env["XDG_RUNTIME_DIR"] || join21(tmpdir6(), `omnius-${uidSuffix()}`);
+  const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join21(home, "AppData", "Local") : env["XDG_STATE_HOME"] || join21(home, ".local", "state");
+  const configBase = platform2 === "win32" ? env["APPDATA"] || join21(home, "AppData", "Roaming") : env["XDG_CONFIG_HOME"] || join21(home, ".config");
+  const runtimeDir = join21(runtimeBase, "omnius");
+  const stateDir = platform2 === "win32" ? join21(stateBase, "Omnius") : join21(stateBase, "omnius");
+  const autostartFile = platform2 === "darwin" ? join21(home, "Library", "LaunchAgents", "ai.omnius.tray.plist") : platform2 === "win32" ? join21(configBase, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "omnius-tray.cmd") : join21(configBase, "autostart", "omnius-tray.desktop");
   return {
     runtimeDir,
     stateDir,
-    pidFile: join19(runtimeDir, "tray.pid"),
-    stateFile: join19(runtimeDir, "tray-state.json"),
-    stdoutLog: join19(stateDir, "tray.log"),
-    stderrLog: join19(stateDir, "tray.err.log"),
+    pidFile: join21(runtimeDir, "tray.pid"),
+    stateFile: join21(runtimeDir, "tray-state.json"),
+    stdoutLog: join21(stateDir, "tray.log"),
+    stderrLog: join21(stateDir, "tray.err.log"),
     autostartFile
   };
 }
@@ -304765,7 +305524,7 @@ function isProcessAlive2(pid) {
 }
 function readPid(path3) {
   try {
-    const pid = Number(readFileSync9(path3, "utf8").trim());
+    const pid = Number(readFileSync10(path3, "utf8").trim());
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
@@ -304773,7 +305532,7 @@ function readPid(path3) {
 }
 function readProcessState(path3) {
   try {
-    return JSON.parse(readFileSync9(path3, "utf8"));
+    return JSON.parse(readFileSync10(path3, "utf8"));
   } catch {
     return null;
   }
@@ -304807,7 +305566,7 @@ async function commandOutput(command, args, timeout = 2e3) {
 async function processCommandLine(pid) {
   try {
     if (process.platform === "linux") {
-      return readFileSync9(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
+      return readFileSync10(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
     }
     if (process.platform !== "win32") {
       return (await commandOutput("ps", ["-p", String(pid), "-o", "command="])).trim();
@@ -304826,7 +305585,7 @@ async function getTrayStatus(explicitEndpoint) {
   const running = pid !== null && isProcessAlive2(pid);
   if (pid && !running) {
     try {
-      unlinkSync5(paths.pidFile);
+      unlinkSync6(paths.pidFile);
     } catch {
     }
   }
@@ -304841,7 +305600,7 @@ async function getTrayStatus(explicitEndpoint) {
     // requested endpoint. This previously kept resurrecting an obsolete
     // custom port (for example 11535) after the daemon had returned to 11435.
     endpoint: running || !explicitEndpoint ? state?.endpoint || requestedEndpoint : requestedEndpoint,
-    registered: existsSync8(paths.autostartFile),
+    registered: existsSync9(paths.autostartFile),
     registrationFile: paths.autostartFile,
     ...state?.health ? { health: state.health } : {},
     supported: support.supported,
@@ -304854,11 +305613,11 @@ async function stopTray() {
   const pid = readPid(paths.pidFile);
   if (!pid || !isProcessAlive2(pid)) {
     try {
-      unlinkSync5(paths.pidFile);
+      unlinkSync6(paths.pidFile);
     } catch {
     }
     try {
-      unlinkSync5(paths.stateFile);
+      unlinkSync6(paths.stateFile);
     } catch {
     }
     return false;
@@ -304875,11 +305634,11 @@ async function stopTray() {
   for (let i = 0; i < 30; i++) {
     if (!isProcessAlive2(pid)) {
       try {
-        unlinkSync5(paths.pidFile);
+        unlinkSync6(paths.pidFile);
       } catch {
       }
       try {
-        unlinkSync5(paths.stateFile);
+        unlinkSync6(paths.stateFile);
       } catch {
       }
       return true;
@@ -304894,11 +305653,11 @@ async function stopTray() {
   for (let i = 0; i < 20; i++) {
     if (!isProcessAlive2(pid)) {
       try {
-        unlinkSync5(paths.pidFile);
+        unlinkSync6(paths.pidFile);
       } catch {
       }
       try {
-        unlinkSync5(paths.stateFile);
+        unlinkSync6(paths.stateFile);
       } catch {
       }
       return true;
@@ -304964,6 +305723,8 @@ async function runUpdateWorkerRuntime(state, paths, endpoint) {
           } : null;
         },
         restartTray: trayWasRunning ? (executable) => restartTrayWithInstalledExecutable(executable, endpoint) : void 0,
+        // A daemon that boots but crashes shortly after is an update failure.
+        stabilityWindowMs: 15e3,
         signal: cancellation.signal
       },
       paths