oxlint-plugin-arch 0.11.0 → 0.12.1

package/dist/presets/react-modules-preset.js

@@ -1,1724 +0,0 @@
-// src/utils/helpers/preset.ts
-import { existsSync, readFileSync } from "node:fs";
-import { relative, resolve } from "node:path";
-
-// src/constants/preset.constants.ts
-var presetExtensions = "*.{ts,tsx,mts,cts}";
-var presetPolicyOrder = [
-  "formatting",
-  "statementLayout",
-  "imports",
-  "typePlacement",
-  "typeSafety",
-  "fileLayout",
-  "serviceStructure",
-  "naming",
-  "comments",
-  "trivialFunctions",
-  "mutableState",
-  "backend",
-  "tests",
-  "schemas",
-  "react",
-  "effects",
-  "routes",
-  "forms",
-  "memoization",
-  "boundaries",
-  "rpcClientOwnership",
-  "tailwind",
-  "shadcn"
-];
-var presetCommonRules = {
-  "vitest/expect-expect": "off",
-  "vitest/no-standalone-expect": "off",
-  "jsx-a11y/no-noninteractive-tabindex": "error",
-  "no-case-declarations": "error",
-  "no-empty": "error",
-  "no-fallthrough": "error",
-  "no-prototype-builtins": "error",
-  "no-regex-spaces": "error",
-  "array-callback-return": "error",
-  "default-case-last": "error",
-  eqeqeq: "error",
-  "no-alert": "error",
-  "no-constructor-return": "error",
-  "no-else-return": "error",
-  "no-extend-native": "error",
-  "no-extra-bind": "error",
-  "no-extra-label": "error",
-  "no-labels": "error",
-  "no-lone-blocks": "error",
-  "no-new": "error",
-  "no-new-func": "error",
-  "no-new-wrappers": "error",
-  "no-param-reassign": "error",
-  "no-proto": "error",
-  "no-return-assign": "error",
-  "no-script-url": "error",
-  "no-self-compare": "error",
-  "no-sequences": "error",
-  "no-useless-call": "error",
-  "no-useless-concat": "error",
-  "no-useless-return": "error",
-  "no-useless-computed-key": "error",
-  "no-var": "error",
-  "object-shorthand": "error",
-  "prefer-const": "error",
-  "prefer-numeric-literals": "error",
-  "prefer-rest-params": "error",
-  "prefer-spread": "error",
-  "prefer-template": "error",
-  "symbol-description": "error",
-  "no-promise-executor-return": "error",
-  "no-template-curly-in-string": "error",
-  "new-cap": [
-    "error",
-    {
-      capIsNew: false
-    }
-  ],
-  "no-lonely-if": "error",
-  "no-multi-assign": "error",
-  "no-nested-ternary": "error",
-  "no-unneeded-ternary": "error",
-  "prefer-object-spread": "error",
-  "no-label-var": "error",
-  "no-await-in-loop": "error",
-  curly: "error",
-  "typescript/no-array-constructor": "error",
-  "typescript/no-dynamic-delete": "error",
-  "typescript/no-empty-object-type": "error",
-  "typescript/no-invalid-void-type": "error",
-  "typescript/no-mixed-enums": "error",
-  "typescript/no-namespace": "error",
-  "typescript/no-non-null-asserted-nullish-coalescing": "error",
-  "typescript/no-non-null-assertion": "error",
-  "typescript/no-require-imports": "error",
-  "typescript/no-unnecessary-boolean-literal-compare": "error",
-  "typescript/no-unnecessary-condition": "error",
-  "typescript/no-unnecessary-template-expression": "error",
-  "typescript/no-unnecessary-type-arguments": "error",
-  "typescript/no-unnecessary-type-assertion": "error",
-  "typescript/no-unnecessary-type-constraint": "error",
-  "typescript/no-unsafe-enum-comparison": "error",
-  "typescript/no-unsafe-function-type": "error",
-  "typescript/no-unused-expressions": "error",
-  "no-unused-vars": [
-    "error",
-    {
-      args: "after-used",
-      argsIgnorePattern: "^_",
-      ignoreRestSiblings: false,
-      vars: "all",
-      varsIgnorePattern: "^_"
-    }
-  ],
-  "typescript/no-useless-constructor": "error",
-  "typescript/prefer-literal-enum-member": "error",
-  "typescript/prefer-promise-reject-errors": "error",
-  "typescript/prefer-reduce-type-parameter": "error",
-  "typescript/prefer-return-this-type": "error",
-  "typescript/restrict-plus-operands": "error",
-  "typescript/return-await": ["error", "error-handling-correctness-only"],
-  "typescript/unbound-method": "error",
-  "typescript/use-unknown-in-catch-callback-variable": "error",
-  "typescript/unified-signatures": "error",
-  "typescript/adjacent-overload-signatures": "error",
-  "typescript/array-type": "error",
-  "typescript/ban-tslint-comment": "error",
-  "typescript/class-literal-property-style": "error",
-  "typescript/consistent-generic-constructors": "error",
-  "typescript/consistent-indexed-object-style": "error",
-  "typescript/consistent-type-assertions": "error",
-  "typescript/consistent-type-definitions": "error",
-  "typescript/consistent-type-imports": [
-    "error",
-    {
-      prefer: "type-imports",
-      disallowTypeAnnotations: true,
-      fixStyle: "separate-type-imports"
-    }
-  ],
-  "typescript/no-confusing-non-null-assertion": "error",
-  "typescript/no-empty-function": "error",
-  "typescript/no-inferrable-types": "error",
-  "typescript/non-nullable-type-assertion-style": "error",
-  "typescript/prefer-find": "error",
-  "typescript/prefer-for-of": "error",
-  "typescript/prefer-function-type": "error",
-  "typescript/prefer-includes": "error",
-  "typescript/prefer-nullish-coalescing": "error",
-  "typescript/prefer-optional-chain": "error",
-  "typescript/prefer-regexp-exec": "error",
-  "typescript/prefer-string-starts-ends-with": "error",
-  "typescript/consistent-type-exports": "error",
-  "typescript/switch-exhaustiveness-check": "error",
-  "typescript/default-param-last": "error",
-  "typescript/no-loop-func": "error",
-  "typescript/no-shadow": "error",
-  "unicorn/prefer-at": "error",
-  "unicorn/prefer-node-protocol": "error",
-  "react-hooks/rules-of-hooks": "error",
-  "react-hooks/exhaustive-deps": "error",
-  "oxc/no-accumulating-spread": "error",
-  "@regru/prefer-early-return/prefer-early-return": [
-    "error",
-    {
-      maximumStatements: 1
-    }
-  ],
-  "tsdoc/syntax": "error",
-  "@eslint-community/eslint-comments/no-aggregating-enable": "error",
-  "@eslint-community/eslint-comments/no-duplicate-disable": "error",
-  "@eslint-community/eslint-comments/no-unused-enable": "error"
-};
-var presetFormattingRules = {
-  "eslint-js/padding-line-between-statements": [
-    "error",
-    {
-      blankLine: "always",
-      prev: ["multiline-const", "multiline-let"],
-      next: "*"
-    },
-    {
-      blankLine: "always",
-      prev: "*",
-      next: ["multiline-const", "multiline-let"]
-    }
-  ],
-  "eslint-js/indent": [
-    "error",
-    2,
-    {
-      MemberExpression: 1,
-      SwitchCase: 1,
-      flatTernaryExpressions: true
-    }
-  ],
-  "eslint-js/semi": ["error", "always"],
-  "eslint-js/quotes": [
-    "error",
-    "single",
-    {
-      avoidEscape: true
-    }
-  ],
-  "eslint-js/comma-dangle": ["error", "always-multiline"],
-  "eslint-js/no-trailing-spaces": "error",
-  "eslint-js/no-multiple-empty-lines": [
-    "error",
-    {
-      max: 1
-    }
-  ],
-  "eslint-js/eol-last": ["error", "always"],
-  "eslint-js/no-multi-spaces": "error",
-  "eslint-js/arrow-spacing": "error",
-  "eslint-js/block-spacing": "error",
-  "eslint-js/comma-spacing": [
-    "error",
-    {
-      before: false,
-      after: true
-    }
-  ],
-  "eslint-js/key-spacing": [
-    "error",
-    {
-      beforeColon: false,
-      afterColon: true
-    }
-  ],
-  "eslint-js/keyword-spacing": [
-    "error",
-    {
-      before: true,
-      after: true
-    }
-  ],
-  "eslint-js/object-curly-spacing": ["error", "always"],
-  "eslint-js/semi-spacing": [
-    "error",
-    {
-      before: false,
-      after: true
-    }
-  ],
-  "eslint-js/space-before-blocks": "error",
-  "eslint-js/space-before-function-paren": [
-    "error",
-    {
-      anonymous: "always",
-      named: "never",
-      asyncArrow: "always"
-    }
-  ],
-  "eslint-js/space-infix-ops": "error",
-  "eslint-js/space-in-parens": ["error", "never"],
-  "eslint-js/template-curly-spacing": ["error", "never"],
-  "eslint-js/rest-spread-spacing": ["error", "never"],
-  "eslint-js/computed-property-spacing": ["error", "never"],
-  "eslint-js/brace-style": [
-    "error",
-    "1tbs",
-    {
-      allowSingleLine: false
-    }
-  ],
-  "eslint-js/arrow-parens": ["error", "always"],
-  "eslint-js/no-extra-semi": "error",
-  "eslint-js/no-floating-decimal": "error",
-  "eslint-js/dot-location": ["error", "property"],
-  "eslint-js/no-whitespace-before-property": "error",
-  "eslint-js/object-curly-newline": [
-    "error",
-    {
-      consistent: true
-    }
-  ],
-  "eslint-js/object-property-newline": [
-    "error",
-    {
-      allowAllPropertiesOnSameLine: true
-    }
-  ],
-  "eslint-js/max-len": [
-    "error",
-    {
-      code: 160,
-      ignoreUrls: true,
-      ignoreStrings: true,
-      ignoreTemplateLiterals: true,
-      ignoreRegExpLiterals: true,
-      ignoreComments: true
-    }
-  ]
-};
-var presetReactRules = {
-  "react/display-name": "error",
-  "react/jsx-no-comment-textnodes": "error",
-  "react/jsx-no-target-blank": "error",
-  "react/no-unknown-property": "error",
-  "react/button-has-type": "error",
-  "react/jsx-boolean-value": "error",
-  "react/jsx-curly-brace-presence": "error",
-  "react/jsx-fragments": "error",
-  "react/jsx-no-useless-fragment": "error",
-  "react/jsx-pascal-case": "error",
-  "react/self-closing-comp": "error",
-  "react-perf/jsx-no-new-object-as-prop": "off",
-  "react-perf/jsx-no-new-array-as-prop": "off",
-  "react-perf/jsx-no-new-function-as-prop": "off",
-  "react-perf/jsx-no-jsx-as-prop": "off",
-  "react-extra/jsx-sort-props": [
-    "error",
-    {
-      ignoreCase: true,
-      callbacksLast: true,
-      shorthandFirst: true,
-      multiline: "ignore",
-      locale: "auto"
-    }
-  ],
-  "react-extra/jsx-first-prop-new-line": ["error", "multiline"],
-  "react-extra/jsx-max-props-per-line": [
-    "error",
-    {
-      when: "multiline",
-      maximum: 1
-    }
-  ],
-  "react-extra/jsx-indent-props": ["error", 2],
-  "react-extra/jsx-closing-bracket-location": ["error", "line-aligned"],
-  "react-extra/jsx-wrap-multilines": [
-    "error",
-    {
-      declaration: "parens-new-line",
-      assignment: "parens-new-line",
-      return: "parens-new-line",
-      arrow: "parens-new-line",
-      condition: "parens-new-line",
-      logical: "parens-new-line",
-      prop: "parens-new-line"
-    }
-  ],
-  "react-extra/jsx-curly-newline": ["error", "consistent"],
-  "react-extra/jsx-no-leaked-render": "error",
-  "react-extra/no-unstable-nested-components": "error",
-  "react-extra/function-component-definition": [
-    "error",
-    {
-      namedComponents: "function-declaration"
-    }
-  ],
-  "react-extra/hook-use-state": "error",
-  "react-extra/no-deprecated": "error",
-  "react-extra/jsx-uses-vars": "off",
-  "react-extra/require-render-return": "error",
-  "svg-jsx/camel-case-colon": "error",
-  "svg-jsx/no-style-string": "error"
-};
-var presetEffectsRules = {
-  "react-you-might-not-need-an-effect/no-adjust-state-on-prop-change": "error",
-  "react-you-might-not-need-an-effect/no-reset-all-state-on-prop-change": "error",
-  "react-you-might-not-need-an-effect/no-event-handler": "error",
-  "react-you-might-not-need-an-effect/no-pass-live-state-to-parent": "error",
-  "react-you-might-not-need-an-effect/no-pass-data-to-parent": "error",
-  "react-you-might-not-need-an-effect/no-initialize-state": "error",
-  "react-you-might-not-need-an-effect/no-chain-state-updates": "error",
-  "react-you-might-not-need-an-effect/no-derived-state": "error"
-};
-var presetTailwindRules = {
-  "tailwindcss/enforce-canonical": "error",
-  "tailwindcss/enforce-sort-order": "error",
-  "tailwindcss/enforce-shorthand": "error",
-  "tailwindcss/no-conflicting-classes": "error",
-  "tailwindcss/no-duplicate-classes": "error",
-  "tailwindcss/no-unknown-classes": "off",
-  "tailwindcss/no-unnecessary-whitespace": "error",
-  "tailwindcss/no-deprecated-classes": "error"
-};
-var presetImportRules = {
-  "import/first": "error",
-  "import/no-absolute-path": "error",
-  "import/no-mutable-exports": "error",
-  "import/no-self-import": "error",
-  "import/no-duplicates": "error",
-  "import/no-named-as-default": "error",
-  "import/no-named-as-default-member": "error",
-  "import/consistent-type-specifier-style": "error",
-  "unused-imports/no-unused-imports": "error",
-  "import-extra/no-useless-path-segments": "error",
-  "import-extra/no-relative-packages": "error",
-  "import-extra/newline-after-import": "error",
-  "perfectionist/sort-named-imports": [
-    "error",
-    {
-      type: "natural",
-      ignoreCase: true
-    }
-  ]
-};
-var presetNamingRules = {
-  "unicorn/filename-case": [
-    "error",
-    {
-      case: "kebabCase"
-    }
-  ]
-};
-var presetTestRules = {
-  "jest/expect-expect": "off",
-  "jest/no-conditional-expect": "off",
-  "jest/no-disabled-tests": "off",
-  "jest/no-export": "off",
-  "jest/no-standalone-expect": "off",
-  "jest/require-to-throw-message": "off",
-  "vitest/no-conditional-expect": "error",
-  "vitest/require-mock-type-parameters": "error"
-};
-var presetModuleMockingApis = ["*.mock", "*.doMock", "*.unstable_mockModule"];
-var presetTestMockingApis = {
-  modules: presetModuleMockingApis,
-  strict: [...presetModuleMockingApis, "*.spyOn", "*.stubGlobal", "*.stubEnv"]
-};
-var presetTestMockingAllow = {
-  modules: [],
-  strict: [{ files: ["**/*.driver.test.ts"], apis: ["*"] }]
-};
-var presetStrictMockingMessage = "Inject a fake driver through the dependencies of the code under test instead of mocking or stubbing.";
-var presetNextHandlerMethods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
-var presetNextSegmentConfig = [
-  "generateStaticParams",
-  "dynamic",
-  "dynamicParams",
-  "revalidate",
-  "fetchCache",
-  "runtime",
-  "preferredRegion",
-  "maxDuration"
-];
-var presetNextSegmentExports = [
-  "generateMetadata",
-  "metadata",
-  "generateViewport",
-  "viewport",
-  ...presetNextSegmentConfig
-];
-var presetExportPrefix = {
-  stem: "before-first-dot",
-  trailingRoles: ["constants", "utils", "handler", "service", "types"],
-  roleSeparators: [".", "-"],
-  normalize: "remove-separators",
-  allowPattern: "^(make[A-Z]|\\*$)"
-};
-var presetGeneratedFiles = [
-  "**/*.generated.*",
-  "**/*.gen.*",
-  "**/*.d.ts",
-  "**/routes.tree.ts",
-  "**/routeTree.gen.ts",
-  "**/paraglide/**"
-];
-
-// src/utils/helpers/preset.ts
-function presetScopes(roots, suffix = `**/${presetExtensions}`) {
-  return roots.map((root) => root === "." ? suffix : `${root}/${suffix}`);
-}
-function presetOverride(files, rules, excludeFiles = []) {
-  return {
-    files,
-    excludeFiles: [...presetGeneratedFiles, ...excludeFiles],
-    rules
-  };
-}
-function presetRuleSeverities(rules, severities) {
-  const result = structuredClone(rules);
-  for (const [name, level] of Object.entries(severities)) {
-    const value = result[name];
-    const current = Array.isArray(value) ? value[0] : value;
-    if (value === undefined || current === "off" || current === "allow" || current === 0) {
-      continue;
-    }
-    result[name] = Array.isArray(value) && level !== "off" ? [level, ...value.slice(1)] : level;
-  }
-  return result;
-}
-function presetPackageName(root, directory) {
-  try {
-    const manifest = JSON.parse(readFileSync(resolve(root, directory, "package.json"), "utf8"));
-    return typeof manifest.name === "string" ? manifest.name : undefined;
-  } catch {
-    return;
-  }
-}
-function presetSeverity(rules, level) {
-  const result = structuredClone(rules);
-  for (const [name, value] of Object.entries(result)) {
-    const current = Array.isArray(value) ? value[0] : value;
-    if (current === "off" || current === "allow" || current === 0) {
-      continue;
-    }
-    result[name] = Array.isArray(value) ? [level, ...value.slice(1)] : level;
-  }
-  return result;
-}
-function presetReadJsonc(path) {
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    return;
-  }
-  let output = "";
-  for (let index = 0;index < text.length; index++) {
-    const character = text[index];
-    if (character === '"') {
-      const end = /"(?:[^"\\]|\\.)*"/y;
-      end.lastIndex = index;
-      const literal = end.exec(text)?.[0] ?? text.slice(index);
-      output += literal;
-      index += literal.length - 1;
-    } else if (character === "/" && text[index + 1] === "/") {
-      index = text.indexOf(`
-`, index) === -1 ? text.length : text.indexOf(`
-`, index) - 1;
-    } else if (character === "/" && text[index + 1] === "*") {
-      index = text.indexOf("*/", index + 2) === -1 ? text.length : text.indexOf("*/", index + 2) + 1;
-    } else if (character === "}" || character === "]") {
-      output = output.replace(/,\s*$/, "") + character;
-    } else {
-      output += character;
-    }
-  }
-  try {
-    return JSON.parse(output);
-  } catch {
-    return;
-  }
-}
-function presetTsconfigAliasTargets(root, directory, specifier) {
-  const config = presetReadJsonc(resolve(root, directory, "tsconfig.json"));
-  if (!config || typeof config !== "object" || !("compilerOptions" in config))
-    return [];
-  const { compilerOptions } = config;
-  if (!compilerOptions || typeof compilerOptions !== "object" || !("paths" in compilerOptions))
-    return [];
-  const { paths } = compilerOptions;
-  const baseUrl = "baseUrl" in compilerOptions && typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : ".";
-  if (!paths || typeof paths !== "object")
-    return [];
-  return Object.entries(paths).flatMap(([pattern, targets]) => {
-    const [prefix, suffix = ""] = pattern.split("*");
-    const wildcard = pattern.includes("*");
-    const matches = wildcard ? specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length : specifier === pattern;
-    if (!matches || !Array.isArray(targets))
-      return [];
-    const captured = wildcard ? specifier.slice(prefix.length, specifier.length - suffix.length) : "";
-    return targets.filter((target) => typeof target === "string").map((target) => relative(root, resolve(root, directory, baseUrl, target.replace("*", captured))).replaceAll("\\", "/")).filter((target) => target && !target.startsWith("..") && existsSync(resolve(root, target)));
-  });
-}
-
-// src/configs/source.ts
-function presetSourceConfig(context) {
-  const { options, web, scripts, app, appFiles, backendFiles, ui, safetyFiles, publicEntrypoints, baseImports } = context;
-  const policies = {};
-  const { semi = "always", quotes = "single" } = options.formatting ?? {};
-  policies.formatting = [
-    presetOverride([`**/${presetExtensions}`], {
-      ...presetFormattingRules,
-      "eslint-js/semi": ["error", semi],
-      "eslint-js/quotes": ["error", quotes, { avoidEscape: true }]
-    })
-  ];
-  policies.statementLayout = [
-    presetOverride([`**/${presetExtensions}`], {
-      "arch/padding-between-statements": ["error", { multilineVariables: true }],
-      "arch/object-multiline": ["error", { minProperties: 3, scope: "call-args" }],
-      "arch/call-array-multiline": ["error", { callees: ["Promise.all"], minElements: 2 }],
-      "arch/key-value-same-line": "error"
-    })
-  ];
-  policies.imports = [
-    presetOverride([`**/${presetExtensions}`], {
-      ...presetImportRules,
-      "arch/prefer-namespace-type-import": ["error", { max: 3 }],
-      "no-restricted-imports": ["error", { patterns: baseImports }],
-      "import-extra/no-relative-packages": "error",
-      "perfectionist/sort-imports": [
-        "error",
-        {
-          type: "natural",
-          ignoreCase: true,
-          newlinesBetween: 0,
-          environment: "bun",
-          internalPattern: options.imports?.internalSortPatterns ?? [
-            "^@/.*",
-            "^#.*",
-            "^~icons/.*",
-            ...publicEntrypoints.map((path) => `^${path.split("/").slice(0, 2).join("/")}/`)
-          ],
-          groups: [["builtin", "external"], "internal", ["parent", "sibling", "index"], "type"]
-        }
-      ]
-    })
-  ];
-  policies.comments = [
-    presetOverride(appFiles, {
-      "arch/no-comments": ["error", { allowWhy: false, allowPatterns: ["^\\s*SAFETY: "] }]
-    }, ui),
-    presetOverride(presetScopes(app, "**/*.{types,constants}.ts"), {
-      "arch/no-comments": ["error", { allowWhy: false }]
-    }),
-    presetOverride([`**/${presetExtensions}`], {
-      "modules/reasoned-directives": "error"
-    })
-  ];
-  policies.trivialFunctions = [
-    presetOverride(appFiles, {
-      "arch/no-trivial-functions": ["error", { mode: "precise", allowAsync: false, allowCallees: [] }]
-    }, ui)
-  ];
-  policies.trivialFunctions.push(presetOverride([...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")], {
-    "arch/no-trivial-functions": [
-      "error",
-      { mode: "precise", allowAsync: false, allowCallees: [], checkServiceMethods: true }
-    ]
-  }, ui));
-  policies.mutableState = [
-    presetOverride(safetyFiles, { "arch/no-module-mutable-state": ["error", { kinds: ["let", "var"] }] }, ui)
-  ];
-  policies.backend = [
-    presetOverride(backendFiles, { "modules/backend-switch": "error" }, options.cliFiles),
-    presetOverride([`**/${presetExtensions}`], { "no-console": "error" }, [
-      ...presetScopes(scripts, "**"),
-      ...options.cliFiles ?? []
-    ]),
-    presetOverride(safetyFiles, { "modules/double-negation": "error" }, ui)
-  ];
-  return policies;
-}
-
-// src/configs/types.ts
-function presetTypesConfig(context) {
-  const {
-    options,
-    web,
-    backend,
-    packageSources,
-    serviceRoots,
-    app,
-    appFiles,
-    webFiles,
-    services,
-    utilities,
-    types,
-    ui,
-    testFiles,
-    safetyFiles,
-    components,
-    hooks,
-    publicEntrypoints,
-    tanstackWeb,
-    nextWeb
-  } = context;
-  const schemaOwners = backend.length ? backend : nextWeb;
-  const runtimeFreeTypes = backend.length ? web : tanstackWeb;
-  const colocatedTypes = options.modules?.colocatedTypeFiles ?? [];
-  const policies = {};
-  policies.typePlacement = [
-    presetOverride(appFiles, { "arch/no-type-declarations": "error" }, [
-      ...types,
-      ...colocatedTypes,
-      ...components,
-      ...hooks,
-      ...services,
-      ...ui,
-      ...testFiles
-    ]),
-    presetOverride(services, { "modules/service-types": "error" }, [...utilities, ...testFiles]),
-    presetOverride([...components, ...hooks], {
-      "modules/local-type-alias": "error",
-      "modules/pascal-interface": "error",
-      "arch/declaration-name": [
-        "error",
-        {
-          kinds: ["interface"],
-          stem: "before-first-dot",
-          normalize: "remove-separators"
-        }
-      ]
-    }, [...ui, ...testFiles]),
-    ...options.react?.componentProps === false ? [] : [presetOverride(components, { "arch/component-props": ["error", { filePrefix: true }] }, [...ui, ...testFiles])],
-    presetOverride(presetScopes(app, "**/*.types.ts"), {
-      "arch/no-restricted-files": ["error", { message: "Domain types belong in src/types." }]
-    }, [...types, ...colocatedTypes, ...ui]),
-    presetOverride(presetScopes(app, "**/*.{utils,constants}.ts"), {
-      "arch/no-type-declarations": "error"
-    }, [...ui, ...testFiles]),
-    presetOverride([
-      ...presetScopes([...schemaOwners, ...packageSources], "types/**/*.types.ts"),
-      ...colocatedTypes,
-      ...presetScopes(app, "**/*.constants.ts")
-    ], {
-      "arch/no-top-level-functions": ["error", { banReExports: false }]
-    }),
-    ...runtimeFreeTypes.length ? [
-      presetOverride(presetScopes(runtimeFreeTypes, "types/**/*.types.ts"), {
-        "arch/no-runtime-in-types": ["error", { runtimeImports: "ban", allowImportSources: [], banReExports: true }]
-      })
-    ] : []
-  ];
-  policies.typeSafety = [
-    presetOverride(safetyFiles, {
-      "typescript/no-explicit-any": "error",
-      "typescript/ban-ts-comment": [
-        "error",
-        {
-          "ts-ignore": true,
-          "ts-nocheck": true,
-          "ts-expect-error": true,
-          "ts-check": false
-        }
-      ],
-      "modules/no-unknown": "error",
-      "modules/shape-suffix": "error",
-      "arch/no-imported-type-alias": "error",
-      "arch/no-literal-in": "error",
-      "arch/no-promise-all-mutation": "error",
-      "arch/no-restricted-constructor": ["error", { constructors: ["Error"], checkCalls: true }],
-      "dillon-anti-slop/no-chained-type-assertions": "error",
-      "dillon-anti-slop/no-conditional-empty-object-spread": "error",
-      "dillon-anti-slop/no-known-value-widening": "error",
-      "dillon-anti-slop/no-reflect-apply": "error",
-      "dillon-anti-slop/no-reflect-get": "error",
-      "dillon-anti-slop/no-runtime-typeof": "error",
-      "dillon-anti-slop/no-unknown-parameters": "error",
-      "dillon-anti-slop/no-unknown-returns": "error",
-      "dillon-anti-slop/no-unknown-type-aliases": "error",
-      "dillon-anti-slop/no-unsafe-dictionary-type": "error",
-      "dillon-anti-slop/no-widen-then-assert": "error",
-      "dillon-anti-slop/require-safety-comment-for-type-assertion": "error"
-    })
-  ];
-  policies.schemas = [
-    presetOverride(appFiles, {
-      "arch/no-local-schema-construction": ["error", { packages: ["zod"], namespaces: ["z"] }]
-    }, [
-      ...presetScopes([...schemaOwners, ...packageSources], "types/**"),
-      ...colocatedTypes,
-      ...ui
-    ]),
-    presetOverride([...webFiles, ...presetScopes(packageSources)], {
-      "arch/no-rederive-schema": [
-        "error",
-        {
-          from: publicEntrypoints,
-          namespaces: ["z"],
-          operators: ["infer", "input"]
-        }
-      ]
-    }),
-    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), {
-      "arch/no-unescaped-like": [
-        "error",
-        {
-          methods: ["like", "ilike"],
-          operatorMethods: ["where"],
-          sanitizers: options.sql?.likeSanitizers ?? ["escapeLikeWildcards"],
-          allowSanitizedBindings: true
-        }
-      ]
-    }),
-    ...options.orpc?.publicProcedureFiles?.length ? [
-      presetOverride(options.orpc?.publicProcedureFiles, {
-        "arch/require-orpc-output": [
-          "error",
-          {
-            handlerMethod: "handler",
-            outputMethod: "output",
-            composers: options.orpc?.outputSchemaComposers ?? []
-          }
-        ]
-      })
-    ] : []
-  ];
-  return policies;
-}
-
-// src/configs/modules.ts
-import { posix } from "node:path";
-function presetModulesConfig(context) {
-  const { web, nextWeb, serviceRoots, app, services, utilities, ui, testFiles, components, hooks, options } = context;
-  const conceptFiles = (options.modules?.customFileRoles ?? []).map((role) => `**/*.${role}.ts`);
-  const migrations = options.modules?.migrationFiles ?? [];
-  const frontendEntries = [
-    ...presetScopes(web, "services/**/*.{client,server,rsc}.ts"),
-    ...presetScopes(web, "services/**/*.rsc.tsx")
-  ];
-  const policies = {};
-  policies.fileLayout = [
-    ...context.folders.flatMap(({ path, folder, mode }) => [
-      presetOverride([
-        mode === "flat" ? `${path}/*/**/${presetExtensions}` : `${path}/${presetExtensions}`,
-        ...mode === "domain" ? [`${path}/*/*/**/${presetExtensions}`] : []
-      ], {
-        "arch/no-restricted-files": [
-          "error",
-          {
-            message: mode === "flat" ? "This folder uses a flat layout; subfolders are forbidden." : "This folder uses exactly one owning domain directory; loose and deeper files are forbidden."
-          }
-        ]
-      }, migrations),
-      ...mode === "domain" ? [
-        presetOverride([`${path}/*/${presetExtensions}`], {
-          "arch/folder-prefix": [
-            "error",
-            {
-              singularize: folder === "components" ? "trailing-s" : "none",
-              separators: [".", "-"],
-              ...folder === "hooks" ? { stripPrefixes: ["use-"] } : {}
-            }
-          ]
-        })
-      ] : []
-    ]),
-    presetOverride(presetScopes(web.filter((path) => !context.folders.some((scope) => scope.path === posix.join(path, "components"))), `components/*/*/**/${presetExtensions}`), {
-      "arch/no-restricted-files": ["error", { message: "Components allow one group folder." }]
-    }, ui),
-    presetOverride([...presetScopes(web, "components/**/*.ts"), ...presetScopes(web, "hooks/**/*.tsx")], {
-      "arch/no-restricted-files": ["error", { message: "Components use TSX; hooks use .ts files." }]
-    }, ui),
-    presetOverride(presetScopes(web, "**/use-*.{ts,tsx}"), {
-      "arch/no-restricted-files": ["error", { message: "Hooks belong in src/hooks." }]
-    }, [...presetScopes(web, "hooks/**"), ...ui]),
-    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), {
-      "arch/no-restricted-files": [
-        "error",
-        {
-          message: "Frontend services use .client.ts, .server.ts or .rsc.{ts,tsx}; shared domain helpers use .utils.ts and values use .constants.ts."
-        }
-      ]
-    }, [
-      "**/*.{client,server,rsc,utils,constants}.ts",
-      "**/*.rsc.tsx",
-      ...presetScopes(nextWeb, "services/**/*.action.ts"),
-      ...conceptFiles,
-      ...options.modules?.colocatedTypeFiles ?? []
-    ])
-  ];
-  policies.serviceStructure = [
-    presetOverride(services, {
-      "modules/service-functions": "error",
-      "arch/no-inline-types": [
-        "error",
-        {
-          parameters: true,
-          returns: true,
-          functionTypes: true,
-          minMembers: 1
-        }
-      ]
-    }, [...utilities, ...testFiles, ...conceptFiles, ...migrations]),
-    presetOverride(frontendEntries, {
-      "modules/service-functions": ["error", { frontend: true }]
-    }, testFiles),
-    ...conceptFiles.map((pattern) => presetOverride(presetScopes(app, `services/${pattern}`), {
-      "modules/service-functions": "off",
-      "arch/export-file-prefix": [
-        "error",
-        {
-          stem: "full-basename",
-          allFunctions: true
-        }
-      ]
-    }, testFiles)),
-    presetOverride([
-      ...presetScopes(app, "services/**/*-{action,query}.*.ts"),
-      ...presetScopes(web, "services/**/*-{action,query}.*.rsc.tsx")
-    ], {
-      "modules/service-functions": [
-        "error",
-        {
-          allowLocalHelpers: true,
-          singleExport: true,
-          message: "Action/query files export exactly one named operation. Keep helpers used only by this operation private inside its function; do not export them. Move a helper to the module's .utils.ts only when it is genuinely shared, not merely to satisfy lint."
-        }
-      ]
-    }, testFiles),
-    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), { "modules/domain-constants": "error" }, [
-      ...utilities,
-      ...testFiles
-    ]),
-    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), {
-      "modules/domain-constants": ["error", { includeData: true }]
-    }, ["**/*.constants.ts", ...testFiles]),
-    presetOverride(frontendEntries, {
-      "modules/domain-constants": ["error", { includeData: true, allowServiceMethods: true }]
-    }, testFiles),
-    presetOverride([...presetScopes(serviceRoots, "services/**/*-{action,query}.*.ts"), ...frontendEntries], { "arch/require-object-params": ["error", { maxParams: 2 }] }, testFiles),
-    presetOverride(frontendEntries, {
-      "arch/require-object-params": ["error", { maxParams: 2, serviceMethods: true }]
-    }, testFiles),
-    presetOverride(presetScopes(serviceRoots, "services/**/*.service.ts"), {
-      "arch/no-extra-exports": [
-        "error",
-        {
-          names: ["make{Domain}Service", "{Domain}Service"],
-          domainStem: "before-first-dot",
-          allowTypeExports: false
-        }
-      ]
-    }, testFiles),
-    presetOverride(presetScopes(app, "services/**/{actions,queries}/**/*.ts"), {
-      "arch/no-restricted-files": [
-        "error",
-        { message: "Use domain-action.name.ts or domain-query.name.ts." }
-      ]
-    })
-  ];
-  policies.naming = [
-    presetOverride([`**/${presetExtensions}`], presetNamingRules),
-    presetOverride(presetScopes(app, "types/**/*.ts"), {
-      "arch/filename-match": [
-        "error",
-        {
-          pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*[.]types[.]ts$",
-          message: "Use domain.types.ts filenames."
-        }
-      ]
-    }, ["**/*.constants.ts"]),
-    presetOverride(presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/export-file-prefix": ["error", presetExportPrefix] }, [...ui, ...presetScopes(serviceRoots, "entry.*.ts")]),
-    presetOverride(frontendEntries, {
-      "arch/export-file-prefix": [
-        "error",
-        { ...presetExportPrefix, allFunctions: true, serviceMethods: true, allowPattern: "^\\*$" }
-      ]
-    }, testFiles),
-    presetOverride(presetScopes(web, "services/**/*.constants.ts"), {
-      "arch/export-file-prefix": [
-        "error",
-        { ...presetExportPrefix, allDeclarations: true, allowPattern: "^\\*$" }
-      ]
-    }, testFiles),
-    presetOverride(presetScopes(app, "**/*.utils.ts"), {
-      "arch/export-file-prefix": [
-        "error",
-        {
-          ...presetExportPrefix,
-          allFunctions: true,
-          allowPattern: "^\\*$"
-        }
-      ]
-    }, ui),
-    presetOverride(hooks, {
-      "arch/filename-match": [
-        "error",
-        {
-          pattern: "^use-[a-z0-9]+(?:-[a-z0-9]+)*(?:[.](?:web|native|ios|android))?[.]ts$",
-          message: "Hooks use use-domain.ts filenames, with an optional .web, .native, .ios or .android platform suffix."
-        }
-      ],
-      "arch/export-file-prefix": "error",
-      "arch/export-name-pattern": ["error", { pattern: "^use[A-Z]", ignoreTypeExports: true }]
-    }, ui),
-    presetOverride(components, {
-      "arch/only-export-components": ["error", { matchFileName: true, allowTypeExports: true, trailingRoles: ["illustration"] }]
-    }, [...ui, ...testFiles]),
-    presetOverride(presetScopes(web.filter((path) => !context.folders.some((scope) => scope.path === posix.join(path, "components"))), "components/**/*.tsx"), {
-      "arch/folder-prefix": ["error", { singularize: "trailing-s", separators: ["-"] }]
-    }, [...ui, ...testFiles]),
-    ...["action", "query"].map((role) => presetOverride([
-      ...presetScopes(app, `services/**/*-${role}.*.ts`),
-      ...presetScopes(web, `services/**/*-${role}.*.rsc.tsx`)
-    ], {
-      "arch/filename-match": [
-        "error",
-        {
-          pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*-${role}\\.[a-z0-9]+(?:-[a-z0-9]+)*\\.ts$`,
-          message: "Use domain-action.name.ts or domain-query.name.ts."
-        }
-      ],
-      "arch/export-file-prefix": [
-        "error",
-        {
-          ...presetExportPrefix,
-          trailingRoles: [role],
-          allFunctions: true,
-          allowPattern: "^\\*$"
-        }
-      ],
-      "arch/filename-export-name": [
-        "error",
-        {
-          file: `{domain}-${role}.{name}.ts`,
-          export: `{domain}${role === "action" ? "Action" : "Query"}{Name}`,
-          placeholderPattern: "[a-z0-9-]+",
-          camelCase: true
-        }
-      ]
-    })),
-    ...["action", "query"].flatMap((role) => ["client.ts", "server.ts", "rsc.ts", "rsc.tsx"].map((suffix) => presetOverride(presetScopes(web, `services/**/*-${role}.*.${suffix}`), {
-      "arch/filename-match": [
-        "error",
-        {
-          pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*-${role}\\.[a-z0-9]+(?:-[a-z0-9]+)*\\.${suffix.replace(".", "\\.")}$`,
-          message: "Frontend operations retain a client, server or rsc runtime suffix."
-        }
-      ],
-      "arch/filename-export-name": [
-        "error",
-        {
-          file: `{domain}-${role}.{name}.${suffix}`,
-          export: `{domain}${role === "action" ? "Action" : "Query"}{Name}`,
-          placeholderPattern: "[a-z0-9-]+",
-          camelCase: true
-        }
-      ]
-    }))),
-    presetOverride(presetScopes(web, "services/**/*.rsc.{ts,tsx}"), {
-      "arch/export-name-pattern": ["error", { pattern: "^[a-z][a-z0-9]*Rsc[A-Z][a-zA-Z0-9]*$" }]
-    }, ["**/*-{action,query}.*.rsc.{ts,tsx}"])
-  ];
-  return policies;
-}
-
-// src/utils/helpers/mocking.ts
-function mockingApiPatternsAssert(patterns) {
-  if (patterns.some((pattern) => !/^(?:\*|(?:vi|jest|\*)\.(?:[A-Za-z_$][\w$]*|\*))$/.test(pattern)))
-    throw new Error("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
-}
-
-// src/configs/tests.ts
-function presetTestsConfig(context) {
-  const { backendRoots, testFiles, baseImports, options } = context;
-  const profile = options.tests?.profile ?? "fixtures";
-  if (profile !== "standard" && profile !== "fixtures")
-    throw new Error("Unknown test profile.");
-  const testFunctions = ["test", "it", ...options.tests?.additionalTestFunctions ?? []];
-  const assertionFunctions = options.tests?.additionalAssertionFunctions ?? [];
-  if (testFunctions.some((name) => !/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(name)))
-    throw new Error("Additional test functions must be literal identifiers or dotted names.");
-  if (assertionFunctions.some((name) => !/^[A-Za-z_$][\w$]*(?:\.[\w$*]+)*$/.test(name)))
-    throw new Error("Assertion functions must be rooted dotted names or patterns.");
-  const mocking = typeof options.tests?.mocking === "string" ? { preset: options.tests.mocking } : options.tests?.mocking ?? {};
-  const mockingPreset = mocking.preset ?? "modules";
-  if (mockingPreset !== "modules" && mockingPreset !== "strict")
-    throw new Error("Unknown test mocking preset.");
-  const mockingDeny = [...mocking.deny ?? [], ...presetTestMockingApis[mockingPreset]].map((entry) => {
-    if (typeof entry !== "string")
-      return entry;
-    return mockingPreset === "strict" ? { api: entry, message: presetStrictMockingMessage } : entry;
-  });
-  const mockingAllow = [...presetTestMockingAllow[mockingPreset], ...mocking.allow ?? []].sort((left, right) => Number(left.apis.includes("*")) - Number(right.apis.includes("*")));
-  mockingApiPatternsAssert([
-    ...mockingDeny.map((entry) => typeof entry === "string" ? entry : entry.api),
-    ...mockingAllow.flatMap((entry) => entry.apis)
-  ]);
-  const mockingCustomized = mockingPreset !== "modules" || (mocking.deny ?? []).length > 0;
-  const mockingRule = (allow) => [
-    "error",
-    { deny: mockingDeny, allow: ["*.fn", ...allow], checkDestructured: mockingCustomized }
-  ];
-  const policies = {};
-  policies.tests = [
-    presetOverride(testFiles, {
-      ...presetTestRules,
-      "dillon-anti-slop/no-module-mocking": mockingCustomized ? mockingRule([]) : "error",
-      "modules/test-modifiers": [
-        "error",
-        { additionalTestFunctions: options.tests?.additionalTestFunctions ?? [] }
-      ],
-      "modules/test-assertions": [
-        "error",
-        {
-          additionalTestFunctions: options.tests?.additionalTestFunctions ?? [],
-          additionalAssertionFunctions: assertionFunctions
-        }
-      ],
-      "arch/test-title-pattern": [
-        "error",
-        { callees: ["describe", ...testFunctions], forbid: "^should\\b", flags: "i" }
-      ]
-    }),
-    presetOverride(presetScopes(backendRoots, "tests/**/*.ts"), {
-      "modules/concurrent-db": "error",
-      ...profile === "fixtures" ? {
-        "no-restricted-imports": [
-          "error",
-          {
-            patterns: [
-              ...baseImports,
-              {
-                group: ["**/helpers/**"],
-                message: "Use named fixtures or tests/support."
-              }
-            ]
-          }
-        ]
-      } : {}
-    }),
-    ...mockingAllow.map((entry) => presetOverride(entry.files, {
-      "dillon-anti-slop/no-module-mocking": entry.apis.includes("*") ? "off" : mockingRule(entry.apis)
-    }))
-  ];
-  return policies;
-}
-
-// src/configs/react.ts
-function presetReactConfig(context) {
-  const { options, web, tanstackWeb, nextWeb, webFiles, reactFiles, webUiRoots, ui, testFiles, components, css } = context;
-  const policies = {};
-  if (reactFiles.length) {
-    policies.react = [
-      presetOverride(reactFiles, {
-        ...presetReactRules,
-        ...options.react?.compiler === false ? {
-          "react-perf/jsx-no-new-object-as-prop": "error",
-          "react-perf/jsx-no-new-array-as-prop": "error",
-          "react-perf/jsx-no-new-function-as-prop": "error",
-          "react-perf/jsx-no-jsx-as-prop": "error"
-        } : {},
-        "arch/jsx-attributes-multiline": ["error", { minAttributes: 3 }]
-      }, ui),
-      presetOverride(components, {
-        "arch/no-file-level-helpers": ["error", { detectComponents: true, hookPattern: "^use[A-Z]" }]
-      }, [...ui, ...testFiles])
-    ];
-  }
-  if (reactFiles.length) {
-    policies.effects = [presetOverride(reactFiles, { ...presetEffectsRules, "modules/empty-effect": "error" }, ui)];
-  }
-  const nextPage = { bannedHooks: ["useState", "useEffect", "useMutation"], inspectExports: true };
-  const routes = [
-    ...tanstackWeb.length ? [
-      presetOverride(presetScopes(tanstackWeb, "routes/**/*.{ts,tsx}"), {
-        "arch/route-surface": [
-          "error",
-          {
-            exportName: "Route",
-            bannedHooks: ["useState", "useEffect", "useMutation"],
-            banIntrinsicJsx: true
-          }
-        ]
-      }, testFiles),
-      presetOverride(presetScopes(tanstackWeb, "routes/handlers/**/*.ts"), {
-        "arch/no-file-level-helpers": [
-          "error",
-          {
-            detectComponents: false,
-            message: "Nest this helper in its owning route handler callback, or move genuine domain logic to a service. Do not create a component, hook or public helper to bypass this rule."
-          }
-        ]
-      })
-    ] : [],
-    ...nextWeb.length ? [
-      presetOverride(presetScopes(nextWeb, "app/**/{page,template,default,not-found,forbidden,unauthorized,loading}.tsx"), {
-        "arch/route-surface": [
-          "error",
-          { exportName: "default", allowedExports: presetNextSegmentExports, banIntrinsicJsx: true, ...nextPage }
-        ]
-      }, [...testFiles, ...presetScopes(nextWeb, "app/not-found.tsx")]),
-      presetOverride([...presetScopes(nextWeb, "app/**/{layout,global-not-found}.tsx"), ...presetScopes(nextWeb, "app/not-found.tsx")], {
-        "arch/route-surface": [
-          "error",
-          { exportName: "default", allowedExports: presetNextSegmentExports, banIntrinsicJsx: false, ...nextPage }
-        ]
-      }, testFiles),
-      presetOverride(presetScopes(nextWeb, "app/**/route.ts"), {
-        "arch/route-surface": [
-          "error",
-          {
-            exportName: "GET",
-            allowedExports: [...presetNextHandlerMethods.slice(1), ...presetNextSegmentConfig],
-            bannedHooks: [],
-            banIntrinsicJsx: false
-          }
-        ],
-        "arch/no-file-level-helpers": [
-          "error",
-          {
-            detectComponents: false,
-            allowPattern: `^(${[...presetNextHandlerMethods, ...presetNextSegmentConfig].join("|")})$`,
-            message: "Nest this helper in its owning route handler, or move genuine domain logic to a service. Do not create a component, hook or public helper to bypass this rule."
-          }
-        ]
-      })
-    ] : []
-  ];
-  if (routes.length) {
-    policies.routes = routes;
-  }
-  if (reactFiles.length) {
-    policies.forms = [
-      presetOverride(reactFiles, {
-        "arch/require-paired-call": [
-          "error",
-          {
-            when: "useForm",
-            require: options.forms?.schemaResolver ?? "standardSchemaResolver"
-          }
-        ]
-      }, ui)
-    ];
-  }
-  if (reactFiles.length && options.react?.compiler !== false) {
-    policies.memoization = [presetOverride(reactFiles, { "modules/memoization": "error" }, ui)];
-  }
-  if (web.length) {
-    policies.rpcClientOwnership = [
-      presetOverride(webFiles, {
-        "arch/no-restricted-token": [
-          "error",
-          {
-            restrictions: [
-              {
-                token: "RouterClient",
-                allowIn: [...options.orpc?.clientOwnerFile ? [options.orpc?.clientOwnerFile] : context.rpcClients]
-              },
-              {
-                token: "createContext",
-                allowPathPatterns: [...presetScopes(web, "context/"), ...webUiRoots.map((path) => `${path}/`)]
-              }
-            ]
-          }
-        ]
-      })
-    ];
-  }
-  if (Object.keys(css).length) {
-    policies.tailwind = Object.entries(css).map(([path, entryPoint]) => presetOverride(presetScopes([path]), Object.fromEntries(Object.entries(presetTailwindRules).map(([rule, severity]) => [
-      rule,
-      rule === "tailwindcss/no-duplicate-classes" || rule === "tailwindcss/no-unnecessary-whitespace" ? severity : [severity, { entryPoint }]
-    ]))));
-  }
-  if (Object.keys(css).length && options.shadcn !== false) {
-    const allow = ["layout", "opacity", "truncate"];
-    const padding = ["p", "px", "py", "ps", "pe", "pt", "pr", "pb", "pl"];
-    const gap = ["gap", "gap-x", "gap-y"];
-    const safeArea = padding.flatMap((group) => ["top", "right", "bottom", "left"].flatMap((side) => [
-      `${group}-[env(safe-area-inset-${side})]`,
-      ...group === "p" ? [] : [`${group}-[max(--spacing(*),env(safe-area-inset-${side}))]`]
-    ]));
-    const illustrationPalette = [
-      "text-color",
-      "bg-color",
-      "gradient-from",
-      "gradient-via",
-      "gradient-to",
-      "border-color",
-      "divide-color",
-      "outline-color",
-      "ring-color",
-      "ring-offset-color",
-      "shadow",
-      "shadow-color",
-      "inset-shadow",
-      "inset-shadow-color",
-      "drop-shadow",
-      "drop-shadow-color",
-      "fill",
-      "stroke",
-      "bg-image",
-      "bg-size",
-      "bg-position",
-      "mask-image",
-      "blur",
-      "saturate"
-    ];
-    const restyle = (base) => ({
-      allow: base,
-      contracts: [
-        { pattern: "^(CardContent|PopoverContent)$", allow: [...base, ...padding] },
-        { pattern: "^TabsContent$", allow: [...base, ...gap, ...padding] },
-        { pattern: "^(Tabs|HoverCardContent|SidebarHeader|BreadcrumbList)$", allow: [...base, ...gap] }
-      ]
-    });
-    policies.shadcn = [
-      presetOverride(webFiles, {
-        "shadcn/no-restyle": ["error", restyle(allow)],
-        "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea] }],
-        "shadcn/require-static-classes": "error",
-        "modules/dynamic-classes": "error"
-      }, ui),
-      presetOverride(presetScopes(web, "components/**/*.illustration.tsx"), {
-        "shadcn/no-restyle": ["error", restyle([...allow, ...illustrationPalette])],
-        "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea, ...illustrationPalette] }]
-      }, ui),
-      presetOverride(webFiles, {
-        "shadcn/no-unknown-classes": ["error", { allow: [] }]
-      }),
-      presetOverride(presetScopes(webUiRoots, "sonner.tsx"), {
-        "shadcn/no-unknown-classes": ["error", { allow: ["toaster", "toast"] }]
-      })
-    ];
-  }
-  return policies;
-}
-
-// src/configs/boundaries.ts
-import { resolve as resolve2 } from "node:path";
-function presetBoundariesConfig(context) {
-  const { options, root, architecture, packages, web, tanstackWeb, nextWeb, backend, appFiles, publicEntrypoints, baseImports } = context;
-  const runtimeBoundary = {
-    web: web.map((path) => resolve2(root, path)),
-    backend: backend.map((path) => resolve2(root, path)),
-    aliases: Object.fromEntries(Object.entries(options.imports?.aliases ?? {}).map(([alias, path]) => [alias.replace(/\/$/, ""), resolve2(root, path)])),
-    backendPackages: Object.entries(architecture).flatMap(([directory, { role }]) => {
-      const name = role === "server" || role === "runner" ? presetPackageName(root, directory) : undefined;
-      return name ? [name] : [];
-    })
-  };
-  const policies = {};
-  policies.boundaries = [
-    presetOverride([...appFiles, ...presetScopes(packages, "**/" + presetExtensions)], {
-      "modules/import-boundaries": [
-        "error",
-        {
-          web: web.map((path) => resolve2(root, path)),
-          backend: backend.map((path) => resolve2(root, path)),
-          packages: packages.map((path) => resolve2(root, path)),
-          fileRoles: options.modules?.customFileRoles ?? [],
-          portableLib: true,
-          aliases: Object.fromEntries(Object.entries(options.imports?.aliases ?? {}).map(([alias, path]) => [
-            alias.replace(/\/$/, ""),
-            resolve2(root, path)
-          ])),
-          appPackages: Object.entries(architecture).flatMap(([directory, { role }]) => {
-            const name = role === "web" || role === "server" || role === "runner" ? presetPackageName(root, directory) : undefined;
-            return name ? [name] : [];
-          }),
-          backendPackages: Object.entries(architecture).flatMap(([directory, { role }]) => {
-            const name = role === "server" || role === "runner" ? presetPackageName(root, directory) : undefined;
-            return name ? [name] : [];
-          }),
-          publicEntrypoints
-        }
-      ]
-    }),
-    presetOverride([...presetScopes(tanstackWeb, "services/**/*.{ts,tsx}"), ...presetScopes(tanstackWeb, "lib/**/*.{ts,tsx}")], {
-      "modules/tanstack-runtime": [
-        "error",
-        {
-          ...runtimeBoundary,
-          rpcClients: ((options.orpc?.clientOwnerFile) ? [options.orpc?.clientOwnerFile] : context.rpcClients).map((path) => resolve2(root, path)),
-          serverImports: options.tanstackStart?.additionalServerOnlyImports ?? [],
-          clientImports: options.tanstackStart?.additionalClientOnlyImports ?? [],
-          allowComputedImportsIn: options.tanstackStart?.computedImportAllowedFiles?.map((path) => resolve2(root, path)) ?? []
-        }
-      ]
-    }),
-    presetOverride([...presetScopes(nextWeb, "services/**/*.{ts,tsx}"), ...presetScopes(nextWeb, "lib/**/*.{ts,tsx}")], {
-      "modules/next-runtime": [
-        "error",
-        {
-          ...runtimeBoundary,
-          serverImports: options.next?.additionalServerOnlyImports ?? [],
-          clientImports: options.next?.additionalClientOnlyImports ?? [],
-          allowComputedImportsIn: options.next?.computedImportAllowedFiles?.map((path) => resolve2(root, path)) ?? []
-        }
-      ]
-    }),
-    presetOverride(presetScopes(backend, "rpc/**/*.ts"), {
-      "modules/rpc-database": "error",
-      "no-restricted-imports": ["error", { paths: ["kysely"], patterns: baseImports }]
-    })
-  ];
-  return policies;
-}
-
-// src/configs/plugins.ts
-import { createRequire } from "node:module";
-var require2 = createRequire(import.meta.url);
-function presetPluginsConfig(context) {
-  const { options, reactFiles, css } = context;
-  const jsPlugins = [
-    { name: "eslint-js", specifier: require2.resolve("oxlint-plugin-eslint") },
-    {
-      name: "import-extra",
-      specifier: require2.resolve("eslint-plugin-import")
-    },
-    require2.resolve("@regru/eslint-plugin-prefer-early-return"),
-    require2.resolve("eslint-plugin-unused-imports"),
-    require2.resolve("eslint-plugin-perfectionist"),
-    require2.resolve("eslint-plugin-tsdoc"),
-    require2.resolve("@eslint-community/eslint-plugin-eslint-comments"),
-    {
-      name: "arch",
-      specifier: require2.resolve("oxlint-plugin-arch")
-    },
-    {
-      name: "dillon-anti-slop",
-      specifier: require2.resolve("oxlint-plugin-arch/rules/dillon-anti-slop")
-    },
-    {
-      name: "modules",
-      specifier: require2.resolve("oxlint-plugin-arch/rules/module-policy")
-    }
-  ];
-  const settings = {
-    react: { version: "19" },
-    "import/resolver": { node: { extensions: [".js", ".jsx", ".ts", ".tsx", ".mts", ".cts"] } }
-  };
-  if (reactFiles.length) {
-    jsPlugins.push({
-      name: "react-extra",
-      specifier: require2.resolve("eslint-plugin-react")
-    }, require2.resolve("eslint-plugin-react-you-might-not-need-an-effect"), require2.resolve("eslint-plugin-svg-jsx"));
-  }
-  if (Object.keys(css).length && options.tailwind !== false) {
-    jsPlugins.push(require2.resolve("oxlint-tailwindcss"));
-    settings.tailwindcss = { rootFontSize: options.tailwind?.rootFontSize ?? 16 };
-    if (options.shadcn !== false) {
-      jsPlugins.push(require2.resolve("@shadcn/lint"));
-      settings.shadcn = {
-        ui: options.shadcn?.ui ?? "@/components/ui",
-        componentImports: options.shadcn?.components ?? ["^@/components/"]
-      };
-    }
-  }
-  return { jsPlugins, settings };
-}
-
-// src/services/preset-context.ts
-import { existsSync as existsSync2, readdirSync } from "node:fs";
-import { resolve as resolve3, posix as posix2 } from "node:path";
-function presetResolveContext(options) {
-  const generated = presetGeneratedFiles;
-  const root = resolve3(options.root ?? process.cwd());
-  const configured = options.architecture ?? {
-    "apps/web": "web",
-    "apps/server": "server",
-    scripts: "scripts",
-    packages: "packages"
-  };
-  const entries = Object.entries(configured).map(([path, configuredRoot]) => {
-    const entry = typeof configuredRoot === "string" ? { role: configuredRoot } : configuredRoot;
-    if (!entry || typeof entry !== "object")
-      throw new Error("Architecture entries must be roles or role/layout objects.");
-    if (Object.keys(entry).some((key) => !["role", "layout", "framework", "sourceDir"].includes(key)))
-      throw new Error("Unknown architecture entry option.");
-    const role = entry.role;
-    if ("framework" in entry && entry.framework !== undefined && role !== "web")
-      throw new Error("Only web architecture roots accept a framework.");
-    const framework = role === "web" ? entry.framework ?? options.framework ?? "tanstack-start" : undefined;
-    if (framework !== undefined && framework !== "tanstack-start" && framework !== "next")
-      throw new Error(`Unknown framework: ${framework}`);
-    const sourced = role === "web" || role === "server" || role === "runner";
-    if ("sourceDir" in entry && entry.sourceDir !== undefined && !sourced)
-      throw new Error("Only web, server and runner architecture roots accept a sourceDir.");
-    const sourceDir = entry.sourceDir ?? "src";
-    if (typeof sourceDir !== "string" || sourceDir !== "." && sourceDir.split("/").some((segment) => !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(segment)))
-      throw new Error("Source folders must be `.` or literal root-relative paths without escapes, globs or empty segments.");
-    const portable = path.replaceAll("\\", "/");
-    if (!portable.trim() || posix2.isAbsolute(portable) || /^[a-z]:/i.test(portable))
-      throw new Error("Architecture roots must be nonempty project-relative paths.");
-    const normalized = posix2.normalize(portable).replace(/\/$/, "");
-    if (normalized === ".." || normalized.startsWith("../"))
-      throw new Error("Architecture roots must stay inside the project.");
-    if (!["web", "server", "runner", "scripts", "packages"].includes(role))
-      throw new Error(`Unknown architecture role: ${role}`);
-    if (entry.layout !== undefined && (!entry.layout || typeof entry.layout !== "object" || Array.isArray(entry.layout)))
-      throw new Error("Folder layout must be a path-to-mode object.");
-    const layout = {};
-    if (role !== "scripts") {
-      layout.services = "domain";
-    }
-    if (role === "web") {
-      layout.hooks = "flat";
-    }
-    for (const [folder, mode] of Object.entries(entry.layout ?? {})) {
-      if (folder.split("/").some((segment) => !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(segment)))
-        throw new Error("Layout folders must be literal source-relative paths without escapes, globs or empty segments.");
-      if (mode !== "flat" && mode !== "domain")
-        throw new Error("Folder layout mode must be flat or domain.");
-      layout[folder] = mode;
-    }
-    const folders2 = Object.keys(layout);
-    for (const [index, folder] of folders2.entries()) {
-      const overlaps = folders2.slice(0, index).some((other) => folder.startsWith(other + "/") || other.startsWith(folder + "/"));
-      if (overlaps) {
-        throw new Error("Layout folders must not overlap.");
-      }
-    }
-    return [
-      normalized,
-      {
-        role,
-        layout,
-        ...framework ? { framework } : {},
-        ...entry.sourceDir === undefined ? {} : { sourceDir }
-      }
-    ];
-  });
-  for (const [index, [path]] of entries.entries()) {
-    const overlaps = entries.slice(0, index).some(([other]) => other === path || other === "." || path === "." || other.startsWith(path + "/") || path.startsWith(other + "/"));
-    if (overlaps) {
-      throw new Error("Architecture roots must not overlap.");
-    }
-  }
-  const architecture = Object.fromEntries(entries);
-  if (options.modules?.customFileRoles?.some((role) => !/^[a-z][a-z0-9-]*$/.test(role)))
-    throw new Error("File roles must be lowercase kebab-case names.");
-  if (options.modules?.customFileRoles?.some((role) => [
-    "service",
-    "client",
-    "server",
-    "rsc",
-    "utils",
-    "action",
-    "query",
-    "types",
-    "constants",
-    "handler",
-    "test",
-    "spec"
-  ].includes(role)))
-    throw new Error("File roles must not replace built-in roles.");
-  if (options.framework !== undefined && options.framework !== "tanstack-start" && options.framework !== "next")
-    throw new Error(`Unknown framework: ${options.framework}`);
-  const source = (path, entry) => posix2.join(path, entry.sourceDir ?? "src");
-  const isPackage = (path) => existsSync2(resolve3(root, path, "package.json"));
-  const packageSource = (path) => posix2.join(path, isPackage(path) ? "src" : "*/src");
-  const web = entries.filter(([, { role }]) => role === "web").map(([path, entry]) => source(path, entry));
-  const webFor = (framework) => entries.filter(([, entry]) => entry.framework === framework).map(([path, entry]) => source(path, entry));
-  const tanstackWeb = webFor("tanstack-start");
-  const nextWeb = webFor("next");
-  const backendEntries = entries.filter(([, { role }]) => role === "server" || role === "runner");
-  const backendRoots = backendEntries.map(([path]) => path);
-  const backend = backendEntries.map(([path, entry]) => source(path, entry));
-  const packages = entries.filter(([, { role }]) => role === "packages").map(([path]) => path);
-  const packageSources = packages.map(packageSource);
-  const serviceRoots = [...backend, ...packageSources];
-  const scripts = entries.filter(([, { role }]) => role === "scripts").map(([path]) => path);
-  const folders = entries.flatMap(([path, entry]) => Object.entries(entry.layout).map(([folder, mode]) => ({
-    path: posix2.join(entry.role === "scripts" ? path : entry.role === "packages" ? packageSource(path) : source(path, entry), folder),
-    folder,
-    mode
-  })));
-  const rpcClients = entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => posix2.join(source(path, entry), "services", entry.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts"));
-  const app = [...web, ...backend, ...packageSources];
-  const appFiles = presetScopes(app);
-  const webFiles = presetScopes(web);
-  const reactFiles = [
-    ...webFiles,
-    ...presetScopes(packageSources, "**/*.tsx"),
-    ...presetScopes(packageSources, `components/**/${presetExtensions}`),
-    ...presetScopes(packageSources, `hooks/**/${presetExtensions}`)
-  ];
-  const backendFiles = presetScopes(backend);
-  const services = presetScopes(app, `services/**/${presetExtensions}`);
-  const utilities = ["**/*.utils.ts", "**/*.constants.ts", "**/*.types.ts"];
-  const types = presetScopes(app, "types/**");
-  const resolveUi = (value) => {
-    if (typeof value !== "string" || !value)
-      throw new Error("shadcn.ui must be a nonempty import path.");
-    const manifests = entries.flatMap(([path, entry]) => {
-      const children = entry.role === "packages" && existsSync2(resolve3(root, path)) && !isPackage(path) ? readdirSync(resolve3(root, path), { withFileTypes: true }).filter((child) => child.isDirectory() && isPackage(posix2.join(path, child.name))).map((child) => ({ directory: posix2.join(path, child.name), sources: posix2.join(path, child.name, "src") })) : [];
-      const sources = ["web", "server", "runner"].includes(entry.role) ? source(path, entry) : posix2.join(path, "src");
-      return [{ directory: path, sources }, ...children];
-    });
-    const named = manifests.filter(({ directory }) => presetPackageName(root, directory) === value);
-    if (named.length)
-      return named.map(({ sources }) => sources);
-    const aliased = [...new Set([".", ...manifests.map(({ directory }) => directory)].flatMap((directory) => presetTsconfigAliasTargets(root, directory, value)))];
-    if (aliased.length)
-      return aliased;
-    throw new Error(`shadcn.ui ${JSON.stringify(value)} matches no workspace package name or existing tsconfig paths alias target.`);
-  };
-  const shadcn = options.shadcn || {};
-  if ("uiImportPath" in shadcn)
-    throw new Error("shadcn.uiImportPath was renamed to shadcn.ui.");
-  if ("componentImportSources" in shadcn)
-    throw new Error("shadcn.componentImportSources was renamed to shadcn.components.");
-  const uiRoots = shadcn.ui === undefined ? web.map((path) => posix2.join(path, "components/ui")) : resolveUi(shadcn.ui);
-  const ui = presetScopes(uiRoots, "**");
-  const webUiRoots = uiRoots.filter((path) => web.some((webRoot) => webRoot === "." || path === webRoot || path.startsWith(webRoot + "/")));
-  const testFiles = ["**/{test,tests,e2e}/**/*.{ts,tsx,mts,cts}", "**/*.{test,spec}.{ts,tsx,mts,cts}"];
-  const safetyFiles = [...appFiles, ...testFiles];
-  const components = presetScopes([...web, ...packageSources], "components/**/*.tsx");
-  const hooks = presetScopes([...web, ...packageSources], "hooks/**/*.ts");
-  const level = options.severity ?? "error";
-  const publicEntrypoints = options.imports?.backendEntryPoints ?? backendRoots.flatMap((directory) => {
-    const name = presetPackageName(root, directory);
-    return name ? [`${name}/client`] : [];
-  });
-  const baseImports = [
-    {
-      group: ["zod/v4", "zod/v4/**"],
-      message: "Import from zod, not its transition entry point."
-    }
-  ];
-  const tailwind = options.tailwind;
-  const entryPoints = Object.fromEntries(Object.entries(tailwind === false ? {} : tailwind?.cssEntryPointsByRoot ?? {}).map(([path, entry]) => [
-    posix2.normalize(path.replaceAll("\\", "/")).replace(/\/$/, ""),
-    entry
-  ]));
-  const webCss = tailwind === false ? {} : Object.fromEntries(entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => {
-    const sourcePath = source(path, entry);
-    const fallback = entry.framework === "next" ? "app/globals.css" : "application/styles.css";
-    return [
-      sourcePath,
-      resolve3(root, entryPoints[path] ?? tailwind?.cssEntryPoint ?? posix2.join(sourcePath, fallback))
-    ];
-  }));
-  const webStylesheets = [...new Set(Object.values(webCss))];
-  const kitCss = Object.fromEntries((tailwind === false ? [] : uiRoots.filter((path) => !webUiRoots.includes(path))).map((path) => {
-    const owners = packages.flatMap((packageRoot) => {
-      if (path !== packageRoot && !path.startsWith(packageRoot + "/"))
-        return [];
-      const child = path.slice(packageRoot.length + 1).split("/")[0];
-      return isPackage(packageRoot) || !child ? [packageRoot] : [posix2.join(packageRoot, child), packageRoot];
-    });
-    const entry = owners.map((owner) => entryPoints[owner]).find(Boolean);
-    if (entry)
-      return [path, resolve3(root, entry)];
-    if (webStylesheets.length === 1)
-      return [path, webStylesheets[0]];
-    throw new Error(`The UI kit ${path} needs a Tailwind stylesheet: set tailwind.cssEntryPointsByRoot for ${owners[0] ?? path}.`);
-  }));
-  const css = { ...webCss, ...kitCss };
-  return {
-    options,
-    root,
-    architecture,
-    folders,
-    rpcClients,
-    packages,
-    scripts,
-    web,
-    tanstackWeb,
-    nextWeb,
-    backend,
-    backendRoots,
-    packageSources,
-    serviceRoots,
-    app,
-    appFiles,
-    webFiles,
-    reactFiles,
-    backendFiles,
-    services,
-    utilities,
-    types,
-    uiRoots,
-    webUiRoots,
-    ui,
-    generated,
-    testFiles,
-    safetyFiles,
-    components,
-    hooks,
-    level,
-    publicEntrypoints,
-    baseImports,
-    css
-  };
-}
-
-// src/services/preset-compose.ts
-function presetCompose(context, policies, plugins) {
-  const { options, level, app, safetyFiles, ui, generated } = context;
-  const severities = options.ruleSeverities ?? {};
-  const levels = (rules) => presetRuleSeverities(presetSeverity(rules, level), severities);
-  const maxLines = (max) => levels({ "max-lines": ["error", { max, skipBlankLines: true, skipComments: true }] });
-  const overrideList = [];
-  for (const name of presetPolicyOrder) {
-    const setting = options.policies?.[name];
-    if (setting === false || !policies[name]) {
-      continue;
-    }
-    const defaults = structuredClone(policies[name]);
-    const entries = typeof setting === "function" ? setting(defaults) : defaults;
-    for (const entry of entries) {
-      overrideList.push({
-        ...entry,
-        rules: entry.rules ? levels(entry.rules) : undefined
-      });
-    }
-  }
-  overrideList.push(presetOverride(safetyFiles, levels({
-    ...maxLines(options.limits?.maxFileLines ?? 400),
-    complexity: ["error", { max: options.limits?.maxFunctionComplexity ?? 32 }]
-  }), ui), presetOverride(presetScopes(app, "**/*.types.ts"), maxLines(options.limits?.maxTypeFileLines ?? 1000), ui));
-  const named = new Set([...Object.keys(presetCommonRules), ...overrideList.flatMap((entry) => Object.keys(entry.rules ?? {}))]);
-  const unnamedLevels = Object.fromEntries(Object.entries(severities).filter(([rule]) => !named.has(rule)));
-  for (const [rule, files] of Object.entries(options.ruleExclusions ?? {})) {
-    overrideList.push({ files, rules: { [rule]: "off" } });
-  }
-  return {
-    options: { typeAware: true },
-    categories: { correctness: level },
-    plugins: ["typescript", "react", "react-perf", "jsx-a11y", "import", "unicorn", "promise", "vitest", "node", "oxc"],
-    ignorePatterns: [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/coverage/**",
-      "**/.output/**",
-      ...context.nextWeb.length ? ["**/.next/**", "**/next-env.d.ts"] : [],
-      ...generated,
-      ...options.ignorePatterns ?? []
-    ],
-    ...plugins,
-    rules: { ...levels(presetCommonRules), ...unnamedLevels },
-    overrides: overrideList.filter((entry) => entry.files.length > 0)
-  };
-}
-
-// src/presets/react-modules-preset.ts
-function reactModulesPreset(options = {}) {
-  const context = presetResolveContext(options);
-  return presetCompose(context, {
-    ...presetSourceConfig(context),
-    ...presetTypesConfig(context),
-    ...presetModulesConfig(context),
-    ...presetTestsConfig(context),
-    ...presetReactConfig(context),
-    ...presetBoundariesConfig(context)
-  }, presetPluginsConfig(context));
-}
-export {
-  reactModulesPreset as default
-};