@rslint/core 0.6.5 → 0.7.0

package/dist/eslint-plugin/lint-worker.js

@@ -22572,9 +22572,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;
@@ -22588,6 +22590,7 @@ function ensureGlobal(gs, name, mode) {
         eslintImplicitGlobalSetting: mode,
         scope: gs
     };
+    syntheticGlobals.add(v);
     gs.variables.push(v);
     gs.set?.set(name, v);
     return v;
@@ -22625,28 +22628,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];
@@ -26084,7 +26109,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);
@@ -26100,7 +26124,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 {
@@ -26155,25 +26179,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
     };
 }

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

@@ -1,9 +1,3 @@
-/**
- * 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
@@ -13,11 +7,27 @@
  * 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;
 }
 
+/**
+ * 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.
+ */
+export declare type GlobalAccess = boolean | null | 'true' | 'false' | 'readonly' | 'readable' | 'writable' | 'writeable' | 'off';
+
+export declare type GlobalsConfig = Record<string, GlobalAccess>;
+
 export { }

package/dist/index.d.ts

@@ -21,6 +21,11 @@ export declare interface ESLintPlugin {
     [key: string]: unknown;
 }
 
+/**
+ * Access level for a declared global variable.
+ */
+declare type GlobalAccess = boolean | null | 'true' | 'false' | 'readonly' | 'readable' | 'writable' | 'writeable' | 'off';
+
 /**
  * Define a global-ignores config entry.
  *
@@ -37,6 +42,14 @@ export declare interface ESLintPlugin {
  */
 export declare function globalIgnores(ignorePatterns: string[]): RslintConfigEntry;
 
+/**
+ * Map of global variable name to its access level.
+ *
+ * @example
+ * globals: { myGlobal: 'readonly' }
+ */
+declare type GlobalsConfig = Record<string, GlobalAccess>;
+
 export declare const importPlugin: {
     configs: {
         recommended: RslintConfigEntry;
@@ -72,6 +85,16 @@ declare type KnownPlugin = (typeof NATIVE_PLUGINS)[number];
  */
 declare interface LanguageOptions {
     parserOptions?: ParserOptions;
+    /**
+     * Global variables available in this file's scope, e.g. from a browser
+     * or Node.js runtime. `'readonly'`, `false`, and `null` allow reading;
+     * `'writable'` and `true` allow reassignment. Only the string `'off'`
+     * un-declares a global inherited from an earlier entry.
+     *
+     * @example
+     * globals: { myGlobal: 'readonly' }
+     */
+    globals?: GlobalsConfig;
 }
 
 export declare interface LintMessage {
@@ -203,13 +226,17 @@ export declare type RslintConfig = RslintConfigEntry[];
  * different file globs and are merged at lint time.
  */
 export declare interface RslintConfigEntry {
+    /** Optional human-readable name for this config entry. */
+    name?: string;
     /**
-     * Glob patterns for files this entry applies to.
+     * Glob selectors for files this entry applies to. Top-level selectors are
+     * ORed; strings inside one nested array are ANDed, matching ESLint flat
+     * config semantics.
      *
      * @example
      * files: ['src/**', 'tests/**']
      */
-    files?: string[];
+    files?: Array<string | string[]>;
     /**
      * Glob patterns excluded from this entry.
      *
@@ -262,7 +289,7 @@ export declare interface RslintOptions {
     /** Extra config appended after the resolved/discovered config (ESLint's overrideConfig). */
     overrideConfig?: RslintConfigEntry | RslintConfigEntry[] | null;
     /**
-     * `string` — use this config file (no discovery).
+     * `string` — use this JS/TS config module (no discovery).
      * `true`   — use only `overrideConfig` (no file, no discovery).
      * `null`/absent — auto-discover the nearest config (ESLint v10 semantics; no `false`).
      */
@@ -270,15 +297,15 @@ export declare interface RslintOptions {
     /** Apply rule auto-fixes; results carry `output` (the JS side persists via outputFixes). */
     fix?: boolean;
     /**
-     * In-memory file overlay (path → content) for fully in-memory linting (issue
-     * #1106): put the `tsconfig.json` that `parserOptions.project` names plus any
+     * In-memory file overlay (path → content) for project inputs (issue #1106):
+     * put the `tsconfig.json` that `parserOptions.project` names plus any
      * dependency files here, then lint a buffer with `lintText`. Keys resolve
      * against `cwd` like a linted path (relative or absolute both work); a
      * same-path `lintText` code entry wins. Inside the tsconfig (`files`) and
      * `parserOptions.project`, use relative paths — the TS compiler resolves
      * those, and a bare POSIX-absolute path there has no drive letter on Windows,
-     * so it won't match the overlay. rslint-only — ESLint has no in-memory file
-     * map.
+     * so it won't match the overlay. The overlay permits filesystem fallback and
+     * is not a sandbox. rslint-only — ESLint has no in-memory file map.
      *
      * Give the tsconfig explicit `files`, not a broad `include` glob: a glob is
      * expanded against the real filesystem and would scan `cwd` on disk.
@@ -287,29 +314,20 @@ export declare interface RslintOptions {
 }
 
 /**
- * Configuration value accepted for a single rule.
+ * Configuration value accepted for a single rule. Aligned with ESLint —
+ * rslint's own `{ level, options }` object form has been removed.
  *
  * - `RuleSeverity` — just toggle the rule.
  * - `[RuleSeverity, ...args]` — ESLint-style array form. Most rules take a
  *   single options object (`[severity, { ... }]`); some accept positional
  *   string/object args (`[severity, "always", { ... }]`).
- * - `{ level, options }` — object form supported by the loader.
- */
-declare type RuleEntry = RuleSeverity | readonly [RuleSeverity, ...any[]] | {
-    level: RuleSeverity;
-    options?: RuleOptions;
-};
-
-/**
- * Rule-specific options object. Each rule defines its own shape; until per-rule
- * types are generated, options are accepted as an open record.
  */
-declare type RuleOptions = Record<string, any>;
+declare type RuleEntry = RuleSeverity | readonly [RuleSeverity, ...any[]];
 
 /**
  * Severity level for a rule.
  */
-declare type RuleSeverity = 'off' | 'warn' | 'error';
+declare type RuleSeverity = 'off' | 'warn' | 'error' | 0 | 1 | 2;
 
 /**
  * Map of rule name → rule configuration. Rule names are `string` (no