oxlint-plugin-arch 0.12.5 → 0.13.0

package/dist/preset/preset.js

@@ -1,36 +1,21 @@
-// src/preset/preset.ts
 import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/preset/preset.ts
+import { globSync } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { matchesGlob as matchesGlob2, posix as posix9 } from "node:path";
 
 // src/preset/groups/backend.ts
-import { posix as posix3, resolve as resolve3 } from "node:path";
+import { posix as posix4, resolve as resolve4 } from "node:path";
 
 // src/preset/preset-detect.ts
-import { existsSync, readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { matchesGlob, posix as posix2, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { matchesGlob, posix as posix3, resolve as resolve3 } 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 },
-  effect: { schemas: true, effect: 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-effect.ts
+import { existsSync as existsSync2, readdirSync } from "node:fs";
+import { posix as posix2, resolve as resolve2 } from "node:path";
 
 // src/preset/preset.constants.ts
 var presetExtensions = "*.{ts,tsx,mts,cts}";
@@ -344,20 +329,22 @@ var presetGeneratedFiles = [
   "**/routeTree.gen.ts",
   "**/paraglide/**"
 ];
-var presetBuiltinFileRoles = [
-  "service",
-  "client",
-  "server",
-  "rsc",
-  "utils",
-  "action",
-  "query",
-  "types",
-  "constants",
-  "handler",
-  "test",
-  "spec"
+var presetLayoutFiles = [
+  "*.service.ts",
+  "*.client.ts",
+  "*.server.ts",
+  "*.rsc.ts",
+  "*.rsc.tsx",
+  "*.utils.ts",
+  "*.types.ts",
+  "*.constants.ts",
+  "*.handler.ts",
+  "*.test.ts",
+  "*.spec.ts",
+  "*-action.*.ts",
+  "*-query.*.ts"
 ];
+var presetLayoutFileName = /^!?[\w.*-]+$/;
 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._-]*$/;
@@ -441,7 +428,7 @@ var presetExternals = [
   "playwright-core"
 ];
 var presetGroupOptions = {
-  layout: { level: "error", services: undefined, hooks: undefined, components: undefined, suffixes: [], strict: false, operations: "flat", service: ["make{Domain}Service", "{Domain}Service"] },
+  layout: { level: "error", services: undefined, hooks: undefined, components: undefined, files: presetLayoutFiles, 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 },
@@ -457,17 +444,20 @@ var presetGroupOptions = {
   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 },
+  backend: { level: "error", exports: undefined, registry: undefined },
+  orpc: { level: "error", public: [], client: undefined },
   schemas: { level: "error" },
-  forms: { level: "error", resolver: "standardSchemaResolver" },
-  sql: { level: "error", sanitizers: ["escapeLikeWildcards"] },
-  effect: { level: "error", width: 160, exports: undefined, skip: undefined },
+  forms: { level: "error" },
+  sql: { level: "error" },
+  effect: { level: "error", code: true, width: 140, exports: undefined, skip: undefined, entries: [] },
   console: { level: "error" },
   deny: { level: "error", imports: {}, calls: {} },
-  externals: { level: "error", packages: presetExternals }
+  externals: { level: "error" }
 };
+var presetQueryWrites = ["insertInto", "updateTable", "deleteFrom", "mergeInto", "replaceInto", "dispatch", "send"];
 var presetFolderKeys = ["severity", "source", "services", "rules"];
+var presetFolderOnlyKeys = ["source", "services", "tanstack", "next", "expo", "backend", "console", "kit"];
+var presetFileSegment = /^(?!\.{1,2}$)[\w.@$[\]*-]+$/;
 var presetA11yRules = [
   "alt-text",
   "anchor-has-content",
@@ -507,6 +497,7 @@ var presetA11yRules = [
 ].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 presetTanstackRsc = { name: "@tanstack/react-start/rsc", message: "Render server components only in services/*.rsc.tsx files." };
 var presetBaseImports = [{ group: ["zod/v4", "zod/v4/**"], message: "Import from zod, not its transition entry point." }];
 var presetDetectFrameworks = [
   ["next", ["next", "vinext"]],
@@ -514,6 +505,13 @@ var presetDetectFrameworks = [
   ["expo", ["expo"]]
 ];
 var presetDetectDesktop = ["electrobun", "electron", "@tauri-apps/api", "@tauri-apps/cli"];
+var presetEffectImports = {
+  effect: "Import the module subpath, such as effect/Effect.",
+  zod: "Use effect/Schema.",
+  "ts-pattern": "Use effect/Match.",
+  dayjs: "Use effect/DateTime."
+};
+var presetRecipeMark = Symbol("recipe");
 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"];
@@ -525,15 +523,121 @@ 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 presetMigrationNumber = "^(\\d{4}-\\d{2}-\\d{2}(?:-\\d{2})*|\\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-recipes.ts
+var presetUi = { react: true, kit: true, tailwind: true };
+function presetRecipe(name, recipe) {
+  return { ...recipe, [presetRecipeMark]: name };
+}
+var presetRecipes = {
+  tanstack: presetRecipe("tanstack", {
+    react: true,
+    tanstack: true,
+    tailwind: true,
+    shadcn: true,
+    schemas: true,
+    forms: true
+  }),
+  next: presetRecipe("next", {
+    react: true,
+    next: true,
+    tailwind: true,
+    shadcn: true,
+    schemas: true,
+    forms: true
+  }),
+  expo: presetRecipe("expo", {
+    react: true,
+    expo: true,
+    schemas: true,
+    forms: true
+  }),
+  backend: presetRecipe("backend", {
+    backend: true,
+    schemas: true,
+    sql: true,
+    orpc: true,
+    layout: { strict: true }
+  }),
+  react: presetRecipe("react", {
+    react: true,
+    tailwind: true,
+    schemas: true
+  }),
+  desktop: presetRecipe("desktop", { console: true }),
+  library: presetRecipe("library", { schemas: true }),
+  effect: presetRecipe("effect", {
+    schemas: true,
+    effect: true,
+    deny: { imports: presetEffectImports }
+  }),
+  ui: presetRecipe("ui", presetUi),
+  kit: presetRecipe("kit", presetUi),
+  cli: presetRecipe("cli", { console: true })
+};
+var presetTemplates = {
+  monorepo: {
+    "apps/web": presetRecipes.tanstack,
+    "apps/server": presetRecipes.backend,
+    "packages/*": presetRecipes.library,
+    scripts: presetRecipes.cli
+  }
+};
+
 // src/preset/preset.utils.ts
-import { readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 import { posix, resolve } from "node:path";
 class PresetError extends Error {
 }
+async function presetEffectImport(load) {
+  try {
+    return await load;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+      return null;
+    }
+    throw error;
+  }
+}
+var presetEffectTsgo = await presetEffectImport(import("@effect/tsgo/oxlint-presets"));
+var presetEffectLinteffect = await presetEffectImport(import("@opsydyn/oxlint-effect"));
+var presetEffectRegexp = await presetEffectImport(import("eslint-plugin-regexp"));
+var presetEffectDeMorgan = await presetEffectImport(import("eslint-plugin-de-morgan"));
+var presetRequire = createRequire2(import.meta.url);
+function presetResolve(name) {
+  try {
+    return presetRequire.resolve(name);
+  } catch {
+    return;
+  }
+}
+function presetEffectStyle() {
+  const sonarjs = presetResolve("eslint-plugin-sonarjs");
+  const regexp = presetEffectRegexp ? presetResolve("eslint-plugin-regexp") : undefined;
+  const deMorgan = presetEffectDeMorgan ? presetResolve("eslint-plugin-de-morgan") : undefined;
+  const rules = { ...presetEffectRegexp?.configs["flat/recommended"].rules, ...presetEffectDeMorgan?.configs.recommended.rules };
+  if (sonarjs) {
+    rules["sonarjs/super-linear-regex"] = "error";
+  }
+  return {
+    rules,
+    jsPlugins: [
+      ...regexp ? [{ name: "regexp", specifier: regexp }] : [],
+      ...deMorgan ? [{ name: "de-morgan", specifier: deMorgan }] : [],
+      ...sonarjs ? [{ name: "sonarjs", specifier: sonarjs }] : []
+    ]
+  };
+}
+function presetEffectPackages() {
+  if (!presetEffectTsgo || !presetEffectLinteffect) {
+    throw new PresetError("The effect group needs @effect/tsgo and @opsydyn/oxlint-effect: bun add -d @effect/tsgo @opsydyn/oxlint-effect");
+  }
+  return { tsgo: presetEffectTsgo, linteffect: presetEffectLinteffect };
+}
 function presetScopes(roots, suffix = `**/${presetExtensions}`) {
   return roots.map((root) => root === "." ? suffix : `${root}/${suffix}`);
 }
@@ -596,6 +700,9 @@ function presetIntersect(glob, scope) {
   const matches = presetIntersectSegments(glob.split("/"), scope.split("/")).map((segments) => segments.join("/"));
   return [...new Set(matches)];
 }
+function presetGlobEscape(path) {
+  return path.replaceAll(/[[\]]/g, (bracket) => `[${bracket}]`);
+}
 function presetAliases(root, aliases) {
   return Object.fromEntries(Object.entries(aliases ?? {}).map(([alias, path]) => [alias.replace(/\/$/, ""), resolve(root, path)]));
 }
@@ -654,77 +761,328 @@ function presetIsFile(path) {
     return false;
   }
 }
+function presetSource(root, directory, configured) {
+  if (configured !== undefined) {
+    return posix.join(directory, configured);
+  }
+  return existsSync(resolve(root, directory, "src")) ? posix.join(directory, "src") : directory;
+}
+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 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;
+  }
+  const merged = presetMergeObject(base, top, 2);
+  const before = base.layout instanceof Object ? base.layout.files : undefined;
+  const after = top.layout instanceof Object ? top.layout.files : undefined;
+  return before && after && merged.layout instanceof Object ? { ...merged, layout: { ...merged.layout, files: [...before, ...after] } } : merged;
+}
+
+// src/preset/preset-effect.ts
+var presetEffectQueryWrites = Object.fromEntries(presetQueryWrites.map((name) => [name, "A queries file only reads; write in an actions file."]));
+var presetEffectWorkflowCalls = Object.fromEntries(["selectFrom", ...presetQueryWrites].map((name) => [name, "A workflow reaches data through its domain service, not the database."]));
+var presetEffectFrameworks = Object.fromEntries(["@tanstack/*", "react-dom", "react-dom/**", "next", "next/**", "vite"].map((name) => [name, "The server imports no web framework."]));
+var presetEffectRouters = ["@tanstack/react-router", "next/link", "next/navigation", "next/router", "expo-router"];
+var presetEffectErrors = ["Schema.TaggedError", "Schema.ErrorClass", "Data.TaggedError", "Data.Error"];
+var presetEffectContractNames = "^[a-z0-9]+(?:-[a-z0-9]+)*(?:[.]schemas|[.]admin[.]schemas|[.]contract|[.]admin[.]contract|[.]errors|[.]layer[.]types)[.]ts$";
+var presetEffectContractMessage = "Contract files use <d>.schemas.ts, <d>-<part>.schemas.ts, <d>.admin.schemas.ts, <d>.contract.ts, <d>.admin.contract.ts, <d>.errors.ts or <d>.layer.types.ts.";
+var presetEffectSchemaUses = {
+  namespaces: ["Schema"],
+  methods: ["Array", "Union", "Record", "Tuple"],
+  structural: ["Struct", "Array", "Union", "Record", "Tuple", "NullOr", "UndefinedOr", "optional", "TaggedStruct"]
+};
+function presetEffectExists(root, key) {
+  return (path) => {
+    const segments = path.split("/");
+    const wildcard = segments.findIndex((segment) => segment.includes("*"));
+    return existsSync2(resolve2(root, key, ...wildcard === -1 ? segments : segments.slice(0, wildcard)));
+  };
+}
+function presetEffectAt(root, key, value) {
+  const source = posix2.relative(key, presetSource(root, key, value.source)) || ".";
+  return (path) => source === "." ? path : posix2.join(source, path);
+}
+function presetEffectCode(value) {
+  return value instanceof Object && Boolean(value.effect) && !(value.effect instanceof Object && value.effect.code === false);
+}
+function presetEffectContract(root, key, value) {
+  if (!presetEffectCode(value) || presetEffectDomains(root, key, value)) {
+    return false;
+  }
+  const source = resolve2(root, presetSource(root, key, value.source));
+  return presetIsDirectory(source) && readdirSync(source).some((name) => presetIsFile(resolve2(source, name, `${name}.contract.ts`)));
+}
+function presetEffectDomains(root, key, value) {
+  return presetEffectCode(value) && presetIsDirectory(resolve2(root, presetSource(root, key, value.source), "domains"));
+}
+function presetEffectServers(root, merged, units) {
+  for (const unit of units) {
+    if (presetEffectDomains(root, unit[0], unit[1])) {
+      unit[1] = presetMerge({ ...presetRecipes.backend, services: "domains" }, unit[1]);
+      merged[unit[0]] = unit[1];
+    }
+  }
+}
+function presetEffectServerKeys(at) {
+  return {
+    [at(".")]: {
+      deny: { imports: { ...presetEffectFrameworks, "effect/Config": "Read config only in application/app.config.ts." } },
+      rules: {
+        "arch/types-declarations": ["error", { modules: true }],
+        "arch/types-inline": ["error", { variables: true, assertions: true, arguments: true }],
+        "arch/comments-code": ["error", { why: false, jsdoc: true, allow: ["^\\s*SAFETY: "] }]
+      }
+    },
+    [at("domains")]: {
+      layout: {
+        files: [
+          "*.actions.ts",
+          "*.queries.ts",
+          "*.layer.ts",
+          "*.workflows.ts",
+          "*.prompts.ts",
+          "*-*.driver.ts",
+          "!*.service.ts",
+          "!*.client.ts",
+          "!*.server.ts",
+          "!*.rsc.ts",
+          "!*.rsc.tsx",
+          "!*.utils.ts",
+          "!*.types.ts",
+          "!*.handler.ts",
+          "!*-action.*.ts",
+          "!*-query.*.ts"
+        ]
+      },
+      deny: { imports: { "../*/*.constants{,.ts}": "Another domain's constants stay in that domain." } }
+    },
+    [at("domains/*/*.actions.ts")]: {
+      limits: { lines: 1000 },
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Action[A-Z]\\w*"], types: true }] }
+    },
+    [at("domains/*/*.queries.ts")]: {
+      limits: { lines: 1000 },
+      deny: { calls: presetEffectQueryWrites, imports: { "./*.actions{,.ts}": "A queries file imports no actions." } },
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Query[A-Z]\\w*"], types: true }] }
+    },
+    [at("domains/*/*.constants.ts")]: { rules: { "arch/files-no-functions": ["error", { reexports: false }] } },
+    [at("domains/*/*.layer.ts")]: { rules: { "arch/effect-layer-file": "error" } },
+    [at("domains/*/*.driver.ts")]: { rules: { "arch/effect-layer-file": "error" } },
+    [at("domains/*/*.workflows.ts")]: {
+      deny: {
+        calls: presetEffectWorkflowCalls,
+        imports: {
+          "**/database": "A workflow reaches data through its domain service, not the database.",
+          "./*.{actions,queries}{,.ts}": "A workflow calls its domain service, not its own actions or queries."
+        }
+      }
+    },
+    [at("application/app.config.ts")]: { deny: { imports: { "effect/Config": false } } },
+    [at("application/app.ts")]: {
+      deny: { imports: { "**/domains/*/!(*.layer|*.layer.ts|*.workflows|*.workflows.ts)": "The application imports only layer and workflows files." } },
+      rules: { "arch/boundaries-imports": "off" }
+    },
+    [at("**/*.tsx")]: { rules: { "arch/files-restricted": ["error", { message: "Mail templates in mails/ are the only JSX on a server." }] } },
+    [at("mails/*.mail.tsx")]: { rules: { "arch/files-restricted": "off" } },
+    [at("rpc")]: { rules: { "arch/code-delegate": "error" } }
+  };
+}
+function presetEffectContractKeys(at) {
+  const schemas = {
+    rules: {
+      "arch/files-constants-only": ["error", { types: true, functions: true }],
+      "arch/files-no-functions": ["error", { reexports: false }],
+      "arch/types-imported-alias": "error",
+      "arch/schemas-single-use": ["error", presetEffectSchemaUses]
+    }
+  };
+  const noFunctions = { rules: { "arch/files-no-functions": "error" } };
+  return {
+    [at("*/*.ts")]: {
+      rules: {
+        "arch/naming-file": ["error", { pattern: presetEffectContractNames, message: presetEffectContractMessage }],
+        "arch/naming-folder": ["error", { singularize: "none", separators: [".", "-"] }],
+        "arch/files-exports": ["error", { stem: "folder", singularize: "trailing-s", patterns: ["{Domain}\\w*"] }]
+      }
+    },
+    [at("*/*.admin.*.ts")]: { rules: { "arch/files-exports": ["error", { stem: "folder", singularize: "trailing-s", patterns: ["Admin{Domain}\\w*"] }] } },
+    [at("*/*.schemas.ts")]: schemas,
+    [at("*/*.contract.ts")]: schemas,
+    [at("*/*.errors.ts")]: noFunctions,
+    [at("*/*.layer.types.ts")]: noFunctions,
+    [at("shared/*.ts")]: {
+      rules: {
+        "arch/naming-file": "off",
+        "arch/naming-folder": "off",
+        "arch/files-exports": "off",
+        "arch/files-no-functions": "off",
+        "arch/files-constants-only": ["error", { types: true, functions: true }]
+      }
+    },
+    [at("contract*.ts")]: {
+      rules: {
+        "arch/files-constants-only": ["error", { types: true, functions: true }],
+        "arch/types-imported-alias": "error",
+        "arch/schemas-single-use": ["error", presetEffectSchemaUses]
+      }
+    }
+  };
+}
+function presetEffectUnit(root, key, value) {
+  if (!value.effect) {
+    return {};
+  }
+  const at = presetEffectAt(root, key, value);
+  const contract = presetEffectContract(root, key, value);
+  const server = presetEffectDomains(root, key, value);
+  const keys = server || contract ? presetFilled(server ? presetEffectServerKeys(at) : presetEffectContractKeys(at), presetEffectExists(root, key)) : {};
+  const errors = Object.fromEntries(presetEffectErrors.map((name) => [name, "Tagged errors live in <d>.errors.ts."]));
+  const placement = server || contract ? { types: { placement: false } } : {};
+  return {
+    ...keys,
+    ".": presetMerge({ ...placement, deny: { imports: presetEffectImports, calls: errors } }, keys["."] ?? {}),
+    [at("**/*.errors.ts")]: { deny: { calls: Object.fromEntries(presetEffectErrors.map((name) => [name, false])) } }
+  };
+}
+function presetEffectFrontend(root, key, value) {
+  const at = presetEffectAt(root, key, value);
+  const exists = presetEffectExists(root, key);
+  const framework = [value.tanstack, value.next, value.expo].some(Boolean);
+  if (!value.effect || !value.react || framework || !["pages", "link.tsx", "link.ts"].some((path) => exists(at(path)))) {
+    return {};
+  }
+  const routers = presetEffectRouters.map((name) => ({ name, message: "Import the router through link.tsx." }));
+  const linkRule = { "no-restricted-imports": ["error", { patterns: presetBaseImports }] };
+  return presetFilled({
+    ".": { forms: true },
+    [at(".")]: {
+      deny: { imports: { "@orpc/*": "A frontend package takes its data functions as props, not from an rpc client." } },
+      rules: {
+        "arch/react-query-props": "error",
+        "no-restricted-imports": [
+          "error",
+          { paths: [{ ...routers[0], allowImportNames: ["ClientOnly"] }, ...routers.slice(1)], patterns: presetBaseImports }
+        ]
+      }
+    },
+    [at("link.tsx")]: { rules: linkRule },
+    [at("link.ts")]: { rules: linkRule },
+    [at("services/**/*.client.ts")]: { rules: { "arch/backend-service-functions": ["error", { frontend: true }] } }
+  }, exists);
+}
+function presetEffectWeb(root, key, value, contracts) {
+  const at = presetEffectAt(root, key, value);
+  if (contracts.length === 0 || !(value.tanstack || value.next)) {
+    return {};
+  }
+  const types = contracts.map((name) => ({ name, allowTypeImports: true, message: "The web imports the contract package as types only." }));
+  const rsc = { rules: { "no-restricted-imports": ["error", { paths: types, patterns: presetBaseImports }] } };
+  if (!value.tanstack) {
+    return { [at(".")]: rsc };
+  }
+  const services = value.services ?? "services";
+  return {
+    [at(".")]: { rules: { "no-restricted-imports": ["error", { paths: [...types, presetTanstackRsc], patterns: presetBaseImports }] } },
+    [at(`${services}/**/*.rsc.ts`)]: rsc,
+    [at(`${services}/**/*.rsc.tsx`)]: rsc
+  };
+}
+function presetEffectKit(root, key, value, units) {
+  if (!value.kit || !value.effect) {
+    return {};
+  }
+  const apps = units.filter(([other, folder]) => other !== key && !(folder instanceof Object && folder.kit));
+  const names = apps.flatMap(([other]) => presetManifest(root, other).name ?? []);
+  const message = "A UI kit imports no app package.";
+  return { ".": { deny: { imports: Object.fromEntries(names.flatMap((name) => [[name, message], [`${name}/**`, message]])) } } };
+}
+function presetEffectConventions(root, key, value, units) {
+  const contracts = units.flatMap(([other, folder]) => presetEffectContract(root, other, folder) ? presetManifest(root, other).name ?? [] : []);
+  return [
+    ...Object.entries(presetEffectUnit(root, key, value)),
+    ...Object.entries(presetEffectFrontend(root, key, value)),
+    ...Object.entries(presetEffectWeb(root, key, value, contracts)),
+    ...Object.entries(presetEffectKit(root, key, value, units))
+  ];
+}
 
 // src/preset/preset-detect.ts
 function presetDirectories(root, base, skip = presetDetectSkip) {
-  if (!presetIsDirectory(resolve2(root, base))) {
+  if (!presetIsDirectory(resolve3(root, base))) {
     return [];
   }
-  return readdirSync(resolve2(root, base)).filter((name) => !name.startsWith(".") && !skip.includes(name) && presetIsDirectory(resolve2(root, base, name))).map((name) => posix2.join(base, name));
+  return readdirSync2(resolve3(root, base)).filter((name) => !name.startsWith(".") && !skip.includes(name) && presetIsDirectory(resolve3(root, base, name))).map((name) => posix3.join(base, name));
 }
 var presetNamedSkip = ["node_modules"];
-function presetSource(root, directory, configured) {
-  if (configured !== undefined) {
-    return posix2.join(directory, configured);
-  }
-  return existsSync(resolve2(root, directory, "src")) ? posix2.join(directory, "src") : directory;
-}
 function presetRegistryFile(root, source, configured, services) {
   if (configured === false) {
     return;
   }
   const file = typeof configured === "string" ? configured : configured?.file;
   if (file !== undefined) {
-    return posix2.normalize(file);
+    return posix3.normalize(file);
   }
-  return [posix2.join(services, "service.ts"), ...presetRegistryFiles.map((path) => posix2.join(source, path))].find((path) => existsSync(resolve2(root, path)));
+  return [posix3.join(services, "service.ts"), ...presetRegistryFiles.map((path) => posix3.join(source, path))].find((path) => existsSync3(resolve3(root, path)));
 }
 function presetDomains(root, services) {
-  return presetDirectories(root, services, presetNamedSkip).map((path) => posix2.basename(path)).filter((name) => existsSync(resolve2(root, services, name, `${name}.service.ts`)));
+  return presetDirectories(root, services, presetNamedSkip).map((path) => posix3.basename(path)).filter((name) => existsSync3(resolve3(root, services, name, `${name}.service.ts`)));
 }
-function presetRecipe(root, directory, app, folder) {
+function presetRecipe2(root, directory, app, folder) {
   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, folder.source);
   const framework = presetDetectFrameworks.find(([, names]) => has(names))?.[0];
+  const frontend = presetIsDirectory(resolve3(root, source, "pages")) || ["link.tsx", "link.ts"].some((name) => existsSync3(resolve3(root, source, name)));
+  const react = has(["react"]) && (frontend || presetIsDirectory(resolve3(root, source, "components")));
+  const reactRecipe = app || frontend ? presetRecipes.react : presetRecipes.ui;
   const servicesFolder = presetServicesFolder(root, source, folder.services, app);
-  const services = resolve2(root, servicesFolder);
-  const entries = presetIsDirectory(services) ? readdirSync(services, { withFileTypes: true }) : [];
-  const folders = entries.filter((entry) => presetIsDirectory(resolve2(services, entry.name))).length;
+  const services = resolve3(root, servicesFolder);
+  const entries = presetIsDirectory(services) ? readdirSync2(services, { withFileTypes: true }) : [];
+  const folders = entries.filter((entry) => presetIsDirectory(resolve3(services, entry.name))).length;
   const flat = entries.filter((entry) => entry.isFile() && /\.tsx?$/.test(entry.name)).length > folders;
+  const backend = presetDomains(root, servicesFolder).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services));
+  const layout = flat ? { layout: { services: "flat" } } : {};
+  const style = has(["effect"]) ? { effect: { code: false } } : {};
+  const { deny: _bans, ...effect } = presetRecipes.effect;
   if (framework) {
-    return flat ? { ...presetRecipes[framework], layout: { services: "flat" } } : presetRecipes[framework];
+    return { ...presetRecipes[framework], ...layout, ...style };
   }
   if (has(presetDetectDesktop)) {
     return presetRecipes.desktop;
   }
-  if (presetDomains(root, servicesFolder).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services))) {
-    return presetRecipes.backend;
+  const reactLayout = frontend ? { ...reactRecipe, ...layout } : reactRecipe;
+  if (has(["effect"]) && react) {
+    return { ...reactLayout, ...style };
   }
-  if (has(["react"]) && presetIsDirectory(resolve2(root, source, "components"))) {
-    return app ? presetRecipes.react : presetRecipes.ui;
+  if (has(["effect"])) {
+    return backend || presetIsDirectory(resolve3(root, source, "domains")) ? { ...presetRecipes.backend, ...effect } : effect;
   }
-  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);
-    }
+  if (backend) {
+    return presetRecipes.backend;
   }
-  return merged;
-}
-function presetMerge(base, top) {
-  if (!(base instanceof Object) || !(top instanceof Object)) {
-    return top === true && base instanceof Object ? base : top;
+  if (react) {
+    return reactLayout;
   }
-  return presetMergeObject(base, top, 2);
+  return presetRecipes.library;
 }
 function presetImportTargets(value) {
   if (typeof value === "string") {
@@ -737,7 +1095,7 @@ function presetImportTargets(value) {
 }
 function presetSpecifiers(manifest, target, file = false) {
   const specifiers = Object.entries(manifest.imports ?? {}).flatMap(([key, value]) => presetImportTargets(value).flatMap((mapped) => {
-    const path = posix2.normalize(mapped);
+    const path = posix3.normalize(mapped);
     const parts = path.split("*");
     const keyParts = key.split("*");
     if (parts.length === 1 && keyParts.length === 1) {
@@ -766,23 +1124,17 @@ function presetOverlaps(left, right) {
 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 = posix2.relative(key, source) || ".";
-  const at = (path) => local === "." ? path : posix2.join(local, path);
-  const exists = (path) => existsSync(resolve2(root, key, path));
+  const local = posix3.relative(key, source) || ".";
+  const at = (path) => local === "." ? path : posix3.join(local, path);
+  const exists = (path) => existsSync3(resolve3(root, key, path));
   const configured = value.backend instanceof Object ? value.backend.registry : undefined;
   const servicesFolder = presetServicesFolder(root, source, value.services);
-  const servicesKey = posix2.relative(key, servicesFolder);
+  const servicesKey = posix3.relative(key, servicesFolder);
   const registryFile = presetRegistryFile(root, source, configured, servicesFolder);
-  const registry = registryFile === undefined ? undefined : posix2.relative(key, registryFile);
+  const registry = registryFile === undefined ? undefined : posix3.relative(key, registryFile);
   const services = presetSpecifiers(manifest, servicesKey);
   const message = "Use the service API, not another service’s operations.";
   const operations = Object.fromEntries(services.flatMap((prefix) => presetOperationImports.map((pattern) => [`${prefix}/${pattern}`, message])));
@@ -802,27 +1154,27 @@ function presetBackendConventions(root, key, value, denied) {
       ...presetDeny({ ...operations, ...Object.fromEntries(services.map((prefix) => [`${prefix}/*/*.service`, "Reach services through the registry."])) })
     }
   };
-  for (const domain of presetDirectories(root, servicesFolder, presetNamedSkip).map((path) => posix2.basename(path))) {
+  for (const domain of presetDirectories(root, servicesFolder, presetNamedSkip).map((path) => posix3.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[posix2.join(servicesKey, domain)] = presetDeny(Object.fromEntries(imports));
+    conventions[posix3.join(servicesKey, domain)] = presetDeny(Object.fromEntries(imports));
   }
   const testFolders = ["tests", "test"];
   for (const tests of testFolders) {
-    if (exists(posix2.join(tests, "kits"))) {
+    if (exists(posix3.join(tests, "kits"))) {
       conventions[tests] = presetDeny(Object.fromEntries(presetKitImports.map((pattern) => [pattern, "Import the kit file you need."])));
-      conventions[posix2.join(tests, "kits")] = { naming: { files: presetKitFiles } };
+      conventions[posix3.join(tests, "kits")] = { naming: { files: presetKitFiles } };
     }
   }
   const queue = ["."];
   while (queue.length > 0) {
     const folder = queue.shift() ?? ".";
-    for (const child of presetDirectories(root, posix2.join(key, folder)).map((path) => posix2.relative(key, path))) {
-      if (posix2.basename(child) === "migrations") {
+    for (const child of presetDirectories(root, posix3.join(key, folder)).map((path) => posix3.relative(key, path))) {
+      if (posix3.basename(child) === "migrations") {
         conventions[child] = { layout: false, naming: { files: presetMigrationFiles, unique: presetMigrationNumber } };
-      } else if (child.split("/").length < 8 && !testFolders.includes(posix2.basename(child))) {
+      } else if (child.split("/").length < 8 && !testFolders.includes(posix3.basename(child))) {
         queue.push(child);
       }
     }
@@ -830,9 +1182,9 @@ function presetBackendConventions(root, key, value, denied) {
   return presetFilled(conventions, exists);
 }
 function presetWebConventions(root, key, value, servers) {
-  const source = posix2.relative(key, presetSource(root, key, value.source)) || ".";
-  const at = (path) => source === "." ? path : posix2.join(source, path);
-  const exists = (path) => existsSync(resolve2(root, key, path));
+  const source = posix3.relative(key, presetSource(root, key, value.source)) || ".";
+  const at = (path) => source === "." ? path : posix3.join(source, path);
+  const exists = (path) => existsSync3(resolve3(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] : []);
@@ -852,8 +1204,8 @@ function presetWebConventions(root, key, value, servers) {
 }
 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)) {
+  const file = resolve3(root, "pnpm-workspace.yaml");
+  if (!existsSync3(file)) {
     return listed;
   }
   const patterns = [...listed];
@@ -876,7 +1228,7 @@ function presetWorkspacePatterns(root, manifest) {
   return patterns;
 }
 function presetWorkspaces(root, patterns) {
-  const clean = (pattern) => posix2.normalize(pattern.replace(/^\.\//, "")).replace(/\/$/, "");
+  const clean = (pattern) => posix3.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));
@@ -895,7 +1247,7 @@ function presetWorkspaces(root, patterns) {
       level.forEach((folder) => candidates.add(folder));
     }
   }
-  return [...candidates].filter((path) => matches(path, include) && !matches(path, exclude) && existsSync(resolve2(root, path, "package.json"))).toSorted();
+  return [...candidates].filter((path) => matches(path, include) && !matches(path, exclude) && existsSync3(resolve3(root, path, "package.json"))).toSorted();
 }
 function presetContains(key, path) {
   if (key === "." || key === path) {
@@ -921,18 +1273,22 @@ function presetDetect(root, folders) {
   };
   const patterns = presetWorkspacePatterns(root, manifest);
   const directories = presetWorkspaces(root, patterns);
-  const detected = Object.fromEntries(directories.map((directory) => [directory, presetRecipe(root, directory, !directory.startsWith("packages/"), configured(directory))]));
-  const rootRecipe = presetRecipe(root, ".", true, configured("."));
+  const detected = Object.fromEntries(directories.map((directory) => [directory, presetRecipe2(root, directory, !directory.startsWith("packages/"), configured(directory))]));
+  const rootRecipe = presetRecipe2(root, ".", true, configured("."));
   const single = Object.keys(manifest).length > 0 || rootRecipe !== presetRecipes.library;
   const rootApp = rootRecipe !== presetRecipes.library && presetSource(root, ".", configured(".").source) !== ".";
   if (patterns.length === 0 ? single : rootApp) {
     detected["."] = rootRecipe;
   }
-  if (existsSync(resolve2(root, "scripts")) && !directories.includes("scripts")) {
+  if (existsSync3(resolve3(root, "scripts")) && !directories.includes("scripts")) {
     detected.scripts = presetRecipes.cli;
   }
+  if (existsSync3(resolve3(root, ".agents"))) {
+    const { quotes, semicolons } = presetGroupOptions.style;
+    detected[".agents"] = { ...presetRecipes.cli, style: { quotes, semicolons } };
+  }
   const keys = Object.keys(folders);
-  const covered = (key) => keys.some((user) => user !== key && user !== "." && (key.startsWith(`${user}/`) || user.endsWith("/*") && posix2.dirname(key) === user.slice(0, -2)));
+  const covered = (key) => keys.some((user) => user !== key && user !== "." && (key.startsWith(`${user}/`) || user.endsWith("/*") && posix3.dirname(key) === user.slice(0, -2)));
   const merged = { ".": presetDeny(presetRootImports) };
   for (const [key, value] of Object.entries(detected)) {
     if (!covered(key)) {
@@ -940,7 +1296,9 @@ function presetDetect(root, folders) {
     }
   }
   for (const [key, value] of Object.entries(folders)) {
-    merged[key] = key in merged ? presetMerge(merged[key], value) : value;
+    const forced = value instanceof Object && presetRecipeMark in value;
+    const kept = forced && key === "." ? presetDeny(presetRootImports) : merged[key];
+    merged[key] = key in merged && (!forced || key === ".") ? presetMerge(kept, value) : value;
   }
   const length = (key) => key.split("/").length;
   const nested = (key) => Object.keys(merged).some((other) => other !== "." && length(other) < length(key) && presetContains(other, key));
@@ -954,6 +1312,7 @@ function presetDetect(root, folders) {
     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)]];
   });
+  presetEffectServers(root, merged, units);
   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(/\*$/, "**")));
@@ -973,11 +1332,11 @@ function presetDetect(root, folders) {
     }
     if (value.backend) {
       for (const [path, folder] of Object.entries(presetBackendConventions(root, key, value, denied))) {
-        add(path === "." ? key : posix2.join(key, path), folder);
+        add(path === "." ? key : posix3.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 : posix2.join(key, path), folder);
+        add(path === "." ? key : posix3.join(key, path), folder);
       }
     } else if ((value.kit || key.startsWith("packages/")) && !value.expo) {
       const own = Object.keys(presetManifest(root, key).imports ?? {});
@@ -985,6 +1344,9 @@ function presetDetect(root, folders) {
       const appImports = internals.filter((specifier) => !own.some((mine) => presetOverlaps(mine, specifier))).map((specifier) => [specifier, message]);
       add(key, presetDeny({ ...presetPackageImports, ...Object.fromEntries(appImports) }));
     }
+    for (const [path, folder] of presetEffectConventions(root, key, value, units)) {
+      add(path === "." ? key : posix3.join(key, path), folder);
+    }
   }
   return merged;
 }
@@ -1005,7 +1367,7 @@ var backendGroup = (project, settings) => {
   }
   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 : posix3.normalize(configured.file);
+  const file = configured.file === undefined ? undefined : posix4.normalize(configured.file);
   const registries = file === undefined ? backendUnits.flatMap((unit) => {
     const found = presetRegistryFile(project.root, unit.source, undefined, unit.services);
     return found ? [{ file: found, unit }] : [];
@@ -1015,8 +1377,8 @@ var backendGroup = (project, settings) => {
       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.services),
+      registry: resolve4(project.root, registry.file),
+      services: resolve4(project.root, registry.unit.services),
       skip: configured.skip ?? (file === undefined ? presetRegistrySkip : [])
     };
     if (configured.object !== undefined) {
@@ -1031,9 +1393,11 @@ var backendGroup = (project, settings) => {
 var basicsGroup = (project, settings) => {
   const trivial = { mode: "precise", async: false, callees: [] };
   const { appFiles, safetyFiles, ui, web } = project;
+  const nextEntries = presetScopes(project.nextWeb, "app/**/{layout,page,default}.tsx");
   return [
     ...settings.trivial ? [
-      presetOverride(appFiles, { "arch/code-trivial-functions": ["error", trivial] }, ui),
+      presetOverride(appFiles, { "arch/code-trivial-functions": ["error", trivial] }, [...ui, ...nextEntries]),
+      presetOverride(nextEntries, { "arch/code-trivial-functions": ["error", { ...trivial, defaults: false }] }, ui),
       presetOverride([...presetServiceScopes(project.serviceFolders, web, "**/*.{client,server,rsc}.ts"), ...presetServiceScopes(project.serviceFolders, web, "**/*.rsc.tsx")], { "arch/code-trivial-functions": ["error", { ...trivial, services: true }] }, ui)
     ] : [],
     ...settings.state ? [presetOverride(safetyFiles, { "arch/code-mutable-state": ["error", { kinds: ["let", "var"] }] }, ui)] : [],
@@ -1054,37 +1418,93 @@ var consoleGroup = () => [presetOverride([`**/${presetExtensions}`], { "no-conso
 
 // src/preset/groups/deny.ts
 var denyGroup = (project, settings) => {
-  const { imports, calls } = settings;
+  const kept = (entries) => Object.fromEntries(Object.entries(entries).filter((entry) => entry[1] !== false));
+  const imports = kept(settings.imports);
+  const calls = kept(settings.calls);
   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 reads = Object.fromEntries(presetQueryWrites.map((name) => [name, "Query files only read; move writes to an action."]));
+  for (const unit of project.units.filter((item) => item.kind === "backend")) {
     const files = [
       ...presetServiceScopes(project.serviceFolders, [unit.source], "**/*-query.*.ts"),
       ...presetServiceScopes(project.serviceFolders, project.operations.filter((path) => path === unit.source), "*/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 } }] }));
+    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: kept({ ...reads, ...settings.calls }) }] }));
   }
   return overrides;
 };
 
 // src/preset/groups/effect.ts
+var effectOff = {
+  "linteffect/no-effect-fn-generator": "off",
+  "linteffect/prefer-extracted-concept": "off",
+  "linteffect/no-clever-effect-expression": "off",
+  "linteffect/no-mixed-pillar-function": "off",
+  "linteffect/no-piped-yield-in-gen": "off",
+  "linteffect/no-domain-logic-in-conditional": "off",
+  "linteffect/prefer-pipe-for-behavior": "off",
+  "linteffect/no-ternary": "off",
+  "linteffect/no-effect-as": "off",
+  "linteffect/no-namespace-effect-import": "off",
+  "linteffect/no-manual-effect-channels": "off",
+  "linteffect/no-or-die-outside-boundary": "off",
+  "linteffect/no-call-tower": "off",
+  "linteffect/no-pipe-ladder": "off",
+  "linteffect/no-nested-effect-gen": "off",
+  "linteffect/no-branch-in-object": "off",
+  "linteffect/no-magic-domain-string": "off",
+  "linteffect/no-return-in-arrow": "off",
+  "linteffect/no-effect-succeed-variable": "off",
+  "linteffect/no-match-effect-branch": "off"
+};
+var effectEntryOff = {
+  "effecttsgo/strict-effect-provide": "off",
+  "linteffect/no-inline-runtime-provide": "off",
+  "linteffect/no-inline-layer-provide-in-program": "off"
+};
+var effectTestOff = {
+  ...effectEntryOff,
+  "linteffect/no-string-sentinel-return": "off",
+  "linteffect/no-effect-never": "off",
+  "linteffect/no-gen-for-mapping": "off",
+  "linteffect/no-adhoc-domain-error": "off"
+};
 var effectGroup = (project, settings) => {
   const files = [`**/${presetExtensions}`];
   const max = settings.width;
+  const style = presetOverride(files, {
+    "typescript/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+    "eslint-js/max-len": ["error", { code: max, ignoreUrls: true, ignoreComments: true, ignoreRegExpLiterals: true }],
+    ...presetEffectStyle().rules
+  });
+  if (!settings.code) {
+    return [style];
+  }
+  const { tsgo, linteffect } = presetEffectPackages();
+  const tsgoRules = [tsgo.correctness, tsgo.antipattern, tsgo.effectNative, tsgo.style].flatMap((config) => Object.keys(config.rules ?? {}));
   return [
+    style,
+    presetOverride(files, {
+      ...Object.fromEntries(tsgoRules.map((rule) => [rule, "error"])),
+      ...linteffect.recommended.rules,
+      ...effectOff
+    }),
+    presetOverride(project.testFiles, effectTestOff),
+    ...settings.entries.length > 0 ? [presetOverride(settings.entries, effectEntryOff)] : [],
     presetOverride(files, {
       "arch/code-trivial-functions": "off",
       "arch/code-branch-once": "error",
+      "arch/code-object-params": ["error", { all: true, services: true }],
+      "arch/code-switch": ["error", { message: "Branch with Match." }],
+      "arch/naming-exports": "off",
       "arch/code-function-nesting": ["error", { max: 4 }],
       "arch/code-inline": ["error", { max, nesting: 2, keep: ["^[A-Z]", "^layer"], allow: "^(?:decode|encode)[A-Z]", services: ["of"] }],
       "arch/code-yield-argument": "error",
+      "arch/effect-layers": "error",
+      "arch/effect-merge-pipe": "error",
+      "arch/effect-values-first": "error",
       "arch/layout-arrow-body": ["error", { max }],
       "arch/layout-call-arguments": ["error", { split: false, hug: { max }, join: { max, nesting: 2, keep: ["Layer.mergeAll"] } }],
       "arch/layout-call-depth": ["error", { max: 2 }],
@@ -1143,17 +1563,17 @@ var expoGroup = (project, settings) => {
 };
 
 // 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 }] })
+var externalsGroup = () => [
+  presetOverride(["**/{vite,next}.config.{ts,mts,cts,js,mjs,cjs}"], { "arch/files-externals": ["error", { packages: presetExternals }] })
 ];
 
 // src/preset/groups/forms.ts
-var formsGroup = (project, settings) => [
-  presetOverride(project.reactFiles, { "arch/code-paired-call": ["error", { when: "useForm", require: settings.resolver }] }, project.ui)
+var formsGroup = (project) => [
+  presetOverride(project.reactFiles, { "arch/code-paired-call": ["error", { when: "useForm", require: "standardSchemaResolver" }] }, project.ui)
 ];
 
 // src/preset/groups/imports.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 function importsPackageNames(project, kinds) {
   return project.units.flatMap((unit) => {
     const name = kinds.includes(unit.kind) ? presetPackageName(project.root, unit.key) : undefined;
@@ -1191,7 +1611,7 @@ var importsGroup = (project, settings) => {
   if (!settings.boundaries) {
     return overrides;
   }
-  const absolute = (paths) => paths.map((path) => resolve4(project.root, path));
+  const absolute = (paths) => paths.map((path) => resolve5(project.root, path));
   overrides.push(presetOverride([...project.appFiles, ...presetScopes(project.packages, `**/${presetExtensions}`)], {
     "arch/boundaries-imports": [
       "error",
@@ -1199,7 +1619,7 @@ var importsGroup = (project, settings) => {
         web: absolute(project.web),
         backend: absolute(project.backend),
         packages: absolute(project.packages),
-        roles: project.suffixes,
+        roles: project.fileKinds,
         services: absolute([...project.web, ...project.backend].map((source) => project.serviceFolders[source])),
         portable: true,
         aliases: presetAliases(project.root, settings.aliases),
@@ -1213,18 +1633,18 @@ var importsGroup = (project, settings) => {
 };
 
 // src/preset/groups/layout.ts
-import { posix as posix4 } from "node:path";
+import { posix as posix5 } from "node:path";
 var layoutGroup = (project, settings) => {
   const { web, nextWeb, serviceRoots, app, services, utilities, ui, testFiles, layouts, operations } = project;
   const folderOperations = presetServiceScopes(project.serviceFolders, operations, "*/{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 names = settings.files.map((name) => name.split("*").map((part) => part.replaceAll(".", "[.]")).join("[a-z0-9]+(?:-[a-z0-9]+)*"));
+  const kindFiles = project.fileKinds.map((kind) => `**/*.${kind}.ts`);
   const frontendEntries = [...presetServiceScopes(project.serviceFolders, web, "**/*.{client,server,rsc}.ts"), ...presetServiceScopes(project.serviceFolders, web, "**/*.rsc.tsx")];
-  const ungroupedWeb = web.filter((path) => !layouts.some((scope) => scope.path === posix4.join(path, "components")));
+  const ungroupedWeb = web.filter((path) => !layouts.some((scope) => scope.path === posix5.join(path, "components")));
   return [
     ...layouts.flatMap(({ path, folder, mode }) => {
-      const folders = folder === "services" && operations.some((source) => posix4.join(source, "services") === path);
+      const folders = folder === "services" && operations.some((source) => posix5.join(source, "services") === path);
       const registries = folder === "services" ? project.registries : [];
       const restricted = presetOverride(mode === "flat" ? [`${path}/*/**/${presetExtensions}`] : [`${path}/${presetExtensions}`, `${path}/*/*/**/${presetExtensions}`], {
         "arch/files-restricted": [
@@ -1247,11 +1667,16 @@ var layoutGroup = (project, settings) => {
         "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.`
+            pattern: `^(?:${names.join("|")})$`,
+            message: `Domain files use one of: ${settings.files.join(", ")}. Add a name to layout.files.`
           }
         ]
-      }, ["**/*-{action,query}.*.ts", ...testFiles, ...registries]);
+      }, [
+        ...settings.files.includes("*-action.*.ts") ? ["**/*-action.*.ts"] : [],
+        ...settings.files.includes("*-query.*.ts") ? ["**/*-query.*.ts"] : [],
+        ...testFiles,
+        ...registries
+      ]);
       return [...domain, strict];
     }),
     presetOverride(presetScopes(ungroupedWeb, `components/*/*/**/${presetExtensions}`), { "arch/files-restricted": ["error", { message: "Components allow one group folder." }] }, ui),
@@ -1268,16 +1693,16 @@ var layoutGroup = (project, settings) => {
       "**/*.{client,server,rsc,utils,constants}.ts",
       "**/*.rsc.tsx",
       ...presetServiceScopes(project.serviceFolders, nextWeb, "**/*.action.ts"),
-      ...conceptFiles,
+      ...kindFiles,
       ...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]),
+    }, [...utilities, ...testFiles, ...kindFiles]),
     presetOverride(frontendEntries, { "arch/backend-service-functions": ["error", { frontend: true }] }, testFiles),
-    ...conceptFiles.map((pattern) => presetOverride(presetServiceScopes(project.serviceFolders, app, pattern), {
+    ...kindFiles.map((pattern) => presetOverride(presetServiceScopes(project.serviceFolders, app, pattern), {
       "arch/backend-service-functions": "off",
       "arch/naming-exports": ["error", { stem: "full-basename", scope: "functions" }]
     }, testFiles)),
@@ -1455,7 +1880,7 @@ var nextGroup = (project, settings) => {
 // 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 }]
+    "arch/backend-orpc-output": ["error", { handler: "handler", output: "output" }]
   })
 ] : [];
 
@@ -1552,13 +1977,8 @@ var shadcnGroup = (project) => {
 };
 
 // src/preset/groups/sql.ts
-var sqlGroup = (project, settings) => [
-  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), {
-    "arch/backend-sql-like": [
-      "error",
-      { methods: ["like", "ilike"], operators: ["where"], sanitizers: settings.sanitizers, bindings: true }
-    ]
-  })
+var sqlGroup = (project) => [
+  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), { "arch/backend-sql-like": "error" })
 ];
 
 // src/preset/groups/style.ts
@@ -1610,7 +2030,7 @@ var tanstackGroup = (project, settings) => {
       "no-restricted-imports": [
         "error",
         {
-          paths: [{ name: "@tanstack/react-start/rsc", message: "Render server components only in services/*.rsc.tsx files." }],
+          paths: [presetTanstackRsc],
           patterns: project.baseImports
         }
       ]
@@ -1646,7 +2066,7 @@ function optionsPatternsTest(patterns, value) {
 function optionsGlob(pattern) {
   const negated = [];
   const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
-    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\?{}]/g, "\\$&").replaceAll("*", "[^/]*")).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)}$`);
@@ -1762,12 +2182,12 @@ var typesGroup = (project, settings) => {
 };
 
 // src/preset/preset-folders.ts
-import { existsSync as existsSync3, readdirSync as readdirSync4, realpathSync as realpathSync2 } from "node:fs";
-import { posix as posix7, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync5, realpathSync as realpathSync2 } from "node:fs";
+import { posix as posix8, resolve as resolve8 } from "node:path";
 
 // src/preset/preset-stylesheet.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync } from "node:fs";
-import { posix as posix5, resolve as resolve5 } from "node:path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, realpathSync } from "node:fs";
+import { posix as posix6, resolve as resolve6 } 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);
@@ -1778,15 +2198,15 @@ function presetStylesheet(root, directory) {
   const visited = new Set;
   while (queue.length > 0) {
     const folder = queue.shift() ?? directory;
-    const real = realpathSync(resolve5(root, folder));
+    const real = realpathSync(resolve6(root, folder));
     if (visited.has(real)) {
       continue;
     }
     visited.add(real);
-    for (const name of readdirSync2(resolve5(root, folder))) {
-      const path = posix5.join(folder, name);
-      const full = resolve5(root, path);
-      const depth = posix5.relative(directory, path).split("/").length;
+    for (const name of readdirSync3(resolve6(root, folder))) {
+      const path = posix6.join(folder, name);
+      const full = resolve6(root, path);
+      const depth = posix6.relative(directory, path).split("/").length;
       if (presetIsDirectory(full)) {
         if (!name.startsWith(".") && !presetDetectSkip.includes(name) && depth < 8) {
           queue.push(path);
@@ -1797,15 +2217,15 @@ function presetStylesheet(root, directory) {
     }
   }
   const rank = (path) => {
-    const index = presetStylesheetNames.indexOf(posix5.basename(path, ".css"));
+    const index = presetStylesheetNames.indexOf(posix6.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 posix6, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync4, readdirSync as readdirSync4 } from "node:fs";
+import { posix as posix7, resolve as resolve7 } from "node:path";
 var presetFrameworks = ["tanstack", "next", "expo"];
 var presetKindGroups = [...presetFrameworks, "backend", "console"];
 function presetUnitSource(root, key, kind, source) {
@@ -1813,9 +2233,9 @@ function presetUnitSource(root, key, kind, source) {
     if (source !== "." && !source.split("/").every((segment) => presetLiteralSegment.test(segment))) {
       throw new PresetError(`Folder \`${key}\` source must be \`.\` or a literal relative path.`);
     }
-    return posix6.join(key, source);
+    return posix7.join(key, source);
   }
-  return kind === "console" || !existsSync2(resolve6(root, key, "src")) ? key : posix6.join(key, "src");
+  return kind === "console" || !existsSync4(resolve7(root, key, "src")) ? key : posix7.join(key, "src");
 }
 function presetSets(folder, name) {
   return folder[name] !== undefined && folder[name] !== false;
@@ -1844,10 +2264,10 @@ function presetHasManifest(root, key) {
     return false;
   }
   if (!key.endsWith("/*")) {
-    return existsSync2(resolve6(root, key, "package.json"));
+    return existsSync4(resolve7(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")));
+  const base = resolve7(root, key.slice(0, -2));
+  return presetIsDirectory(base) && readdirSync4(base).some((name) => existsSync4(resolve7(base, name, "package.json")));
 }
 function presetUnit(root, key, scope) {
   const { effective } = scope;
@@ -1896,20 +2316,24 @@ function presetUnits(root, scopes, ignored) {
       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) => posix6.join(base, name)).filter((key) => !explicit.has(key) && !ignored.has(key)).map((key) => presetUnit(root, key, scope));
+    return readdirSync4(resolve7(root, base)).filter((name) => !name.startsWith(".") && presetIsDirectory(resolve7(root, base, name))).map((name) => posix7.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) {
+function presetPortableKey(key) {
   const portable = key.replaceAll("\\", "/");
-  if (!portable.trim() || posix7.isAbsolute(portable) || /^[a-z]:/i.test(portable)) {
+  if (!portable.trim() || posix8.isAbsolute(portable) || /^[a-z]:/i.test(portable)) {
     throw new PresetError(`Folder keys must be project-relative paths: ${key}`);
   }
-  const normalized = posix7.normalize(portable).replace(/\/$/, "");
+  const normalized = posix8.normalize(portable).replace(/\/$/, "");
   if (normalized === ".." || normalized.startsWith("../")) {
     throw new PresetError(`Folder keys must stay inside the project: ${key}`);
   }
+  return normalized;
+}
+function presetNormalizeKey(key) {
+  const normalized = presetPortableKey(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}`);
@@ -1919,6 +2343,25 @@ function presetNormalizeKey(key) {
   }
   return normalized;
 }
+function presetBraces(key) {
+  const match = /\{([^{}]*)\}/.exec(key);
+  if (!match) {
+    return [key];
+  }
+  return match[1].split(",").flatMap((option) => presetBraces(`${key.slice(0, match.index)}${option}${key.slice(match.index + match[0].length)}`));
+}
+function presetIsFileKey(root, key) {
+  const name = key.split("/").at(-1) ?? "";
+  const pattern = key.includes("*");
+  if (!pattern && !existsSync5(resolve8(root, key)) && /[^.]\.[^.]+$/.test(name)) {
+    throw new PresetError(`File \`${key}\` does not exist.`);
+  }
+  const file = pattern ? name !== "*" && name.includes(".") : presetIsFile(resolve8(root, key));
+  if (file && !key.split("/").every((segment) => presetFileSegment.test(segment))) {
+    throw new PresetError(`File keys hold letters, digits, \`._-@$[]\` and \`*\` wildcards: ${key}`);
+  }
+  return file;
+}
 function presetMatches(pattern, path) {
   return pattern.every((segment, index) => segment === "*" || segment === path[index]);
 }
@@ -1954,13 +2397,28 @@ function presetGroupValue(name, value, inherited, severity) {
   return { ...base, ...merged, level: severity ?? base.level };
 }
 function presetDenyEntries(inherited, changes) {
-  return Object.fromEntries(Object.entries({ ...inherited, ...changes }).flatMap(([key, message]) => {
+  return Object.fromEntries(Object.entries({ ...inherited, ...changes }).map(([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]];
+    return [key, message];
   }));
 }
+function presetLayoutNames(inherited, entries) {
+  if (!Array.isArray(entries) || !entries.every((entry) => typeof entry === "string" && presetLayoutFileName.test(entry))) {
+    throw new PresetError("layout.files takes file names such as `*.prompts.ts`; `!*.utils.ts` removes one.");
+  }
+  const names = [...inherited];
+  for (const entry of entries) {
+    const index = names.indexOf(entry.startsWith("!") ? entry.slice(1) : entry);
+    if (entry.startsWith("!") && index !== -1) {
+      names.splice(index, 1);
+    } else if (!entry.startsWith("!") && index === -1) {
+      names.push(entry);
+    }
+  }
+  return names;
+}
 function presetEffective(folder, parent) {
   const resolveGroup = (name) => {
     const defaults = presetDefaultGroups.includes(name) ? presetGroupOptions[name] : null;
@@ -1976,6 +2434,11 @@ function presetEffective(folder, parent) {
       calls: presetDenyEntries(inherited.calls, deny.calls)
     };
   }
+  const layout = folder.layout;
+  if (effective.layout && layout instanceof Object && layout.files !== undefined) {
+    const inherited = (parent ? parent.layout?.files : null) ?? presetGroupOptions.layout.files;
+    effective.layout = { ...effective.layout, files: presetLayoutNames(inherited, layout.files) };
+  }
   return effective;
 }
 function presetFolder(key, value) {
@@ -2006,7 +2469,7 @@ function presetScopesTree(root, folders) {
   }
   for (const key of keys) {
     const base = key.endsWith("/*") ? key.slice(0, -2) : key;
-    if (!existsSync3(resolve7(root, base))) {
+    if (!existsSync5(resolve8(root, base))) {
       throw new PresetError(`Folder \`${key}\` does not exist.`);
     }
   }
@@ -2038,14 +2501,26 @@ function presetScopesTree(root, folders) {
   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);
+  const given = resolve8(config.root ?? process.cwd());
+  const root = existsSync5(given) ? realpathSync2(given) : given;
+  const expanded = Object.entries(config.folders ?? {}).flatMap(([key, value]) => presetBraces(key).map((path) => [presetPortableKey(path), value, key.includes("{")]));
+  const files = expanded.filter(([key]) => presetIsFileKey(root, key));
+  const listed = expanded.filter((entry) => !files.includes(entry)).map(([key, value, fromList]) => [presetNormalizeKey(key), value, fromList]);
+  const twice = listed.find(([key, , fromList], index) => listed.some(([other, , otherFromList], at) => at < index && other === key && !fromList && !otherFromList));
   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 configured = {};
+  for (const [key, value] of listed) {
+    configured[key] = key in configured ? presetMerge(configured[key], value) : value;
+  }
+  const detected = config.detect === false ? configured : presetDetect(root, configured);
+  const conventions = Object.entries(detected).filter(([key]) => !(key in configured) && presetIsFileKey(root, key));
+  const folders = Object.fromEntries(Object.entries(detected).filter(([key]) => !conventions.some(([other]) => other === key)));
+  const fileEntries = [
+    ...conventions.filter(([key]) => !files.some(([other]) => other === key)),
+    ...files.map(([key, value]) => [key, key in detected ? presetMerge(detected[key], value) : value])
+  ];
   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));
@@ -2053,6 +2528,22 @@ function presetProject(config) {
   if (dead) {
     throw new PresetError(`Folder \`${dead.key}\` sits inside the skipped folder \`${dead.parent?.key}\`.`);
   }
+  const fileKeys = fileEntries.flatMap(([key, value]) => {
+    if (value === false) {
+      return [];
+    }
+    const folder = presetFolder(key, value);
+    const option = Object.keys(folder).find((name) => presetFolderOnlyKeys.includes(name));
+    if (option) {
+      throw new PresetError(`Set \`${option}\` on a folder, not on \`${key}\`.`);
+    }
+    if (Object(folder.layout).operations !== undefined) {
+      throw new PresetError(`Set layout.operations on an app or package folder, not on \`${key}\`.`);
+    }
+    const pattern = presetGlobEscape(key);
+    const reached = live.filter((scope) => presetIntersect(pattern, scope.key).length > 0).map((scope) => ({ key: scope.key, parent: scope, depth: scope.depth, folder, effective: presetEffective(folder, scope.effective) }));
+    return [{ pattern, folder, scopes: reached }];
+  });
   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);
@@ -2063,10 +2554,6 @@ function presetProject(config) {
   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);
@@ -2080,19 +2567,15 @@ function presetProject(config) {
   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 fileKinds = [
+    ...new Set([...effective, ...fileKeys.flatMap((fileKey) => fileKey.scopes.map((scope) => scope.effective))].flatMap((groups) => (groups.layout?.files ?? []).flatMap((name) => presetLayoutFiles.includes(name) ? [] : /^\*\.([a-z][a-z0-9-]*)\.ts$/.exec(name)?.[1] ?? [])))
+  ];
   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) => posix7.join(unit.services, unit.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts")) : [client];
+  const rpcClients = client === undefined ? webUnits.map((unit) => posix8.join(unit.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) => posix7.join(path, "components/ui")), ...kitUnits.map((unit) => unit.source)])];
+  const uiRoots = [...new Set([...web.map((path) => posix8.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;
@@ -2100,7 +2583,7 @@ function presetProject(config) {
       return;
     }
     const css = tailwind.css ?? presetStylesheet(root, unit.key);
-    return css === undefined ? undefined : resolve7(root, css);
+    return css === undefined ? undefined : resolve8(root, css);
   };
   const webCss = Object.fromEntries(webUnits.flatMap((unit) => {
     const css = stylesheet(unit);
@@ -2134,21 +2617,21 @@ function presetProject(config) {
       return [key];
     }
     const base = key.slice(0, -2);
-    return readdirSync4(resolve7(root, base)).filter((name) => presetIsDirectory(resolve7(root, base, name))).map((name) => posix7.join(base, name)).filter((path) => !live.some((scope) => scope.key === path));
+    return readdirSync5(resolve8(root, base)).filter((name) => presetIsDirectory(resolve8(root, base, name))).map((name) => posix8.join(base, name)).filter((path) => !live.some((scope) => scope.key === path));
   });
   return {
     root,
     serviceFolders,
     scopes: live,
+    fileKeys,
     units,
-    suffixes,
+    fileKinds,
     colocated: listOf(effective.map((groups) => groups.types?.colocated)),
     orpc: {
-      public: publicProcedures.length > 0 ? publicProcedures : backendUnits.map((unit) => posix7.join(unit.source, "rpc/api")).filter((path) => existsSync3(resolve7(root, path))).map((path) => `${path}/**`),
-      composers: listOf(orpcScopes.map((settings) => settings.composers)),
+      public: publicProcedures.length > 0 ? publicProcedures : backendUnits.map((unit) => posix8.join(unit.source, "rpc/api")).filter((path) => existsSync5(resolve8(root, path))).map((path) => `${path}/**`),
       client: client ?? ""
     },
-    layouts: units.flatMap((unit) => Object.entries(unit.layout).map(([folder, mode]) => ({ path: folder === "services" ? unit.services : posix7.join(unit.source, folder), folder, mode }))),
+    layouts: units.flatMap((unit) => Object.entries(unit.layout).map(([folder, mode]) => ({ path: folder === "services" ? unit.services : posix8.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),
@@ -2186,7 +2669,7 @@ function presetProject(config) {
     baseImports: presetBaseImports,
     css: { ...webCss, ...kitCss },
     registries: backendUnits.flatMap((unit) => presetRegistryFile(root, unit.source, unit.scope.effective.backend?.registry, unit.services) ?? []),
-    ignores: skipped.map((key) => `${key}/**`),
+    ignores: [...skipped.map((key) => `${key}/**`), ...fileEntries.flatMap(([key, value]) => value === false ? [presetGlobEscape(key)] : [])],
     outputs: [".", ...units.map((unit) => unit.key)].flatMap((key) => presetOutputFolders.map((folder) => key === "." ? `${folder}/**` : `${key}/${folder}/**`))
   };
 }
@@ -2195,7 +2678,7 @@ function presetProject(config) {
 var recipes = presetRecipes;
 var templates = presetTemplates;
 var externals = presetExternals;
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire3(import.meta.url);
 function presetOptional(name, group) {
   try {
     return require2.resolve(name);
@@ -2244,40 +2727,70 @@ function presetSettings(scope, name) {
   }
   return settings ? null : { level: presetLevel(scope) };
 }
-function presetEmit(project, name, builder) {
+function presetKeyFiles(fileKey, scope, globs, expand) {
+  const scoped = globs.flatMap((glob) => presetIntersect(glob, scope.key));
+  const within = (glob) => {
+    const prefix = glob.slice(0, -`**/${presetExtensions}`.length).replace(/\/$/, "");
+    return glob.endsWith(`**/${presetExtensions}`) && !/[*?{[]/.test(prefix) && (prefix === "" || fileKey.pattern.startsWith(`${prefix}/`)) && /\.(?:ts|tsx|mts|cts)$/.test(fileKey.pattern);
+  };
+  return scoped.some(within) ? presetIntersect(fileKey.pattern, scope.key) : expand(fileKey).filter((path) => scoped.some((glob) => matchesGlob2(path, glob))).map(presetGlobEscape);
+}
+function presetEmit(project, name, builder, expand) {
   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)) {
+  const region = (scope) => {
+    let current = scope;
+    while (current && !breaks.includes(current)) {
       current = current.parent;
     }
-    return scope !== owner && current === owner;
-  });
+    return current;
+  };
+  const keyed = project.fileKeys.flatMap((fileKey) => fileKey.scopes.filter((scope) => scope.parent && key(scope) !== key(scope.parent)).map((scope) => ({ owner: region(scope.parent), fileKey, scope })));
   return breaks.flatMap((owner) => {
     const settings = presetSettings(owner, name);
     if (!settings) {
       return [];
     }
-    const excluded = nearest(owner).map((scope) => `${scope.key}/**`);
+    const nested = breaks.filter((scope) => scope !== owner && region(scope.parent) === owner).map((scope) => `${scope.key}/**`);
+    const owned = keyed.filter((entry) => entry.owner === owner);
     return builder(project, settings, owner).flatMap((override) => {
       const files = override.files.flatMap((glob) => presetIntersect(glob, owner.key));
       if (files.length === 0 || !override.rules) {
         return [];
       }
+      const replaced = owned.flatMap((entry) => presetKeyFiles(entry.fileKey, entry.scope, override.files, expand));
       return [
         {
           ...override,
           files,
-          excludeFiles: [...override.excludeFiles ?? [], ...excluded],
+          excludeFiles: [...override.excludeFiles ?? [], ...nested, ...replaced],
           rules: presetSeverity(override.rules, settings.level)
         }
       ];
     });
   });
 }
+function presetFileEmit(project, name, builder, expand) {
+  return project.fileKeys.flatMap((fileKey) => fileKey.scopes.flatMap((scope) => {
+    const owner = scope.parent;
+    const settings = presetSettings(scope, name);
+    if (!owner || !settings || JSON.stringify(presetSettings(owner, name)) === JSON.stringify(settings)) {
+      return [];
+    }
+    const nested = project.scopes.filter((other) => other.parent === owner).map((other) => `${other.key}/**`);
+    return builder(project, settings, scope).flatMap((override) => {
+      const files = presetKeyFiles(fileKey, scope, override.files, expand);
+      if (files.length === 0 || !override.rules) {
+        return [];
+      }
+      return [{ ...override, files, excludeFiles: [...override.excludeFiles ?? [], ...nested], rules: presetSeverity(override.rules, settings.level) }];
+    });
+  }));
+}
 function presetPlugins(project) {
   const react = project.scopes.some((scope) => scope.effective.react);
+  const effect = project.scopes.some((scope) => scope.effective.effect);
+  const effectCode = project.scopes.some((scope) => scope.effective.effect?.code);
   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);
@@ -2299,6 +2812,15 @@ function presetPlugins(project) {
     { name: "arch", specifier: require2.resolve("oxlint-plugin-arch") },
     { name: "dillon-anti-slop", specifier: require2.resolve("oxlint-plugin-arch/dillon-anti-slop") }
   ];
+  const plugins = ["typescript", "react", "react-perf", "jsx-a11y", "import", "unicorn", "promise", "vitest", "node", "oxc"];
+  if (effectCode) {
+    const { tsgo, linteffect } = presetEffectPackages();
+    plugins.push(...tsgo.correctness.plugins ?? []);
+    jsPlugins.push(...linteffect.recommended.jsPlugins);
+  }
+  if (effect) {
+    jsPlugins.push(...presetEffectStyle().jsPlugins);
+  }
   const settings = {
     react: { version: "19" },
     "import/resolver": { node: { extensions: [".js", ".jsx", ".ts", ".tsx", ".mts", ".cts"] } }
@@ -2307,7 +2829,7 @@ function presetPlugins(project) {
     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 };
+    return { plugins, jsPlugins, settings };
   }
   jsPlugins.push(presetOptional("oxlint-tailwindcss", "tailwind"));
   settings.tailwindcss = { rootFontSize: tailwind.rem };
@@ -2315,27 +2837,38 @@ function presetPlugins(project) {
     jsPlugins.push(presetOptional("@shadcn/lint", "shadcn"));
     settings.shadcn = { ui: shadcn.ui, componentImports: shadcn.components };
   }
-  return { jsPlugins, settings };
+  return { plugins, jsPlugins, settings };
 }
 function preset(config) {
   const project = presetProject(config);
   const [root] = project.scopes;
   const level = presetLevel(root);
+  const expanded = new Map;
+  const expand = (fileKey) => {
+    const paths = expanded.get(fileKey.pattern) ?? globSync(fileKey.pattern, { cwd: project.root, exclude: (path) => posix9.basename(path) === "node_modules" });
+    expanded.set(fileKey.pattern, paths);
+    return paths;
+  };
   const emitGroup = (name) => {
     const builder = presetBuilders[name];
-    return builder ? presetEmit(project, name, builder) : [];
+    return builder ? [...presetEmit(project, name, builder, expand), ...presetFileEmit(project, name, builder, expand)] : [];
   };
   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)];
+  const fileSeverities = project.fileKeys.flatMap((fileKey) => fileKey.folder.severity ? [{ files: [fileKey.pattern], rules: presetSeverity(presetCommonRules, fileKey.folder.severity) }] : []);
+  const overrides = [...severities, ...fileSeverities, ...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 });
     }
   }
+  for (const fileKey of project.fileKeys) {
+    if (fileKey.folder.rules) {
+      overrides.push({ files: [fileKey.pattern], rules: fileKey.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,