omnius 1.0.899 → 1.0.900

package/dist/update-worker-runtime.js

@@ -57172,7 +57172,7 @@ var require_util = __commonJS({
       return path3;
     }
     exports.normalize = normalize;
-    function join20(aRoot, aPath) {
+    function join21(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -57204,7 +57204,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join20;
+    exports.join = join21;
     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 = join21(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");
             }
@@ -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(
@@ -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,
@@ -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 join21() {
         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) {
@@ -304478,6 +304478,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 +304545,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 +304598,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 +304685,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 join20 } from "node:path";
+
+// packages/cli/src/config-home.ts
+import { homedir as homedir17 } from "node:os";
+import { join as join18 } from "node:path";
+function omniusConfigDir(...parts) {
+  return join18(
+    process.env["OMNIUS_CONFIG_HOME"] ?? homedir17(),
+    ".omnius",
+    ...parts
+  );
+}
 
 // packages/cli/src/tray-menu.ts
 import { execFile as execFile4 } from "node:child_process";
@@ -304668,30 +304736,686 @@ var run = promisify4(execFile4);
 init_daemon();
 
 // packages/cli/src/updater.ts
-import { join as join18 } from "node:path";
+import { join as join19 } 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 = join19(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"] || join20(tmpdir6(), `omnius-${uidSuffix()}`);
+  const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join20(home, "AppData", "Local") : env["XDG_STATE_HOME"] || join20(home, ".local", "state");
+  const configBase = platform2 === "win32" ? env["APPDATA"] || join20(home, "AppData", "Roaming") : env["XDG_CONFIG_HOME"] || join20(home, ".config");
+  const runtimeDir = join20(runtimeBase, "omnius");
+  const stateDir = platform2 === "win32" ? join20(stateBase, "Omnius") : join20(stateBase, "omnius");
+  const autostartFile = platform2 === "darwin" ? join20(home, "Library", "LaunchAgents", "ai.omnius.tray.plist") : platform2 === "win32" ? join20(configBase, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "omnius-tray.cmd") : join20(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: join20(runtimeDir, "tray.pid"),
+    stateFile: join20(runtimeDir, "tray-state.json"),
+    stdoutLog: join20(stateDir, "tray.log"),
+    stderrLog: join20(stateDir, "tray.err.log"),
     autostartFile
   };
 }
@@ -304765,7 +305489,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 +305497,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 +305531,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 +305550,7 @@ async function getTrayStatus(explicitEndpoint) {
   const running = pid !== null && isProcessAlive2(pid);
   if (pid && !running) {
     try {
-      unlinkSync5(paths.pidFile);
+      unlinkSync6(paths.pidFile);
     } catch {
     }
   }
@@ -304841,7 +305565,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 +305578,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 +305599,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 +305618,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 +305688,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