@rslint/core 0.6.5 → 0.7.1

package/dist/index.js

@@ -1,10 +1,15 @@
 import node_path from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
+import { lstat, readFile, stat as promises_stat, writeFile } from "node:fs/promises";
+import fs_0, * as __rspack_external_fs from "fs";
+import path_0, { basename, dirname, normalize as external_path_normalize, posix, relative as external_path_relative, resolve as external_path_resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import picomatch from "picomatch";
+import node_fs from "node:fs";
 import { NodeRslintService } from "./internal.js";
-import { loadConfigFile, normalizeConfig } from "./config-loader.js";
-import { findJSConfigUp, glob } from "./cli.js";
+import { ConfigModuleHost, normalizeConfig } from "./519.js";
 import { RSLintService } from "./service.js";
-const typescript_base = {
+const base = {
     files: [
         '**/*.ts',
         '**/*.tsx',
@@ -16,7 +21,7 @@ const typescript_base = {
     ]
 };
 const recommended = {
-    ...typescript_base,
+    ...base,
     languageOptions: {
         parserOptions: {
             projectService: true
@@ -50,6 +55,7 @@ const recommended = {
         'no-delete-var': 'error',
         'no-dupe-else-if': 'error',
         'no-empty-character-class': 'error',
+        'no-empty-static-block': 'error',
         'no-ex-assign': 'error',
         'no-extra-boolean-cast': 'error',
         'no-fallthrough': 'error',
@@ -66,6 +72,9 @@ const recommended = {
         'no-unexpected-multiline': 'error',
         'no-unsafe-finally': 'error',
         'no-unsafe-optional-chaining': 'error',
+        'no-unused-labels': 'error',
+        'no-unused-private-class-members': 'error',
+        'no-unassigned-vars': 'error',
         'no-useless-backreference': 'error',
         'no-useless-catch': 'error',
         'no-useless-escape': 'error',
@@ -130,6 +139,7 @@ const javascript_recommended = {
         'no-dupe-class-members': 'error',
         'no-dupe-else-if': 'error',
         'no-empty-character-class': 'error',
+        'no-empty-static-block': 'error',
         'no-ex-assign': 'error',
         'no-extra-boolean-cast': 'error',
         'no-fallthrough': 'error',
@@ -139,10 +149,12 @@ const javascript_recommended = {
         'no-invalid-regexp': 'error',
         'no-irregular-whitespace': 'error',
         'no-misleading-character-class': 'error',
+        'no-new-native-nonconstructor': 'error',
         'no-nonoctal-decimal-escape': 'error',
         'no-obj-calls': 'error',
         'no-octal': 'error',
         'no-prototype-builtins': 'error',
+        'no-redeclare': 'error',
         'no-regex-spaces': 'error',
         'no-self-assign': 'error',
         'no-setter-return': 'error',
@@ -154,6 +166,9 @@ const javascript_recommended = {
         'no-unsafe-finally': 'error',
         'no-unsafe-negation': 'error',
         'no-unsafe-optional-chaining': 'error',
+        'no-unused-labels': 'error',
+        'no-unused-private-class-members': 'error',
+        'no-unassigned-vars': 'error',
         'no-useless-backreference': 'error',
         'no-useless-catch': 'error',
         'no-useless-escape': 'error',
@@ -190,6 +205,7 @@ const react_recommended = {
         'react'
     ],
     rules: {
+        'react/display-name': 'error',
         'react/jsx-key': 'error',
         'react/jsx-no-comment-textnodes': 'error',
         'react/jsx-no-duplicate-props': 'error',
@@ -225,7 +241,11 @@ const import_recommended = {
     plugins: [
         'eslint-plugin-import'
     ],
-    rules: {}
+    rules: {
+        'import/namespace': 'error',
+        'import/default': 'error',
+        'import/no-duplicates': 'warn'
+    }
 };
 const promise_recommended = {
     plugins: [
@@ -236,8 +256,12 @@ const promise_recommended = {
         'promise/no-return-wrap': 'error',
         'promise/param-names': 'error',
         'promise/catch-or-return': 'error',
+        'promise/no-nesting': 'warn',
         'promise/no-promise-in-callback': 'warn',
+        'promise/no-callback-in-promise': 'warn',
         'promise/avoid-new': 'off',
+        'promise/no-new-statics': 'error',
+        'promise/no-return-in-finally': 'warn',
         'promise/valid-params': 'warn'
     }
 };
@@ -256,6 +280,7 @@ const jest_recommended = {
         'jest/no-export': 'error',
         'jest/no-focused-tests': 'error',
         'jest/no-identical-title': 'error',
+        'jest/no-interpolation-in-snapshots': 'error',
         'jest/no-jasmine-globals': 'error',
         'jest/no-mocks-import': 'error',
         'jest/no-standalone-expect': 'error',
@@ -281,7 +306,15 @@ const unicorn_recommended = {
     ],
     rules: {
         'unicorn/filename-case': 'error',
-        'unicorn/no-static-only-class': 'error'
+        'unicorn/new-for-builtins': 'error',
+        'unicorn/no-instanceof-builtins': 'error',
+        'unicorn/no-static-only-class': 'error',
+        'unicorn/no-thenable': 'error',
+        'unicorn/no-useless-switch-case': 'error',
+        'unicorn/prefer-array-flat-map': 'error',
+        'unicorn/prefer-number-properties': 'error',
+        'unicorn/require-array-join-separator': 'error',
+        'unicorn/require-number-to-fixed-digits-argument': 'error'
     }
 };
 const jsx_a11y_recommended = {
@@ -453,7 +486,7 @@ const jsx_a11y_recommended = {
 };
 const ts = {
     configs: {
-        base: typescript_base,
+        base: base,
         recommended: recommended
     }
 };
@@ -498,6 +531,971 @@ const jsxA11yPlugin = {
         recommended: jsx_a11y_recommended
     }
 };
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+function cleanPath(path) {
+    let normalized = external_path_normalize(path);
+    if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+    return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+    return "/" === path || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+    const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+    const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
+    if (resolvePaths) path = external_path_resolve(path);
+    if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+    if ("." === path) return "";
+    const needsSeperator = path[path.length - 1] !== pathSeparator;
+    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+    return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+    return function(filename, directoryPath) {
+        const sameRoot = directoryPath.startsWith(root);
+        if (sameRoot) return directoryPath.slice(root.length) + filename;
+        return convertSlashes(external_path_relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+    };
+}
+function joinPath(filename) {
+    return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+    return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+    const { relativePaths, includeBasePath } = options;
+    return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+function pushDirectoryWithRelativePath(root) {
+    return function(directoryPath, paths) {
+        paths.push(directoryPath.substring(root.length) || ".");
+    };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+    return function(directoryPath, paths, filters) {
+        const relativePath = directoryPath.substring(root.length) || ".";
+        if (filters.every((filter)=>filter(relativePath, true))) paths.push(relativePath);
+    };
+}
+const pushDirectory = (directoryPath, paths)=>{
+    paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters)=>{
+    const path = directoryPath || ".";
+    if (filters.every((filter)=>filter(path, true))) paths.push(path);
+};
+const empty$2 = ()=>{};
+function build$6(root, options) {
+    const { includeDirs, filters, relativePaths } = options;
+    if (!includeDirs) return empty$2;
+    if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+    return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+const pushFileFilterAndCount = (filename, _paths, counts, filters)=>{
+    if (filters.every((filter)=>filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters)=>{
+    if (filters.every((filter)=>filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters)=>{
+    counts.files++;
+};
+const pushFile = (filename, paths)=>{
+    paths.push(filename);
+};
+const empty$1 = ()=>{};
+function build$5(options) {
+    const { excludeFiles, filters, onlyCounts } = options;
+    if (excludeFiles) return empty$1;
+    if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+    if (onlyCounts) return pushFileCount;
+    return pushFile;
+}
+const getArray = (paths)=>paths;
+const getArrayGroup = ()=>[
+        ""
+    ].slice(0, 0);
+function build$4(options) {
+    return options.group ? getArrayGroup : getArray;
+}
+const groupFiles = (groups, directory, files)=>{
+    groups.push({
+        directory,
+        files,
+        dir: directory
+    });
+};
+const empty = ()=>{};
+function build$3(options) {
+    return options.group ? groupFiles : empty;
+}
+const resolveSymlinksAsync = function(path, state, callback$1) {
+    const { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue();
+    fs.realpath(path, (error, resolvedPath)=>{
+        if (error) return queue.dequeue(suppressErrors ? null : error, state);
+        fs.stat(resolvedPath, (error$1, stat)=>{
+            if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+            if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+            callback$1(stat, resolvedPath);
+            queue.dequeue(null, state);
+        });
+    });
+};
+const resolveSymlinks = function(path, state, callback$1) {
+    const { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue();
+    try {
+        const resolvedPath = fs.realpathSync(path);
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+        callback$1(stat, resolvedPath);
+    } catch (e) {
+        if (!suppressErrors) throw e;
+    }
+};
+function build$2(options, isSynchronous) {
+    if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+    if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+    let parent = dirname(path);
+    let depth = 1;
+    while(parent !== state.root && depth < 2){
+        const resolvedPath = state.symlinks.get(parent);
+        const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+        if (isSameRoot) depth++;
+        else parent = dirname(parent);
+    }
+    state.symlinks.set(path, resolved);
+    return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+    return state.visited.includes(resolved + state.options.pathSeparator);
+}
+const onlyCountsSync = (state)=>state.counts;
+const groupsSync = (state)=>state.groups;
+const defaultSync = (state)=>state.paths;
+const limitFilesSync = (state)=>state.paths.slice(0, state.options.maxFiles);
+const onlyCountsAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.counts, state.options.suppressErrors);
+    return null;
+};
+const defaultAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.paths, state.options.suppressErrors);
+    return null;
+};
+const limitFilesAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+    return null;
+};
+const groupsAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.groups, state.options.suppressErrors);
+    return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+    callback$1(error && !suppressErrors ? error : null, output);
+}
+function build$1(options, isSynchronous) {
+    const { onlyCounts, group, maxFiles } = options;
+    if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+    if (group) return isSynchronous ? groupsSync : groupsAsync;
+    if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+    return isSynchronous ? defaultSync : defaultAsync;
+}
+const readdirOpts = {
+    withFileTypes: true
+};
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    state.queue.enqueue();
+    if (currentDepth < 0) return state.queue.dequeue(null, state);
+    const { fs } = state;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    fs.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
+        callback$1(entries, directoryPath, currentDepth);
+        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+    });
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    const { fs } = state;
+    if (currentDepth < 0) return;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+    } catch (e) {
+        if (!state.options.suppressErrors) throw e;
+    }
+    callback$1(entries, directoryPath, currentDepth);
+};
+function dist_build(isSynchronous) {
+    return isSynchronous ? walkSync : walkAsync;
+}
+var Queue = class {
+    count = 0;
+    constructor(onQueueEmpty){
+        this.onQueueEmpty = onQueueEmpty;
+    }
+    enqueue() {
+        this.count++;
+        return this.count;
+    }
+    dequeue(error, output) {
+        if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+            this.onQueueEmpty(error, output);
+            if (error) {
+                output.controller.abort();
+                this.onQueueEmpty = void 0;
+            }
+        }
+    }
+};
+var Counter = class {
+    _files = 0;
+    _directories = 0;
+    set files(num) {
+        this._files = num;
+    }
+    get files() {
+        return this._files;
+    }
+    set directories(num) {
+        this._directories = num;
+    }
+    get directories() {
+        return this._directories;
+    }
+    get dirs() {
+        return this._directories;
+    }
+};
+var Aborter = class {
+    aborted = false;
+    abort() {
+        this.aborted = true;
+    }
+};
+var Walker = class {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(root, options, callback$1){
+        this.isSynchronous = !callback$1;
+        this.callbackInvoker = build$1(options, this.isSynchronous);
+        this.root = normalizePath(root, options);
+        this.state = {
+            root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+            paths: [
+                ""
+            ].slice(0, 0),
+            groups: [],
+            counts: new Counter(),
+            options,
+            queue: new Queue((error, state)=>this.callbackInvoker(state, error, callback$1)),
+            symlinks: /* @__PURE__ */ new Map(),
+            visited: [
+                ""
+            ].slice(0, 0),
+            controller: new Aborter(),
+            fs: options.fs || __rspack_external_fs
+        };
+        this.joinPath = build$7(this.root, options);
+        this.pushDirectory = build$6(this.root, options);
+        this.pushFile = build$5(options);
+        this.getArray = build$4(options);
+        this.groupFiles = build$3(options);
+        this.resolveSymlink = build$2(options, this.isSynchronous);
+        this.walkDirectory = dist_build(this.isSynchronous);
+    }
+    start() {
+        this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (entries, directoryPath, depth)=>{
+        const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+        if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+        const files = this.getArray(this.state.paths);
+        for(let i = 0; i < entries.length; ++i){
+            const entry = entries[i];
+            if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+                const filename = this.joinPath(entry.name, directoryPath);
+                this.pushFile(filename, files, this.state.counts, filters);
+            } else if (entry.isDirectory()) {
+                let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                if (exclude && exclude(entry.name, path)) continue;
+                this.pushDirectory(path, paths, filters);
+                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+            } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+                let path = joinPathWithBasePath(entry.name, directoryPath);
+                this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
+                    if (stat.isDirectory()) {
+                        resolvedPath = normalizePath(resolvedPath, this.state.options);
+                        if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                    } else {
+                        resolvedPath = useRealPaths ? resolvedPath : path;
+                        const filename = basename(resolvedPath);
+                        const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+                        resolvedPath = this.joinPath(filename, directoryPath$1);
+                        this.pushFile(resolvedPath, files, this.state.counts, filters);
+                    }
+                });
+            }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+    };
+};
+function promise(root, options) {
+    return new Promise((resolve$1, reject)=>{
+        callback(root, options, (err, output)=>{
+            if (err) return reject(err);
+            resolve$1(output);
+        });
+    });
+}
+function callback(root, options, callback$1) {
+    let walker = new Walker(root, options, callback$1);
+    walker.start();
+}
+function sync(root, options) {
+    const walker = new Walker(root, options);
+    return walker.start();
+}
+var APIBuilder = class {
+    constructor(root, options){
+        this.root = root;
+        this.options = options;
+    }
+    withPromise() {
+        return promise(this.root, this.options);
+    }
+    withCallback(cb) {
+        callback(this.root, this.options, cb);
+    }
+    sync() {
+        return sync(this.root, this.options);
+    }
+};
+let pm = null;
+try {
+    __require.resolve("picomatch");
+    pm = __require("picomatch");
+} catch  {}
+var Builder = class {
+    globCache = {};
+    options = {
+        maxDepth: 1 / 0,
+        suppressErrors: true,
+        pathSeparator: sep,
+        filters: []
+    };
+    globFunction;
+    constructor(options){
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        this.globFunction = this.options.globFunction;
+    }
+    group() {
+        this.options.group = true;
+        return this;
+    }
+    withPathSeparator(separator) {
+        this.options.pathSeparator = separator;
+        return this;
+    }
+    withBasePath() {
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withRelativePaths() {
+        this.options.relativePaths = true;
+        return this;
+    }
+    withDirs() {
+        this.options.includeDirs = true;
+        return this;
+    }
+    withMaxDepth(depth) {
+        this.options.maxDepth = depth;
+        return this;
+    }
+    withMaxFiles(limit) {
+        this.options.maxFiles = limit;
+        return this;
+    }
+    withFullPaths() {
+        this.options.resolvePaths = true;
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withErrors() {
+        this.options.suppressErrors = false;
+        return this;
+    }
+    withSymlinks({ resolvePaths = true } = {}) {
+        this.options.resolveSymlinks = true;
+        this.options.useRealPaths = resolvePaths;
+        return this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        this.options.signal = signal;
+        return this;
+    }
+    normalize() {
+        this.options.normalizePath = true;
+        return this;
+    }
+    filter(predicate) {
+        this.options.filters.push(predicate);
+        return this;
+    }
+    onlyDirs() {
+        this.options.excludeFiles = true;
+        this.options.includeDirs = true;
+        return this;
+    }
+    exclude(predicate) {
+        this.options.exclude = predicate;
+        return this;
+    }
+    onlyCounts() {
+        this.options.onlyCounts = true;
+        return this;
+    }
+    crawl(root) {
+        return new APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        this.globFunction = fn;
+        return this;
+    }
+    crawlWithOptions(root, options) {
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        return new APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        if (this.globFunction) return this.globWithOptions(patterns);
+        return this.globWithOptions(patterns, {
+            dot: true
+        });
+    }
+    globWithOptions(patterns, ...options) {
+        const globFn = this.globFunction || pm;
+        if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+        var isMatch = this.globCache[patterns.join("\0")];
+        if (!isMatch) {
+            isMatch = globFn(patterns, ...options);
+            this.globCache[patterns.join("\0")] = isMatch;
+        }
+        this.options.filters.push((path)=>isMatch(path));
+        return this;
+    }
+};
+const isReadonlyArray = Array.isArray;
+const isWin = "win32" === process.platform;
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+    const patternsCount = patterns.length;
+    const patternsParts = Array(patternsCount);
+    const matchers = Array(patternsCount);
+    const globstarEnabled = !options.noglobstar;
+    for(let i = 0; i < patternsCount; i++){
+        const parts = splitPattern(patterns[i]);
+        patternsParts[i] = parts;
+        const partsCount = parts.length;
+        const partMatchers = Array(partsCount);
+        for(let j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
+        matchers[i] = partMatchers;
+    }
+    return (input)=>{
+        const inputParts = input.split("/");
+        if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+        for(let i = 0; i < patterns.length; i++){
+            const patternParts = patternsParts[i];
+            const matcher = matchers[i];
+            const inputPatternCount = inputParts.length;
+            const minParts = Math.min(inputPatternCount, patternParts.length);
+            let j = 0;
+            while(j < minParts){
+                const part = patternParts[j];
+                if (part.includes("/")) return true;
+                const match = matcher[j](inputParts[j]);
+                if (!match) break;
+                if (globstarEnabled && "**" === part) return true;
+                j++;
+            }
+            if (j === inputPatternCount) return true;
+        }
+        return false;
+    };
+}
+const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+const isRoot = isWin ? (p)=>WIN32_ROOT_DIR.test(p) : (p)=>"/" === p;
+function buildFormat(cwd, root, absolute) {
+    if (cwd === root || root.startsWith(`${cwd}/`)) {
+        if (absolute) {
+            const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+            return (p, isDir)=>p.slice(start, isDir ? -1 : void 0) || ".";
+        }
+        const prefix = root.slice(cwd.length + 1);
+        if (prefix) return (p, isDir)=>{
+            if ("." === p) return prefix;
+            const result = `${prefix}/${p}`;
+            return isDir ? result.slice(0, -1) : result;
+        };
+        return (p, isDir)=>isDir && "." !== p ? p.slice(0, -1) : p;
+    }
+    if (absolute) return (p)=>posix.relative(cwd, p) || ".";
+    return (p)=>posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+    if (root.startsWith(`${cwd}/`)) {
+        const prefix = root.slice(cwd.length + 1);
+        return (p)=>`${prefix}/${p}`;
+    }
+    return (p)=>{
+        const result = posix.relative(cwd, `${root}/${p}`);
+        if (p.endsWith("/") && "" !== result) return `${result}/`;
+        return result || ".";
+    };
+}
+const splitPatternOptions = {
+    parts: true
+};
+function splitPattern(path$1) {
+    var _result$parts;
+    const result = picomatch.scan(path$1, splitPatternOptions);
+    return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
+        path$1
+    ];
+}
+const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path$1) {
+    return escapePosixPath(path$1);
+}
+function convertWin32PathToPattern(path$1) {
+    return escapeWin32Path(path$1).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$1)=>path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1)=>path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+    if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
+    const scan = picomatch.scan(pattern);
+    return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+    console.log(`[tinyglobby ${/* @__PURE__ */ new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+    let result = pattern;
+    if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+    if (!result.endsWith("*") && expandDirectories) result += "/**";
+    const escapedCwd = escapePath(cwd);
+    result = path_0.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+    const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+    const parts = splitPattern(result);
+    if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
+        const n = (parentDirectoryMatch[0].length + 1) / 3;
+        let i = 0;
+        const cwdParts = escapedCwd.split("/");
+        while(i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]){
+            result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+            i++;
+        }
+        const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
+        if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+            props.root = potentialRoot;
+            props.depthOffset = -n + i;
+        }
+    }
+    if (!isIgnore && props.depthOffset >= 0) {
+        null != props.commonPath || (props.commonPath = parts);
+        const newCommonPath = [];
+        const length = Math.min(props.commonPath.length, parts.length);
+        for(let i = 0; i < length; i++){
+            const part = parts[i];
+            if ("**" === part && !parts[i + 1]) {
+                newCommonPath.pop();
+                break;
+            }
+            if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+            newCommonPath.push(part);
+        }
+        props.depthOffset = newCommonPath.length;
+        props.commonPath = newCommonPath;
+        props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
+    }
+    return result;
+}
+function processPatterns({ patterns = [
+    "**/*"
+], ignore = [], expandDirectories = true }, cwd, props) {
+    if ("string" == typeof patterns) patterns = [
+        patterns
+    ];
+    if ("string" == typeof ignore) ignore = [
+        ignore
+    ];
+    const matchPatterns = [];
+    const ignorePatterns = [];
+    for (const pattern of ignore)if (pattern) {
+        if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+    }
+    for (const pattern of patterns)if (pattern) {
+        if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
+        else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+    }
+    return {
+        match: matchPatterns,
+        ignore: ignorePatterns
+    };
+}
+function formatPaths(paths, relative) {
+    for(let i = paths.length - 1; i >= 0; i--){
+        const path$1 = paths[i];
+        paths[i] = relative(path$1);
+    }
+    return paths;
+}
+function normalizeCwd(cwd) {
+    if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+    if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
+    return path_0.resolve(cwd).replace(BACKSLASHES, "/");
+}
+function getCrawler(patterns, inputOptions = {}) {
+    const options = process.env.TINYGLOBBY_DEBUG ? {
+        ...inputOptions,
+        debug: true
+    } : inputOptions;
+    const cwd = normalizeCwd(options.cwd);
+    if (options.debug) log("globbing with:", {
+        patterns,
+        options,
+        cwd
+    });
+    if (Array.isArray(patterns) && 0 === patterns.length) return [
+        {
+            sync: ()=>[],
+            withPromise: async ()=>[]
+        },
+        false
+    ];
+    const props = {
+        root: cwd,
+        commonPath: null,
+        depthOffset: 0
+    };
+    const processed = processPatterns({
+        ...options,
+        patterns
+    }, cwd, props);
+    if (options.debug) log("internal processing patterns:", processed);
+    const matchOptions = {
+        dot: options.dot,
+        nobrace: false === options.braceExpansion,
+        nocase: false === options.caseSensitiveMatch,
+        noextglob: false === options.extglob,
+        noglobstar: false === options.globstar,
+        posix: true
+    };
+    const matcher = picomatch(processed.match, {
+        ...matchOptions,
+        ignore: processed.ignore
+    });
+    const ignore = picomatch(processed.ignore, matchOptions);
+    const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+    const format = buildFormat(cwd, props.root, options.absolute);
+    const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
+    const fdirOptions = {
+        filters: [
+            options.debug ? (p, isDirectory)=>{
+                const path$1 = format(p, isDirectory);
+                const matches = matcher(path$1);
+                if (matches) log(`matched ${path$1}`);
+                return matches;
+            } : (p, isDirectory)=>matcher(format(p, isDirectory))
+        ],
+        exclude: options.debug ? (_, p)=>{
+            const relativePath = formatExclude(p, true);
+            const skipped = "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+            skipped ? log(`skipped ${p}`) : log(`crawling ${p}`);
+            return skipped;
+        } : (_, p)=>{
+            const relativePath = formatExclude(p, true);
+            return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+        },
+        fs: options.fs ? {
+            readdir: options.fs.readdir || fs_0.readdir,
+            readdirSync: options.fs.readdirSync || fs_0.readdirSync,
+            realpath: options.fs.realpath || fs_0.realpath,
+            realpathSync: options.fs.realpathSync || fs_0.realpathSync,
+            stat: options.fs.stat || fs_0.stat,
+            statSync: options.fs.statSync || fs_0.statSync
+        } : void 0,
+        pathSeparator: "/",
+        relativePaths: true,
+        resolveSymlinks: true,
+        signal: options.signal
+    };
+    if (void 0 !== options.deep) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+    if (options.absolute) {
+        fdirOptions.relativePaths = false;
+        fdirOptions.resolvePaths = true;
+        fdirOptions.includeBasePath = true;
+    }
+    if (false === options.followSymbolicLinks) {
+        fdirOptions.resolveSymlinks = false;
+        fdirOptions.excludeSymlinks = true;
+    }
+    if (options.onlyDirectories) {
+        fdirOptions.excludeFiles = true;
+        fdirOptions.includeDirs = true;
+    } else if (false === options.onlyFiles) fdirOptions.includeDirs = true;
+    props.root = props.root.replace(BACKSLASHES, "");
+    const root = props.root;
+    if (options.debug) log("internal properties:", props);
+    const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+    return [
+        new Builder(fdirOptions).crawl(root),
+        relative
+    ];
+}
+async function glob(patternsOrOptions, options) {
+    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+    const isModern = isReadonlyArray(patternsOrOptions) || "string" == typeof patternsOrOptions;
+    const opts = isModern ? options : patternsOrOptions;
+    const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+    const [crawler, relative] = getCrawler(patterns, opts);
+    if (!relative) return crawler.withPromise();
+    return formatPaths(await crawler.withPromise(), relative);
+}
+function createPathIdentity(paths, caseSensitive) {
+    const normalize = (filePath)=>{
+        let normalized = paths.normalize(filePath);
+        const root = paths.parse(normalized).root;
+        while(normalized.length > root.length && normalized.endsWith(paths.sep))normalized = normalized.slice(0, -1);
+        return normalized;
+    };
+    const key = (filePath)=>{
+        const normalized = normalize(filePath);
+        return caseSensitive ? normalized : normalized.toLowerCase();
+    };
+    return {
+        paths,
+        key,
+        normalize,
+        equals: (left, right)=>key(left) === key(right),
+        isSameOrChild: (parent, child)=>{
+            const parentKey = key(parent);
+            const childKey = key(child);
+            if (parentKey === childKey) return true;
+            const prefix = parentKey.endsWith(paths.sep) ? parentKey : `${parentKey}${paths.sep}`;
+            return childKey.startsWith(prefix);
+        },
+        compare: (left, right)=>key(left).localeCompare(key(right)) || normalize(left).localeCompare(normalize(right))
+    };
+}
+const nativePathIdentity = createPathIdentity(node_path, true);
+async function realpathNative(filePath) {
+    const resolvedPath = await new Promise((resolve, reject)=>{
+        node_fs.realpath.native(filePath, (error, resolvedPath)=>{
+            if (error) reject(error);
+            else resolve(resolvedPath);
+        });
+    });
+    return resolvedPath;
+}
+class RunPathResolver {
+    #resolved = new Map();
+    async resolve(filePath) {
+        const resolved = await this.#resolveState(filePath);
+        return resolved;
+    }
+    async #resolveState(filePath) {
+        const lexicalPath = nativePathIdentity.normalize(filePath);
+        const lexicalKey = nativePathIdentity.key(lexicalPath);
+        let pending = this.#resolved.get(lexicalKey);
+        if (!pending) {
+            pending = (async ()=>{
+                let canonicalPath = lexicalPath;
+                let physicallyResolved = false;
+                try {
+                    canonicalPath = nativePathIdentity.normalize(await realpathNative(lexicalPath));
+                    physicallyResolved = true;
+                } catch  {}
+                return {
+                    lexicalPath,
+                    lexicalKey,
+                    canonicalPath,
+                    canonicalKey: nativePathIdentity.key(canonicalPath),
+                    physicallyResolved
+                };
+            })();
+            this.#resolved.set(lexicalKey, pending);
+        }
+        const resolved = await pending;
+        return resolved;
+    }
+    async resolveWithAncestorFallback(filePath) {
+        const exact = await this.#resolveState(filePath);
+        if (exact.physicallyResolved) return exact;
+        const suffix = [];
+        let current = exact.lexicalPath;
+        while(true){
+            const parent = node_path.dirname(current);
+            if (nativePathIdentity.equals(parent, current)) return exact;
+            suffix.unshift(node_path.basename(current));
+            const resolvedParent = await this.#resolveState(parent);
+            if (resolvedParent.physicallyResolved) {
+                const canonicalPath = nativePathIdentity.normalize(node_path.resolve(resolvedParent.canonicalPath, ...suffix));
+                return {
+                    lexicalPath: exact.lexicalPath,
+                    lexicalKey: exact.lexicalKey,
+                    canonicalPath,
+                    canonicalKey: nativePathIdentity.key(canonicalPath)
+                };
+            }
+            current = parent;
+        }
+    }
+    async resolveAll(filePaths, concurrency = 32) {
+        const results = new Array(filePaths.length);
+        let next = 0;
+        const worker = async ()=>{
+            while(true){
+                const index = next++;
+                if (index >= filePaths.length) return;
+                results[index] = await this.resolve(filePaths[index]);
+            }
+        };
+        const workerCount = Math.min(filePaths.length, Math.max(1, Math.floor(concurrency)));
+        await Promise.all(Array.from({
+            length: workerCount
+        }, worker));
+        return results;
+    }
+}
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function isPluginHostFactoryModule(value) {
+    return isRecord(value) && 'function' == typeof value.createPluginLintHost;
+}
+function isPluginLintHost(value) {
+    return isRecord(value) && 'function' == typeof value.lint && 'function' == typeof value.shutdown;
+}
+let pluginHostFactoryPromise;
+async function loadPluginHostFactory() {
+    pluginHostFactoryPromise ??= (async ()=>{
+        const pluginEntry = '@rslint/core/eslint-plugin';
+        const module = await import(pluginEntry);
+        if (!isPluginHostFactoryModule(module)) throw new Error('rslint ESLint-plugin entry does not export createPluginLintHost');
+        return module.createPluginLintHost;
+    })();
+    const factory = await pluginHostFactoryPromise;
+    return factory;
+}
+class PluginHostLifecycle {
+    #pendingBuilds = new Set();
+    #staged = new Set();
+    #active = new Set();
+    #shutdowns = new WeakMap();
+    async trackBuild(build) {
+        this.#pendingBuilds.add(build);
+        build.then(()=>this.#pendingBuilds.delete(build), ()=>this.#pendingBuilds.delete(build));
+        const result = await build;
+        return result;
+    }
+    stage(host) {
+        this.#staged.add(host);
+    }
+    publish(host) {
+        this.#staged.delete(host);
+        this.#active.add(host);
+    }
+    async shutdown(host) {
+        this.#staged.delete(host);
+        this.#active.delete(host);
+        let shutdown = this.#shutdowns.get(host);
+        if (!shutdown) {
+            shutdown = host.shutdown();
+            this.#shutdowns.set(host, shutdown);
+        }
+        await shutdown;
+    }
+    async shutdownAll() {
+        while(this.#pendingBuilds.size > 0)await Promise.allSettled([
+            ...this.#pendingBuilds
+        ]);
+        const shutdowns = [];
+        for (const host of new Set([
+            ...this.#staged,
+            ...this.#active
+        ]))shutdowns.push(this.shutdown(host));
+        await Promise.allSettled(shutdowns);
+    }
+}
+async function stageNativeConfigActivation(configHost, request, getPluginHostFactory, onLog, isClosing, lifecycle) {
+    let pluginHost = null;
+    try {
+        const activation = await configHost.activateConfigs(request, void 0, async (candidate)=>{
+            if (0 === candidate.pluginConfigs.length) return;
+            if (isClosing()) throw new Error('rslint service is closing');
+            const createPluginLintHost = await getPluginHostFactory();
+            if (isClosing()) throw new Error('rslint service is closing');
+            const build = (async ()=>{
+                const host = await createPluginLintHost(candidate.pluginConfigs, onLog);
+                lifecycle?.stage(host);
+                return host;
+            })();
+            pluginHost = await (lifecycle?.trackBuild(build) ?? build);
+            if (isClosing()) throw new Error('rslint service is closing');
+        });
+        if (isClosing()) throw new Error('rslint service is closing');
+        return {
+            activation,
+            pluginHost
+        };
+    } catch (error) {
+        try {
+            const createdHost = pluginHost;
+            if (isPluginLintHost(createdHost)) await (lifecycle?.shutdown(createdHost) ?? createdHost.shutdown());
+        } catch  {}
+        throw error;
+    }
+}
 function _to_primitive(input, hint) {
     if ("object" !== _type_of(input) || null === input) return input;
     var prim = input[Symbol.toPrimitive];
@@ -516,6 +1514,105 @@ function _type_of(obj) {
     return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 let _computedKey;
+function rslint_isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function globPatternRole(pattern) {
+    if ('!' !== pattern[0] || '(' === pattern[1]) return 'match';
+    if ('!' !== pattern[1] || '(' === pattern[2]) return 'ignore';
+    return 'skip';
+}
+const DEFAULT_LINT_GLOB_IGNORES = [
+    '**/node_modules/**',
+    '**/.git/**'
+];
+function staticGlobRoot(pattern, cwd) {
+    const absolutePattern = node_path.resolve(cwd, pattern);
+    const root = node_path.parse(absolutePattern).root;
+    const segments = absolutePattern.slice(root.length).split(node_path.sep);
+    let current = root;
+    for (const segment of segments){
+        if (!segment || isDynamicPattern(segment)) break;
+        current = node_path.join(current, segment);
+    }
+    return current || cwd;
+}
+function deduplicateScanDirectories(directories) {
+    const byIdentity = new Map();
+    for (const directory of directories){
+        const normalized = node_path.normalize(directory);
+        const key = nativePathIdentity.key(normalized);
+        if (!byIdentity.has(key)) byIdentity.set(key, normalized);
+    }
+    return [
+        ...byIdentity.values()
+    ].sort(nativePathIdentity.compare);
+}
+function normalizeGlobPatternForCwd(pattern, cwd) {
+    let normalized = pattern;
+    if (normalized.endsWith('/') || normalized.endsWith('\\')) normalized = normalized.slice(0, -1);
+    if (node_path.isAbsolute(normalized)) normalized = node_path.relative(cwd, normalized);
+    normalized = normalized.split(node_path.sep).join('/');
+    return node_path.posix.normalize(normalized);
+}
+function matchesExcludedLiteral(filePath, patterns, cwd) {
+    const candidate = node_path.relative(cwd, filePath).split(node_path.sep).join('/');
+    for (const rawPattern of patterns){
+        let pattern = rawPattern;
+        if (pattern.startsWith('!')) {
+            if ('(' === pattern[1]) continue;
+            if ('!' === pattern[1] && '(' !== pattern[2]) continue;
+            pattern = pattern.slice(1);
+        }
+        pattern = normalizeGlobPatternForCwd(pattern, cwd);
+        const expandedPatterns = pattern.endsWith('*') ? [
+            pattern
+        ] : [
+            pattern,
+            `${pattern}/**`
+        ];
+        if (picomatch(expandedPatterns, {
+            dot: true,
+            nocase: false
+        })(candidate)) return true;
+    }
+    return false;
+}
+async function classifyLintPatterns(patterns, cwd) {
+    const literalFilePatterns = [];
+    const literalDirectorySymlinks = [];
+    const scanDirectories = new Set();
+    const excludedLiteralPatterns = [
+        ...DEFAULT_LINT_GLOB_IGNORES,
+        ...patterns.filter((pattern)=>'ignore' === globPatternRole(pattern))
+    ];
+    for (const pattern of patterns){
+        if ('match' !== globPatternRole(pattern)) continue;
+        if (isDynamicPattern(pattern)) {
+            const scanRoot = staticGlobRoot(pattern, cwd);
+            try {
+                if ((await promises_stat(scanRoot)).isDirectory()) scanDirectories.add(scanRoot);
+            } catch  {}
+            continue;
+        }
+        const absolute = node_path.resolve(cwd, pattern);
+        try {
+            const info = await promises_stat(absolute);
+            if (info.isDirectory()) {
+                scanDirectories.add(absolute);
+                if ((await lstat(absolute)).isSymbolicLink()) literalDirectorySymlinks.push(absolute);
+            } else if (info.isFile()) {
+                const absolutePattern = node_path.resolve(cwd, pattern);
+                if (!matchesExcludedLiteral(absolutePattern, excludedLiteralPatterns, cwd)) literalFilePatterns.push(absolutePattern);
+            }
+        } catch  {}
+    }
+    return {
+        literalFilePatterns,
+        literalDirectorySymlinks,
+        scanDirectories: deduplicateScanDirectories(scanDirectories)
+    };
+}
 _computedKey = _to_property_key(Symbol.asyncDispose);
 class Rslint {
     #service;
@@ -524,6 +1621,10 @@ class Rslint {
     #overrideConfigFile;
     #fix;
     #virtualFiles;
+    #pluginHosts = new PluginHostLifecycle();
+    #normalizedOverrideConfig;
+    #closeRequested = false;
+    #closePromise;
     constructor(options = {}){
         this.#cwd = options.cwd ? node_path.resolve(options.cwd) : process.cwd();
         this.#overrideConfig = options.overrideConfig;
@@ -534,65 +1635,132 @@ class Rslint {
     }
     async lintText(code, options = {}) {
         const filePath = node_path.resolve(this.#cwd, options.filePath ?? '__text__.ts');
-        const { config, configDirectory } = await this.#resolveConfig(node_path.dirname(filePath));
-        const response = await this.#service.lint({
-            config,
-            configDirectory,
-            workingDirectory: this.#cwd,
-            files: [
+        const pathResolver = new RunPathResolver();
+        const resolvedFile = await pathResolver.resolveWithAncestorFallback(filePath);
+        const overrideConfig = this.#getNormalizedOverrideConfig() ?? [];
+        const usesNativeDiscovery = true !== this.#overrideConfigFile;
+        const discoverySession = usesNativeDiscovery ? this.#createNativeConfigDiscoverySession() : null;
+        try {
+            const response = await this.#service.lint({
+                config: usesNativeDiscovery ? void 0 : overrideConfig,
+                configDiscovery: usesNativeDiscovery ? {
+                    explicitConfigPath: 'string' == typeof this.#overrideConfigFile ? node_path.resolve(this.#cwd, this.#overrideConfigFile) : void 0,
+                    explicitFiles: [
+                        true
+                    ],
+                    overrideConfig
+                } : void 0,
+                configDirectory: usesNativeDiscovery ? void 0 : this.#cwd,
+                workingDirectory: this.#cwd,
+                files: [
+                    filePath
+                ],
+                canonicalFiles: [
+                    resolvedFile.canonicalPath
+                ],
+                fileContents: {
+                    ...this.#resolveOverlay(),
+                    [filePath]: code
+                },
+                fix: this.#fix
+            }, discoverySession?.handlers ?? {});
+            const results = this.#toLintResults(response, this.#cwd, [
                 filePath
-            ],
-            fileContents: {
-                ...this.#resolveOverlay(),
+            ], {
                 [filePath]: code
-            },
-            fix: this.#fix
-        });
-        const results = this.#toLintResults(response, configDirectory, [
-            filePath
-        ], {
-            [filePath]: code
-        });
-        const primary = results.filter((r)=>r.filePath === filePath);
-        if (null == options.filePath) {
-            for (const r of primary)if (r.filePath === filePath) r.filePath = '<text>';
+            });
+            const primary = results.filter((r)=>nativePathIdentity.equals(r.filePath, filePath));
+            if (null == options.filePath) {
+                for (const r of primary)if (nativePathIdentity.equals(r.filePath, filePath)) r.filePath = '<text>';
+            }
+            return primary;
+        } finally{
+            await discoverySession?.shutdown();
         }
-        return primary;
     }
     async lintFiles(patterns) {
         const globs = Array.isArray(patterns) ? patterns : [
             patterns
         ];
-        const matched = await glob(globs, {
+        const { literalFilePatterns, literalDirectorySymlinks, scanDirectories } = await classifyLintPatterns(globs, this.#cwd);
+        const globOptions = {
             cwd: this.#cwd,
             absolute: true,
-            onlyFiles: true
+            onlyFiles: true,
+            dot: true,
+            ignore: DEFAULT_LINT_GLOB_IGNORES
+        };
+        const matched = await glob(globs, {
+            ...globOptions,
+            followSymbolicLinks: false
         });
-        const files = matched.map((f)=>node_path.normalize(f));
-        if (0 === files.length) return [];
-        const { config, configDirectory } = await this.#resolveConfig(this.#cwd);
-        const response = await this.#service.lint({
-            config,
-            configDirectory,
-            workingDirectory: this.#cwd,
-            files,
-            fileContents: this.#resolveOverlay(),
-            fix: this.#fix
+        const directorySymlinkMatches = 0 === literalDirectorySymlinks.length ? [] : await glob([
+            ...literalDirectorySymlinks.map((directory)=>`${convertPathToPattern(directory)}/**/*`),
+            ...globs.filter((pattern)=>pattern.startsWith('!'))
+        ], {
+            ...globOptions,
+            followSymbolicLinks: false
         });
-        const contents = {};
-        const bomFiles = new Set();
-        for (const d of response.diagnostics ?? []){
-            const abs = node_path.isAbsolute(d.filePath) ? node_path.normalize(d.filePath) : node_path.resolve(configDirectory, d.filePath);
-            if (!(abs in contents)) try {
-                const raw = await readFile(abs, 'utf8');
-                if (0xfeff === raw.charCodeAt(0)) {
-                    bomFiles.add(abs);
-                    contents[abs] = raw.slice(1);
-                } else contents[abs] = raw;
-            } catch  {}
+        const literalMatches = literalFilePatterns;
+        const filesByIdentity = new Map();
+        for (const file of [
+            ...matched,
+            ...directorySymlinkMatches
+        ]){
+            const normalized = node_path.normalize(file);
+            const key = nativePathIdentity.key(normalized);
+            if (!filesByIdentity.has(key)) filesByIdentity.set(key, {
+                filePath: normalized,
+                explicit: false
+            });
+        }
+        for (const file of literalMatches){
+            const normalized = node_path.normalize(file);
+            const key = nativePathIdentity.key(normalized);
+            filesByIdentity.set(key, {
+                filePath: normalized,
+                explicit: true
+            });
+        }
+        const lexicalFiles = [
+            ...filesByIdentity.values()
+        ];
+        if (0 === lexicalFiles.length) return [];
+        const pathResolver = new RunPathResolver();
+        const resolvedPaths = await pathResolver.resolveAll(lexicalFiles.map(({ filePath })=>filePath));
+        const plannedFiles = resolvedPaths.map((resolved, index)=>({
+                ...resolved,
+                explicit: lexicalFiles[index].explicit
+            }));
+        const selectedFiles = [
+            ...plannedFiles
+        ].sort((left, right)=>nativePathIdentity.compare(left.lexicalPath, right.lexicalPath));
+        const overrideConfig = this.#getNormalizedOverrideConfig() ?? [];
+        const usesNativeDiscovery = true !== this.#overrideConfigFile;
+        const discoverySession = usesNativeDiscovery ? this.#createNativeConfigDiscoverySession() : null;
+        try {
+            const files = selectedFiles.map((file)=>file.lexicalPath);
+            const response = await this.#service.lint({
+                config: usesNativeDiscovery ? void 0 : overrideConfig,
+                configDiscovery: usesNativeDiscovery ? {
+                    explicitConfigPath: 'string' == typeof this.#overrideConfigFile ? node_path.resolve(this.#cwd, this.#overrideConfigFile) : void 0,
+                    directories: scanDirectories,
+                    explicitFiles: selectedFiles.map((file)=>file.explicit),
+                    overrideConfig
+                } : void 0,
+                configDirectory: usesNativeDiscovery ? void 0 : this.#cwd,
+                workingDirectory: this.#cwd,
+                files,
+                canonicalFiles: selectedFiles.map((file)=>file.canonicalPath),
+                fileContents: this.#resolveOverlay(),
+                fix: this.#fix
+            }, discoverySession?.handlers ?? {});
+            const { contents, bomFiles } = await this.#readDiagnosticContents(response, this.#cwd);
+            const linted = response.lintedFiles ? response.lintedFiles.map((file)=>node_path.isAbsolute(file) ? node_path.normalize(file) : node_path.resolve(this.#cwd, file)) : files;
+            return this.#toLintResults(response, this.#cwd, linted, contents, bomFiles).sort((a, b)=>nativePathIdentity.compare(a.filePath, b.filePath));
+        } finally{
+            await discoverySession?.shutdown();
         }
-        const linted = response.lintedFiles ? response.lintedFiles.map((f)=>node_path.isAbsolute(f) ? node_path.normalize(f) : node_path.resolve(configDirectory, f)) : files;
-        return this.#toLintResults(response, configDirectory, linted, contents, bomFiles);
     }
     static async outputFixes(results) {
         await Promise.all(results.map(async (r)=>{
@@ -600,7 +1768,17 @@ class Rslint {
         }));
     }
     async close() {
-        await this.#service.close();
+        this.#closePromise ??= this.#closeResources();
+        await this.#closePromise;
+    }
+    async #closeResources() {
+        this.#closeRequested = true;
+        await this.#pluginHosts.shutdownAll();
+        try {
+            await this.#service.close();
+        } finally{
+            await this.#pluginHosts.shutdownAll();
+        }
     }
     async [_computedKey]() {
         await this.close();
@@ -611,52 +1789,109 @@ class Rslint {
         for (const [p, content] of Object.entries(this.#virtualFiles))resolved[node_path.resolve(this.#cwd, p)] = content;
         return resolved;
     }
-    async #resolveConfig(fromDir) {
-        let base = [];
-        let configDirectory = this.#cwd;
-        if (true === this.#overrideConfigFile) ;
-        else if ('string' == typeof this.#overrideConfigFile) {
-            const configPath = node_path.resolve(this.#cwd, this.#overrideConfigFile);
-            base = normalizeConfig(await loadConfigFile(configPath));
-            configDirectory = node_path.dirname(configPath);
-        } else {
-            const configPath = findJSConfigUp(fromDir);
-            if (configPath) {
-                base = normalizeConfig(await loadConfigFile(configPath));
-                configDirectory = node_path.dirname(configPath);
-            }
+    #createNativeConfigDiscoverySession() {
+        const configHost = new ConfigModuleHost();
+        const transactions = new Set();
+        let pluginSession = null;
+        const shutdown = async ()=>{
+            if (pluginSession) await this.#pluginHosts.shutdown(pluginSession.host);
+            pluginSession = null;
+            for (const transactionId of transactions)configHost.deleteSession(transactionId);
+            transactions.clear();
+        };
+        return {
+            handlers: {
+                loadConfigs: async (request)=>{
+                    const response = await configHost.loadConfigs(request);
+                    transactions.add(request.transactionId);
+                    return response;
+                },
+                activateConfigs: async (request)=>{
+                    const { activation, pluginHost } = await stageNativeConfigActivation(configHost, request, loadPluginHostFactory, (record)=>{
+                        process.stderr.write(`[rslint:plugin] ${record.text}\n`);
+                    }, ()=>this.#closeRequested, this.#pluginHosts);
+                    if (pluginHost) {
+                        if (this.#closeRequested) {
+                            await this.#pluginHosts.shutdown(pluginHost);
+                            throw new Error('rslint service is closing');
+                        }
+                        this.#pluginHosts.publish(pluginHost);
+                        pluginSession = {
+                            host: pluginHost
+                        };
+                    }
+                    return activation;
+                },
+                pluginLint: async (request)=>{
+                    if (!pluginSession) throw new Error('rslint API: pluginLint requested without an activated plugin host');
+                    return pluginSession.host.lint(request);
+                }
+            },
+            shutdown
+        };
+    }
+    #getNormalizedOverrideConfig() {
+        if (null == this.#overrideConfig) return null;
+        if (this.#normalizedOverrideConfig) return this.#normalizedOverrideConfig;
+        const override = Array.isArray(this.#overrideConfig) ? this.#overrideConfig : [
+            this.#overrideConfig
+        ];
+        for (const [index, entry] of override.entries()){
+            if (null == entry || 'object' != typeof entry || Array.isArray(entry)) continue;
+            const plugins = rslint_isRecord(entry) ? entry.plugins : void 0;
+            if (null !== plugins && 'object' == typeof plugins && !Array.isArray(plugins)) throw new Error(`[rslint] overrideConfig entry at index ${index} uses object-form "plugins". Community ESLint plugins in overrideConfig are not supported because the plugin worker cannot re-import an in-memory plugin object. Move the plugin declaration to rslint.config.js (or .mjs/.cjs/.ts/.mts/.cts), or use array-form built-in plugins.`);
         }
-        if (null != this.#overrideConfig) {
-            const override = Array.isArray(this.#overrideConfig) ? this.#overrideConfig : [
-                this.#overrideConfig
-            ];
-            base = [
-                ...base,
-                ...normalizeConfig(override)
-            ];
+        this.#normalizedOverrideConfig = normalizeConfig(override);
+        return this.#normalizedOverrideConfig;
+    }
+    async #readDiagnosticContents(response, configDirectory) {
+        const contents = {};
+        const bomFiles = new Set();
+        for (const d of response.diagnostics ?? []){
+            const abs = node_path.isAbsolute(d.filePath) ? node_path.normalize(d.filePath) : node_path.resolve(configDirectory, d.filePath);
+            if (!(abs in contents)) try {
+                const raw = await readFile(abs, 'utf8');
+                if (0xfeff === raw.charCodeAt(0)) {
+                    bomFiles.add(nativePathIdentity.key(abs));
+                    contents[abs] = raw.slice(1);
+                } else contents[abs] = raw;
+            } catch  {}
         }
         return {
-            config: base,
-            configDirectory
+            contents,
+            bomFiles
         };
     }
     #toLintResults(response, configDirectory, files, contents, bomFiles) {
         const toAbs = (p)=>node_path.isAbsolute(p) ? node_path.normalize(p) : node_path.resolve(configDirectory, p);
+        const contentByPath = new Map();
+        for (const [filePath, source] of Object.entries(contents ?? {}))contentByPath.set(nativePathIdentity.key(filePath), source);
         const byFile = new Map();
-        for (const f of files)byFile.set(node_path.normalize(f), []);
+        for (const file of files){
+            const filePath = node_path.normalize(file);
+            const key = nativePathIdentity.key(filePath);
+            if (!byFile.has(key)) byFile.set(key, {
+                filePath,
+                messages: []
+            });
+        }
         for (const d of response.diagnostics ?? []){
             const abs = toAbs(d.filePath);
-            let messages = byFile.get(abs);
-            if (!messages) {
-                messages = [];
-                byFile.set(abs, messages);
+            const key = nativePathIdentity.key(abs);
+            let bucket = byFile.get(key);
+            if (!bucket) {
+                bucket = {
+                    filePath: abs,
+                    messages: []
+                };
+                byFile.set(key, bucket);
             }
-            messages.push(toLintMessage(d, contents?.[abs]));
+            bucket.messages.push(toLintMessage(d, contentByPath.get(key)));
         }
-        const outputByAbs = new Map();
-        for (const [rel, fixed] of Object.entries(response.output ?? {}))outputByAbs.set(toAbs(rel), fixed);
+        const outputByPath = new Map();
+        for (const [rel, fixed] of Object.entries(response.output ?? {}))outputByPath.set(nativePathIdentity.key(toAbs(rel)), fixed);
         const results = [];
-        for (const [filePath, messages] of byFile){
+        for (const [key, { filePath, messages }] of byFile){
             let errorCount = 0;
             let warningCount = 0;
             let fixableErrorCount = 0;
@@ -676,8 +1911,8 @@ class Rslint {
                 fixableErrorCount,
                 fixableWarningCount
             };
-            const output = outputByAbs.get(filePath);
-            if (void 0 !== output) result.output = bomFiles?.has(filePath) ? '\uFEFF' + output : output;
+            const output = outputByPath.get(key);
+            if (void 0 !== output) result.output = bomFiles?.has(key) ? '\uFEFF' + output : output;
             results.push(result);
         }
         return results;
@@ -750,6 +1985,6 @@ function mergeFixes(fixes, sourceText) {
         text
     };
 }
-export { defineConfig, globalIgnores } from "./config-loader.js";
+export { defineConfig, globalIgnores } from "./519.js";
 export { runCLI } from "./cli.js";
 export { Rslint, importPlugin, jestPlugin, js, jsxA11yPlugin, promisePlugin, reactHooksPlugin, reactPlugin, ts, unicornPlugin };