eslint-plugin-bunisms 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dave Lunny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# eslint-plugin-bunisms 🐰
+
+[![npm version](https://img.shields.io/npm/v/eslint-plugin-bunisms.svg)](https://www.npmjs.com/package/eslint-plugin-bunisms)
+[![CI](https://github.com/himynameisdave/eslint-plugin-bunisms/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/himynameisdave/eslint-plugin-bunisms/actions/workflows/ci.yml?query=branch%3Amain)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fhimynameisdave%2Feslint-plugin-bunisms.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2Fhimynameisdave%2Feslint-plugin-bunisms?ref=badge_shield&issueType=license)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fhimynameisdave%2Feslint-plugin-bunisms.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2Fhimynameisdave%2Feslint-plugin-bunisms?ref=badge_shield&issueType=security)
+
+> ESLint rules for idiomatic and correct Bun code. Supports TypeScript and JavaScript, Oxlint, and ESLint 9–10.
+
+## Installation
+
+```bash
+bun add -D eslint-plugin-bunisms
+```
+
+You also need `oxlint` or `eslint` installed.
+
+## Oxlint
+
+```ts
+// oxlint.config.ts
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+  jsPlugins: [{ name: 'bun', specifier: 'eslint-plugin-bunisms' }],
+  rules: {
+    'bun/prefer-bun-file': 'warn',
+    'bun/prefer-bun-write': 'warn',
+    'bun/prefer-bun-spawn': 'warn',
+  },
+});
+```
+
+ESLint is optional when using Oxlint. Oxlint's JavaScript plugin support is currently alpha; compatibility is tested in CI.
+
+## ESLint
+
+```ts
+// eslint.config.ts
+import bun from 'eslint-plugin-bunisms';
+
+export default [bun.configs.recommended];
+```
+
+ESLint needs [`jiti`](https://github.com/unjs/jiti) to load a TypeScript config file on Node. For TypeScript files, configure a TypeScript parser such as `@typescript-eslint/parser`. These rules do not require type information.
+
+## Rules
+
+| Rule                                                   | Recommends                                                                 |
+| ------------------------------------------------------ | -------------------------------------------------------------------------- |
+| [bun/prefer-bun-file](docs/rules/prefer-bun-file.md)   | `Bun.file()` instead of Node's `readFile()`                                |
+| [bun/prefer-bun-write](docs/rules/prefer-bun-write.md) | `Bun.write()` instead of Node's `writeFile()`                              |
+| [bun/prefer-bun-spawn](docs/rules/prefer-bun-spawn.md) | `Bun.spawn()` / `Bun.spawnSync()` instead of Node's subprocess equivalents |
+
+Rules recognize imports, aliases and CommonJS bindings, respecting lexical scope. They report calls without automatically rewriting them: Node and Bun APIs have different options and return values.
+
+The `recommended`, `strict` and `all` ESLint presets currently enable all three rules as warnings. Override individual rules after the preset:
+
+```ts
+export default [bun.configs.recommended, { rules: { 'bun/prefer-bun-file': 'error' } }];
+```
+
+## Compatibility
+
+Targets **Bun >=1.4.0** applications. The plugin itself runs on **Node >=18.18.0**, subject to your linter's Node requirements, and has no runtime dependencies.
+
+Apply the plugin only to code intended for Bun. For a mixed-runtime project, scope the ESLint preset with `files`:
+
+```ts
+export default [{ ...bun.configs.recommended, files: ['scripts/**/*.ts'] }];
+```
+
+See [Contributing](CONTRIBUTING.md) for development and [the roadmap](https://github.com/himynameisdave/eslint-plugin-bunisms/blob/main/docs/roadmap.md) for planned rules.
+
+## See also
+
+- [`@himynameisdave/oxlint-config`](https://github.com/himynameisdave/oxlint-config)
+- [`@himynameisdave/oxfmt-config`](https://github.com/himynameisdave/oxfmt-config)
+
+---
+
+<sub>_[MIT](LICENSE) © Dave Lunny_</sub>

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { ESLint, Linter } from 'eslint';
+declare const rules: {
+    'prefer-bun-file': import("eslint").Rule.RuleModule;
+    'prefer-bun-write': import("eslint").Rule.RuleModule;
+    'prefer-bun-spawn': import("eslint").Rule.RuleModule;
+};
+type Preset = 'recommended' | 'strict' | 'all';
+declare const plugin: ESLint.Plugin & {
+    rules: typeof rules;
+    configs: Record<Preset, Linter.Config>;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,260 @@
+// package.json
+var package_default = {
+  name: "eslint-plugin-bunisms",
+  version: "0.1.0",
+  description: "ESLint rules for idiomatic and correct Bun code.",
+  keywords: [
+    "bun",
+    "bunjs",
+    "eslint",
+    "eslintplugin",
+    "lint",
+    "linter",
+    "oxlint"
+  ],
+  homepage: "https://github.com/himynameisdave/eslint-plugin-bunisms#readme",
+  bugs: "https://github.com/himynameisdave/eslint-plugin-bunisms/issues",
+  license: "MIT",
+  author: "Dave Lunny",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/himynameisdave/eslint-plugin-bunisms.git"
+  },
+  files: [
+    "dist",
+    "docs/rules",
+    "README.md",
+    "LICENSE"
+  ],
+  type: "module",
+  sideEffects: false,
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  scripts: {
+    build: "bun scripts/build.ts && tsc -p tsconfig.build.json",
+    check: "bun run typecheck && bun run lint && bun run format:check && bun run test && bun run build && bun run test:node && bun run test:oxlint && bun run test:package",
+    format: "oxfmt --write",
+    "format:check": "oxfmt --check",
+    lint: "oxlint -c oxlint.config.ts --deny-warnings",
+    "lint:fix": "bun run lint --fix",
+    prepublishOnly: "bun run check",
+    test: "bun test tests/rules.test.ts",
+    "test:node": "node --test tests/node.test.mjs",
+    "test:oxlint": "bun scripts/test-oxlint.ts",
+    "test:package": "bun scripts/test-package.ts",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@himynameisdave/oxfmt-config": "^1.0.0",
+    "@himynameisdave/oxlint-config": "^1.2.0",
+    "@types/bun": "^1.4.2",
+    "@types/estree": "^1.0.9",
+    "@typescript-eslint/parser": "^8.70.1",
+    eslint: "^9.39.5",
+    eslint10: "npm:eslint@^10",
+    oxfmt: "0.70.0",
+    oxlint: "^1.85.0",
+    typescript: "~5.9.3"
+  },
+  peerDependencies: {
+    eslint: ">=9.0.0 <11"
+  },
+  peerDependenciesMeta: {
+    eslint: {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=18.18.0"
+  },
+  packageManager: "bun@1.4.2"
+};
+
+// src/utils/imports.ts
+function variableFor(context, node) {
+  let scope = context.sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.set.get(node.name);
+    if (variable) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+}
+function propertyName(node, computed) {
+  if (!computed && node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+}
+function isModified(variable) {
+  return variable.references.some((reference) => {
+    if (reference.isWrite() && !reference.init) {
+      return true;
+    }
+    let node = reference.identifier;
+    while (node.parent?.type === "MemberExpression" && node.parent.object === node) {
+      node = node.parent;
+    }
+    const { parent } = node;
+    return parent?.type === "AssignmentExpression" && parent.left === node || parent?.type === "UpdateExpression" || parent?.type === "UnaryExpression" && parent.operator === "delete";
+  });
+}
+function resolveBuiltin(context, node) {
+  if (node.type === "MemberExpression") {
+    const property = propertyName(node.property, node.computed);
+    const object = resolveBuiltin(context, node.object);
+    if (property && object) {
+      return { ...object, path: [...object.path, property] };
+    }
+    return;
+  }
+  if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require") {
+    const variable = variableFor(context, node.callee);
+    if (variable?.defs.length || node.arguments.length !== 1) {
+      return;
+    }
+    const [source] = node.arguments;
+    if (source?.type === "Literal" && typeof source.value === "string") {
+      return { module: source.value.replace(/^node:/u, ""), path: [] };
+    }
+    return;
+  }
+  if (node.type !== "Identifier") {
+    return;
+  }
+  const variable = variableFor(context, node);
+  if (!variable || variable.defs.length !== 1 || isModified(variable)) {
+    return;
+  }
+  const [definition] = variable.defs;
+  if (!definition) {
+    return;
+  }
+  if (definition.type === "ImportBinding") {
+    const declaration = definition.parent;
+    if (declaration.importKind === "type" || definition.node.importKind === "type") {
+      return;
+    }
+    const source = declaration.source.value;
+    if (typeof source !== "string") {
+      return;
+    }
+    const specifier = definition.node;
+    const path = specifier.type === "ImportSpecifier" ? [
+      specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value)
+    ] : [];
+    return { module: source.replace(/^node:/u, ""), path };
+  }
+  if (definition.type !== "Variable" || definition.parent.kind !== "const") {
+    return;
+  }
+  const { id, init } = definition.node;
+  if (!init || init.type !== "CallExpression") {
+    return;
+  }
+  const origin = resolveBuiltin(context, init);
+  if (!origin) {
+    return;
+  }
+  if (id.type === "Identifier") {
+    return origin;
+  }
+  if (id.type === "ObjectPattern") {
+    const property = id.properties.find((entry) => entry.type === "Property" && entry.value.type === "Identifier" && entry.value.name === node.name);
+    if (property?.type !== "Property") {
+      return;
+    }
+    const name = propertyName(property.key, property.computed);
+    if (name) {
+      return { ...origin, path: [...origin.path, name] };
+    }
+  }
+}
+
+// src/utils/create-rule.ts
+function createRule(name, methods, modules, fsPromises = false) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description: `Prefer ${Object.values(methods).join(" or ")} over the corresponding Node.js APIs.`,
+        url: `https://github.com/himynameisdave/eslint-plugin-bunisms/blob/main/docs/rules/${name}.md`
+      },
+      schema: [],
+      messages: { preferBun: "Prefer {{replacement}} over Node.js {{method}}() when targeting Bun." }
+    },
+    create(context) {
+      return {
+        CallExpression(node) {
+          const reference = resolveBuiltin(context, node.callee);
+          if (!reference || !modules.includes(reference.module)) {
+            return;
+          }
+          let { path } = reference;
+          if (fsPromises && reference.module === "fs" && path[0] === "promises") {
+            path = path.slice(1);
+          }
+          if (path.length !== 1) {
+            return;
+          }
+          const [method] = path;
+          if (!method || !Object.hasOwn(methods, method)) {
+            return;
+          }
+          const replacement = methods[method];
+          if (!replacement) {
+            return;
+          }
+          context.report({
+            node: node.callee,
+            messageId: "preferBun",
+            data: { method, replacement }
+          });
+        }
+      };
+    }
+  };
+}
+
+// src/rules/prefer-bun-file.ts
+var prefer_bun_file_default = createRule("prefer-bun-file", { readFile: "Bun.file()" }, ["fs", "fs/promises"], true);
+
+// src/rules/prefer-bun-spawn.ts
+var prefer_bun_spawn_default = createRule("prefer-bun-spawn", { spawn: "Bun.spawn()", spawnSync: "Bun.spawnSync()" }, [
+  "child_process"
+]);
+
+// src/rules/prefer-bun-write.ts
+var prefer_bun_write_default = createRule("prefer-bun-write", { writeFile: "Bun.write()" }, ["fs", "fs/promises"], true);
+
+// src/index.ts
+var rules = {
+  "prefer-bun-file": prefer_bun_file_default,
+  "prefer-bun-write": prefer_bun_write_default,
+  "prefer-bun-spawn": prefer_bun_spawn_default
+};
+var plugin = {
+  meta: { name: "eslint-plugin-bunisms", version: package_default.version },
+  rules,
+  configs: {}
+};
+for (const preset of ["recommended", "strict", "all"]) {
+  plugin.configs[preset] = {
+    name: `bun/${preset}`,
+    plugins: { bun: plugin },
+    rules: Object.fromEntries(Object.keys(rules).map((name) => [`bun/${name}`, "warn"]))
+  };
+}
+var src_default = plugin;
+export {
+  src_default as default
+};

package/dist/rules/prefer-bun-file.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/rules/prefer-bun-spawn.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/rules/prefer-bun-write.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/utils/create-rule.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare function createRule(name: string, methods: Record<string, string>, modules: string[], fsPromises?: boolean): Rule.RuleModule;

package/dist/utils/imports.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from 'eslint';
+import type { Node, Expression } from 'estree';
+export type BuiltinReference = {
+    module: string;
+    path: string[];
+};
+/** Resolve only direct builtin imports/requires, never names alone or arbitrary aliases. */
+export declare function resolveBuiltin(context: Rule.RuleContext, node: Expression | Node): BuiltinReference | undefined;

package/docs/rules/prefer-bun-file.md

@@ -0,0 +1,48 @@
+# prefer-bun-file
+
+📝 Prefer `Bun.file()` over the corresponding Node.js APIs.
+
+⚠️ This rule _warns_ in the following [configs](https://github.com/himynameisdave/eslint-plugin-bunisms#eslint): ✅ `recommended`, 🔒 `strict`, 🌐 `all`.
+
+[`Bun.file()`](https://bun.sh/docs/runtime/file-io) exposes text, JSON, binary and streaming readers without needing the Node filesystem API.
+
+This rule reports [`readFile()`](https://nodejs.org/api/fs.html) from `fs` and `fs/promises`, including `fs.promises.readFile()`. It does not report `readFileSync`, streams, directory operations or unrelated functions.
+
+Named, aliased, default and namespace imports are supported, with either bare or `node:` module names. CommonJS direct calls and `const` require bindings (including destructuring) are supported. Lexical shadowing and visible binding/module-property mutations suppress reports. Dynamic imports, indirect aliases, mutable CommonJS declarations and interprocedural mutation tracking are not supported. Only actual calls report; unused imports or function references do not.
+
+The rule reports without a fix, because the APIs are not drop-in replacements. `Bun.file()` creates a lazy file object; reading requires `.text()`, `.json()`, `.arrayBuffer()` or another reader, and its binary result is not a Node `Buffer`. Keep the Node API when the module must also run under Node, when callback behavior is required, or when encodings, options or file descriptors need Node-specific handling. Disable the rule for such files or scope the preset to Bun-only code.
+
+## Examples
+
+```js
+// ❌
+import { readFile } from 'node:fs/promises';
+const text = await readFile('hello.txt', 'utf8');
+
+// ✅
+const text = await Bun.file('hello.txt').text();
+```
+
+```js
+// ❌
+import fs from 'node:fs';
+const bytes = await fs.promises.readFile('hello.bin');
+
+// ✅
+const bytes = await Bun.file('hello.bin').arrayBuffer();
+```
+
+```js
+// ❌
+const { readFile } = require('fs/promises');
+const config = JSON.parse(await readFile('config.json', 'utf8'));
+
+// ✅
+const config = await Bun.file('config.json').json();
+```
+
+```js
+// ✅
+import { readFileSync } from 'node:fs';
+const text = readFileSync('hello.txt', 'utf8');
+```

package/docs/rules/prefer-bun-spawn.md

@@ -0,0 +1,49 @@
+# prefer-bun-spawn
+
+📝 Prefer `Bun.spawn()` or `Bun.spawnSync()` over the corresponding Node.js APIs.
+
+⚠️ This rule _warns_ in the following [configs](https://github.com/himynameisdave/eslint-plugin-bunisms#eslint): ✅ `recommended`, 🔒 `strict`, 🌐 `all`.
+
+[`Bun.spawn()` and `Bun.spawnSync()`](https://bun.sh/docs/runtime/child-process) integrate with Bun streams and offer asynchronous and synchronous process execution.
+
+This rule reports [`spawn()` and `spawnSync()`](https://nodejs.org/api/child_process.html) from `child_process`. It does not report `exec`, `execSync` or `fork`; shell migration belongs to a future separate rule.
+
+Named, aliased, default and namespace imports are supported, with either bare or `node:` module names. CommonJS direct calls and `const` require bindings (including destructuring) are supported. Lexical shadowing and visible binding/module-property mutations suppress reports. Dynamic imports, indirect aliases, mutable CommonJS declarations and interprocedural mutation tracking are not supported. Only actual calls report; unused imports or function references do not.
+
+The rule reports without a fix, because the APIs are not drop-in replacements: argument shapes, return objects, signals, buffering and error handling differ. Keep the Node API in cross-runtime tools, or where Node `ChildProcess` events, IPC or specific stdio/options semantics are required. Disable the rule for such files or scope the preset to Bun-only code.
+
+## Examples
+
+```js
+// ❌
+import { spawn } from 'node:child_process';
+spawn('echo', ['hello']);
+
+// ✅
+const child = Bun.spawn(['echo', 'hello']);
+await child.exited;
+```
+
+```js
+// ❌
+import * as cp from 'node:child_process';
+cp.spawnSync('echo', ['hello']);
+
+// ✅
+const result = Bun.spawnSync(['echo', 'hello']);
+```
+
+```js
+// ❌
+const { spawn: run } = require('child_process');
+run('echo', ['hello']);
+
+// ✅
+const child = Bun.spawn(['echo', 'hello']);
+```
+
+```js
+// ✅
+import { exec } from 'node:child_process';
+exec('echo hello');
+```

package/docs/rules/prefer-bun-write.md

@@ -0,0 +1,48 @@
+# prefer-bun-write
+
+📝 Prefer `Bun.write()` over the corresponding Node.js APIs.
+
+⚠️ This rule _warns_ in the following [configs](https://github.com/himynameisdave/eslint-plugin-bunisms#eslint): ✅ `recommended`, 🔒 `strict`, 🌐 `all`.
+
+[`Bun.write()`](https://bun.sh/docs/runtime/file-io) accepts strings, binary data, blobs and responses for Bun-native file writes.
+
+This rule reports [`writeFile()`](https://nodejs.org/api/fs.html) from `fs` and `fs/promises`, including `fs.promises.writeFile()`. It does not report `appendFile`, `writeFileSync`, streams or other filesystem operations.
+
+Named, aliased, default and namespace imports are supported, with either bare or `node:` module names. CommonJS direct calls and `const` require bindings (including destructuring) are supported. Lexical shadowing and visible binding/module-property mutations suppress reports. Dynamic imports, indirect aliases, mutable CommonJS declarations and interprocedural mutation tracking are not supported. Only actual calls report; unused imports or function references do not.
+
+The rule reports without a fix, because the APIs are not drop-in replacements. `Bun.write()` returns a byte count; Node's `writeFile()` does not. Keep the Node API in shared Node/Bun code, or where callback, encoding, permissions, flags, abort signals or file-descriptor semantics are needed. Review options and error handling before migrating. Disable the rule for such files or scope the preset to Bun-only code.
+
+## Examples
+
+```js
+// ❌
+import { writeFile } from 'node:fs/promises';
+await writeFile('hello.txt', 'Hello!');
+
+// ✅
+await Bun.write('hello.txt', 'Hello!');
+```
+
+```js
+// ❌
+import fs from 'node:fs';
+await fs.promises.writeFile('data.json', JSON.stringify(data));
+
+// ✅
+await Bun.write('data.json', JSON.stringify(data));
+```
+
+```js
+// ❌
+const { writeFile: save } = require('fs/promises');
+await save('hello.txt', 'Hello!');
+
+// ✅
+await Bun.write('hello.txt', 'Hello!');
+```
+
+```js
+// ✅
+import { appendFile } from 'node:fs/promises';
+await appendFile('log.txt', 'Hello!\n');
+```

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "eslint-plugin-bunisms",
+  "version": "0.1.0",
+  "description": "ESLint rules for idiomatic and correct Bun code.",
+  "keywords": [
+    "bun",
+    "bunjs",
+    "eslint",
+    "eslintplugin",
+    "lint",
+    "linter",
+    "oxlint"
+  ],
+  "homepage": "https://github.com/himynameisdave/eslint-plugin-bunisms#readme",
+  "bugs": "https://github.com/himynameisdave/eslint-plugin-bunisms/issues",
+  "license": "MIT",
+  "author": "Dave Lunny",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/himynameisdave/eslint-plugin-bunisms.git"
+  },
+  "files": [
+    "dist",
+    "docs/rules",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts && tsc -p tsconfig.build.json",
+    "check": "bun run typecheck && bun run lint && bun run format:check && bun run test && bun run build && bun run test:node && bun run test:oxlint && bun run test:package",
+    "format": "oxfmt --write",
+    "format:check": "oxfmt --check",
+    "lint": "oxlint -c oxlint.config.ts --deny-warnings",
+    "lint:fix": "bun run lint --fix",
+    "prepublishOnly": "bun run check",
+    "test": "bun test tests/rules.test.ts",
+    "test:node": "node --test tests/node.test.mjs",
+    "test:oxlint": "bun scripts/test-oxlint.ts",
+    "test:package": "bun scripts/test-package.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@himynameisdave/oxfmt-config": "^1.0.0",
+    "@himynameisdave/oxlint-config": "^1.2.0",
+    "@types/bun": "^1.4.2",
+    "@types/estree": "^1.0.9",
+    "@typescript-eslint/parser": "^8.70.1",
+    "eslint": "^9.39.5",
+    "eslint10": "npm:eslint@^10",
+    "oxfmt": "0.70.0",
+    "oxlint": "^1.85.0",
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0 <11"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "packageManager": "bun@1.4.2"
+}