@acme-skunkworks/eslint-config 1.0.2 → 1.0.4

package/dist/rules/astro.js

@@ -8,20 +8,23 @@ import { configs } from "eslint-plugin-astro";
  * `@/` tsconfig path alias, and direct `.astro` file imports.
  */
 export const astro = [
+    // eslint-plugin-astro flat/recommended — upstream preset (parser, env, core astro rules).
+    // https://github.com/ota-meshi/eslint-plugin-astro#configuration
     ...configs["flat/recommended"],
     {
         files: ["**/*.astro"],
         rules: {
+            // astro/no-set-html-directive — disallows `set:html` (XSS risk) in favour of safer patterns.
+            // Error: we treat unsanitised HTML injection as a hard failure in Astro templates.
+            // https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-html-directive/
             "astro/no-set-html-directive": "error",
-            // Ignore imports that ESLint's static resolver can't handle in Astro files
+            // import/no-unresolved — reports imports that cannot be resolved to a file on disk.
+            // Error with ignore patterns: Astro virtual modules, path aliases, and .astro imports are valid but opaque to the resolver.
+            // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-unresolved.md
             "import/no-unresolved": [
                 "error",
                 {
-                    ignore: [
-                        "^astro:", // Astro virtual modules (astro:content, astro:assets, etc.)
-                        "^@/", // Path aliases defined in tsconfig (e.g., @/components)
-                        "\\.astro$", // .astro file imports (Astro's custom file format)
-                    ],
+                    ignore: ["^astro:", "^@/", "\\.astro$"],
                 },
             ],
         },

package/dist/rules/commonjs.d.ts

@@ -3,7 +3,8 @@
  *
  * `.cjs` parser shim: sets `sourceType: "script"` plus Node + ES2021 globals
  * so CommonJS files (legacy config files, certain tooling shims) parse
- * cleanly under the otherwise-ESM-default flat config.
+ * cleanly under the otherwise-ESM-default flat config. No rules — only `languageOptions`.
+ * @see https://eslint.org/docs/latest/use/configure/language-options
  */
 export declare const commonjs: {
     files: string[];

package/dist/rules/commonjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commonjs.d.ts","sourceRoot":"","sources":["../../rules/commonjs.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcI,CAAC"}
+{"version":3,"file":"commonjs.d.ts","sourceRoot":"","sources":["../../rules/commonjs.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcI,CAAC"}

package/dist/rules/commonjs.js

@@ -4,7 +4,8 @@ import globals from "globals";
  *
  * `.cjs` parser shim: sets `sourceType: "script"` plus Node + ES2021 globals
  * so CommonJS files (legacy config files, certain tooling shims) parse
- * cleanly under the otherwise-ESM-default flat config.
+ * cleanly under the otherwise-ESM-default flat config. No rules — only `languageOptions`.
+ * @see https://eslint.org/docs/latest/use/configure/language-options
  */
 export const commonjs = {
     files: ["**/*.cjs"],

package/dist/rules/complexity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../rules/complexity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAOrC,CAAC"}
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../rules/complexity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAUrC,CAAC"}

package/dist/rules/complexity.js

@@ -18,6 +18,9 @@ export const complexity = [
     {
         files: ["**/scripts/**/*.{ts,tsx,js,mjs}"],
         rules: {
+            // complexity — limits cyclomatic complexity per function (branching paths).
+            // Error + max 40: orchestration scripts are linear step lists; default threshold is too low.
+            // https://eslint.org/docs/latest/rules/complexity
             complexity: ["error", 40],
         },
     },

package/dist/rules/e2e.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"e2e.d.ts","sourceRoot":"","sources":["../../rules/e2e.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG;;;;;CAKS,CAAC"}
+{"version":3,"file":"e2e.d.ts","sourceRoot":"","sources":["../../rules/e2e.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG;;;;;CAQS,CAAC"}

package/dist/rules/e2e.js

@@ -14,6 +14,9 @@
 export const e2e = {
     files: ["**/e2e/**/*.{ts,tsx}"],
     rules: {
+        // react-hooks/rules-of-hooks — enforces Rules of Hooks (only call hooks at top level).
+        // Off in e2e: Playwright `test.extend` fixture factories are misread as hook calls.
+        // https://react.dev/reference/eslint-plugin-react-hooks#rules-of-hooks
         "react-hooks/rules-of-hooks": "off",
     },
 };

package/dist/rules/frameworkRouting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frameworkRouting.d.ts","sourceRoot":"","sources":["../../rules/frameworkRouting.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;;;;CAcJ,CAAC"}
+{"version":3,"file":"frameworkRouting.d.ts","sourceRoot":"","sources":["../../rules/frameworkRouting.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;;;;CAeJ,CAAC"}

package/dist/rules/frameworkRouting.js

@@ -22,9 +22,10 @@ export const frameworkRouting = {
         "**/src/pages/**/*.{ts,tsx,js,jsx}", // Astro pattern
     ],
     rules: {
-        // Disable filename-match-exported for framework routing directories
-        // File-based routing requires specific filenames (e.g., root.tsx, home.tsx)
-        // that don't match exported component names (e.g., Layout, Home, meta)
+        // canonical/filename-match-exported — requires default export name to match the filename.
+        // Off in routing dirs: file-based routes use conventional names (root.tsx, page.tsx) not export names.
+        // See: https://github.com/RobEasthope/protomolecule/issues/299
+        // https://github.com/gajus/eslint-plugin-canonical#rules
         "canonical/filename-match-exported": "off",
     },
 };

package/dist/rules/ignoredFileAndFolders.d.ts

@@ -6,6 +6,7 @@
  * `.react-router`, `.wrangler`, `.vscode`, `.claude`), `node_modules`, and
  * the lock file. Also ignores `tsconfig.json` and the consumer's own
  * `eslint.config.{ts,mjs}` — those are tooling input, not source to lint.
+ * @see https://eslint.org/docs/latest/use/configure/ignore
  */
 export declare const ignoredFileAndFolders: {
     ignores: string[];

package/dist/rules/ignoredFileAndFolders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ignoredFileAndFolders.d.ts","sourceRoot":"","sources":["../../rules/ignoredFileAndFolders.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;CAmBT,CAAC"}
+{"version":3,"file":"ignoredFileAndFolders.d.ts","sourceRoot":"","sources":["../../rules/ignoredFileAndFolders.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;CAmBT,CAAC"}

package/dist/rules/ignoredFileAndFolders.js

@@ -6,6 +6,7 @@
  * `.react-router`, `.wrangler`, `.vscode`, `.claude`), `node_modules`, and
  * the lock file. Also ignores `tsconfig.json` and the consumer's own
  * `eslint.config.{ts,mjs}` — those are tooling input, not source to lint.
+ * @see https://eslint.org/docs/latest/use/configure/ignore
  */
 export const ignoredFileAndFolders = {
     ignores: [

package/dist/rules/packageJson.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packageJson.d.ts","sourceRoot":"","sources":["../../rules/packageJson.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;CAKC,CAAC"}
+{"version":3,"file":"packageJson.d.ts","sourceRoot":"","sources":["../../rules/packageJson.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;CAQC,CAAC"}

package/dist/rules/packageJson.js

@@ -9,6 +9,9 @@
 export const packageJson = {
     files: ["**/package.json"],
     rules: {
+        // jsonc/sort-keys — enforces alphabetical (or configured) key order in JSON/JSONC files.
+        // Off: sort-package-json (lint-staged) owns package.json field order with npm conventions.
+        // https://ota.github.io/eslint-plugin-jsonc/rules/sort-keys.html
         "jsonc/sort-keys": "off",
     },
 };

package/dist/rules/preferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../rules/preferences.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GC,CAAC"}
+{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../rules/preferences.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoJC,CAAC"}

package/dist/rules/preferences.js

@@ -22,27 +22,38 @@ export const preferences = {
         },
     },
     rules: {
+        // canonical/filename-match-regex — requires exported symbol names to match a filename regex.
+        // Off: canonical's default regex is too strict for our file-routing and colocated-file patterns.
+        // https://github.com/gajus/eslint-plugin-canonical#rules
         "canonical/filename-match-regex": "off",
+        // canonical/id-match — enforces identifier naming conventions (regex/case).
+        // Off: conflicts with framework and library conventions (e.g. single-letter Sanity `S`).
+        // https://github.com/gajus/eslint-plugin-canonical#rules
         "canonical/id-match": "off",
-        // Prefer top-level type imports for React Router 7 compatibility
-        // Top-level: import type { Foo } from 'bar'
-        // Inline: import { type Foo } from 'bar' (causes issues with virtual modules)
+        // canonical/prefer-inline-type-import — prefers `import { type Foo }` over `import type { Foo }`.
+        // Off: top-level type imports are required for React Router 7 virtual modules and verbatimModuleSyntax.
         // See: https://github.com/RobEasthope/protomolecule/issues/333
+        // https://github.com/gajus/eslint-plugin-canonical#rules
         "canonical/prefer-inline-type-import": "off",
-        // Enforce function declarations as the standard pattern
-        // Arrow functions and function expressions will error
-        // Note: React Router 7 files (root.tsx, *route.tsx) need framework-specific exceptions
+        // func-style — requires `function foo() {}` over `const foo = function () {}` / arrows.
+        // Error + declaration: our default style; frameworkRouting relaxes root/route files.
         // See: https://github.com/RobEasthope/protomolecule/issues/299
+        // https://eslint.org/docs/latest/rules/func-style
         "func-style": ["error", "declaration"],
-        // Prefer top-level type imports over inline type imports
-        // This ensures compatibility with React Router 7 virtual modules and verbatimModuleSyntax
+        // import/consistent-type-specifier-style — enforces where `type` appears in import specifiers.
+        // Error + prefer-top-level: separate `import type` lines for RR7 virtual modules compatibility.
         // See: https://github.com/RobEasthope/protomolecule/issues/333
+        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/consistent-type-specifier-style.md
         "import/consistent-type-specifier-style": ["error", "prefer-top-level"],
-        // Prevent duplicate imports from the same module
-        // With prefer-inline: false, allows separate type and value imports
-        // e.g., import { useState } from 'react' and import type { FC } from 'react'
+        // import/no-duplicates — reports multiple import declarations from the same module.
+        // Error + prefer-inline false: allows separate value and type imports from one module.
         // See: https://github.com/RobEasthope/protomolecule/issues/333
+        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-duplicates.md
         "import/no-duplicates": ["error", { "prefer-inline": false }],
+        // import/no-extraneous-dependencies — forbids importing packages not listed in package.json.
+        // Error with devDependencies allowlist for tests, configs, scripts, and monorepo packageDir lookup.
+        // See: https://github.com/RobEasthope/protomolecule/issues/299
+        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-extraneous-dependencies.md
         "import/no-extraneous-dependencies": [
             "error",
             {
@@ -58,31 +69,38 @@ export const preferences = {
                     ".github/scripts/**",
                     "scripts/**",
                 ],
-                // Allow importing from @react-router/dev and similar framework dev packages
-                // These are in devDependencies but required for route configuration at build time
-                // See: https://github.com/RobEasthope/protomolecule/issues/299
                 includeInternal: false,
                 includeTypes: true,
                 packageDir: ["./", "../", "../../"],
-                // Allow importing from peerDependencies (for shared configs like eslint-config)
                 peerDependencies: true,
             },
         ],
-        // Allow CSS file imports (standard pattern in Vite, Next.js, React Router, Remix, Astro)
+        // import/no-unassigned-import — forbids side-effect imports that bind no symbols.
+        // Error with CSS/SCSS/etc. allowlist: framework apps import stylesheets without bindings.
         // See: https://github.com/RobEasthope/protomolecule/issues/299
+        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-unassigned-import.md
         "import/no-unassigned-import": [
             "error",
             {
                 allow: ["**/*.css", "**/*.scss", "**/*.sass", "**/*.less", "**/*.pcss"],
             },
         ],
+        // no-console — disallows `console` calls (with optional allowlist of methods).
+        // Warn + allow error/debug/warn/log: discourage casual logging but permit intentional use.
+        // https://eslint.org/docs/latest/rules/no-console
         "no-console": ["warn", { allow: ["error", "debug", "warn", "log"] }],
-        // Allow empty patterns with type annotations (React Router v7, Remix, SvelteKit patterns)
-        // e.g., `export function meta({}: Route.MetaArgs) { ... }`
-        // The empty destructuring satisfies the type system even when arguments aren't used
+        // no-empty-pattern — disallows empty object/array patterns in destructuring.
+        // Off: typed framework route args use `{}` placeholders (e.g. `meta({}: Route.MetaArgs)`).
         // See: https://github.com/RobEasthope/protomolecule/issues/299
+        // https://eslint.org/docs/latest/rules/no-empty-pattern
         "no-empty-pattern": "off",
+        // perfectionist/sort-modules — enforces ordering of ES module statements.
+        // Off: canonical enables this; we prefer manual/import-group ordering without auto-sort noise.
+        // https://perfectionist.dev/rules/sort-modules
         "perfectionist/sort-modules": "off",
+        // prettier/prettier — runs Prettier as an ESLint rule and reports formatting diffs.
+        // Error with tailwind plugin + cn/clsx: formatting is enforced at lint time, not only on save.
+        // https://github.com/prettier/eslint-plugin-prettier#options
         "prettier/prettier": [
             "error",
             {
@@ -91,33 +109,53 @@ export const preferences = {
                 tailwindFunctions: ["cn", "clsx"],
             },
         ],
+        // quotes — enforces consistent quote style for strings.
+        // Warn + double + avoidEscape: align with Prettier double-quote default; escapes when needed.
+        // https://eslint.org/docs/latest/rules/quotes
         quotes: ["warn", "double", { avoidEscape: true }],
+        // react/forbid-component-props — bans specific props on DOM/components.
+        // Off: canonical's forbidden-prop list is too opinionated for our component libraries.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/forbid-component-props.md
         "react/forbid-component-props": "off",
+        // react/function-component-definition — enforces arrow vs function declaration for components.
+        // Off: we use func-style globally instead; this rule duplicates and conflicts with RR7 patterns.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/function-component-definition.md
         "react/function-component-definition": "off",
+        // regexp/no-unused-capturing-group — flags capturing groups whose match is never used.
+        // Off: false positives on regexes where groups aid readability or future back-references.
+        // https://ota.github.io/eslint-plugin-regexp/rules/no-unused-capturing-group.html
         "regexp/no-unused-capturing-group": "off",
+        // require-unicode-regexp — requires the `u` flag on `RegExp` literals and constructors.
+        // Off: not all regexes need Unicode semantics; canonical's default is too strict for us.
+        // https://eslint.org/docs/latest/rules/require-unicode-regexp
         "require-unicode-regexp": "off",
+        // unicorn/better-regex — suggests regex optimizations (simpler patterns, fewer backtracks).
+        // Off: auto-suggestions conflict with intentionally explicit patterns in places.
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/better-regex.md
         "unicorn/better-regex": "off",
+        // unicorn/numeric-separators-style — enforces `_` separators in numeric literals.
+        // Off: style preference; teams vary on when separators help readability.
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/numeric-separators-style.md
         "unicorn/numeric-separators-style": "off",
     },
     settings: {
-        // TypeScript import resolver for monorepo support
-        // Fixes false positives with import/no-extraneous-dependencies when lint-staged
-        // passes absolute file paths in monorepo workspaces
+        // import-x/resolver — tells import-x rules how to resolve module paths (TypeScript projects).
+        // typescript resolver + monorepo tsconfig globs: fixes false positives when lint-staged passes absolute paths.
         // See: https://github.com/RobEasthope/protomolecule/issues/327
+        // https://github.com/import-js/eslint-import-resolver-typescript
         "import-x/resolver": {
             typescript: {
-                // Always try to resolve types under `@types/*` directory
                 alwaysTryTypes: true,
-                // Support both monorepo and single-package projects
-                // Monorepo: Multiple tsconfig files for workspace packages
-                // Single package: Falls back to root tsconfig.json
                 project: [
-                    "tsconfig.json", // Root or single package
-                    "apps/*/tsconfig.json", // Monorepo apps
-                    "packages/*/tsconfig.json", // Monorepo packages
+                    "tsconfig.json",
+                    "apps/*/tsconfig.json",
+                    "packages/*/tsconfig.json",
                 ],
             },
         },
+        // react.version — supplies React version to eslint-plugin-react for version-aware rules.
+        // detect: read version from installed `react` package instead of hard-coding.
+        // https://github.com/jsx-eslint/eslint-plugin-react#configuration
         react: {
             version: "detect",
         },

package/dist/rules/reactRouterExceptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactRouterExceptions.d.ts","sourceRoot":"","sources":["../../rules/reactRouterExceptions.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;CAoBT,CAAC"}
+{"version":3,"file":"reactRouterExceptions.d.ts","sourceRoot":"","sources":["../../rules/reactRouterExceptions.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;CAST,CAAC"}

package/dist/rules/reactRouterExceptions.js

@@ -10,21 +10,10 @@
 export const reactRouterExceptions = {
     files: ["**/root.tsx", "**/*.route.tsx"],
     rules: {
-        // Allow arrow functions for React Router 7 typed exports
-        // React Router 7 uses patterns like:
-        //   export const links: Route.LinksFunction = () => [...]
-        //   export const meta: Route.MetaFunction = () => ({ ... })
-        //   export const loader: Route.LoaderFunction = async () => { ... }
-        //
-        // These MUST be arrow functions or function expressions because:
-        // 1. They require type annotations (Route.LinksFunction, etc.)
-        // 2. TypeScript doesn't allow type annotations on function declarations
-        // 3. The framework expects these specific export patterns
-        //
-        // The allowArrowFunctions option permits arrow functions in variable
-        // declarations while still enforcing function declarations elsewhere
-        //
+        // func-style — requires `function foo() {}` over `const foo = function () {}` / arrows.
+        // Error + declaration + allowArrowFunctions: RR7 typed exports need annotated arrow/const patterns.
         // See: https://github.com/RobEasthope/protomolecule/issues/323
+        // https://eslint.org/docs/latest/rules/func-style
         "func-style": ["error", "declaration", { allowArrowFunctions: true }],
     },
 };

package/dist/rules/sanity.d.ts

@@ -6,7 +6,7 @@
  * Combined Sanity ESLint configuration. Exports an array of two configs
  * documented inline above: schema property ordering for `*.schema.ts` (a
  * perfectionist `sort-objects` rule with custom groups so identity → fields
- * → behavior → validation appear in a deterministic, readable order) and
+ * → behaviour → validation appear in a deterministic, readable order) and
  * structure-file exceptions (allows the `S => S.list()` arrow-function
  * pattern and the canonical single-letter `S` parameter that Sanity's docs
  * universally use for the StructureBuilder).

package/dist/rules/sanity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanity.d.ts","sourceRoot":"","sources":["../../rules/sanity.ts"],"names":[],"mappings":"AAkIA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;IAAkD,CAAC"}
+{"version":3,"file":"sanity.d.ts","sourceRoot":"","sources":["../../rules/sanity.ts"],"names":[],"mappings":"AA6IA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;IAAkD,CAAC"}

package/dist/rules/sanity.js

@@ -7,8 +7,8 @@
  * Property ordering follows a logical grouping:
  * 1. Identity: name, title, type, icon
  * 2. Fields: fields (placed early so document content stays visually prominent)
- * 3. Organization: fieldset, group, groups, fieldsets
- * 4. Behavior: hidden, readOnly
+ * 3. Organisation: fieldset, group, groups, fieldsets
+ * 4. Behaviour: hidden, readOnly
  * 5. Type-specific: options, rows, to, of, marks, styles
  * 6. Content defaults: initialValue, description
  * 7. Validation: validation
@@ -19,6 +19,9 @@
 const sanitySchemaPropertyOrdering = {
     files: ["**/*.schema.ts"],
     rules: {
+        // perfectionist/sort-objects — enforces consistent ordering of object keys/properties.
+        // Error with custom groups: Sanity defineField/defineType objects follow identity → fields → validation order.
+        // https://perfectionist.dev/rules/sort-objects
         "perfectionist/sort-objects": [
             "error",
             {
@@ -30,12 +33,12 @@ const sanitySchemaPropertyOrdering = {
                     { elementNamePattern: "^icon$", groupName: "icon" },
                     // 2. Fields array (placed early so the schema's content stays visually prominent)
                     { elementNamePattern: "^fields$", groupName: "fields" },
-                    // 3. Organization - where does it go?
+                    // 3. Organisation - where does it go?
                     { elementNamePattern: "^fieldset$", groupName: "fieldset" },
                     { elementNamePattern: "^group$", groupName: "group" },
                     { elementNamePattern: "^groups$", groupName: "groups" },
                     { elementNamePattern: "^fieldsets$", groupName: "fieldsets" },
-                    // 4. Behavior - how does it behave?
+                    // 4. Behaviour - how does it behave?
                     { elementNamePattern: "^hidden$", groupName: "hidden" },
                     { elementNamePattern: "^readOnly$", groupName: "readOnly" },
                     // 5. Type-specific options
@@ -62,12 +65,12 @@ const sanitySchemaPropertyOrdering = {
                     "icon",
                     // Fields
                     "fields",
-                    // Organization
+                    // Organisation
                     "fieldset",
                     "group",
                     "groups",
                     "fieldsets",
-                    // Behavior
+                    // Behaviour
                     "hidden",
                     "readOnly",
                     // Type-specific
@@ -112,7 +115,15 @@ const sanitySchemaPropertyOrdering = {
 const sanityStructure = {
     files: ["**/sanity.structure.ts", "**/deskStructure.ts"],
     rules: {
+        // func-style — requires `function foo() {}` over `const foo = function () {}` / arrows.
+        // Off: Sanity structure resolvers use `export const structure = (S) => …` arrow pattern.
+        // See: https://github.com/RobEasthope/protomolecule/issues/365
+        // https://eslint.org/docs/latest/rules/func-style
         "func-style": "off",
+        // id-length — enforces minimum identifier length (flags single-letter names).
+        // Off: Sanity docs universally use `S` for the StructureBuilder parameter.
+        // See: https://github.com/RobEasthope/protomolecule/issues/365
+        // https://eslint.org/docs/latest/rules/id-length
         "id-length": "off",
     },
 };
@@ -124,7 +135,7 @@ const sanityStructure = {
  * Combined Sanity ESLint configuration. Exports an array of two configs
  * documented inline above: schema property ordering for `*.schema.ts` (a
  * perfectionist `sort-objects` rule with custom groups so identity → fields
- * → behavior → validation appear in a deterministic, readable order) and
+ * → behaviour → validation appear in a deterministic, readable order) and
  * structure-file exceptions (allows the `S => S.list()` arrow-function
  * pattern and the canonical single-letter `S` parameter that Sanity's docs
  * universally use for the StructureBuilder).

package/dist/rules/storybook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storybook.d.ts","sourceRoot":"","sources":["../../rules/storybook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MASN,CAAC"}
+{"version":3,"file":"storybook.d.ts","sourceRoot":"","sources":["../../rules/storybook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAaN,CAAC"}

package/dist/rules/storybook.js

@@ -13,9 +13,13 @@ export const storybook = {
     files: ["**/*.stories.ts", "**/*.stories.tsx"],
     ignores: ["**/storybook-static/**/*"],
     rules: {
+        // canonical/filename-match-exported — requires default export name to match the filename.
+        // Off: stories are named `Component.stories.tsx`, not after the default export symbol.
+        // https://github.com/gajus/eslint-plugin-canonical#rules
         "canonical/filename-match-exported": "off",
-        // Disable type-aware linting for Storybook files excluded from tsconfig
-        // This keeps syntax-based rules active while avoiding project reference errors
+        // typescript-eslint disableTypeChecked — turns off rules that need type information.
+        // Spread: story files are often excluded from tsconfig; avoids "not in project" errors.
+        // https://typescript-eslint.io/users/configs#disable-type-checked
         ...tseslint.configs.disableTypeChecked.rules,
     },
 };

package/dist/rules/tableComponents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tableComponents.d.ts","sourceRoot":"","sources":["../../rules/tableComponents.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;;CAKH,CAAC"}
+{"version":3,"file":"tableComponents.d.ts","sourceRoot":"","sources":["../../rules/tableComponents.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;;CAQH,CAAC"}

package/dist/rules/tableComponents.js

@@ -16,6 +16,9 @@
 export const tableComponents = {
     files: ["**/*Table.tsx"],
     rules: {
+        // react/no-unstable-nested-components — forbids defining components inside render (re-mount risk).
+        // Off in *Table.tsx: TanStack/Refine column cell renderers are inline by API; defs are memoised.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-unstable-nested-components.md
         "react/no-unstable-nested-components": "off",
     },
 };

package/dist/rules/testFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testFiles.d.ts","sourceRoot":"","sources":["../../rules/testFiles.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAiCG,CAAC"}
+{"version":3,"file":"testFiles.d.ts","sourceRoot":"","sources":["../../rules/testFiles.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAgCG,CAAC"}

package/dist/rules/testFiles.js

@@ -18,24 +18,26 @@ export const testFiles = {
         "**/*.test.{ts,tsx,js,jsx}",
         "**/*.spec.{ts,tsx,js,jsx}",
         "**/__tests__/**/*.{ts,tsx,js,jsx}",
-        // Test setup files - specific framework names to avoid false positives
         "**/{vitest,jest,playwright,test}.setup.{ts,js}",
-        // Setup files in test directories
         "**/__tests__/**/*.setup.{ts,js}",
         "**/tests/**/*.setup.{ts,js}",
     ],
     rules: {
-        // Relax TypeScript strict rules for test files where `any` is acceptable
-        // for testing type validation and error handling
+        // @typescript-eslint/no-explicit-any — disallows the `any` type.
+        // Warn in tests: fixtures and error-path tests often need `any` for edge-case coverage.
+        // https://typescript-eslint.io/rules/no-explicit-any
         "@typescript-eslint/no-explicit-any": "warn",
-        // Allow non-null assertions in test files where preconditions are asserted
-        // and the test would fail anyway if the assumption is wrong
+        // @typescript-eslint/no-non-null-assertion — disallows postfix `!` non-null assertions.
+        // Warn in tests: preconditions are often asserted; failure surfaces as a test failure anyway.
+        // https://typescript-eslint.io/rules/no-non-null-assertion
         "@typescript-eslint/no-non-null-assertion": "warn",
-        // Vitest setup files use `/// <reference types="..." />` to augment global
-        // types (e.g. `@testing-library/jest-dom`); the rule is a false positive there.
+        // @typescript-eslint/triple-slash-reference — disallows `/// <reference … />` directives.
+        // Off in setup files: Vitest/Jest setups use triple-slash to augment global types.
+        // https://typescript-eslint.io/rules/triple-slash-reference
         "@typescript-eslint/triple-slash-reference": "off",
-        // Allow devDependencies in test files and setup files
-        // Test dependencies should be in devDependencies, not dependencies
+        // import/no-extraneous-dependencies — forbids importing packages not listed in package.json.
+        // Error + devDependencies true: test-only packages belong in devDependencies, not dependencies.
+        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-extraneous-dependencies.md
         "import/no-extraneous-dependencies": [
             "error",
             {

package/dist/rules/typescriptOverrides.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescriptOverrides.d.ts","sourceRoot":"","sources":["../../rules/typescriptOverrides.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;CAMP,CAAC"}
+{"version":3,"file":"typescriptOverrides.d.ts","sourceRoot":"","sources":["../../rules/typescriptOverrides.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;CAYP,CAAC"}

package/dist/rules/typescriptOverrides.js

@@ -8,7 +8,13 @@
 export const typescriptOverrides = {
     files: ["**/*.{ts,tsx}"],
     rules: {
+        // react/no-unused-prop-types — flags PropTypes declared but never used in the component.
+        // Off under TS: prop types are checked by TypeScript, not runtime PropTypes.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-unused-prop-types.md
         "react/no-unused-prop-types": "off",
+        // react/prop-types — requires React components to declare PropTypes for props.
+        // Off under TS: interfaces/types replace PropTypes for compile-time checking.
+        // https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/prop-types.md
         "react/prop-types": "off",
     },
 };