@vizejs/nuxt-lint-config 0.315.1

package/README.md

@@ -0,0 +1,26 @@
+# `@vizejs/nuxt-lint-config`
+
+The engine-neutral, shareable Nuxt lint preset core used by `@vizejs/nuxt`.
+It ports the project-aware directory, feature, and rule-block decisions from
+`@nuxt/eslint-config` without requiring Nuxt or ESLint at runtime.
+
+```ts
+import {
+  buildNuxtLintPlan,
+  resolveNuxtLintDirs,
+  resolveNuxtLintFeatures,
+} from "@vizejs/nuxt-lint-config";
+
+const dirs = resolveNuxtLintDirs({ src: ["src"] });
+const features = resolveNuxtLintFeatures({ stylistic: true }, () => true);
+const plan = buildNuxtLintPlan(features, dirs);
+```
+
+The result is an ordered, engine-neutral plan using eslint-compatible rule
+identifiers. `@vizejs/nuxt` consumes the same exports and emits them for
+Vize's oxlint integration, so the module and standalone entry point cannot
+drift into separate implementations.
+
+Compatibility is pinned to the real `@nuxt/eslint` and
+`@nuxt/eslint-config` packages by the committed differential oracle under
+`test/nuxt-eslint-compat`.

package/dist/index.d.mts

@@ -0,0 +1,227 @@
+//#region src/dirs.d.ts
+/** A component directory declaration on a Nuxt layer. */
+type NuxtComponentDirDeclaration = string | {
+  path?: string;
+  prefix?: string;
+  [key: string]: unknown;
+};
+/** The subset of a Nuxt layer's config that lint directories are derived from. */
+interface NuxtLintLayer {
+  srcDir: string;
+  imports?: {
+    dirs?: Array<string | undefined | null>;
+  };
+  components?: boolean | NuxtComponentDirDeclaration[] | {
+    dirs?: NuxtComponentDirDeclaration[];
+  };
+}
+/** The `nuxt.options.dir` overrides that lint directories honour. */
+interface NuxtLintDirNames {
+  pages?: string;
+  layouts?: string;
+  plugins?: string;
+  middleware?: string;
+  modules?: string;
+}
+/** The Nuxt project state lint directories are derived from. */
+interface NuxtLintProjectState {
+  /** Directory the emitted globs are relative to. */
+  rootDir: string;
+  /** `nuxt.options.dir`. Missing entries fall back to their Nuxt defaults. */
+  dir?: NuxtLintDirNames;
+  /** `nuxt.options._layers`, in Nuxt's own order. */
+  layers: NuxtLintLayer[];
+}
+/** Every directory list the generated lint config globs over. */
+interface NuxtLintDirs {
+  pages: string[];
+  composables: string[];
+  components: string[];
+  componentsPrefixed: string[];
+  layouts: string[];
+  plugins: string[];
+  middleware: string[];
+  modules: string[];
+  servers: string[];
+  root: string[];
+  src: string[];
+}
+/**
+ * The key order of {@link NuxtLintDirs}.
+ *
+ * Upstream serialises `dirs` with `Object.entries`, so this order is observable
+ * in the generated config file and the oracle asserts it.
+ */
+declare const NUXT_LINT_DIR_KEYS: readonly ["pages", "composables", "components", "componentsPrefixed", "layouts", "plugins", "middleware", "modules", "servers", "root", "src"];
+/**
+ * Derive every lint directory from the Nuxt project state.
+ *
+ * `servers` and `root` are intentionally left empty: upstream's `getDirs` never
+ * populates them, and because an empty array is truthy the `||=` defaults in
+ * `resolveNuxtLintDirs` do not fire for a module-generated config either. The
+ * oracle pins that, so a future upstream change surfaces as a failure rather
+ * than as a silently different set of linted files.
+ */
+declare function collectNuxtLintDirs(state: NuxtLintProjectState): NuxtLintDirs;
+/**
+ * Apply the directory defaults used when a config is written by hand rather
+ * than generated from a Nuxt instance.
+ *
+ * Upstream uses `||=`, so a directory list that is present but empty keeps its
+ * empty value. This port reproduces that, because generated configs rely on it.
+ */
+declare function resolveNuxtLintDirs(dirs: Partial<NuxtLintDirs> | undefined): NuxtLintDirs;
+//#endregion
+//#region src/features.d.ts
+/**
+ * Feature-flag resolution for the shareable Nuxt lint config.
+ *
+ * This is a behavioural port of `resolveOptions().features` in
+ * `@nuxt/eslint-config` (see `test/nuxt-eslint-compat/`). The defaults are
+ * load-bearing: they decide which config blocks the generator emits, so they
+ * are pinned against the real package by the differential oracle rather than
+ * restated from documentation.
+ */
+/** Options for the Nuxt-specific rule block. */
+interface NuxtLintNuxtOptions {
+  /**
+   * Enforce a recommended key order in `nuxt.config`.
+   *
+   * @default true when `stylistic` is enabled
+   */
+  sortConfigKeys?: boolean;
+}
+/** Options for the tooling (module/library author) rule blocks. */
+interface NuxtLintToolingOptions {
+  /** @default true */
+  regexp?: boolean;
+  /** @default true */
+  unicorn?: boolean;
+  /** @default true */
+  jsdoc?: boolean;
+}
+/** Options for the import rule block. */
+interface NuxtLintImportOptions {
+  /** @default "eslint-plugin-import-x" */
+  package?: "eslint-plugin-import-lite" | "eslint-plugin-import-x";
+}
+/** Options for the TypeScript rule block. */
+interface NuxtLintTypeScriptOptions {
+  /** @default true */
+  strict?: boolean;
+  /** Enables type-aware rules when set. */
+  tsconfigPath?: string;
+}
+/**
+ * The `features` surface of the generated lint config.
+ *
+ * Mirrors `NuxtESLintFeaturesOptions` from `@nuxt/eslint-config`.
+ */
+interface NuxtLintFeatures {
+  /**
+   * Set up the baseline JavaScript, TypeScript and Vue rule blocks.
+   *
+   * @default true
+   */
+  standalone?: boolean;
+  /**
+   * Enable rules aimed at Nuxt module and library authors.
+   *
+   * @default false
+   */
+  tooling?: boolean | NuxtLintToolingOptions;
+  /**
+   * Enable the import rule block.
+   *
+   * @default true
+   */
+  import?: boolean | NuxtLintImportOptions;
+  /**
+   * Enable stylistic (formatting) rules.
+   *
+   * @default false
+   */
+  stylistic?: boolean | Record<string, unknown>;
+  /**
+   * Enable formatter delegation for non-script file types.
+   *
+   * @default false
+   */
+  formatters?: boolean | Record<string, unknown>;
+  /** Options for the Nuxt-specific rule block. */
+  nuxt?: NuxtLintNuxtOptions;
+  /**
+   * Enable TypeScript support.
+   *
+   * Defaults to whether `typescript` is resolvable from the project.
+   */
+  typescript?: boolean | NuxtLintTypeScriptOptions;
+}
+/** Every feature flag with its default applied. */
+interface ResolvedNuxtLintFeatures {
+  standalone: boolean;
+  stylistic: boolean | Record<string, unknown>;
+  typescript: boolean | NuxtLintTypeScriptOptions;
+  tooling: boolean | NuxtLintToolingOptions;
+  formatters: boolean | Record<string, unknown>;
+  nuxt: NuxtLintNuxtOptions;
+  import: boolean | NuxtLintImportOptions;
+}
+/**
+ * Whether TypeScript is present in the project.
+ *
+ * `@nuxt/eslint-config` calls `local-pkg`'s `isPackageExists("typescript")`
+ * here. The probe is injected so the resolver stays a pure function: the
+ * generator passes the real detection, tests pass a fixed answer.
+ */
+type TypeScriptProbe = () => boolean;
+/**
+ * Apply `@nuxt/eslint-config`'s feature defaults.
+ *
+ * Note that only *missing* keys take a default: an explicitly passed
+ * `undefined` value is spread over the defaults by the upstream implementation
+ * and therefore wins, which this port reproduces by spreading the same way.
+ */
+declare function resolveNuxtLintFeatures(features: NuxtLintFeatures | undefined, hasTypeScript: TypeScriptProbe): ResolvedNuxtLintFeatures;
+/**
+ * Whether `nuxt/nuxt-config-keys-order` is enabled.
+ *
+ * Upstream reads `features.nuxt.sortConfigKeys` and falls back to
+ * `!!features.stylistic`, so enabling stylistic rules also turns on config-key
+ * sorting unless the project opts out explicitly.
+ */
+declare function shouldSortNuxtConfigKeys(features: ResolvedNuxtLintFeatures): boolean;
+//#endregion
+//#region src/plan.d.ts
+/** Extensions every Nuxt-aware glob covers. */
+declare const NUXT_LINT_GLOB_EXTS = "{js,ts,jsx,tsx,vue}";
+/** Globs matching a `nuxt.config` file in either supported location. */
+declare const NUXT_CONFIG_GLOBS: readonly ["**/.config/nuxt.?([cm])[jt]s?(x)", "**/nuxt.config.?([cm])[jt]s?(x)"];
+/** Directories the generated config never lints. */
+declare const NUXT_LINT_IGNORES: readonly ["**/dist", "**/node_modules", "**/.nuxt", "**/.output", "**/.vercel", "**/.netlify", "**/public"];
+/** A severity as it appears in the plan. */
+type NuxtLintSeverity = "off" | "warn" | "error";
+/** One item of the generated config: a named block of rules over a glob set. */
+interface NuxtLintConfigItem {
+  /** Stable identity, matching `@nuxt/eslint`'s config item names. */
+  name: string;
+  /** Files the block applies to. Absent means "every linted file". */
+  files?: string[];
+  /** Paths excluded from linting entirely. */
+  ignores?: string[];
+  /** Rule severities keyed by eslint-compatible rule id. */
+  rules?: Record<string, NuxtLintSeverity>;
+  /** Globals the block declares, so undefined-variable rules stay quiet. */
+  globals?: Record<string, "readonly" | "writable">;
+}
+/** Runtime globals Nuxt injects into every linted file. */
+declare const NUXT_RUNTIME_GLOBALS: Record<string, "readonly">;
+/**
+ * Build the Nuxt-specific part of the generated lint config, in emission order.
+ *
+ * The order is observable — later items override earlier ones — so it is part
+ * of the contract the oracle pins, not an implementation detail.
+ */
+declare function buildNuxtLintPlan(features: ResolvedNuxtLintFeatures, dirs: NuxtLintDirs): NuxtLintConfigItem[];
+//#endregion
+export { NUXT_CONFIG_GLOBS, NUXT_LINT_DIR_KEYS, NUXT_LINT_GLOB_EXTS, NUXT_LINT_IGNORES, NUXT_RUNTIME_GLOBALS, type NuxtComponentDirDeclaration, type NuxtLintConfigItem, type NuxtLintDirNames, type NuxtLintDirs, type NuxtLintFeatures, type NuxtLintImportOptions, type NuxtLintLayer, type NuxtLintNuxtOptions, type NuxtLintProjectState, type NuxtLintSeverity, type NuxtLintToolingOptions, type NuxtLintTypeScriptOptions, type ResolvedNuxtLintFeatures, type TypeScriptProbe, buildNuxtLintPlan, collectNuxtLintDirs, resolveNuxtLintDirs, resolveNuxtLintFeatures, shouldSortNuxtConfigKeys };

package/dist/index.mjs

@@ -0,0 +1,281 @@
+import { posix } from "node:path";
+//#region src/paths.ts
+/**
+* POSIX path helpers with upstream `pathe` semantics.
+*
+* `@nuxt/eslint` builds every lint directory and glob with `pathe`, which
+* normalises Windows separators to `/` and then behaves like `node:path/posix`.
+* The generated globs are matched against POSIX-normalised paths on every
+* platform, so reproducing that normalisation is what makes the Windows output
+* identical to the Linux and macOS output.
+*/
+/** Replace Windows separators so POSIX path maths applies uniformly. */
+function toPosix(value) {
+	return value.replace(/\\/g, "/");
+}
+/** `pathe.join` — POSIX join over separator-normalised segments. */
+function posixJoin(...segments) {
+	return posix.join(...segments.map(toPosix));
+}
+/** `pathe.resolve` — POSIX resolve over separator-normalised segments. */
+function posixResolve(...segments) {
+	return posix.resolve(...segments.map(toPosix));
+}
+/** `pathe.relative` — POSIX relative over separator-normalised paths. */
+function posixRelative(from, to) {
+	return posix.relative(toPosix(from), toPosix(to));
+}
+//#endregion
+//#region src/dirs.ts
+/**
+* Project-state to shareable lint-directory resolution.
+*
+* This is a behavioural port of `getDirs()` in `@nuxt/eslint` plus the `dirs`
+* defaulting in `@nuxt/eslint-config`'s `resolveOptions()`. Every directory the
+* generated lint config globs over is derived here, so this module is the input
+* both the config emitter and the dev-server checker read.
+*
+* The exact resolution is pinned against the real packages by the differential
+* oracle in `test/nuxt-eslint-compat/`.
+*/
+/**
+* The key order of {@link NuxtLintDirs}.
+*
+* Upstream serialises `dirs` with `Object.entries`, so this order is observable
+* in the generated config file and the oracle asserts it.
+*/
+const NUXT_LINT_DIR_KEYS = [
+	"pages",
+	"composables",
+	"components",
+	"componentsPrefixed",
+	"layouts",
+	"plugins",
+	"middleware",
+	"modules",
+	"servers",
+	"root",
+	"src"
+];
+function emptyDirs() {
+	return {
+		pages: [],
+		composables: [],
+		components: [],
+		componentsPrefixed: [],
+		layouts: [],
+		plugins: [],
+		middleware: [],
+		modules: [],
+		servers: [],
+		root: [],
+		src: []
+	};
+}
+/**
+* Normalise one layer-relative path into a root-relative POSIX path.
+*
+* The `~/` (and `~\`) prefix is stripped rather than resolved: upstream treats a
+* tilde-prefixed `imports.dirs` entry as srcDir-relative, which is the same
+* thing Nuxt's own alias resolution does for that option.
+*/
+function layerRelative(rootDir, srcDir, target) {
+	return posixRelative(rootDir, posixResolve(srcDir, target.replace(/^~[/\\]/, "")));
+}
+function collectComponentDirs(layer, dirs, toRootRelative) {
+	if (!layer.components || layer.components === true) {
+		dirs.components.push(toRootRelative("components"));
+		return;
+	}
+	const declarations = Array.isArray(layer.components) ? layer.components : layer.components.dirs ?? [];
+	for (const declaration of declarations) {
+		if (typeof declaration === "string") {
+			dirs.components.push(toRootRelative(declaration));
+			continue;
+		}
+		if (!declaration || typeof declaration.path !== "string") continue;
+		dirs.components.push(toRootRelative(declaration.path));
+		if (declaration.prefix) dirs.componentsPrefixed.push(toRootRelative(declaration.path));
+	}
+}
+/**
+* Derive every lint directory from the Nuxt project state.
+*
+* `servers` and `root` are intentionally left empty: upstream's `getDirs` never
+* populates them, and because an empty array is truthy the `||=` defaults in
+* `resolveNuxtLintDirs` do not fire for a module-generated config either. The
+* oracle pins that, so a future upstream change surfaces as a failure rather
+* than as a silently different set of linted files.
+*/
+function collectNuxtLintDirs(state) {
+	const dirs = emptyDirs();
+	const dirNames = state.dir ?? {};
+	for (const layer of state.layers) {
+		const toRootRelative = (target) => layerRelative(state.rootDir, layer.srcDir, target);
+		dirs.src.push(toRootRelative(""));
+		dirs.pages.push(toRootRelative(dirNames.pages || "pages"));
+		dirs.layouts.push(toRootRelative(dirNames.layouts || "layouts"));
+		dirs.plugins.push(toRootRelative(dirNames.plugins || "plugins"));
+		dirs.middleware.push(toRootRelative(dirNames.middleware || "middleware"));
+		dirs.modules.push(toRootRelative(dirNames.modules || "modules"));
+		dirs.composables.push(toRootRelative("composables"));
+		dirs.composables.push(toRootRelative("utils"));
+		for (const dir of layer.imports?.dirs ?? []) if (dir) dirs.composables.push(toRootRelative(dir));
+		collectComponentDirs(layer, dirs, toRootRelative);
+	}
+	return dirs;
+}
+/**
+* Apply the directory defaults used when a config is written by hand rather
+* than generated from a Nuxt instance.
+*
+* Upstream uses `||=`, so a directory list that is present but empty keeps its
+* empty value. This port reproduces that, because generated configs rely on it.
+*/
+function resolveNuxtLintDirs(dirs) {
+	const resolved = { ...dirs };
+	resolved.root ||= [".", "./app"];
+	resolved.src ||= resolved.root;
+	const src = resolved.src;
+	resolved.pages ||= src.map((dir) => `${dir}/pages`);
+	resolved.layouts ||= src.map((dir) => `${dir}/layouts`);
+	resolved.components ||= src.map((dir) => `${dir}/components`);
+	resolved.composables ||= src.map((dir) => `${dir}/composables`);
+	resolved.plugins ||= src.map((dir) => `${dir}/plugins`);
+	resolved.modules ||= src.map((dir) => `${dir}/modules`);
+	resolved.middleware ||= src.map((dir) => `${dir}/middleware`);
+	resolved.servers ||= src.map((dir) => `${dir}/servers`);
+	resolved.componentsPrefixed ||= [];
+	return resolved;
+}
+//#endregion
+//#region src/features.ts
+/**
+* Apply `@nuxt/eslint-config`'s feature defaults.
+*
+* Note that only *missing* keys take a default: an explicitly passed
+* `undefined` value is spread over the defaults by the upstream implementation
+* and therefore wins, which this port reproduces by spreading the same way.
+*/
+function resolveNuxtLintFeatures(features, hasTypeScript) {
+	return {
+		standalone: true,
+		stylistic: false,
+		typescript: hasTypeScript(),
+		tooling: false,
+		formatters: false,
+		nuxt: {},
+		import: {},
+		...features
+	};
+}
+/**
+* Whether `nuxt/nuxt-config-keys-order` is enabled.
+*
+* Upstream reads `features.nuxt.sortConfigKeys` and falls back to
+* `!!features.stylistic`, so enabling stylistic rules also turns on config-key
+* sorting unless the project opts out explicitly.
+*/
+function shouldSortNuxtConfigKeys(features) {
+	const { sortConfigKeys = !!features.stylistic } = features.nuxt || {};
+	return sortConfigKeys;
+}
+//#endregion
+//#region src/plan.ts
+/** Extensions every Nuxt-aware glob covers. */
+const NUXT_LINT_GLOB_EXTS = "{js,ts,jsx,tsx,vue}";
+/** Globs matching a `nuxt.config` file in either supported location. */
+const NUXT_CONFIG_GLOBS = ["**/.config/nuxt.?([cm])[jt]s?(x)", "**/nuxt.config.?([cm])[jt]s?(x)"];
+/** Directories the generated config never lints. */
+const NUXT_LINT_IGNORES = [
+	"**/dist",
+	"**/node_modules",
+	"**/.nuxt",
+	"**/.output",
+	"**/.vercel",
+	"**/.netlify",
+	"**/public"
+];
+/** Runtime globals Nuxt injects into every linted file. */
+const NUXT_RUNTIME_GLOBALS = { $fetch: "readonly" };
+const nestedGlob = `**/*.${NUXT_LINT_GLOB_EXTS}`;
+/**
+* Files allowed to have a single-word component name.
+*
+* Nuxt gives `app` and `error` a special meaning, layouts and pages are never
+* referenced by tag name, and prefixed component directories get their name
+* from the prefix — so `vue/multi-word-component-names` is off for all of them.
+*/
+function routeFiles(dirs) {
+	return [...new Set([
+		...dirs.src.flatMap((dir) => [posixJoin(dir, `app.${NUXT_LINT_GLOB_EXTS}`), posixJoin(dir, `error.${NUXT_LINT_GLOB_EXTS}`)]),
+		...dirs.layouts.map((dir) => posixJoin(dir, nestedGlob)),
+		...dirs.pages.map((dir) => posixJoin(dir, nestedGlob)),
+		...dirs.components.map((dir) => posixJoin(dir, "*", nestedGlob)),
+		...dirs.componentsPrefixed.map((dir) => posixJoin(dir, nestedGlob))
+	])].sort();
+}
+/** Files that must render exactly one root element. */
+function singleRootFiles(dirs) {
+	return [
+		...dirs.layouts.map((dir) => posixJoin(dir, nestedGlob)),
+		...dirs.pages.map((dir) => posixJoin(dir, nestedGlob)),
+		...dirs.components.map((dir) => posixJoin(dir, `**/*.server.${NUXT_LINT_GLOB_EXTS}`))
+	].sort();
+}
+/** Files where `definePageMeta` is extracted at build time. */
+function pageFiles(dirs) {
+	return dirs.pages.map((dir) => posixJoin(dir, nestedGlob)).sort();
+}
+/**
+* Build the Nuxt-specific part of the generated lint config, in emission order.
+*
+* The order is observable — later items override earlier ones — so it is part
+* of the contract the oracle pins, not an implementation detail.
+*/
+function buildNuxtLintPlan(features, dirs) {
+	const items = [];
+	if (features.standalone !== false) items.push({
+		name: "nuxt/ignores",
+		ignores: [...NUXT_LINT_IGNORES]
+	});
+	items.push({
+		name: "nuxt/setup",
+		globals: { ...NUXT_RUNTIME_GLOBALS }
+	});
+	const singleRoot = singleRootFiles(dirs);
+	if (singleRoot.length > 0) items.push({
+		name: "nuxt/vue/single-root",
+		files: singleRoot,
+		rules: { "vue/no-multiple-template-root": "error" }
+	});
+	items.push({
+		name: "nuxt/rules",
+		rules: { "nuxt/prefer-import-meta": "error" }
+	});
+	const pages = pageFiles(dirs);
+	if (pages.length > 0) items.push({
+		name: "nuxt/pages",
+		files: pages,
+		rules: { "nuxt/no-page-meta-runtime-values": "error" }
+	});
+	items.push({
+		name: "nuxt/nuxt-config",
+		files: [...NUXT_CONFIG_GLOBS],
+		rules: { "nuxt/no-nuxt-config-test-key": "error" }
+	});
+	if (shouldSortNuxtConfigKeys(features)) items.push({
+		name: "nuxt/sort-config",
+		files: [...NUXT_CONFIG_GLOBS],
+		rules: { "nuxt/nuxt-config-keys-order": "error" }
+	});
+	const routes = routeFiles(dirs);
+	if (routes.length > 0) items.push({
+		name: "nuxt/disables/routes",
+		files: routes,
+		rules: { "vue/multi-word-component-names": "off" }
+	});
+	return items;
+}
+//#endregion
+export { NUXT_CONFIG_GLOBS, NUXT_LINT_DIR_KEYS, NUXT_LINT_GLOB_EXTS, NUXT_LINT_IGNORES, NUXT_RUNTIME_GLOBALS, buildNuxtLintPlan, collectNuxtLintDirs, resolveNuxtLintDirs, resolveNuxtLintFeatures, shouldSortNuxtConfigKeys };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@vizejs/nuxt-lint-config",
+  "version": "0.315.1",
+  "description": "Shareable Nuxt-aware lint preset core for the Vize toolchain",
+  "keywords": [
+    "config",
+    "lint",
+    "nuxt",
+    "oxlint",
+    "preset",
+    "vize",
+    "vue"
+  ],
+  "homepage": "https://github.com/ubugeeei-prod/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei-prod/vize/issues"
+  },
+  "license": "MIT",
+  "author": "ubugeeei",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei-prod/vize.git",
+    "directory": "npm/framework/nuxt-lint-config"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "pnpm build && node --test src/*.test.ts",
+    "check": "vp check src vite.config.ts",
+    "check:fix": "vp check --fix src vite.config.ts",
+    "fmt": "vp fmt --write src vite.config.ts"
+  },
+  "devDependencies": {
+    "@types/node": "25.9.2",
+    "typescript": "6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.21",
+    "vite-plus": "0.1.21"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}