@nx/oxlint 0.0.1

package/README.md

@@ -0,0 +1,67 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+[![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Monorepos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+This package is an [Oxlint plugin for Nx](https://nx.dev/nx-api/oxlint).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://nx.dev/blog)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Monorepos · Fast Builds"></a></p>
+

package/dist/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2026 Narwhal Technologies Inc.
+
+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/dist/generators.d.ts

@@ -0,0 +1,2 @@
+export { initGenerator } from './src/generators/init/init.js';
+export { configurationGenerator } from './src/generators/configuration/configuration.js';

package/dist/generators.js

@@ -0,0 +1,2 @@
+export { initGenerator } from './src/generators/init/init.js';
+export { configurationGenerator } from './src/generators/configuration/configuration.js';

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createNodes, createNodesV2, type OxlintPluginOptions, } from './src/plugins/plugin.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+// The graph plugin only — this is what `nx.json` names as `@nx/oxlint`.
+// Generators live in `./generators`.
+export { createNodes, createNodesV2, } from './src/plugins/plugin.js';

package/dist/src/boundaries-plugin/index.d.ts

@@ -0,0 +1,7 @@
+declare const nxOxlintBoundariesPlugin: {
+    meta: {
+        name: string;
+    };
+    rules: Record<string, unknown>;
+};
+export default nxOxlintBoundariesPlugin;

package/dist/src/boundaries-plugin/index.js

@@ -0,0 +1,37 @@
+/**
+ * Experimental bridge exposing Nx's `enforce-module-boundaries` rule to Oxlint
+ * as a JS plugin.
+ *
+ * Oxlint's JS-plugin rule context deliberately mirrors ESLint's `RuleContext`
+ * (`options`, `report`, `filename`, `sourceCode`, …), so the ESLint rule runs
+ * unmodified — `ESLintUtils.RuleCreator` applies `defaultOptions` from
+ * `context.options` inside its own `create`.
+ *
+ * Oxlint's JS-plugin API is excluded from its semver policy and may change in
+ * any release.
+ */
+// Imported from `/internal` rather than the `/nx` plugin entry: that entry
+// spreads `workspaceRules`, whose module-level initializer compiles the
+// consuming workspace's `tools/eslint-rules` directory just to hand back one
+// rule.
+import { enforceModuleBoundaries } from '@nx/eslint-plugin/internal';
+const RULE_NAME = 'enforce-module-boundaries';
+// Annotated rather than inferred: the inferred type names `Options` /
+// `MessageIds` from a non-portable deep path in `@nx/eslint-plugin` (TS2883).
+const nxOxlintBoundariesPlugin = {
+    meta: { name: '@nx' },
+    rules: {
+        [RULE_NAME]: {
+            ...enforceModuleBoundaries,
+            // Oxlint takes the rule's name from this object's key, not from `meta`.
+            // `meta.name` on the *plugin* above is not required either — without it
+            // Oxlint falls back to the package name and the rule registers as
+            // `@nx/oxlint/enforce-module-boundaries` instead of the id the docs tell
+            // users to configure. Carrying the name here anyway keeps the rule
+            // self-describing, since `ESLintUtils.RuleCreator` keeps `name` as a
+            // sibling of `meta` rather than inside it.
+            meta: { ...enforceModuleBoundaries.meta, name: RULE_NAME },
+        },
+    },
+};
+export default nxOxlintBoundariesPlugin;

package/dist/src/generators/configuration/configuration.d.ts

@@ -0,0 +1,17 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export interface ConfigurationGeneratorSchema {
+    project: string;
+    skipFormat?: boolean;
+    skipPackageJson?: boolean;
+    keepExistingVersions?: boolean;
+    /** Oxlint plugins to enable for this project, e.g. `['react', 'jsx-a11y']`. */
+    plugins?: string[];
+}
+/**
+ * Registers `@nx/oxlint` and enables this project's Oxlint plugins.
+ *
+ * It writes no target: `@nx/oxlint` is inference-only, so the plugin registered
+ * by `init` is what gives the project its Oxlint task.
+ */
+export declare function configurationGenerator(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
+export default configurationGenerator;

package/dist/src/generators/configuration/configuration.js

@@ -0,0 +1,28 @@
+import { formatFiles, readProjectConfiguration, runTasksInSerial, } from '@nx/devkit';
+import { initGenerator } from '../init/init.js';
+import { addPluginsToOxlintConfig } from '../../utils/oxlint-config.js';
+/**
+ * Registers `@nx/oxlint` and enables this project's Oxlint plugins.
+ *
+ * It writes no target: `@nx/oxlint` is inference-only, so the plugin registered
+ * by `init` is what gives the project its Oxlint task.
+ */
+export async function configurationGenerator(tree, options) {
+    const tasks = [];
+    tasks.push(await initGenerator(tree, {
+        skipFormat: true,
+        skipPackageJson: options.skipPackageJson,
+        keepExistingVersions: options.keepExistingVersions,
+    }));
+    // Read before the `plugins` check: `plugins` defaults to `[]`, so gating this
+    // on it means a plain `--project=<typo>` run validates nothing and exits 0.
+    const projectConfig = readProjectConfiguration(tree, options.project);
+    if (options.plugins?.length) {
+        addPluginsToOxlintConfig(tree, projectConfig.root, options.plugins);
+    }
+    if (!options.skipFormat) {
+        await formatFiles(tree);
+    }
+    return runTasksInSerial(...tasks);
+}
+export default configurationGenerator;

package/dist/src/generators/configuration/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "NxOxlintConfiguration",
+  "title": "Configure Oxlint for a project",
+  "description": "Register `@nx/oxlint` and enable this project\u2019s Oxlint plugins.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-prompt": "Which project should use Oxlint?"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files.",
+      "default": false
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "description": "Do not add dependencies to `package.json`.",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "description": "Keep existing dependency versions when possible.",
+      "default": false
+    },
+    "plugins": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Oxlint plugins to enable for this project, such as `react` or `jsx-a11y`.",
+      "default": []
+    }
+  },
+  "required": ["project"],
+  "additionalProperties": false
+}

package/dist/src/generators/init/init.d.ts

@@ -0,0 +1,14 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export interface InitGeneratorSchema {
+    skipPackageJson?: boolean;
+    keepExistingVersions?: boolean;
+    updatePackageScripts?: boolean;
+    skipFormat?: boolean;
+}
+/**
+ * `lint` first so greenfield workspaces get the natural name, falling through
+ * the rest when something else already owns it.
+ */
+export declare const OXLINT_TARGET_NAMES: string[];
+export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;

package/dist/src/generators/init/init.js

@@ -0,0 +1,104 @@
+import { addDependenciesToPackageJson, createProjectGraphAsync, formatFiles, getDependencyVersionFromPackageJson, runTasksInSerial, updateJson, writeJson, } from '@nx/devkit';
+import { addPlugin, assertSupportedPackageVersion } from '@nx/devkit/internal';
+import { createNodes } from '../../plugins/plugin.js';
+import { OXLINT_CONFIG_FILENAMES } from '../../utils/config-file.js';
+import { minSupportedOxlintVersion, nxVersion, oxlintVersion, } from '../../utils/versions.js';
+/**
+ * `lint` first so greenfield workspaces get the natural name, falling through
+ * the rest when something else already owns it.
+ */
+export const OXLINT_TARGET_NAMES = [
+    'lint',
+    'oxlint',
+    'oxlint:lint',
+    'oxlint-lint',
+];
+/**
+ * The candidate target names nothing in the workspace already uses.
+ *
+ * `addPlugin` can resolve this itself, but it does so by running our own
+ * `createNodes` against the real filesystem — where the root config does not
+ * exist yet on a first install, because the `Tree` has not been flushed. Our
+ * plugin returns no projects without a config, so `addPlugin` would see zero
+ * conflicts and take `lint` even in a workspace where ESLint owns it. Reading
+ * the existing graph answers the same question without that dependency.
+ */
+function resolveTargetNames(graph) {
+    const taken = new Set();
+    for (const node of Object.values(graph.nodes ?? {})) {
+        for (const target of Object.keys(node.data?.targets ?? {})) {
+            taken.add(target);
+        }
+    }
+    const available = OXLINT_TARGET_NAMES.filter((name) => !taken.has(name));
+    if (!available.length) {
+        throw new Error(`Could not add the @nx/oxlint plugin: every candidate target name is already in use (${OXLINT_TARGET_NAMES.join(', ')}). Rename one of them, or register the plugin yourself in nx.json with ` +
+            `{ "plugin": "@nx/oxlint", "options": { "targetName": "<name>" } }.`);
+    }
+    // Hand `addPlugin` the whole remaining list rather than one name, so it keeps
+    // its own fallback chain if its per-project probe disagrees with this one.
+    return available;
+}
+export async function initGenerator(tree, options) {
+    assertSupportedPackageVersion(tree, 'oxlint', minSupportedOxlintVersion);
+    const tasks = [];
+    // Registered unconditionally, and deliberately not gated on
+    // `useInferencePlugins` / `NX_ADD_PLUGINS`: `@nx/oxlint` produces tasks only
+    // through inference, so opting out would leave a workspace with no Oxlint
+    // tasks at all rather than a different way of running them. Matches
+    // `@nx/dotnet`, the other inference-only plugin.
+    const graph = await createProjectGraphAsync();
+    await addPlugin(tree, graph, '@nx/oxlint', createNodes, { targetName: resolveTargetNames(graph) }, options.updatePackageScripts);
+    ensureRootConfig(tree);
+    updateVsCodeRecommendedExtensions(tree);
+    if (!options.skipPackageJson) {
+        const devDependencies = { oxlint: oxlintVersion };
+        // Only declare ourselves when absent. `addDependenciesToPackageJson`
+        // compares versions and treats any non-semver range (`link:`, `file:`,
+        // `workspace:`) as lower than whatever it is given, so re-declaring would
+        // replace a deliberate local reference with a plain version.
+        if (!getDependencyVersionFromPackageJson(tree, '@nx/oxlint')) {
+            devDependencies['@nx/oxlint'] = nxVersion;
+        }
+        tasks.push(addDependenciesToPackageJson(tree, {}, devDependencies, undefined, options.keepExistingVersions));
+    }
+    if (!options.skipFormat) {
+        await formatFiles(tree);
+    }
+    return runTasksInSerial(...tasks);
+}
+/**
+ * Appends the official Oxc extension to existing VS Code recommendations.
+ * Only touches the file when it is already there — setting up a linter is not
+ * a reason to start dictating a workspace's editor config.
+ */
+function updateVsCodeRecommendedExtensions(tree) {
+    if (!tree.exists('.vscode/extensions.json')) {
+        return;
+    }
+    updateJson(tree, '.vscode/extensions.json', (json) => {
+        json.recommendations ??= [];
+        const extension = 'oxc.oxc-vscode';
+        if (!json.recommendations.includes(extension)) {
+            json.recommendations.push(extension);
+        }
+        return json;
+    });
+}
+function ensureRootConfig(tree) {
+    if (OXLINT_CONFIG_FILENAMES.some((file) => tree.exists(file))) {
+        return;
+    }
+    // Mirrors what `oxlint --init` scaffolds. The schema is resolved from
+    // `node_modules` rather than a URL so it matches the installed Oxlint
+    // version and works offline; this is only ever written at the workspace
+    // root, where `oxlint` is a direct dependency.
+    writeJson(tree, '.oxlintrc.json', {
+        $schema: './node_modules/oxlint/configuration_schema.json',
+        plugins: ['typescript', 'unicorn', 'oxc'],
+        categories: { correctness: 'error' },
+        rules: {},
+        env: { builtin: true },
+    });
+}
+export default initGenerator;

package/dist/src/generators/init/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "NxOxlintInit",
+  "title": "Initialize Oxlint",
+  "description": "Set up `@nx/oxlint` in the workspace.",
+  "type": "object",
+  "properties": {
+    "skipPackageJson": {
+      "type": "boolean",
+      "description": "Do not add dependencies to `package.json`.",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "description": "Keep existing dependency versions when possible.",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "description": "Update `package.json` scripts to use inferred targets.",
+      "default": true
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files.",
+      "default": false
+    }
+  },
+  "additionalProperties": false
+}

package/dist/src/plugins/plugin.d.ts

@@ -0,0 +1,6 @@
+import { CreateNodes } from '@nx/devkit';
+export interface OxlintPluginOptions {
+    targetName?: string;
+}
+export declare const createNodes: CreateNodes<OxlintPluginOptions>;
+export declare const createNodesV2: CreateNodes<OxlintPluginOptions>;

package/dist/src/plugins/plugin.js

@@ -0,0 +1,458 @@
+import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, calculateHashesForCreateNodes, combineGlobPatterns, globWithWorkspaceContext, hashObject, PluginCache, workspaceDataDirectory, } from '@nx/devkit/internal';
+import { createNodesFromFiles, detectPackageManager, getPackageManagerCommand, readJsonFile, } from '@nx/devkit';
+import { getLockFileName, getRootTsConfigFileName } from '@nx/js';
+import { walkTsconfigExtendsChain, } from '@nx/js/internal';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname as nativeDirname, join as nativeJoin, relative as nativeRelative, sep as nativeSep, } from 'node:path';
+import { basename, dirname, join, normalize, sep } from 'node:path/posix';
+import { OXLINT_CONFIG_FILENAMES } from '../utils/config-file.js';
+/**
+ * Source types Oxlint can parse. It does not lint JSON. Not configurable:
+ * Oxlint picks the files it lints itself, so this only decides whether a
+ * project has anything worth inferring a target for.
+ */
+const LINTABLE_EXTENSIONS = [
+    'js',
+    'mjs',
+    'cjs',
+    'jsx',
+    'ts',
+    'mts',
+    'cts',
+    'tsx',
+    'vue',
+    'svelte',
+    'astro',
+];
+const LINTABLE_FILES_GLOB = `**/*.{${LINTABLE_EXTENSIONS.join(',')}}`;
+const PROJECT_CONFIG_FILENAMES = ['project.json', 'package.json'];
+const OXLINT_CONFIG_GLOB = combineGlobPatterns([
+    ...OXLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+    ...PROJECT_CONFIG_FILENAMES.map((f) => `**/${f}`),
+]);
+const internalCreateNodes = async (configFilePath, options, context, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc, rootConfig) => {
+    const configDir = dirname(configFilePath);
+    // Collect each project root's contribution in parallel, but write them into
+    // `projects` afterwards in input order so insertion order (and therefore
+    // downstream merge order) stays deterministic.
+    const orderedProjectRoots = projectRootsByOxlintRoots.get(configDir) ?? [];
+    const contributions = await Promise.all(orderedProjectRoots.map(async (projectRoot) => {
+        const hash = hashByRoot.get(projectRoot);
+        const cached = projectsCache.get(hash);
+        if (cached) {
+            return cached;
+        }
+        // Require something lintable, so docs-only projects get no target even
+        // when they own a config — a target there fails with "No files found to
+        // lint". This spans the whole workspace, so it stays behind the cache
+        // check and is memoized across configs.
+        const shouldInferTarget = ((await getLintableFilesPerProjectRoot()).get(projectRoot) ?? 0) > 0;
+        if (!shouldInferTarget) {
+            projectsCache.set(hash, {});
+            return null;
+        }
+        const project = getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, tsconfigChainsByProjectRoot.get(projectRoot) ?? [], rootConfig);
+        if (project) {
+            const entry = { [projectRoot]: project };
+            projectsCache.set(hash, entry);
+            return entry;
+        }
+        projectsCache.set(hash, {});
+        return null;
+    }));
+    const projects = {};
+    for (const contribution of contributions) {
+        if (contribution) {
+            Object.assign(projects, contribution);
+        }
+    }
+    return { projects };
+};
+export const createNodes = [
+    OXLINT_CONFIG_GLOB,
+    async (configFiles, options, context) => {
+        options = normalizeOptions(options);
+        const optionsHash = hashObject(options);
+        const cachePath = join(workspaceDataDirectory, `oxlint-${optionsHash}.hash`);
+        const targetsCache = new PluginCache(cachePath);
+        const { oxlintConfigFiles, projectRoots, projectRootsByOxlintRoots } = splitConfigFiles(configFiles, context.workspaceRoot);
+        // The glob also matches `**/package.json`, so this callback runs in every
+        // workspace, Oxlint or not. Bail before the chain walks and the hashing.
+        if (oxlintConfigFiles.length === 0) {
+            return [];
+        }
+        // The most expensive thing here, and only needed on a cache miss. Lazy so a
+        // warm run skips it; memoized so concurrent per-config calls share one glob.
+        let lintableFilesPerProjectRoot;
+        const getLintableFilesPerProjectRoot = () => (lintableFilesPerProjectRoot ??= collectLintableFilesByProjectRoot(projectRoots, context));
+        // Workspace-global and invariant for the whole run, so it is resolved once
+        // here rather than re-stat'ed for every project.
+        const rootConfig = OXLINT_CONFIG_FILENAMES.find((file) => existsSync(join(context.workspaceRoot, file)));
+        const configChainsByConfig = collectConfigChains(oxlintConfigFiles, context.workspaceRoot);
+        const tsconfigChainsByProjectRoot = collectTsconfigChainsByProjectRoot(projectRoots, context.workspaceRoot);
+        // Stats the workspace root, so detect once for both uses below — and after
+        // the bail, so a workspace with no Oxlint config never pays for it.
+        const packageManager = detectPackageManager(context.workspaceRoot);
+        const pmc = getPackageManagerCommand(packageManager);
+        const lockFilePattern = getLockFileName(packageManager);
+        const hashes = await calculateHashesForCreateNodes(projectRoots, options, context, projectRoots.map((root) => {
+            // Own directory and every ancestor. Configs below the root are already
+            // covered by the hasher's `{projectRoot}/**/*` glob.
+            const governingConfigs = oxlintConfigFiles.filter((oxlintConfig) => {
+                const configDir = dirname(oxlintConfig);
+                return configDir === root || isSubDir(configDir, root);
+            });
+            // Deduped: every chain ends at the same root config, and each duplicate
+            // is another whole-workspace glob for the hasher.
+            return [
+                ...new Set([
+                    ...governingConfigs,
+                    ...governingConfigs.flatMap((config) => configChainsByConfig.get(config) ?? []),
+                    lockFilePattern,
+                    ...(tsconfigChainsByProjectRoot.get(root) ?? []),
+                ]),
+            ];
+        }));
+        const hashByRoot = new Map(projectRoots.map((r, i) => [r, hashes[i]]));
+        try {
+            return await createNodesFromFiles((configFile, fileOptions, fileContext) => internalCreateNodes(configFile, fileOptions, fileContext, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc, rootConfig), oxlintConfigFiles, options, context);
+        }
+        finally {
+            targetsCache.writeToDisk();
+        }
+    },
+];
+export const createNodesV2 = createNodes;
+function splitConfigFiles(configFiles, workspaceRoot) {
+    const oxlintConfigFiles = [];
+    const packageJsonFiles = [];
+    const projectJsonRoots = new Set();
+    for (const configFile of configFiles) {
+        const fileName = basename(configFile);
+        if (fileName === 'package.json') {
+            packageJsonFiles.push(configFile);
+        }
+        else if (fileName === 'project.json') {
+            projectJsonRoots.add(dirname(configFile));
+        }
+        else {
+            oxlintConfigFiles.push(configFile);
+        }
+    }
+    // The caller bails on this too, so returning early keeps a workspace with no
+    // Oxlint config from reading the root package.json, pnpm-workspace.yaml and
+    // lerna.json and minimatching every package.json for a discarded result.
+    if (oxlintConfigFiles.length === 0) {
+        return {
+            oxlintConfigFiles,
+            projectRoots: [],
+            projectRootsByOxlintRoots: new Map(),
+        };
+    }
+    // A package.json outside the workspaces globs is not a project: nested marker
+    // files have no `name`, and promoting one fails the whole graph with
+    // ProjectsWithNoNameError. Unconditional on purpose — core admits a root only
+    // when it carries an `nx` key, so empty globs mean core creates no root either.
+    const patterns = buildPackageJsonPatterns(workspaceRoot, (f) => readJsonFile(join(workspaceRoot, f)));
+    const isInPackageManagerWorkspaces = buildPackageJsonWorkspacesMatcher(patterns);
+    const projectRoots = new Set(projectJsonRoots);
+    for (const packageJsonFile of packageJsonFiles) {
+        // Next to a project.json it is a project regardless of the workspaces globs.
+        if (isInPackageManagerWorkspaces(packageJsonFile) ||
+            projectJsonRoots.has(dirname(packageJsonFile))) {
+            projectRoots.add(dirname(packageJsonFile));
+        }
+    }
+    const projectRootsByOxlintRoots = new Map();
+    for (const configFile of oxlintConfigFiles) {
+        projectRootsByOxlintRoots.set(dirname(configFile), []);
+    }
+    for (const projectRoot of projectRoots) {
+        const oxlintRoot = getRootForDirectory(projectRoot, projectRootsByOxlintRoots);
+        if (oxlintRoot) {
+            projectRootsByOxlintRoots.get(oxlintRoot).push(projectRoot);
+        }
+    }
+    return {
+        oxlintConfigFiles,
+        projectRoots: Array.from(projectRoots),
+        projectRootsByOxlintRoots,
+    };
+}
+/**
+ * Resolves each config's `extends` chain to workspace-relative target inputs.
+ * Oxlint resolves entries relative to the referencing config and only tracks the
+ * chain for its LSP, so Nx walks it here or caching goes stale. TypeScript
+ * configs are not statically readable, so only the file itself is tracked.
+ */
+function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
+    const result = new Map();
+    // Shared across configs so the common root config is read once. `null` records
+    // a failed read, so a bad file is not retried per referrer.
+    const jsonCache = new Map();
+    const existsCache = new Map();
+    const configExists = (relativeConfigPath) => {
+        let exists = existsCache.get(relativeConfigPath);
+        if (exists === undefined) {
+            exists = existsSync(join(workspaceRoot, relativeConfigPath));
+            existsCache.set(relativeConfigPath, exists);
+        }
+        return exists;
+    };
+    const readConfig = (relativeConfigPath) => {
+        if (jsonCache.has(relativeConfigPath)) {
+            return jsonCache.get(relativeConfigPath);
+        }
+        let json = null;
+        if (configExists(relativeConfigPath)) {
+            try {
+                json = readJsonFile(join(workspaceRoot, relativeConfigPath), {
+                    expectComments: true,
+                    allowTrailingComma: true,
+                });
+            }
+            catch {
+                // A malformed config drops its chain from the task inputs rather than
+                // failing graph construction, matching `readCachedJson` in @nx/js.
+                json = null;
+            }
+        }
+        jsonCache.set(relativeConfigPath, json);
+        return json;
+    };
+    for (const configFile of oxlintConfigFiles) {
+        const extended = [];
+        const seen = new Set();
+        const walk = (relativeConfigPath) => {
+            if (seen.has(relativeConfigPath)) {
+                return;
+            }
+            seen.add(relativeConfigPath);
+            if (!/\.jsonc?$/.test(relativeConfigPath)) {
+                return;
+            }
+            const json = readConfig(relativeConfigPath);
+            if (!Array.isArray(json?.extends)) {
+                return;
+            }
+            for (const entry of json.extends) {
+                if (typeof entry !== 'string') {
+                    continue;
+                }
+                const resolved = normalize(join(dirname(relativeConfigPath), entry));
+                if (resolved.startsWith('..')) {
+                    continue; // escapes the workspace, cannot be a `{workspaceRoot}` input
+                }
+                // Declared even when absent: an input matching no file costs nothing and
+                // keeps `inputs` stable if the file later appears.
+                extended.push(resolved);
+                if (configExists(resolved)) {
+                    walk(resolved);
+                }
+            }
+        };
+        walk(configFile);
+        result.set(configFile, extended);
+    }
+    return result;
+}
+/**
+ * Per project root, the `extends`-reachable tsconfig files that live OUTSIDE the
+ * project root. Type-aware Oxlint reads the tsconfig, so those have to invalidate
+ * the cache. Mirrors `@nx/eslint`'s equivalent, including its skip cases.
+ */
+function collectTsconfigChainsByProjectRoot(projectRoots, workspaceRoot) {
+    const jsonCache = new Map();
+    const result = new Map();
+    // The root tsconfig is handled by the native selective hasher, which only
+    // hashes the path aliases relevant to each project. Declaring it explicitly
+    // would bypass that and make every project dirty on any change.
+    const rootTsConfigName = getRootTsConfigFileName();
+    for (const projectRoot of projectRoots) {
+        if (projectRoot === '.')
+            continue;
+        const tsconfigPath = join(projectRoot, 'tsconfig.json');
+        if (!existsSync(join(workspaceRoot, tsconfigPath)))
+            continue;
+        const outside = [];
+        const projectPrefix = `${projectRoot}/`;
+        walkTsconfigExtendsChain(join(workspaceRoot, tsconfigPath), (absolutePath) => {
+            const wsRelative = nativeRelative(workspaceRoot, absolutePath)
+                .split(nativeSep)
+                .join('/');
+            if (wsRelative.startsWith('../') || wsRelative === '..') {
+                return 'continue'; // escapes workspace
+            }
+            if (wsRelative.startsWith('node_modules/') ||
+                wsRelative.includes('/node_modules/')) {
+                return 'continue'; // external package, lockfile invalidates
+            }
+            if (wsRelative === projectRoot ||
+                wsRelative.startsWith(projectPrefix)) {
+                return 'continue'; // inside project root, covered by `default`
+            }
+            if (wsRelative === rootTsConfigName) {
+                return 'continue'; // handled by native selective hasher
+            }
+            outside.push(wsRelative);
+            return 'continue';
+        }, { jsonCache });
+        result.set(projectRoot, outside);
+    }
+    return result;
+}
+const localRequire = createRequire(import.meta.url);
+/**
+ * Asks Oxlint itself which files it would lint. A glob cannot answer this:
+ * Oxlint honours `ignorePatterns`, `.eslintignore` and `.gitignore`, including
+ * from nested project configs, so a project whose files are all ignored is
+ * empty to Oxlint but not to a glob.
+ *
+ * Returns null when Oxlint cannot answer — it is not installed, or one
+ * malformed config anywhere aborts the whole run. Callers fall back to globbing
+ * rather than failing graph construction over another project's broken config.
+ */
+function enumerateLintableFilesWithOxlint(workspaceRoot) {
+    let bin;
+    try {
+        bin = nativeJoin(nativeDirname(localRequire.resolve('oxlint/package.json', { paths: [workspaceRoot] })), 'bin', 'oxlint');
+    }
+    catch {
+        return null;
+    }
+    if (!existsSync(bin)) {
+        return null;
+    }
+    try {
+        // Spawned through `process.execPath` rather than the `.bin` shim so this
+        // does not depend on a shell or on PATH.
+        // `--ignore-pattern` rather than trusting the workspace's `.gitignore`:
+        // `globWithWorkspaceContext` always skips `node_modules`, and a workspace
+        // that does not gitignore it would otherwise enumerate every dependency.
+        const stdout = execFileSync(process.execPath, [bin, '--debug=files', '--ignore-pattern', '**/node_modules/**', '.'], {
+            cwd: workspaceRoot,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 64 * 1024 * 1024,
+            windowsHide: true,
+            // Graph construction must not hang on a wedged subprocess; a timeout
+            // throws, which is the same fall-back-to-globbing path as any other
+            // failure here.
+            timeout: 30_000,
+        });
+        return stdout
+            .split('\n')
+            .filter(Boolean)
+            .map((file) => file.split(nativeSep).join(sep));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Counts rather than collects: the only caller asks whether a project has any
+ * lintable file, and the enumeration spans the whole workspace.
+ */
+async function collectLintableFilesByProjectRoot(projectRoots, context) {
+    const lintableFilesPerProjectRoot = new Map();
+    const lintableFiles = enumerateLintableFilesWithOxlint(context.workspaceRoot) ??
+        (await globWithWorkspaceContext(context.workspaceRoot, [
+            LINTABLE_FILES_GLOB,
+        ]));
+    for (const projectRoot of projectRoots) {
+        lintableFilesPerProjectRoot.set(projectRoot, 0);
+    }
+    for (const file of lintableFiles) {
+        const projectRoot = getRootForDirectory(dirname(file), lintableFilesPerProjectRoot);
+        if (projectRoot) {
+            lintableFilesPerProjectRoot.set(projectRoot, lintableFilesPerProjectRoot.get(projectRoot) + 1);
+        }
+    }
+    return lintableFilesPerProjectRoot;
+}
+// Only the keys are read, so the value type is left open for both callers.
+function getRootForDirectory(directory, roots) {
+    let currentPath = normalize(directory);
+    while (currentPath !== dirname(currentPath)) {
+        if (roots.has(currentPath)) {
+            return currentPath;
+        }
+        currentPath = dirname(currentPath);
+    }
+    return roots.has(currentPath) ? currentPath : null;
+}
+function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, tsconfigChainOutsideProjectRoot, rootConfig) {
+    let standaloneSrcPath;
+    if (projectRoot === '.' &&
+        existsSync(join(context.workspaceRoot, projectRoot, 'package.json'))) {
+        if (existsSync(join(context.workspaceRoot, projectRoot, 'src'))) {
+            standaloneSrcPath = 'src';
+        }
+        else if (existsSync(join(context.workspaceRoot, projectRoot, 'lib'))) {
+            standaloneSrcPath = 'lib';
+        }
+    }
+    if (projectRoot === '.' && !standaloneSrcPath) {
+        return null;
+    }
+    const oxlintConfigs = [configFilePath];
+    if (rootConfig && !oxlintConfigs.includes(rootConfig)) {
+        oxlintConfigs.unshift(rootConfig);
+    }
+    // Deduped: a project config that extends the root names it a second time.
+    const configInputs = [
+        ...new Set(oxlintConfigs.flatMap((config) => [
+            config,
+            ...(configChainsByConfig.get(config) ?? []),
+        ])),
+    ];
+    const isRootProject = projectRoot === '.';
+    const lintPath = isRootProject && standaloneSrcPath ? `./${standaloneSrcPath}` : '.';
+    const targetConfig = {
+        command: `oxlint ${lintPath}`,
+        options: { cwd: projectRoot },
+        cache: true,
+        inputs: [
+            'default',
+            '^default',
+            ...configInputs.map((config) => `{workspaceRoot}/${config}`),
+            ...tsconfigChainOutsideProjectRoot.map((file) => `{workspaceRoot}/${file}`),
+            { externalDependencies: ['oxlint'] },
+        ],
+        metadata: {
+            technologies: ['oxlint'],
+            description: 'Runs Oxlint on project',
+            help: {
+                command: `${pmc.exec} oxlint --help`,
+                example: {
+                    options: {
+                        'max-warnings': 0,
+                    },
+                },
+            },
+        },
+    };
+    return {
+        targets: {
+            [options.targetName]: targetConfig,
+        },
+    };
+}
+function normalizeOptions(options) {
+    return {
+        targetName: options?.targetName ?? 'lint',
+    };
+}
+function isSubDir(parent, child) {
+    if (parent === '.') {
+        return true;
+    }
+    parent = normalize(parent);
+    child = normalize(child);
+    if (!parent.endsWith(sep)) {
+        parent += sep;
+    }
+    return child.startsWith(parent);
+}

package/dist/src/utils/config-file.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Config filenames Oxlint discovers on its own, in the order it declares them.
+ * Two configs in the same directory is a hard error in Oxlint, so order here
+ * only affects which one we report — not which one Oxlint uses.
+ * See `apps/oxlint/src/lib.rs` in oxc-project/oxc.
+ */
+export declare const OXLINT_CONFIG_FILENAMES: string[];

package/dist/src/utils/config-file.js

@@ -0,0 +1,12 @@
+/**
+ * Config filenames Oxlint discovers on its own, in the order it declares them.
+ * Two configs in the same directory is a hard error in Oxlint, so order here
+ * only affects which one we report — not which one Oxlint uses.
+ * See `apps/oxlint/src/lib.rs` in oxc-project/oxc.
+ */
+export const OXLINT_CONFIG_FILENAMES = [
+    '.oxlintrc.json',
+    '.oxlintrc.jsonc',
+    'oxlint.config.ts',
+    'oxlint.config.mts',
+];

package/dist/src/utils/oxlint-config.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * Enables Oxlint plugins for a single project, in that project's own config.
+ *
+ * A nested config *replaces* the one above it rather than merging into it, so
+ * the generated config extends its nearest ancestor explicitly. Without that
+ * `extends`, that config's `categories` and `rules` silently stop applying.
+ */
+export declare function addPluginsToOxlintConfig(tree: Tree, projectRoot: string, plugins: string[]): void;

package/dist/src/utils/oxlint-config.js

@@ -0,0 +1,106 @@
+import { joinPathFragments, logger, offsetFromRoot, updateJson, writeJson, } from '@nx/devkit';
+import { OXLINT_CONFIG_FILENAMES } from './config-file.js';
+/**
+ * The root config a root project rewrites in place — though the `.json` check
+ * below still refuses `.jsonc`. Not where generated `extends` targets come from:
+ * those come from the ancestor walk, narrowed by the `.jsonc?` test in
+ * `addPluginsToOxlintConfig` rather than by this list.
+ */
+const EXTENDABLE_CONFIG_FILENAMES = OXLINT_CONFIG_FILENAMES.filter((file) => /\.jsonc?$/.test(file));
+function findRootOxlintConfig(tree) {
+    return EXTENDABLE_CONFIG_FILENAMES.find((file) => tree.exists(file)) ?? null;
+}
+/**
+ * Nearest config above `projectRoot` — the one Oxlint resolves to, and so the
+ * only correct `extends` target. Probes every filename, not just the extendable
+ * ones: walking past a TypeScript ancestor to reach the root would point the
+ * `extends` at a config that is not the one being replaced.
+ */
+function findNearestOxlintConfig(tree, projectRoot) {
+    let dir = projectRoot;
+    while (dir !== '.') {
+        dir = dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : '.';
+        const found = OXLINT_CONFIG_FILENAMES.map((file) => joinPathFragments(dir, file)).find((path) => tree.exists(path));
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+/**
+ * Enables Oxlint plugins for a single project, in that project's own config.
+ *
+ * A nested config *replaces* the one above it rather than merging into it, so
+ * the generated config extends its nearest ancestor explicitly. Without that
+ * `extends`, that config's `categories` and `rules` silently stop applying.
+ */
+export function addPluginsToOxlintConfig(tree, projectRoot, plugins) {
+    if (!plugins.length) {
+        return;
+    }
+    // Probe every filename Oxlint honours, not just the editable ones: two configs
+    // in one directory is a hard error in Oxlint, not an override, so a config we
+    // cannot edit still has to stop us writing `.oxlintrc.json` beside it.
+    const existingProjectConfig = projectRoot === '.'
+        ? undefined
+        : OXLINT_CONFIG_FILENAMES.map((file) => joinPathFragments(projectRoot, file)).find((path) => tree.exists(path));
+    // The governing config's format only constrains us when a project config has
+    // to be created, since that is what needs an `extends` pointing at it. A
+    // project that already has its own editable config can be updated whatever
+    // sits above it. A root project is its own config, so it always needs one.
+    const nearestConfigPath = projectRoot === '.'
+        ? findRootOxlintConfig(tree)
+        : findNearestOxlintConfig(tree, projectRoot);
+    // A TypeScript ancestor governs the project but cannot be extended, so it is
+    // no more usable as a target than having no config at all.
+    const governingConfigPath = nearestConfigPath && /\.jsonc?$/.test(nearestConfigPath)
+        ? nearestConfigPath
+        : null;
+    if (!governingConfigPath && !existingProjectConfig) {
+        // A TypeScript config cannot be rewritten statically. Say so — otherwise
+        // the generator reports success and the plugins silently never run. Name the
+        // file too: it can be an ancestor several levels up, so "your Oxlint config"
+        // sends the user looking in the project directory, where there is nothing.
+        logger.warn(`Could not enable the Oxlint plugin(s) ${plugins.join(', ')} for "${projectRoot}": only JSON Oxlint configs can be updated automatically. ` +
+            `Add them to the "plugins" array of ${nearestConfigPath ? `"${nearestConfigPath}"` : 'your Oxlint config'} manually.`);
+        return;
+    }
+    const projectConfigPath = projectRoot === '.'
+        ? governingConfigPath
+        : (existingProjectConfig ??
+            joinPathFragments(projectRoot, '.oxlintrc.json'));
+    // Only plain JSON survives a rewrite: without this, `updateJson` strips a
+    // `.jsonc`'s comments and throws outright on a TypeScript config.
+    if (!projectConfigPath.endsWith('.json')) {
+        const reason = projectConfigPath.endsWith('.jsonc')
+            ? `rewriting ${projectConfigPath} would strip its comments`
+            : `${projectConfigPath} is not JSON and cannot be updated automatically`;
+        logger.warn(`Could not enable the Oxlint plugin(s) ${plugins.join(', ')} for "${projectRoot}": ${reason}. ` +
+            `Add them to its "plugins" array manually.`);
+        return;
+    }
+    if (tree.exists(projectConfigPath)) {
+        updateJson(tree, projectConfigPath, (json) => {
+            json.plugins = union(json.plugins ?? [], plugins);
+            // Not added automatically: a config without `extends` may be isolating
+            // deliberately. Silent when an `extends` exists (it may reach the governing
+            // config through a preset) or the nearest ancestor is TypeScript.
+            if (governingConfigPath && !json.extends?.length && projectRoot !== '.') {
+                logger.warn(`"${projectRoot}" has an Oxlint config with no "extends", so ${governingConfigPath}'s ` +
+                    `categories and rules do not apply to it. The plugin(s) ${plugins.join(', ')} still run, but under Oxlint's defaults — so this project can pass lint on ` +
+                    `violations ${governingConfigPath} would fail it for. Add "extends": ["${joinPathFragments(offsetFromRoot(projectRoot), governingConfigPath)}"] if that is not intended.`);
+            }
+            return json;
+        });
+        return;
+    }
+    writeJson(tree, projectConfigPath, {
+        extends: [
+            joinPathFragments(offsetFromRoot(projectRoot), governingConfigPath),
+        ],
+        plugins: [...plugins],
+    });
+}
+function union(a, b) {
+    return Array.from(new Set([...a, ...b]));
+}

package/dist/src/utils/versions.d.ts

@@ -0,0 +1,14 @@
+export declare const nxVersion: string;
+/**
+ * The inference plugin enumerates lintable files by spawning
+ * `oxlint --debug=files`, which needs two things that only line up from 1.70.0:
+ * the `--debug` flag itself, and a `./package.json` entry in Oxlint's `exports`
+ * so `require.resolve('oxlint/package.json')` can locate the binary. Below that
+ * both fail and inference silently loses ignore-awareness.
+ *
+ * Earlier floors this supersedes: `oxlint.config.ts` support (oxc #17563) in
+ * 1.43.0, which `OXLINT_CONFIG_FILENAMES` still depends on, the JS plugin API
+ * the boundaries bridge needs in 1.16.0, and `--type-aware` in 1.11.0.
+ */
+export declare const minSupportedOxlintVersion = "1.70.0";
+export declare const oxlintVersion = "^1.75.0";

package/dist/src/utils/versions.js

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export const nxVersion = require('@nx/oxlint/package.json').version;
+/**
+ * The inference plugin enumerates lintable files by spawning
+ * `oxlint --debug=files`, which needs two things that only line up from 1.70.0:
+ * the `--debug` flag itself, and a `./package.json` entry in Oxlint's `exports`
+ * so `require.resolve('oxlint/package.json')` can locate the binary. Below that
+ * both fail and inference silently loses ignore-awareness.
+ *
+ * Earlier floors this supersedes: `oxlint.config.ts` support (oxc #17563) in
+ * 1.43.0, which `OXLINT_CONFIG_FILENAMES` still depends on, the JS plugin API
+ * the boundaries bridge needs in 1.16.0, and `--type-aware` in 1.11.0.
+ */
+export const minSupportedOxlintVersion = '1.70.0';
+export const oxlintVersion = '^1.75.0';

package/generators.json

@@ -0,0 +1,18 @@
+{
+  "name": "Nx Oxlint",
+  "version": "0.1",
+  "generators": {
+    "init": {
+      "factory": "./dist/src/generators/init/init#initGenerator",
+      "schema": "./dist/src/generators/init/schema.json",
+      "description": "Initialize the `@nx/oxlint` plugin.",
+      "aliases": ["ng-add"],
+      "hidden": true
+    },
+    "configuration": {
+      "factory": "./dist/src/generators/configuration/configuration#configurationGenerator",
+      "schema": "./dist/src/generators/configuration/schema.json",
+      "description": "Configure Oxlint for a project."
+    }
+  }
+}

package/migrations.json

@@ -0,0 +1,4 @@
+{
+  "generators": {},
+  "packageJsonUpdates": {}
+}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@nx/oxlint",
+  "description": "Experimental. The Oxlint plugin for Nx contains generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "migrations.json",
+    "generators.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nrwl/nx.git",
+    "directory": "packages/oxlint"
+  },
+  "bugs": {
+    "url": "https://github.com/nrwl/nx/issues"
+  },
+  "keywords": [
+    "Monorepo",
+    "Web",
+    "Lint",
+    "Oxlint",
+    "CLI"
+  ],
+  "author": "Victor Savkin",
+  "license": "MIT",
+  "homepage": "https://nx.dev",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "generators": [
+        "dist/generators.d.ts"
+      ],
+      "boundaries-plugin": [
+        "dist/src/boundaries-plugin/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "@nx/nx-source": "./index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./migrations.json": "./migrations.json",
+    "./generators.json": "./generators.json",
+    "./generators": {
+      "@nx/nx-source": "./generators.ts",
+      "types": "./dist/generators.d.ts",
+      "default": "./dist/generators.js"
+    },
+    "./boundaries-plugin": {
+      "@nx/nx-source": "./src/boundaries-plugin/index.ts",
+      "types": "./dist/src/boundaries-plugin/index.d.ts",
+      "default": "./dist/src/boundaries-plugin/index.js"
+    }
+  },
+  "nx-migrations": {
+    "migrations": "./migrations.json",
+    "supportsOptionalMigrations": true
+  },
+  "generators": "./generators.json",
+  "dependencies": {
+    "@nx/devkit": "workspace:*",
+    "@nx/eslint-plugin": "workspace:*",
+    "@nx/js": "workspace:*",
+    "tslib": "catalog:typescript"
+  },
+  "peerDependencies": {
+    "oxlint": "^1.43.0"
+  },
+  "peerDependenciesMeta": {
+    "oxlint": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "devDependencies": {
+    "nx": "workspace:*"
+  }
+}