oxlint-plugin-arch 0.4.0 → 0.6.0

package/dist/presets/index.js

@@ -0,0 +1,1380 @@
+// src/utils/helpers/preset.ts
+import { readFileSync } from "node:fs";
+import { 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 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}`);
+}
+function presetOverride(files, rules, excludeFiles = []) {
+  return {
+    files,
+    excludeFiles: [...presetGeneratedFiles, ...excludeFiles],
+    rules
+  };
+}
+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;
+}
+
+// src/configs/source.ts
+function presetSourceConfig(context) {
+  const { options, web, scripts, app, appFiles, backendFiles, ui, safetyFiles, publicEntrypoints, baseImports } = context;
+  const policies = {};
+  policies.formatting = [presetOverride([`**/${presetExtensions}`], presetFormattingRules)];
+  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,
+    app,
+    appFiles,
+    webFiles,
+    services,
+    utilities,
+    types,
+    ui,
+    testFiles,
+    safetyFiles,
+    components,
+    hooks,
+    publicEntrypoints
+  } = context;
+  const policies = {};
+  policies.typePlacement = [
+    presetOverride(appFiles, { "arch/no-type-declarations": "error" }, [
+      ...types,
+      ...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, ...ui]),
+    presetOverride(presetScopes(app, "**/*.{utils,constants}.ts"), {
+      "arch/no-type-declarations": "error"
+    }, [...ui, ...testFiles]),
+    presetOverride([...presetScopes(backend, "types/**/*.types.ts"), ...presetScopes(app, "**/*.constants.ts")], {
+      "arch/no-top-level-functions": ["error", { banReExports: false }]
+    }),
+    presetOverride(presetScopes(web, "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(backend, "types/**"), ...ui]),
+    presetOverride(webFiles, {
+      "arch/no-rederive-schema": [
+        "error",
+        {
+          from: publicEntrypoints,
+          namespaces: ["z"],
+          operators: ["infer", "input"]
+        }
+      ]
+    }),
+    presetOverride(presetScopes(backend, "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
+function presetModulesConfig(context) {
+  const { web, backend, 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 === 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", ...conceptFiles])
+  ];
+  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(backend, "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(backend, "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(backend, "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(backend, "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]+)*[.]ts$",
+          message: "Hooks use use-domain.ts filenames."
+        }
+      ],
+      "arch/export-file-prefix": "error",
+      "arch/export-name-pattern": ["error", { pattern: "^use[A-Z]", ignoreTypeExports: true }]
+    }),
+    presetOverride(components, {
+      "arch/only-export-components": ["error", { matchFileName: true, allowTypeExports: true }]
+    }, [...ui, ...testFiles]),
+    presetOverride(presetScopes(web.filter((path) => !context.folders.some((scope) => scope.path === 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/configs/tests.ts
+function presetTestsConfig(context) {
+  const { backend, 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 policies = {};
+  policies.tests = [
+    presetOverride(testFiles, {
+      ...presetTestRules,
+      "dillon-anti-slop/no-module-mocking": "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(backend.map((path) => path.replace(/\/src$/, "")), "tests/**/*.ts"), {
+      "modules/concurrent-db": "error",
+      ...profile === "fixtures" ? {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...baseImports,
+              {
+                group: ["**/helpers/**"],
+                message: "Use named fixtures or tests/support."
+              }
+            ]
+          }
+        ]
+      } : {}
+    })
+  ];
+  return policies;
+}
+
+// src/configs/react.ts
+function presetReactConfig(context) {
+  const { options, web, webFiles, ui, testFiles, components, css } = context;
+  const policies = {};
+  if (web.length) {
+    policies.react = [
+      presetOverride(webFiles, {
+        ...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 (web.length) {
+    policies.effects = [presetOverride(webFiles, { ...presetEffectsRules, "modules/empty-effect": "error" }, ui)];
+  }
+  if (web.length) {
+    policies.routes = [
+      presetOverride(presetScopes(web, "routes/**/*.{ts,tsx}"), {
+        "arch/route-surface": [
+          "error",
+          {
+            exportName: "Route",
+            bannedHooks: ["useState", "useEffect", "useMutation"],
+            banIntrinsicJsx: true
+          }
+        ]
+      }, testFiles),
+      presetOverride(presetScopes(web, "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."
+          }
+        ]
+      })
+    ];
+  }
+  if (web.length) {
+    policies.forms = [
+      presetOverride(webFiles, {
+        "arch/require-paired-call": [
+          "error",
+          {
+            when: "useForm",
+            require: options.forms?.schemaResolver ?? "standardSchemaResolver"
+          }
+        ]
+      }, ui)
+    ];
+  }
+  if (web.length && options.react?.compiler !== false) {
+    policies.memoization = [presetOverride(webFiles, { "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/"), ...presetScopes(web, "components/ui/")]
+              }
+            ]
+          }
+        ]
+      })
+    ];
+  }
+  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) {
+    policies.shadcn = [
+      presetOverride(webFiles, {
+        "shadcn/no-restyle": ["error", { allow: ["layout", "opacity"] }],
+        "shadcn/no-arbitrary-values": ["error", { allow: ["layout"] }],
+        "shadcn/require-static-classes": "error",
+        "modules/dynamic-classes": "error"
+      }, ui),
+      presetOverride(webFiles, {
+        "shadcn/no-unknown-classes": ["error", { allow: [] }]
+      })
+    ];
+  }
+  return policies;
+}
+
+// src/configs/boundaries.ts
+import { resolve as resolve2 } from "node:path";
+function presetBoundariesConfig(context) {
+  const { options, root, architecture, packages, web, backend, appFiles, publicEntrypoints, baseImports } = context;
+  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(web, "services/**/*.{ts,tsx}"), ...presetScopes(web, "lib/**/*.{ts,tsx}")], {
+      "modules/tanstack-runtime": [
+        "error",
+        {
+          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] : [];
+          }),
+          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(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";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+function presetPluginsConfig(context) {
+  const { options, web, 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: fileURLToPath(new URL("../index.js", import.meta.url))
+    },
+    {
+      name: "dillon-anti-slop",
+      specifier: fileURLToPath(new URL("../rules/dillon-anti-slop/index.js", import.meta.url))
+    },
+    {
+      name: "modules",
+      specifier: fileURLToPath(new URL("../rules/module-policy/index.js", import.meta.url))
+    }
+  ];
+  const settings = {
+    react: { version: "19" },
+    "import/resolver": { node: { extensions: [".js", ".jsx", ".ts", ".tsx", ".mts", ".cts"] } }
+  };
+  if (web.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?.uiImportPath ?? "@/components/ui",
+        componentImports: options.shadcn?.componentImportSources ?? ["^@/components/"]
+      };
+    }
+  }
+  return { jsPlugins, settings };
+}
+
+// src/services/preset-context.ts
+import { resolve as resolve3, posix } 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"].includes(key)))
+      throw new Error("Unknown architecture entry option.");
+    const role = entry.role;
+    const portable = path.replaceAll("\\", "/");
+    if (!portable.trim() || posix.isAbsolute(portable) || /^[a-z]:/i.test(portable))
+      throw new Error("Architecture roots must be nonempty project-relative paths.");
+    const normalized = posix.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 === "web" || role === "server" || role === "runner") {
+      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 folders = Object.keys(layout);
+    for (const [index, folder] of folders.entries()) {
+      const overlaps = folders.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 }];
+  });
+  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.");
+  const web = entries.filter(([, { role }]) => role === "web").map(([path]) => posix.join(path, "src"));
+  const backendRoots = entries.filter(([, { role }]) => role === "server" || role === "runner").map(([path]) => path);
+  const backend = backendRoots.map((path) => posix.join(path, "src"));
+  const packages = entries.filter(([, { role }]) => role === "packages").map(([path]) => path);
+  const scripts = entries.filter(([, { role }]) => role === "scripts").map(([path]) => path);
+  const folders = entries.flatMap(([path, entry]) => Object.entries(entry.layout).map(([folder, mode]) => ({
+    path: posix.join(path, ["web", "server", "runner"].includes(entry.role) ? "src" : "", folder),
+    folder,
+    mode
+  })));
+  const rpcClients = entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => posix.join(path, "src/services", entry.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts"));
+  const app = [...web, ...backend];
+  const appFiles = presetScopes(app);
+  const webFiles = presetScopes(web);
+  const backendFiles = presetScopes(backend);
+  const services = presetScopes(app, `services/**/${presetExtensions}`);
+  const utilities = ["**/*.utils.ts", "**/*.constants.ts", "**/*.types.ts"];
+  const types = presetScopes(app, "types/**");
+  const ui = presetScopes(web, "components/ui/**");
+  const testFiles = ["**/{test,tests,e2e}/**/*.{ts,tsx,mts,cts}", "**/*.{test,spec}.{ts,tsx,mts,cts}"];
+  const safetyFiles = [...appFiles, ...testFiles];
+  const components = presetScopes(web, "components/**/*.tsx");
+  const hooks = presetScopes(web, "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]) => [
+    posix.normalize(path.replaceAll("\\", "/")).replace(/\/$/, ""),
+    entry
+  ]));
+  const css = tailwind === false ? {} : Object.fromEntries(web.map((path) => [
+    path,
+    resolve3(root, entryPoints[posix.dirname(path)] ?? tailwind?.cssEntryPoint ?? `${path}/application/styles.css`)
+  ]));
+  return {
+    options,
+    root,
+    architecture,
+    folders,
+    rpcClients,
+    packages,
+    scripts,
+    web,
+    backend,
+    app,
+    appFiles,
+    webFiles,
+    backendFiles,
+    services,
+    utilities,
+    types,
+    ui,
+    generated,
+    testFiles,
+    safetyFiles,
+    components,
+    hooks,
+    level,
+    publicEntrypoints,
+    baseImports,
+    css
+  };
+}
+
+// src/services/preset-compose.ts
+function presetCompose(context, policies, plugins) {
+  const { options, level, safetyFiles, ui, generated } = context;
+  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 ? presetSeverity(entry.rules, level) : undefined
+      });
+    }
+  }
+  overrideList.push(presetOverride(safetyFiles, {
+    "max-lines": [level, { max: options.limits?.maxFileLines ?? 400, skipBlankLines: true, skipComments: true }],
+    complexity: [level, { max: options.limits?.maxFunctionComplexity ?? 32 }]
+  }, ui));
+  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/**",
+      ...generated,
+      ...options.ignorePatterns ?? []
+    ],
+    ...plugins,
+    rules: presetSeverity(presetCommonRules, level),
+    overrides: overrideList.filter((entry) => entry.files.length > 0)
+  };
+}
+
+// src/presets/tanstack-start-react-modules-preset.ts
+function tanstackStartReactModulesPreset(options = {}) {
+  const context = presetResolveContext(options);
+  return presetCompose(context, {
+    ...presetSourceConfig(context),
+    ...presetTypesConfig(context),
+    ...presetModulesConfig(context),
+    ...presetTestsConfig(context),
+    ...presetReactConfig(context),
+    ...presetBoundariesConfig(context)
+  }, presetPluginsConfig(context));
+}
+export {
+  tanstackStartReactModulesPreset
+};