@rustwrap/eslint 1.0.1 → 1.0.3

package/README.md

@@ -22,6 +22,32 @@ dependency at `@rustwrap/eslint` and lint **~50–80× faster**.
 No script changes needed — `eslint …`, `pcf-scripts lint`, and tools using the ESLint Node API keep
 working. `@rustwrap/eslint` ships the `eslint` bin.
 
+## Requirements
+
+**Node.js `^20.19.0 || ^22.13.0 || >=24`** (enforced via the package's `engines` field).
+
+This is **not** an arbitrary floor — it is the exact intersection of the engine requirements of the
+Rust toolchain this package is built on:
+
+| Dependency | Requires | Why |
+|---|---|---|
+| `oxlint` (+ native binding) | `^20.19.0 \|\| >=22.12.0` | The N-API/V8 features the Rust binary uses were backported into each LTS line at Node **20.19.0** and **22.12.0**. |
+| `eslint-scope` | `^20.19.0 \|\| ^22.13.0 \|\| >=24` | Follows ESLint's policy: active LTS lines only, skipping odd non-LTS majors (21.x, 23.x). |
+
+Taking the **strictest** clause on each line yields the declared range. Reading it:
+
+- `^20.19.0` → the **Node 20 LTS** line, from patch **.19** up (`>=20.19.0 <21`). Earlier 20.x patches
+  lack the backported native feature.
+- `^22.13.0` → the **Node 22 LTS** line, from patch **.13** up (`>=22.13.0 <23`). Note this is one
+  patch higher than oxlint's own `22.12.0` floor, because `eslint-scope` requires `22.13.0`.
+- `>=24` → **Node 24+** (the next even LTS line and beyond).
+- **Excluded:** Node ≤16 (EOL), 18.x, 21.x, 22.0–22.12, and 23.x — none satisfy every dependency.
+
+> **Node 16 / 18 are not supported.** oxlint 1.x and Rolldown 1.x dropped them; the native Rust
+> binaries will not run there. The `engines` field makes this an **immediate, named `EBADENGINE`
+> warning** at install (or a hard failure under `engine-strict=true`/CI) instead of a cryptic deep
+> crash inside the native module.
+
 ## What it honors (config & ignore)
 - **Legacy eslintrc**: `.eslintrc.json`, `.eslintrc`, `.eslintrc.js`, `.eslintrc.cjs`,
   `.eslintrc.yaml`/`.yml`, and `package.json#eslintConfig`. Auto-discovered up the directory tree;
@@ -37,14 +63,18 @@ working. `@rustwrap/eslint` ships the `eslint` bin.
   doesn't implement are dropped automatically (it would otherwise reject the config).
 - **`env`, `globals`, `settings`, `overrides`, `ignorePatterns`** — translated (incl. normalizing
   `settings.react.version: "detect"` to a concrete version).
-- **`parser` / `parserOptions`** — not needed: oxlint detects TS/JSX by extension.
+- **`parser` / `parserOptions`** — TS/JSX is auto-detected by extension. `parserOptions.project` is
+  honored for **tsconfig resolution**: oxlint auto-discovers the nearest `tsconfig.json` per file, and
+  if your config points `project` at a non-standard tsconfig (e.g. `tsconfig.eslint.json`) it's passed
+  through via `--tsconfig`. An explicit `--tsconfig <file>` CLI flag (and `tsconfig` Node API option)
+  overrides discovery.
 - **`.eslintignore`** + `--ignore-path` + `--ignore-pattern` + `--no-ignore`.
 
 ## CLI
 ESLint-compatible flags: file/dir/**glob** args (incl. `src/**/*.{ts,tsx}` brace expansion — `@rustwrap/eslint`
 expands globs since oxlint doesn't), `--fix`, `--quiet`, `--max-warnings <n>`, `-c/--config`,
 `--no-eslintrc`, `--ext`, `-f/--format <stylish|json|compact|unix|summary>`, `-o/--output-file`,
-`--ignore-path`, `--ignore-pattern`, `--no-ignore`, `--color/--no-color`, `--stdin`/`--stdin-filename`.
+`--ignore-path`, `--ignore-pattern`, `--no-ignore`, `--tsconfig <file>`, `--color/--no-color`, `--stdin`/`--stdin-filename`.
 Other ESLint flags are accepted and ignored for drop-in tolerance.
 
 **Exit codes** match ESLint: `0` clean (or warnings under threshold), `1` lint errors or

package/bin/{oxpack.js → rustwrap-eslint.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 /*
- * oxpack CLI — an `eslint`-compatible command backed by oxlint. Parses the common ESLint flags,
+ * @rustwrap/eslint CLI — an `eslint`-compatible command backed by oxlint. Parses the common ESLint flags,
  * expands globs (ESLint expands internally; oxlint does not), runs oxlint, renders an ESLint-style
  * report, and exits with ESLint semantics (0 = clean / warnings under threshold, 1 = lint errors or
  * --max-warnings exceeded, 2 = fatal).
@@ -34,13 +34,15 @@ function parse(argv) {
     else if (a === "--ignore-path") o.ignorePath = next();
     else if (a.startsWith("--ignore-path=")) o.ignorePath = a.split("=")[1];
     else if (a === "--ignore-pattern") o.ignorePattern.push(next());
+    else if (a === "--tsconfig") o.tsconfig = next();
+    else if (a.startsWith("--tsconfig=")) o.tsconfig = a.split("=")[1];
     else if (a === "--no-ignore") o.noIgnore = true;
     else if (a === "--no-color") process.env.NO_COLOR = "1";
     else if (a === "--color") process.env.FORCE_COLOR = "1";
     else if (a === "--report-unused-disable-directives") o.reportUnused = true;
     else if (a === "--rulesdir" || a === "--resolve-plugins-relative-to" || a === "--parser" || a === "--parser-options" || a === "--rule" || a === "--env" || a === "--global" || a === "--cache-location" || a === "--cache-strategy") { next(); /* accepted, ignored */ }
     else if (a === "--cache" || a === "--no-cache" || a === "--stdin" || a === "--stdin-filename" || a === "--init" || a === "--debug" || a === "--exit-on-fatal-error") { if (a === "--stdin-filename") o.stdinFilename = next(); else if (a === "--stdin") o.stdin = true; }
-    else if (a === "-v" || a === "--version") { console.log(require("../package.json").version + " (oxpack, eslint-compatible)"); process.exit(0); }
+    else if (a === "-v" || a === "--version") { console.log(require("../package.json").version + " (@rustwrap/eslint, eslint-compatible)"); process.exit(0); }
     else if (a === "-h" || a === "--help") { printHelp(); process.exit(0); }
     else if (a.startsWith("-")) { /* unknown flag: ignore for drop-in tolerance */ }
     else o.patterns.push(a);
@@ -49,7 +51,7 @@ function parse(argv) {
 }
 
 function printHelp() {
-  console.log("oxpack — eslint-compatible CLI backed by oxlint\n\nUsage: eslint [options] [file|dir|glob]*\n\nCommon options: --fix --quiet --max-warnings <n> -c/--config <file> --no-eslintrc\n  --ext <.ts,.tsx> -f/--format <stylish|json|compact|unix|summary> -o/--output-file <file>\n  --ignore-path <file> --ignore-pattern <glob> --no-ignore --color/--no-color");
+  console.log("@rustwrap/eslint — eslint-compatible CLI backed by oxlint\n\nUsage: eslint [options] [file|dir|glob]*\n\nCommon options: --fix --quiet --max-warnings <n> -c/--config <file> --no-eslintrc\n  --ext <.ts,.tsx> -f/--format <stylish|json|compact|unix|summary> -o/--output-file <file>\n  --ignore-path <file> --ignore-pattern <glob> --no-ignore --tsconfig <file> --color/--no-color");
 }
 
 async function main() {
@@ -66,12 +68,12 @@ async function main() {
 
   const files = expandPatterns(opts.patterns.length ? opts.patterns : ["."], cwd, opts.exts);
   if (!files.length) {
-    if (opts.patterns.length) process.stderr.write("oxpack: no files matched the provided patterns\n");
+    if (opts.patterns.length) process.stderr.write("@rustwrap/eslint: no files matched the provided patterns\n");
     process.exit(0);
   }
-  const { oxConfig } = buildOxlintConfig({ cwd, configFile: opts.config, noEslintrc: opts.noEslintrc });
+  const { oxConfig, tsconfig } = buildOxlintConfig({ cwd, configFile: opts.config, noEslintrc: opts.noEslintrc, tsconfig: opts.tsconfig });
   const { results, internalError } = runOxlint(files, oxConfig, {
-    cwd, fix: !!opts.fix, quiet: !!opts.quiet, ignorePath: opts.ignorePath, ignorePattern: opts.ignorePattern, noIgnore: opts.noIgnore,
+    cwd, fix: !!opts.fix, quiet: !!opts.quiet, ignorePath: opts.ignorePath, ignorePattern: opts.ignorePattern, noIgnore: opts.noIgnore, tsconfig,
   });
   if (internalError) { process.stderr.write(internalError + "\n"); process.exit(2); }
   // ESLint reports clean files too (count only); for output we only need ones with messages.
@@ -89,7 +91,7 @@ function finish(results, opts) {
   // ESLint exit semantics.
   if (errorCount > 0) process.exit(1);
   if (opts.maxWarnings >= 0 && warningCount > opts.maxWarnings) {
-    process.stderr.write(`oxpack: too many warnings (${warningCount}). Maximum allowed is ${opts.maxWarnings}.\n`);
+    process.stderr.write(`@rustwrap/eslint: too many warnings (${warningCount}). Maximum allowed is ${opts.maxWarnings}.\n`);
     process.exit(1);
   }
   process.exit(0);

package/lib/config.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * oxpack config layer — discovers an ESLint configuration (eslintrc legacy or flat), and translates
+ * @rustwrap/eslint config layer — discovers an ESLint configuration (eslintrc legacy or flat), and translates
  * it into the `.oxlintrc.json` shape oxlint consumes (oxlint already targets ESLint-v8 config
  * compatibility, so most of `rules`/`env`/`globals`/`settings`/`overrides` pass straight through;
  * `plugins`/`extends`/`parser` need mapping).
@@ -103,6 +103,8 @@ function loadEslintrc(file, inline, seen) {
     rules: cfg.rules || {}, env: cfg.env || {}, globals: cfg.globals || {}, settings: cfg.settings || {},
     overrides: cfg.overrides || [], ignorePatterns: [].concat(cfg.ignorePatterns || []),
   });
+  const po = cfg.parserOptions || {};
+  if (po.project) merged._project = resolveProjectRef(po.project, baseDir);
   return merged;
 }
 
@@ -114,6 +116,38 @@ function mergeInto(target, src) {
   if (src.overrides) target.overrides.push(...src.overrides);
   if (src.ignorePatterns) target.ignorePatterns.push(...src.ignorePatterns);
   if (src._pluginIds) for (const p of src._pluginIds) target._pluginIds.add(p);
+  if (src._project && !target._project) target._project = src._project;
+}
+
+// Resolve an ESLint `parserOptions.project` value (string | string[] | true) to a single tsconfig
+// path relative to the config file's directory. `true` means "nearest tsconfig" — left for discovery.
+function resolveProjectRef(project, baseDir) {
+  if (project === true) return true;
+  const first = Array.isArray(project) ? project[0] : project;
+  if (typeof first !== "string") return true;
+  return path.resolve(baseDir, first);
+}
+
+// Walk up from `dir` to find the nearest tsconfig.json (like tsc/webpack resolution).
+function findTsconfig(dir) {
+  for (let i = 0; i < 12 && dir; i++) {
+    const f = path.join(dir, "tsconfig.json");
+    if (fs.existsSync(f)) return f;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return undefined;
+}
+
+// Decide which tsconfig (if any) to *override* oxlint with. oxlint already auto-discovers the
+// nearest tsconfig.json per file, so we only pass --tsconfig when the user is explicit: an explicit
+// option/CLI flag, or `parserOptions.project` (which can point at a non-standard name/path oxlint
+// wouldn't find on its own). When project===true or unset, return undefined and let oxlint discover.
+function resolveTsconfig(opts, project, configDir, cwd) {
+  if (opts && opts.tsconfig) { const p = path.resolve(cwd, opts.tsconfig); return fs.existsSync(p) ? p : undefined; }
+  if (project && project !== true) return fs.existsSync(project) ? project : undefined;
+  return undefined;
 }
 
 // Load the set of rule names oxlint actually implements from its bundled JSON schema, so we can
@@ -275,19 +309,23 @@ function sanitizeGlobals(globals) {
 
 // Returns { oxConfig, pluginFlags, source } or null when no config found / --no-eslintrc.
 function buildOxlintConfig(opts) {
-  if (opts && opts.noEslintrc) return { oxConfig: { plugins: ["typescript", "unicorn", "oxc"], categories: { correctness: "warn" } }, source: null };
+  opts = opts || {};
+  const cwd = opts.cwd || process.cwd();
+  const defaults = { plugins: ["typescript", "unicorn", "oxc"], categories: { correctness: "warn" } };
+  if (opts.noEslintrc) return { oxConfig: defaults, source: null, tsconfig: resolveTsconfig(opts, null, cwd, cwd) };
   let found;
-  if (opts && opts.configFile) found = { type: opts.configFile.endsWith(".js") || opts.configFile.endsWith(".mjs") || opts.configFile.endsWith(".cjs") ? "flat" : "eslintrc", file: path.resolve(opts.configFile) };
-  else found = discoverConfig((opts && opts.cwd) || process.cwd());
-  if (!found) return { oxConfig: { plugins: ["typescript", "unicorn", "oxc"], categories: { correctness: "warn" } }, source: null };
+  if (opts.configFile) found = { type: opts.configFile.endsWith(".js") || opts.configFile.endsWith(".mjs") || opts.configFile.endsWith(".cjs") ? "flat" : "eslintrc", file: path.resolve(opts.configFile) };
+  else found = discoverConfig(cwd);
+  if (!found) return { oxConfig: defaults, source: null, tsconfig: resolveTsconfig(opts, null, cwd, cwd) };
+  const configDir = found.file ? path.dirname(found.file) : cwd;
   if (found.type === "flat") {
     // Flat config: we can read `rules`/`plugins` heuristically but cannot fully evaluate it; enable
     // common plugins and let oxlint use its own discovery. Pass-through with defaults.
     const flat = loadFlat(found.file);
-    return { oxConfig: toOxlintConfig(flat), source: found.file };
+    return { oxConfig: toOxlintConfig(flat), source: found.file, tsconfig: resolveTsconfig(opts, flat._project, configDir, cwd) };
   }
-  const merged = loadEslintrc(found.inline ? found.file : found.file, found.inline, new Set());
-  return { oxConfig: toOxlintConfig(merged), source: found.file };
+  const merged = loadEslintrc(found.file, found.inline, new Set());
+  return { oxConfig: toOxlintConfig(merged), source: found.file, tsconfig: resolveTsconfig(opts, merged._project, configDir, cwd) };
 }
 
 // Best-effort flat-config reader: merges `rules`/`plugins` across array entries.
@@ -302,8 +340,10 @@ function loadFlat(file) {
     if (block.languageOptions && block.languageOptions.globals) Object.assign(merged.globals, block.languageOptions.globals);
     for (const name of Object.keys(block.plugins || {})) { const id = PLUGIN_MAP[name] || PLUGIN_MAP[name.replace(/^eslint-plugin-/, "")]; if (id) merged._pluginIds.add(id); }
     if (block.ignores) merged.ignorePatterns.push(...block.ignores);
+    const po = block.languageOptions && block.languageOptions.parserOptions;
+    if (po && po.project && !merged._project) merged._project = resolveProjectRef(po.project, path.dirname(file));
   }
   return merged;
 }
 
-module.exports = { discoverConfig, buildOxlintConfig, toOxlintConfig, loadEslintrc, normalizeRules, PLUGIN_MAP };
+module.exports = { discoverConfig, buildOxlintConfig, toOxlintConfig, loadEslintrc, normalizeRules, PLUGIN_MAP, findTsconfig };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * oxpack — a drop-in ESLint Node API + CLI backed by oxlint.
+ * @rustwrap/eslint — a drop-in ESLint Node API + CLI backed by oxlint.
  *
  * Exposes the modern `ESLint` class (lintFiles/lintText/loadFormatter/outputFixes/…), the legacy
  * `CLIEngine`, `Linter`, and `loadESLint`, all delegating to oxlint (Rust). Config is discovered
@@ -52,11 +52,12 @@ class ESLint {
     const files = expandPatterns(patterns, cwd, extensions);
     if (!files.length) return [];
     // Discover/translate config relative to the first file's directory.
-    const { oxConfig } = buildOxlintConfig({ cwd, configFile: typeof overrideConfigFile === "string" ? overrideConfigFile : undefined, noEslintrc });
+    const tsOpt = o.tsconfig || (o.overrideConfig && o.overrideConfig.parserOptions && o.overrideConfig.parserOptions.project);
+    const { oxConfig, tsconfig } = buildOxlintConfig({ cwd, configFile: typeof overrideConfigFile === "string" ? overrideConfigFile : undefined, noEslintrc, tsconfig: tsOpt });
     applyOverrides(oxConfig, o.overrideConfig);
     const { results, internalError } = runOxlint(files, oxConfig, {
       cwd, fix: !!o.fix, quiet: !!o.quiet, ignorePath: o.ignorePath, noIgnore: o.ignore === false,
-      ignorePattern: o.overrideConfig && o.overrideConfig.ignorePatterns,
+      ignorePattern: o.overrideConfig && o.overrideConfig.ignorePatterns, tsconfig,
     });
     if (internalError) { const e = new Error(internalError); throw e; }
     // Ensure every linted file has a result entry (ESLint returns clean files too).
@@ -67,11 +68,11 @@ class ESLint {
     options = options || {};
     const cwd = this.cwd;
     const filePath = options.filePath || path.join(cwd, "__stdin__.ts");
-    const tmp = path.join(require("os").tmpdir(), `oxpack-stdin-${process.pid}-${Date.now()}${path.extname(filePath) || ".ts"}`);
+    const tmp = path.join(require("os").tmpdir(), `rustwrap-stdin-${process.pid}-${Date.now()}${path.extname(filePath) || ".ts"}`);
     fs.writeFileSync(tmp, code);
     try {
-      const { oxConfig } = buildOxlintConfig({ cwd, noEslintrc: this.options.useEslintrc === false });
-      const { results } = runOxlint([tmp], oxConfig, { cwd, quiet: !!this.options.quiet });
+      const { oxConfig, tsconfig } = buildOxlintConfig({ cwd, noEslintrc: this.options.useEslintrc === false, tsconfig: this.options.tsconfig });
+      const { results } = runOxlint([tmp], oxConfig, { cwd, quiet: !!this.options.quiet, tsconfig });
       const r = results[0] || { filePath: tmp, messages: [], errorCount: 0, warningCount: 0, fatalErrorCount: 0, fixableErrorCount: 0, fixableWarningCount: 0, suppressedMessages: [], usedDeprecatedRules: [] };
       r.filePath = path.resolve(filePath);
       r.source = code;
@@ -114,7 +115,7 @@ class ESLint {
     return out;
   }
 
-  static get version() { return "8.57.0-oxpack"; }
+  static get version() { return "8.57.0-rustwrap"; }
 }
 
 function applyOverrides(oxConfig, override) {
@@ -137,18 +138,18 @@ class CLIEngine {
     // CLIEngine is sync; run oxlint synchronously via the same path.
     const cwd = this.options.cwd || process.cwd();
     const files = expandPatterns(patterns, cwd, this.options.extensions);
-    const { oxConfig } = buildOxlintConfig({ cwd, noEslintrc: this.options.useEslintrc === false });
-    const { results } = runOxlint(files, oxConfig, { cwd, fix: !!this.options.fix, quiet: !!this.options.quiet });
+    const { oxConfig, tsconfig } = buildOxlintConfig({ cwd, noEslintrc: this.options.useEslintrc === false, tsconfig: this.options.tsconfig });
+    const { results } = runOxlint(files, oxConfig, { cwd, fix: !!this.options.fix, quiet: !!this.options.quiet, tsconfig });
     const filled = fillMissing(results, files);
     return makeReport(filled);
   }
   executeOnText(text, filename) {
     const cwd = this.options.cwd || process.cwd();
-    const tmp = path.join(require("os").tmpdir(), `oxpack-cli-${Date.now()}${path.extname(filename || ".ts") || ".ts"}`);
+    const tmp = path.join(require("os").tmpdir(), `rustwrap-cli-${Date.now()}${path.extname(filename || ".ts") || ".ts"}`);
     fs.writeFileSync(tmp, text);
     try {
-      const { oxConfig } = buildOxlintConfig({ cwd });
-      const { results } = runOxlint([tmp], oxConfig, { cwd });
+      const { oxConfig, tsconfig } = buildOxlintConfig({ cwd, tsconfig: this.options.tsconfig });
+      const { results } = runOxlint([tmp], oxConfig, { cwd, tsconfig });
       if (results[0]) results[0].filePath = filename ? path.resolve(filename) : "<text>";
       return makeReport(results.length ? results : [{ filePath: filename || "<text>", messages: [], errorCount: 0, warningCount: 0, fatalErrorCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 }]);
     } finally { try { fs.unlinkSync(tmp); } catch (_) {} }
@@ -174,7 +175,7 @@ class Linter {
   constructor() {}
   verify(code, _config, options) {
     const filename = (typeof options === "string" ? options : options && options.filename) || "input.ts";
-    const tmp = path.join(require("os").tmpdir(), `oxpack-linter-${Date.now()}${path.extname(filename) || ".ts"}`);
+    const tmp = path.join(require("os").tmpdir(), `rustwrap-linter-${Date.now()}${path.extname(filename) || ".ts"}`);
     fs.writeFileSync(tmp, code);
     try { const { results } = runOxlint([tmp], null, { cwd: process.cwd() }); return (results[0] && results[0].messages) || []; }
     finally { try { fs.unlinkSync(tmp); } catch (_) {} }

package/lib/runner.js

@@ -70,7 +70,7 @@ function runOxlint(paths, oxConfigObj, opts) {
     }
     return { results: groupResults((res.parsed && res.parsed.diagnostics) || [], opts.cwd || process.cwd()), raw: res.parsed };
   }
-  return { results: [], internalError: "oxpack: could not produce a valid oxlint config after stripping unknown rules/options" };
+  return { results: [], internalError: "@rustwrap/eslint: could not produce a valid oxlint config after stripping unknown rules/options" };
 }
 
 function hasRuleOptions(cfg) {
@@ -90,7 +90,7 @@ function invoke(paths, cfg, opts) {
   const args = [];
   let tmpCfg;
   if (cfg) {
-    tmpCfg = path.join(os.tmpdir(), `oxpack-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.oxlintrc.json`);
+    tmpCfg = path.join(os.tmpdir(), `rustwrap-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.oxlintrc.json`);
     fs.writeFileSync(tmpCfg, JSON.stringify(cfg));
     args.push("-c", tmpCfg);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rustwrap/eslint",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A drop-in ESLint replacement (CLI + Node API) backed by the Rust-based oxlint for very fast linting. Honors .eslintrc(.json/.js/.yml), package.json#eslintConfig, flat eslint.config.js, and .eslintignore.",
   "main": "lib/index.js",
   "publishConfig": {
@@ -10,8 +10,8 @@
     "test": "node test/run.js"
   },
   "bin": {
-    "eslint": "bin/oxpack.js",
-    "oxpack": "bin/oxpack.js"
+    "eslint": "bin/rustwrap-eslint.js",
+    "rustwrap-eslint": "bin/rustwrap-eslint.js"
   },
   "files": [
     "lib/",
@@ -30,5 +30,8 @@
     "oxc",
     "pcf"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  }
 }