@oclif/core 3.0.0-beta.9 → 3.0.1

package/lib/config/config.js

@@ -1,42 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCached = exports.Config = void 0;
+exports.Config = void 0;
+const tslib_1 = require("tslib");
+const ejs = tslib_1.__importStar(require("ejs"));
+const is_wsl_1 = tslib_1.__importDefault(require("is-wsl"));
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
+const stream_1 = require("../cli-ux/stream");
 const errors_1 = require("../errors");
-const ejs = require("ejs");
-const os = require("os");
-const path = require("path");
-const url_1 = require("url");
-const util_1 = require("util");
-const util_2 = require("./util");
-const util_3 = require("../util");
+const util_1 = require("../help/util");
 const module_loader_1 = require("../module-loader");
-const help_1 = require("../help");
-const stream_1 = require("../ux/stream");
 const performance_1 = require("../performance");
 const settings_1 = require("../settings");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const plugin_loader_1 = require("./plugin-loader");
+const fs_1 = require("../util/fs");
+const os_1 = require("../util/os");
+const util_2 = require("../util/util");
+const plugin_loader_1 = tslib_1.__importDefault(require("./plugin-loader"));
+const util_3 = require("./util");
 // eslint-disable-next-line new-cap
-const debug = (0, util_2.Debug)();
-const _pjson = (0, util_3.requireJson)(__dirname, '..', '..', 'package.json');
+const debug = (0, util_3.Debug)();
+const _pjson = (0, fs_1.requireJson)(__dirname, '..', '..', 'package.json');
 const BASE = `${_pjson.name}@${_pjson.version}`;
 function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
 }
-const WSL = require('is-wsl');
 function isConfig(o) {
     return o && Boolean(o._base);
 }
 class Permutations extends Map {
-    constructor() {
-        super(...arguments);
-        this.validPermutations = new Map();
-    }
+    validPermutations = new Map();
     add(permutation, commandId) {
         this.validPermutations.set(permutation, commandId);
-        for (const id of (0, util_2.collectUsableIds)([permutation])) {
+        for (const id of (0, util_3.collectUsableIds)([permutation])) {
             if (this.has(id)) {
                 this.set(id, this.get(id).add(commandId));
             }
@@ -48,33 +46,61 @@ class Permutations extends Map {
     get(key) {
         return super.get(key) ?? new Set();
     }
-    getValid(key) {
-        return this.validPermutations.get(key);
-    }
     getAllValid() {
         return [...this.validPermutations.keys()];
     }
+    getValid(key) {
+        return this.validPermutations.get(key);
+    }
     hasValid(key) {
         return this.validPermutations.has(key);
     }
 }
 class Config {
+    options;
+    _base = BASE;
+    _commandIDs;
+    _commands = new Map();
+    static _rootPlugin;
+    _topics = new Map();
+    commandPermutations = new Permutations();
+    pluginLoader;
+    topicPermutations = new Permutations();
+    arch;
+    bin;
+    binAliases;
+    binPath;
+    cacheDir;
+    channel;
+    configDir;
+    dataDir;
+    debug = 0;
+    dirname;
+    errlog;
+    flexibleTaxonomy;
+    home;
+    name;
+    npmRegistry;
+    nsisCustomization;
+    pjson;
+    platform;
+    plugins = new Map();
+    root;
+    shell;
+    topicSeparator = ':';
+    userAgent;
+    userPJSON;
+    valid;
+    version;
+    warned = false;
+    windows;
     constructor(options) {
         this.options = options;
-        this._base = BASE;
-        this.debug = 0;
-        this.plugins = new Map();
-        this.topicSeparator = ':';
-        this.warned = false;
-        this.commandPermutations = new Permutations();
-        this.topicPermutations = new Permutations();
-        this._commands = new Map();
-        this._topics = new Map();
     }
     static async load(opts = module.filename || __dirname) {
         // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
         if (typeof opts === 'string' && opts.startsWith('file://')) {
-            opts = (0, url_1.fileURLToPath)(opts);
+            opts = (0, node_url_1.fileURLToPath)(opts);
         }
         if (typeof opts === 'string')
             opts = { root: opts };
@@ -104,10 +130,268 @@ class Config {
     static get rootPlugin() {
         return Config._rootPlugin;
     }
+    _debug() {
+        if (this.scopedEnvVarTrue('DEBUG'))
+            return 1;
+        try {
+            const { enabled } = require('debug')(this.bin);
+            if (enabled)
+                return 1;
+        }
+        catch { }
+        return 0;
+    }
+    _shell() {
+        let shellPath;
+        const { COMSPEC } = process.env;
+        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
+        if (SHELL) {
+            shellPath = SHELL.split('/');
+        }
+        else if (this.windows && COMSPEC) {
+            shellPath = COMSPEC.split(/\\|\//);
+        }
+        else {
+            shellPath = ['unknown'];
+        }
+        return shellPath.at(-1) ?? 'unknown';
+    }
+    /**
+     * This method is responsible for locating the correct plugin to use for a named command id
+     * It searches the {Config} registered commands to match either the raw command id or the command alias
+     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
+     * create the same command or command alias.
+     *
+     * In the case of more than one found command, the function will select the command based on the order in which
+     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
+     * is selected as the command to run.
+     *
+     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
+     * is present, this function defers to the core plugin.
+     *
+     * If there is not a core plugin command present, this function will return the first
+     * plugin as discovered (will not change the order)
+     *
+     * @param commands commands to determine the priority of
+     * @returns command instance {Command.Loadable} or undefined
+     */
+    determinePriority(commands) {
+        const oclifPlugins = this.pjson.oclif?.plugins ?? [];
+        const commandPlugins = commands.sort((a, b) => {
+            const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
+            const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
+            const aIndex = oclifPlugins.indexOf(pluginAliasA);
+            const bIndex = oclifPlugins.indexOf(pluginAliasB);
+            // When both plugin types are 'core' plugins sort based on index
+            if (a.pluginType === 'core' && b.pluginType === 'core') {
+                // If b appears first in the pjson.plugins sort it first
+                return aIndex - bIndex;
+            }
+            // if b is a core plugin and a is not sort b first
+            if (b.pluginType === 'core' && a.pluginType !== 'core') {
+                return 1;
+            }
+            // if a is a core plugin and b is not sort a first
+            if (a.pluginType === 'core' && b.pluginType !== 'core') {
+                return -1;
+            }
+            // if a is a jit plugin and b is not sort b first
+            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
+                return 1;
+            }
+            // if b is a jit plugin and a is not sort a first
+            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
+                return -1;
+            }
+            // neither plugin is core, so do not change the order
+            return 0;
+        });
+        return commandPlugins[0];
+    }
+    getCmdLookupId(id) {
+        if (this._commands.has(id))
+            return id;
+        if (this.commandPermutations.hasValid(id))
+            return this.commandPermutations.getValid(id);
+        return id;
+    }
+    getTopicLookupId(id) {
+        if (this._topics.has(id))
+            return id;
+        if (this.topicPermutations.hasValid(id))
+            return this.topicPermutations.getValid(id);
+        return id;
+    }
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     * @returns void
+     */
+    insertLegacyPlugins(plugins) {
+        for (const plugin of plugins) {
+            this.plugins.set(plugin.name, plugin);
+            this.loadCommands(plugin);
+        }
+    }
+    isJitPluginCommand(c) {
+        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
+        return (Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') &&
+            Boolean(c?.pluginName && !this.plugins.has(c.pluginName)));
+    }
+    loadCommands(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadCommands#${plugin.name}`, { plugin: plugin.name });
+        for (const command of plugin.commands) {
+            // set canonical command id
+            if (this._commands.has(command.id)) {
+                const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
+                this._commands.set(prioritizedCommand.id, prioritizedCommand);
+            }
+            else {
+                this._commands.set(command.id, command);
+            }
+            // v3 moved command id permutations to the manifest, but some plugins may not have
+            // the new manifest yet. For those, we need to calculate the permutations here.
+            const permutations = this.flexibleTaxonomy && command.permutations === undefined
+                ? (0, util_3.getCommandIdPermutations)(command.id)
+                : command.permutations ?? [command.id];
+            // set every permutation
+            for (const permutation of permutations) {
+                this.commandPermutations.add(permutation, command.id);
+            }
+            // set command aliases
+            for (const alias of command.aliases ?? []) {
+                if (this._commands.has(alias)) {
+                    const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
+                    this._commands.set(alias, { ...prioritizedCommand, id: alias });
+                }
+                else {
+                    this._commands.set(alias, { ...command, id: alias });
+                }
+                // set every permutation of the aliases
+                // v3 moved command alias permutations to the manifest, but some plugins may not have
+                // the new manifest yet. For those, we need to calculate the permutations here.
+                const aliasPermutations = this.flexibleTaxonomy && command.aliasPermutations === undefined
+                    ? (0, util_3.getCommandIdPermutations)(alias)
+                    : command.permutations ?? [alias];
+                // set every permutation
+                for (const permutation of aliasPermutations) {
+                    this.commandPermutations.add(permutation, command.id);
+                }
+            }
+        }
+        marker?.addDetails({ commandCount: plugin.commands.length });
+        marker?.stop();
+    }
+    loadTopics(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadTopics#${plugin.name}`, { plugin: plugin.name });
+        for (const topic of (0, util_2.compact)(plugin.topics)) {
+            const existing = this._topics.get(topic.name);
+            if (existing) {
+                existing.description = topic.description || existing.description;
+                existing.hidden = existing.hidden || topic.hidden;
+            }
+            else {
+                this._topics.set(topic.name, topic);
+            }
+            const permutations = this.flexibleTaxonomy ? (0, util_3.getCommandIdPermutations)(topic.name) : [topic.name];
+            for (const permutation of permutations) {
+                this.topicPermutations.add(permutation, topic.name);
+            }
+        }
+        // Add missing topics for displaying help when partial commands are entered.
+        for (const c of plugin.commands.filter((c) => !c.hidden)) {
+            const parts = c.id.split(':');
+            while (parts.length > 0) {
+                const name = parts.join(':');
+                if (name && !this._topics.has(name)) {
+                    this._topics.set(name, { description: c.summary || c.description, name });
+                }
+                parts.pop();
+            }
+        }
+        marker?.stop();
+    }
+    dir(category) {
+        const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
+            (this.windows && process.env.LOCALAPPDATA) ||
+            (0, node_path_1.join)(this.home, category === 'data' ? '.local/share' : '.' + category);
+        return (0, node_path_1.join)(base, this.dirname);
+    }
+    findCommand(id, opts = {}) {
+        const lookupId = this.getCmdLookupId(id);
+        const command = this._commands.get(lookupId);
+        if (opts.must && !command)
+            (0, errors_1.error)(`command ${lookupId} not found`);
+        return command;
+    }
+    /**
+     * Find all command ids that include the provided command id.
+     *
+     * For example, if the command ids are:
+     * - foo:bar:baz
+     * - one:two:three
+     *
+     * `bar` would return `foo:bar:baz`
+     *
+     * @param partialCmdId string
+     * @param argv string[] process.argv containing the flags and arguments provided by the user
+     * @returns string[]
+     */
+    findMatches(partialCmdId, argv) {
+        const flags = argv
+            .filter((arg) => !(0, util_1.getHelpFlagAdditions)(this).includes(arg) && arg.startsWith('-'))
+            .map((a) => a.replaceAll('-', ''));
+        const possibleMatches = [...this.commandPermutations.get(partialCmdId)].map((k) => this._commands.get(k));
+        const matches = possibleMatches.filter((command) => {
+            const cmdFlags = Object.entries(command.flags).flatMap(([flag, def]) => def.char ? [def.char, flag] : [flag]);
+            // A command is a match if the provided flags belong to the full command
+            return flags.every((f) => cmdFlags.includes(f));
+        });
+        return matches;
+    }
+    findTopic(name, opts = {}) {
+        const lookupId = this.getTopicLookupId(name);
+        const topic = this._topics.get(lookupId);
+        if (topic)
+            return topic;
+        if (opts.must)
+            throw new Error(`topic ${name} not found`);
+    }
+    /**
+     * Returns an array of all command ids. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns string[]
+     */
+    getAllCommandIDs() {
+        return this.getAllCommands().map((c) => c.id);
+    }
+    /**
+     * Returns an array of all commands. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns Command.Loadable[]
+     */
+    getAllCommands() {
+        const commands = [...this._commands.values()];
+        const validPermutations = [...this.commandPermutations.getAllValid()];
+        for (const permutation of validPermutations) {
+            if (!this._commands.has(permutation)) {
+                const cmd = this._commands.get(this.getCmdLookupId(permutation));
+                commands.push({ ...cmd, id: permutation });
+            }
+        }
+        return commands;
+    }
+    getPluginsList() {
+        return [...this.plugins.values()];
+    }
     // eslint-disable-next-line complexity
     async load() {
-        settings_1.default.performanceEnabled = (settings_1.default.performanceEnabled === undefined ? this.options.enablePerf : settings_1.default.performanceEnabled) ?? false;
-        this.pluginLoader = new plugin_loader_1.default({ root: this.options.root, plugins: this.options.plugins });
+        settings_1.settings.performanceEnabled =
+            (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.load');
+        this.pluginLoader = new plugin_loader_1.default({ plugins: this.options.plugins, root: this.options.root });
         Config._rootPlugin = await this.pluginLoader.loadRoot();
         this.root = Config._rootPlugin.root;
         this.pjson = Config._rootPlugin.pjson;
@@ -118,8 +402,8 @@ class Config {
         this.version = this.options.version || this.pjson.version || '0.0.0';
         this.channel = this.options.channel || channelFromVersion(this.version);
         this.valid = Config._rootPlugin.valid;
-        this.arch = (os.arch() === 'ia32' ? 'x86' : os.arch());
-        this.platform = WSL ? 'wsl' : os.platform();
+        this.arch = (0, node_os_1.arch)() === 'ia32' ? 'x86' : (0, node_os_1.arch)();
+        this.platform = is_wsl_1.default ? 'wsl' : (0, os_1.getPlatform)();
         this.windows = this.platform === 'win32';
         this.bin = this.pjson.oclif.bin || this.name;
         this.binAliases = this.pjson.oclif.binAliases;
@@ -127,18 +411,18 @@ class Config {
         this.dirname = this.pjson.oclif.dirname || this.name;
         this.flexibleTaxonomy = this.pjson.oclif.flexibleTaxonomy || false;
         // currently, only colons or spaces are valid separators
-        if (this.pjson.oclif.topicSeparator && [':', ' '].includes(this.pjson.oclif.topicSeparator))
+        if (this.pjson.oclif.topicSeparator && [' ', ':'].includes(this.pjson.oclif.topicSeparator))
             this.topicSeparator = this.pjson.oclif.topicSeparator;
         if (this.platform === 'win32')
             this.dirname = this.dirname.replace('/', '\\');
         this.userAgent = `${this.name}/${this.version} ${this.platform}-${this.arch} node-${process.version}`;
         this.shell = this._shell();
         this.debug = this._debug();
-        this.home = process.env.HOME || (this.windows && this.windowsHome()) || os.homedir() || os.tmpdir();
+        this.home = process.env.HOME || (this.windows && this.windowsHome()) || (0, os_1.getHomeDir)() || (0, node_os_1.tmpdir)();
         this.cacheDir = this.scopedEnvVar('CACHE_DIR') || this.macosCacheDir() || this.dir('cache');
         this.configDir = this.scopedEnvVar('CONFIG_DIR') || this.dir('config');
         this.dataDir = this.scopedEnvVar('DATA_DIR') || this.dir('data');
-        this.errlog = path.join(this.cacheDir, 'error.log');
+        this.errlog = (0, node_path_1.join)(this.cacheDir, 'error.log');
         this.binPath = this.scopedEnvVar('BINPATH');
         this.npmRegistry = this.scopedEnvVar('NPM_REGISTRY') || this.pjson.oclif.npmRegistry;
         this.pjson.oclif.update = this.pjson.oclif.update || {};
@@ -152,88 +436,141 @@ class Config {
             ...s3.templates,
             target: {
                 baseDir: '<%- bin %>',
+                manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- platform %>-<%- arch %>",
                 unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-<%- platform %>-<%- arch %><%- ext %>",
                 versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %>-<%- platform %>-<%- arch %><%- ext %>",
-                manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- platform %>-<%- arch %>",
-                ...s3.templates && s3.templates.target,
+                ...(s3.templates && s3.templates.target),
             },
             vanilla: {
-                unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %><%- ext %>",
-                versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %><%- ext %>",
                 baseDir: '<%- bin %>',
                 manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %>version",
-                ...s3.templates && s3.templates.vanilla,
+                unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %><%- ext %>",
+                versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %><%- ext %>",
+                ...(s3.templates && s3.templates.vanilla),
             },
         };
-        const marker = performance_1.default.mark('config.load');
         await this.loadPluginsAndCommands();
         debug('config done');
         marker?.addDetails({
-            plugins: this.plugins.size,
             commandPermutations: this.commands.length,
             commands: [...this.plugins.values()].reduce((acc, p) => acc + p.commands.length, 0),
+            plugins: this.plugins.size,
             topics: this.topics.length,
         });
         marker?.stop();
     }
     async loadPluginsAndCommands(opts) {
-        const marker = performance_1.default.mark('config.loadPluginsAndCommands');
-        const { plugins, errors } = await this.pluginLoader.loadChildren({
-            devPlugins: this.options.devPlugins,
-            userPlugins: this.options.userPlugins,
+        const pluginsMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.loadAllPlugins');
+        const { errors, plugins } = await this.pluginLoader.loadChildren({
             dataDir: this.dataDir,
-            rootPlugin: Config._rootPlugin,
+            devPlugins: this.options.devPlugins,
             force: opts?.force ?? false,
+            rootPlugin: Config._rootPlugin,
+            userPlugins: this.options.userPlugins,
         });
         this.plugins = plugins;
+        pluginsMarker?.stop();
+        const commandsMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.loadAllCommands');
         for (const plugin of this.plugins.values()) {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
+        commandsMarker?.stop();
         for (const error of errors) {
             this.warn(error);
         }
-        marker?.stop();
     }
-    async runHook(event, opts, timeout, captureErrors) {
-        const marker = performance_1.default.mark(`config.runHook#${event}`);
-        debug('start %s hook', event);
-        const search = (m) => {
-            if (typeof m === 'function')
-                return m;
-            if (m.default && typeof m.default === 'function')
-                return m.default;
-            return Object.values(m).find((m) => typeof m === 'function');
-        };
-        const withTimeout = async (ms, promise) => {
+    macosCacheDir() {
+        return (this.platform === 'darwin' && (0, node_path_1.join)(this.home, 'Library', 'Caches', this.dirname)) || undefined;
+    }
+    async runCommand(id, argv = [], cachedCommand = null) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runCommand#${id}`);
+        debug('runCommand %s %o', id, argv);
+        let c = cachedCommand ?? this.findCommand(id);
+        if (!c) {
+            const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
+            const hookResult = this.flexibleTaxonomy && matches.length > 0
+                ? await this.runHook('command_incomplete', { argv, id, matches })
+                : await this.runHook('command_not_found', { argv, id });
+            if (hookResult.successes[0])
+                return hookResult.successes[0].result;
+            if (hookResult.failures[0])
+                throw hookResult.failures[0].error;
+            throw new errors_1.CLIError(`command ${id} not found`);
+        }
+        if (this.isJitPluginCommand(c)) {
+            const pluginName = c.pluginName;
+            const pluginVersion = this.pjson.oclif.jitPlugins[pluginName];
+            const jitResult = await this.runHook('jit_plugin_not_installed', {
+                argv,
+                command: c,
+                id,
+                pluginName,
+                pluginVersion,
+            });
+            if (jitResult.failures[0])
+                throw jitResult.failures[0].error;
+            if (jitResult.successes[0]) {
+                await this.loadPluginsAndCommands({ force: true });
+                c = this.findCommand(id) ?? c;
+            }
+            else {
+                // this means that no jit_plugin_not_installed hook exists, so we should run the default behavior
+                const result = await this.runHook('command_not_found', { argv, id });
+                if (result.successes[0])
+                    return result.successes[0].result;
+                if (result.failures[0])
+                    throw result.failures[0].error;
+                throw new errors_1.CLIError(`command ${id} not found`);
+            }
+        }
+        const command = await c.load();
+        await this.runHook('prerun', { Command: command, argv });
+        const result = (await command.run(argv, this));
+        await this.runHook('postrun', { Command: command, argv, result });
+        marker?.addDetails({ command: id, plugin: c.pluginName });
+        marker?.stop();
+        return result;
+    }
+    async runHook(event, opts, timeout, captureErrors) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runHook#${event}`);
+        debug('start %s hook', event);
+        const search = (m) => {
+            if (typeof m === 'function')
+                return m;
+            if (m.default && typeof m.default === 'function')
+                return m.default;
+            return Object.values(m).find((m) => typeof m === 'function');
+        };
+        const withTimeout = async (ms, promise) => {
             let id;
             const timeout = new Promise((_, reject) => {
                 id = setTimeout(() => {
                     reject(new Error(`Timed out after ${ms} ms.`));
                 }, ms).unref();
             });
-            return Promise.race([promise, timeout]).then(result => {
+            return Promise.race([promise, timeout]).then((result) => {
                 clearTimeout(id);
                 return result;
             });
         };
         const final = {
-            successes: [],
             failures: [],
+            successes: [],
         };
         const promises = [...this.plugins.values()].map(async (p) => {
             const debug = require('debug')([this.bin, p.name, 'hooks', event].join(':'));
             const context = {
                 config: this,
                 debug,
+                error(message, options = {}) {
+                    (0, errors_1.error)(message, options);
+                },
                 exit(code = 0) {
                     (0, errors_1.exit)(code);
                 },
                 log(message, ...args) {
-                    stream_1.stdout.write((0, util_1.format)(message, ...args) + '\n');
-                },
-                error(message, options = {}) {
-                    (0, errors_1.error)(message, options);
+                    stream_1.stdout.write((0, node_util_1.format)(message, ...args) + '\n');
                 },
                 warn(message) {
                     (0, errors_1.warn)(message);
@@ -241,14 +578,14 @@ class Config {
             };
             const hooks = p.hooks[event] || [];
             for (const hook of hooks) {
-                const marker = performance_1.default.mark(`config.runHook#${p.name}(${hook})`);
+                const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runHook#${p.name}(${hook})`);
                 try {
                     /* eslint-disable no-await-in-loop */
-                    const { isESM, module, filePath } = await module_loader_1.default.loadWithData(p, hook);
+                    const { filePath, isESM, module } = await (0, module_loader_1.loadWithData)(p, (0, node_path_1.join)(p.root, hook));
                     debug('start', isESM ? '(import)' : '(require)', filePath);
-                    const result = timeout ?
-                        await withTimeout(timeout, search(module).call(context, { ...opts, config: this })) :
-                        await search(module).call(context, { ...opts, config: this });
+                    const result = timeout
+                        ? await withTimeout(timeout, search(module).call(context, { ...opts, config: this }))
+                        : await search(module).call(context, { ...opts, config: this });
                     final.successes.push({ plugin: p, result });
                     if (p.name === '@oclif/plugin-legacy' && event === 'init') {
                         this.insertLegacyPlugins(result);
@@ -256,15 +593,15 @@ class Config {
                     debug('done');
                 }
                 catch (error) {
-                    final.failures.push({ plugin: p, error: error });
+                    final.failures.push({ error: error, plugin: p });
                     debug(error);
                     if (!captureErrors && error.oclif?.exit !== undefined)
                         throw error;
                 }
                 marker?.addDetails({
-                    plugin: p.name,
                     event,
                     hook,
+                    plugin: p.name,
                 });
                 marker?.stop();
             }
@@ -274,61 +611,24 @@ class Config {
         marker?.stop();
         return final;
     }
-    async runCommand(id, argv = [], cachedCommand = null) {
-        const marker = performance_1.default.mark(`config.runCommand#${id}`);
-        debug('runCommand %s %o', id, argv);
-        let c = cachedCommand ?? this.findCommand(id);
-        if (!c) {
-            const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
-            const hookResult = this.flexibleTaxonomy && matches.length > 0 ?
-                await this.runHook('command_incomplete', { id, argv, matches }) :
-                await this.runHook('command_not_found', { id, argv });
-            if (hookResult.successes[0])
-                return hookResult.successes[0].result;
-            if (hookResult.failures[0])
-                throw hookResult.failures[0].error;
-            throw new errors_1.CLIError(`command ${id} not found`);
-        }
-        if (this.isJitPluginCommand(c)) {
-            const pluginName = c.pluginName;
-            const pluginVersion = this.pjson.oclif.jitPlugins[pluginName];
-            const jitResult = await this.runHook('jit_plugin_not_installed', {
-                id,
-                argv,
-                command: c,
-                pluginName,
-                pluginVersion,
-            });
-            if (jitResult.failures[0])
-                throw jitResult.failures[0].error;
-            if (jitResult.successes[0]) {
-                await this.loadPluginsAndCommands({ force: true });
-                c = this.findCommand(id) ?? c;
-            }
-            else {
-                // this means that no jit_plugin_not_installed hook exists, so we should run the default behavior
-                const result = await this.runHook('command_not_found', { id, argv });
-                if (result.successes[0])
-                    return result.successes[0].result;
-                if (result.failures[0])
-                    throw result.failures[0].error;
-                throw new errors_1.CLIError(`command ${id} not found`);
-            }
-        }
-        const command = await c.load();
-        await this.runHook('prerun', { Command: command, argv });
-        const result = (await command.run(argv, this));
-        await this.runHook('postrun', { Command: command, result, argv });
-        marker?.addDetails({ command: id, plugin: c.pluginName });
-        marker?.stop();
-        return result;
+    s3Key(type, ext, options = {}) {
+        if (typeof ext === 'object')
+            options = ext;
+        else if (ext)
+            options.ext = ext;
+        const template = this.pjson.oclif.update.s3.templates[options.platform ? 'target' : 'vanilla'][type] ?? '';
+        return ejs.render(template, { ...this, ...options });
     }
-    scopedEnvVar(k) {
-        return process.env[this.scopedEnvVarKeys(k).find(k => process.env[k])];
+    s3Url(key) {
+        const { host } = this.pjson.oclif.update.s3;
+        if (!host)
+            throw new Error('no s3 host is set');
+        const url = new node_url_1.URL(host);
+        url.pathname = (0, node_path_1.join)(url.pathname, key);
+        return url.toString();
     }
-    scopedEnvVarTrue(k) {
-        const v = process.env[this.scopedEnvVarKeys(k).find(k => process.env[k])];
-        return v === '1' || v === 'true';
+    scopedEnvVar(k) {
+        return process.env[this.scopedEnvVarKeys(k).find((k) => process.env[k])];
     }
     /**
      * this DOES NOT account for bin aliases, use scopedEnvVarKeys instead which will account for bin aliases
@@ -337,7 +637,7 @@ class Config {
      */
     scopedEnvVarKey(k) {
         return [this.bin, k]
-            .map(p => p.replace(/@/g, '').replace(/[/-]/g, '_'))
+            .map((p) => p.replaceAll('@', '').replaceAll(/[/-]/g, '_'))
             .join('_')
             .toUpperCase();
     }
@@ -347,156 +647,13 @@ class Config {
      * @returns {string[]} e.g. ['SF_DEBUG', 'SFDX_DEBUG']
      */
     scopedEnvVarKeys(k) {
-        return [this.bin, ...this.binAliases ?? []].filter(alias => Boolean(alias)).map(alias => [alias.replace(/@/g, '').replace(/[/-]/g, '_'), k].join('_').toUpperCase());
-    }
-    findCommand(id, opts = {}) {
-        const lookupId = this.getCmdLookupId(id);
-        const command = this._commands.get(lookupId);
-        if (opts.must && !command)
-            (0, errors_1.error)(`command ${lookupId} not found`);
-        return command;
-    }
-    findTopic(name, opts = {}) {
-        const lookupId = this.getTopicLookupId(name);
-        const topic = this._topics.get(lookupId);
-        if (topic)
-            return topic;
-        if (opts.must)
-            throw new Error(`topic ${name} not found`);
-    }
-    /**
-     * Find all command ids that include the provided command id.
-     *
-     * For example, if the command ids are:
-     * - foo:bar:baz
-     * - one:two:three
-     *
-     * `bar` would return `foo:bar:baz`
-     *
-     * @param partialCmdId string
-     * @param argv string[] process.argv containing the flags and arguments provided by the user
-     * @returns string[]
-     */
-    findMatches(partialCmdId, argv) {
-        const flags = argv.filter(arg => !(0, help_1.getHelpFlagAdditions)(this).includes(arg) && arg.startsWith('-')).map(a => a.replace(/-/g, ''));
-        const possibleMatches = [...this.commandPermutations.get(partialCmdId)].map(k => this._commands.get(k));
-        const matches = possibleMatches.filter(command => {
-            const cmdFlags = Object.entries(command.flags).flatMap(([flag, def]) => {
-                return def.char ? [def.char, flag] : [flag];
-            });
-            // A command is a match if the provided flags belong to the full command
-            return flags.every(f => cmdFlags.includes(f));
-        });
-        return matches;
-    }
-    /**
-     * Returns an array of all commands. If flexible taxonomy is enabled then all permutations will be appended to the array.
-     * @returns Command.Loadable[]
-     */
-    getAllCommands() {
-        const commands = [...this._commands.values()];
-        const validPermutations = [...this.commandPermutations.getAllValid()];
-        for (const permutation of validPermutations) {
-            if (!this._commands.has(permutation)) {
-                const cmd = this._commands.get(this.getCmdLookupId(permutation));
-                commands.push({ ...cmd, id: permutation });
-            }
-        }
-        return commands;
-    }
-    /**
-     * Returns an array of all command ids. If flexible taxonomy is enabled then all permutations will be appended to the array.
-     * @returns string[]
-     */
-    getAllCommandIDs() {
-        return this.getAllCommands().map(c => c.id);
-    }
-    get commands() {
-        return [...this._commands.values()];
-    }
-    get commandIDs() {
-        if (this._commandIDs)
-            return this._commandIDs;
-        this._commandIDs = this.commands.map(c => c.id);
-        return this._commandIDs;
-    }
-    get topics() {
-        return [...this._topics.values()];
-    }
-    get versionDetails() {
-        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
-        return {
-            cliVersion,
-            architecture,
-            nodeVersion,
-            pluginVersions: Object.fromEntries([...this.plugins.values()].map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
-            osVersion: `${os.type()} ${os.release()}`,
-            shell: this.shell,
-            rootPath: this.root,
-        };
-    }
-    s3Key(type, ext, options = {}) {
-        if (typeof ext === 'object')
-            options = ext;
-        else if (ext)
-            options.ext = ext;
-        const template = this.pjson.oclif.update.s3.templates[options.platform ? 'target' : 'vanilla'][type] ?? '';
-        return ejs.render(template, { ...this, ...options });
-    }
-    s3Url(key) {
-        const host = this.pjson.oclif.update.s3.host;
-        if (!host)
-            throw new Error('no s3 host is set');
-        const url = new url_1.URL(host);
-        url.pathname = path.join(url.pathname, key);
-        return url.toString();
-    }
-    getPluginsList() {
-        return [...this.plugins.values()];
-    }
-    dir(category) {
-        const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
-            (this.windows && process.env.LOCALAPPDATA) ||
-            path.join(this.home, category === 'data' ? '.local/share' : '.' + category);
-        return path.join(base, this.dirname);
-    }
-    windowsHome() {
-        return this.windowsHomedriveHome() || this.windowsUserprofileHome();
-    }
-    windowsHomedriveHome() {
-        return (process.env.HOMEDRIVE && process.env.HOMEPATH && path.join(process.env.HOMEDRIVE, process.env.HOMEPATH));
-    }
-    windowsUserprofileHome() {
-        return process.env.USERPROFILE;
+        return [this.bin, ...(this.binAliases ?? [])]
+            .filter(Boolean)
+            .map((alias) => [alias.replaceAll('@', '').replaceAll(/[/-]/g, '_'), k].join('_').toUpperCase());
     }
-    macosCacheDir() {
-        return (this.platform === 'darwin' && path.join(this.home, 'Library', 'Caches', this.dirname)) || undefined;
-    }
-    _shell() {
-        let shellPath;
-        const COMSPEC = process.env.COMSPEC;
-        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
-        if (SHELL) {
-            shellPath = SHELL.split('/');
-        }
-        else if (this.windows && COMSPEC) {
-            shellPath = COMSPEC.split(/\\|\//);
-        }
-        else {
-            shellPath = ['unknown'];
-        }
-        return shellPath[shellPath.length - 1];
-    }
-    _debug() {
-        if (this.scopedEnvVarTrue('DEBUG'))
-            return 1;
-        try {
-            const { enabled } = require('debug')(this.bin);
-            if (enabled)
-                return 1;
-        }
-        catch { }
-        return 0;
+    scopedEnvVarTrue(k) {
+        const v = process.env[this.scopedEnvVarKeys(k).find((k) => process.env[k])];
+        return v === '1' || v === 'true';
     }
     warn(err, scope) {
         if (this.warned)
@@ -532,298 +689,41 @@ class Config {
         ]).join('\n');
         process.emitWarning(JSON.stringify(err));
     }
-    get isProd() {
-        return (0, util_3.isProd)();
-    }
-    isJitPluginCommand(c) {
-        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
-        return Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') && Boolean(c?.pluginName && !this.plugins.has(c.pluginName));
-    }
-    getCmdLookupId(id) {
-        if (this._commands.has(id))
-            return id;
-        if (this.commandPermutations.hasValid(id))
-            return this.commandPermutations.getValid(id);
-        return id;
-    }
-    getTopicLookupId(id) {
-        if (this._topics.has(id))
-            return id;
-        if (this.topicPermutations.hasValid(id))
-            return this.topicPermutations.getValid(id);
-        return id;
-    }
-    loadCommands(plugin) {
-        const marker = performance_1.default.mark(`config.loadCommands#${plugin.name}`, { plugin: plugin.name });
-        for (const command of plugin.commands) {
-            // set canonical command id
-            if (this._commands.has(command.id)) {
-                const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
-                this._commands.set(prioritizedCommand.id, prioritizedCommand);
-            }
-            else {
-                this._commands.set(command.id, command);
-            }
-            // set every permutation
-            for (const permutation of command.permutations ?? [command.id]) {
-                this.commandPermutations.add(permutation, command.id);
-            }
-            // set command aliases
-            for (const alias of command.aliases ?? []) {
-                if (this._commands.has(alias)) {
-                    const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
-                    this._commands.set(alias, { ...prioritizedCommand, id: alias });
-                }
-                else {
-                    this._commands.set(alias, { ...command, id: alias });
-                }
-                // set every permutation of the aliases
-                for (const permutation of command.aliasPermutations ?? [alias]) {
-                    this.commandPermutations.add(permutation, command.id);
-                }
-            }
-        }
-        marker?.addDetails({ commandCount: plugin.commands.length });
-        marker?.stop();
-    }
-    loadTopics(plugin) {
-        const marker = performance_1.default.mark(`config.loadTopics#${plugin.name}`, { plugin: plugin.name });
-        for (const topic of (0, util_2.compact)(plugin.topics)) {
-            const existing = this._topics.get(topic.name);
-            if (existing) {
-                existing.description = topic.description || existing.description;
-                existing.hidden = existing.hidden || topic.hidden;
-            }
-            else {
-                this._topics.set(topic.name, topic);
-            }
-            const permutations = this.flexibleTaxonomy ? (0, util_2.getCommandIdPermutations)(topic.name) : [topic.name];
-            for (const permutation of permutations) {
-                this.topicPermutations.add(permutation, topic.name);
-            }
-        }
-        // Add missing topics for displaying help when partial commands are entered.
-        for (const c of plugin.commands.filter(c => !c.hidden)) {
-            const parts = c.id.split(':');
-            while (parts.length > 0) {
-                const name = parts.join(':');
-                if (name && !this._topics.has(name)) {
-                    this._topics.set(name, { name, description: c.summary || c.description });
-                }
-                parts.pop();
-            }
-        }
-        marker?.stop();
-    }
-    /**
-     * This method is responsible for locating the correct plugin to use for a named command id
-     * It searches the {Config} registered commands to match either the raw command id or the command alias
-     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
-     * create the same command or command alias.
-     *
-     * In the case of more than one found command, the function will select the command based on the order in which
-     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
-     * is selected as the command to run.
-     *
-     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
-     * is present, this function defers to the core plugin.
-     *
-     * If there is not a core plugin command present, this function will return the first
-     * plugin as discovered (will not change the order)
-     *
-     * @param commands commands to determine the priority of
-     * @returns command instance {Command.Loadable} or undefined
-     */
-    determinePriority(commands) {
-        const oclifPlugins = this.pjson.oclif?.plugins ?? [];
-        const commandPlugins = commands.sort((a, b) => {
-            const pluginAliasA = a.pluginAlias ?? 'A-Cannot-Find-This';
-            const pluginAliasB = b.pluginAlias ?? 'B-Cannot-Find-This';
-            const aIndex = oclifPlugins.indexOf(pluginAliasA);
-            const bIndex = oclifPlugins.indexOf(pluginAliasB);
-            // When both plugin types are 'core' plugins sort based on index
-            if (a.pluginType === 'core' && b.pluginType === 'core') {
-                // If b appears first in the pjson.plugins sort it first
-                return aIndex - bIndex;
-            }
-            // if b is a core plugin and a is not sort b first
-            if (b.pluginType === 'core' && a.pluginType !== 'core') {
-                return 1;
-            }
-            // if a is a core plugin and b is not sort a first
-            if (a.pluginType === 'core' && b.pluginType !== 'core') {
-                return -1;
-            }
-            // if a is a jit plugin and b is not sort b first
-            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
-                return 1;
-            }
-            // if b is a jit plugin and a is not sort a first
-            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
-                return -1;
-            }
-            // neither plugin is core, so do not change the order
-            return 0;
-        });
-        return commandPlugins[0];
-    }
-    /**
-      * Insert legacy plugins
-      *
-      * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
-      * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
-      *
-      * @param plugins array of oclif-compatible plugins
-      * @returns void
-      */
-    insertLegacyPlugins(plugins) {
-        for (const plugin of plugins) {
-            this.plugins.set(plugin.name, plugin);
-            this.loadCommands(plugin);
-        }
+    windowsHome() {
+        return this.windowsHomedriveHome() || this.windowsUserprofileHome();
     }
-}
-exports.Config = Config;
-// when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultFlagToCached = async (flag, respectNoCacheDefault) => {
-    if (respectNoCacheDefault && flag.noCacheDefault)
-        return;
-    // Prefer the defaultHelp function (returns a friendly string for complex types)
-    if (typeof flag.defaultHelp === 'function') {
-        try {
-            return await flag.defaultHelp({ options: flag, flags: {} });
-        }
-        catch {
-            return;
-        }
+    windowsHomedriveHome() {
+        return process.env.HOMEDRIVE && process.env.HOMEPATH && (0, node_path_1.join)(process.env.HOMEDRIVE, process.env.HOMEPATH);
     }
-    // if not specified, try the default function
-    if (typeof flag.default === 'function') {
-        try {
-            return await flag.default({ options: flag, flags: {} });
-        }
-        catch { }
+    windowsUserprofileHome() {
+        return process.env.USERPROFILE;
     }
-    else {
-        return flag.default;
+    get commandIDs() {
+        if (this._commandIDs)
+            return this._commandIDs;
+        this._commandIDs = this.commands.map((c) => c.id);
+        return this._commandIDs;
     }
-};
-const defaultArgToCached = async (arg, respectNoCacheDefault) => {
-    if (respectNoCacheDefault && arg.noCacheDefault)
-        return;
-    // Prefer the defaultHelp function (returns a friendly string for complex types)
-    if (typeof arg.defaultHelp === 'function') {
-        try {
-            return await arg.defaultHelp({ options: arg, flags: {} });
-        }
-        catch {
-            return;
-        }
+    get commands() {
+        return [...this._commands.values()];
     }
-    // if not specified, try the default function
-    if (typeof arg.default === 'function') {
-        try {
-            return await arg.default({ options: arg, flags: {} });
-        }
-        catch { }
+    get isProd() {
+        return (0, util_2.isProd)();
     }
-    else {
-        return arg.default;
-    }
-};
-async function toCached(c, plugin, respectNoCacheDefault = false) {
-    const flags = {};
-    for (const [name, flag] of Object.entries(c.flags || {})) {
-        if (flag.type === 'boolean') {
-            flags[name] = {
-                name,
-                type: flag.type,
-                char: flag.char,
-                summary: flag.summary,
-                description: flag.description,
-                hidden: flag.hidden,
-                required: flag.required,
-                helpLabel: flag.helpLabel,
-                helpGroup: flag.helpGroup,
-                allowNo: flag.allowNo,
-                dependsOn: flag.dependsOn,
-                relationships: flag.relationships,
-                exclusive: flag.exclusive,
-                deprecated: flag.deprecated,
-                deprecateAliases: c.deprecateAliases,
-                aliases: flag.aliases,
-                delimiter: flag.delimiter,
-                noCacheDefault: flag.noCacheDefault,
-            };
-        }
-        else {
-            flags[name] = {
-                name,
-                type: flag.type,
-                char: flag.char,
-                summary: flag.summary,
-                description: flag.description,
-                hidden: flag.hidden,
-                required: flag.required,
-                helpLabel: flag.helpLabel,
-                helpValue: flag.helpValue,
-                helpGroup: flag.helpGroup,
-                multiple: flag.multiple,
-                options: flag.options,
-                dependsOn: flag.dependsOn,
-                relationships: flag.relationships,
-                exclusive: flag.exclusive,
-                default: await defaultFlagToCached(flag, respectNoCacheDefault),
-                deprecated: flag.deprecated,
-                deprecateAliases: c.deprecateAliases,
-                aliases: flag.aliases,
-                delimiter: flag.delimiter,
-                noCacheDefault: flag.noCacheDefault,
-            };
-            // a command-level placeholder in the manifest so that oclif knows it should regenerate the command during help-time
-            if (typeof flag.defaultHelp === 'function') {
-                c.hasDynamicHelp = true;
-            }
-        }
+    get topics() {
+        return [...this._topics.values()];
     }
-    const args = {};
-    for (const [name, arg] of Object.entries((0, util_3.ensureArgObject)(c.args))) {
-        args[name] = {
-            name,
-            description: arg.description,
-            required: arg.required,
-            options: arg.options,
-            default: await defaultArgToCached(arg, respectNoCacheDefault),
-            hidden: arg.hidden,
-            noCacheDefault: arg.noCacheDefault,
+    get versionDetails() {
+        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
+        return {
+            architecture,
+            cliVersion,
+            nodeVersion,
+            osVersion: `${(0, node_os_1.type)()} ${(0, node_os_1.release)()}`,
+            pluginVersions: Object.fromEntries([...this.plugins.values()].map((p) => [p.name, { root: p.root, type: p.type, version: p.version }])),
+            rootPath: this.root,
+            shell: this.shell,
         };
     }
-    const stdProperties = {
-        id: c.id,
-        summary: c.summary,
-        description: c.description,
-        strict: c.strict,
-        usage: c.usage,
-        pluginName: plugin && plugin.name,
-        pluginAlias: plugin && plugin.alias,
-        pluginType: plugin && plugin.type,
-        hidden: c.hidden,
-        state: c.state,
-        aliases: c.aliases || [],
-        examples: c.examples || c.example,
-        deprecationOptions: c.deprecationOptions,
-        deprecateAliases: c.deprecateAliases,
-        flags,
-        args,
-    };
-    // do not include these properties in manifest
-    const ignoreCommandProperties = ['plugin', '_flags', '_enableJsonFlag', '_globalFlags', '_baseFlags'];
-    const stdKeys = Object.keys(stdProperties);
-    const keysToAdd = Object.keys(c).filter(property => ![...stdKeys, ...ignoreCommandProperties].includes(property));
-    const additionalProperties = {};
-    for (const key of keysToAdd) {
-        additionalProperties[key] = c[key];
-    }
-    return { ...stdProperties, ...additionalProperties };
 }
-exports.toCached = toCached;
+exports.Config = Config;