@od-oneapp/config 2026.2.2001-canary.1

package/eslint/rules/no-used-underscore-vars.mjs

@@ -0,0 +1,297 @@
+/**
+ * @fileoverview Custom ESLint rule: no-used-underscore-vars
+ *
+ * Prevents using variables that start with underscore (convention for unused variables).
+ * Allows underscore-prefixed variables in declaration contexts but disallows them in usage contexts.
+ *
+ * @module no-used-underscore-vars
+ */
+
+/**
+ * AST node type constants for type safety and maintainability.
+ *
+ * @type {Record<string, string>}
+ */
+const AST_NODE_TYPES = {
+  VARIABLE_DECLARATOR: 'VariableDeclarator',
+  FUNCTION_DECLARATION: 'FunctionDeclaration',
+  REST_ELEMENT: 'RestElement',
+  ARRAY_PATTERN: 'ArrayPattern',
+  FUNCTION_EXPRESSION: 'FunctionExpression',
+  ARROW_FUNCTION_EXPRESSION: 'ArrowFunctionExpression',
+  TS_INTERFACE_DECLARATION: 'TSInterfaceDeclaration',
+  TS_TYPE_ALIAS_DECLARATION: 'TSTypeAliasDeclaration',
+  TS_PROPERTY_SIGNATURE: 'TSPropertySignature',
+  TS_TYPE_PARAMETER: 'TSTypeParameter',
+  TS_PARAMETER_PROPERTY: 'TSParameterProperty',
+  CLASS_DECLARATION: 'ClassDeclaration',
+  CLASS_EXPRESSION: 'ClassExpression',
+  MEMBER_EXPRESSION: 'MemberExpression',
+  PROPERTY: 'Property',
+  OBJECT_PATTERN: 'ObjectPattern',
+  OBJECT_EXPRESSION: 'ObjectExpression',
+  CATCH_CLAUSE: 'CatchClause',
+  ASSIGNMENT_PATTERN: 'AssignmentPattern',
+};
+
+/**
+ * Parent types where underscore-prefixed identifiers are allowed (declaration contexts).
+ *
+ * These AST node types represent declaration positions where underscore-prefixed
+ * variables are intentionally unused and should be allowed.
+ *
+ * @type {readonly string[]}
+ */
+const ALLOWED_PARENT_TYPES = [
+  AST_NODE_TYPES.VARIABLE_DECLARATOR,
+  AST_NODE_TYPES.FUNCTION_DECLARATION,
+  AST_NODE_TYPES.REST_ELEMENT,
+  AST_NODE_TYPES.ARRAY_PATTERN,
+  AST_NODE_TYPES.FUNCTION_EXPRESSION,
+  AST_NODE_TYPES.ARROW_FUNCTION_EXPRESSION,
+  AST_NODE_TYPES.TS_INTERFACE_DECLARATION,
+  AST_NODE_TYPES.TS_TYPE_ALIAS_DECLARATION,
+  AST_NODE_TYPES.CATCH_CLAUSE,
+  AST_NODE_TYPES.TS_TYPE_PARAMETER,
+  AST_NODE_TYPES.CLASS_DECLARATION,
+  AST_NODE_TYPES.CLASS_EXPRESSION,
+];
+
+/**
+ * Checks if a node is within a VariableDeclarator's init (right side - a usage).
+ *
+ * VariableDeclarator nodes have two sides:
+ * - `id` (left side): Declaration position - underscore vars allowed
+ * - `init` (right side): Usage position - underscore vars disallowed
+ *
+ * This helper walks up the AST tree to determine if the node is in the init position,
+ * which indicates a usage context where underscore-prefixed variables should be reported.
+ *
+ * @param {import('eslint').Rule.Node} node - The AST node to check
+ * @returns {boolean} `true` if node is in init position (usage context), `false` otherwise
+ *
+ * @example
+ * ```javascript
+ * // false - _unused is in id (left side, declaration)
+ * const _unused = value;
+ *
+ * // true - _unused is in init (right side, usage)
+ * const x = _unused;
+ * ```
+ *
+ * @internal
+ */
+function isInVariableDeclaratorInit(node) {
+  if (node.parent.type !== AST_NODE_TYPES.VARIABLE_DECLARATOR) {
+    return false;
+  }
+
+  // Walk up the tree to find the first ancestor that is a direct child of VariableDeclarator
+  let current = node;
+  while (current && current.parent !== node.parent) {
+    current = current.parent;
+  }
+
+  // If we're on the init side, it's a usage - report error
+  return current === node.parent.init;
+}
+
+/**
+ * ESLint rule to prevent using variables that start with underscore.
+ *
+ * Underscore-prefixed variables are conventionally used to indicate unused variables.
+ * This rule enforces that underscore-prefixed variables should only be used in
+ * declaration contexts (where they're intentionally unused), not in usage contexts.
+ *
+ * @example
+ * // ✅ Valid: Declaration context
+ * const _unused = 1;
+ * function _helper() {}
+ * const { _prop } = obj;
+ *
+ * @example
+ * // ✅ Valid: Property access (not a variable usage)
+ * obj._id
+ * obj._private
+ *
+ * @example
+ * // ✅ Valid: Type definitions
+ * interface Foo { _prop: string; }
+ * type Bar = { _field: number; }
+ *
+ * @example
+ * // ❌ Invalid: Usage context
+ * const x = _unused; // Error: underscore variable used
+ * if (_condition) {} // Error: underscore variable used
+ * function test() { return _value; } // Error: underscore variable used
+ *
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow using variables that start with underscore',
+      recommended: false,
+      category: 'Best Practices',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allow: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    fixable: null,
+  },
+  /**
+   * Creates the rule implementation.
+   *
+   * Analyzes identifier nodes in the AST and reports errors when underscore-prefixed
+   * variables are used outside of declaration contexts. Handles various edge cases:
+   * - Variable declarations (id vs init)
+   * - Property access (object._id)
+   * - Object destructuring
+   * - Type definitions
+   * - Shorthand properties
+   *
+   * @param {import('eslint').Rule.RuleContext} context - The ESLint rule context
+   * @returns {import('eslint').Rule.RuleListener} The rule listener with Identifier handler
+   */
+  create(context) {
+    const options = context.options[0] ?? {};
+    const allowedNames = new Set(options.allow ?? []);
+
+    return {
+      Identifier(node) {
+        // Guard against null/undefined parent
+        if (!node.parent) {
+          return;
+        }
+
+        // Only check identifiers that start with underscore
+        if (!node.name.startsWith('_')) {
+          return;
+        }
+
+        // Allow explicitly allowed names (e.g., __dirname, __filename)
+        if (allowedNames.has(node.name)) {
+          return;
+        }
+
+        // Skip if the identifier is a type definition (interface, type alias property)
+        if (node.parent.type === AST_NODE_TYPES.TS_PROPERTY_SIGNATURE) {
+          return;
+        }
+
+        // Skip if the identifier is a type parameter (e.g., <_T>)
+        if (node.parent.type === AST_NODE_TYPES.TS_TYPE_PARAMETER) {
+          return;
+        }
+
+        // Skip if the identifier is a catch clause parameter (e.g., catch (_error))
+        if (node.parent.type === AST_NODE_TYPES.CATCH_CLAUSE) {
+          return;
+        }
+
+        // Skip if the identifier is the name of a function declaration or expression
+        // This allows: function _helper() {} and const _fn = function() {}
+        if (
+          (node.parent.type === AST_NODE_TYPES.FUNCTION_DECLARATION && node.parent.id === node) ||
+          (node.parent.type === AST_NODE_TYPES.FUNCTION_EXPRESSION && node.parent.id === node) ||
+          (node.parent.type === AST_NODE_TYPES.CLASS_DECLARATION && node.parent.id === node) ||
+          (node.parent.type === AST_NODE_TYPES.CLASS_EXPRESSION && node.parent.id === node)
+        ) {
+          return;
+        }
+
+        // Skip if the identifier is a function parameter (including with default values)
+        // This covers: function test(_param) and function test(_param = 1)
+        if (
+          node.parent.type === AST_NODE_TYPES.ASSIGNMENT_PATTERN ||
+          node.parent.type === AST_NODE_TYPES.TS_PARAMETER_PROPERTY
+        ) {
+          // Check if we're in a function parameter context
+          let current = node.parent;
+          while (current) {
+            if (
+              current.type === AST_NODE_TYPES.FUNCTION_DECLARATION ||
+              current.type === AST_NODE_TYPES.FUNCTION_EXPRESSION ||
+              current.type === AST_NODE_TYPES.ARROW_FUNCTION_EXPRESSION
+            ) {
+              return;
+            }
+            current = current.parent;
+          }
+        }
+
+        // Skip if the identifier is a property access (e.g., object._id)
+        if (
+          node.parent.type === AST_NODE_TYPES.MEMBER_EXPRESSION &&
+          node.parent.property === node
+        ) {
+          return;
+        }
+
+        // Handle Property nodes with specific rules for keys vs values
+        // Note: We need to distinguish between:
+        //   1. Property keys (allowed ONLY if not shorthand, e.g., { _key: value })
+        //   2. Shorthand properties (NOT allowed, e.g., { _value } - this is a variable usage)
+        //   3. Property values in destructuring (allowed, e.g., const { key: _value } = obj)
+        //   4. Property values in object literals (NOT allowed, e.g., { key: _value })
+        if (node.parent.type === AST_NODE_TYPES.PROPERTY) {
+          const propertyNode = node.parent;
+          const container = propertyNode.parent;
+
+          // Allow property keys ONLY when not a shorthand (key !== value)
+          // Shorthand properties like { _value } are variable usages and should be caught
+          if (propertyNode.key === node && propertyNode.value !== node) {
+            return;
+          }
+
+          // Allow destructuring targets (object patterns) - both keys and values
+          // This covers: const { key: _value } = obj and const { _key } = obj
+          if (container && container.type === AST_NODE_TYPES.OBJECT_PATTERN) {
+            return;
+          }
+
+          // If we reach here, it's either:
+          // - A shorthand property usage: { _value }
+          // - A property value in an object literal: { key: _value }
+          // Both should fall through to report error
+        }
+
+        // Check if this identifier is in an allowed declaration context
+        if (ALLOWED_PARENT_TYPES.includes(node.parent.type)) {
+          // Special case for VariableDeclarator: check if we're in id (allowed) or init (not allowed)
+          if (node.parent.type === AST_NODE_TYPES.VARIABLE_DECLARATOR) {
+            if (isInVariableDeclaratorInit(node)) {
+              context.report({
+                node,
+                message:
+                  'Variable names starting with underscore should not be used (convention for unused variables)',
+              });
+            }
+            return;
+          }
+          // For other allowed types, it's in declaration position - allow it
+          return;
+        }
+
+        // Report error if underscore-prefixed variable is used outside declaration contexts
+        context.report({
+          node,
+          message:
+            'Variable names starting with underscore should not be used (convention for unused variables)',
+        });
+      },
+    };
+  },
+};

package/eslint/shared/__tests__/common-ignores.test.mjs

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+
+import { toPrettierIgnore, GLOBAL_IGNORES } from '../common-ignores.mjs';
+
+describe('common-ignores', () => {
+  it('toPrettierIgnore should clean glob patterns', () => {
+    const patterns = ['**/dist/**', 'build/**'];
+    const cleaned = toPrettierIgnore(patterns);
+    expect(cleaned).toContain('dist');
+    expect(cleaned).toContain('build');
+
+    expect(toPrettierIgnore(['**/node_modules/**'])).toEqual(['node_modules']);
+  });
+
+  it('GLOBAL_IGNORES should be defined', () => {
+    expect(Array.isArray(GLOBAL_IGNORES)).toBe(true);
+    expect(GLOBAL_IGNORES.length).toBeGreaterThan(0);
+  });
+});

package/eslint/shared/common-ignores.mjs

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Common ignore patterns - SINGLE SOURCE OF TRUTH for ESLint and Stylelint
+ *
+ * Centralized ignore patterns used across all linting tools in the monorepo.
+ * This ensures consistency between ESLint, Stylelint, Prettier, and other tools.
+ *
+ * **Synchronization**: When adding new exclusions, keep these files in sync:
+ * - .prettierignore (root) - without **​/ prefix
+ * - .linters/.markdownlintignore - if applicable to Markdown
+ * - .mega-linter.yml _base_exclusions anchor - regex format
+ *
+ * See .linters/README.md for sync instructions and format conversion.
+ *
+ * @module common-ignores
+ */
+
+/**
+ * Global ignore patterns for build artifacts, caches, and generated files.
+ *
+ * These patterns exclude files and directories that should not be linted:
+ * - Build outputs (`.next`, `dist`, `build`, `out`)
+ * - Dependencies (`node_modules`, `.pnpm-store`)
+ * - Cache directories (`.turbo`, `.cache`, `.vitest-ui`)
+ * - Generated files (`generated`, `*.tsbuildinfo`)
+ * - Test artifacts (`coverage`, `test-results`, `playwright-report`)
+ * - IDE and editor files (`.vscode`, `.idea`)
+ * - Environment files (`.env*`)
+ * - Log files (`*.log`)
+ *
+ * Used by ESLint flat config and can be converted for Prettier via `toPrettierIgnore()`.
+ *
+ * @type {readonly string[]}
+ */
+export const GLOBAL_IGNORES = [
+  // Build artifacts
+  '**/.next/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/out/**',
+  '**/storybook-static/**',
+  '**/coverage/**',
+  '**/.vitest-ui/coverage/**',
+  '**/html/coverage/**',
+  '**/coverage-browser/**',
+  '**/.nyc_output/**',
+  '**/generated/**',
+
+  // Coverage files
+  '**/.coverage-summary.json',
+  '**/coverage-final.json',
+  '**/coverage-summary.json',
+
+  // Package files
+  '**/node_modules/**',
+  '**/.pnpm-store/**',
+  '**/.turbo/**',
+  '**/.cache/**',
+  '**/pnpm-lock.yaml',
+  '**/.env*',
+  '**/.env*.local',
+
+  // IDE & Editor files
+  '**/.vscode/**',
+  '**/.idea/**',
+
+  // Generated files
+  '**/.react-email/**',
+  '**/*.test.todo.ts',
+  '**/test-results/**',
+  '**/test-results.json',
+  '**/playwright-report/**',
+  '**/blob-report/**',
+
+  // TypeScript build artifacts
+  '**/*.tsbuildinfo',
+  '**/next-env.d.ts',
+
+  // Temporary & Cache files
+  '**/temp/**',
+  '**/tmp/**',
+  '**/.tmp/**',
+  '**/logs/**',
+
+  // Documentation & Development
+  '**/.source/**',
+  '**/docs/llms/.cache/**',
+
+  // Deployment
+  '**/.vercel/**',
+
+  // Database files
+  '**/*.db',
+  '**/*.db-journal',
+
+  // Log files
+  '**/*.log',
+  '**/npm-debug.log*',
+  '**/yarn-debug.log*',
+  '**/yarn-error.log*',
+  '**/pnpm-debug.log*',
+  '**/lerna-debug.log*',
+
+  // GitHub configuration (to avoid linting workflows during development)
+  '**/.github/**',
+
+  // Worktrees
+  '**/.worktrees/**',
+
+  // MegaLinter reports
+  '**/megalinter-reports/**',
+
+  // Example Svelte projects (not TypeScript/React)
+  '**/teams/engineering/apps/nonrepo-examples/ai/**/*.svelte',
+  '**/teams/engineering/apps/nonrepo-examples/ai/**',
+  '**/*.svelte',
+  '**/*.astro',
+
+  // Claude sandbox examples
+  '**/.claude/**',
+
+  // Knip config (JSON, not JS)
+  '**/.kniprc.json',
+
+  // Temporary: Ignore errors.test.ts with false positive errors from ESLint/TypeScript project service
+  // TODO: Investigate why ESLint reports errors on non-existent lines (393) and false console statements
+  '**/__tests__/tools/errors.test.ts',
+];
+
+/**
+ * Ignore patterns for TypeScript type-aware linting contexts.
+ *
+ * These files/directories are excluded from `projectService` type-aware linting
+ * to improve performance and avoid errors. Type-aware linting requires TypeScript
+ * compilation context and can be slow or error-prone for:
+ * - Storybook config files (handled by Storybook-specific config)
+ * - Test config files (`vitest.config.ts`, `cypress.config.ts`, etc.)
+ * - Generated files (don't need type checking)
+ * - Build outputs (`dist/**`)
+ *
+ * @type {readonly string[]}
+ */
+export const TYPE_AWARE_IGNORES = [
+  '**/.storybook/**',
+  '**/vitest.config.{ts,mts}',
+  '**/cypress.config.{ts,mts}',
+  '**/playwright.config.{ts,mts}',
+  '**/vitest.setup.{ts,mts}',
+  '**/setupTests.{ts,mts}',
+  '**/generated/**',
+  '**/dist/**',
+];
+
+/**
+ * Convert ESLint glob patterns to Prettier ignore patterns.
+ *
+ * Prettier uses simpler ignore patterns than ESLint. This function
+ * removes glob prefixes and suffixes, and filters out empty patterns.
+ *
+ * @param {readonly string[]} patterns - Array of ESLint glob patterns
+ * @returns {string[]} Array of Prettier-compatible ignore patterns
+ */
+export function toPrettierIgnore(patterns) {
+  return patterns
+    .map(pattern => {
+      // Remove leading **/ for top-level matches
+      let cleaned = pattern.replace(/^\*\*\//, '');
+      // Remove trailing /** for directory matches
+      cleaned = cleaned.replace(/\/\*\*$/, '');
+      return cleaned;
+    })
+    .filter(Boolean);
+}

package/eslint/shared/disabled-type-aware-rules.mjs

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Shared constant for TypeScript rules that require type-aware linting
+ *
+ * These rules are disabled in contexts where type-aware linting is not available
+ * or would impact performance (test files, Storybook, config files, etc.).
+ *
+ * **Performance Impact**: Type-aware rules require TypeScript compilation context
+ * via `projectService: true`. Disabling them in certain file contexts improves
+ * linting performance by 60-80%.
+ *
+ * **When to Use**: Spread this object in rule configurations for:
+ * - Test files (Vitest, Cypress, Playwright)
+ * - Storybook files
+ * - Config files (`vitest.config.ts`, `cypress.config.ts`, etc.)
+ * - Any context where `projectService: false` is set
+ *
+ * @type {Record<string, 'off'>}
+ *
+ * @example
+ * // In ESLint config:
+ * // rules: { ...DISABLED_TYPE_AWARE_RULES }
+ */
+export const DISABLED_TYPE_AWARE_RULES = {
+  '@typescript-eslint/no-floating-promises': 'off',
+  '@typescript-eslint/no-misused-promises': 'off',
+  '@typescript-eslint/no-unnecessary-condition': 'off',
+  '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+  '@typescript-eslint/prefer-nullish-coalescing': 'off',
+  '@typescript-eslint/prefer-optional-chain': 'off',
+  '@typescript-eslint/switch-exhaustiveness-check': 'off',
+  '@typescript-eslint/prefer-includes': 'off',
+  '@typescript-eslint/prefer-string-starts-ends-with': 'off',
+  '@typescript-eslint/prefer-as-const': 'off',
+  '@typescript-eslint/no-non-null-assertion': 'off',
+};

package/eslint/shared/file-patterns.mjs

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview Shared file pattern constants for ESLint configurations
+ *
+ * Centralized file pattern constants used across multiple ESLint config files
+ * to ensure consistency. These patterns define which files rules apply to.
+ *
+ * @module file-patterns
+ */
+
+/**
+ * All TypeScript and JavaScript source files.
+ *
+ * Includes all common source file extensions:
+ * - TypeScript: `.ts`, `.tsx`
+ * - JavaScript: `.js`, `.jsx`
+ * - ESM modules: `.mjs`
+ *
+ * Used for rules that apply to all source code regardless of language.
+ *
+ * @type {readonly string[]}
+ */
+export const ALL_SOURCE_FILES = ['**/*.{ts,tsx,js,jsx,mjs}'];
+
+/**
+ * TypeScript files only (including module TypeScript).
+ *
+ * Includes:
+ * - Standard TypeScript: `.ts`, `.tsx`
+ * - Module TypeScript: `.mts` (ESM), `.cts` (CommonJS)
+ *
+ * Used for TypeScript-specific rules and type-aware linting that requires
+ * TypeScript compilation context.
+ *
+ * @type {readonly string[]}
+ */
+export const TS_FILES = ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'];
+
+/**
+ * JavaScript files only (including ESM modules).
+ *
+ * Includes:
+ * - Standard JavaScript: `.js`, `.jsx`
+ * - ESM modules: `.mjs`
+ *
+ * Used for JavaScript-specific rules where TypeScript rules don't apply
+ * (e.g., when TypeScript rules are disabled for `.js` files).
+ *
+ * @type {readonly string[]}
+ */
+export const JS_FILES = ['**/*.js', '**/*.jsx', '**/*.mjs'];
+
+/**
+ * Test file patterns for Vitest, Jest, Cypress, and Playwright.
+ *
+ * Includes patterns for:
+ * - Vitest/Jest: `*.test.{ts,tsx,js,jsx,mjs}`, `*.spec.*`, `test/**`, `tests/**`, `__tests__/**`
+ * - Cypress: `cypress/**`, `cypress.config.*`, `cypress.env.*`
+ * - Playwright: `playwright/**`, `playwright.config.*`, `*.playwright.*`
+ * - Test utilities: `*.test-utils.*`, `*.test-helpers.*`
+ * - Test configs: `vitest.config.*`
+ *
+ * Used by test configuration to apply test-specific rules and globals.
+ *
+ * @type {readonly string[]}
+ */
+export const TEST_FILES = [
+  // Vitest/Jest test files
+  '**/*.test.{ts,tsx,js,jsx,mjs}',
+  '**/*.spec.{ts,tsx,js,jsx,mjs}',
+  '**/test/**/*.{ts,tsx,js,jsx,mjs}',
+  '**/tests/**/*.{ts,tsx,js,jsx,mjs}',
+  '**/__tests__/**/*.{ts,tsx,js,jsx,mjs}',
+  // Cypress test files
+  '**/cypress/**/*.{ts,tsx,js,jsx}',
+  '**/cypress.config.{ts,js,mjs}',
+  '**/cypress.env.{ts,js,mjs}',
+  // Playwright test files
+  '**/playwright/**/*.{ts,tsx,js,jsx}',
+  '**/playwright.config.{ts,js,mjs}',
+  '**/*.playwright.{ts,tsx,js,jsx}',
+  // Vitest config files
+  '**/vitest.config.{ts,js,mjs}',
+  // General test utilities and helpers
+  '**/*.test-utils.{ts,tsx,js,jsx}',
+  '**/*.test-helpers.{ts,tsx,js,jsx}',
+];
+
+/**
+ * Config file patterns for build tools, linters, and test frameworks.
+ *
+ * Includes:
+ * - General configs: `*.config.{js,ts,mjs}`
+ * - ESLint configs: `eslint.config.{js,mjs}`
+ * - Vitest configs: `vitest.config.{ts,js,mjs}`
+ * - Playwright configs: `playwright.config.{ts,js,mjs}`
+ *
+ * Used for relaxing certain rules in configuration files (e.g., allowing `console`,
+ * disabling `import/no-extraneous-dependencies`).
+ *
+ * @type {readonly string[]}
+ */
+export const CONFIG_FILES = [
+  '**/*.config.{js,ts,mjs}',
+  '**/eslint.config.{js,mjs}',
+  '**/vitest.config.{ts,js,mjs}',
+  '**/playwright.config.{ts,js,mjs}',
+];
+
+/**
+ * Storybook-related file patterns.
+ *
+ * Includes story files, .storybook config files, and story test files.
+ *
+ * Used by Storybook configuration to apply Storybook-specific rules and
+ * disable type-aware linting for performance.
+ *
+ * @type {readonly string[]}
+ */
+export const STORYBOOK_FILES = [
+  '**/*.stories.@(ts|tsx|js|jsx|mjs|mdx)',
+  '**/.storybook/**/*.{ts,tsx,js,jsx,mjs}',
+  '**/stories/**/*.test.{ts,tsx}',
+  '**/stories/**/*.spec.{ts,tsx}',
+];

package/eslint/shared/node-globals.mjs

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Node.js 22+ globals for ESLint configuration
+ *
+ * Node.js 22 includes native support for Fetch API, WebSocket, and other
+ * web-standard globals. This module provides a consolidated set of globals
+ * for Node.js projects, combining standard Node.js globals with new web APIs.
+ *
+ * @module node-globals
+ */
+
+import globals from 'globals';
+
+/**
+ * Complete set of Node.js 22+ globals including:
+ * - All standard Node.js globals (process, Buffer, etc.)
+ * - Native Fetch API (fetch, Request, Response, Headers, FormData)
+ * - WebSocket support
+ * - navigator (for compatibility with web APIs)
+ * - CommonJS module variables (__dirname, __filename)
+ *
+ * @type {Record<string, 'readonly' | 'writable'>}
+ *
+ * @example
+ * import { NODE_22_GLOBALS } from './shared/node-globals.mjs';
+ *
+ * const config = {
+ *   languageOptions: {
+ *     globals: NODE_22_GLOBALS,
+ *   },
+ * };
+ */
+export const NODE_22_GLOBALS = {
+  ...globals.node,
+  // Native Fetch API (Node.js 18+)
+  fetch: 'readonly',
+  Request: 'readonly',
+  Response: 'readonly',
+  Headers: 'readonly',
+  FormData: 'readonly',
+  // WebSocket (Node.js 22+)
+  WebSocket: 'readonly',
+  // Web compatibility
+  navigator: 'readonly',
+  // CommonJS module variables (still used in .mjs via import.meta workarounds)
+  __dirname: 'readonly',
+  __filename: 'readonly',
+  // Explicit common globals (already in globals.node but listed for clarity)
+  process: 'readonly',
+  console: 'readonly',
+};