@rslint/core 0.6.4 → 0.7.0

package/dist/cli.js

@@ -1,10 +1,18 @@
 import node_path from "node:path";
 import node_fs from "node:fs";
 import { parseArgs } from "node:util";
-import { loadConfigFile, collectPluginMeta, normalizeConfig } from "./config-loader.js";
-import { filterConfigsByParentIgnores, discoverConfigs } from "./207.js";
+import { resolveRslintBinary } from "./770.js";
+const OUTPUT_FORMATS = [
+    'default',
+    'jsonline',
+    'github',
+    'gitlab'
+];
+function isOutputFormat(value) {
+    return OUTPUT_FORMATS.includes(value);
+}
 function isJSConfigFile(filePath) {
-    return /\.(ts|mts|js|mjs)$/.test(filePath);
+    return /\.(ts|mts|cts|js|mjs|cjs)$/.test(filePath);
 }
 function args_parseArgs(argv) {
     const { values, tokens } = parseArgs({
@@ -13,11 +21,16 @@ function args_parseArgs(argv) {
         tokens: true,
         options: {
             config: {
-                type: 'string'
+                type: 'string',
+                short: 'c'
             },
             init: {
                 type: 'boolean'
             },
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
             singleThreaded: {
                 type: 'boolean'
             },
@@ -69,89 +82,13 @@ function args_parseArgs(argv) {
     return {
         config: values.config ?? null,
         init: values.init ?? false,
+        help: values.help ?? false,
         singleThreaded: values.singleThreaded ?? false,
+        format: values.format ?? null,
         rest,
         positionals
     };
 }
-function classifyArgs(positionals, cwd) {
-    const files = [];
-    const dirs = [];
-    for (const arg of positionals){
-        const resolved = node_path.resolve(cwd, arg);
-        try {
-            const real = node_fs.realpathSync(resolved);
-            if (node_fs.statSync(real).isDirectory()) dirs.push(real);
-            else files.push(real);
-        } catch  {
-            files.push(resolved);
-        }
-    }
-    return {
-        files,
-        dirs
-    };
-}
-async function runWithJSConfigs(binPath, configs, goArgs, cwd, singleThreaded) {
-    const configEntries = [];
-    const dirToPath = new Map();
-    const isSingleConfig = 1 === configs.size;
-    for (const [configPath, configDir] of configs){
-        let rawConfig;
-        try {
-            rawConfig = await loadConfigFile(configPath);
-        } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (isSingleConfig) {
-                process.stderr.write(`Error: failed to load config ${configPath}: ${msg}\n`);
-                return 1;
-            }
-            process.stderr.write(`Warning: skipping config ${configPath}: ${msg}\n`);
-            continue;
-        }
-        let entries;
-        try {
-            entries = normalizeConfig(rawConfig);
-        } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (isSingleConfig) {
-                process.stderr.write(`Error: invalid config in ${configPath}: ${msg}\n`);
-                return 1;
-            }
-            process.stderr.write(`Warning: skipping config ${configPath}: ${msg}\n`);
-            continue;
-        }
-        configEntries.push({
-            configDirectory: configDir,
-            entries
-        });
-        dirToPath.set(configDir, configPath);
-    }
-    const { runEngine } = await import("./0~engine.js");
-    if (0 === configEntries.length) return runEngine({
-        binPath,
-        goArgs,
-        configs: [],
-        cwd
-    });
-    const filteredEntries = filterConfigsByParentIgnores(configEntries);
-    const { eslintPluginEntries, pluginConfigs } = collectPluginMeta(filteredEntries.map((ce)=>({
-            configPath: dirToPath.get(ce.configDirectory) ?? '',
-            configDirectory: ce.configDirectory,
-            entries: ce.entries
-        })));
-    return runEngine({
-        binPath,
-        goArgs,
-        configs: filteredEntries,
-        cwd,
-        eslintPluginEntries,
-        pluginConfigs,
-        runtime: {
-            singleThreaded
-        }
-    });
-}
 async function run(binPath, argv, startTime) {
     const cwd = process.cwd();
     const args = args_parseArgs(argv);
@@ -162,10 +99,13 @@ async function run(binPath, argv, startTime) {
             goArgs: [
                 '--init'
             ],
-            configs: [],
             cwd
         });
     }
+    if (!args.help && null !== args.format && !isOutputFormat(args.format)) {
+        process.stderr.write(`error: invalid output format ${JSON.stringify(args.format)} (expected ${OUTPUT_FORMATS.slice(0, -1).join(', ')}, or ${OUTPUT_FORMATS.at(-1)})\n`);
+        return 2;
+    }
     if (args.config) {
         const configPath = node_path.resolve(cwd, args.config);
         if (!node_fs.existsSync(configPath)) {
@@ -177,12 +117,9 @@ async function run(binPath, argv, startTime) {
         `--start-time=${startTime}`,
         ...args.rest
     ];
-    const { files, dirs } = classifyArgs(args.positionals, cwd);
-    const configs = await discoverConfigs(files, dirs, cwd, args.config);
-    const jsConfigs = new Map();
-    for (const [configPath, configDir] of configs)if (isJSConfigFile(configPath)) jsConfigs.set(configPath, configDir);
-    if (jsConfigs.size > 0) return runWithJSConfigs(binPath, jsConfigs, goArgs, cwd, args.singleThreaded);
-    const jsonGoArgs = args.config ? [
+    const explicitConfigPath = args.config ? node_path.resolve(cwd, args.config) : null;
+    const usesExplicitJSConfig = null != explicitConfigPath && isJSConfigFile(explicitConfigPath);
+    const jsonGoArgs = args.config && !usesExplicitJSConfig ? [
         '--config',
         args.config,
         ...goArgs
@@ -191,8 +128,21 @@ async function run(binPath, argv, startTime) {
     return runEngine({
         binPath,
         goArgs: jsonGoArgs,
-        configs: [],
-        cwd
+        cwd,
+        runtime: {
+            singleThreaded: args.singleThreaded
+        },
+        extraInit: {
+            configDiscovery: {
+                mode: usesExplicitJSConfig ? 'explicit' : args.config ? 'disabled' : 'auto',
+                explicitConfigPath: usesExplicitJSConfig ? explicitConfigPath : void 0
+            }
+        }
     });
 }
-export { run };
+async function runCLI({ argv = process.argv } = {}) {
+    const startTime = Date.now();
+    const exitCode = await run(resolveRslintBinary(), argv.slice(2), startTime);
+    process.exitCode = exitCode;
+}
+export { run, runCLI };

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;