@xo-code/cli 0.1.2 → 0.1.3

package/dist/index.js

@@ -1559,14 +1559,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command} `this` command for chaining
        * @private
        */
-      _optionEx(config, flags, description, fn, defaultValue) {
+      _optionEx(config2, flags, description, fn, defaultValue) {
         if (typeof flags === "object" && flags instanceof Option2) {
           throw new Error(
             "To add an Option object use addOption() instead of option() or requiredOption()"
           );
         }
         const option = this.createOption(flags, description);
-        option.makeOptionMandatory(!!config.mandatory);
+        option.makeOptionMandatory(!!config2.mandatory);
         if (typeof fn === "function") {
           option.default(defaultValue).argParser(fn);
         } else if (fn instanceof RegExp) {
@@ -2470,9 +2470,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
           this._outputConfiguration.writeErr("\n");
           this.outputHelp({ error: true });
         }
-        const config = errorOptions || {};
-        const exitCode = config.exitCode || 1;
-        const code = config.code || "commander.error";
+        const config2 = errorOptions || {};
+        const exitCode = config2.exitCode || 1;
+        const code = config2.code || "commander.error";
         this._exit(exitCode, code, message);
       }
       /**
@@ -33374,19 +33374,19 @@ ${lanes.join("\n")}
           pollScheduled = host.setTimeout(pollQueue, 2e3, "pollQueue");
         }
       }
-      function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
+      function createSingleWatcherPerName(cache2, useCaseSensitiveFileNames2, name, callback, createWatcher) {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
         const path14 = toCanonicalFileName(name);
-        const existing = cache.get(path14);
+        const existing = cache2.get(path14);
         if (existing) {
           existing.callbacks.push(callback);
         } else {
-          cache.set(path14, {
+          cache2.set(path14, {
             watcher: createWatcher(
               // Cant infer types correctly so lets satisfy checker
               (param1, param2, param3) => {
                 var _a;
-                return (_a = cache.get(path14)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
+                return (_a = cache2.get(path14)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
               }
             ),
             callbacks: [callback]
@@ -33394,10 +33394,10 @@ ${lanes.join("\n")}
         }
         return {
           close: () => {
-            const watcher = cache.get(path14);
+            const watcher = cache2.get(path14);
             if (!watcher) return;
             if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
-            cache.delete(path14);
+            cache2.delete(path14);
             closeFileWatcherOf(watcher);
           }
         };
@@ -33433,7 +33433,7 @@ ${lanes.join("\n")}
         setTimeout: setTimeout2,
         clearTimeout: clearTimeout2
       }) {
-        const cache = /* @__PURE__ */ new Map();
+        const cache2 = /* @__PURE__ */ new Map();
         const callbackCache = createMultiMap();
         const cacheToUpdateChildWatches = /* @__PURE__ */ new Map();
         let timerToUpdateChildWatches;
@@ -33442,7 +33442,7 @@ ${lanes.join("\n")}
         return (dirName, callback, recursive, options) => recursive ? createDirectoryWatcher(dirName, options, callback) : watchDirectory(dirName, callback, recursive, options);
         function createDirectoryWatcher(dirName, options, callback, link) {
           const dirPath = toCanonicalFilePath(dirName);
-          let directoryWatcher = cache.get(dirPath);
+          let directoryWatcher = cache2.get(dirPath);
           if (directoryWatcher) {
             directoryWatcher.refCount++;
           } else {
@@ -33453,7 +33453,7 @@ ${lanes.join("\n")}
                   var _a;
                   if (isIgnoredPath(fileName, options)) return;
                   if (options == null ? void 0 : options.synchronousWatchDirectory) {
-                    if (!((_a = cache.get(dirPath)) == null ? void 0 : _a.targetWatcher)) invokeCallbacks(dirName, dirPath, fileName);
+                    if (!((_a = cache2.get(dirPath)) == null ? void 0 : _a.targetWatcher)) invokeCallbacks(dirName, dirPath, fileName);
                     updateChildWatches(dirName, dirPath, options);
                   } else {
                     nonSyncUpdateChildWatches(dirName, dirPath, fileName, options);
@@ -33468,7 +33468,7 @@ ${lanes.join("\n")}
               targetWatcher: void 0,
               links: void 0
             };
-            cache.set(dirPath, directoryWatcher);
+            cache2.set(dirPath, directoryWatcher);
             updateChildWatches(dirName, dirPath, options);
           }
           if (link) (directoryWatcher.links ?? (directoryWatcher.links = /* @__PURE__ */ new Set())).add(link);
@@ -33480,12 +33480,12 @@ ${lanes.join("\n")}
             dirName,
             close: () => {
               var _a;
-              const directoryWatcher2 = Debug.checkDefined(cache.get(dirPath));
+              const directoryWatcher2 = Debug.checkDefined(cache2.get(dirPath));
               if (callbackToAdd) callbackCache.remove(dirPath, callbackToAdd);
               if (link) (_a = directoryWatcher2.links) == null ? void 0 : _a.delete(link);
               directoryWatcher2.refCount--;
               if (directoryWatcher2.refCount) return;
-              cache.delete(dirPath);
+              cache2.delete(dirPath);
               directoryWatcher2.links = void 0;
               closeFileWatcherOf(directoryWatcher2);
               closeTargetWatcher(directoryWatcher2);
@@ -33521,7 +33521,7 @@ ${lanes.join("\n")}
               }
             }
           });
-          (_b = (_a = cache.get(dirPath)) == null ? void 0 : _a.links) == null ? void 0 : _b.forEach((link) => {
+          (_b = (_a = cache2.get(dirPath)) == null ? void 0 : _a.links) == null ? void 0 : _b.forEach((link) => {
             const toPathInLink = (fileName2) => combinePaths(link, getRelativePathFromDirectory(dirName, fileName2, toCanonicalFilePath));
             if (invokeMap) {
               invokeCallbacks(link, toCanonicalFilePath(link), invokeMap, fileNames == null ? void 0 : fileNames.map(toPathInLink));
@@ -33531,7 +33531,7 @@ ${lanes.join("\n")}
           });
         }
         function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
-          const parentWatcher = cache.get(dirPath);
+          const parentWatcher = cache2.get(dirPath);
           if (parentWatcher && fileSystemEntryExists(
             dirName,
             1
@@ -33569,7 +33569,7 @@ ${lanes.join("\n")}
             const { value: [dirPath, { dirName, options, fileNames }] } = result;
             cacheToUpdateChildWatches.delete(dirPath);
             const hasChanges = updateChildWatches(dirName, dirPath, options);
-            if (!((_a = cache.get(dirPath)) == null ? void 0 : _a.targetWatcher)) invokeCallbacks(dirName, dirPath, invokeMap, hasChanges ? void 0 : fileNames);
+            if (!((_a = cache2.get(dirPath)) == null ? void 0 : _a.targetWatcher)) invokeCallbacks(dirName, dirPath, invokeMap, hasChanges ? void 0 : fileNames);
           }
           sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start}ms:: ${cacheToUpdateChildWatches.size}`);
           callbackCache.forEach((callbacks, rootDirName) => {
@@ -33593,7 +33593,7 @@ ${lanes.join("\n")}
           parentWatcher.childWatches = emptyArray;
           for (const childWatcher of existingChildWatches) {
             childWatcher.close();
-            removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));
+            removeChildWatches(cache2.get(toCanonicalFilePath(childWatcher.dirName)));
           }
         }
         function closeTargetWatcher(watcher) {
@@ -33603,7 +33603,7 @@ ${lanes.join("\n")}
           }
         }
         function updateChildWatches(parentDir, parentDirPath, options) {
-          const parentWatcher = cache.get(parentDirPath);
+          const parentWatcher = cache2.get(parentDirPath);
           if (!parentWatcher) return false;
           const target = normalizePath(realpath(parentDir));
           let hasChanges;
@@ -34036,9 +34036,9 @@ ${lanes.join("\n")}
           path14,
           data,
           !!writeBom,
-          (path22, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path22, data2, writeByteOrderMark),
-          (path22) => sys2.createDirectory(path22),
-          (path22) => sys2.directoryExists(path22)
+          (path23, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path23, data2, writeByteOrderMark),
+          (path23) => sys2.createDirectory(path23),
+          (path23) => sys2.directoryExists(path23)
         );
       }
       var sys = (() => {
@@ -48056,13 +48056,13 @@ ${lanes.join("\n")}
         function hasAnySymlinks() {
           return !!(symlinkedFiles == null ? void 0 : symlinkedFiles.size) || !!symlinkedDirectories && !!forEachEntry(symlinkedDirectories, (value) => !!value);
         }
-        function processResolution(cache, resolution) {
+        function processResolution(cache2, resolution) {
           if (!resolution || !resolution.originalPath || !resolution.resolvedFileName) return;
           const { resolvedFileName, originalPath } = resolution;
-          cache.setSymlinkedFile(toPath(originalPath, cwd, getCanonicalFileName), resolvedFileName);
+          cache2.setSymlinkedFile(toPath(originalPath, cwd, getCanonicalFileName), resolvedFileName);
           const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedFileName, originalPath, cwd, getCanonicalFileName) || emptyArray;
           if (commonResolved && commonOriginal) {
-            cache.setSymlinkedDirectory(
+            cache2.setSymlinkedDirectory(
               commonOriginal,
               {
                 real: ensureTrailingDirectorySeparator(commonResolved),
@@ -48245,13 +48245,13 @@ ${lanes.join("\n")}
           visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
         }
         return flatten(results);
-        function visitDirectory(path22, absolutePath, depth2) {
+        function visitDirectory(path23, absolutePath, depth2) {
           const canonicalPath = toCanonical(realpath(absolutePath));
           if (visited.has(canonicalPath)) return;
           visited.set(canonicalPath, true);
-          const { files, directories } = getFileSystemEntries(path22);
+          const { files, directories } = getFileSystemEntries(path23);
           for (const current of toSorted(files, compareStringsCaseSensitive)) {
-            const name = combinePaths(path22, current);
+            const name = combinePaths(path23, current);
             const absoluteName = combinePaths(absolutePath, current);
             if (extensions && !fileExtensionIsOneOf(name, extensions)) continue;
             if (excludeRegex && excludeRegex.test(absoluteName)) continue;
@@ -48271,7 +48271,7 @@ ${lanes.join("\n")}
             }
           }
           for (const current of toSorted(directories, compareStringsCaseSensitive)) {
-            const name = combinePaths(path22, current);
+            const name = combinePaths(path23, current);
             const absoluteName = combinePaths(absolutePath, current);
             if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && (!excludeRegex || !excludeRegex.test(absoluteName))) {
               visitDirectory(name, absoluteName, depth2);
@@ -48532,10 +48532,10 @@ ${lanes.join("\n")}
         const match = str2.match(/\//g);
         return match ? match.length : 0;
       }
-      function compareNumberOfDirectorySeparators(path1, path22) {
+      function compareNumberOfDirectorySeparators(path1, path23) {
         return compareValues(
           numberOfDirectorySeparators(path1),
-          numberOfDirectorySeparators(path22)
+          numberOfDirectorySeparators(path23)
         );
       }
       var extensionsToRemove = [
@@ -70632,7 +70632,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,
@@ -70666,8 +70666,8 @@ ${lanes.join("\n")}
             }
           }
         }
-        assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
-        return config;
+        assign(config2.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
+        return config2;
       }
       function optionMapToObject(optionMap) {
         return Object.fromEntries(optionMap);
@@ -70685,12 +70685,12 @@ ${lanes.join("\n")}
         const includeRe = patterns.includeFilePattern && getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
         if (includeRe) {
           if (excludeRe) {
-            return (path22) => !(includeRe.test(path22) && !excludeRe.test(path22));
+            return (path23) => !(includeRe.test(path23) && !excludeRe.test(path23));
           }
-          return (path22) => !includeRe.test(path22);
+          return (path23) => !includeRe.test(path23);
         }
         if (excludeRe) {
-          return (path22) => excludeRe.test(path22);
+          return (path23) => excludeRe.test(path23);
         }
         return returnTrue;
       }
@@ -71394,7 +71394,7 @@ ${lanes.join("\n")}
         if (extendedConfigCache && (value = extendedConfigCache.get(path14))) {
           ({ extendedResult, extendedConfig } = value);
         } else {
-          extendedResult = readJsonConfigFile(extendedConfigPath, (path22) => host.readFile(path22));
+          extendedResult = readJsonConfigFile(extendedConfigPath, (path23) => host.readFile(path23));
           if (!extendedResult.parseDiagnostics.length) {
             extendedConfig = parseConfig(
               /*json*/
@@ -71893,7 +71893,7 @@ ${lanes.join("\n")}
         Debug.assert(extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
       }
-      function createResolvedModuleWithFailedLookupLocationsHandlingSymlink(moduleName, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state, cache, alternateResult) {
+      function createResolvedModuleWithFailedLookupLocationsHandlingSymlink(moduleName, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state, cache2, alternateResult) {
         if (!state.resultFromCache && !state.compilerOptions.preserveSymlinks && resolved && isExternalLibraryImport && !resolved.originalPath && !isExternalModuleNameRelative(moduleName)) {
           const { resolvedFileName, originalPath } = getOriginalAndResolvedFileName(resolved.path, state.host, state.traceEnabled);
           if (originalPath) resolved = { ...resolved, path: resolvedFileName, originalPath };
@@ -71905,13 +71905,13 @@ ${lanes.join("\n")}
           affectingLocations,
           diagnostics,
           state.resultFromCache,
-          cache,
+          cache2,
           alternateResult
         );
       }
-      function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache, cache, alternateResult) {
+      function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache, cache2, alternateResult) {
         if (resultFromCache) {
-          if (!(cache == null ? void 0 : cache.isReadonly)) {
+          if (!(cache2 == null ? void 0 : cache2.isReadonly)) {
             resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, failedLookupLocations);
             resultFromCache.affectingLocations = updateResolutionField(resultFromCache.affectingLocations, affectingLocations);
             resultFromCache.resolutionDiagnostics = updateResolutionField(resultFromCache.resolutionDiagnostics, diagnostics);
@@ -72067,9 +72067,9 @@ ${lanes.join("\n")}
         return typeRoots;
       }
       var nodeModulesAtTypes = combinePaths("node_modules", "@types");
-      function arePathsEqual(path1, path22, host) {
+      function arePathsEqual(path1, path23, host) {
         const useCaseSensitiveFileNames2 = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
-        return comparePaths(path1, path22, !useCaseSensitiveFileNames2) === 0;
+        return comparePaths(path1, path23, !useCaseSensitiveFileNames2) === 0;
       }
       function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
         const resolvedFileName = realPath(fileName, host, traceEnabled);
@@ -72084,16 +72084,16 @@ ${lanes.join("\n")}
         const nameForLookup = endsWith(typeRoot, "/node_modules/@types") || endsWith(typeRoot, "/node_modules/@types/") ? mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) : typeReferenceDirectiveName;
         return combinePaths(typeRoot, nameForLookup);
       }
-      function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
+      function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache2, resolutionMode) {
         Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
         const traceEnabled = isTraceEnabled(options, host);
         if (redirectedReference) {
           options = redirectedReference.commandLine.options;
         }
         const containingDirectory = containingFile ? getDirectoryPath(containingFile) : void 0;
-        let result = containingDirectory ? cache == null ? void 0 : cache.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : void 0;
+        let result = containingDirectory ? cache2 == null ? void 0 : cache2.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : void 0;
         if (!result && containingDirectory && !isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-          result = cache == null ? void 0 : cache.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference);
+          result = cache2 == null ? void 0 : cache2.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference);
         }
         if (result) {
           if (traceEnabled) {
@@ -72141,7 +72141,7 @@ ${lanes.join("\n")}
           traceEnabled,
           failedLookupLocations,
           affectingLocations,
-          packageJsonInfoCache: cache,
+          packageJsonInfoCache: cache2,
           features,
           conditions,
           requestContainingDirectory: containingDirectory,
@@ -72175,15 +72175,15 @@ ${lanes.join("\n")}
           affectingLocations: initializeResolutionField(affectingLocations),
           resolutionDiagnostics: initializeResolutionField(diagnostics)
         };
-        if (containingDirectory && cache && !cache.isReadonly) {
-          cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(
+        if (containingDirectory && cache2 && !cache2.isReadonly) {
+          cache2.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(
             typeReferenceDirectiveName,
             /*mode*/
             resolutionMode,
             result
           );
           if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-            cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, result);
+            cache2.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, result);
           }
         }
         if (traceEnabled) traceResult(result);
@@ -72318,8 +72318,8 @@ ${lanes.join("\n")}
         }
         return concatenate(conditions, options.customConditions);
       }
-      function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
-        const moduleResolutionState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options);
+      function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache2) {
+        const moduleResolutionState = getTemporaryModuleResolutionState(cache2 == null ? void 0 : cache2.getPackageJsonInfoCache(), host, options);
         return forEachAncestorDirectory(containingDirectory, (ancestorDirectory) => {
           if (getBaseFileName(ancestorDirectory) !== "node_modules") {
             const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules");
@@ -72459,27 +72459,27 @@ ${lanes.join("\n")}
         }
       }
       function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
-        let cache;
+        let cache2;
         return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, getInternalMap };
         function getPackageJsonInfo2(packageJsonPath) {
-          return cache == null ? void 0 : cache.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
+          return cache2 == null ? void 0 : cache2.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
         }
         function setPackageJsonInfo(packageJsonPath, info) {
-          (cache || (cache = /* @__PURE__ */ new Map())).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
+          (cache2 || (cache2 = /* @__PURE__ */ new Map())).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
         }
         function clear2() {
-          cache = void 0;
+          cache2 = void 0;
         }
         function getInternalMap() {
-          return cache;
+          return cache2;
         }
       }
       function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
-        const cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
-        let result = cache.get(key);
+        const cache2 = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
+        let result = cache2.get(key);
         if (!result) {
           result = create();
-          cache.set(key, result);
+          cache2.set(key, result);
         }
         return result;
       }
@@ -72514,17 +72514,17 @@ ${lanes.join("\n")}
       function createModeAwareCache() {
         const underlying = /* @__PURE__ */ new Map();
         const memoizedReverseKeys = /* @__PURE__ */ new Map();
-        const cache = {
+        const cache2 = {
           get(specifier, mode) {
             return underlying.get(getUnderlyingCacheKey(specifier, mode));
           },
           set(specifier, mode, value) {
             underlying.set(getUnderlyingCacheKey(specifier, mode), value);
-            return cache;
+            return cache2;
           },
           delete(specifier, mode) {
             underlying.delete(getUnderlyingCacheKey(specifier, mode));
-            return cache;
+            return cache2;
           },
           has(specifier, mode) {
             return underlying.has(getUnderlyingCacheKey(specifier, mode));
@@ -72539,7 +72539,7 @@ ${lanes.join("\n")}
             return underlying.size;
           }
         };
-        return cache;
+        return cache2;
         function getUnderlyingCacheKey(specifier, mode) {
           const result = createModeAwareCacheKey(specifier, mode);
           memoizedReverseKeys.set(result, [specifier, mode]);
@@ -72685,12 +72685,12 @@ ${lanes.join("\n")}
       function getOptionsForLibraryResolution(options) {
         return { moduleResolution: 2, traceResolution: options.traceResolution };
       }
-      function resolveLibrary(libraryName, resolveFrom, compilerOptions, host, cache) {
-        return resolveModuleName(libraryName, resolveFrom, getOptionsForLibraryResolution(compilerOptions), host, cache);
+      function resolveLibrary(libraryName, resolveFrom, compilerOptions, host, cache2) {
+        return resolveModuleName(libraryName, resolveFrom, getOptionsForLibraryResolution(compilerOptions), host, cache2);
       }
-      function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
+      function resolveModuleNameFromCache(moduleName, containingFile, cache2, mode) {
         const containingDirectory = getDirectoryPath(containingFile);
-        return cache.getFromDirectoryCache(
+        return cache2.getFromDirectoryCache(
           moduleName,
           mode,
           containingDirectory,
@@ -72698,7 +72698,7 @@ ${lanes.join("\n")}
           void 0
         );
       }
-      function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+      function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode) {
         const traceEnabled = isTraceEnabled(compilerOptions, host);
         if (redirectedReference) {
           compilerOptions = redirectedReference.commandLine.options;
@@ -72710,7 +72710,7 @@ ${lanes.join("\n")}
           }
         }
         const containingDirectory = getDirectoryPath(containingFile);
-        let result = cache == null ? void 0 : cache.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, redirectedReference);
+        let result = cache2 == null ? void 0 : cache2.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, redirectedReference);
         if (result) {
           if (traceEnabled) {
             trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -72729,27 +72729,27 @@ ${lanes.join("\n")}
           }
           switch (moduleResolution) {
             case 3:
-              result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+              result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode);
               break;
             case 99:
-              result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+              result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode);
               break;
             case 2:
-              result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
+              result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
               break;
             case 1:
-              result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
+              result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference);
               break;
             case 100:
-              result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
+              result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
               break;
             default:
               return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`);
           }
-          if (cache && !cache.isReadonly) {
-            cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);
+          if (cache2 && !cache2.isReadonly) {
+            cache2.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);
             if (!isExternalModuleNameRelative(moduleName)) {
-              cache.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
+              cache2.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
             }
           }
         }
@@ -72896,31 +72896,31 @@ ${lanes.join("\n")}
         NodeResolutionFeatures2[NodeResolutionFeatures2["EsmMode"] = 32] = "EsmMode";
         return NodeResolutionFeatures2;
       })(NodeResolutionFeatures || {});
-      function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+      function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode) {
         return nodeNextModuleNameResolverWorker(
           30,
           moduleName,
           containingFile,
           compilerOptions,
           host,
-          cache,
+          cache2,
           redirectedReference,
           resolutionMode
         );
       }
-      function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+      function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode) {
         return nodeNextModuleNameResolverWorker(
           30,
           moduleName,
           containingFile,
           compilerOptions,
           host,
-          cache,
+          cache2,
           redirectedReference,
           resolutionMode
         );
       }
-      function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode, conditions) {
+      function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, resolutionMode, conditions) {
         const containingDirectory = getDirectoryPath(containingFile);
         const esmMode = resolutionMode === 99 ? 32 : 0;
         let extensions = compilerOptions.noDtsResolution ? 3 : 1 | 2 | 4;
@@ -72933,7 +72933,7 @@ ${lanes.join("\n")}
           containingDirectory,
           compilerOptions,
           host,
-          cache,
+          cache2,
           extensions,
           /*isConfigLookup*/
           false,
@@ -72959,7 +72959,7 @@ ${lanes.join("\n")}
           void 0
         );
       }
-      function bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, conditions) {
+      function bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, conditions) {
         const containingDirectory = getDirectoryPath(containingFile);
         let extensions = compilerOptions.noDtsResolution ? 3 : 1 | 2 | 4;
         if (getResolveJsonModule(compilerOptions)) {
@@ -72971,7 +72971,7 @@ ${lanes.join("\n")}
           containingDirectory,
           compilerOptions,
           host,
-          cache,
+          cache2,
           extensions,
           /*isConfigLookup*/
           false,
@@ -72979,7 +72979,7 @@ ${lanes.join("\n")}
           conditions
         );
       }
-      function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, conditions, isConfigLookup) {
+      function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference, conditions, isConfigLookup) {
         let extensions;
         if (isConfigLookup) {
           extensions = 8;
@@ -72989,7 +72989,7 @@ ${lanes.join("\n")}
         } else {
           extensions = getResolveJsonModule(compilerOptions) ? 1 | 2 | 4 | 8 : 1 | 2 | 4;
         }
-        return nodeModuleNameResolverWorker(conditions ? 30 : 0, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference, conditions);
+        return nodeModuleNameResolverWorker(conditions ? 30 : 0, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache2, extensions, !!isConfigLookup, redirectedReference, conditions);
       }
       function nodeNextJsonConfigResolver(moduleName, containingFile, host) {
         return nodeModuleNameResolverWorker(
@@ -73012,7 +73012,7 @@ ${lanes.join("\n")}
           void 0
         );
       }
-      function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, isConfigLookup, redirectedReference, conditions) {
+      function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache2, extensions, isConfigLookup, redirectedReference, conditions) {
         var _a, _b, _c, _d, _e;
         const traceEnabled = isTraceEnabled(compilerOptions, host);
         const failedLookupLocations = [];
@@ -73030,7 +73030,7 @@ ${lanes.join("\n")}
           traceEnabled,
           failedLookupLocations,
           affectingLocations,
-          packageJsonInfoCache: cache,
+          packageJsonInfoCache: cache2,
           features,
           conditions: conditions ?? emptyArray,
           requestContainingDirectory: containingDirectory,
@@ -73092,7 +73092,7 @@ ${lanes.join("\n")}
           affectingLocations,
           diagnostics,
           state,
-          cache,
+          cache2,
           alternateResult
         );
         function tryResolve(extensions2, state2) {
@@ -73111,10 +73111,10 @@ ${lanes.join("\n")}
           if (!isExternalModuleNameRelative(moduleName)) {
             let resolved2;
             if (features & 2 && startsWith(moduleName, "#")) {
-              resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+              resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache2, redirectedReference);
             }
             if (!resolved2 && features & 4) {
-              resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+              resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache2, redirectedReference);
             }
             if (!resolved2) {
               if (moduleName.includes(":")) {
@@ -73126,7 +73126,7 @@ ${lanes.join("\n")}
               if (traceEnabled) {
                 trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
               }
-              resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+              resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache2, redirectedReference);
             }
             if (extensions2 & 4) {
               resolved2 ?? (resolved2 = resolveFromTypeRoot(moduleName, state2));
@@ -73400,14 +73400,14 @@ ${lanes.join("\n")}
         const versionPaths = packageInfo && getVersionPathsOfPackageJsonInfo(packageInfo, state);
         return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths), state);
       }
-      function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) {
+      function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache2, resolveJs) {
         if (!resolveJs && packageJsonInfo.contents.resolvedEntrypoints !== void 0) {
           return packageJsonInfo.contents.resolvedEntrypoints;
         }
         let entrypoints;
         const extensions = 1 | 4 | (resolveJs ? 2 : 0);
         const features = getNodeResolutionFeatures(options);
-        const loadPackageJsonMainState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options);
+        const loadPackageJsonMainState = getTemporaryModuleResolutionState(cache2 == null ? void 0 : cache2.getPackageJsonInfoCache(), host, options);
         loadPackageJsonMainState.conditions = getConditions(options);
         loadPackageJsonMainState.requestContainingDirectory = packageJsonInfo.packageDirectory;
         const mainResolution = loadNodeModuleFromDirectoryWorker(
@@ -73709,7 +73709,7 @@ ${lanes.join("\n")}
       function noKeyStartsWithDot(obj) {
         return !some(getOwnKeys(obj), (k) => startsWith(k, "."));
       }
-      function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) {
+      function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache2, redirectedReference) {
         var _a, _b;
         const directoryPath = getNormalizedAbsolutePath(directory, (_b = (_a = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a));
         const scope = getPackageScopeForPath(directoryPath, state);
@@ -73727,13 +73727,13 @@ ${lanes.join("\n")}
         const trailingParts = parts.slice(nameParts.length);
         const subpath = !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`;
         if (getAllowJSCompilerOption(state.compilerOptions) && !pathContainsNodeModules(directory)) {
-          return loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference);
+          return loadModuleFromExports(scope, extensions, subpath, state, cache2, redirectedReference);
         }
         const priorityExtensions = extensions & (1 | 4);
         const secondaryExtensions = extensions & ~(1 | 4);
-        return loadModuleFromExports(scope, priorityExtensions, subpath, state, cache, redirectedReference) || loadModuleFromExports(scope, secondaryExtensions, subpath, state, cache, redirectedReference);
+        return loadModuleFromExports(scope, priorityExtensions, subpath, state, cache2, redirectedReference) || loadModuleFromExports(scope, secondaryExtensions, subpath, state, cache2, redirectedReference);
       }
-      function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
+      function loadModuleFromExports(scope, extensions, subpath, state, cache2, redirectedReference) {
         if (!scope.contents.packageJsonContent.exports) {
           return void 0;
         }
@@ -73748,7 +73748,7 @@ ${lanes.join("\n")}
             const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(
               extensions,
               state,
-              cache,
+              cache2,
               redirectedReference,
               subpath,
               scope,
@@ -73776,7 +73776,7 @@ ${lanes.join("\n")}
           const result = loadModuleFromImportsOrExports(
             extensions,
             state,
-            cache,
+            cache2,
             redirectedReference,
             subpath,
             scope.contents.packageJsonContent.exports,
@@ -73796,7 +73796,7 @@ ${lanes.join("\n")}
           void 0
         );
       }
-      function loadModuleFromImports(extensions, moduleName, directory, state, cache, redirectedReference) {
+      function loadModuleFromImports(extensions, moduleName, directory, state, cache2, redirectedReference) {
         var _a, _b;
         if (moduleName === "#" || startsWith(moduleName, "#/")) {
           if (state.traceEnabled) {
@@ -73830,7 +73830,7 @@ ${lanes.join("\n")}
         const result = loadModuleFromImportsOrExports(
           extensions,
           state,
-          cache,
+          cache2,
           redirectedReference,
           moduleName,
           scope.contents.packageJsonContent.imports,
@@ -73862,8 +73862,8 @@ ${lanes.join("\n")}
         if (b.length > a.length) return 1;
         return 0;
       }
-      function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
-        const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
+      function loadModuleFromImportsOrExports(extensions, state, cache2, redirectedReference, moduleName, lookupTable, scope, isImports) {
+        const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache2, redirectedReference, moduleName, scope, isImports);
         if (!endsWith(moduleName, directorySeparator) && !moduleName.includes("*") && hasProperty(lookupTable, moduleName)) {
           const target = lookupTable[moduleName];
           return loadModuleFromTargetImportOrExport(
@@ -73921,7 +73921,7 @@ ${lanes.join("\n")}
         const firstStar = patternKey.indexOf("*");
         return firstStar !== -1 && firstStar === patternKey.lastIndexOf("*");
       }
-      function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
+      function getLoadModuleFromTargetImportOrExport(extensions, state, cache2, redirectedReference, moduleName, scope, isImports) {
         return loadModuleFromTargetImportOrExport;
         function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) {
           if (typeof target === "string") {
@@ -73945,7 +73945,7 @@ ${lanes.join("\n")}
                   scope.packageDirectory + "/",
                   state.compilerOptions,
                   state.host,
-                  cache,
+                  cache2,
                   extensions,
                   /*isConfigLookup*/
                   false,
@@ -74157,7 +74157,7 @@ ${lanes.join("\n")}
         if (!range) return false;
         return range.test(version);
       }
-      function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
+      function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache2, redirectedReference) {
         return loadModuleFromNearestNodeModulesDirectoryWorker(
           extensions,
           moduleName,
@@ -74165,7 +74165,7 @@ ${lanes.join("\n")}
           state,
           /*typesScopeOnly*/
           false,
-          cache,
+          cache2,
           redirectedReference
         );
       }
@@ -74183,7 +74183,7 @@ ${lanes.join("\n")}
           void 0
         );
       }
-      function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
+      function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache2, redirectedReference) {
         const mode = state.features === 0 ? void 0 : state.features & 32 ? 99 : 1;
         const priorityExtensions = extensions & (1 | 4);
         const secondaryExtensions = extensions & ~(1 | 4);
@@ -74199,23 +74199,23 @@ ${lanes.join("\n")}
         function lookup(extensions2) {
           return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
             if (getBaseFileName(ancestorDirectory) !== "node_modules") {
-              const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
+              const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache2, moduleName, mode, ancestorDirectory, redirectedReference, state);
               if (resolutionFromCache) {
                 return resolutionFromCache;
               }
-              return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
+              return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache2, redirectedReference));
             }
           });
         }
       }
-      function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
+      function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache2, redirectedReference) {
         const nodeModulesFolder = combinePaths(directory, "node_modules");
         const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
         if (!nodeModulesFolderExists && state.traceEnabled) {
           trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
         }
         if (!typesScopeOnly) {
-          const packageResult = loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
+          const packageResult = loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache2, redirectedReference);
           if (packageResult) {
             return packageResult;
           }
@@ -74229,10 +74229,10 @@ ${lanes.join("\n")}
             }
             nodeModulesAtTypesExists = false;
           }
-          return loadModuleFromSpecificNodeModulesDirectory(4, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference);
+          return loadModuleFromSpecificNodeModulesDirectory(4, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache2, redirectedReference);
         }
       }
-      function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
+      function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache2, redirectedReference) {
         var _a, _b;
         const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName));
         const { packageName, rest } = parsePackageName(moduleName);
@@ -74275,7 +74275,7 @@ ${lanes.join("\n")}
           state.resolvedPackageDirectory = true;
         }
         if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & 8) {
-          return (_b = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache, redirectedReference)) == null ? void 0 : _b.value;
+          return (_b = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache2, redirectedReference)) == null ? void 0 : _b.value;
         }
         const versionPaths = rest !== "" && packageInfo ? getVersionPathsOfPackageJsonInfo(packageInfo, state) : void 0;
         if (versionPaths) {
@@ -74317,9 +74317,9 @@ ${lanes.join("\n")}
             }
             const extension = tryGetExtensionFromPath2(subst);
             if (extension !== void 0) {
-              const path22 = tryFile(candidate, onlyRecordFailures, state);
-              if (path22 !== void 0) {
-                return noPackageId({ path: path22, ext: extension, resolvedUsingTsExtension: void 0 });
+              const path23 = tryFile(candidate, onlyRecordFailures, state);
+              if (path23 !== void 0) {
+                return noPackageId({ path: path23, ext: extension, resolvedUsingTsExtension: void 0 });
               }
             }
             return loader(extensions, candidate, onlyRecordFailures || !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
@@ -74357,8 +74357,8 @@ ${lanes.join("\n")}
       function unmangleScopedPackageName(typesPackageName) {
         return typesPackageName.includes(mangledScopedPackageSeparator) ? "@" + typesPackageName.replace(mangledScopedPackageSeparator, directorySeparator) : typesPackageName;
       }
-      function tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, containingDirectory, redirectedReference, state) {
-        const result = cache && cache.getFromNonRelativeNameCache(moduleName, mode, containingDirectory, redirectedReference);
+      function tryFindNonRelativeModuleNameInCache(cache2, moduleName, mode, containingDirectory, redirectedReference, state) {
+        const result = cache2 && cache2.getFromNonRelativeNameCache(moduleName, mode, containingDirectory, redirectedReference);
         if (result) {
           if (state.traceEnabled) {
             trace(state.host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -74375,7 +74375,7 @@ ${lanes.join("\n")}
           };
         }
       }
-      function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
+      function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache2, redirectedReference) {
         const traceEnabled = isTraceEnabled(compilerOptions, host);
         const failedLookupLocations = [];
         const affectingLocations = [];
@@ -74387,7 +74387,7 @@ ${lanes.join("\n")}
           traceEnabled,
           failedLookupLocations,
           affectingLocations,
-          packageJsonInfoCache: cache,
+          packageJsonInfoCache: cache2,
           features: 0,
           conditions: [],
           requestContainingDirectory: containingDirectory,
@@ -74408,7 +74408,7 @@ ${lanes.join("\n")}
           affectingLocations,
           diagnostics,
           state,
-          cache
+          cache2
         );
         function tryResolve(extensions) {
           const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
@@ -74418,7 +74418,7 @@ ${lanes.join("\n")}
           if (!isExternalModuleNameRelative(moduleName)) {
             const resolved2 = forEachAncestorDirectory(containingDirectory, (directory) => {
               const resolutionFromCache = tryFindNonRelativeModuleNameInCache(
-                cache,
+                cache2,
                 moduleName,
                 /*mode*/
                 void 0,
@@ -78200,9 +78200,9 @@ ${lanes.join("\n")}
         if (!moduleSourceFile) {
           return emptyArray;
         }
-        const cache = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
-        const cached = cache == null ? void 0 : cache.get(importingSourceFile.path, moduleSourceFile.path, userPreferences, options);
-        return [cached == null ? void 0 : cached.kind, cached == null ? void 0 : cached.moduleSpecifiers, moduleSourceFile, cached == null ? void 0 : cached.modulePaths, cache];
+        const cache2 = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
+        const cached = cache2 == null ? void 0 : cache2.get(importingSourceFile.path, moduleSourceFile.path, userPreferences, options);
+        return [cached == null ? void 0 : cached.kind, cached == null ? void 0 : cached.moduleSpecifiers, moduleSourceFile, cached == null ? void 0 : cached.modulePaths, cache2];
       }
       function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
         return getModuleSpecifiersWithCacheInfo(
@@ -78227,7 +78227,7 @@ ${lanes.join("\n")}
             computedWithoutCache
           };
         }
-        let [kind, specifiers, moduleSourceFile, modulePaths, cache] = tryGetModuleSpecifiersFromCacheWorker(
+        let [kind, specifiers, moduleSourceFile, modulePaths, cache2] = tryGetModuleSpecifiersFromCacheWorker(
           moduleSymbol,
           importingSourceFile,
           host,
@@ -78247,7 +78247,7 @@ ${lanes.join("\n")}
           options,
           forAutoImport
         );
-        cache == null ? void 0 : cache.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, result.kind, modulePaths, result.moduleSpecifiers);
+        cache2 == null ? void 0 : cache2.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, result.kind, modulePaths, result.moduleSpecifiers);
         return result;
       }
       function getLocalModuleSpecifierBetweenFileNames(importingFile, targetFileName, compilerOptions, host, preferences, options = {}) {
@@ -78475,14 +78475,14 @@ ${lanes.join("\n")}
         var _a;
         const importingFilePath = toPath(info.importingSourceFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
         const importedFilePath = toPath(importedFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
-        const cache = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
-        if (cache) {
-          const cached = cache.get(importingFilePath, importedFilePath, preferences, options);
+        const cache2 = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
+        if (cache2) {
+          const cached = cache2.get(importingFilePath, importedFilePath, preferences, options);
           if (cached == null ? void 0 : cached.modulePaths) return cached.modulePaths;
         }
         const modulePaths = getAllModulePathsWorker(info, importedFileName, host, compilerOptions, options);
-        if (cache) {
-          cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
+        if (cache2) {
+          cache2.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
         }
         return modulePaths;
       }
@@ -78499,11 +78499,11 @@ ${lanes.join("\n")}
       }
       function getAllModulePathsWorker(info, importedFileName, host, compilerOptions, options) {
         var _a, _b;
-        const cache = (_a = host.getModuleResolutionCache) == null ? void 0 : _a.call(host);
+        const cache2 = (_a = host.getModuleResolutionCache) == null ? void 0 : _a.call(host);
         const links = (_b = host.getSymlinkCache) == null ? void 0 : _b.call(host);
-        if (cache && links && host.readFile && !pathContainsNodeModules(info.importingSourceFileName)) {
+        if (cache2 && links && host.readFile && !pathContainsNodeModules(info.importingSourceFileName)) {
           Debug.type(host);
-          const state = getTemporaryModuleResolutionState(cache.getPackageJsonInfoCache(), host, {});
+          const state = getTemporaryModuleResolutionState(cache2.getPackageJsonInfoCache(), host, {});
           const packageJson = getPackageScopeForPath(getDirectoryPath(info.importingSourceFileName), state);
           if (packageJson) {
             const toResolve = getAllRuntimeDependencies(packageJson.contents.packageJsonContent);
@@ -78513,7 +78513,7 @@ ${lanes.join("\n")}
                 combinePaths(packageJson.packageDirectory, "package.json"),
                 compilerOptions,
                 host,
-                cache,
+                cache2,
                 /*redirectedReference*/
                 void 0,
                 options.overrideImportMode
@@ -83143,11 +83143,11 @@ ${lanes.join("\n")}
             return void 0;
           }
           const links = getSymbolLinks(symbol);
-          const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
+          const cache2 = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
           const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node);
           const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`;
-          if (cache.has(key)) {
-            return cache.get(key);
+          if (cache2.has(key)) {
+            return cache2.get(key);
           }
           const id = getSymbolId(symbol);
           let visitedSymbolTables = visitedSymbolTablesMap.get(id);
@@ -83155,7 +83155,7 @@ ${lanes.join("\n")}
             visitedSymbolTablesMap.set(id, visitedSymbolTables = []);
           }
           const result = forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
-          cache.set(key, result);
+          cache2.set(key, result);
           return result;
           function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification, isLocalNameLookup) {
             if (!pushIfUnique(visitedSymbolTables, symbols)) {
@@ -95826,21 +95826,21 @@ ${lanes.join("\n")}
           }
         }
         function getSimplifiedIndexedAccessType(type, writing) {
-          const cache = writing ? "simplifiedForWriting" : "simplifiedForReading";
-          if (type[cache]) {
-            return type[cache] === circularConstraintType ? type : type[cache];
+          const cache2 = writing ? "simplifiedForWriting" : "simplifiedForReading";
+          if (type[cache2]) {
+            return type[cache2] === circularConstraintType ? type : type[cache2];
           }
-          type[cache] = circularConstraintType;
+          type[cache2] = circularConstraintType;
           const objectType = getSimplifiedType(type.objectType, writing);
           const indexType = getSimplifiedType(type.indexType, writing);
           const distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing);
           if (distributedOverIndex) {
-            return type[cache] = distributedOverIndex;
+            return type[cache2] = distributedOverIndex;
           }
           if (!(indexType.flags & 465829888)) {
             const distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing);
             if (distributedOverObject) {
-              return type[cache] = distributedOverObject;
+              return type[cache2] = distributedOverObject;
             }
           }
           if (isGenericTupleType(objectType) && indexType.flags & 296) {
@@ -95852,15 +95852,15 @@ ${lanes.join("\n")}
               writing
             );
             if (elementType) {
-              return type[cache] = elementType;
+              return type[cache2] = elementType;
             }
           }
           if (isGenericMappedType(objectType)) {
             if (getMappedTypeNameTypeKind(objectType) !== 2) {
-              return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), (t) => getSimplifiedType(t, writing));
+              return type[cache2] = mapType(substituteIndexedMappedType(objectType, type.indexType), (t) => getSimplifiedType(t, writing));
             }
           }
-          return type[cache] = type;
+          return type[cache2] = type;
         }
         function getSimplifiedConditionalType(type, writing) {
           const checkType = type.checkType;
@@ -104381,12 +104381,12 @@ ${lanes.join("\n")}
           }
           function getTypeAtFlowLoopLabel(flow) {
             const id = getFlowNodeId(flow);
-            const cache = flowLoopCaches[id] || (flowLoopCaches[id] = /* @__PURE__ */ new Map());
+            const cache2 = flowLoopCaches[id] || (flowLoopCaches[id] = /* @__PURE__ */ new Map());
             const key2 = getOrSetCacheKey();
             if (!key2) {
               return declaredType;
             }
-            const cached = cache.get(key2);
+            const cached = cache2.get(key2);
             if (cached) {
               return cached;
             }
@@ -104420,7 +104420,7 @@ ${lanes.join("\n")}
                 flowType = getTypeAtFlowNode(antecedent);
                 flowTypeCache = saveFlowTypeCache;
                 flowLoopCount--;
-                const cached2 = cache.get(key2);
+                const cached2 = cache2.get(key2);
                 if (cached2) {
                   return cached2;
                 }
@@ -104446,7 +104446,7 @@ ${lanes.join("\n")}
                 true
               );
             }
-            cache.set(key2, result);
+            cache2.set(key2, result);
             return result;
           }
           function getUnionOrEvolvingArrayType(types, subtypeReduction) {
@@ -115286,8 +115286,8 @@ ${lanes.join("\n")}
             /* TypeOnly */
           );
           if (flowInvocationCount !== startInvocationCount) {
-            const cache = flowTypeCache || (flowTypeCache = []);
-            cache[getNodeId(node)] = type;
+            const cache2 = flowTypeCache || (flowTypeCache = []);
+            cache2[getNodeId(node)] = type;
             setNodeFlags(
               node,
               node.flags | 268435456
@@ -157157,8 +157157,8 @@ ${lanes.join("\n")}
         }
         function generateNameCached(node, privateName, flags, prefix, suffix) {
           const nodeId = getNodeId(node);
-          const cache = privateName ? nodeIdToGeneratedPrivateName : nodeIdToGeneratedName;
-          return cache[nodeId] || (cache[nodeId] = generateNameForNode(node, privateName, flags ?? 0, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
+          const cache2 = privateName ? nodeIdToGeneratedPrivateName : nodeIdToGeneratedName;
+          return cache2[nodeId] || (cache2[nodeId] = generateNameForNode(node, privateName, flags ?? 0, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
         }
         function isUniqueName(name, privateName) {
           return isFileLevelUniqueNameInCurrentFile(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
@@ -158964,7 +158964,7 @@ ${lanes.join("\n")}
         getName: getModuleResolutionName,
         getMode: (entry, file, compilerOptions) => getModeForUsageLocation(file, entry, compilerOptions)
       };
-      function createModuleResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+      function createModuleResolutionLoader(containingFile, redirectedReference, options, host, cache2) {
         return {
           nameAndMode: moduleResolutionNameAndModeGetter,
           resolve: (moduleName, resolutionMode) => resolveModuleName(
@@ -158972,7 +158972,7 @@ ${lanes.join("\n")}
             containingFile,
             options,
             host,
-            cache,
+            cache2,
             redirectedReference,
             resolutionMode
           )
@@ -158985,7 +158985,7 @@ ${lanes.join("\n")}
         getName: getTypeReferenceResolutionName,
         getMode: (entry, file, compilerOptions) => getModeForFileReference(entry, file && getDefaultResolutionModeForFileWorker(file, compilerOptions))
       };
-      function createTypeReferenceResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+      function createTypeReferenceResolutionLoader(containingFile, redirectedReference, options, host, cache2) {
         return {
           nameAndMode: typeReferenceResolutionNameAndModeGetter,
           resolve: (typeRef, resoluionMode) => resolveTypeReferenceDirective(
@@ -158994,7 +158994,7 @@ ${lanes.join("\n")}
             options,
             host,
             redirectedReference,
-            cache,
+            cache2,
             resoluionMode
           )
         };
@@ -159002,15 +159002,15 @@ ${lanes.join("\n")}
       function loadWithModeAwareCache(entries, containingFile, redirectedReference, options, containingSourceFile, host, resolutionCache, createLoader) {
         if (entries.length === 0) return emptyArray;
         const resolutions = [];
-        const cache = /* @__PURE__ */ new Map();
+        const cache2 = /* @__PURE__ */ new Map();
         const loader = createLoader(containingFile, redirectedReference, options, host, resolutionCache);
         for (const entry of entries) {
           const name = loader.nameAndMode.getName(entry);
           const mode = loader.nameAndMode.getMode(entry, containingSourceFile, (redirectedReference == null ? void 0 : redirectedReference.commandLine.options) || options);
           const key = createModeAwareCacheKey(name, mode);
-          let result = cache.get(key);
+          let result = cache2.get(key);
           if (!result) {
-            cache.set(key, result = loader.resolve(name, mode));
+            cache2.set(key, result = loader.resolve(name, mode));
           }
           resolutions.push(result);
         }
@@ -165414,7 +165414,7 @@ ${lanes.join("\n")}
           const watcher = fileWatchesOfAffectingLocations.get(path14);
           if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path14);
           if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path14);
-          (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path22) => invalidateAffectingFileWatcher(path22, packageJsonMap));
+          (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path23) => invalidateAffectingFileWatcher(path23, packageJsonMap));
           packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path14));
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
@@ -165564,8 +165564,8 @@ ${lanes.join("\n")}
             /* Recursive */
           );
         }
-        function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
-          const resolutions = cache.get(filePath);
+        function removeResolutionsOfFileFromCache(cache2, filePath, getResolutionWithResolvedFileName) {
+          const resolutions = cache2.get(filePath);
           if (resolutions) {
             resolutions.forEach(
               (resolution) => stopWatchFailedLookupLocationOfResolution(
@@ -165574,7 +165574,7 @@ ${lanes.join("\n")}
                 getResolutionWithResolvedFileName
               )
             );
-            cache.delete(filePath);
+            cache2.delete(filePath);
           }
         }
         function removeResolutionsFromProjectReferenceRedirects(filePath) {
@@ -166623,12 +166623,12 @@ ${lanes.join("\n")}
             missingFilesMap = void 0;
           }
           if (parsedConfigs) {
-            clearMap(parsedConfigs, (config) => {
+            clearMap(parsedConfigs, (config2) => {
               var _a;
-              (_a = config.watcher) == null ? void 0 : _a.close();
-              config.watcher = void 0;
-              if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
-              config.watchedDirectories = void 0;
+              (_a = config2.watcher) == null ? void 0 : _a.close();
+              config2.watcher = void 0;
+              if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
+              config2.watchedDirectories = void 0;
             });
             parsedConfigs = void 0;
           }
@@ -166931,32 +166931,32 @@ ${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 });
           }
-          watchReferencedProject(configFileName2, configPath, config);
+          watchReferencedProject(configFileName2, configPath, config2);
           return parsedCommandLine;
         }
         function getParsedCommandLineFromConfigFileHost(configFileName2) {
@@ -166976,11 +166976,11 @@ ${lanes.join("\n")}
         function onReleaseParsedCommandLine(fileName) {
           var _a;
           const path14 = toPath3(fileName);
-          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path14);
-          if (!config) return;
+          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path14);
+          if (!config2) return;
           parsedConfigs.delete(path14);
-          if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
-          (_a = config.watcher) == null ? void 0 : _a.close();
+          if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
+          (_a = config2.watcher) == null ? void 0 : _a.close();
           clearSharedExtendedConfigFileWatcher(path14, sharedExtendedConfigFileWatchers);
         }
         function watchFilePath(path14, file, callback, pollingInterval, options, watchType) {
@@ -167076,8 +167076,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();
@@ -167096,8 +167096,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();
             },
@@ -167118,22 +167118,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();
                   }
                 },
@@ -167572,14 +167572,14 @@ ${lanes.join("\n")}
       }
       function disableCache(state) {
         if (!state.cache) return;
-        const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache, libraryResolutionCache } = state;
-        host.readFile = cache.originalReadFile;
-        host.fileExists = cache.originalFileExists;
-        host.directoryExists = cache.originalDirectoryExists;
-        host.createDirectory = cache.originalCreateDirectory;
-        host.writeFile = cache.originalWriteFile;
-        compilerHost.getSourceFile = cache.originalGetSourceFile;
-        state.readFileWithCache = cache.originalReadFileWithCache;
+        const { cache: cache2, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache, libraryResolutionCache } = state;
+        host.readFile = cache2.originalReadFile;
+        host.fileExists = cache2.originalFileExists;
+        host.directoryExists = cache2.originalDirectoryExists;
+        host.createDirectory = cache2.originalCreateDirectory;
+        host.writeFile = cache2.originalWriteFile;
+        compilerHost.getSourceFile = cache2.originalGetSourceFile;
+        state.readFileWithCache = cache2.originalReadFileWithCache;
         extendedConfigCache.clear();
         moduleResolutionCache == null ? void 0 : moduleResolutionCache.clear();
         typeReferenceDirectiveResolutionCache == null ? void 0 : typeReferenceDirectiveResolutionCache.clear();
@@ -167624,29 +167624,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 program3;
         let buildResult;
@@ -167655,7 +167655,7 @@ ${lanes.join("\n")}
           project,
           projectPath,
           buildOrder,
-          getCompilerOptions: () => config.options,
+          getCompilerOptions: () => config2.options,
           getCurrentDirectory: () => state.compilerHost.getCurrentDirectory(),
           getBuilderProgram: () => withProgramOrUndefined(identity),
           getProgram: () => withProgramOrUndefined(
@@ -167727,23 +167727,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;
-          (_a = state.moduleResolutionCache) == null ? void 0 : _a.update(config.options);
-          (_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config.options);
+          state.projectCompilerOptions = config2.options;
+          (_a = state.moduleResolutionCache) == null ? void 0 : _a.update(config2.options);
+          (_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config2.options);
           program3 = 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();
@@ -167818,7 +167818,7 @@ ${lanes.join("\n")}
             customTransformers || ((_b = (_a = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a, 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 = program3.hasChangedEmitSignature) == null ? void 0 : _c.call(program3)) ? 0 : 2;
@@ -167826,7 +167826,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);
@@ -167848,7 +167848,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;
               case 3:
@@ -167872,29 +167872,29 @@ ${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);
-            updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, canJsonReportNoInputFiles(config.raw));
-            watchInputFiles(state, project, projectPath, config);
-            watchPackageJsonFiles(state, project, projectPath, config);
+            config2.fileNames = getFileNamesFromConfigSpecs(config2.options.configFile.configFileSpecs, getDirectoryPath(project), config2.options, state.parseConfigFileHost);
+            updateErrorForNoInputFiles(config2.fileNames, project, config2.options.configFile.configFileSpecs, config2.errors, canJsonReportNoInputFiles(config2.raw));
+            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);
@@ -167902,20 +167902,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(
@@ -167929,7 +167929,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;
           }
@@ -167939,7 +167939,7 @@ ${lanes.join("\n")}
             project,
             projectPath,
             projectIndex,
-            config
+            config: config2
           };
         }
         return void 0;
@@ -168379,9 +168379,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);
@@ -169732,8 +169732,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*/
@@ -169755,7 +169755,7 @@ ${lanes.join("\n")}
           options,
           projectReferences,
           host,
-          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config)
+          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config2)
         };
         const program3 = createProgram(programOptions);
         const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
@@ -169773,8 +169773,8 @@ ${lanes.join("\n")}
         cb(program3);
         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,
@@ -169788,7 +169788,7 @@ ${lanes.join("\n")}
           system: sys2,
           rootNames: fileNames,
           options,
-          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config),
+          configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config2),
           projectReferences,
           reportDiagnostic,
           reportErrorSummary: createReportErrorSummary(sys2, options),
@@ -174178,7 +174178,7 @@ ${lanes.join("\n")}
         const symbols = /* @__PURE__ */ new Map();
         const packages = /* @__PURE__ */ new Map();
         let usableByFileName;
-        const cache = {
+        const cache2 = {
           isUsableByFile: (importingFile) => importingFile === usableByFileName,
           isEmpty: () => !exportInfo.size,
           clear: () => {
@@ -174188,7 +174188,7 @@ ${lanes.join("\n")}
           },
           add: (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, checker) => {
             if (importingFile !== usableByFileName) {
-              cache.clear();
+              cache2.clear();
               usableByFileName = importingFile;
             }
             let packageName;
@@ -174276,7 +174276,7 @@ ${lanes.join("\n")}
             // Changes elsewhere in the file can change the *type* of an export in a module augmentation,
             // but type info is gathered in getCompletionEntryDetails, which doesn't use the cache.
             !arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations) || !ambientModuleDeclarationsAreEqual(oldSourceFile, newSourceFile)) {
-              cache.clear();
+              cache2.clear();
               return true;
             }
             usableByFileName = newSourceFile.path;
@@ -174284,9 +174284,9 @@ ${lanes.join("\n")}
           }
         };
         if (Debug.isDebugging) {
-          Object.defineProperty(cache, "__cache", { value: exportInfo });
+          Object.defineProperty(cache2, "__cache", { value: exportInfo });
         }
-        return cache;
+        return cache2;
         function rehydrateCachedInfo(info) {
           if (info.symbol && info.moduleSymbol) return info;
           const { id, exportKind, targetFlags, isFromPackageJson, moduleFileName } = info;
@@ -174481,7 +174481,7 @@ ${lanes.join("\n")}
         var _a, _b, _c, _d, _e;
         const start = timestamp();
         (_a = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a.call(host);
-        const cache = ((_b = host.getCachedExportInfoMap) == null ? void 0 : _b.call(host)) || createCacheableExportInfoMap({
+        const cache2 = ((_b = host.getCachedExportInfoMap) == null ? void 0 : _b.call(host)) || createCacheableExportInfoMap({
           getCurrentProgram: () => program3,
           getPackageJsonAutoImportProvider: () => {
             var _a2;
@@ -174492,9 +174492,9 @@ ${lanes.join("\n")}
             return (_a2 = host.getGlobalTypingsCacheLocation) == null ? void 0 : _a2.call(host);
           }
         });
-        if (cache.isUsableByFile(importingFile.path)) {
+        if (cache2.isUsableByFile(importingFile.path)) {
           (_c = host.log) == null ? void 0 : _c.call(host, "getExportInfoMap: cache hit");
-          return cache;
+          return cache2;
         }
         (_d = host.log) == null ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
         let moduleCount = 0;
@@ -174511,7 +174511,7 @@ ${lanes.join("\n")}
               const checker = program22.getTypeChecker();
               const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
               if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
-                cache.add(
+                cache2.add(
                   importingFile.path,
                   defaultInfo.symbol,
                   defaultInfo.exportKind === 1 ? "default" : "export=",
@@ -174524,7 +174524,7 @@ ${lanes.join("\n")}
               }
               checker.forEachExportAndPropertyOfModule(moduleSymbol, (exported, key) => {
                 if (exported !== (defaultInfo == null ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && addToSeen(seenExports, key)) {
-                  cache.add(
+                  cache2.add(
                     importingFile.path,
                     exported,
                     key,
@@ -174539,11 +174539,11 @@ ${lanes.join("\n")}
             }
           );
         } catch (err) {
-          cache.clear();
+          cache2.clear();
           throw err;
         }
         (_e = host.log) == null ? void 0 : _e.call(host, `getExportInfoMap: done in ${timestamp() - start} ms`);
-        return cache;
+        return cache2;
       }
       function getDefaultLikeExportInfo(moduleSymbol, checker) {
         const exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol);
@@ -199562,8 +199562,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function completionEntryDataIsResolved(data) {
         return !!(data == null ? void 0 : data.moduleSpecifier);
       }
-      function continuePreviousIncompleteResponse(cache, file, location, program3, host, preferences, cancellationToken, position) {
-        const previousResponse = cache.get();
+      function continuePreviousIncompleteResponse(cache2, file, location, program3, host, preferences, cancellationToken, position) {
+        const previousResponse = cache2.get();
         if (!previousResponse) return void 0;
         const touchNode = getTouchingPropertyName(file, position);
         const lowerCaseTokenText = location.text.toLowerCase();
@@ -199750,12 +199750,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           ];
         }
         return patternWorker(path14, pattern, initializer, dotDotDotToken, { tabstop: 1 });
-        function patternWorker(path22, pattern2, initializer2, dotDotDotToken2, counter) {
+        function patternWorker(path23, pattern2, initializer2, dotDotDotToken2, counter) {
           if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
             const oldTabstop = counter.tabstop;
             const childCounter = { tabstop: oldTabstop };
             const rootParam = getJSDocParamAnnotation(
-              path22,
+              path23,
               initializer2,
               dotDotDotToken2,
               isJs,
@@ -199769,7 +199769,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             );
             let childTags = [];
             for (const element of pattern2.elements) {
-              const elementTags = elementWorker(path22, element, childCounter);
+              const elementTags = elementWorker(path23, element, childCounter);
               if (!elementTags) {
                 childTags = void 0;
                 break;
@@ -199784,7 +199784,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
           return [
             getJSDocParamAnnotation(
-              path22,
+              path23,
               initializer2,
               dotDotDotToken2,
               isJs,
@@ -199798,13 +199798,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             )
           ];
         }
-        function elementWorker(path22, element, counter) {
+        function elementWorker(path23, element, counter) {
           if (!element.propertyName && isIdentifier(element.name) || isIdentifier(element.name)) {
             const propertyName = element.propertyName ? tryGetTextOfPropertyName(element.propertyName) : element.name.text;
             if (!propertyName) {
               return void 0;
             }
-            const paramName = `${path22}.${propertyName}`;
+            const paramName = `${path23}.${propertyName}`;
             return [
               getJSDocParamAnnotation(
                 paramName,
@@ -199822,7 +199822,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             ];
           } else if (element.propertyName) {
             const propertyName = tryGetTextOfPropertyName(element.propertyName);
-            return propertyName && patternWorker(`${path22}.${propertyName}`, element.name, element.initializer, element.dotDotDotToken, counter);
+            return propertyName && patternWorker(`${path23}.${propertyName}`, element.name, element.initializer, element.dotDotDotToken, counter);
           }
           return void 0;
         }
@@ -223450,9 +223450,9 @@ ${options.prefix}` : "\n" : options.prefix
         // TODO: GH#18217
       };
       var noopConfigFileWatcher = { close: noop };
-      function getConfigFileNameFromCache(info, cache) {
-        if (!cache || isAncestorConfigFileInfo(info)) return void 0;
-        return cache.get(info.path);
+      function getConfigFileNameFromCache(info, cache2) {
+        if (!cache2 || isAncestorConfigFileInfo(info)) return void 0;
+        return cache2.get(info.path);
       }
       function isOpenScriptInfo(infoOrFileNameOrConfig) {
         return !!infoOrFileNameOrConfig.containingProjects;
@@ -224239,18 +224239,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
           );
@@ -224271,9 +224271,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}`);
@@ -224291,15 +224291,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 _a;
             if (!watchWildcardDirectories) return;
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
@@ -225060,22 +225060,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 */
@@ -225184,21 +225184,21 @@ ${options.prefix}` : "\n" : options.prefix
           project.markAsDirty();
           return project.updateGraph();
         }
-        reloadFileNamesOfParsedConfig(configFileName, config) {
-          if (config.updateLevel === void 0) return config.parsedCommandLine.fileNames;
+        reloadFileNamesOfParsedConfig(configFileName, config2) {
+          if (config2.updateLevel === void 0) return config2.parsedCommandLine.fileNames;
           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 };
+          config2.parsedCommandLine = { ...config2.parsedCommandLine, fileNames };
           return fileNames;
         }
         /** @internal */
@@ -226256,7 +226256,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 _a, _b;
             if (!((_a = configFileExistenceInfo.config) == null ? void 0 : _a.parsedCommandLine) || contains(
               configFileExistenceInfo.config.parsedCommandLine.fileNames,
@@ -226267,10 +226267,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
@@ -226939,8 +226939,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(
@@ -226954,12 +226954,12 @@ Dynamic files must always be opened with service's current directory or service
       }
       function createModuleSpecifierCache(host) {
         let containedNodeModulesWatchers;
-        let cache;
+        let cache2;
         let currentKey;
         const result = {
           get(fromFileName, toFileName2, preferences, options) {
-            if (!cache || currentKey !== key(fromFileName, preferences, options)) return void 0;
-            return cache.get(toFileName2);
+            if (!cache2 || currentKey !== key(fromFileName, preferences, options)) return void 0;
+            return cache2.get(toFileName2);
           },
           set(fromFileName, toFileName2, preferences, options, kind, modulePaths, moduleSpecifiers2) {
             ensureCache(fromFileName, preferences, options).set(toFileName2, createInfo(
@@ -226987,12 +226987,12 @@ Dynamic files must always be opened with service's current directory or service
             }
           },
           setModulePaths(fromFileName, toFileName2, preferences, options, modulePaths) {
-            const cache2 = ensureCache(fromFileName, preferences, options);
-            const info = cache2.get(toFileName2);
+            const cache22 = ensureCache(fromFileName, preferences, options);
+            const info = cache22.get(toFileName2);
             if (info) {
               info.modulePaths = modulePaths;
             } else {
-              cache2.set(toFileName2, createInfo(
+              cache22.set(toFileName2, createInfo(
                 /*kind*/
                 void 0,
                 modulePaths,
@@ -227006,13 +227006,13 @@ Dynamic files must always be opened with service's current directory or service
             }
           },
           setBlockedByPackageJsonDependencies(fromFileName, toFileName2, preferences, options, packageName, isBlockedByPackageJsonDependencies) {
-            const cache2 = ensureCache(fromFileName, preferences, options);
-            const info = cache2.get(toFileName2);
+            const cache22 = ensureCache(fromFileName, preferences, options);
+            const info = cache22.get(toFileName2);
             if (info) {
               info.isBlockedByPackageJsonDependencies = isBlockedByPackageJsonDependencies;
               info.packageName = packageName;
             } else {
-              cache2.set(toFileName2, createInfo(
+              cache22.set(toFileName2, createInfo(
                 /*kind*/
                 void 0,
                 /*modulePaths*/
@@ -227026,25 +227026,25 @@ Dynamic files must always be opened with service's current directory or service
           },
           clear() {
             containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.forEach(closeFileWatcher);
-            cache == null ? void 0 : cache.clear();
+            cache2 == null ? void 0 : cache2.clear();
             containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.clear();
             currentKey = void 0;
           },
           count() {
-            return cache ? cache.size : 0;
+            return cache2 ? cache2.size : 0;
           }
         };
         if (Debug.isDebugging) {
-          Object.defineProperty(result, "__cache", { get: () => cache });
+          Object.defineProperty(result, "__cache", { get: () => cache2 });
         }
         return result;
         function ensureCache(fromFileName, preferences, options) {
           const newKey = key(fromFileName, preferences, options);
-          if (cache && currentKey !== newKey) {
+          if (cache2 && currentKey !== newKey) {
             result.clear();
           }
           currentKey = newKey;
-          return cache || (cache = /* @__PURE__ */ new Map());
+          return cache2 || (cache2 = /* @__PURE__ */ new Map());
         }
         function key(fromFileName, preferences, options) {
           return `${fromFileName},${preferences.importModuleSpecifierEnding},${preferences.importModuleSpecifierPreference},${options.overrideImportMode}`;
@@ -231200,9 +231200,9 @@ ${e.message}`;
       _ScriptVersionCache.maxVersions = 8;
       var ScriptVersionCache = _ScriptVersionCache;
       var LineIndexSnapshot = class _LineIndexSnapshot {
-        constructor(version2, cache, index, changesSincePreviousVersion = emptyArray2) {
+        constructor(version2, cache2, index, changesSincePreviousVersion = emptyArray2) {
           this.version = version2;
-          this.cache = cache;
+          this.cache = cache2;
           this.index = index;
           this.changesSincePreviousVersion = changesSincePreviousVersion;
         }
@@ -237541,9 +237541,9 @@ ${nodeLocation}` : message;
       return ts__namespace.createLanguageServiceSourceFile(filePath, scriptSnapshot, optionsOrScriptTarget ?? ts__namespace.ScriptTarget.Latest, version, setParentNodes, scriptKind);
     }
     function createDocumentCache(files) {
-      const cache = new InternalDocumentCache();
-      cache._addFiles(files);
-      return cache;
+      const cache2 = new InternalDocumentCache();
+      cache2._addFiles(files);
+      return cache2;
     }
     var FileSystemDocumentCache = class {
       #documentCache;
@@ -292642,50 +292642,104 @@ function ora(options) {
 
 // src/index.ts
 var import_node_child_process = require("child_process");
+var import_node_path2 = __toESM(require("path"));
+var import_node_os3 = __toESM(require("os"));
+var import_fs_extra14 = __toESM(require_lib());
+var import_prompts2 = __toESM(require_prompts3());
+
+// src/global-config.ts
 var import_node_path = __toESM(require("path"));
 var import_node_os2 = __toESM(require("os"));
-var import_fs_extra13 = __toESM(require_lib());
-var import_prompts2 = __toESM(require_prompts3());
+var import_fs_extra = __toESM(require_lib());
+var CONFIG_PATH = import_node_path.default.join(import_node_os2.default.homedir(), ".xo", "config.json");
+var DEFAULTS = {
+  autoUpdate: true,
+  registryUrl: "https://registry.npmjs.org"
+};
+var CONFIG_META = {
+  autoUpdate: {
+    description: "Show update notifications after each command",
+    type: "boolean",
+    default: "true"
+  },
+  registryUrl: {
+    description: "npm registry URL used for update checks",
+    type: "string",
+    default: "https://registry.npmjs.org"
+  },
+  githubToken: {
+    description: "GitHub personal access token for private generator repos",
+    type: "string"
+  }
+};
+async function readGlobalConfig() {
+  if (!await import_fs_extra.default.pathExists(CONFIG_PATH)) return { ...DEFAULTS };
+  const stored = await import_fs_extra.default.readJson(CONFIG_PATH).catch(() => ({}));
+  return { ...DEFAULTS, ...stored };
+}
+async function getConfigValue(key) {
+  if (!(key in CONFIG_META)) throw new Error(unknownKeyMsg(key));
+  const config2 = await readGlobalConfig();
+  return config2[key];
+}
+async function setConfigValue(key, raw) {
+  if (!(key in CONFIG_META)) throw new Error(unknownKeyMsg(key));
+  const meta = CONFIG_META[key];
+  let value = raw;
+  if (meta.type === "boolean") {
+    if (raw === "true") value = true;
+    else if (raw === "false") value = false;
+    else throw new Error(`Invalid value for "${key}": expected true or false, got "${raw}"`);
+  }
+  const current = await readGlobalConfig();
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(CONFIG_PATH));
+  await import_fs_extra.default.writeJson(CONFIG_PATH, { ...current, [key]: value }, { spaces: 2 });
+}
+function unknownKeyMsg(key) {
+  return `Unknown config key: "${key}"
+Valid keys: ${Object.keys(CONFIG_META).join(", ")}`;
+}
 
 // ../core/dist/index.mjs
 var import_path = __toESM(require("path"), 1);
-var import_fs_extra = __toESM(require_lib(), 1);
+var import_fs_extra2 = __toESM(require_lib(), 1);
 var import_yaml = __toESM(require_dist2(), 1);
 var import_path2 = __toESM(require("path"), 1);
-var import_fs_extra2 = __toESM(require_lib(), 1);
+var import_fs_extra3 = __toESM(require_lib(), 1);
 var import_crypto = require("crypto");
 var import_path3 = __toESM(require("path"), 1);
 var import_os = __toESM(require("os"), 1);
-var import_fs_extra3 = __toESM(require_lib(), 1);
-var import_path4 = __toESM(require("path"), 1);
 var import_fs_extra4 = __toESM(require_lib(), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_fs_extra5 = __toESM(require_lib(), 1);
 var import_prompts = __toESM(require_prompts3(), 1);
 var import_handlebars = __toESM(require_lib3(), 1);
 var import_path5 = __toESM(require("path"), 1);
-var import_fs_extra5 = __toESM(require_lib(), 1);
-var import_child_process = require("child_process");
+var import_https = __toESM(require("https"), 1);
 var import_fs_extra6 = __toESM(require_lib(), 1);
+var import_child_process = require("child_process");
+var import_fs_extra7 = __toESM(require_lib(), 1);
 var import_path6 = __toESM(require("path"), 1);
 var import_path7 = __toESM(require("path"), 1);
 var import_os2 = __toESM(require("os"), 1);
-var import_fs_extra7 = __toESM(require_lib(), 1);
+var import_fs_extra8 = __toESM(require_lib(), 1);
 var import_yaml2 = __toESM(require_dist2(), 1);
 var import_path8 = __toESM(require("path"), 1);
 var import_os3 = __toESM(require("os"), 1);
-var import_fs_extra8 = __toESM(require_lib(), 1);
+var import_fs_extra9 = __toESM(require_lib(), 1);
 var import_yaml3 = __toESM(require_dist2(), 1);
 var import_path9 = __toESM(require("path"), 1);
-var import_fs_extra9 = __toESM(require_lib(), 1);
+var import_fs_extra10 = __toESM(require_lib(), 1);
 var import_ts_morph = __toESM(require_ts_morph(), 1);
 var import_path10 = __toESM(require("path"), 1);
-var import_fs_extra10 = __toESM(require_lib(), 1);
+var import_fs_extra11 = __toESM(require_lib(), 1);
 var import_path11 = __toESM(require("path"), 1);
 var import_os4 = __toESM(require("os"), 1);
-var import_fs_extra11 = __toESM(require_lib(), 1);
+var import_fs_extra12 = __toESM(require_lib(), 1);
 var import_yaml4 = __toESM(require_dist2(), 1);
 var import_path12 = __toESM(require("path"), 1);
 var import_os5 = __toESM(require("os"), 1);
-var import_fs_extra12 = __toESM(require_lib(), 1);
+var import_fs_extra13 = __toESM(require_lib(), 1);
 var import_yaml5 = __toESM(require_dist2(), 1);
 function interpolate(template, ctx) {
   return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
@@ -292711,7 +292765,7 @@ var DEFAULT_CONFIG_FILE = "xo.config.yaml";
 async function findConfigFile(cwd) {
   for (const filename of CONFIG_FILES) {
     const filePath = import_path.default.join(cwd, filename);
-    if (await import_fs_extra.default.pathExists(filePath)) {
+    if (await import_fs_extra2.default.pathExists(filePath)) {
       return { filePath, isYaml: !filename.endsWith(".json") };
     }
   }
@@ -292721,18 +292775,18 @@ async function readConfig(cwd) {
   const found = await findConfigFile(cwd);
   if (!found) return {};
   try {
-    const content = await import_fs_extra.default.readFile(found.filePath, "utf8");
+    const content = await import_fs_extra2.default.readFile(found.filePath, "utf8");
     return found.isYaml ? (0, import_yaml.parse)(content) : JSON.parse(content);
   } catch {
     return {};
   }
 }
-async function writeConfig(cwd, config) {
+async function writeConfig(cwd, config2) {
   const found = await findConfigFile(cwd);
   const filePath = found?.filePath ?? import_path.default.join(cwd, DEFAULT_CONFIG_FILE);
   const isYaml = !filePath.endsWith(".json");
-  const content = isYaml ? (0, import_yaml.stringify)(config) : JSON.stringify(config, null, 2);
-  await import_fs_extra.default.writeFile(filePath, content, "utf8");
+  const content = isYaml ? (0, import_yaml.stringify)(config2) : JSON.stringify(config2, null, 2);
+  await import_fs_extra2.default.writeFile(filePath, content, "utf8");
 }
 async function mergeConfig(cwd, patch) {
   const existing = await readConfig(cwd);
@@ -292745,13 +292799,13 @@ async function getStatePath(cwd) {
 }
 async function readState(cwd) {
   const statePath = await getStatePath(cwd);
-  if (!await import_fs_extra2.default.pathExists(statePath)) return { operations: [] };
-  return import_fs_extra2.default.readJson(statePath).catch(() => ({ operations: [] }));
+  if (!await import_fs_extra3.default.pathExists(statePath)) return { operations: [] };
+  return import_fs_extra3.default.readJson(statePath).catch(() => ({ operations: [] }));
 }
 async function writeState(cwd, state) {
   const statePath = await getStatePath(cwd);
-  await import_fs_extra2.default.ensureDir(import_path2.default.dirname(statePath));
-  await import_fs_extra2.default.writeJson(statePath, state, { spaces: 2 });
+  await import_fs_extra3.default.ensureDir(import_path2.default.dirname(statePath));
+  await import_fs_extra3.default.writeJson(statePath, state, { spaces: 2 });
 }
 async function recordOperation(cwd, generator, type, files) {
   const state = await readState(cwd);
@@ -292771,11 +292825,11 @@ async function undoLastOperation(cwd) {
   for (const snap of [...op.files].reverse()) {
     const absPath = import_path2.default.join(cwd, snap.filePath);
     if (snap.action === "created") {
-      await import_fs_extra2.default.remove(absPath);
+      await import_fs_extra3.default.remove(absPath);
     } else if (snap.action === "modified" && snap.before !== void 0) {
-      await import_fs_extra2.default.outputFile(absPath, snap.before, "utf8");
+      await import_fs_extra3.default.outputFile(absPath, snap.before, "utf8");
     } else if (snap.action === "deleted" && snap.before !== void 0) {
-      await import_fs_extra2.default.outputFile(absPath, snap.before, "utf8");
+      await import_fs_extra3.default.outputFile(absPath, snap.before, "utf8");
     }
   }
   await writeState(cwd, state);
@@ -292787,17 +292841,17 @@ async function listOperations(cwd) {
 }
 async function snapshotFile(cwd, filePath) {
   const absPath = import_path2.default.join(cwd, filePath);
-  if (!await import_fs_extra2.default.pathExists(absPath)) return void 0;
-  return import_fs_extra2.default.readFile(absPath, "utf8");
+  if (!await import_fs_extra3.default.pathExists(absPath)) return void 0;
+  return import_fs_extra3.default.readFile(absPath, "utf8");
 }
 var REGISTRY_PATH = import_path3.default.join(import_os.default.homedir(), ".xo", "registry.json");
 async function readRegistry() {
-  if (!await import_fs_extra3.default.pathExists(REGISTRY_PATH)) return {};
-  return import_fs_extra3.default.readJson(REGISTRY_PATH).catch(() => ({}));
+  if (!await import_fs_extra4.default.pathExists(REGISTRY_PATH)) return {};
+  return import_fs_extra4.default.readJson(REGISTRY_PATH).catch(() => ({}));
 }
 async function writeRegistry(registry2) {
-  await import_fs_extra3.default.ensureDir(import_path3.default.dirname(REGISTRY_PATH));
-  await import_fs_extra3.default.writeJson(REGISTRY_PATH, registry2, { spaces: 2 });
+  await import_fs_extra4.default.ensureDir(import_path3.default.dirname(REGISTRY_PATH));
+  await import_fs_extra4.default.writeJson(REGISTRY_PATH, registry2, { spaces: 2 });
 }
 async function addToRegistry(name, url, path132) {
   const registry2 = await readRegistry();
@@ -292835,13 +292889,13 @@ function validateConflicts(conflicts, appliedWorkflows) {
 }
 async function checkRule(rule, cwd) {
   if (rule.file !== void 0) {
-    const exists = await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, rule.file));
+    const exists = await import_fs_extra5.default.pathExists(import_path4.default.join(cwd, rule.file));
     return rule.exists !== void 0 ? exists === rule.exists : exists;
   }
   if (rule.pkg !== void 0) {
     const pkgPath = import_path4.default.join(cwd, "package.json");
-    if (!await import_fs_extra4.default.pathExists(pkgPath)) return rule.exists === false;
-    const json = await import_fs_extra4.default.readJson(pkgPath).catch(() => ({}));
+    if (!await import_fs_extra5.default.pathExists(pkgPath)) return rule.exists === false;
+    const json = await import_fs_extra5.default.readJson(pkgPath).catch(() => ({}));
     const allDeps = { ...json.dependencies, ...json.devDependencies };
     const version = allDeps[rule.pkg];
     if (rule.exists !== void 0) return Boolean(version) === rule.exists;
@@ -292856,15 +292910,24 @@ async function validateDetects(detects, cwd) {
   const results = await Promise.all(detects.map((r) => checkRule(r, cwd)));
   return results.every(Boolean);
 }
+function normalizeChoice(c) {
+  if (typeof c === "string") return { title: c, value: c };
+  return { title: c.label ?? c.value, value: c.value };
+}
 async function collectInputs(inputs, prefilled = {}) {
-  const result = { ...prefilled };
-  const toPrompt = Object.entries(inputs).filter(([name]) => result[name] === void 0);
-  if (toPrompt.length === 0) return result;
+  const withDefaults = { ...prefilled };
+  for (const [name, input] of Object.entries(inputs)) {
+    if (withDefaults[name] === void 0 && input.default !== void 0) {
+      withDefaults[name] = input.default;
+    }
+  }
+  const toPrompt = Object.entries(inputs).filter(
+    ([name]) => withDefaults[name] === void 0
+  );
+  if (toPrompt.length === 0) return withDefaults;
   const questions = toPrompt.map(([name, input]) => {
-    const base = {
-      name,
-      message: input.prompt
-    };
+    const message = input.prompt ?? input.description ?? name;
+    const base = { name, message };
     if (input.type === "confirm") {
       return {
         ...base,
@@ -292872,9 +292935,9 @@ async function collectInputs(inputs, prefilled = {}) {
         initial: input.default === true || input.default === "true"
       };
     }
-    if (input.type === "select" || input.type === "multiselect") {
-      const choices = (input.choices ?? []).map((c) => ({ title: c, value: c }));
-      const initialIndex = input.default ? (input.choices ?? []).indexOf(String(input.default)) : 0;
+    if (input.type === "select" || input.type === "multiselect" || input.type === "list") {
+      const choices = (input.choices ?? []).map(normalizeChoice);
+      const initialIndex = input.default ? (input.choices ?? []).map(normalizeChoice).findIndex((c) => c.value === String(input.default)) : 0;
       if (input.type === "multiselect") {
         return { ...base, type: "multiselect", choices };
       }
@@ -292885,16 +292948,6 @@ async function collectInputs(inputs, prefilled = {}) {
         initial: Math.max(0, initialIndex)
       };
     }
-    if (input.type === "list") {
-      const choices = (input.choices ?? []).map((c) => ({ title: c, value: c }));
-      const initialIndex = input.default ? (input.choices ?? []).indexOf(String(input.default)) : 0;
-      return {
-        ...base,
-        type: "select",
-        choices,
-        initial: Math.max(0, initialIndex)
-      };
-    }
     return {
       ...base,
       type: "text",
@@ -292907,7 +292960,7 @@ async function collectInputs(inputs, prefilled = {}) {
       process.exit(0);
     }
   });
-  return { ...result, ...answers };
+  return { ...withDefaults, ...answers };
 }
 import_handlebars.default.registerHelper("eq", (a, b) => a === b);
 import_handlebars.default.registerHelper("ne", (a, b) => a !== b);
@@ -292940,39 +292993,61 @@ function renderTemplate(source, ctx) {
 function renderFilename(name, ctx) {
   return renderTemplate(name, ctx);
 }
+async function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    import_https.default.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return fetchText(res.headers.location).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+      }
+      let data = "";
+      res.on("data", (c) => data += c);
+      res.on("end", () => resolve(data));
+    }).on("error", reject);
+  });
+}
+async function readSource(generatorDir, source) {
+  const rawbasePath = import_path5.default.join(generatorDir, ".rawbase");
+  if (await import_fs_extra6.default.pathExists(rawbasePath)) {
+    const base = (await import_fs_extra6.default.readFile(rawbasePath, "utf8")).trim();
+    return fetchText(`${base}/${source}`);
+  }
+  return import_fs_extra6.default.readFile(import_path5.default.join(generatorDir, source), "utf8");
+}
 function resolveTarget(target, ctx) {
   return renderFilename(interpolate(target, ctx), ctx);
 }
 async function copyFile(generatorDir, cwd, action, ctx) {
-  const src = import_path5.default.join(generatorDir, action.source);
+  const content = await readSource(generatorDir, action.source);
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
-  await import_fs_extra5.default.ensureDir(import_path5.default.dirname(dest));
-  await import_fs_extra5.default.copy(src, dest, { overwrite: true });
+  await import_fs_extra6.default.ensureDir(import_path5.default.dirname(dest));
+  await import_fs_extra6.default.writeFile(dest, content, "utf8");
 }
 async function templateFile(generatorDir, cwd, action, ctx) {
-  const src = import_path5.default.join(generatorDir, action.source);
-  const raw = await import_fs_extra5.default.readFile(src, "utf8");
+  const raw = await readSource(generatorDir, action.source);
   const rendered = renderTemplate(raw, ctx);
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
-  await import_fs_extra5.default.ensureDir(import_path5.default.dirname(dest));
-  await import_fs_extra5.default.writeFile(dest, rendered, "utf8");
+  await import_fs_extra6.default.ensureDir(import_path5.default.dirname(dest));
+  await import_fs_extra6.default.writeFile(dest, rendered, "utf8");
 }
 async function appendToFile(cwd, action, ctx) {
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
   const content = renderTemplate(interpolate(action.content, ctx), ctx);
   const prefix = action.newline !== false ? "\n" : "";
-  await import_fs_extra5.default.ensureDir(import_path5.default.dirname(dest));
-  if (await import_fs_extra5.default.pathExists(dest)) {
-    await import_fs_extra5.default.appendFile(dest, prefix + content, "utf8");
+  await import_fs_extra6.default.ensureDir(import_path5.default.dirname(dest));
+  if (await import_fs_extra6.default.pathExists(dest)) {
+    await import_fs_extra6.default.appendFile(dest, prefix + content, "utf8");
   } else {
-    await import_fs_extra5.default.writeFile(dest, content, "utf8");
+    await import_fs_extra6.default.writeFile(dest, content, "utf8");
   }
 }
 async function injectIntoFile(cwd, action, ctx) {
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
-  if (!await import_fs_extra5.default.pathExists(dest)) throw new Error(`inject: target file not found: ${dest}`);
+  if (!await import_fs_extra6.default.pathExists(dest)) throw new Error(`inject: target file not found: ${dest}`);
   const content = renderTemplate(interpolate(action.content, ctx), ctx);
-  let text = await import_fs_extra5.default.readFile(dest, "utf8");
+  let text = await import_fs_extra6.default.readFile(dest, "utf8");
   if (action.after) {
     const marker = interpolate(action.after, ctx);
     const idx = text.indexOf(marker);
@@ -292987,41 +293062,41 @@ async function injectIntoFile(cwd, action, ctx) {
   } else {
     text = text + "\n" + content;
   }
-  await import_fs_extra5.default.writeFile(dest, text, "utf8");
+  await import_fs_extra6.default.writeFile(dest, text, "utf8");
 }
 async function replaceInFile(cwd, action, ctx) {
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
-  if (!await import_fs_extra5.default.pathExists(dest)) throw new Error(`replace: target file not found: ${dest}`);
-  const text = await import_fs_extra5.default.readFile(dest, "utf8");
+  if (!await import_fs_extra6.default.pathExists(dest)) throw new Error(`replace: target file not found: ${dest}`);
+  const text = await import_fs_extra6.default.readFile(dest, "utf8");
   const search = interpolate(action.search, ctx);
   const replacement = renderTemplate(interpolate(action.replace, ctx), ctx);
   const regex2 = new RegExp(search, action.flags ?? "g");
-  await import_fs_extra5.default.writeFile(dest, text.replace(regex2, replacement), "utf8");
+  await import_fs_extra6.default.writeFile(dest, text.replace(regex2, replacement), "utf8");
 }
 async function mergeJsonFile(cwd, action, ctx) {
   const dest = import_path5.default.join(cwd, resolveTarget(action.target, ctx));
-  await import_fs_extra5.default.ensureDir(import_path5.default.dirname(dest));
-  const existing = await import_fs_extra5.default.pathExists(dest) ? await import_fs_extra5.default.readJson(dest).catch(() => ({})) : {};
+  await import_fs_extra6.default.ensureDir(import_path5.default.dirname(dest));
+  const existing = await import_fs_extra6.default.pathExists(dest) ? await import_fs_extra6.default.readJson(dest).catch(() => ({})) : {};
   const merged = action.deep ? deepMerge(existing, action.merge) : { ...existing, ...action.merge };
-  await import_fs_extra5.default.writeJson(dest, merged, { spaces: 2 });
+  await import_fs_extra6.default.writeJson(dest, merged, { spaces: 2 });
 }
 async function setEnvVar(cwd, action, ctx) {
   const dest = import_path5.default.join(cwd, action.target ?? ".env");
-  await import_fs_extra5.default.ensureDir(import_path5.default.dirname(dest));
+  await import_fs_extra6.default.ensureDir(import_path5.default.dirname(dest));
   const key = interpolate(action.key, ctx);
   const value = interpolate(action.value, ctx);
   const line = `${key}=${value}`;
-  if (await import_fs_extra5.default.pathExists(dest)) {
-    let text = await import_fs_extra5.default.readFile(dest, "utf8");
+  if (await import_fs_extra6.default.pathExists(dest)) {
+    let text = await import_fs_extra6.default.readFile(dest, "utf8");
     const keyRegex = new RegExp(`^${key}=.*$`, "m");
     if (keyRegex.test(text)) {
       text = text.replace(keyRegex, line);
     } else {
       text = text.endsWith("\n") ? text + line + "\n" : text + "\n" + line + "\n";
     }
-    await import_fs_extra5.default.writeFile(dest, text, "utf8");
+    await import_fs_extra6.default.writeFile(dest, text, "utf8");
   } else {
-    await import_fs_extra5.default.writeFile(dest, line + "\n", "utf8");
+    await import_fs_extra6.default.writeFile(dest, line + "\n", "utf8");
   }
 }
 function deepMerge(target, source) {
@@ -293049,7 +293124,7 @@ function runCommand(cwd, action, ctx, dryRun = false) {
 }
 async function runScript(generatorDir, cwd, action, ctx, dryRun = false) {
   const scriptPath = import_path6.default.join(generatorDir, interpolate(action.script, ctx));
-  if (!await import_fs_extra6.default.pathExists(scriptPath)) {
+  if (!await import_fs_extra7.default.pathExists(scriptPath)) {
     throw new Error(`Script not found: ${scriptPath}`);
   }
   const execCwd = action.cwd ? import_path6.default.join(cwd, interpolate(action.cwd, ctx)) : cwd;
@@ -293101,7 +293176,7 @@ function authHeaders() {
   const token = process.env["XO_GITHUB_TOKEN"];
   return token ? { Authorization: `token ${token}` } : {};
 }
-async function fetchText(url) {
+async function fetchText2(url) {
   try {
     const res = await fetch(url, { headers: authHeaders() });
     if (!res.ok) return null;
@@ -293129,13 +293204,13 @@ async function resolveGitHubWorkflow(ref, trigger) {
   }
   candidates.push(`${base}/workflow.yaml`, `${base}/workflow.yml`);
   for (const url of candidates) {
-    const content = await fetchText(url);
+    const content = await fetchText2(url);
     if (!content) continue;
     const workflow = parseWorkflow(content);
-    await import_fs_extra8.default.ensureDir(dir);
-    await import_fs_extra8.default.writeFile(import_path8.default.join(dir, "workflow.yaml"), (0, import_yaml3.stringify)(workflow));
-    await import_fs_extra8.default.writeFile(import_path8.default.join(dir, ".rawbase"), base);
-    await import_fs_extra8.default.writeFile(import_path8.default.join(dir, ".ref"), JSON.stringify(ref));
+    await import_fs_extra9.default.ensureDir(dir);
+    await import_fs_extra9.default.writeFile(import_path8.default.join(dir, "workflow.yaml"), (0, import_yaml3.stringify)(workflow));
+    await import_fs_extra9.default.writeFile(import_path8.default.join(dir, ".rawbase"), base);
+    await import_fs_extra9.default.writeFile(import_path8.default.join(dir, ".ref"), JSON.stringify(ref));
     return { workflow, dir, ref };
   }
   return null;
@@ -293144,14 +293219,14 @@ async function loadFromCacheDir(dir, trigger) {
   if (trigger) {
     for (const ext of ["yaml", "yml"]) {
       const file2 = import_path8.default.join(dir, "workflows", `${trigger}.${ext}`);
-      if (await import_fs_extra8.default.pathExists(file2)) {
-        return parseWorkflow(await import_fs_extra8.default.readFile(file2, "utf8"));
+      if (await import_fs_extra9.default.pathExists(file2)) {
+        return parseWorkflow(await import_fs_extra9.default.readFile(file2, "utf8"));
       }
     }
   }
   const file = import_path8.default.join(dir, "workflow.yaml");
-  if (await import_fs_extra8.default.pathExists(file)) {
-    return parseWorkflow(await import_fs_extra8.default.readFile(file, "utf8"));
+  if (await import_fs_extra9.default.pathExists(file)) {
+    return parseWorkflow(await import_fs_extra9.default.readFile(file, "utf8"));
   }
   return null;
 }
@@ -293177,7 +293252,7 @@ async function loadLocalAction(uses, generatorDir) {
   const fullPath = import_path7.default.resolve(generatorDir, uses);
   const ext = import_path7.default.extname(uses);
   if ([".js", ".mjs", ".cjs"].includes(ext)) {
-    if (!await import_fs_extra7.default.pathExists(fullPath)) {
+    if (!await import_fs_extra8.default.pathExists(fullPath)) {
       throw new Error(`Script action not found: ${fullPath}`);
     }
     return { def: {}, dir: import_path7.default.dirname(fullPath), type: "node", mainPath: fullPath };
@@ -293186,16 +293261,16 @@ async function loadLocalAction(uses, generatorDir) {
   if (![".yaml", ".yml"].includes(ext)) {
     for (const name of ["action.yaml", "action.yml"]) {
       const candidate = import_path7.default.join(fullPath, name);
-      if (await import_fs_extra7.default.pathExists(candidate)) {
+      if (await import_fs_extra8.default.pathExists(candidate)) {
         yamlPath = candidate;
         break;
       }
     }
   }
-  if (!await import_fs_extra7.default.pathExists(yamlPath)) {
+  if (!await import_fs_extra8.default.pathExists(yamlPath)) {
     throw new Error(`Action not found: ${fullPath}`);
   }
-  const def = (0, import_yaml2.parse)(await import_fs_extra7.default.readFile(yamlPath, "utf8"));
+  const def = (0, import_yaml2.parse)(await import_fs_extra8.default.readFile(yamlPath, "utf8"));
   const dir = import_path7.default.dirname(yamlPath);
   if (def.runs?.using === "node" && def.runs.main) {
     return { def, dir, type: "node", mainPath: import_path7.default.resolve(dir, def.runs.main) };
@@ -293220,14 +293295,14 @@ async function loadGitHubAction(uses) {
       const res = await fetch(`${base}/${filename}`, { headers });
       if (!res.ok) continue;
       const def = (0, import_yaml2.parse)(await res.text());
-      await import_fs_extra7.default.ensureDir(cacheDir2);
-      await import_fs_extra7.default.writeFile(import_path7.default.join(cacheDir2, "action.yaml"), (0, import_yaml2.stringify)(def));
+      await import_fs_extra8.default.ensureDir(cacheDir2);
+      await import_fs_extra8.default.writeFile(import_path7.default.join(cacheDir2, "action.yaml"), (0, import_yaml2.stringify)(def));
       if (def.runs?.using === "node" && def.runs.main) {
         const mainRes = await fetch(`${base}/${def.runs.main}`, { headers });
         if (!mainRes.ok) throw new Error(`Failed to fetch action main: ${base}/${def.runs.main}`);
         const mainPath = import_path7.default.join(cacheDir2, def.runs.main);
-        await import_fs_extra7.default.ensureDir(import_path7.default.dirname(mainPath));
-        await import_fs_extra7.default.writeFile(mainPath, await mainRes.text());
+        await import_fs_extra8.default.ensureDir(import_path7.default.dirname(mainPath));
+        await import_fs_extra8.default.writeFile(mainPath, await mainRes.text());
         return { def, dir: cacheDir2, type: "node", mainPath };
       }
       return { def, dir: cacheDir2, type: "composite" };
@@ -293244,8 +293319,8 @@ Tried: ${base}/action.yaml and action.yml
 }
 async function loadCachedAction(dir) {
   const yamlPath = import_path7.default.join(dir, "action.yaml");
-  if (!await import_fs_extra7.default.pathExists(yamlPath)) return null;
-  const def = (0, import_yaml2.parse)(await import_fs_extra7.default.readFile(yamlPath, "utf8"));
+  if (!await import_fs_extra8.default.pathExists(yamlPath)) return null;
+  const def = (0, import_yaml2.parse)(await import_fs_extra8.default.readFile(yamlPath, "utf8"));
   if (def.runs?.using === "node" && def.runs.main) {
     return { def, dir, type: "node", mainPath: import_path7.default.resolve(dir, def.runs.main) };
   }
@@ -293322,31 +293397,31 @@ async function runScriptAction(loaded, withArgs, parentContext) {
   }) ?? {};
 }
 async function detectPackageManager(cwd) {
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "bun.lockb")) || await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "bun.lock")))
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "bun.lockb")) || await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "bun.lock")))
     return "bun";
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "yarn.lock"))) return "yarn";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function detectLanguage(cwd) {
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "tsconfig.json"))) return "typescript";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "tsconfig.json"))) return "typescript";
   const pkgPath = import_path10.default.join(cwd, "package.json");
-  if (await import_fs_extra10.default.pathExists(pkgPath)) {
-    const pkg = await import_fs_extra10.default.readJson(pkgPath).catch(() => ({}));
+  if (await import_fs_extra11.default.pathExists(pkgPath)) {
+    const pkg = await import_fs_extra11.default.readJson(pkgPath).catch(() => ({}));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (allDeps["typescript"] || allDeps["ts-node"]) return "typescript";
   }
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "pubspec.yaml"))) return "dart";
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "go.mod"))) return "go";
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "Cargo.toml"))) return "rust";
-  if (await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "requirements.txt")) || await import_fs_extra10.default.pathExists(import_path10.default.join(cwd, "pyproject.toml")))
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "pubspec.yaml"))) return "dart";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "go.mod"))) return "go";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "Cargo.toml"))) return "rust";
+  if (await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "requirements.txt")) || await import_fs_extra11.default.pathExists(import_path10.default.join(cwd, "pyproject.toml")))
     return "python";
   return "javascript";
 }
 async function isPkgInstalled(cwd, pkg) {
   const pkgPath = import_path10.default.join(cwd, "package.json");
-  if (!await import_fs_extra10.default.pathExists(pkgPath)) return { installed: false };
-  const json = await import_fs_extra10.default.readJson(pkgPath).catch(() => ({}));
+  if (!await import_fs_extra11.default.pathExists(pkgPath)) return { installed: false };
+  const json = await import_fs_extra11.default.readJson(pkgPath).catch(() => ({}));
   const allDeps = {
     ...json.dependencies,
     ...json.devDependencies,
@@ -293357,8 +293432,8 @@ async function isPkgInstalled(cwd, pkg) {
 }
 async function readJsonAtPath(cwd, file, jsonPath) {
   const absPath = import_path10.default.join(cwd, file);
-  if (!await import_fs_extra10.default.pathExists(absPath)) return void 0;
-  const json = await import_fs_extra10.default.readJson(absPath).catch(() => void 0);
+  if (!await import_fs_extra11.default.pathExists(absPath)) return void 0;
+  const json = await import_fs_extra11.default.readJson(absPath).catch(() => void 0);
   if (json === void 0) return void 0;
   const parts = jsonPath.split(".");
   let cur = json;
@@ -293391,7 +293466,7 @@ function dotToNested(dotPath, value) {
 }
 async function astAddImport(cwd, args, ctx) {
   const targetPath = import_path9.default.join(cwd, interpolate(args.file, ctx));
-  if (!await import_fs_extra9.default.pathExists(targetPath)) {
+  if (!await import_fs_extra10.default.pathExists(targetPath)) {
     throw new Error(`xo/ast-import: file not found: ${targetPath}`);
   }
   const project = new import_ts_morph.Project({ useInMemoryFileSystem: false });
@@ -293427,7 +293502,7 @@ async function runBuiltinAction(actionName, args, ctx, context) {
   }
   if (actionName === "xo/file-exists") {
     const filePath = str(w.path);
-    const exists = await import_fs_extra9.default.pathExists(import_path9.default.join(cwd, filePath));
+    const exists = await import_fs_extra10.default.pathExists(import_path9.default.join(cwd, filePath));
     if (!dryRun) console.log(`    \u2714 xo/file-exists(${filePath}) \u2192 ${exists}`);
     return { exists };
   }
@@ -293609,18 +293684,18 @@ async function runJobs(jobs, context, onJobStart) {
 }
 var LINKED_PATH = import_path11.default.join(import_os4.default.homedir(), ".xo", "linked.json");
 async function read() {
-  if (!await import_fs_extra11.default.pathExists(LINKED_PATH)) return {};
-  return import_fs_extra11.default.readJson(LINKED_PATH).catch(() => ({}));
+  if (!await import_fs_extra12.default.pathExists(LINKED_PATH)) return {};
+  return import_fs_extra12.default.readJson(LINKED_PATH).catch(() => ({}));
 }
 async function write(data) {
-  await import_fs_extra11.default.ensureDir(import_path11.default.dirname(LINKED_PATH));
-  await import_fs_extra11.default.writeJson(LINKED_PATH, data, { spaces: 2 });
+  await import_fs_extra12.default.ensureDir(import_path11.default.dirname(LINKED_PATH));
+  await import_fs_extra12.default.writeJson(LINKED_PATH, data, { spaces: 2 });
 }
 async function readWorkflowName(dir) {
   for (const filename of ["workflow.yaml", "workflow.yml"]) {
     const file = import_path11.default.join(dir, filename);
-    if (await import_fs_extra11.default.pathExists(file)) {
-      const content = await import_fs_extra11.default.readFile(file, "utf8");
+    if (await import_fs_extra12.default.pathExists(file)) {
+      const content = await import_fs_extra12.default.readFile(file, "utf8");
       const wf = (0, import_yaml4.parse)(content);
       return wf.name ?? null;
     }
@@ -293628,8 +293703,8 @@ async function readWorkflowName(dir) {
   for (const trigger of ["add", "create", "run"]) {
     for (const ext of ["yaml", "yml"]) {
       const file = import_path11.default.join(dir, "workflows", `${trigger}.${ext}`);
-      if (await import_fs_extra11.default.pathExists(file)) {
-        const content = await import_fs_extra11.default.readFile(file, "utf8");
+      if (await import_fs_extra12.default.pathExists(file)) {
+        const content = await import_fs_extra12.default.readFile(file, "utf8");
         const wf = (0, import_yaml4.parse)(content);
         return wf.name ?? null;
       }
@@ -293678,15 +293753,15 @@ async function loadFromDir(dir, trigger) {
   if (trigger) {
     for (const ext of ["yaml", "yml"]) {
       const file = import_path12.default.join(dir, "workflows", `${trigger}.${ext}`);
-      if (await import_fs_extra12.default.pathExists(file)) {
-        return parseWorkflow2(await import_fs_extra12.default.readFile(file, "utf8"));
+      if (await import_fs_extra13.default.pathExists(file)) {
+        return parseWorkflow2(await import_fs_extra13.default.readFile(file, "utf8"));
       }
     }
   }
   for (const filename of WORKFLOW_FILES) {
     const file = import_path12.default.join(dir, filename);
-    if (await import_fs_extra12.default.pathExists(file)) {
-      return parseWorkflow2(await import_fs_extra12.default.readFile(file, "utf8"));
+    if (await import_fs_extra13.default.pathExists(file)) {
+      return parseWorkflow2(await import_fs_extra13.default.readFile(file, "utf8"));
     }
   }
   return null;
@@ -293712,9 +293787,9 @@ async function fetchFromRegistryEntry(url, subpath, name, trigger) {
       const content = await res.text();
       const workflow = parseWorkflow2(content);
       const cacheDir2 = import_path12.default.join(CACHE_DIR2, name.replace(/\//g, import_path12.default.sep));
-      await import_fs_extra12.default.ensureDir(cacheDir2);
-      await import_fs_extra12.default.writeFile(import_path12.default.join(cacheDir2, "workflow.yaml"), (0, import_yaml5.stringify)(workflow));
-      await import_fs_extra12.default.writeFile(import_path12.default.join(cacheDir2, ".rawbase"), rawBase2);
+      await import_fs_extra13.default.ensureDir(cacheDir2);
+      await import_fs_extra13.default.writeFile(import_path12.default.join(cacheDir2, "workflow.yaml"), (0, import_yaml5.stringify)(workflow));
+      await import_fs_extra13.default.writeFile(import_path12.default.join(cacheDir2, ".rawbase"), rawBase2);
       return { workflow, dir: cacheDir2 };
     } catch {
       continue;
@@ -293793,7 +293868,7 @@ async function runWorkflow(name, cwd, opts = {}) {
   const { dryRun = false, local = false } = opts;
   const trigger = opts.trigger ?? "add";
   const { workflow, dir: generatorDir } = await loadWorkflow(name, cwd, trigger, local);
-  const config = await readConfig(cwd);
+  const config2 = await readConfig(cwd);
   if (workflow.detects?.length) {
     const ok = await validateDetects(workflow.detects, cwd);
     if (!ok) {
@@ -293815,7 +293890,7 @@ async function runWorkflow(name, cwd, opts = {}) {
   const inputs = workflow.inputs && !dryRun ? await collectInputs(workflow.inputs, opts.inputs ?? {}) : { ...opts.inputs ?? {} };
   const context = {
     inputs,
-    config,
+    config: config2,
     steps: {},
     // populated as steps with `id:` run
     env: process.env,
@@ -293825,7 +293900,7 @@ async function runWorkflow(name, cwd, opts = {}) {
   };
   const filesChanged = [];
   if (!dryRun) {
-    const flatCtx = { inputs, config, steps: {}, env: process.env };
+    const flatCtx = { inputs, config: config2, steps: {}, env: process.env };
     const targets = extractTargetFiles(workflow, flatCtx);
     for (const filePath of targets) {
       const before = await snapshotFile(cwd, filePath);
@@ -293841,7 +293916,7 @@ async function runWorkflow(name, cwd, opts = {}) {
     if (trigger === "create") {
       await mergeConfig(cwd, { template: name });
     } else {
-      const existing = config.features ?? [];
+      const existing = config2.features ?? [];
       await mergeConfig(cwd, { features: [.../* @__PURE__ */ new Set([...existing, name])] });
     }
   }
@@ -293850,7 +293925,7 @@ async function runWorkflow(name, cwd, opts = {}) {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("xo").description("Local workflow engine for developers \u2014 compose actions into workflows").version("0.1.2");
+program2.name("xo").description("Local workflow engine for developers \u2014 compose actions into workflows").version("0.1.3");
 function parseInputFlags(flags) {
   const result = {};
   for (const flag of flags) {
@@ -294057,7 +294132,7 @@ registry.command("list").description("List all registered generators").action(as
   console.log();
 });
 program2.command("init [dir]").description("Scaffold a new generator repo (workflow.yaml, templates/, actions/)").action(async (dir) => {
-  const targetDir = import_node_path.default.resolve(dir ?? process.cwd());
+  const targetDir = import_node_path2.default.resolve(dir ?? process.cwd());
   console.log(source_default.bold("\nInitializing new xo generator\n"));
   const answers = await (0, import_prompts2.default)([
     {
@@ -294086,27 +294161,27 @@ program2.command("init [dir]").description("Scaffold a new generator repo (workf
   const { name, description, triggers } = answers;
   const triggersYaml = `[${triggers.join(", ")}]`;
   const hasMultipleTriggers = triggers.length > 1;
-  await import_fs_extra13.default.ensureDir(targetDir);
-  await import_fs_extra13.default.ensureDir(import_node_path.default.join(targetDir, "templates"));
-  await import_fs_extra13.default.ensureDir(import_node_path.default.join(targetDir, "actions"));
+  await import_fs_extra14.default.ensureDir(targetDir);
+  await import_fs_extra14.default.ensureDir(import_node_path2.default.join(targetDir, "templates"));
+  await import_fs_extra14.default.ensureDir(import_node_path2.default.join(targetDir, "actions"));
   if (hasMultipleTriggers) {
-    await import_fs_extra13.default.ensureDir(import_node_path.default.join(targetDir, "workflows"));
+    await import_fs_extra14.default.ensureDir(import_node_path2.default.join(targetDir, "workflows"));
     for (const trigger of triggers) {
-      await import_fs_extra13.default.writeFile(
-        import_node_path.default.join(targetDir, "workflows", `${trigger}.yaml`),
+      await import_fs_extra14.default.writeFile(
+        import_node_path2.default.join(targetDir, "workflows", `${trigger}.yaml`),
         buildWorkflowYaml(name, `[${trigger}]`, description),
         "utf8"
       );
     }
   } else {
-    await import_fs_extra13.default.writeFile(
-      import_node_path.default.join(targetDir, "workflow.yaml"),
+    await import_fs_extra14.default.writeFile(
+      import_node_path2.default.join(targetDir, "workflow.yaml"),
       buildWorkflowYaml(name, triggersYaml, description),
       "utf8"
     );
   }
-  await import_fs_extra13.default.writeFile(
-    import_node_path.default.join(targetDir, "README.md"),
+  await import_fs_extra14.default.writeFile(
+    import_node_path2.default.join(targetDir, "README.md"),
     buildReadme(name, description, triggers),
     "utf8"
   );
@@ -294129,6 +294204,44 @@ program2.command("init [dir]").description("Scaffold a new generator repo (workf
   console.log(source_default.dim(`    3. Run ${source_default.white("xo link")} to test locally`));
   console.log();
 });
+var cache = program2.command("cache").description("Manage the local xo cache");
+cache.command("clear [owner]").description("Clear cached GitHub workflows. Optionally scope to a specific owner (e.g. betaversionio).").action(async (owner) => {
+  const cacheDir2 = owner ? import_node_path2.default.join(import_node_os3.default.homedir(), ".xo", "cache", "github", owner) : import_node_path2.default.join(import_node_os3.default.homedir(), ".xo", "cache", "github");
+  if (!await import_fs_extra14.default.pathExists(cacheDir2)) {
+    console.log(source_default.dim("Cache is already empty."));
+    return;
+  }
+  await import_fs_extra14.default.remove(cacheDir2);
+  const label = owner ? source_default.cyan(`@github/${owner}`) : "all GitHub workflows";
+  console.log(source_default.green(`\u2714 Cleared cache for ${label}`));
+});
+cache.command("list").description("Show what is currently cached.").action(async () => {
+  const cacheDir2 = import_node_path2.default.join(import_node_os3.default.homedir(), ".xo", "cache", "github");
+  if (!await import_fs_extra14.default.pathExists(cacheDir2)) {
+    console.log(source_default.dim("Cache is empty."));
+    return;
+  }
+  const owners = await import_fs_extra14.default.readdir(cacheDir2);
+  if (owners.length === 0) {
+    console.log(source_default.dim("Cache is empty."));
+    return;
+  }
+  console.log(source_default.bold("\nCached GitHub workflows:\n"));
+  for (const owner of owners) {
+    const ownerDir = import_node_path2.default.join(cacheDir2, owner);
+    const repos = await import_fs_extra14.default.readdir(ownerDir).catch(() => []);
+    for (const repo of repos) {
+      const repoDir = import_node_path2.default.join(ownerDir, repo);
+      const refs = await import_fs_extra14.default.readdir(repoDir).catch(() => []);
+      for (const ref of refs) {
+        const rawbasePath = import_node_path2.default.join(repoDir, ref, ".rawbase");
+        const base = await import_fs_extra14.default.pathExists(rawbasePath) ? (await import_fs_extra14.default.readFile(rawbasePath, "utf8")).trim() : `github.com/${owner}/${repo}@${ref}`;
+        console.log(`  ${source_default.cyan(`@github/${owner}/${repo}`)}  ${source_default.dim(base)}`);
+      }
+    }
+  }
+  console.log();
+});
 program2.command("self-update").description("Check for a newer version of xo and update if available").action(async () => {
   const PACKAGE = "@xo-code/cli";
   const current = program2.version() ?? "0.0.0";
@@ -294153,6 +294266,41 @@ program2.command("self-update").description("Check for a newer version of xo and
     process.exit(1);
   }
 });
+var config = program2.command("config").description("Get and set global xo configuration");
+config.command("get <key>").description("Get a config value").action(async (key) => {
+  try {
+    const value = await getConfigValue(key);
+    if (value === void 0) {
+      console.log(source_default.dim(`${key} is not set`));
+    } else {
+      console.log(`${source_default.dim(key + ":")} ${source_default.white(String(value))}`);
+    }
+  } catch (err) {
+    console.error(source_default.red(`\u2716 ${err.message}`));
+    process.exit(1);
+  }
+});
+config.command("set <key> <value>").description("Set a config value").action(async (key, value) => {
+  try {
+    await setConfigValue(key, value);
+    console.log(source_default.green(`\u2714 ${key} = ${value}`));
+  } catch (err) {
+    console.error(source_default.red(`\u2716 ${err.message}`));
+    process.exit(1);
+  }
+});
+config.command("list").description("List all config keys, their current values, and defaults").action(async () => {
+  const current = await readGlobalConfig();
+  console.log(source_default.bold("\nxo global config\n"));
+  for (const [key, meta] of Object.entries(CONFIG_META)) {
+    const value = current[key];
+    const valueStr = value === void 0 ? source_default.dim("(not set)") : source_default.white(String(value));
+    const defaultStr = meta.default ? source_default.dim(` default: ${meta.default}`) : "";
+    console.log(`  ${source_default.cyan(key.padEnd(16))} ${valueStr}${defaultStr}`);
+    console.log(`  ${" ".repeat(16)} ${source_default.dim(meta.description)}`);
+    console.log();
+  }
+});
 function collect(val, acc) {
   acc.push(val);
   return acc;
@@ -294215,36 +294363,39 @@ xo unlink        # remove when done
 \`\`\`
 `;
 }
-var UPDATE_CACHE = import_node_path.default.join(import_node_os2.default.homedir(), ".xo", "update-check.json");
+var UPDATE_CACHE = import_node_path2.default.join(import_node_os3.default.homedir(), ".xo", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 program2.hook("postAction", async () => {
   try {
-    let cache = { lastCheck: 0, latest: "0.1.2" };
-    if (await import_fs_extra13.default.pathExists(UPDATE_CACHE)) {
-      cache = await import_fs_extra13.default.readJson(UPDATE_CACHE).catch(() => cache);
+    const globalConfig = await readGlobalConfig();
+    if (!globalConfig.autoUpdate) return;
+    let cache2 = { lastCheck: 0, latest: "0.1.3" };
+    if (await import_fs_extra14.default.pathExists(UPDATE_CACHE)) {
+      cache2 = await import_fs_extra14.default.readJson(UPDATE_CACHE).catch(() => cache2);
     }
     const now = Date.now();
-    let latest = cache.latest;
-    if (now - cache.lastCheck >= CHECK_INTERVAL_MS) {
+    let latest = cache2.latest;
+    if (now - cache2.lastCheck >= CHECK_INTERVAL_MS) {
+      const registryBase = globalConfig.registryUrl.replace(/\/$/, "");
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), 3e3);
       try {
-        const res = await fetch("https://registry.npmjs.org/@xo-code/cli/latest", {
+        const res = await fetch(`${registryBase}/@xo-code/cli/latest`, {
           signal: controller.signal
         });
         if (res.ok) {
           ({ version: latest } = await res.json());
-          await import_fs_extra13.default.ensureDir(import_node_path.default.dirname(UPDATE_CACHE));
-          await import_fs_extra13.default.writeJson(UPDATE_CACHE, { lastCheck: now, latest });
+          await import_fs_extra14.default.ensureDir(import_node_path2.default.dirname(UPDATE_CACHE));
+          await import_fs_extra14.default.writeJson(UPDATE_CACHE, { lastCheck: now, latest });
         }
       } finally {
         clearTimeout(timer);
       }
     }
-    if (isNewer(latest, "0.1.2")) {
+    if (isNewer(latest, "0.1.3")) {
       console.log(
         source_default.dim(`
-  Update available `) + source_default.yellow("0.1.2") + source_default.dim(" \u2192 ") + source_default.green(latest) + source_default.dim("  run ") + source_default.white("xo self-update")
+  Update available `) + source_default.yellow("0.1.3") + source_default.dim(" \u2192 ") + source_default.green(latest) + source_default.dim("  run ") + source_default.white("xo self-update")
       );
     }
   } catch {