oxlint-plugin-arch 0.13.0 → 0.13.2

package/dist/preset/preset.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/preset/preset.ts
-import { globSync } from "node:fs";
+import { globSync as globSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { matchesGlob as matchesGlob2, posix as posix9 } from "node:path";
 
@@ -399,6 +399,7 @@ var presetGroupOrder = [
   "kit",
   "limits",
   "deny",
+  "top",
   "externals"
 ];
 var presetDefaultGroups = [
@@ -412,6 +413,7 @@ var presetDefaultGroups = [
   "imports",
   "tests",
   "deny",
+  "top",
   "externals"
 ];
 var presetExternals = [
@@ -432,7 +434,7 @@ var presetGroupOptions = {
   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 },
+  naming: { level: "error", files: true, exports: true, folders: true, unique: undefined, imports: {} },
   comments: { level: "error", directives: true },
   types: { level: "error", placement: true, safety: true, colocated: [] },
   imports: { level: "error", sort: true, boundaries: true, aliases: {}, internal: undefined },
@@ -449,9 +451,10 @@ var presetGroupOptions = {
   schemas: { level: "error" },
   forms: { level: "error" },
   sql: { level: "error" },
-  effect: { level: "error", code: true, width: 140, exports: undefined, skip: undefined, entries: [] },
+  effect: { level: "error", code: true, width: 140, exports: undefined, skip: undefined, entries: [], files: [], strict: true },
   console: { level: "error" },
-  deny: { level: "error", imports: {}, calls: {} },
+  deny: { level: "error", imports: {}, calls: {}, only: [] },
+  top: { level: "error", allow: undefined, deny: undefined, message: undefined, stem: undefined, singularize: undefined, roles: undefined, separators: undefined, file: undefined, placeholder: undefined },
   externals: { level: "error" }
 };
 var presetQueryWrites = ["insertInto", "updateTable", "deleteFrom", "mergeInto", "replaceInto", "dispatch", "send"];
@@ -511,10 +514,13 @@ var presetEffectImports = {
   "ts-pattern": "Use effect/Match.",
   dayjs: "Use effect/DateTime."
 };
+var presetEffectServerImports = {
+  ai: "Use effect/ai.",
+  "@ai-sdk/**": "Use effect/ai."
+};
 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"];
 var presetRegistryFiles = ["core/core.services.ts", "service.ts"];
 var presetRegistrySkip = ["brand", "database", "db", "math", "security", "tools"];
 var presetServerEntries = ["rpc", "server", "security", "services"];
@@ -588,7 +594,7 @@ var presetTemplates = {
 };
 
 // src/preset/preset.utils.ts
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, globSync, readFileSync, statSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { posix, resolve } from "node:path";
 class PresetError extends Error {
@@ -703,6 +709,23 @@ function presetIntersect(glob, scope) {
 function presetGlobEscape(path) {
   return path.replaceAll(/[[\]]/g, (bracket) => `[${bracket}]`);
 }
+function presetFileOverlaps(root, build, keys) {
+  const matched = new Map;
+  for (const key of keys) {
+    for (const path of globSync(key.pattern, { cwd: root, exclude: (name) => posix.basename(name) === "node_modules" })) {
+      matched.set(path, [...matched.get(path) ?? [], key]);
+    }
+  }
+  const reach = new Map(keys.map((key) => [key, [...matched.values()].filter((found) => found.includes(key)).length]));
+  const merged = [...matched].flatMap(([path, found]) => {
+    if (found.length < 2) {
+      return [];
+    }
+    const ordered = found.toSorted((left, right) => (reach.get(right) ?? 0) - (reach.get(left) ?? 0));
+    return [build(presetGlobEscape(path), ordered.reduce((folder, key) => Object(presetMerge(folder, key.folder)), {}))];
+  });
+  return [...keys, ...merged];
+}
 function presetAliases(root, aliases) {
   return Object.fromEntries(Object.entries(aliases ?? {}).map(([alias, path]) => [alias.replace(/\/$/, ""), resolve(root, path)]));
 }
@@ -769,7 +792,8 @@ function presetSource(root, directory, configured) {
 }
 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;
+    const denied = folder instanceof Object && folder.deny instanceof Object ? { ...folder.deny.imports, ...folder.deny.calls } : undefined;
+    const empty = denied !== undefined && Object.keys(denied).length === 0;
     return exists(path) && !empty;
   }));
 }
@@ -793,8 +817,27 @@ function presetMerge(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;
+  const owned = [base.deny, top.deny].flatMap((deny) => deny instanceof Object ? deny.only ?? [] : []);
+  if (owned.length > 0 && merged.deny instanceof Object) {
+    merged.deny = { ...merged.deny, only: owned };
+  }
   return before && after && merged.layout instanceof Object ? { ...merged, layout: { ...merged.layout, files: [...before, ...after] } } : merged;
 }
+function presetNames(inherited, entries, option) {
+  if (!Array.isArray(entries) || !entries.every((entry) => typeof entry === "string" && presetLayoutFileName.test(entry))) {
+    throw new PresetError(`${option} 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;
+}
 
 // src/preset/preset-effect.ts
 var presetEffectQueryWrites = Object.fromEntries(presetQueryWrites.map((name) => [name, "A queries file only reads; write in an actions file."]));
@@ -802,8 +845,11 @@ var presetEffectWorkflowCalls = Object.fromEntries(["selectFrom", ...presetQuery
 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 presetEffectContractKinds = ["*.schemas.ts", "*.admin.schemas.ts", "*.contract.ts", "*.admin.contract.ts", "*.errors.ts", "*.layer.types.ts", "*.service.ts"];
+var presetEffectSpans = [
+  "error",
+  { labels: [{ callee: "Effect.fn", name: "{name}", drop: ["Action", "Query"], loose: true }] }
+];
 var presetEffectSchemaUses = {
   namespaces: ["Schema"],
   methods: ["Array", "Union", "Record", "Tuple"],
@@ -848,7 +894,7 @@ function presetEffectServerKeys(at) {
       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: "] }]
+        "arch/comments-code": ["error", { why: false, jsdoc: true, allow: ["^\\s*SAFETY: "], steps: true }]
       }
     },
     [at("domains")]: {
@@ -876,17 +922,18 @@ function presetEffectServerKeys(at) {
     },
     [at("domains/*/*.actions.ts")]: {
       limits: { lines: 1000 },
-      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Action[A-Z]\\w*"], types: true }] }
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Action[A-Z]\\w*"], types: true }], "arch/naming-labels": presetEffectSpans }
     },
     [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 }] }
+      rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Query[A-Z]\\w*"], types: true }], "arch/naming-labels": presetEffectSpans }
     },
     [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/*/*.layer.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
+    [at("domains/*/*.driver.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
     [at("domains/*/*.workflows.ts")]: {
+      rules: { "arch/naming-labels": ["error", { labels: [{ callee: "Workflow.make", name: "{name}", drop: "Workflow$" }] }] },
       deny: {
         calls: presetEffectWorkflowCalls,
         imports: {
@@ -905,7 +952,14 @@ function presetEffectServerKeys(at) {
     [at("rpc")]: { rules: { "arch/code-delegate": "error" } }
   };
 }
-function presetEffectContractKeys(at) {
+function presetEffectContractKeys(at, files) {
+  const kinds = presetNames(presetEffectContractKinds, files ?? [], "effect.files");
+  if (kinds.some((kind) => !/^\*\.[a-z0-9.-]+\.ts$/.test(kind))) {
+    throw new PresetError("effect.files takes contract file kinds such as `*.service.ts`.");
+  }
+  const pattern = `^[a-z0-9]+(?:-[a-z0-9]+)*(?:${kinds.map((kind) => kind.slice(1, -3).replaceAll(".", "[.]")).join("|")})[.]ts$`;
+  const listed = kinds.flatMap((kind) => kind === "*.schemas.ts" ? ["<d>.schemas.ts", "<d>-<part>.schemas.ts"] : [`<d>${kind.slice(1)}`]);
+  const message = `Contract files use ${listed.slice(0, -1).join(", ")} or ${listed.at(-1)}.`;
   const schemas = {
     rules: {
       "arch/files-constants-only": ["error", { types: true, functions: true }],
@@ -918,7 +972,7 @@ function presetEffectContractKeys(at) {
   return {
     [at("*/*.ts")]: {
       rules: {
-        "arch/naming-file": ["error", { pattern: presetEffectContractNames, message: presetEffectContractMessage }],
+        "arch/naming-file": ["error", { pattern, message }],
         "arch/naming-folder": ["error", { singularize: "none", separators: [".", "-"] }],
         "arch/files-exports": ["error", { stem: "folder", singularize: "trailing-s", patterns: ["{Domain}\\w*"] }]
       }
@@ -928,6 +982,7 @@ function presetEffectContractKeys(at) {
     [at("*/*.contract.ts")]: schemas,
     [at("*/*.errors.ts")]: noFunctions,
     [at("*/*.layer.types.ts")]: noFunctions,
+    [at("*/*.service.ts")]: noFunctions,
     [at("shared/*.ts")]: {
       rules: {
         "arch/naming-file": "off",
@@ -946,19 +1001,116 @@ function presetEffectContractKeys(at) {
     }
   };
 }
-function presetEffectUnit(root, key, value) {
+function presetEffectTop(allow) {
+  return { top: { allow, stem: "folder" } };
+}
+function presetEffectStrictServer(at, service) {
+  const operations = presetEffectTop([{ kind: "const", exported: true, from: "^Effect\\.fn" }, { kind: "const", names: "^decode[A-Z]" }]);
+  const layerKeys = service === undefined ? {} : { "arch/effect-layer-keys": ["error", { service }] };
+  return {
+    [at(".")]: {
+      rules: {
+        "arch/effect-yield-name": "error",
+        "arch/effect-yields-first": "error",
+        "arch/code-inside": ["error", { inside: [{ callee: "*.transaction", calls: { "*Workflow.execute": "Start the workflow after the commit." } }] }]
+      }
+    },
+    [at("domains")]: { naming: { imports: { "./{file}.ts": "{File}" } } },
+    [at("domains/*/*.actions.ts")]: operations,
+    [at("domains/*/*.queries.ts")]: operations,
+    [at("domains/*/*.utils.ts")]: {
+      ...operations,
+      rules: { "arch/naming-labels": ["error", { labels: [{ callee: "Effect.fn", name: "{name}", loose: true }] }] }
+    },
+    [at("domains/*/*.layer.ts")]: {
+      rules: { "arch/naming-keys": ["error", { callees: ["*.bind", "*.of"], name: "^{folder}(?:Action|Query){Path}$", inline: false }], ...layerKeys }
+    },
+    [at("domains/*/*.workflows.ts")]: {
+      ...presetEffectTop([{ kind: "const", from: "(?:^Workflow\\.make|\\.toLayer|^Layer\\.\\w+|^Schedule\\.\\w+)$" }]),
+      rules: {
+        "arch/files-exports": ["error", { stem: "folder", patterns: ["{Domain}\\w*Workflow", "{Domain}WorkflowsLayer", "{domain}Schedule[A-Z]\\w*"] }],
+        "arch/naming-labels": [
+          "error",
+          {
+            labels: [
+              { callee: "Workflow.make", name: "{name}", drop: "Workflow$" },
+              { callee: "Effect.fn", name: "{name}", within: "*.toLayer", loose: true }
+            ]
+          }
+        ]
+      }
+    },
+    [at("domains/*/*.constants.ts")]: presetEffectTop([{ kind: "const", exported: true, names: "^{DOMAIN}_" }]),
+    [at("domains/*/*.config.ts")]: presetEffectTop([{ kind: "const", exported: true, names: "^{domain}\\w*Config$" }]),
+    [at("domains/*/*.prompts.ts")]: { rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Prompt[A-Z]\\w*"], types: true }] } },
+    [at("rpc/*/*.ts")]: {
+      ...presetEffectTop([{ kind: "const", exported: true }]),
+      rules: {
+        "arch/naming-file": ["error", { template: "{group}/rpc.{group}.{area}.ts", message: "Handlers use rpc/<group>/rpc.<group>.<area>.ts." }],
+        "arch/files-exports": ["error", { file: "rpc.{group}.{area}.ts", names: ["rpc{Group}{Area}"] }],
+        "arch/naming-keys": ["error", { exports: "^rpc[A-Z]", delegate: true }]
+      }
+    },
+    [at("mails/*.mail.tsx")]: { rules: { "arch/files-exports": ["error", { file: "{name}.mail.tsx", names: ["{name}Mail", "{Name}Email"], types: true }] } }
+  };
+}
+function presetEffectStrictContract(at, name, files) {
+  const key = name === undefined ? [] : [{ callee: "Context.Service", name: `${name}/{folder}/{file}/{name}` }];
+  const labels = key.length > 0 ? { "arch/naming-labels": ["error", { labels: key }] } : {};
+  const service = presetNames(presetEffectContractKinds, files ?? [], "effect.files").includes("*.service.ts");
+  const sibling = service ? { "arch/files-siblings": ["error", { require: "{folder}.service.ts", message: "A domain is reached through its service." }] } : {};
+  return {
+    [at("*/*.schemas.ts")]: presetEffectTop(["type", "interface", "namespace", { kind: "const", exported: true }]),
+    [at("*/*.contract.ts")]: {
+      ...presetEffectTop(["type", { kind: "const", exported: true }, { kind: "const", exported: false, from: "^[A-Z]\\w*\\." }]),
+      deny: { calls: { "Schema.Struct": "Name the Schema in <d>.schemas.ts." } },
+      rules: sibling
+    },
+    [at("*/*.service.ts")]: {
+      ...presetEffectTop(["interface", "type", "class", "namespace"]),
+      rules: { ...labels, "arch/effect-service-params": "error" }
+    },
+    [at("*/*.errors.ts")]: {
+      ...presetEffectTop([{ kind: "class", exported: true }]),
+      rules: {
+        "arch/naming-labels": [
+          "error",
+          {
+            labels: [
+              { callee: ["Schema.TaggedErrorClass", "Schema.TaggedError", "Data.TaggedError"], name: "{name}" },
+              { callee: "*.Tagged", property: "tag", name: "{name}" },
+              { callee: "*.Tagged", property: "code", pattern: "^[A-Z][A-Z0-9_]*$" }
+            ]
+          }
+        ]
+      }
+    }
+  };
+}
+var presetEffectStrictTests = { top: { allow: ["describe*", "it*", "test*", "layer*"] } };
+function presetEffectUnit(root, key, value, contract) {
   if (!value.effect) {
     return {};
   }
   const at = presetEffectAt(root, key, value);
-  const contract = presetEffectContract(root, key, value);
+  const own = presetEffectContract(root, key, value);
   const server = presetEffectDomains(root, key, value);
-  const keys = server || contract ? presetFilled(server ? presetEffectServerKeys(at) : presetEffectContractKeys(at), presetEffectExists(root, key)) : {};
+  const options = value.effect instanceof Object ? value.effect : {};
+  const service = contract && `${posix2.join(root, contract.source)}/{folder}/{folder}.service.ts`;
+  const base = server ? presetEffectServerKeys(at) : presetEffectContractKeys(at, options.files);
+  const tests = { "tests/**/*.test.ts": presetEffectStrictTests, "test/**/*.test.ts": presetEffectStrictTests };
+  const strict = server ? { ...presetEffectStrictServer(at, service), ...tests } : presetEffectStrictContract(at, presetManifest(root, key).name, options.files);
+  const locked = options.strict === false ? {} : strict;
+  const paths = [...new Set([...Object.keys(base), ...Object.keys(locked)])];
+  const merged = (path) => (path in base) && (path in locked) ? presetMerge(base[path], locked[path]) : base[path] ?? locked[path];
+  const conventions = Object.fromEntries(paths.map((path) => [path, merged(path)]));
+  const keys = server || own ? presetFilled(conventions, 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 } } : {};
+  const placement = server || own ? { types: { placement: false } } : {};
+  const imports = server || own ? { ...presetEffectImports, ...presetEffectServerImports } : presetEffectImports;
   return {
     ...keys,
-    ".": presetMerge({ ...placement, deny: { imports: presetEffectImports, calls: errors } }, keys["."] ?? {}),
+    ".": presetMerge({ ...placement, deny: { imports, calls: errors } }, keys["."] ?? {}),
     [at("**/*.errors.ts")]: { deny: { calls: Object.fromEntries(presetEffectErrors.map((name) => [name, false])) } }
   };
 }
@@ -1015,9 +1167,13 @@ function presetEffectKit(root, key, value, units) {
   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 ?? [] : []);
+  const packages = units.flatMap(([other, folder]) => {
+    const name = presetEffectContract(root, other, folder) ? presetManifest(root, other).name : undefined;
+    return name === undefined ? [] : [{ name, source: presetSource(root, other, folder instanceof Object ? folder.source : undefined) }];
+  });
+  const contracts = packages.map((item) => item.name);
   return [
-    ...Object.entries(presetEffectUnit(root, key, value)),
+    ...Object.entries(presetEffectUnit(root, key, value, packages.at(0))),
     ...Object.entries(presetEffectFrontend(root, key, value)),
     ...Object.entries(presetEffectWeb(root, key, value, contracts)),
     ...Object.entries(presetEffectKit(root, key, value, units))
@@ -1422,8 +1578,9 @@ var denyGroup = (project, settings) => {
   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 }] }));
+  const only = settings.only.length > 0 ? { only: settings.only } : {};
+  if (Object.keys(imports).length > 0 || Object.keys(calls).length > 0 || settings.only.length > 0) {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/boundaries-deny": ["error", { imports, calls, ...only }] }));
   }
   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")) {
@@ -1431,7 +1588,7 @@ var denyGroup = (project, settings) => {
       ...presetServiceScopes(project.serviceFolders, [unit.source], "**/*-query.*.ts"),
       ...presetServiceScopes(project.serviceFolders, project.operations.filter((path) => path === unit.source), "*/queries/*.ts")
     ];
-    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: kept({ ...reads, ...settings.calls }) }] }));
+    overrides.push(presetOverride(files, { "arch/boundaries-deny": ["error", { imports, calls: kept({ ...reads, ...settings.calls }), ...only }] }));
   }
   return overrides;
 };
@@ -1500,17 +1657,19 @@ var effectGroup = (project, settings) => {
       "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-inline": ["error", { max, nesting: 2, callbacks: true, 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 }],
+      "arch/layout-call-arguments": ["error", { split: false, pipe: { min: 2 }, hug: { max }, join: { max, nesting: 2, keep: ["Layer.mergeAll"] } }],
+      "arch/layout-call-depth": ["error", { max: 2, callbacks: true }],
       "arch/layout-items": "error",
+      "arch/layout-object": ["error", { min: 3, scope: "call-args", params: true, nested: true, siblings: true, inner: 2 }],
       "arch/layout-pipe": "error",
-      "arch/layout-ternary": ["error", { fit: false, branch: { max: 3 } }]
+      "arch/layout-ternary": ["error", { max: 100, branch: { max: 3 } }],
+      "arch/layout-type-arguments": ["error", { min: 3 }]
     }),
     presetOverride(files, {
       "arch/code-justified-call": [
@@ -1845,6 +2004,10 @@ var namingGroup = (project, settings, owner) => {
     }
   }
   add("exports", presetServiceScopes(project.serviceFolders, web, "**/*.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]);
+  const imports = Object.entries(settings.imports).flatMap(([source, name]) => name === false ? [] : [{ source, name }]);
+  if (imports.length > 0) {
+    overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-imports": ["error", { imports }] }));
+  }
   if (typeof exportsPattern === "string") {
     overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-exports": ["error", { mode: "pattern", pattern: exportsPattern, types: true }] }));
   }
@@ -1978,7 +2141,10 @@ var shadcnGroup = (project) => {
 
 // src/preset/groups/sql.ts
 var sqlGroup = (project) => [
-  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), { "arch/backend-sql-like": "error" })
+  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), {
+    "arch/backend-sql-like": "error",
+    "arch/layout-chain": ["error", { groups: [{ min: 3, methods: ["selectFrom", "insertInto", "updateTable", "deleteFrom", "mergeInto", "with"] }] }]
+  })
 ];
 
 // src/preset/groups/style.ts
@@ -2079,6 +2245,12 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function optionsWildcards(names) {
+  return [names ?? []].flat().map((name) => new RegExp(`^${name.split("*").map(optionsEscape).join(".*")}$`));
+}
 
 // src/preset/groups/tests.ts
 var testsGroup = (project, settings) => {
@@ -2125,6 +2297,16 @@ var testsGroup = (project, settings) => {
   ];
 };
 
+// src/preset/groups/top.ts
+var topGroup = (_project, { level: _level, allow, ...rest }) => {
+  if (allow === undefined && rest.deny === undefined) {
+    return [];
+  }
+  const listed = allow === undefined || allow.includes("import") ? allow : ["import", ...allow];
+  const options = Object.fromEntries(Object.entries({ allow: listed, ...rest }).filter(([, value]) => value !== undefined));
+  return [presetOverride([`**/${presetExtensions}`], { "arch/files-top-level": ["error", options] })];
+};
+
 // src/preset/groups/types.ts
 var typesGroup = (project, settings) => {
   const { web, backend, packageSources, app, appFiles, services, utilities, types, ui, testFiles, components, hooks } = project;
@@ -2185,9 +2367,69 @@ var typesGroup = (project, settings) => {
 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-sets.ts
+var presetSetsReserved = ["domain", "stem", "file", "folder", "parent", "name", "key", "value"];
+function presetSets(folders, sets = {}) {
+  const names = Object.keys(sets);
+  const reserved = names.find((name) => presetSetsReserved.includes(name) || !/^[a-z][A-Za-z0-9]*$/.test(name));
+  if (reserved) {
+    throw new PresetError(`Set \`${reserved}\` needs another name: start with a lowercase letter, use letters and digits, and avoid ${presetSetsReserved.join(", ")}.`);
+  }
+  if (names.length === 0) {
+    return folders;
+  }
+  const token = new RegExp(`\\{(${names.join("|")})\\}`);
+  const pairs = (name) => {
+    if (!Object.hasOwn(sets, name)) {
+      throw new PresetError(`Unknown set \`${name}\`.`);
+    }
+    const set = sets[name];
+    return Array.isArray(set) ? set.map((item) => [item, item]) : Object.entries(set);
+  };
+  const text = (value, key, item) => value.replaceAll("{key}", key).replaceAll("{value}", item);
+  const fill = (value, key, item) => {
+    if (typeof value === "string") {
+      return text(value, key, item);
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => fill(entry, key, item));
+    }
+    return value instanceof Object ? Object.fromEntries(Object.entries(value).map(([name, entry]) => [text(name, key, item), fill(entry, key, item)])) : value;
+  };
+  const spread = (value) => {
+    const match = token.exec(value);
+    return match ? pairs(match[1]).flatMap(([key]) => spread(value.replace(match[0], key))) : [value];
+  };
+  const expandEntries = (value) => Object.entries(value).flatMap(([name, entry]) => {
+    const match = token.exec(name);
+    return match ? pairs(match[1]).flatMap(([key, item]) => expandEntries({ [name.replace(match[0], key)]: fill(entry, key, item) })) : [[name, name === "message" ? entry : expand(entry)]];
+  });
+  const expand = (value) => {
+    if (typeof value === "string") {
+      return token.test(value) ? spread(value) : value;
+    }
+    if (!Array.isArray(value)) {
+      const marks = value instanceof Object ? Object.getOwnPropertySymbols(value).map((mark) => [mark, Reflect.get(value, mark)]) : [];
+      return value instanceof Object ? Object.assign(Object.fromEntries(expandEntries(value)), Object.fromEntries(marks)) : value;
+    }
+    return value.flatMap((entry) => {
+      if (typeof entry === "string") {
+        return spread(entry);
+      }
+      if (!(entry instanceof Object) || Array.isArray(entry) || typeof entry.each !== "string") {
+        return [expand(entry)];
+      }
+      const { each, ...rest } = entry;
+      return pairs(each).map(([key, item]) => expand(fill(rest, key, item)));
+    });
+  };
+  return expand(folders);
+}
+
 // src/preset/preset-stylesheet.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync3, realpathSync } from "node:fs";
 import { posix as posix6, resolve as resolve6 } from "node:path";
+var presetStylesheetNames = ["styles", "globals", "global", "app", "index", "main", "style", "tailwind"];
 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);
@@ -2237,7 +2479,7 @@ function presetUnitSource(root, key, kind, source) {
   }
   return kind === "console" || !existsSync4(resolve7(root, key, "src")) ? key : posix7.join(key, "src");
 }
-function presetSets(folder, name) {
+function presetSets2(folder, name) {
   return folder[name] !== undefined && folder[name] !== false;
 }
 function presetKind(key, enabled) {
@@ -2273,8 +2515,8 @@ 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 own = presetKindGroups.some((name) => presetSets2(folder, name)) || presetHasManifest(root, key);
+  const { kind, framework } = presetKind(key, (name) => own ? presetSets2(folder, name) : Boolean(effective[name]));
   const layout = {};
   const settings = effective.layout;
   if (settings) {
@@ -2297,7 +2539,7 @@ function presetUnits(root, scopes, ignored) {
   const candidates = [];
   for (const scope of scopes) {
     const manifest = presetHasManifest(root, scope.key);
-    const own = presetKindGroups.some((name) => presetSets(scope.folder, name)) || manifest;
+    const own = presetKindGroups.some((name) => presetSets2(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;
@@ -2404,20 +2646,16 @@ function presetDenyEntries(inherited, changes) {
     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.");
+function presetDenyOnly(inherited, entries = []) {
+  const each = entries.find((entry) => entry.each !== undefined)?.each;
+  if (each !== undefined) {
+    throw new PresetError(`Unknown set \`${each}\`.`);
   }
-  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);
-    }
+  const known = (entry) => ("in" in entry) && (("imports" in entry) || ("calls" in entry)) && Object.keys(entry).every((key) => ["imports", "calls", "in", "message"].includes(key));
+  if (!Array.isArray(entries) || !entries.every((entry) => entry instanceof Object && known(entry))) {
+    throw new PresetError("deny.only takes entries such as `{ imports: [...], in: [...], message }`, with `imports` or `calls` and the places that may use them.");
   }
-  return names;
+  return [...inherited, ...entries];
 }
 function presetEffective(folder, parent) {
   const resolveGroup = (name) => {
@@ -2431,13 +2669,14 @@ function presetEffective(folder, parent) {
     effective.deny = {
       ...effective.deny,
       imports: presetDenyEntries(inherited.imports, deny.imports),
-      calls: presetDenyEntries(inherited.calls, deny.calls)
+      calls: presetDenyEntries(inherited.calls, deny.calls),
+      only: presetDenyOnly(inherited.only, deny.only)
     };
   }
   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) };
+    effective.layout = { ...effective.layout, files: presetNames(inherited, layout.files, "layout.files") };
   }
   return effective;
 }
@@ -2458,7 +2697,7 @@ function presetFolder(key, value) {
   if (folder.severity !== undefined && !["error", "warn"].includes(folder.severity)) {
     throw new PresetError(`Folder \`${key}\` severity must be 'error' or 'warn'.`);
   }
-  return folder;
+  return Array.isArray(folder.top) ? { ...folder, top: { allow: folder.top } } : folder;
 }
 function presetScopesTree(root, folders) {
   const entries = Object.entries(folders).map(([key, value]) => [presetNormalizeKey(key), value]);
@@ -2503,7 +2742,7 @@ function presetScopesTree(root, folders) {
 function presetProject(config) {
   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 expanded = Object.entries(presetSets(config.folders ?? {}, config.sets)).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));
@@ -2528,7 +2767,11 @@ 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]) => {
+  const keyFor = (pattern, folder) => {
+    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 fileKeys = presetFileOverlaps(root, keyFor, fileEntries.flatMap(([key, value]) => {
     if (value === false) {
       return [];
     }
@@ -2540,10 +2783,8 @@ function presetProject(config) {
     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 }];
-  });
+    return [keyFor(presetGlobEscape(key), folder)];
+  }));
   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);
@@ -2710,6 +2951,7 @@ var presetBuilders = {
   shadcn: shadcnGroup,
   limits: limitsGroup,
   deny: denyGroup,
+  top: topGroup,
   externals: externalsGroup
 };
 function presetLevel(scope) {
@@ -2845,7 +3087,7 @@ function preset(config) {
   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" });
+    const paths = expanded.get(fileKey.pattern) ?? globSync2(fileKey.pattern, { cwd: project.root, exclude: (path) => posix9.basename(path) === "node_modules" });
     expanded.set(fileKey.pattern, paths);
     return paths;
   };