oxlint-plugin-arch 0.11.0 → 0.12.1

package/dist/preset/preset.js

@@ -0,0 +1,2299 @@
+// src/preset/preset.ts
+import { createRequire } from "node:module";
+
+// src/preset/groups/backend.ts
+import { posix as posix2, resolve as resolve3 } from "node:path";
+
+// src/preset/preset-detect.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { matchesGlob, posix, resolve as resolve2 } from "node:path";
+
+// src/preset/preset-recipes.ts
+var presetUi = { react: true, kit: true, tailwind: true };
+var presetRecipes = {
+  tanstack: { react: true, tanstack: true, tailwind: true, shadcn: true, schemas: true, forms: true },
+  next: { react: true, next: true, tailwind: true, shadcn: true, schemas: true, forms: true },
+  expo: { react: true, expo: true, schemas: true, forms: true },
+  backend: { backend: true, schemas: true, sql: true, layout: { strict: true } },
+  react: { react: true, tailwind: true, schemas: true },
+  desktop: { console: true },
+  library: { schemas: true },
+  ui: presetUi,
+  kit: presetUi,
+  cli: { console: true }
+};
+var presetTemplates = {
+  monorepo: {
+    "apps/web": presetRecipes.tanstack,
+    "apps/server": presetRecipes.backend,
+    "packages/*": presetRecipes.library,
+    scripts: presetRecipes.cli
+  }
+};
+
+// src/preset/preset.constants.ts
+var presetExtensions = "*.{ts,tsx,mts,cts}";
+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",
+  roles: ["constants", "utils", "handler", "service", "types"],
+  separators: [".", "-"],
+  normalize: "remove-separators",
+  allow: "^(make[A-Z]|\\*$)"
+};
+var presetGeneratedFiles = [
+  "**/*.generated.*",
+  "**/*.gen.*",
+  "**/*.d.ts",
+  "**/routes.tree.ts",
+  "**/routeTree.gen.ts",
+  "**/paraglide/**"
+];
+var presetBuiltinFileRoles = [
+  "service",
+  "client",
+  "server",
+  "rsc",
+  "utils",
+  "action",
+  "query",
+  "types",
+  "constants",
+  "handler",
+  "test",
+  "spec"
+];
+var presetShorthandOptions = [["tests", "mocking", "preset"], ["backend", "registry", "file"]];
+var presetOutputFolders = ["dist", "build", "coverage", ".output"];
+var presetLiteralSegment = /^(?!\.{1,2}$)[a-zA-Z0-9._][a-zA-Z0-9._-]*$/;
+var presetIllustrationPalette = [
+  "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"
+];
+var presetGroupOrder = [
+  "style",
+  "imports",
+  "types",
+  "layout",
+  "naming",
+  "comments",
+  "basics",
+  "console",
+  "tests",
+  "schemas",
+  "sql",
+  "orpc",
+  "react",
+  "forms",
+  "tanstack",
+  "next",
+  "expo",
+  "backend",
+  "tailwind",
+  "shadcn",
+  "kit",
+  "limits",
+  "deny",
+  "externals"
+];
+var presetDefaultGroups = [
+  "layout",
+  "limits",
+  "style",
+  "basics",
+  "naming",
+  "comments",
+  "types",
+  "imports",
+  "tests",
+  "deny",
+  "externals"
+];
+var presetExternals = [
+  "@napi-rs/*",
+  "@node-rs/*",
+  "@takumi-rs/*",
+  "sharp",
+  "pg",
+  "ioredis",
+  "bullmq",
+  "tiny-secp256k1",
+  "ssh2",
+  "playwright",
+  "playwright-core"
+];
+var presetGroupOptions = {
+  layout: { level: "error", services: undefined, hooks: undefined, components: undefined, suffixes: [], strict: false, operations: "flat", service: ["make{Domain}Service", "{Domain}Service"] },
+  limits: { level: "error", lines: 400, types: 1000, complexity: 32 },
+  style: { level: "error", quotes: "single", semicolons: true, multiline: true, padding: true, dashes: true },
+  basics: { level: "error", trivial: true, state: true, switch: true, negation: true },
+  naming: { level: "error", files: true, exports: true, folders: true, unique: undefined },
+  comments: { level: "error", directives: true },
+  types: { level: "error", placement: true, safety: true, colocated: [] },
+  imports: { level: "error", sort: true, boundaries: true, aliases: {}, internal: undefined },
+  tests: { level: "error", assertions: [], functions: [], mocking: "modules", titles: true, fixtures: true },
+  react: { level: "error", a11y: true, effects: true, memo: undefined, props: true, perf: undefined, compiler: true },
+  tanstack: { level: "error", server: [], client: [], dynamic: [] },
+  next: { level: "error", server: [], client: [], dynamic: [] },
+  expo: { level: "error", server: [] },
+  tailwind: { level: "error", css: undefined, rem: 16 },
+  shadcn: { level: "error", ui: "@/components/ui", components: ["^@/components/"] },
+  kit: { level: "error" },
+  backend: { level: "error", exports: undefined, registry: undefined, writes: ["insertInto", "updateTable", "deleteFrom", "mergeInto", "replaceInto", "dispatch", "send"] },
+  orpc: { level: "error", public: [], composers: [], client: undefined },
+  schemas: { level: "error" },
+  forms: { level: "error", resolver: "standardSchemaResolver" },
+  sql: { level: "error", sanitizers: ["escapeLikeWildcards"] },
+  console: { level: "error" },
+  deny: { level: "error", imports: {}, calls: {} },
+  externals: { level: "error", packages: presetExternals }
+};
+var presetFolderKeys = ["severity", "source", "rules"];
+var presetA11yRules = [
+  "alt-text",
+  "anchor-has-content",
+  "anchor-is-valid",
+  "aria-activedescendant-has-tabindex",
+  "aria-props",
+  "aria-proptypes",
+  "aria-role",
+  "aria-unsupported-elements",
+  "autocomplete-valid",
+  "click-events-have-key-events",
+  "control-has-associated-label",
+  "heading-has-content",
+  "html-has-lang",
+  "iframe-has-title",
+  "img-redundant-alt",
+  "interactive-supports-focus",
+  "label-has-associated-control",
+  "lang",
+  "media-has-caption",
+  "mouse-events-have-key-events",
+  "no-access-key",
+  "no-aria-hidden-on-focusable",
+  "no-autofocus",
+  "no-distracting-elements",
+  "no-interactive-element-to-noninteractive-role",
+  "no-noninteractive-element-interactions",
+  "no-noninteractive-element-to-interactive-role",
+  "no-noninteractive-tabindex",
+  "no-redundant-roles",
+  "no-static-element-interactions",
+  "prefer-tag-over-role",
+  "role-has-required-aria-props",
+  "role-supports-aria-props",
+  "scope",
+  "tabindex-no-positive"
+].map((rule) => `jsx-a11y/${rule}`);
+var presetExpoRouteExports = ["ErrorBoundary", "unstable_settings", "generateStaticParams"];
+var presetTestFiles = ["**/{test,tests,e2e}/**/*.{ts,tsx,mts,cts}", "**/*.{test,spec}.{ts,tsx,mts,cts}"];
+var presetBaseImports = [{ group: ["zod/v4", "zod/v4/**"], message: "Import from zod, not its transition entry point." }];
+var presetDetectFrameworks = [
+  ["next", ["next", "vinext"]],
+  ["tanstack", ["@tanstack/react-start"]],
+  ["expo", ["expo"]]
+];
+var presetDetectDesktop = ["electrobun", "electron", "@tauri-apps/api", "@tauri-apps/cli"];
+var presetDetectBackend = ["@orpc/server", "hono", "kysely", "drizzle-orm", "express", "fastify", "elysia"];
+var presetDetectSkip = ["node_modules", "dist", "build", "coverage", "public", ".output", ".next", ".vinext", ".turbo", ".wrangler", "target"];
+var presetStylesheetNames = ["styles", "globals", "global", "app", "index", "main", "style", "tailwind"];
+var presetRegistryFiles = ["services/service.ts", "core/core.services.ts", "service.ts"];
+var presetRegistrySkip = ["brand", "database", "db", "math", "security", "tools"];
+var presetServerEntries = ["rpc", "server", "security", "services"];
+var presetOperationImports = ["*/*-action.*", "*/*-query.*", "*/actions/*", "*/queries/*"];
+var presetKitImports = ["**/kits", "**/kits/index", "**/kits/index.ts"];
+var presetKitFiles = "^(?:kit|[a-z0-9]+(?:-[a-z0-9]+)*\\.kit)\\.ts$";
+var presetCliFiles = "^cli(?:-[a-z0-9]+)*(?:\\.[a-z0-9-]+)*\\.tsx?$";
+var presetMigrationFiles = "^(?:\\d{3,14}[-_][a-z0-9]+(?:[-_][a-z0-9]+)*|index)\\.ts$";
+var presetMigrationNumber = "^(\\d{3,14})[-_]";
+var presetRootImports = { "framer-motion": "Use motion/react." };
+var presetPackageImports = { "../../apps/**": "Packages stay app-agnostic; do not import app internals." };
+
+// src/preset/preset.utils.ts
+import { readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+class PresetError extends Error {
+}
+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 presetSeverity(rules, level) {
+  return Object.fromEntries(Object.entries(rules).map(([name, value]) => {
+    const current = Array.isArray(value) ? value[0] : value;
+    if (current === "off" || current === "allow" || current === 0) {
+      return [name, value];
+    }
+    return [name, Array.isArray(value) ? [level, ...value.slice(1)] : level];
+  }));
+}
+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 presetSegment(pattern, segment) {
+  if (pattern === segment || pattern === "*" || segment === "*") {
+    return true;
+  }
+  const source = pattern.replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", ".").replaceAll("*", "[^/]*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
+  return new RegExp(`^${source}$`).test(segment);
+}
+function presetIntersectSegments(glob, scope) {
+  if (scope.length === 0) {
+    return glob.length > 0 ? [glob] : [];
+  }
+  if (glob.length === 0) {
+    return [];
+  }
+  const [head, ...rest] = glob;
+  if (head === "**") {
+    const deeper = scope.map((_, index) => presetIntersectSegments(rest, scope.slice(index)).map((tail) => [...scope.slice(0, index), ...tail]));
+    return [[...scope, ...glob], ...deeper.flat()];
+  }
+  if (!presetSegment(head, scope[0])) {
+    return [];
+  }
+  const segment = scope[0] === "*" ? head : scope[0];
+  return presetIntersectSegments(rest, scope.slice(1)).map((tail) => [segment, ...tail]);
+}
+function presetIntersect(glob, scope) {
+  if (scope === ".") {
+    return [glob];
+  }
+  const matches = presetIntersectSegments(glob.split("/"), scope.split("/")).map((segments) => segments.join("/"));
+  return [...new Set(matches)];
+}
+function presetAliases(root, aliases) {
+  return Object.fromEntries(Object.entries(aliases ?? {}).map(([alias, path]) => [alias.replace(/\/$/, ""), resolve(root, path)]));
+}
+function presetRuntime(project, settings, framework, rule) {
+  return project.units.flatMap((unit) => {
+    if (unit.framework !== framework) {
+      return [];
+    }
+    const options = {
+      web: project.web.map((path) => resolve(project.root, path)),
+      backend: project.backend.map((path) => resolve(project.root, path)),
+      aliases: presetAliases(project.root, unit.scope.effective.imports?.aliases),
+      backendPackages: project.units.flatMap((item) => item.kind === "backend" ? presetPackageName(project.root, item.key) ?? [] : []),
+      server: settings.server,
+      client: settings.client,
+      dynamic: settings.dynamic.map((path) => resolve(project.root, path))
+    };
+    if (rule === "arch/boundaries-tanstack") {
+      options.rpc = project.rpcClients.map((path) => resolve(project.root, path));
+    }
+    return [
+      presetOverride([...presetScopes([unit.source], "services/**/*.{ts,tsx}"), ...presetScopes([unit.source], "lib/**/*.{ts,tsx}")], {
+        [rule]: ["error", options]
+      })
+    ];
+  });
+}
+function presetManifest(root, directory) {
+  try {
+    return JSON.parse(readFileSync(resolve(root, directory, "package.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function presetIsDirectory(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  } catch {
+    return false;
+  }
+}
+function presetIsFile(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+// src/preset/preset-detect.ts
+function presetDirectories(root, base, skip = presetDetectSkip) {
+  if (!presetIsDirectory(resolve2(root, base))) {
+    return [];
+  }
+  return readdirSync(resolve2(root, base)).filter((name) => !name.startsWith(".") && !skip.includes(name) && presetIsDirectory(resolve2(root, base, name))).map((name) => posix.join(base, name));
+}
+var presetNamedSkip = ["node_modules"];
+function presetSource(root, directory, configured) {
+  if (configured !== undefined) {
+    return posix.join(directory, configured);
+  }
+  return existsSync(resolve2(root, directory, "src")) ? posix.join(directory, "src") : directory;
+}
+function presetRegistryFile(root, source, configured) {
+  if (configured === false) {
+    return;
+  }
+  const file = typeof configured === "string" ? configured : configured?.file;
+  if (file !== undefined) {
+    return posix.normalize(file);
+  }
+  return presetRegistryFiles.map((path) => posix.join(source, path)).find((path) => existsSync(resolve2(root, path)));
+}
+function presetDomains(root, source) {
+  return presetDirectories(root, posix.join(source, "services"), presetNamedSkip).map((path) => posix.basename(path)).filter((name) => existsSync(resolve2(root, source, "services", name, `${name}.service.ts`)));
+}
+function presetRecipe(root, directory, app, configured) {
+  const manifest = presetManifest(root, directory);
+  const dependencies = new Set([manifest.dependencies, manifest.devDependencies, manifest.peerDependencies].flatMap((listed) => Object.keys(listed ?? {})));
+  const has = (names) => names.some((name) => dependencies.has(name));
+  const source = presetSource(root, directory, configured);
+  const framework = presetDetectFrameworks.find(([, names]) => has(names))?.[0];
+  const services = resolve2(root, source, "services");
+  const entries = presetIsDirectory(services) ? readdirSync(services, { withFileTypes: true }) : [];
+  const folders = entries.filter((entry) => presetIsDirectory(resolve2(services, entry.name))).length;
+  const flat = entries.filter((entry) => entry.isFile() && /\.tsx?$/.test(entry.name)).length > folders;
+  if (framework) {
+    return flat ? { ...presetRecipes[framework], layout: { services: "flat" } } : presetRecipes[framework];
+  }
+  if (has(presetDetectDesktop)) {
+    return presetRecipes.desktop;
+  }
+  if (presetDomains(root, source).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services))) {
+    return presetRecipes.backend;
+  }
+  if (has(["react"]) && presetIsDirectory(resolve2(root, source, "components"))) {
+    return app ? presetRecipes.react : presetRecipes.ui;
+  }
+  return presetRecipes.library;
+}
+function presetMergeObject(base, top, depth) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(top)) {
+    const previous = Reflect.get(merged, key);
+    const nested = previous instanceof Object && value instanceof Object && !Array.isArray(previous) && !Array.isArray(value);
+    if (nested && depth > 0) {
+      Reflect.set(merged, key, presetMergeObject(previous, value, depth - 1));
+    } else if (value !== true || !(previous instanceof Object)) {
+      Reflect.set(merged, key, value);
+    }
+  }
+  return merged;
+}
+function presetMerge(base, top) {
+  if (!(base instanceof Object) || !(top instanceof Object)) {
+    return top === true && base instanceof Object ? base : top;
+  }
+  return presetMergeObject(base, top, 2);
+}
+function presetImportTargets(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(presetImportTargets);
+  }
+  return value instanceof Object ? Object.values(value).flatMap(presetImportTargets) : [];
+}
+function presetSpecifiers(manifest, target, file = false) {
+  const specifiers = Object.entries(manifest.imports ?? {}).flatMap(([key, value]) => presetImportTargets(value).flatMap((mapped) => {
+    const path = posix.normalize(mapped);
+    const parts = path.split("*");
+    const keyParts = key.split("*");
+    if (parts.length === 1 && keyParts.length === 1) {
+      return path.replace(/\.[cm]?[jt]sx?$/, "") === target ? [key] : [];
+    }
+    if (parts.length !== 2 || keyParts.length !== 2) {
+      return [];
+    }
+    const [before, after] = parts;
+    const [head, suffix] = keyParts;
+    const prefix = before.replace(/\/$/, "");
+    if (target !== prefix && !target.startsWith(`${prefix}/`)) {
+      return [];
+    }
+    const rest = target.slice(prefix.length).replace(/^\//, "");
+    const tail = after && rest.endsWith(after) ? rest.slice(0, -after.length) : rest;
+    return [`${head}${tail}${file ? suffix : ""}`.replace(/\/$/, "")];
+  }));
+  return [...new Set(specifiers)];
+}
+function presetOverlaps(left, right) {
+  const [leftBase] = left.split("*");
+  const [rightBase] = right.split("*");
+  return leftBase.startsWith(rightBase) || rightBase.startsWith(leftBase);
+}
+function presetDeny(imports) {
+  return { deny: { imports } };
+}
+function presetFilled(conventions, exists) {
+  return Object.fromEntries(Object.entries(conventions).filter(([path, folder]) => {
+    const empty = folder instanceof Object && folder.deny instanceof Object && Object.keys(folder.deny.imports ?? {}).length === 0;
+    return exists(path) && !empty;
+  }));
+}
+function presetBackendConventions(root, key, value, denied) {
+  const manifest = presetManifest(root, key);
+  const source = presetSource(root, key, value.source);
+  const local = posix.relative(key, source) || ".";
+  const at = (path) => local === "." ? path : posix.join(local, path);
+  const exists = (path) => existsSync(resolve2(root, key, path));
+  const configured = value.backend instanceof Object ? value.backend.registry : undefined;
+  const registryFile = presetRegistryFile(root, source, configured);
+  const registry = registryFile === undefined ? undefined : posix.relative(key, registryFile);
+  const services = presetSpecifiers(manifest, at("services"));
+  const message = "Use the service API, not another service’s operations.";
+  const operations = Object.fromEntries(services.flatMap((prefix) => presetOperationImports.map((pattern) => [`${prefix}/${pattern}`, message])));
+  const registryImports = registry ? Object.fromEntries(presetSpecifiers(manifest, registry.replace(/\.[cm]?[jt]sx?$/, ""), true).map((specifier) => [specifier, "Only the composition root imports the service registry."])) : {};
+  const entries = Object.fromEntries(presetServerEntries.map((entry) => [`${manifest.name}/${entry}`, "Server code imports its own modules, not the package entries."]));
+  const serviceImports = { ...registryImports, ...operations };
+  if (manifest.name) {
+    Object.assign(serviceImports, entries);
+  }
+  const conventions = {
+    [at("services")]: presetDeny(serviceImports),
+    [at("core")]: presetDeny(operations),
+    [at("rpc")]: presetDeny(registryImports),
+    [at("routes")]: presetDeny(registryImports),
+    [at("cli")]: {
+      naming: { files: presetCliFiles },
+      ...presetDeny({ ...operations, ...Object.fromEntries(services.map((prefix) => [`${prefix}/*/*.service`, "Reach services through the registry."])) })
+    }
+  };
+  for (const domain of presetDirectories(root, posix.join(source, "services"), presetNamedSkip).map((path) => posix.basename(path))) {
+    const imports = services.flatMap((prefix) => presetOperationImports.filter((pattern) => !denied.has(`${prefix}/${pattern}`)).flatMap((pattern) => [
+      [`${prefix}/${pattern}`, false],
+      [`${prefix}/${pattern.replace(/^\*/, `!(${domain})`)}`, message]
+    ]));
+    conventions[at(`services/${domain}`)] = presetDeny(Object.fromEntries(imports));
+  }
+  for (const tests of ["tests", "test"]) {
+    if (exists(posix.join(tests, "kits"))) {
+      conventions[tests] = presetDeny(Object.fromEntries(presetKitImports.map((pattern) => [pattern, "Import the kit file you need."])));
+      conventions[posix.join(tests, "kits")] = { naming: { files: presetKitFiles } };
+    }
+  }
+  const queue = ["."];
+  while (queue.length > 0) {
+    const folder = queue.shift() ?? ".";
+    for (const child of presetDirectories(root, posix.join(key, folder)).map((path) => posix.relative(key, path))) {
+      if (posix.basename(child) === "migrations") {
+        conventions[child] = { layout: false, naming: { files: presetMigrationFiles, unique: presetMigrationNumber } };
+      } else if (child.split("/").length < 8) {
+        queue.push(child);
+      }
+    }
+  }
+  return presetFilled(conventions, exists);
+}
+function presetWebConventions(root, key, value, servers) {
+  const source = posix.relative(key, presetSource(root, key, value.source)) || ".";
+  const at = (path) => source === "." ? path : posix.join(source, path);
+  const exists = (path) => existsSync(resolve2(root, key, path));
+  const own = Object.keys(presetManifest(root, key).imports ?? {});
+  const internals = servers.flatMap((manifest) => Object.keys(manifest.imports ?? {}).filter((specifier) => !own.some((mine) => presetOverlaps(mine, specifier))).map((specifier) => specifier.replace(/\*$/, "**")));
+  const named = servers.flatMap((manifest) => manifest.name ? [manifest.name] : []);
+  const entries = Object.fromEntries(named.flatMap((name) => presetServerEntries.map((entry) => [`${name}/${entry}`, "UI code imports the client entry."])));
+  const clients = Object.fromEntries(named.map((name) => [`${name}/client`, "Route handlers run on the server; import the server entry."]));
+  const appImports = Object.fromEntries(internals.map((specifier) => [specifier, "Import the backend through its client entry."]));
+  if (servers.length > 0) {
+    appImports["**/services/*.service"] = "Import the client or rsc service file, not a server service.";
+  }
+  const conventions = {
+    ".": presetDeny(appImports),
+    [at("components")]: presetDeny(entries),
+    [at("routes")]: presetDeny(entries),
+    [at("routes/handlers")]: { deny: { imports: { ...clients, ...Object.fromEntries(Object.keys(entries).map((entry) => [entry, false])) } } }
+  };
+  return presetFilled(conventions, exists);
+}
+function presetWorkspacePatterns(root, manifest) {
+  const listed = Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? [];
+  const file = resolve2(root, "pnpm-workspace.yaml");
+  if (!existsSync(file)) {
+    return listed;
+  }
+  const patterns = [...listed];
+  let inside = false;
+  for (const line of readFileSync2(file, "utf8").split(`
+`)) {
+    const flow = /^packages\s*:\s*\[(.*)\]/.exec(line);
+    const item = /^\s*-\s*(["']?)([^"'#\s]+)\1\s*(?:#.*)?$/.exec(line);
+    if (flow) {
+      patterns.push(...flow[1].split(",").map((entry) => entry.trim().replaceAll(/^["']|["']$/g, "")).filter(Boolean));
+      inside = false;
+    } else if (/^packages\s*:/.test(line)) {
+      inside = true;
+    } else if (inside && item) {
+      patterns.push(item[2]);
+    } else if (/^\S/.test(line)) {
+      inside = false;
+    }
+  }
+  return patterns;
+}
+function presetWorkspaces(root, patterns) {
+  const clean = (pattern) => posix.normalize(pattern.replace(/^\.\//, "")).replace(/\/$/, "");
+  const include = patterns.filter((pattern) => !pattern.startsWith("!")).map(clean);
+  const exclude = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => clean(pattern.slice(1)));
+  const matches = (path, globs) => globs.some((glob) => path === glob || matchesGlob(path, glob));
+  const candidates = new Set;
+  for (const pattern of include) {
+    const segments = pattern.split("/");
+    const literal = segments.findIndex((segment) => /[*?{[]/.test(segment));
+    if (literal === -1) {
+      candidates.add(pattern);
+      continue;
+    }
+    const depth = segments.includes("**") ? 8 : segments.length - literal;
+    let level = [segments.slice(0, literal).join("/") || "."];
+    for (let step = 0;step < depth; step++) {
+      level = level.flatMap((folder) => presetDirectories(root, folder, presetNamedSkip));
+      level.forEach((folder) => candidates.add(folder));
+    }
+  }
+  return [...candidates].filter((path) => matches(path, include) && !matches(path, exclude) && existsSync(resolve2(root, path, "package.json"))).toSorted();
+}
+function presetContains(key, path) {
+  if (key === "." || key === path) {
+    return true;
+  }
+  const pattern = key.split("/");
+  const segments = path.split("/");
+  return pattern.length <= segments.length && pattern.every((segment, index) => segment === "*" || segment === segments[index]);
+}
+function presetOwner(folders, path, owns) {
+  const depth = (key) => key === "." ? 0 : key.split("/").length;
+  return Object.entries(folders).filter(([key, value]) => presetContains(key, path) && owns(value)).toSorted(([left], [right]) => depth(left) - depth(right) || Number(right.includes("*")) - Number(left.includes("*"))).at(-1)?.[1];
+}
+function presetGroupOff(folders, path, group) {
+  const owner = presetOwner(folders, path, (value) => value instanceof Object && (group in value));
+  return owner instanceof Object && Object(owner)[group] === false;
+}
+function presetDetect(root, folders) {
+  const manifest = presetManifest(root, ".");
+  const configuredSource = (key) => {
+    const value = folders[key];
+    return value instanceof Object ? value.source : undefined;
+  };
+  const patterns = presetWorkspacePatterns(root, manifest);
+  const directories = presetWorkspaces(root, patterns);
+  const detected = Object.fromEntries(directories.map((directory) => [directory, presetRecipe(root, directory, !directory.startsWith("packages/"), configuredSource(directory))]));
+  const rootRecipe = presetRecipe(root, ".", true, configuredSource("."));
+  const single = Object.keys(manifest).length > 0 || rootRecipe !== presetRecipes.library;
+  const rootApp = rootRecipe !== presetRecipes.library && presetSource(root, ".", configuredSource(".")) !== ".";
+  if (patterns.length === 0 ? single : rootApp) {
+    detected["."] = rootRecipe;
+  }
+  if (existsSync(resolve2(root, "scripts")) && !directories.includes("scripts")) {
+    detected.scripts = presetRecipes.cli;
+  }
+  const keys = Object.keys(folders);
+  const covered = (key) => keys.some((user) => user !== key && user !== "." && (key.startsWith(`${user}/`) || user.endsWith("/*") && posix.dirname(key) === user.slice(0, -2)));
+  const merged = { ".": presetDeny(presetRootImports) };
+  for (const [key, value] of Object.entries(detected)) {
+    if (!covered(key)) {
+      merged[key] = presetMerge(merged[key], value);
+    }
+  }
+  for (const [key, value] of Object.entries(folders)) {
+    merged[key] = key in merged ? presetMerge(merged[key], value) : value;
+  }
+  const length = (key) => key.split("/").length;
+  const nested = (key) => Object.keys(merged).some((other) => other !== "." && length(other) < length(key) && presetContains(other, key));
+  const units = Object.entries(merged).flatMap(([key, value]) => {
+    if (key.endsWith("/*")) {
+      return presetDirectories(root, key.slice(0, -2), presetNamedSkip).filter((directory) => !(directory in merged)).map((directory) => [directory, value]);
+    }
+    if (key.includes("*") || nested(key)) {
+      return [];
+    }
+    const siblings = Object.entries(merged).filter(([other]) => other !== key && other.endsWith("/*") && length(other) === length(key) && presetContains(other, key));
+    return [[key, siblings.reduce((inherited, [, sibling]) => presetMerge(sibling, inherited), value)]];
+  });
+  const denied = new Set(Object.values(folders).flatMap((folder) => folder instanceof Object && folder.deny instanceof Object ? Object.entries(folder.deny.imports ?? {}).flatMap(([pattern, message]) => typeof message === "string" ? [pattern] : []) : []));
+  const servers = units.filter(([, value]) => value instanceof Object && Boolean(value.backend)).map(([key]) => presetManifest(root, key));
+  const internals = servers.flatMap((server) => Object.keys(server.imports ?? {}).map((specifier) => specifier.replace(/\*$/, "**")));
+  const add = (key, folder) => {
+    if (presetOwner(folders, key, () => true) === false) {
+      return;
+    }
+    const kept = folder instanceof Object ? Object.fromEntries(Object.entries(folder).filter(([group]) => !presetGroupOff(folders, key, group))) : folder;
+    if (kept instanceof Object && Object.keys(kept).length === 0) {
+      return;
+    }
+    merged[key] = key in merged ? presetMerge(kept, merged[key]) : kept;
+  };
+  for (const [key, value] of units) {
+    if (!(value instanceof Object)) {
+      continue;
+    }
+    if (value.backend) {
+      for (const [path, folder] of Object.entries(presetBackendConventions(root, key, value, denied))) {
+        add(path === "." ? key : posix.join(key, path), folder);
+      }
+    } else if (value.tanstack || value.next) {
+      for (const [path, folder] of Object.entries(presetWebConventions(root, key, value, servers))) {
+        add(path === "." ? key : posix.join(key, path), folder);
+      }
+    } else if ((value.kit || key.startsWith("packages/")) && !value.expo) {
+      const own = Object.keys(presetManifest(root, key).imports ?? {});
+      const message = presetPackageImports["../../apps/**"];
+      const appImports = internals.filter((specifier) => !own.some((mine) => presetOverlaps(mine, specifier))).map((specifier) => [specifier, message]);
+      add(key, presetDeny({ ...presetPackageImports, ...Object.fromEntries(appImports) }));
+    }
+  }
+  return merged;
+}
+
+// src/preset/groups/backend.ts
+var backendGroup = (project, settings) => {
+  const overrides = [
+    presetOverride(presetScopes(project.backend, "{rpc,routes}/**/*.ts"), {
+      "arch/boundaries-rpc-database": "error",
+      "no-restricted-imports": ["error", { paths: ["kysely", "drizzle-orm"], patterns: project.baseImports }]
+    }),
+    presetOverride(presetScopes(project.backend), {
+      "eslint-js/no-restricted-syntax": ["error", { selector: ':function > Identifier.params[name="trx"]', message: "Name the transaction db so helpers take either." }]
+    })
+  ];
+  if (settings.registry === false) {
+    return overrides;
+  }
+  const configured = typeof settings.registry === "string" ? { file: settings.registry } : settings.registry ?? {};
+  const backendUnits = project.units.filter((unit) => unit.kind === "backend");
+  const file = configured.file === undefined ? undefined : posix2.normalize(configured.file);
+  const registries = file === undefined ? backendUnits.flatMap((unit) => {
+    const found = presetRegistryFile(project.root, unit.source, undefined);
+    return found ? [{ file: found, unit }] : [];
+  }) : [{ file, unit: backendUnits.find((unit) => unit.key === "." || file.startsWith(`${unit.key}/`)) }];
+  for (const registry of registries) {
+    if (!registry.unit) {
+      throw new PresetError(`backend.registry \`${registry.file}\` must be a project-relative path inside a backend folder.`);
+    }
+    const options = {
+      registry: resolve3(project.root, registry.file),
+      services: resolve3(project.root, registry.unit.source, "services"),
+      skip: configured.skip ?? (file === undefined ? presetRegistrySkip : [])
+    };
+    if (configured.object !== undefined) {
+      options.object = configured.object;
+    }
+    overrides.push(presetOverride([registry.file], { "arch/backend-registry": ["error", options] }));
+  }
+  return overrides;
+};
+
+// src/preset/groups/basics.ts
+var basicsGroup = (project, settings) => {
+  const trivial = { mode: "precise", async: false, callees: [] };
+  const { appFiles, safetyFiles, ui, web } = project;
+  return [
+    ...settings.trivial ? [
+      presetOverride(appFiles, { "arch/code-trivial-functions": ["error", trivial] }, ui),
+      presetOverride([...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")], { "arch/code-trivial-functions": ["error", { ...trivial, services: true }] }, ui)
+    ] : [],
+    ...settings.state ? [presetOverride(safetyFiles, { "arch/code-mutable-state": ["error", { kinds: ["let", "var"] }] }, ui)] : [],
+    ...settings.switch ? [presetOverride(project.backendFiles, { "arch/code-switch": ["error", { message: "Use ts-pattern in backend application code." }] })] : [],
+    ...settings.negation ? [presetOverride(safetyFiles, { "arch/code-double-negation": "error" }, ui)] : []
+  ];
+};
+
+// src/preset/groups/comments.ts
+var commentsGroup = (project, settings) => [
+  presetOverride(project.appFiles, { "arch/comments-code": ["error", { why: false, allow: ["^\\s*SAFETY: "] }] }, project.ui),
+  presetOverride(presetScopes(project.app, "**/*.{types,constants}.ts"), { "arch/comments-code": ["error", { why: false }] }),
+  ...settings.directives ? [presetOverride([`**/${presetExtensions}`], { "arch/comments-directives": "error" })] : []
+];
+
+// src/preset/groups/console.ts
+var consoleGroup = () => [presetOverride([`**/${presetExtensions}`], { "no-console": "error" })];
+
+// src/preset/groups/deny.ts
+var denyGroup = (project, settings) => {
+  const { imports, calls } = settings;
+  const overrides = [];
+  if (Object.keys(imports).length > 0 || Object.keys(calls).length > 0) {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/boundaries-deny": ["error", { imports, calls }] }));
+  }
+  for (const unit of project.units) {
+    const writes = unit.kind === "backend" ? unit.scope.effective.backend?.writes ?? [] : [];
+    if (writes.length === 0) {
+      continue;
+    }
+    const files = [
+      ...presetScopes([unit.source], "services/**/*-query.*.ts"),
+      ...presetScopes(project.operations.filter((path) => path === unit.source), "services/*/queries/*.ts")
+    ];
+    const reads = Object.fromEntries(writes.map((name) => [name, "Query files only read; move writes to an action."]));
+    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: { ...reads, ...calls } }] }));
+  }
+  return overrides;
+};
+
+// src/preset/groups/expo.ts
+var expoGroup = (project, settings) => {
+  const { expoWeb, testFiles } = project;
+  const server = settings.server;
+  const overrides = [
+    presetOverride(presetScopes(expoWeb, "app/**/*.tsx"), {
+      "arch/files-route": [
+        "error",
+        { export: "default", exports: presetExpoRouteExports, hooks: ["useState", "useEffect", "useMutation"], intrinsic: false }
+      ]
+    }, testFiles),
+    presetOverride(presetScopes(expoWeb, "app/**/*.tsx"), {
+      "arch/naming-file": [
+        "error",
+        {
+          pattern: "^(?:_layout|index|\\[(?:[.]{3})?[\\w.]+\\]|[+][a-z][\\w-]*|[a-z][a-z0-9-]*)(?:[.](?:web|native|ios|android))?[.]tsx$",
+          message: "Expo Router files are kebab-case, _layout, index, [param], [...rest] or +special."
+        }
+      ],
+      "arch/files-helpers": [
+        "error",
+        {
+          allow: "^makeStyles$",
+          message: "Route files hold screens and their components; move logic to a service or hook."
+        }
+      ]
+    }, testFiles),
+    presetOverride(presetScopes(expoWeb, "app/**/*+api.ts"), {
+      "arch/files-route": ["error", { export: "GET", exports: ["HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"], hooks: [], intrinsic: false }]
+    })
+  ];
+  if (server.length > 0) {
+    overrides.push(presetOverride(presetScopes(expoWeb), {
+      "no-restricted-imports": ["error", { paths: server, patterns: project.baseImports }]
+    }));
+  }
+  return overrides;
+};
+
+// src/preset/groups/externals.ts
+var externalsGroup = (_project, settings) => [
+  presetOverride(["**/{vite,next}.config.{ts,mts,cts,js,mjs,cjs}"], { "arch/files-externals": ["error", { packages: settings.packages }] })
+];
+
+// src/preset/groups/forms.ts
+var formsGroup = (project, settings) => [
+  presetOverride(project.reactFiles, { "arch/code-paired-call": ["error", { when: "useForm", require: settings.resolver }] }, project.ui)
+];
+
+// src/preset/groups/imports.ts
+import { resolve as resolve4 } from "node:path";
+function importsPackageNames(project, kinds) {
+  return project.units.flatMap((unit) => {
+    const name = kinds.includes(unit.kind) ? presetPackageName(project.root, unit.key) : undefined;
+    return name ? [name] : [];
+  });
+}
+var importsGroup = (project, settings) => {
+  const rules = {
+    ...presetImportRules,
+    "arch/types-namespace-import": ["error", { max: 3 }],
+    "no-restricted-imports": ["error", { patterns: project.baseImports }],
+    "import-extra/no-relative-packages": "error",
+    "perfectionist/sort-imports": [
+      "error",
+      {
+        type: "natural",
+        ignoreCase: true,
+        newlinesBetween: 0,
+        environment: "bun",
+        internalPattern: settings.internal ?? [
+          "^@/.*",
+          "^#.*",
+          "^~icons/.*",
+          ...project.publicEntrypoints.map((path) => `^${path.split("/").slice(0, 2).join("/")}/`)
+        ],
+        groups: [["builtin", "external"], "internal", ["parent", "sibling", "index"], "type"]
+      }
+    ]
+  };
+  if (!settings.sort) {
+    delete rules["perfectionist/sort-imports"];
+    delete rules["perfectionist/sort-named-imports"];
+  }
+  const overrides = [presetOverride([`**/${presetExtensions}`], rules)];
+  if (!settings.boundaries) {
+    return overrides;
+  }
+  const absolute = (paths) => paths.map((path) => resolve4(project.root, path));
+  overrides.push(presetOverride([...project.appFiles, ...presetScopes(project.packages, `**/${presetExtensions}`)], {
+    "arch/boundaries-imports": [
+      "error",
+      {
+        web: absolute(project.web),
+        backend: absolute(project.backend),
+        packages: absolute(project.packages),
+        roles: project.suffixes,
+        portable: true,
+        aliases: presetAliases(project.root, settings.aliases),
+        appPackages: importsPackageNames(project, ["web", "backend"]),
+        backendPackages: importsPackageNames(project, ["backend"]),
+        entrypoints: project.publicEntrypoints
+      }
+    ]
+  }));
+  return overrides;
+};
+
+// src/preset/groups/layout.ts
+import { posix as posix3 } from "node:path";
+var layoutGroup = (project, settings) => {
+  const { web, nextWeb, serviceRoots, app, services, utilities, ui, testFiles, layouts, operations } = project;
+  const folderOperations = presetScopes(operations, "services/*/{actions,queries}/*.ts");
+  const operationMessage = "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.";
+  const roles = [...presetBuiltinFileRoles.filter((role) => role !== "action" && role !== "query"), ...project.suffixes];
+  const conceptFiles = project.suffixes.map((suffix) => `**/*.${suffix}.ts`);
+  const frontendEntries = [...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")];
+  const ungroupedWeb = web.filter((path) => !layouts.some((scope) => scope.path === posix3.join(path, "components")));
+  return [
+    ...layouts.flatMap(({ path, folder, mode }) => {
+      const folders = folder === "services" && operations.some((source) => posix3.join(source, "services") === path);
+      const registries = folder === "services" ? project.registries : [];
+      const restricted = presetOverride(mode === "flat" ? [`${path}/*/**/${presetExtensions}`] : [`${path}/${presetExtensions}`, `${path}/*/*/**/${presetExtensions}`], {
+        "arch/files-restricted": [
+          "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."
+          }
+        ]
+      }, [...folders ? [`${path}/*/{actions,queries}/*.ts`] : [], ...registries]);
+      if (mode !== "domain") {
+        return [restricted];
+      }
+      const prefix = { singularize: folder === "components" ? "trailing-s" : "none", separators: [".", "-"] };
+      const naming = folder === "hooks" ? { ...prefix, prefixes: ["use-"] } : prefix;
+      const domain = [restricted, presetOverride([`${path}/*/${presetExtensions}`], { "arch/naming-folder": ["error", naming] }, registries)];
+      if (!settings.strict || folder !== "services") {
+        return domain;
+      }
+      const strict = presetOverride([`${path}/*/**/${presetExtensions}`], {
+        "arch/naming-file": [
+          "error",
+          {
+            pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*(?:[.](?:${roles.join("|")})[.]ts|[.]rsc[.]tsx)$`,
+            message: `Domain files use domain[-part].<role>.ts with a role from: ${roles.join(", ")}. Add new roles to layout.suffixes.`
+          }
+        ]
+      }, ["**/*-{action,query}.*.ts", ...testFiles, ...registries]);
+      return [...domain, strict];
+    }),
+    presetOverride(presetScopes(ungroupedWeb, `components/*/*/**/${presetExtensions}`), { "arch/files-restricted": ["error", { message: "Components allow one group folder." }] }, ui),
+    presetOverride([...presetScopes(web, "components/**/*.ts"), ...presetScopes(web, "hooks/**/*.tsx")], { "arch/files-restricted": ["error", { message: "Components use TSX; hooks use .ts files." }] }, ui),
+    presetOverride(presetScopes(web, "**/use-*.{ts,tsx}"), { "arch/files-restricted": ["error", { message: "Hooks belong in src/hooks." }] }, [...presetScopes(web, "hooks/**"), ...ui]),
+    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), {
+      "arch/files-restricted": [
+        "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,
+      ...project.colocated,
+      ...testFiles
+    ]),
+    presetOverride(services, {
+      "arch/backend-service-functions": "error",
+      "arch/types-inline": ["error", { parameters: true, returns: true, functions: true, min: 1 }]
+    }, [...utilities, ...testFiles, ...conceptFiles]),
+    presetOverride(frontendEntries, { "arch/backend-service-functions": ["error", { frontend: true }] }, testFiles),
+    ...conceptFiles.map((pattern) => presetOverride(presetScopes(app, `services/${pattern}`), {
+      "arch/backend-service-functions": "off",
+      "arch/naming-exports": ["error", { stem: "full-basename", scope: "functions" }]
+    }, testFiles)),
+    presetOverride([...presetScopes(app, "services/**/*-{action,query}.*.ts"), ...presetScopes(web, "services/**/*-{action,query}.*.rsc.tsx")], { "arch/backend-service-functions": ["error", { helpers: true, single: true, message: operationMessage }] }, testFiles),
+    presetOverride(folderOperations, { "arch/backend-service-functions": ["error", { helpers: true, single: true, message: operationMessage }] }, testFiles),
+    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), { "arch/files-domain-constants": "error" }, [...utilities, ...testFiles]),
+    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), { "arch/files-domain-constants": ["error", { data: true }] }, [
+      "**/*.constants.ts",
+      ...testFiles
+    ]),
+    presetOverride(frontendEntries, { "arch/files-domain-constants": ["error", { data: true, services: true }] }, testFiles),
+    presetOverride([...presetScopes(serviceRoots, "services/**/*-{action,query}.*.ts"), ...folderOperations, ...frontendEntries], { "arch/code-object-params": ["error", { max: 2 }] }, testFiles),
+    presetOverride(frontendEntries, { "arch/code-object-params": ["error", { max: 2, services: true }] }, testFiles),
+    presetOverride(presetScopes(serviceRoots, "services/**/*.service.ts"), { "arch/files-exports": ["error", { names: settings.service, stem: "before-first-dot", types: false }] }, testFiles),
+    presetOverride(presetScopes(app.filter((path) => !operations.includes(path)), "services/**/{actions,queries}/**/*.ts"), {
+      "arch/files-restricted": ["error", { message: "Use domain-action.name.ts or domain-query.name.ts." }]
+    })
+  ];
+};
+
+// src/preset/groups/limits.ts
+var limitsGroup = (project, settings) => [
+  presetOverride(project.safetyFiles, {
+    "max-lines": ["error", { max: settings.lines, skipBlankLines: true, skipComments: true }],
+    complexity: ["error", { max: settings.complexity }]
+  }, project.ui),
+  presetOverride(presetScopes(project.app, "**/*.types.ts"), { "max-lines": ["error", { max: settings.types, skipBlankLines: true, skipComments: true }] }, project.ui)
+];
+
+// src/preset/groups/naming.ts
+var namingOperationMessage = "Use domain-action.name.ts or domain-query.name.ts.";
+var namingFrontendPrefix = { ...presetExportPrefix, scope: "functions", services: true, allow: "^\\*$" };
+function namingOperationPrefix(role) {
+  return { ...presetExportPrefix, roles: [role], scope: "functions", allow: "^\\*$" };
+}
+function namingOperation(role, file) {
+  return { mode: "template", file, export: `{domain}${role === "action" ? "Action" : "Query"}{Name}`, placeholder: "[a-z0-9-]+", camelCase: true };
+}
+var namingGroup = (project, settings, owner) => {
+  const { web, serviceRoots, app, ui, testFiles, components, hooks, operations } = project;
+  const flatApp = app.filter((path) => !operations.includes(path));
+  const folderApp = app.filter((path) => operations.includes(path));
+  const frontendEntries = [...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")];
+  const ungroupedWeb = web.filter((path) => !project.layouts.some((scope) => scope.path === `${path}/components`));
+  const overrides = [];
+  const { files: filesPattern, exports: exportsPattern, unique } = settings;
+  for (const [key, source] of [["files", filesPattern], ["exports", exportsPattern], ["unique", unique]]) {
+    try {
+      RegExp(typeof source === "string" ? source : "");
+    } catch {
+      throw new PresetError(`naming.${String(key)} must be a valid regular expression.`);
+    }
+  }
+  const folderChecks = [];
+  if (typeof filesPattern === "string" || unique !== undefined) {
+    const check = { pattern: typeof filesPattern === "string" ? filesPattern : "", message: `File names here must match ${String(filesPattern)}.` };
+    if (unique !== undefined) {
+      check.unique = unique;
+    }
+    folderChecks.push(check);
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-file": ["error", check] }));
+    for (const override of owner.effective.layout ? layoutGroup(project, owner.effective.layout, owner) : []) {
+      const layoutRule = override.rules?.["arch/naming-file"];
+      if (Array.isArray(layoutRule)) {
+        overrides.push({ ...override, rules: { "arch/naming-file": [...layoutRule, check] } });
+      }
+    }
+  }
+  const add = (kind, files, rules, excludeFiles) => {
+    const fileRule = rules["arch/naming-file"];
+    if (Array.isArray(fileRule) && folderChecks.length > 0) {
+      rules["arch/naming-file"] = [...fileRule, ...folderChecks];
+    }
+    if (settings[kind]) {
+      overrides.push(presetOverride(files, rules, excludeFiles));
+    }
+  };
+  add("files", [`**/${presetExtensions}`], presetNamingRules);
+  add("files", presetScopes(app, "types/**/*.ts"), { "arch/naming-file": ["error", { pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*[.]types[.]ts$", message: "Use domain.types.ts filenames." }] }, ["**/*.constants.ts"]);
+  add("exports", presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/naming-exports": ["error", presetExportPrefix] }, [...ui, ...presetScopes(serviceRoots, "entry.*.ts")]);
+  add("exports", frontendEntries, { "arch/naming-exports": ["error", namingFrontendPrefix] }, testFiles);
+  add("exports", presetScopes(web, "services/**/*.constants.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "declarations", allow: "^\\*$" }] }, testFiles);
+  add("exports", presetScopes(app, "**/*.utils.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "functions", allow: "^\\*$" }] }, ui);
+  add("files", hooks, {
+    "arch/naming-file": [
+      "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."
+      }
+    ]
+  }, ui);
+  add("exports", hooks, { "arch/naming-exports": ["error", {}, { mode: "pattern", pattern: "^use[A-Z]", types: true }] }, ui);
+  add("exports", components, { "arch/files-components-only": ["error", { filename: true, types: true, roles: ["illustration"] }] }, [...ui, ...testFiles]);
+  add("folders", presetScopes(ungroupedWeb, "components/**/*.tsx"), { "arch/naming-folder": ["error", { singularize: "trailing-s", separators: ["-"] }] }, [...ui, ...testFiles]);
+  for (const role of ["action", "query"]) {
+    const files = [...presetScopes(flatApp, `services/**/*-${role}.*.ts`), ...presetScopes(web, `services/**/*-${role}.*.rsc.tsx`)];
+    add("files", files, {
+      "arch/naming-file": ["error", { pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*-${role}\\.[a-z0-9]+(?:-[a-z0-9]+)*\\.ts$`, message: namingOperationMessage }]
+    }, testFiles);
+    add("exports", files, {
+      "arch/naming-exports": [
+        "error",
+        namingOperationPrefix(role),
+        namingOperation(role, `{domain}-${role}.{name}.ts`)
+      ]
+    }, testFiles);
+  }
+  for (const [role, folder, separator] of [["action", "actions", "."], ["query", "queries", "-"]]) {
+    const files = presetScopes(folderApp, `services/*/${folder}/*.ts`);
+    add("files", files, {
+      "arch/naming-file": [
+        "error",
+        {
+          pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*-${role}[${separator}][a-z0-9]+(?:-[a-z0-9]+)*[.]ts$`,
+          message: "Use domain-action.name.ts in actions/ and domain-query-name.ts in queries/."
+        }
+      ]
+    }, testFiles);
+    add("exports", files, {
+      "arch/naming-exports": [
+        "error",
+        { mode: "template", file: `{domain}-${role}${separator}{name}.ts`, export: `make{Domain}${role === "action" ? "Action" : "Query"}{Name}`, placeholder: "[a-z0-9-]+" }
+      ]
+    }, testFiles);
+  }
+  for (const role of ["action", "query"]) {
+    for (const suffix of ["client.ts", "server.ts", "rsc.ts", "rsc.tsx"]) {
+      const files = presetScopes(web, `services/**/*-${role}.*.${suffix}`);
+      add("files", files, {
+        "arch/naming-file": [
+          "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."
+          }
+        ]
+      }, testFiles);
+      add("exports", files, { "arch/naming-exports": ["error", namingOperationPrefix(role), namingOperation(role, `{domain}-${role}.{name}.${suffix}`)] }, testFiles);
+    }
+  }
+  add("exports", presetScopes(web, "services/**/*.rsc.{ts,tsx}"), { "arch/naming-exports": ["error", namingFrontendPrefix, { mode: "pattern", pattern: "^[a-z][a-z0-9]*Rsc[A-Z][a-zA-Z0-9]*$" }] }, ["**/*-{action,query}.*.rsc.{ts,tsx}", ...testFiles]);
+  if (typeof exportsPattern === "string") {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-exports": ["error", { mode: "pattern", pattern: exportsPattern, types: true }] }));
+  }
+  return overrides;
+};
+
+// src/preset/groups/next.ts
+var nextGroup = (project, settings) => {
+  const { nextWeb, testFiles } = project;
+  const hooks = ["useState", "useEffect", "useMutation"];
+  const page = { export: "default", exports: presetNextSegmentExports, hooks, inspect: true };
+  return [
+    presetOverride(presetScopes(nextWeb, "app/**/{page,template,default,not-found,forbidden,unauthorized,loading}.tsx"), { "arch/files-route": ["error", { ...page, intrinsic: true }] }, [...testFiles, ...presetScopes(nextWeb, "app/not-found.tsx")]),
+    presetOverride([...presetScopes(nextWeb, "app/**/{layout,global-not-found}.tsx"), ...presetScopes(nextWeb, "app/not-found.tsx")], { "arch/files-route": ["error", { ...page, intrinsic: false }] }, testFiles),
+    presetOverride(presetScopes(nextWeb, "app/**/route.ts"), {
+      "arch/files-route": [
+        "error",
+        { export: "GET", exports: [...presetNextHandlerMethods.slice(1), ...presetNextSegmentConfig], hooks: [], intrinsic: false }
+      ],
+      "arch/files-helpers": [
+        "error",
+        {
+          components: false,
+          allow: `^(${[...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."
+        }
+      ]
+    }),
+    ...presetRuntime(project, settings, "next", "arch/boundaries-next")
+  ];
+};
+
+// src/preset/groups/orpc.ts
+var orpcGroup = (project) => project.orpc.public.length > 0 ? [
+  presetOverride(project.orpc.public, {
+    "arch/backend-orpc-output": ["error", { handler: "handler", output: "output", composers: project.orpc.composers }]
+  })
+] : [];
+
+// src/preset/groups/react.ts
+var reactGroup = (project, settings) => {
+  const { reactFiles, web, ui, testFiles, components } = project;
+  const memo = settings.memo ?? settings.compiler;
+  const perf = settings.perf ?? !settings.compiler;
+  const rules = { ...presetReactRules, "arch/layout-jsx-attributes": ["error", { min: 3 }] };
+  if (perf) {
+    for (const rule of ["new-object", "new-array", "new-function", "jsx"]) {
+      rules[`react-perf/jsx-no-${rule}-as-prop`] = "error";
+    }
+  }
+  const overrides = [
+    presetOverride(reactFiles, rules, ui),
+    presetOverride(components, { "arch/files-helpers": ["error", { components: true, hooks: "^use[A-Z]" }] }, [...ui, ...testFiles])
+  ];
+  if (settings.effects) {
+    overrides.push(presetOverride(reactFiles, { ...presetEffectsRules, "arch/react-empty-effect": "error" }, ui));
+  }
+  if (memo) {
+    overrides.push(presetOverride(reactFiles, { "arch/react-memo": "error" }, ui));
+  }
+  if (web.length > 0) {
+    overrides.push(presetOverride(project.webFiles, {
+      "arch/boundaries-token-owner": [
+        "error",
+        {
+          restrictions: [
+            { token: "RouterClient", allow: [...project.rpcClients] },
+            { token: "createContext", patterns: [...presetScopes(web, "context/"), ...project.webUiRoots.map((path) => `${path}/`)] }
+          ]
+        }
+      ]
+    }));
+  }
+  if (settings.props) {
+    overrides.push(presetOverride(components, { "arch/react-props": ["error", { prefix: true }] }, [...ui, ...testFiles]));
+  }
+  if (!settings.a11y) {
+    overrides.push(presetOverride(["**/*.{tsx,jsx}"], Object.fromEntries(presetA11yRules.map((rule) => [rule, "off"]))));
+  }
+  return overrides;
+};
+
+// src/preset/groups/schemas.ts
+var schemasGroup = (project) => {
+  const { backend, nextWeb, packageSources, ui } = project;
+  const owners = backend.length > 0 ? backend : nextWeb;
+  return [
+    presetOverride(project.appFiles, { "arch/schemas-local": ["error", { packages: ["zod"], namespaces: ["z"] }] }, [...presetScopes([...owners, ...packageSources], "types/**"), ...project.colocated, ...ui]),
+    presetOverride([...project.webFiles, ...presetScopes(packageSources)], {
+      "arch/schemas-rederive": ["error", { from: project.publicEntrypoints, namespaces: ["z"], operators: ["infer", "input"] }]
+    })
+  ];
+};
+
+// src/preset/groups/shadcn.ts
+var shadcnGroup = (project) => {
+  const { web, webFiles, ui, webUiRoots } = project;
+  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 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] }
+    ]
+  });
+  if (Object.keys(project.css).length === 0) {
+    return [];
+  }
+  return [
+    presetOverride(webFiles, {
+      "shadcn/no-restyle": ["error", restyle(allow)],
+      "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea] }],
+      "shadcn/require-static-classes": "error",
+      "arch/react-dynamic-classes": "error"
+    }, ui),
+    presetOverride(presetScopes(web, "components/**/*.illustration.tsx"), {
+      "shadcn/no-restyle": ["error", restyle([...allow, ...presetIllustrationPalette])],
+      "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea, ...presetIllustrationPalette] }]
+    }, ui),
+    presetOverride(webFiles, { "shadcn/no-unknown-classes": ["error", { allow: [] }] }),
+    presetOverride(presetScopes(webUiRoots, "sonner.tsx"), { "shadcn/no-unknown-classes": ["error", { allow: ["toaster", "toast"] }] })
+  ];
+};
+
+// src/preset/groups/sql.ts
+var sqlGroup = (project, settings) => [
+  presetOverride(presetScopes(project.serviceRoots, "services/**/*.ts"), {
+    "arch/backend-sql-like": [
+      "error",
+      { methods: ["like", "ilike"], operators: ["where"], sanitizers: settings.sanitizers, bindings: true }
+    ]
+  })
+];
+
+// src/preset/groups/style.ts
+var styleGroup = (_project, settings) => {
+  const files = [`**/${presetExtensions}`];
+  const layout = {};
+  if (settings.padding) {
+    layout["arch/layout-padding"] = ["error", { multiline: true }];
+  }
+  if (settings.multiline) {
+    layout["arch/layout-object"] = ["error", { min: 3, scope: "call-args" }];
+    layout["arch/layout-call-array"] = ["error", { callees: ["Promise.all"], min: 2 }];
+    layout["arch/layout-key-value"] = "error";
+  }
+  if (settings.dashes) {
+    layout["arch/copy-dashes"] = "error";
+  }
+  return [
+    presetOverride(files, {
+      ...presetFormattingRules,
+      "eslint-js/semi": ["error", settings.semicolons ? "always" : "never"],
+      "eslint-js/quotes": ["error", settings.quotes, { avoidEscape: true }]
+    }),
+    presetOverride(files, layout)
+  ];
+};
+
+// src/preset/groups/tailwind.ts
+var tailwindGroup = (project) => Object.entries(project.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 }]
+]))));
+
+// src/preset/groups/tanstack.ts
+var tanstackGroup = (project, settings) => {
+  const { tanstackWeb, testFiles } = project;
+  return [
+    presetOverride(presetScopes(tanstackWeb, "routes/**/*.{ts,tsx}"), { "arch/files-route": ["error", { export: "Route", hooks: ["useState", "useEffect", "useMutation"], intrinsic: true }] }, testFiles),
+    presetOverride(presetScopes(tanstackWeb, "routes/handlers/**/*.ts"), {
+      "arch/files-helpers": [
+        "error",
+        {
+          components: 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."
+        }
+      ]
+    }),
+    presetOverride(presetScopes(tanstackWeb), {
+      "no-restricted-imports": [
+        "error",
+        {
+          paths: [{ name: "@tanstack/react-start/rsc", message: "Render server components only in services/*.rsc.tsx files." }],
+          patterns: project.baseImports
+        }
+      ]
+    }, presetScopes(tanstackWeb, "services/**/*.rsc.{ts,tsx}")),
+    ...presetRuntime(project, settings, "tanstack", "arch/boundaries-tanstack")
+  ];
+};
+
+// src/utils/options.utils.ts
+class OptionsError extends Error {
+}
+var optionsPatternSchema = {
+  anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, minItems: 1 }]
+};
+function optionsFirst(context, fallback) {
+  return context.options[0] ?? fallback;
+}
+function optionsAll(context) {
+  return context.options;
+}
+function optionsPatterns(pattern, flags) {
+  return optionsPatternsWithEmpty(pattern === undefined ? undefined : [pattern].flat().filter((source) => source !== ""), flags);
+}
+function optionsPatternsWithEmpty(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
+}
+function optionsPatternsTest(patterns, value) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+function optionsGlob(pattern) {
+  const negated = [];
+  const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    return `\x02${negated.length - 1}\x03`;
+  }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
+  return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
+}
+function optionsPatternLabel(pattern) {
+  return pattern === undefined ? "" : [pattern].flat().filter((source) => source !== "").join(" | ");
+}
+function optionsAssertMockingApis(patterns) {
+  if (patterns.some((pattern) => !/^(?:\*|(?:vi|jest|\*)\.(?:[A-Za-z_$][\w$]*|\*))$/.test(pattern))) {
+    throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
+  }
+}
+
+// src/preset/groups/tests.ts
+var testsGroup = (project, settings) => {
+  const { functions, assertions } = settings;
+  const testFunctions = ["test", "it", ...functions];
+  if (testFunctions.some((name) => !/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(name))) {
+    throw new PresetError("Test functions must be literal identifiers or dotted names.");
+  }
+  if (assertions.some((name) => !/^[A-Za-z_$][\w$]*(?:\.[\w$*]+)*$/.test(name))) {
+    throw new PresetError("Assertion functions must be rooted dotted names or patterns.");
+  }
+  const configured = settings.mocking;
+  const mocking = typeof configured === "string" ? { preset: configured } : configured;
+  const preset = mocking.preset ?? "modules";
+  if (!["modules", "strict"].includes(preset)) {
+    throw new PresetError("Unknown test mocking preset.");
+  }
+  const deny = [...mocking.deny ?? [], ...presetTestMockingApis[preset]].map((entry) => typeof entry === "string" && preset === "strict" ? { api: entry, message: presetStrictMockingMessage } : entry);
+  const allow = [...presetTestMockingAllow[preset], ...mocking.allow ?? []].toSorted((left, right) => Number(left.apis.includes("*")) - Number(right.apis.includes("*")));
+  optionsAssertMockingApis([...deny.map((entry) => typeof entry === "string" ? entry : entry.api), ...allow.flatMap((entry) => entry.apis)]);
+  const customized = preset !== "modules" || (mocking.deny ?? []).length > 0;
+  const mockingRule = (apis) => ["error", { deny, allow: ["*.fn", ...apis], checkDestructured: customized }];
+  const backendRules = { "arch/tests-concurrent-db": "error" };
+  if (settings.fixtures) {
+    backendRules["no-restricted-imports"] = [
+      "error",
+      { patterns: [...project.baseImports, { group: ["**/helpers/**"], message: "Use named fixtures or tests/support." }] }
+    ];
+  }
+  const rules = {
+    ...presetTestRules,
+    "dillon-anti-slop/no-module-mocking": customized ? mockingRule([]) : "error",
+    "arch/tests-modifiers": ["error", { functions }],
+    "arch/tests-assertions": ["error", { functions, assertions }]
+  };
+  if (settings.titles) {
+    rules["arch/tests-titles"] = ["error", { callees: ["describe", ...testFunctions], deny: "^should\\b", flags: "i" }];
+  }
+  return [
+    presetOverride(project.testFiles, rules),
+    presetOverride(presetScopes(project.units.map((unit) => unit.source), "**/*.{test,spec}.{ts,tsx,mts,cts}"), { "arch/files-restricted": ["error", { message: "Tests live in a tests/ folder, not next to the code." }] }, ["**/tests/**", "**/test/**"]),
+    presetOverride(presetScopes(project.backendRoots, "tests/**/*.ts"), backendRules),
+    ...allow.map((entry) => presetOverride(entry.files, { "dillon-anti-slop/no-module-mocking": entry.apis.includes("*") ? "off" : mockingRule(entry.apis) }))
+  ];
+};
+
+// src/preset/groups/types.ts
+var typesGroup = (project, settings) => {
+  const { web, backend, packageSources, app, appFiles, services, utilities, types, ui, testFiles, components, hooks } = project;
+  const schemaOwners = backend.length > 0 ? backend : project.nextWeb;
+  const runtimeFreeTypes = backend.length > 0 ? web : [...project.tanstackWeb, ...project.expoWeb];
+  const colocated = project.colocated;
+  const overrides = [];
+  if (settings.placement) {
+    overrides.push(presetOverride(appFiles, { "arch/types-declarations": "error" }, [
+      ...types,
+      ...colocated,
+      ...components,
+      ...hooks,
+      ...services,
+      ...ui,
+      ...testFiles
+    ]), presetOverride(services, { "arch/types-service": "error" }, [...utilities, ...testFiles]), presetOverride([...components, ...hooks], {
+      "arch/types-local-alias": "error",
+      "arch/naming-types": "error",
+      "arch/naming-declarations": [
+        "error",
+        { kinds: ["interface"], stem: "before-first-dot", normalize: "remove-separators" }
+      ]
+    }, [...ui, ...testFiles]), presetOverride(presetScopes(app, "**/*.types.ts"), { "arch/files-restricted": ["error", { message: "Domain types belong in src/types." }] }, [...types, ...colocated, ...ui]), presetOverride(presetScopes(app, "**/*.{utils,constants}.ts"), { "arch/types-declarations": "error" }, [...ui, ...testFiles]), presetOverride([...presetScopes([...schemaOwners, ...packageSources], "types/**/*.types.ts"), ...colocated, ...presetScopes(app, "**/*.constants.ts")], { "arch/files-no-functions": ["error", { reexports: false }] }), ...runtimeFreeTypes.length > 0 ? [
+      presetOverride(presetScopes(runtimeFreeTypes, "types/**/*.types.ts"), {
+        "arch/files-types-only": ["error", { imports: "ban", sources: [], reexports: true }]
+      })
+    ] : []);
+  }
+  if (settings.safety) {
+    overrides.push(presetOverride(project.safetyFiles, {
+      "typescript/no-explicit-any": "error",
+      "typescript/ban-ts-comment": ["error", { "ts-ignore": true, "ts-nocheck": true, "ts-expect-error": true, "ts-check": false }],
+      "arch/types-unknown": "error",
+      "arch/types-imported-alias": "error",
+      "arch/code-literal-in": "error",
+      "arch/code-promise-mutation": "error",
+      "arch/code-constructor": ["error", { constructors: ["Error"], calls: 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-shape-in-symbol-names": "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"
+    }));
+  }
+  return overrides;
+};
+
+// src/preset/preset-folders.ts
+import { existsSync as existsSync3, readdirSync as readdirSync4, realpathSync as realpathSync2 } from "node:fs";
+import { posix as posix6, resolve as resolve7 } from "node:path";
+
+// src/preset/preset-stylesheet.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync } from "node:fs";
+import { posix as posix4, resolve as resolve5 } from "node:path";
+function presetTailwindEntry(css) {
+  const code = css.replaceAll(/\/\*[\s\S]*?\*\//g, "");
+  return /(?:^|[;{}])\s*@(?:import\s+(?:url\(\s*(["']?)tailwindcss(?:\/[^"')\s]*)?\1\s*\)|(["'])tailwindcss(?:\/[^"']*)?\2)|tailwind\s)/.test(code);
+}
+function presetStylesheet(root, directory) {
+  const found = [];
+  const queue = [directory];
+  const visited = new Set;
+  while (queue.length > 0) {
+    const folder = queue.shift() ?? directory;
+    const real = realpathSync(resolve5(root, folder));
+    if (visited.has(real)) {
+      continue;
+    }
+    visited.add(real);
+    for (const name of readdirSync2(resolve5(root, folder))) {
+      const path = posix4.join(folder, name);
+      const full = resolve5(root, path);
+      const depth = posix4.relative(directory, path).split("/").length;
+      if (presetIsDirectory(full)) {
+        if (!name.startsWith(".") && !presetDetectSkip.includes(name) && depth < 8) {
+          queue.push(path);
+        }
+      } else if (name.endsWith(".css") && presetIsFile(full) && presetTailwindEntry(readFileSync3(full, "utf8"))) {
+        found.push(path);
+      }
+    }
+  }
+  const rank = (path) => {
+    const index = presetStylesheetNames.indexOf(posix4.basename(path, ".css"));
+    return index === -1 ? presetStylesheetNames.length : index;
+  };
+  return found.toSorted((left, right) => rank(left) - rank(right) || left.length - right.length).at(0);
+}
+
+// src/preset/preset-units.ts
+import { existsSync as existsSync2, readdirSync as readdirSync3 } from "node:fs";
+import { posix as posix5, resolve as resolve6 } from "node:path";
+var presetFrameworks = ["tanstack", "next", "expo"];
+var presetKindGroups = [...presetFrameworks, "backend", "console"];
+function presetUnitSource(root, key, kind, source) {
+  if (source !== undefined) {
+    if (source !== "." && !source.split("/").every((segment) => presetLiteralSegment.test(segment))) {
+      throw new PresetError(`Folder \`${key}\` source must be \`.\` or a literal relative path.`);
+    }
+    return posix5.join(key, source);
+  }
+  return kind === "console" || !existsSync2(resolve6(root, key, "src")) ? key : posix5.join(key, "src");
+}
+function presetSets(folder, name) {
+  return folder[name] !== undefined && folder[name] !== false;
+}
+function presetKind(key, enabled) {
+  const frameworks = presetFrameworks.filter(enabled);
+  if (frameworks.length > 1) {
+    throw new PresetError(`Folder \`${key}\` enables more than one of tanstack, next and expo.`);
+  }
+  const [framework] = frameworks;
+  if (frameworks.length > 0 && enabled("backend")) {
+    throw new PresetError(`Folder \`${key}\` is either an app (tanstack, next, expo) or a backend, not both.`);
+  }
+  let kind = "library";
+  if (frameworks.length > 0) {
+    kind = "web";
+  } else if (enabled("backend")) {
+    kind = "backend";
+  } else if (enabled("console")) {
+    kind = "console";
+  }
+  return { kind, framework };
+}
+function presetHasManifest(root, key) {
+  if (key === ".") {
+    return false;
+  }
+  if (!key.endsWith("/*")) {
+    return existsSync2(resolve6(root, key, "package.json"));
+  }
+  const base = resolve6(root, key.slice(0, -2));
+  return presetIsDirectory(base) && readdirSync3(base).some((name) => existsSync2(resolve6(base, name, "package.json")));
+}
+function presetUnit(root, key, scope) {
+  const { effective } = scope;
+  const wildcard = scope.parent && scope.parent.depth === scope.depth && scope.parent.key.includes("*") ? scope.parent.folder : {};
+  const folder = { ...wildcard, ...scope.folder };
+  const own = presetKindGroups.some((name) => presetSets(folder, name)) || presetHasManifest(root, key);
+  const { kind, framework } = presetKind(key, (name) => own ? presetSets(folder, name) : Boolean(effective[name]));
+  const layout = {};
+  const settings = effective.layout;
+  if (settings) {
+    const services = settings.services ?? (kind === "console" ? false : "domain");
+    const hooks = settings.hooks ?? (kind === "web" ? "flat" : false);
+    const modes = { services, hooks, components: settings.components ?? false };
+    for (const [name, mode] of Object.entries(modes)) {
+      if (mode === "flat" || mode === "domain") {
+        layout[name] = mode;
+      }
+    }
+  }
+  return { key, scope, kind, framework, source: presetUnitSource(root, key, kind, folder.source), layout };
+}
+function presetUnits(root, scopes, ignored) {
+  const [rootScope] = scopes;
+  const rootKind = presetKind(".", (name) => Boolean(rootScope.effective[name])).kind;
+  const candidates = [];
+  for (const scope of scopes) {
+    const manifest = presetHasManifest(root, scope.key);
+    const own = presetKindGroups.some((name) => presetSets(scope.folder, name)) || manifest;
+    const top = scope.parent?.key === "." && (rootKind === "library" || own);
+    const sibling = scope.parent !== null && candidates.includes(scope.parent) && scope.parent.depth === scope.depth && !scope.key.includes("*");
+    const workspace = scope.parent !== null && scope.parent.key !== "." && manifest;
+    if (top || sibling || workspace) {
+      candidates.push(scope);
+    }
+  }
+  const unitScopes = candidates.filter((scope) => !ignored.has(scope.key));
+  const explicit = new Set(unitScopes.map((scope) => scope.key));
+  const rootSource = presetUnitSource(root, ".", rootKind, rootScope.folder.source);
+  const overlaps = (left, right) => left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+  const rootOwnsSource = rootSource !== "." && !unitScopes.some((scope) => overlaps(scope.key.replace(/\/\*$/, ""), rootSource));
+  const rootUnit = rootKind !== "library" || rootOwnsSource || unitScopes.every((scope) => presetUnit(root, scope.key, scope).kind === "console");
+  return [...rootUnit ? [rootScope] : [], ...unitScopes].flatMap((scope) => {
+    if (!scope.key.endsWith("/*")) {
+      return [presetUnit(root, scope.key, scope)];
+    }
+    const base = scope.key.slice(0, -2);
+    return readdirSync3(resolve6(root, base)).filter((name) => !name.startsWith(".") && presetIsDirectory(resolve6(root, base, name))).map((name) => posix5.join(base, name)).filter((key) => !explicit.has(key) && !ignored.has(key)).map((key) => presetUnit(root, key, scope));
+  });
+}
+
+// src/preset/preset-folders.ts
+function presetNormalizeKey(key) {
+  const portable = key.replaceAll("\\", "/");
+  if (!portable.trim() || posix6.isAbsolute(portable) || /^[a-z]:/i.test(portable)) {
+    throw new PresetError(`Folder keys must be project-relative paths: ${key}`);
+  }
+  const normalized = posix6.normalize(portable).replace(/\/$/, "");
+  if (normalized === ".." || normalized.startsWith("../")) {
+    throw new PresetError(`Folder keys must stay inside the project: ${key}`);
+  }
+  const segments = normalized.split("/");
+  if (normalized !== "." && segments.some((segment) => segment !== "*" && !presetLiteralSegment.test(segment))) {
+    throw new PresetError(`Folder keys must be literal paths; only a whole \`*\` segment may be a wildcard: ${key}`);
+  }
+  if (segments.slice(0, -1).includes("*")) {
+    throw new PresetError(`Only the last segment of a folder key may be \`*\`: ${key}`);
+  }
+  return normalized;
+}
+function presetMatches(pattern, path) {
+  return pattern.every((segment, index) => segment === "*" || segment === path[index]);
+}
+function presetGroupValue(name, value, inherited, severity) {
+  if (value === undefined) {
+    return inherited && severity ? { ...inherited, level: severity } : inherited ?? null;
+  }
+  if (value === false) {
+    return null;
+  }
+  const base = inherited ?? presetGroupOptions[name];
+  if (value === true) {
+    return { ...base, level: severity ?? base.level };
+  }
+  if (value === "warn") {
+    return { ...base, level: "warn" };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new PresetError(`Group \`${name}\` takes true, false, 'warn' or an options object.`);
+  }
+  const changes = Object(value);
+  const unknown = Object.keys(changes).find((key) => !(key in base) || key === "level");
+  if (unknown) {
+    throw new PresetError(`Unknown option \`${name}.${unknown}\`.`);
+  }
+  const plain = (option) => option instanceof Object && !Array.isArray(option);
+  const merged = Object.fromEntries(Object.entries(changes).map(([key, option]) => {
+    const stored = Object(base)[key];
+    const field = presetShorthandOptions.find(([group, setting]) => group === name && setting === key)?.[2];
+    const previous = typeof stored === "string" && field !== undefined && plain(option) ? { [field]: stored } : stored;
+    return [key, plain(previous) && plain(option) ? { ...Object(previous), ...Object(option) } : option];
+  }));
+  return { ...base, ...merged, level: severity ?? base.level };
+}
+function presetDenyEntries(inherited, changes) {
+  return Object.fromEntries(Object.entries({ ...inherited, ...changes }).flatMap(([key, message]) => {
+    if (message !== false && typeof message !== "string") {
+      throw new PresetError(`Deny entry \`${key}\` takes a message string or false.`);
+    }
+    return message === false ? [] : [[key, message]];
+  }));
+}
+function presetEffective(folder, parent) {
+  const resolveGroup = (name) => {
+    const defaults = presetDefaultGroups.includes(name) ? presetGroupOptions[name] : null;
+    return [name, presetGroupValue(name, folder[name], parent ? parent[name] : defaults, folder.severity)];
+  };
+  const effective = Object.fromEntries(presetGroupOrder.map(resolveGroup));
+  const deny = folder.deny;
+  if (effective.deny && deny instanceof Object) {
+    const inherited = (parent ? parent.deny : null) ?? presetGroupOptions.deny;
+    effective.deny = {
+      ...effective.deny,
+      imports: presetDenyEntries(inherited.imports, deny.imports),
+      calls: presetDenyEntries(inherited.calls, deny.calls)
+    };
+  }
+  return effective;
+}
+function presetFolder(key, value) {
+  if (value === true || value === false) {
+    return {};
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new PresetError(`Folder \`${key}\` takes true, false or an object.`);
+  }
+  const options = Object.keys(value);
+  const groups = presetGroupOrder;
+  const unknown = options.find((option) => !presetFolderKeys.includes(option) && !groups.includes(option));
+  if (unknown) {
+    throw new PresetError(`Unknown folder option \`${unknown}\` in \`${key}\`.`);
+  }
+  const folder = value;
+  if (folder.severity !== undefined && !["error", "warn"].includes(folder.severity)) {
+    throw new PresetError(`Folder \`${key}\` severity must be 'error' or 'warn'.`);
+  }
+  return folder;
+}
+function presetScopesTree(root, folders) {
+  const entries = Object.entries(folders).map(([key, value]) => [presetNormalizeKey(key), value]);
+  const keys = entries.map(([key]) => key);
+  const duplicate = keys.find((key, index) => keys.indexOf(key) !== index);
+  if (duplicate) {
+    throw new PresetError(`Folder \`${duplicate}\` is listed twice.`);
+  }
+  for (const key of keys) {
+    const base = key.endsWith("/*") ? key.slice(0, -2) : key;
+    if (!existsSync3(resolve7(root, base))) {
+      throw new PresetError(`Folder \`${key}\` does not exist.`);
+    }
+  }
+  const rootFolder = entries.find(([key]) => key === ".")?.[1];
+  const rootScope = { key: ".", parent: null, depth: 0, folder: presetFolder(".", rootFolder ?? true), effective: {} };
+  rootScope.effective = presetEffective(rootScope.folder, null);
+  const scopes = [rootScope];
+  const sorted = entries.filter(([key]) => key !== ".").toSorted(([left], [right]) => left.split("/").length - right.split("/").length || Number(right.includes("*")) - Number(left.includes("*")));
+  for (const [key, value] of sorted) {
+    const segments = key.split("/");
+    const parents = scopes.filter((candidate) => {
+      if (candidate.key === ".") {
+        return false;
+      }
+      const pattern = candidate.key.split("/");
+      const sibling = pattern.length === segments.length && candidate.key.includes("*") && !key.includes("*");
+      return (pattern.length < segments.length || sibling) && presetMatches(pattern, segments);
+    });
+    const parent = parents.at(-1) ?? rootScope;
+    const folder = presetFolder(key, value);
+    scopes.push({
+      key,
+      parent,
+      depth: segments.length,
+      folder,
+      effective: presetEffective(folder, parent.effective)
+    });
+  }
+  return scopes;
+}
+function presetProject(config) {
+  const given = resolve7(config.root ?? process.cwd());
+  const root = existsSync3(given) ? realpathSync2(given) : given;
+  const listed = Object.entries(config.folders ?? {}).map(([key, value]) => [presetNormalizeKey(key), value]);
+  const twice = listed.find(([key], index) => listed.findIndex(([other]) => other === key) !== index);
+  if (twice) {
+    throw new PresetError(`Folder \`${twice[0]}\` is listed twice.`);
+  }
+  const folders = config.detect === false ? Object.fromEntries(listed) : presetDetect(root, Object.fromEntries(listed));
+  const scopes = presetScopesTree(root, folders);
+  const ignored = new Set(Object.entries(folders).flatMap(([key, value]) => value === false ? [presetNormalizeKey(key)] : []));
+  const live = scopes.filter((scope) => !ignored.has(scope.key));
+  const dead = live.find((scope) => scope.parent && ignored.has(scope.parent.key) && scope.parent.depth < scope.depth);
+  if (dead) {
+    throw new PresetError(`Folder \`${dead.key}\` sits inside the skipped folder \`${dead.parent?.key}\`.`);
+  }
+  const units = presetUnits(root, scopes, ignored);
+  const unitKeys = new Set(units.map((unit) => unit.scope.key));
+  const misplaced = live.find((scope) => !unitKeys.has(scope.key) && Object(scope.folder.layout).operations !== undefined);
+  if (misplaced) {
+    throw new PresetError(`Set layout.operations on an app or package folder, not on \`${misplaced.key}\`.`);
+  }
+  const writes = live.find((scope) => !unitKeys.has(scope.key) && Object(scope.folder.backend).writes !== undefined);
+  if (writes) {
+    throw new PresetError(`Set backend.writes on a backend folder, not on \`${writes.key}\`.`);
+  }
+  const of = (kind) => units.filter((unit) => unit.kind === kind);
+  const webUnits = of("web");
+  const web = webUnits.map((unit) => unit.source);
+  const backendUnits = of("backend");
+  const backend = backendUnits.map((unit) => unit.source);
+  const backendRoots = backendUnits.map((unit) => unit.key);
+  const libraryUnits = of("library");
+  const packageSources = libraryUnits.map((unit) => unit.source);
+  const app = [...web, ...backend, ...packageSources];
+  const appFiles = presetScopes(app);
+  const webFiles = presetScopes(web);
+  const effective = live.map((scope) => scope.effective);
+  const suffixes = [...new Set(effective.flatMap((groups) => groups.layout?.suffixes ?? []))];
+  if (suffixes.some((suffix) => !/^[a-z][a-z0-9-]*$/.test(suffix))) {
+    throw new PresetError("Layout suffixes must be lowercase kebab-case names.");
+  }
+  if (suffixes.some((suffix) => presetBuiltinFileRoles.includes(suffix))) {
+    throw new PresetError("Layout suffixes must not replace built-in file roles.");
+  }
+  const orpcScopes = effective.flatMap((groups) => groups.orpc ? [groups.orpc] : []);
+  const listOf = (values) => [...new Set(values.flatMap((value) => value ?? []))];
+  const client = orpcScopes.find((settings) => settings.client !== undefined)?.client;
+  const rpcClients = client === undefined ? webUnits.map((unit) => posix6.join(unit.source, "services", unit.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts")) : [client];
+  const kitUnits = units.filter((unit) => unit.scope.effective.kit);
+  const uiRoots = [...new Set([...web.map((path) => posix6.join(path, "components/ui")), ...kitUnits.map((unit) => unit.source)])];
+  const webUiRoots = uiRoots.filter((path) => web.some((webRoot) => webRoot === "." || path === webRoot || path.startsWith(`${webRoot}/`)));
+  const stylesheet = (unit) => {
+    const tailwind = unit.scope.effective.tailwind;
+    if (!tailwind) {
+      return;
+    }
+    const css = tailwind.css ?? presetStylesheet(root, unit.key);
+    return css === undefined ? undefined : resolve7(root, css);
+  };
+  const webCss = Object.fromEntries(webUnits.flatMap((unit) => {
+    const css = stylesheet(unit);
+    return css ? [[unit.source, css]] : [];
+  }));
+  const webStylesheets = [...new Set(Object.values(webCss))];
+  const kitCss = Object.fromEntries(units.filter((unit) => unit.kind !== "web" && unit.scope.effective.tailwind && !webUiRoots.includes(unit.source)).flatMap((unit) => {
+    const name = presetManifest(root, unit.key).name ?? "";
+    const consumer = webUnits.find((candidate) => {
+      const manifest = presetManifest(root, candidate.key);
+      return name in { ...manifest.dependencies, ...manifest.devDependencies };
+    });
+    const css = stylesheet(unit) ?? (unit.scope.effective.kit ? (consumer && webCss[consumer.source]) ?? webStylesheets.at(0) : undefined);
+    if (css === undefined && unit.scope.effective.kit) {
+      throw new PresetError(`The UI kit ${unit.key} needs a Tailwind stylesheet: set tailwind.css on it.`);
+    }
+    return css ? [[unit.source, css]] : [];
+  }));
+  const backendExports = listOf(effective.map((groups) => groups.backend?.exports));
+  const publicEntrypoints = backendExports.length > 0 ? backendExports : backendRoots.flatMap((directory) => {
+    const manifest = presetManifest(root, directory);
+    const entries = manifest.exports instanceof Object ? Object.keys(manifest.exports).filter((key) => key.startsWith("./")) : [];
+    if (!manifest.name) {
+      return [];
+    }
+    return entries.length > 0 ? entries.map((key) => `${manifest.name}/${key.slice(2)}`) : [`${manifest.name}/client`];
+  });
+  const publicProcedures = listOf(orpcScopes.map((settings) => settings.public));
+  const skipped = [...ignored].flatMap((key) => {
+    if (!key.endsWith("/*")) {
+      return [key];
+    }
+    const base = key.slice(0, -2);
+    return readdirSync4(resolve7(root, base)).filter((name) => presetIsDirectory(resolve7(root, base, name))).map((name) => posix6.join(base, name)).filter((path) => !live.some((scope) => scope.key === path));
+  });
+  return {
+    root,
+    scopes: live,
+    units,
+    suffixes,
+    colocated: listOf(effective.map((groups) => groups.types?.colocated)),
+    orpc: {
+      public: publicProcedures.length > 0 ? publicProcedures : backendUnits.map((unit) => posix6.join(unit.source, "rpc/api")).filter((path) => existsSync3(resolve7(root, path))).map((path) => `${path}/**`),
+      composers: listOf(orpcScopes.map((settings) => settings.composers)),
+      client: client ?? ""
+    },
+    layouts: units.flatMap((unit) => Object.entries(unit.layout).map(([folder, mode]) => ({ path: posix6.join(unit.source, folder), folder, mode }))),
+    rpcClients,
+    operations: units.flatMap((unit) => unit.scope.effective.layout?.operations === "folders" ? [unit.source] : []),
+    packages: libraryUnits.map((unit) => unit.key),
+    scripts: of("console").map((unit) => unit.key),
+    web,
+    tanstackWeb: webUnits.filter((unit) => unit.framework === "tanstack").map((unit) => unit.source),
+    nextWeb: webUnits.filter((unit) => unit.framework === "next").map((unit) => unit.source),
+    expoWeb: webUnits.filter((unit) => unit.framework === "expo").map((unit) => unit.source),
+    backend,
+    backendRoots,
+    packageSources,
+    serviceRoots: [...backend, ...packageSources],
+    app,
+    appFiles,
+    webFiles,
+    reactFiles: [
+      ...webFiles,
+      ...presetScopes(packageSources, "**/*.tsx"),
+      ...presetScopes(packageSources, `components/**/${presetExtensions}`),
+      ...presetScopes(packageSources, `hooks/**/${presetExtensions}`)
+    ],
+    backendFiles: presetScopes(backend),
+    services: presetScopes(app, `services/**/${presetExtensions}`),
+    utilities: ["**/*.utils.ts", "**/*.constants.ts", "**/*.types.ts"],
+    types: presetScopes(app, "types/**"),
+    uiRoots,
+    webUiRoots,
+    ui: presetScopes(uiRoots, "**"),
+    generated: presetGeneratedFiles,
+    testFiles: presetTestFiles,
+    safetyFiles: [...appFiles, ...presetTestFiles],
+    components: presetScopes([...web, ...packageSources], "components/**/*.tsx"),
+    hooks: presetScopes([...web, ...packageSources], "hooks/**/*.ts"),
+    publicEntrypoints,
+    baseImports: presetBaseImports,
+    css: { ...webCss, ...kitCss },
+    registries: backendUnits.flatMap((unit) => presetRegistryFile(root, unit.source, unit.scope.effective.backend?.registry) ?? []),
+    ignores: skipped.map((key) => `${key}/**`),
+    outputs: [".", ...units.map((unit) => unit.key)].flatMap((key) => presetOutputFolders.map((folder) => key === "." ? `${folder}/**` : `${key}/${folder}/**`))
+  };
+}
+
+// src/preset/preset.ts
+var recipes = presetRecipes;
+var templates = presetTemplates;
+var externals = presetExternals;
+var require2 = createRequire(import.meta.url);
+function presetOptional(name, group) {
+  try {
+    return require2.resolve(name);
+  } catch {
+    throw new PresetError(`The ${group} group needs ${name}: bun add -d ${name}`);
+  }
+}
+var presetBuilders = {
+  style: styleGroup,
+  imports: importsGroup,
+  types: typesGroup,
+  layout: layoutGroup,
+  naming: namingGroup,
+  comments: commentsGroup,
+  basics: basicsGroup,
+  console: consoleGroup,
+  tests: testsGroup,
+  schemas: schemasGroup,
+  sql: sqlGroup,
+  orpc: orpcGroup,
+  react: reactGroup,
+  forms: formsGroup,
+  tanstack: tanstackGroup,
+  next: nextGroup,
+  expo: expoGroup,
+  backend: backendGroup,
+  tailwind: tailwindGroup,
+  shadcn: shadcnGroup,
+  limits: limitsGroup,
+  deny: denyGroup,
+  externals: externalsGroup
+};
+function presetLevel(scope) {
+  for (let current = scope;current; current = current.parent) {
+    if (current.folder.severity) {
+      return current.folder.severity;
+    }
+  }
+  return "error";
+}
+function presetSettings(scope, name) {
+  const settings = scope.effective[name];
+  if (name !== "console") {
+    return settings ?? null;
+  }
+  return settings ? null : { level: presetLevel(scope) };
+}
+function presetEmit(project, name, builder) {
+  const key = (scope) => JSON.stringify(presetSettings(scope, name));
+  const breaks = project.scopes.filter((scope) => scope.parent === null || key(scope) !== key(scope.parent));
+  const nearest = (owner) => breaks.filter((scope) => {
+    let current = scope.parent;
+    while (current && current !== owner && !breaks.includes(current)) {
+      current = current.parent;
+    }
+    return scope !== owner && current === owner;
+  });
+  return breaks.flatMap((owner) => {
+    const settings = presetSettings(owner, name);
+    if (!settings) {
+      return [];
+    }
+    const excluded = nearest(owner).map((scope) => `${scope.key}/**`);
+    return builder(project, settings, owner).flatMap((override) => {
+      const files = override.files.flatMap((glob) => presetIntersect(glob, owner.key));
+      if (files.length === 0 || !override.rules) {
+        return [];
+      }
+      return [
+        {
+          ...override,
+          files,
+          excludeFiles: [...override.excludeFiles ?? [], ...excluded],
+          rules: presetSeverity(override.rules, settings.level)
+        }
+      ];
+    });
+  });
+}
+function presetPlugins(project) {
+  const react = project.scopes.some((scope) => scope.effective.react);
+  const tailwinds = project.scopes.flatMap((scope) => scope.effective.tailwind ? [scope.effective.tailwind] : []);
+  const shadcns = project.scopes.flatMap((scope) => scope.effective.shadcn ? [scope.effective.shadcn] : []);
+  const tailwind = tailwinds.at(0);
+  const shadcn = shadcns.at(0);
+  if (new Set(tailwinds.map((settings2) => settings2.rem)).size > 1) {
+    throw new PresetError("tailwind.rem is project-wide: set the same value in every folder, or set it once on `.`.");
+  }
+  if (new Set(shadcns.map((settings2) => JSON.stringify([settings2.ui, settings2.components]))).size > 1) {
+    throw new PresetError("shadcn.ui and shadcn.components are project-wide: set the same values in every folder, or set them once on `.`.");
+  }
+  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/dillon-anti-slop") }
+  ];
+  const settings = {
+    react: { version: "19" },
+    "import/resolver": { node: { extensions: [".js", ".jsx", ".ts", ".tsx", ".mts", ".cts"] } }
+  };
+  if (react) {
+    jsPlugins.push({ name: "react-extra", specifier: presetOptional("eslint-plugin-react", "react") }, presetOptional("eslint-plugin-react-you-might-not-need-an-effect", "react"), presetOptional("eslint-plugin-svg-jsx", "react"));
+  }
+  if (!tailwind || Object.keys(project.css).length === 0) {
+    return { jsPlugins, settings };
+  }
+  jsPlugins.push(presetOptional("oxlint-tailwindcss", "tailwind"));
+  settings.tailwindcss = { rootFontSize: tailwind.rem };
+  if (shadcn) {
+    jsPlugins.push(presetOptional("@shadcn/lint", "shadcn"));
+    settings.shadcn = { ui: shadcn.ui, componentImports: shadcn.components };
+  }
+  return { jsPlugins, settings };
+}
+function preset(config) {
+  const project = presetProject(config);
+  const [root] = project.scopes;
+  const level = presetLevel(root);
+  const emitGroup = (name) => {
+    const builder = presetBuilders[name];
+    return builder ? presetEmit(project, name, builder) : [];
+  };
+  const severities = project.scopes.filter((scope) => scope.parent && presetLevel(scope) !== presetLevel(scope.parent)).toSorted((left, right) => left.depth - right.depth).map((scope) => ({ files: [`${scope.key}/**`], rules: presetSeverity(presetCommonRules, presetLevel(scope)) }));
+  const overrides = [...severities, ...presetGroupOrder.flatMap(emitGroup)];
+  for (const scope of project.scopes.toSorted((left, right) => left.depth - right.depth)) {
+    if (scope.folder.rules) {
+      overrides.push({ files: [scope.key === "." ? "**" : `${scope.key}/**`], rules: scope.folder.rules });
+    }
+  }
+  return {
+    options: { typeAware: true },
+    categories: { correctness: level },
+    plugins: ["typescript", "react", "react-perf", "jsx-a11y", "import", "unicorn", "promise", "vitest", "node", "oxc"],
+    ignorePatterns: [
+      "**/node_modules/**",
+      ...project.outputs,
+      ...project.nextWeb.length > 0 ? ["**/.next/**", "**/next-env.d.ts"] : [],
+      ...project.expoWeb.length > 0 ? ["**/.expo/**", "**/expo-env.d.ts"] : [],
+      ...project.generated,
+      ...project.ignores
+    ],
+    ...presetPlugins(project),
+    rules: presetSeverity(presetCommonRules, level),
+    overrides
+  };
+}
+export {
+  templates,
+  recipes,
+  preset,
+  externals,
+  PresetError
+};