@rslint/core 0.6.5 → 0.7.0

package/dist/config-loader.d.ts

@@ -1,14 +1,28 @@
+/** Go's final effective-ID selection after ignore/ownership resolution. */
+export declare interface ActivateConfigsRequest {
+    protocolVersion: typeof CONFIG_DISCOVERY_PROTOCOL_VERSION;
+    transactionId: string;
+    effectiveConfigIds: string[];
+}
+
+/** Minimal activation payload returned across IPC/JSON-RPC to Go. */
+export declare interface ActivateConfigsResponse {
+    transactionId: string;
+    eslintPluginEntries: ConfigModuleEslintPluginEntry[];
+}
+
 /**
  * Derive, from normalized configs, the ESLint-plugin metadata the Go core
  * needs (`{prefix, ruleNames}` for placeholder rules) and the worker-pool
  * descriptors (only for configs that mount plugins — others stay
- * zero-overhead). Shared by the CLI (cli.ts) and the VS Code extension
- * (Rslint.ts) so both produce the identical `eslintPlugins` shape Go parses.
+ * zero-overhead). ConfigModuleHost invokes this only after Go selects the
+ * transaction's effective IDs, so discarded candidates cannot leak plugin
+ * placeholders or worker routes into the activated catalog.
  * ruleNames for a shared prefix are merged (set union) across configs: Go's
  * placeholder registry is a per-prefix superset, while the worker routes the
- * actual rules per-config. This is NOT a validation — a genuinely conflicting
- * redefinition (same prefix, different plugin object) is caught at worker init
- * (plugin-loader throws ESLint's `Cannot redefine plugin` error), not here.
+ * actual rules per config. This is not the validation boundary: worker config
+ * loading rejects conflicting plugin definitions, including duplicate routing
+ * descriptors that mount different instances under the same prefix.
  */
 export declare function collectPluginMeta(configs: ReadonlyArray<{
     configPath: string;
@@ -23,13 +37,165 @@ export declare function collectPluginMeta(configs: ReadonlyArray<{
 };
 
 /**
- * Load a JS/TS config file.
- * - .js/.mjs: native import()
- * - .ts/.mts: native import() when Node.js has TypeScript support (>= 22.6),
- *             otherwise fall back to jiti
+ * Logical protocol shared by the native CLI, programmatic API, and LSP config
+ * discovery adapters. The transports differ (framed IPC versus JSON-RPC), but
+ * every adapter sends these payloads to the same Node-side module host.
+ *
+ * Paths in requests identify values selected by Go. Node may native-normalize
+ * configPath for local I/O, but configDirectory is an opaque routing identity
+ * and must retain its exact spelling. Load responses correlate only by opaque
+ * candidate ID. Activation responses contain only the transaction identity and
+ * plugin metadata consumed by Go; Node-only preparation data never crosses the
+ * transport boundary.
+ */
+export declare const CONFIG_DISCOVERY_PROTOCOL_VERSION: 1;
+
+export declare interface ConfigEntry {
+    configDirectory: string;
+    entries: unknown[];
+}
+
+/**
+ * Node-local activation data derived from exactly the effective IDs selected
+ * by Go. It is exposed only to the prepare callback and is never serialized
+ * as the activation response.
+ */
+export declare interface ConfigModuleActivationPlan {
+    transactionId: string;
+    configs: EffectiveConfigModule[];
+    eslintPluginEntries: ConfigModuleEslintPluginEntry[];
+    pluginConfigs: ConfigModulePluginDescriptor[];
+}
+
+export declare interface ConfigModuleCandidate {
+    /** Opaque, transaction-local identity allocated by the Go coordinator. */
+    id: string;
+    /** Absolute path to the JS/TS config module Node must execute. */
+    configPath: string;
+    /** Go-authoritative directory used for config matching and plugin routing. */
+    configDirectory: string;
+}
+
+export declare interface ConfigModuleEslintPluginEntry {
+    prefix: string;
+    ruleNames: string[];
+}
+
+/**
+ * Executes config modules on behalf of Go's discovery coordinator.
+ *
+ * A host may serve multiple concurrent discovery transactions. Operations in
+ * one transaction are serialized (frontier batches can safely build on earlier
+ * batches), while separate transactions remain independent. Call
+ * deleteSession after commit/abort so normalized entries do not remain live.
+ */
+export declare class ConfigModuleHost {
+    #private;
+    constructor(options?: ConfigModuleHostOptions);
+    /** Load and normalize one discovery frontier without fail-fast evaluation. */
+    loadConfigs(request: LoadConfigsRequest, signal?: AbortSignal): Promise<LoadConfigsResponse>;
+    /**
+     * Protocol-facing activation transaction.
+     *
+     * Plugin workers re-import plugin-bearing config modules. The optional
+     * prepare callback therefore runs between two source-fingerprint checks.
+     * A caller cannot publish the normalized activation until every effective
+     * source still matches the bytes from which that activation was derived.
+     */
+    activateConfigs(request: ActivateConfigsRequest, signal?: AbortSignal, prepare?: (plan: ConfigModuleActivationPlan) => Promise<void>): Promise<ActivateConfigsResponse>;
+    /** Drop all normalized module state for a committed or aborted transaction. */
+    deleteSession(transactionId: string): boolean;
+}
+
+export declare interface ConfigModuleHostOptions {
+    /** Test/embedding seam; production defaults to loadConfigFile. */
+    loadCached?: ConfigModuleLoader;
+    /** Test/embedding seam; production defaults to loadConfigFileFresh. */
+    loadFresh?: ConfigModuleLoader;
+    /** Test/embedding seam; production defaults to fs.promises.readFile. */
+    readSource?: ConfigSourceReader;
+}
+
+declare type ConfigModuleLoader = (configPath: string) => Promise<unknown>;
+
+export declare type ConfigModuleLoadMode = 'cached' | 'fresh';
+
+export declare type ConfigModuleLoadResult = LoadedConfigModuleResult | FailedConfigModuleResult;
+
+export declare type ConfigModulePluginDescriptor = PluginConfigDescriptor;
+
+declare type ConfigSourceReader = (configPath: string) => Promise<Uint8Array>;
+
+export declare interface EffectiveConfigModule {
+    id: string;
+    configPath: string;
+    configDirectory: string;
+    entries: Record<string, unknown>[];
+    sourceFingerprint: string;
+}
+
+export declare interface FailedConfigModuleResult {
+    id: string;
+    status: 'failed';
+    error: {
+        message: string;
+        code?: string;
+    };
+}
+
+/**
+ * Filter loaded nested config candidates whose directory is covered by an
+ * ancestor config's global ignores. Candidate discovery and module loading are
+ * intentionally independent from this effective-catalog step.
+ *
+ * `forceIncludeConfigDirectories` is for explicit CLI file targets: ESLint
+ * resolves the nearest config for an explicit file even when parent directory
+ * traversal would have been blocked.
+ */
+export declare function filterConfigsByParentIgnores<T extends ConfigEntry>(configEntries: T[], forceIncludeConfigDirectories?: Set<string>): T[];
+
+/**
+ * Load a selected JS/TS config file.
+ * TypeScript modules use native import when Node.js supports type stripping
+ * and otherwise fall back to jiti. Other module formats use native import.
  */
 export declare function loadConfigFile(configPath: string): Promise<unknown>;
 
+/**
+ * Load a config without reusing the config module from a previous reload.
+ * TypeScript loading selects native stripping or jiti before evaluation so a
+ * runtime exception from the config is propagated without executing it again.
+ */
+export declare function loadConfigFileFresh(configPath: string): Promise<unknown>;
+
+export declare interface LoadConfigsRequest {
+    protocolVersion: typeof CONFIG_DISCOVERY_PROTOCOL_VERSION;
+    /** Isolates batches belonging to one discovery transaction. */
+    transactionId: string;
+    /**
+     * `cached` preserves one-shot CLI module-import semantics. `fresh` is used
+     * by long-lived API and editor refreshes; it cache-busts the entry module,
+     * while static transitive imports retain Node's normal module cache.
+     */
+    loadMode: ConfigModuleLoadMode;
+    /** Serialize module evaluation when the CLI requested --singleThreaded. */
+    singleThreaded?: boolean;
+    candidates: ConfigModuleCandidate[];
+}
+
+export declare interface LoadConfigsResponse {
+    transactionId: string;
+    /** Results are in exactly the same order as request.candidates. */
+    results: ConfigModuleLoadResult[];
+}
+
+export declare interface LoadedConfigModuleResult {
+    id: string;
+    status: 'loaded';
+    /** Serializable normalizeConfig output. Live plugin objects never cross. */
+    entries: Record<string, unknown>[];
+}
+
 /**
  * Validate and strip non-serializable fields from the config.
  */

package/dist/config-loader.js

@@ -1,161 +1,3 @@
-import node_path from "node:path";
-import { pathToFileURL } from "node:url";
-const NATIVE_PLUGINS = [
-    "@typescript-eslint",
-    'import',
-    'jest',
-    'jsx-a11y',
-    'promise',
-    'react',
-    'react-hooks',
-    'unicorn'
-];
-const NATIVE_PLUGIN_DECL_ALIASES = [
-    'eslint-plugin-import',
-    'eslint-plugin-jest',
-    'eslint-plugin-jsx-a11y',
-    'eslint-plugin-promise',
-    'eslint-plugin-react-hooks',
-    'eslint-plugin-unicorn'
-];
-const NATIVE_PLUGIN_RESERVED_NAMES = new Set([
-    ...NATIVE_PLUGINS,
-    ...NATIVE_PLUGIN_DECL_ALIASES
-]);
-function defineConfig(config) {
-    return config;
-}
-function globalIgnores(ignorePatterns) {
-    if (!Array.isArray(ignorePatterns)) throw new TypeError('ignorePatterns must be an array');
-    if (0 === ignorePatterns.length) throw new TypeError('ignorePatterns must contain at least one pattern');
-    return {
-        ignores: ignorePatterns
-    };
-}
-function selectPluginSource(entry) {
-    if (null == entry || 'object' != typeof entry) return null;
-    const e = entry;
-    if (null != e.plugins && 'object' == typeof e.plugins && !Array.isArray(e.plugins)) return e.plugins;
-    return null;
-}
-function unwrapPluginModule(mod) {
-    if (null == mod || 'object' != typeof mod) return null;
-    const m = mod;
-    if (null != m.default && 'object' == typeof m.default) return m.default;
-    return mod;
-}
-async function loadConfigFile(configPath) {
-    const ext = node_path.extname(configPath);
-    if ('.js' === ext || '.mjs' === ext) {
-        const mod = await import(pathToFileURL(configPath).href);
-        return mod.default ?? mod;
-    }
-    if ('.ts' === ext || '.mts' === ext) {
-        const useNative = Boolean(process.features.typescript);
-        if (useNative) {
-            const mod = await import(pathToFileURL(configPath).href);
-            return mod.default ?? mod;
-        }
-        const jiti = await loadJiti(configPath);
-        if (jiti) {
-            const resolved = await jiti.import(configPath);
-            return extractDefault(resolved);
-        }
-        throw new Error(`Failed to load TypeScript config file: ${configPath}\nTo load .ts config files, either:\n  1. Use Node.js >= 22.6 (with native TypeScript support)\n  2. Install jiti as a dependency: npm install -D jiti`);
-    }
-    throw new Error(`Unsupported config file extension: ${ext}`);
-}
-async function loadJiti(configPath) {
-    try {
-        const { createJiti } = await import("jiti");
-        return createJiti(node_path.dirname(configPath), {
-            interopDefault: true
-        });
-    } catch  {
-        return null;
-    }
-}
-function extractDefault(mod) {
-    if ('object' == typeof mod && null !== mod && 'default' in mod) return mod.default;
-    return mod;
-}
-function normalizeConfig(config) {
-    if (!Array.isArray(config)) throw new Error(`rslint config must export an array (flat config format), got ${typeof config}`);
-    return config.filter((entry, index)=>{
-        if (null == entry || 'object' != typeof entry) {
-            console.warn(`[rslint] Config entry at index ${index} is not an object (got ${null === entry ? 'null' : typeof entry}), skipping.`);
-            return false;
-        }
-        return true;
-    }).map((entry, index)=>{
-        if (null != entry.files && !Array.isArray(entry.files)) throw new Error(`[rslint] Config entry at index ${index}: "files" must be an array, got ${typeof entry.files}`);
-        if (null != entry.ignores && !Array.isArray(entry.ignores)) throw new Error(`[rslint] Config entry at index ${index}: "ignores" must be an array, got ${typeof entry.ignores}`);
-        const pluginSource = selectPluginSource(entry);
-        const eslintPluginMeta = {};
-        const pluginPrefixes = [];
-        if (null != pluginSource) for (const prefix of Object.keys(pluginSource)){
-            if (NATIVE_PLUGIN_RESERVED_NAMES.has(prefix)) throw new Error(`[rslint] Config entry at index ${index}: plugins prefix "${prefix}" collides with the built-in plugin of the same name; choose a different prefix.`);
-            const plugin = unwrapPluginModule(pluginSource[prefix]);
-            const pluginRules = plugin?.rules;
-            if (null == pluginRules || 'object' != typeof pluginRules) throw new Error(`[rslint] Config entry at index ${index}: plugins["${prefix}"] must expose a "rules" object.`);
-            eslintPluginMeta[prefix] = {
-                ruleNames: Object.keys(pluginRules).sort()
-            };
-            pluginPrefixes.push(prefix);
-        }
-        const stringPlugins = Array.isArray(entry.plugins) ? entry.plugins.filter((p)=>'string' == typeof p) : [];
-        const plugins = [
-            ...new Set([
-                ...stringPlugins,
-                ...pluginPrefixes
-            ])
-        ];
-        return {
-            files: entry.files,
-            ignores: entry.ignores,
-            languageOptions: entry.languageOptions,
-            rules: entry.rules,
-            plugins,
-            settings: entry.settings,
-            ...pluginPrefixes.length > 0 ? {
-                eslintPlugins: eslintPluginMeta
-            } : {}
-        };
-    });
-}
-function collectPluginMeta(configs) {
-    const isPluginMetaMap = (v)=>null !== v && 'object' == typeof v;
-    const byPrefix = new Map();
-    const pluginConfigs = [];
-    for (const c of configs){
-        let hasPlugins = false;
-        for (const entry of c.entries){
-            if (null === entry || 'object' != typeof entry || !('eslintPlugins' in entry)) continue;
-            const ep = entry.eslintPlugins;
-            if (isPluginMetaMap(ep)) for (const [prefix, meta] of Object.entries(ep)){
-                hasPlugins = true;
-                const existing = byPrefix.get(prefix);
-                if (existing) {
-                    for (const name of meta.ruleNames)if (!existing.includes(name)) existing.push(name);
-                } else byPrefix.set(prefix, [
-                    ...meta.ruleNames
-                ]);
-            }
-        }
-        if (hasPlugins) pluginConfigs.push({
-            configPath: c.configPath,
-            configDirectory: c.configDirectory
-        });
-    }
-    const eslintPluginEntries = [
-        ...byPrefix.entries()
-    ].map(([prefix, ruleNames])=>({
-            prefix,
-            ruleNames
-        }));
-    return {
-        eslintPluginEntries,
-        pluginConfigs
-    };
-}
-export { collectPluginMeta, defineConfig, globalIgnores, loadConfigFile, normalizeConfig };
+var config_loader_CONFIG_DISCOVERY_PROTOCOL_VERSION = 1;
+export { ConfigModuleHost, collectPluginMeta, filterConfigsByParentIgnores, loadConfigFile, loadConfigFileFresh, normalizeConfig } from "./519.js";
+export { config_loader_CONFIG_DISCOVERY_PROTOCOL_VERSION as CONFIG_DISCOVERY_PROTOCOL_VERSION };

package/dist/eslint-plugin/index.d.ts

@@ -40,12 +40,6 @@ declare interface Comment {
     loc: SourceLocation;
 }
 
-/**
- * Types shared between the eslint-plugin host and its lint workers.
- *
- * Wire-format / IPC frame types (the Go↔Node frame contract) live in
- * `src/ipc/protocol.ts` — the single source the CLI host consumes.
- */
 /**
  * Per-config descriptor handed to the worker pool. Each worker imports
  * every descriptor's `configPath` once at init, then routes per-file
@@ -55,10 +49,11 @@ declare interface Comment {
  * it as a Map key for per-file dispatch.
  */
 export declare interface ConfigDescriptor {
-    /** Absolute filesystem path of the rslint config file (`rslint.config.{js,mjs,ts,mts}`). */
+    /** Absolute filesystem path of the selected JS/TS config file. */
     configPath: string;
-    /** Absolute filesystem path of the directory holding the config file.
-     *  Matches the `ConfigKey` Go emits per file during plugin-lint dispatch. */
+    /** Go-authoritative absolute matching/routing directory. In explicit mode
+     *  this can differ from the config file's parent and MUST byte-match the
+     *  `ConfigKey` Go emits during plugin-lint dispatch. */
     configDirectory: string;
 }
 
@@ -101,6 +96,8 @@ export declare interface Diagnostic {
  * doesn't need to re-validate Go's serialization.
  */
 export declare interface EslintPluginLintRequest {
+    /** LSP config/worker generation. Omitted by the CLI's single-host path. */
+    generation?: string;
     files: ReadonlyArray<{
         path: string;
         /**
@@ -119,8 +116,8 @@ export declare interface EslintPluginLintRequest {
         languageOptions?: unknown;
         settings?: Record<string, unknown>;
         /**
-         * The owning config's directory in the SAME form the host used as
-         * its `ConfigDescriptor.configDirectory` (CLI: fs path; LSP: URI).
+         * The owning config's absolute filesystem directory in the same form the
+         * host used as its `ConfigDescriptor.configDirectory`.
          * The worker uses it to pick the right `LoadedPlugins`. Empty when
          * no JS config governs the file.
          */
@@ -192,6 +189,21 @@ declare interface Fix {
     text: string;
 }
 
+/**
+ * Types shared between the eslint-plugin host and its lint workers.
+ *
+ * Wire-format / IPC frame types (the Go↔Node frame contract) live in
+ * `src/ipc/protocol.ts` — the single source the CLI host consumes.
+ */
+/**
+ * ESLint-compatible access values carried to the plugin worker. This mirrors
+ * the public config authoring type without coupling the worker build project to
+ * the config-loader build project.
+ */
+declare type GlobalAccess = boolean | null | 'true' | 'false' | 'readonly' | 'readable' | 'writable' | 'writeable' | 'off';
+
+declare type GlobalsConfig = Record<string, GlobalAccess>;
+
 /** Minimal node shape — the fixer only needs `range`. */
 declare interface HasRange {
     range: [number, number];
@@ -223,7 +235,7 @@ declare interface LanguageOptions {
     ecmaVersion?: number | 'latest';
     /** Module / script / commonjs — top-level in ESLint v10. Same rationale as `ecmaVersion`. */
     sourceType?: 'module' | 'script' | 'commonjs';
-    globals?: Record<string, 'readonly' | 'writable' | 'off'>;
+    globals?: GlobalsConfig;
     /**
      * Parser-specific extras. Only `ecmaFeatures` lives here in v10
      * (rules that gate on `jsx` / `globalReturn` / `impliedStrict` read
@@ -283,7 +295,7 @@ export declare interface LintFileRequest {
     languageOptions?: {
         ecmaVersion?: number | 'latest';
         sourceType?: 'module' | 'script' | 'commonjs';
-        globals?: Record<string, 'readonly' | 'writable' | 'off'>;
+        globals?: GlobalsConfig;
         parserOptions?: {
             ecmaFeatures?: {
                 jsx?: boolean;

package/dist/eslint-plugin/index.js

@@ -23169,9 +23169,11 @@ function scope_factory_analyze(ast, opts) {
         childVisitorKeys: VISITOR_KEYS
     });
 }
+const syntheticGlobals = new WeakSet();
 function ensureGlobal(gs, name, mode) {
     const existing = gs.set?.get(name);
     if (existing) {
+        if (!syntheticGlobals.has(existing)) return existing;
         existing.writeable = 'writable' === mode;
         existing.eslintImplicitGlobalSetting = mode;
         return existing;
@@ -23185,6 +23187,7 @@ function ensureGlobal(gs, name, mode) {
         eslintImplicitGlobalSetting: mode,
         scope: gs
     };
+    syntheticGlobals.add(v);
     gs.variables.push(v);
     gs.set?.set(name, v);
     return v;
@@ -23222,28 +23225,50 @@ function seedGlobals(scopeManager, globals) {
     const gs = sm.globalScope;
     if (!gs) return;
     if (!globals) return void resolveThroughReferences(gs);
-    for (const [name, mode] of Object.entries(globals)){
-        if ('off' === mode) {
-            if (gs.set?.has(name)) {
-                const v = gs.set.get(name);
-                if (Array.isArray(v.references) && v.references.length > 0) {
-                    const through = gs.through ?? (gs.through = []);
-                    for (const ref of v.references){
-                        ref.resolved = null;
-                        through.push(ref);
+    for (const [name, access] of Object.entries(globals)){
+        const mode = normalizeGlobalAccess(access);
+        if (null != mode) {
+            if ('off' === mode) {
+                const v = gs.set?.get(name);
+                if (v && syntheticGlobals.has(v)) {
+                    if (Array.isArray(v.references) && v.references.length > 0) {
+                        const through = gs.through ?? (gs.through = []);
+                        for (const ref of v.references){
+                            ref.resolved = null;
+                            through.push(ref);
+                        }
+                        v.references = [];
                     }
-                    v.references = [];
+                    const idx = gs.variables.indexOf(v);
+                    if (idx >= 0) gs.variables.splice(idx, 1);
+                    gs.set?.delete(name);
                 }
-                const idx = gs.variables.indexOf(v);
-                if (idx >= 0) gs.variables.splice(idx, 1);
-                gs.set.delete(name);
+                continue;
             }
-            continue;
+            ensureGlobal(gs, name, mode);
         }
-        ensureGlobal(gs, name, mode);
     }
     resolveThroughReferences(gs);
 }
+function normalizeGlobalAccess(access) {
+    switch(access){
+        case true:
+        case 'true':
+        case 'writable':
+        case 'writeable':
+            return 'writable';
+        case false:
+        case null:
+        case 'false':
+        case 'readonly':
+        case 'readable':
+            return 'readonly';
+        case 'off':
+            return 'off';
+        default:
+            return;
+    }
+}
 function esquery_esm_min_e(e, t) {
     (null == t || t > e.length) && (t = e.length);
     for(var r = 0, n = Array(t); r < t; r++)n[r] = e[r];
@@ -26681,7 +26706,6 @@ function unwrapPluginModule(mod) {
 }
 async function importConfigFile(configFilePath) {
     const ext = node_path.extname(configFilePath);
-    if ('.js' === ext || '.mjs' === ext || '.cjs' === ext) return import(pathToFileURL(configFilePath).href);
     if ('.ts' === ext || '.mts' === ext || '.cts' === ext) {
         const useNative = Boolean(process.features.typescript);
         if (useNative) return import(pathToFileURL(configFilePath).href);
@@ -26697,7 +26721,7 @@ async function importConfigFile(configFilePath) {
         const resolved = await jiti.import(configFilePath);
         return resolved;
     }
-    throw new Error(`Unsupported config file extension: ${ext}`);
+    return import(pathToFileURL(configFilePath).href);
 }
 const MIN_NODE_MAJOR = 20;
 class PluginLoaderError extends Error {
@@ -26752,25 +26776,35 @@ async function loadPluginsFromConfigs(configs) {
     for(let i = 0; i < configs.length; i++){
         const dir = configs[i].configDirectory;
         const existing = out.get(dir);
-        out.set(dir, existing ? mergeLoadedPlugins(existing, loadedList[i], dir) : loadedList[i]);
+        out.set(dir, existing ? mergeLoadedPlugins(existing, loadedList[i], dir, configs[i].configPath) : loadedList[i]);
     }
     return out;
 }
-function mergeLoadedPlugins(a, b, dir) {
+function mergeLoadedPlugins(a, b, dir, configPath) {
+    const plugins = [
+        ...a.plugins
+    ];
+    const pluginsByPrefix = new Map(plugins.map((loaded)=>[
+            loaded.prefix,
+            loaded
+        ]));
+    for (const loaded of b.plugins){
+        const existing = pluginsByPrefix.get(loaded.prefix);
+        if (existing) {
+            if (existing.plugin !== loaded.plugin) throw new PluginLoaderError(configPath, `Cannot redefine plugin "${loaded.prefix}" for routing key "${dir}".`);
+            continue;
+        }
+        pluginsByPrefix.set(loaded.prefix, loaded);
+        plugins.push(loaded);
+    }
     const rules = new Map(a.rules);
     for (const [key, rule] of b.rules){
         const existing = rules.get(key);
-        if (void 0 !== existing && existing !== rule) {
-            process.stderr.write(`[rslint] plugin rule "${key}" is defined by more than one config in the same directory (${dir}); keeping the first. Deduplicate the rslint.config.* files for this directory.\n`);
-            continue;
-        }
+        if (void 0 !== existing && existing !== rule) throw new PluginLoaderError(configPath, `[rslint] plugin rule "${key}" is defined by different plugin instances for the same config key (${dir})`);
         rules.set(key, rule);
     }
     return {
-        plugins: [
-            ...a.plugins,
-            ...b.plugins
-        ],
+        plugins,
         rules
     };
 }