oxlint-plugin-arch 0.12.0 → 0.12.2

package/dist/preset/preset.js

@@ -2,8 +2,34 @@
 import { createRequire } from "node:module";
 
 // src/preset/groups/backend.ts
-import { existsSync } from "node:fs";
-import { posix, resolve as resolve2 } from "node:path";
+import { posix as posix3, resolve as resolve3 } 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";
+
+// src/preset/preset-recipes.ts
+var presetUi = { react: true, kit: true, tailwind: true };
+var presetRecipes = {
+  tanstack: { react: true, tanstack: true, tailwind: true, shadcn: true, schemas: true, forms: true },
+  next: { react: true, next: true, tailwind: true, shadcn: true, schemas: true, forms: true },
+  expo: { react: true, expo: true, schemas: true, forms: true },
+  backend: { backend: true, schemas: true, sql: true, layout: { strict: true } },
+  react: { react: true, tailwind: true, schemas: true },
+  desktop: { console: true },
+  library: { schemas: true },
+  ui: presetUi,
+  kit: presetUi,
+  cli: { console: true }
+};
+var presetTemplates = {
+  monorepo: {
+    "apps/web": presetRecipes.tanstack,
+    "apps/server": presetRecipes.backend,
+    "packages/*": presetRecipes.library,
+    scripts: presetRecipes.cli
+  }
+};
 
 // src/preset/preset.constants.ts
 var presetExtensions = "*.{ts,tsx,mts,cts}";
@@ -331,7 +357,9 @@ var presetBuiltinFileRoles = [
   "test",
   "spec"
 ];
-var presetLiteralSegment = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+var presetShorthandOptions = [["tests", "mocking", "preset"], ["backend", "registry", "file"]];
+var presetOutputFolders = ["dist", "build", "coverage", ".output"];
+var presetLiteralSegment = /^(?!\.{1,2}$)[a-zA-Z0-9._][a-zA-Z0-9._-]*$/;
 var presetIllustrationPalette = [
   "text-color",
   "bg-color",
@@ -436,7 +464,7 @@ var presetGroupOptions = {
   deny: { level: "error", imports: {}, calls: {} },
   externals: { level: "error", packages: presetExternals }
 };
-var presetFolderKeys = ["severity", "source", "rules"];
+var presetFolderKeys = ["severity", "source", "services", "rules"];
 var presetA11yRules = [
   "alt-text",
   "anchor-has-content",
@@ -478,15 +506,15 @@ var presetExpoRouteExports = ["ErrorBoundary", "unstable_settings", "generateSta
 var presetTestFiles = ["**/{test,tests,e2e}/**/*.{ts,tsx,mts,cts}", "**/*.{test,spec}.{ts,tsx,mts,cts}"];
 var presetBaseImports = [{ group: ["zod/v4", "zod/v4/**"], message: "Import from zod, not its transition entry point." }];
 var presetDetectFrameworks = [
-  ["tanstack", ["@tanstack/react-start"]],
   ["next", ["next", "vinext"]],
+  ["tanstack", ["@tanstack/react-start"]],
   ["expo", ["expo"]]
 ];
 var presetDetectDesktop = ["electrobun", "electron", "@tauri-apps/api", "@tauri-apps/cli"];
 var presetDetectBackend = ["@orpc/server", "hono", "kysely", "drizzle-orm", "express", "fastify", "elysia"];
 var presetDetectSkip = ["node_modules", "dist", "build", "coverage", "public", ".output", ".next", ".vinext", ".turbo", ".wrangler", "target"];
 var presetStylesheetNames = ["styles", "globals", "global", "app", "index", "main", "style", "tailwind"];
-var presetRegistryFiles = ["services/service.ts", "core/core.services.ts", "service.ts"];
+var presetRegistryFiles = ["core/core.services.ts", "service.ts"];
 var presetRegistrySkip = ["brand", "database", "db", "math", "security", "tools"];
 var presetServerEntries = ["rpc", "server", "security", "services"];
 var presetOperationImports = ["*/*-action.*", "*/*-query.*", "*/actions/*", "*/queries/*"];
@@ -499,13 +527,16 @@ var presetRootImports = { "framer-motion": "Use motion/react." };
 var presetPackageImports = { "../../apps/**": "Packages stay app-agnostic; do not import app internals." };
 
 // src/preset/preset.utils.ts
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { readFileSync, statSync } from "node:fs";
+import { posix, resolve } from "node:path";
 class PresetError extends Error {
 }
 function presetScopes(roots, suffix = `**/${presetExtensions}`) {
   return roots.map((root) => root === "." ? suffix : `${root}/${suffix}`);
 }
+function presetServiceScopes(folders, sources, suffix = `**/${presetExtensions}`) {
+  return presetScopes(sources.map((source) => folders[source] ?? posix.join(source, "services")), suffix);
+}
 function presetOverride(files, rules, excludeFiles = []) {
   return {
     files,
@@ -583,12 +614,376 @@ function presetRuntime(project, settings, framework, rule) {
       options.rpc = project.rpcClients.map((path) => resolve(project.root, path));
     }
     return [
-      presetOverride([...presetScopes([unit.source], "services/**/*.{ts,tsx}"), ...presetScopes([unit.source], "lib/**/*.{ts,tsx}")], {
+      presetOverride([...presetServiceScopes(project.serviceFolders, [unit.source], "**/*.{ts,tsx}"), ...presetScopes([unit.source], "lib/**/*.{ts,tsx}")], {
         [rule]: ["error", options]
       })
     ];
   });
 }
+function presetManifest(root, directory) {
+  try {
+    return JSON.parse(readFileSync(resolve(root, directory, "package.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function presetIsDirectory(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  } catch {
+    return false;
+  }
+}
+function presetServicesFolder(root, source, configured, fallback = true) {
+  if (configured !== undefined) {
+    if (!configured.split("/").every((segment) => presetLiteralSegment.test(segment))) {
+      throw new PresetError(`services \`${configured}\` must be a literal relative path.`);
+    }
+    return posix.join(source, configured);
+  }
+  const lib = fallback && !presetIsDirectory(resolve(root, source, "services")) && presetIsDirectory(resolve(root, source, "lib"));
+  return posix.join(source, lib ? "lib" : "services");
+}
+function presetIsFile(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+// src/preset/preset-detect.ts
+function presetDirectories(root, base, skip = presetDetectSkip) {
+  if (!presetIsDirectory(resolve2(root, base))) {
+    return [];
+  }
+  return readdirSync(resolve2(root, base)).filter((name) => !name.startsWith(".") && !skip.includes(name) && presetIsDirectory(resolve2(root, base, name))).map((name) => posix2.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 [posix2.join(services, "service.ts"), ...presetRegistryFiles.map((path) => posix2.join(source, path))].find((path) => existsSync(resolve2(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`)));
+}
+function presetRecipe(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 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 flat = entries.filter((entry) => entry.isFile() && /\.tsx?$/.test(entry.name)).length > folders;
+  if (framework) {
+    return flat ? { ...presetRecipes[framework], layout: { services: "flat" } } : presetRecipes[framework];
+  }
+  if (has(presetDetectDesktop)) {
+    return presetRecipes.desktop;
+  }
+  if (presetDomains(root, servicesFolder).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services))) {
+    return presetRecipes.backend;
+  }
+  if (has(["react"]) && presetIsDirectory(resolve2(root, source, "components"))) {
+    return app ? presetRecipes.react : presetRecipes.ui;
+  }
+  return presetRecipes.library;
+}
+function presetMergeObject(base, top, depth) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(top)) {
+    const previous = Reflect.get(merged, key);
+    const nested = previous instanceof Object && value instanceof Object && !Array.isArray(previous) && !Array.isArray(value);
+    if (nested && depth > 0) {
+      Reflect.set(merged, key, presetMergeObject(previous, value, depth - 1));
+    } else if (value !== true || !(previous instanceof Object)) {
+      Reflect.set(merged, key, value);
+    }
+  }
+  return merged;
+}
+function presetMerge(base, top) {
+  if (!(base instanceof Object) || !(top instanceof Object)) {
+    return top === true && base instanceof Object ? base : top;
+  }
+  return presetMergeObject(base, top, 2);
+}
+function presetImportTargets(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(presetImportTargets);
+  }
+  return value instanceof Object ? Object.values(value).flatMap(presetImportTargets) : [];
+}
+function presetSpecifiers(manifest, target, file = false) {
+  const specifiers = Object.entries(manifest.imports ?? {}).flatMap(([key, value]) => presetImportTargets(value).flatMap((mapped) => {
+    const path = posix2.normalize(mapped);
+    const parts = path.split("*");
+    const keyParts = key.split("*");
+    if (parts.length === 1 && keyParts.length === 1) {
+      return path.replace(/\.[cm]?[jt]sx?$/, "") === target ? [key] : [];
+    }
+    if (parts.length !== 2 || keyParts.length !== 2) {
+      return [];
+    }
+    const [before, after] = parts;
+    const [head, suffix] = keyParts;
+    const prefix = before.replace(/\/$/, "");
+    if (target !== prefix && !target.startsWith(`${prefix}/`)) {
+      return [];
+    }
+    const rest = target.slice(prefix.length).replace(/^\//, "");
+    const tail = after && rest.endsWith(after) ? rest.slice(0, -after.length) : rest;
+    return [`${head}${tail}${file ? suffix : ""}`.replace(/\/$/, "")];
+  }));
+  return [...new Set(specifiers)];
+}
+function presetOverlaps(left, right) {
+  const [leftBase] = left.split("*");
+  const [rightBase] = right.split("*");
+  return leftBase.startsWith(rightBase) || rightBase.startsWith(leftBase);
+}
+function presetDeny(imports) {
+  return { deny: { imports } };
+}
+function presetFilled(conventions, exists) {
+  return Object.fromEntries(Object.entries(conventions).filter(([path, folder]) => {
+    const empty = folder instanceof Object && folder.deny instanceof Object && Object.keys(folder.deny.imports ?? {}).length === 0;
+    return exists(path) && !empty;
+  }));
+}
+function presetBackendConventions(root, key, value, denied) {
+  const manifest = presetManifest(root, key);
+  const source = presetSource(root, key, value.source);
+  const local = posix2.relative(key, source) || ".";
+  const at = (path) => local === "." ? path : posix2.join(local, path);
+  const exists = (path) => existsSync(resolve2(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 registryFile = presetRegistryFile(root, source, configured, servicesFolder);
+  const registry = registryFile === undefined ? undefined : posix2.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])));
+  const registryImports = registry ? Object.fromEntries(presetSpecifiers(manifest, registry.replace(/\.[cm]?[jt]sx?$/, ""), true).map((specifier) => [specifier, "Only the composition root imports the service registry."])) : {};
+  const entries = Object.fromEntries(presetServerEntries.map((entry) => [`${manifest.name}/${entry}`, "Server code imports its own modules, not the package entries."]));
+  const serviceImports = { ...registryImports, ...operations };
+  if (manifest.name) {
+    Object.assign(serviceImports, entries);
+  }
+  const conventions = {
+    [servicesKey]: presetDeny(serviceImports),
+    [at("core")]: presetDeny(operations),
+    [at("rpc")]: presetDeny(registryImports),
+    [at("routes")]: presetDeny(registryImports),
+    [at("cli")]: {
+      naming: { files: presetCliFiles },
+      ...presetDeny({ ...operations, ...Object.fromEntries(services.map((prefix) => [`${prefix}/*/*.service`, "Reach services through the registry."])) })
+    }
+  };
+  for (const domain of presetDirectories(root, servicesFolder, presetNamedSkip).map((path) => posix2.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));
+  }
+  for (const tests of ["tests", "test"]) {
+    if (exists(posix2.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 } };
+    }
+  }
+  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") {
+        conventions[child] = { layout: false, naming: { files: presetMigrationFiles, unique: presetMigrationNumber } };
+      } else if (child.split("/").length < 8) {
+        queue.push(child);
+      }
+    }
+  }
+  return presetFilled(conventions, exists);
+}
+function presetWebConventions(root, key, value, servers) {
+  const source = 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 own = Object.keys(presetManifest(root, key).imports ?? {});
+  const internals = servers.flatMap((manifest) => Object.keys(manifest.imports ?? {}).filter((specifier) => !own.some((mine) => presetOverlaps(mine, specifier))).map((specifier) => specifier.replace(/\*$/, "**")));
+  const named = servers.flatMap((manifest) => manifest.name ? [manifest.name] : []);
+  const entries = Object.fromEntries(named.flatMap((name) => presetServerEntries.map((entry) => [`${name}/${entry}`, "UI code imports the client entry."])));
+  const clients = Object.fromEntries(named.map((name) => [`${name}/client`, "Route handlers run on the server; import the server entry."]));
+  const appImports = Object.fromEntries(internals.map((specifier) => [specifier, "Import the backend through its client entry."]));
+  if (servers.length > 0) {
+    appImports["**/services/*.service"] = "Import the client or rsc service file, not a server service.";
+  }
+  const conventions = {
+    ".": presetDeny(appImports),
+    [at("components")]: presetDeny(entries),
+    [at("routes")]: presetDeny(entries),
+    [at("routes/handlers")]: { deny: { imports: { ...clients, ...Object.fromEntries(Object.keys(entries).map((entry) => [entry, false])) } } }
+  };
+  return presetFilled(conventions, exists);
+}
+function presetWorkspacePatterns(root, manifest) {
+  const listed = Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? [];
+  const file = resolve2(root, "pnpm-workspace.yaml");
+  if (!existsSync(file)) {
+    return listed;
+  }
+  const patterns = [...listed];
+  let inside = false;
+  for (const line of readFileSync2(file, "utf8").split(`
+`)) {
+    const flow = /^packages\s*:\s*\[(.*)\]/.exec(line);
+    const item = /^\s*-\s*(["']?)([^"'#\s]+)\1\s*(?:#.*)?$/.exec(line);
+    if (flow) {
+      patterns.push(...flow[1].split(",").map((entry) => entry.trim().replaceAll(/^["']|["']$/g, "")).filter(Boolean));
+      inside = false;
+    } else if (/^packages\s*:/.test(line)) {
+      inside = true;
+    } else if (inside && item) {
+      patterns.push(item[2]);
+    } else if (/^\S/.test(line)) {
+      inside = false;
+    }
+  }
+  return patterns;
+}
+function presetWorkspaces(root, patterns) {
+  const clean = (pattern) => posix2.normalize(pattern.replace(/^\.\//, "")).replace(/\/$/, "");
+  const include = patterns.filter((pattern) => !pattern.startsWith("!")).map(clean);
+  const exclude = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => clean(pattern.slice(1)));
+  const matches = (path, globs) => globs.some((glob) => path === glob || matchesGlob(path, glob));
+  const candidates = new Set;
+  for (const pattern of include) {
+    const segments = pattern.split("/");
+    const literal = segments.findIndex((segment) => /[*?{[]/.test(segment));
+    if (literal === -1) {
+      candidates.add(pattern);
+      continue;
+    }
+    const depth = segments.includes("**") ? 8 : segments.length - literal;
+    let level = [segments.slice(0, literal).join("/") || "."];
+    for (let step = 0;step < depth; step++) {
+      level = level.flatMap((folder) => presetDirectories(root, folder, presetNamedSkip));
+      level.forEach((folder) => candidates.add(folder));
+    }
+  }
+  return [...candidates].filter((path) => matches(path, include) && !matches(path, exclude) && existsSync(resolve2(root, path, "package.json"))).toSorted();
+}
+function presetContains(key, path) {
+  if (key === "." || key === path) {
+    return true;
+  }
+  const pattern = key.split("/");
+  const segments = path.split("/");
+  return pattern.length <= segments.length && pattern.every((segment, index) => segment === "*" || segment === segments[index]);
+}
+function presetOwner(folders, path, owns) {
+  const depth = (key) => key === "." ? 0 : key.split("/").length;
+  return Object.entries(folders).filter(([key, value]) => presetContains(key, path) && owns(value)).toSorted(([left], [right]) => depth(left) - depth(right) || Number(right.includes("*")) - Number(left.includes("*"))).at(-1)?.[1];
+}
+function presetGroupOff(folders, path, group) {
+  const owner = presetOwner(folders, path, (value) => value instanceof Object && (group in value));
+  return owner instanceof Object && Object(owner)[group] === false;
+}
+function presetDetect(root, folders) {
+  const manifest = presetManifest(root, ".");
+  const configured = (key) => {
+    const value = folders[key];
+    return value instanceof Object ? value : {};
+  };
+  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 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")) {
+    detected.scripts = presetRecipes.cli;
+  }
+  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 merged = { ".": presetDeny(presetRootImports) };
+  for (const [key, value] of Object.entries(detected)) {
+    if (!covered(key)) {
+      merged[key] = presetMerge(merged[key], value);
+    }
+  }
+  for (const [key, value] of Object.entries(folders)) {
+    merged[key] = key in merged ? presetMerge(merged[key], value) : value;
+  }
+  const length = (key) => key.split("/").length;
+  const nested = (key) => Object.keys(merged).some((other) => other !== "." && length(other) < length(key) && presetContains(other, key));
+  const units = Object.entries(merged).flatMap(([key, value]) => {
+    if (key.endsWith("/*")) {
+      return presetDirectories(root, key.slice(0, -2), presetNamedSkip).filter((directory) => !(directory in merged)).map((directory) => [directory, value]);
+    }
+    if (key.includes("*") || nested(key)) {
+      return [];
+    }
+    const siblings = Object.entries(merged).filter(([other]) => other !== key && other.endsWith("/*") && length(other) === length(key) && presetContains(other, key));
+    return [[key, siblings.reduce((inherited, [, sibling]) => presetMerge(sibling, inherited), value)]];
+  });
+  const denied = new Set(Object.values(folders).flatMap((folder) => folder instanceof Object && folder.deny instanceof Object ? Object.entries(folder.deny.imports ?? {}).flatMap(([pattern, message]) => typeof message === "string" ? [pattern] : []) : []));
+  const servers = units.filter(([, value]) => value instanceof Object && Boolean(value.backend)).map(([key]) => presetManifest(root, key));
+  const internals = servers.flatMap((server) => Object.keys(server.imports ?? {}).map((specifier) => specifier.replace(/\*$/, "**")));
+  const add = (key, folder) => {
+    if (presetOwner(folders, key, () => true) === false) {
+      return;
+    }
+    const kept = folder instanceof Object ? Object.fromEntries(Object.entries(folder).filter(([group]) => !presetGroupOff(folders, key, group))) : folder;
+    if (kept instanceof Object && Object.keys(kept).length === 0) {
+      return;
+    }
+    merged[key] = key in merged ? presetMerge(kept, merged[key]) : kept;
+  };
+  for (const [key, value] of units) {
+    if (!(value instanceof Object)) {
+      continue;
+    }
+    if (value.backend) {
+      for (const [path, folder] of Object.entries(presetBackendConventions(root, key, value, denied))) {
+        add(path === "." ? key : posix2.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);
+      }
+    } else if ((value.kit || key.startsWith("packages/")) && !value.expo) {
+      const own = Object.keys(presetManifest(root, key).imports ?? {});
+      const message = presetPackageImports["../../apps/**"];
+      const appImports = internals.filter((specifier) => !own.some((mine) => presetOverlaps(mine, specifier))).map((specifier) => [specifier, message]);
+      add(key, presetDeny({ ...presetPackageImports, ...Object.fromEntries(appImports) }));
+    }
+  }
+  return merged;
+}
 
 // src/preset/groups/backend.ts
 var backendGroup = (project, settings) => {
@@ -606,9 +1001,9 @@ 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 : posix.normalize(configured.file);
+  const file = configured.file === undefined ? undefined : posix3.normalize(configured.file);
   const registries = file === undefined ? backendUnits.flatMap((unit) => {
-    const found = presetRegistryFiles.map((path) => posix.join(unit.source, path)).find((path) => existsSync(resolve2(project.root, path)));
+    const found = presetRegistryFile(project.root, unit.source, undefined, unit.services);
     return found ? [{ file: found, unit }] : [];
   }) : [{ file, unit: backendUnits.find((unit) => unit.key === "." || file.startsWith(`${unit.key}/`)) }];
   for (const registry of registries) {
@@ -616,8 +1011,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: resolve2(project.root, registry.file),
-      services: resolve2(project.root, registry.unit.source, "services"),
+      registry: resolve3(project.root, registry.file),
+      services: resolve3(project.root, registry.unit.services),
       skip: configured.skip ?? (file === undefined ? presetRegistrySkip : [])
     };
     if (configured.object !== undefined) {
@@ -635,7 +1030,7 @@ var basicsGroup = (project, settings) => {
   return [
     ...settings.trivial ? [
       presetOverride(appFiles, { "arch/code-trivial-functions": ["error", trivial] }, ui),
-      presetOverride([...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")], { "arch/code-trivial-functions": ["error", { ...trivial, services: true }] }, ui)
+      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)] : [],
     ...settings.switch ? [presetOverride(project.backendFiles, { "arch/code-switch": ["error", { message: "Use ts-pattern in backend application code." }] })] : [],
@@ -666,8 +1061,8 @@ var denyGroup = (project, settings) => {
       continue;
     }
     const files = [
-      ...presetScopes([unit.source], "services/**/*-query.*.ts"),
-      ...presetScopes(project.operations.filter((path) => path === unit.source), "services/*/queries/*.ts")
+      ...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 } }] }));
@@ -725,7 +1120,7 @@ var formsGroup = (project, settings) => [
 ];
 
 // src/preset/groups/imports.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 function importsPackageNames(project, kinds) {
   return project.units.flatMap((unit) => {
     const name = kinds.includes(unit.kind) ? presetPackageName(project.root, unit.key) : undefined;
@@ -763,7 +1158,7 @@ var importsGroup = (project, settings) => {
   if (!settings.boundaries) {
     return overrides;
   }
-  const absolute = (paths) => paths.map((path) => resolve3(project.root, path));
+  const absolute = (paths) => paths.map((path) => resolve4(project.root, path));
   overrides.push(presetOverride([...project.appFiles, ...presetScopes(project.packages, `**/${presetExtensions}`)], {
     "arch/boundaries-imports": [
       "error",
@@ -772,6 +1167,7 @@ var importsGroup = (project, settings) => {
         backend: absolute(project.backend),
         packages: absolute(project.packages),
         roles: project.suffixes,
+        services: absolute([...project.web, ...project.backend].map((source) => project.serviceFolders[source])),
         portable: true,
         aliases: presetAliases(project.root, settings.aliases),
         appPackages: importsPackageNames(project, ["web", "backend"]),
@@ -784,18 +1180,19 @@ var importsGroup = (project, settings) => {
 };
 
 // src/preset/groups/layout.ts
-import { posix as posix2 } from "node:path";
+import { posix as posix4 } from "node:path";
 var layoutGroup = (project, settings) => {
   const { web, nextWeb, serviceRoots, app, services, utilities, ui, testFiles, layouts, operations } = project;
-  const folderOperations = presetScopes(operations, "services/*/{actions,queries}/*.ts");
+  const 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 frontendEntries = [...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")];
-  const ungroupedWeb = web.filter((path) => !layouts.some((scope) => scope.path === posix2.join(path, "components")));
+  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")));
   return [
     ...layouts.flatMap(({ path, folder, mode }) => {
-      const folders = folder === "services" && operations.some((source) => posix2.join(source, "services") === path);
+      const folders = folder === "services" && operations.some((source) => posix4.join(source, "services") === path);
+      const registries = folder === "services" ? project.registries : [];
       const restricted = presetOverride(mode === "flat" ? [`${path}/*/**/${presetExtensions}`] : [`${path}/${presetExtensions}`, `${path}/*/*/**/${presetExtensions}`], {
         "arch/files-restricted": [
           "error",
@@ -803,31 +1200,31 @@ var layoutGroup = (project, settings) => {
             message: mode === "flat" ? "This folder uses a flat layout; subfolders are forbidden." : "This folder uses exactly one owning domain directory; loose and deeper files are forbidden."
           }
         ]
-      }, folders ? [`${path}/*/{actions,queries}/*.ts`] : []);
+      }, [...folders ? [`${path}/*/{actions,queries}/*.ts`] : [], ...registries]);
       if (mode !== "domain") {
         return [restricted];
       }
       const prefix = { singularize: folder === "components" ? "trailing-s" : "none", separators: [".", "-"] };
       const naming = folder === "hooks" ? { ...prefix, prefixes: ["use-"] } : prefix;
-      const domain = [restricted, presetOverride([`${path}/*/${presetExtensions}`], { "arch/naming-folder": ["error", naming] })];
+      const domain = [restricted, presetOverride([`${path}/*/${presetExtensions}`], { "arch/naming-folder": ["error", naming] }, registries)];
       if (!settings.strict || folder !== "services") {
         return domain;
       }
-      const strict = presetOverride([`${path}/*/${presetExtensions}`], {
+      const strict = presetOverride([`${path}/*/**/${presetExtensions}`], {
         "arch/naming-file": [
           "error",
           {
-            pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*[.](?:${roles.join("|")})[.]ts$`,
+            pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*(?:[.](?:${roles.join("|")})[.]ts|[.]rsc[.]tsx)$`,
             message: `Domain files use domain[-part].<role>.ts with a role from: ${roles.join(", ")}. Add new roles to layout.suffixes.`
           }
         ]
-      }, ["**/*-{action,query}.*.ts"]);
+      }, ["**/*-{action,query}.*.ts", ...testFiles, ...registries]);
       return [...domain, strict];
     }),
     presetOverride(presetScopes(ungroupedWeb, `components/*/*/**/${presetExtensions}`), { "arch/files-restricted": ["error", { message: "Components allow one group folder." }] }, ui),
     presetOverride([...presetScopes(web, "components/**/*.ts"), ...presetScopes(web, "hooks/**/*.tsx")], { "arch/files-restricted": ["error", { message: "Components use TSX; hooks use .ts files." }] }, ui),
     presetOverride(presetScopes(web, "**/use-*.{ts,tsx}"), { "arch/files-restricted": ["error", { message: "Hooks belong in src/hooks." }] }, [...presetScopes(web, "hooks/**"), ...ui]),
-    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), {
+    presetOverride(presetServiceScopes(project.serviceFolders, web, "**/*.{ts,tsx}"), {
       "arch/files-restricted": [
         "error",
         {
@@ -837,31 +1234,32 @@ var layoutGroup = (project, settings) => {
     }, [
       "**/*.{client,server,rsc,utils,constants}.ts",
       "**/*.rsc.tsx",
-      ...presetScopes(nextWeb, "services/**/*.action.ts"),
+      ...presetServiceScopes(project.serviceFolders, nextWeb, "**/*.action.ts"),
       ...conceptFiles,
-      ...project.colocated
+      ...project.colocated,
+      ...testFiles
     ]),
     presetOverride(services, {
       "arch/backend-service-functions": "error",
       "arch/types-inline": ["error", { parameters: true, returns: true, functions: true, min: 1 }]
     }, [...utilities, ...testFiles, ...conceptFiles]),
     presetOverride(frontendEntries, { "arch/backend-service-functions": ["error", { frontend: true }] }, testFiles),
-    ...conceptFiles.map((pattern) => presetOverride(presetScopes(app, `services/${pattern}`), {
+    ...conceptFiles.map((pattern) => presetOverride(presetServiceScopes(project.serviceFolders, app, pattern), {
       "arch/backend-service-functions": "off",
       "arch/naming-exports": ["error", { stem: "full-basename", scope: "functions" }]
     }, testFiles)),
-    presetOverride([...presetScopes(app, "services/**/*-{action,query}.*.ts"), ...presetScopes(web, "services/**/*-{action,query}.*.rsc.tsx")], { "arch/backend-service-functions": ["error", { helpers: true, single: true, message: operationMessage }] }, testFiles),
-    presetOverride(folderOperations, { "arch/backend-service-functions": ["error", { helpers: true, message: operationMessage }] }, testFiles),
-    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), { "arch/files-domain-constants": "error" }, [...utilities, ...testFiles]),
-    presetOverride(presetScopes(web, "services/**/*.{ts,tsx}"), { "arch/files-domain-constants": ["error", { data: true }] }, [
+    presetOverride([...presetServiceScopes(project.serviceFolders, app, "**/*-{action,query}.*.ts"), ...presetServiceScopes(project.serviceFolders, web, "**/*-{action,query}.*.rsc.tsx")], { "arch/backend-service-functions": ["error", { helpers: true, single: true, message: operationMessage }] }, testFiles),
+    presetOverride(folderOperations, { "arch/backend-service-functions": ["error", { helpers: true, single: true, message: operationMessage }] }, testFiles),
+    presetOverride(presetServiceScopes(project.serviceFolders, serviceRoots, "**/*.ts"), { "arch/files-domain-constants": "error" }, [...utilities, ...testFiles]),
+    presetOverride(presetServiceScopes(project.serviceFolders, web, "**/*.{ts,tsx}"), { "arch/files-domain-constants": ["error", { data: true }] }, [
       "**/*.constants.ts",
       ...testFiles
     ]),
     presetOverride(frontendEntries, { "arch/files-domain-constants": ["error", { data: true, services: true }] }, testFiles),
-    presetOverride([...presetScopes(serviceRoots, "services/**/*-{action,query}.*.ts"), ...folderOperations, ...frontendEntries], { "arch/code-object-params": ["error", { max: 2 }] }, testFiles),
+    presetOverride([...presetServiceScopes(project.serviceFolders, serviceRoots, "**/*-{action,query}.*.ts"), ...folderOperations, ...frontendEntries], { "arch/code-object-params": ["error", { max: 2 }] }, testFiles),
     presetOverride(frontendEntries, { "arch/code-object-params": ["error", { max: 2, services: true }] }, testFiles),
-    presetOverride(presetScopes(serviceRoots, "services/**/*.service.ts"), { "arch/files-exports": ["error", { names: settings.service, stem: "before-first-dot", types: false }] }, testFiles),
-    presetOverride(presetScopes(app.filter((path) => !operations.includes(path)), "services/**/{actions,queries}/**/*.ts"), {
+    presetOverride(presetServiceScopes(project.serviceFolders, serviceRoots, "**/*.service.ts"), { "arch/files-exports": ["error", { names: settings.service, stem: "before-first-dot", types: false }] }, testFiles),
+    presetOverride(presetServiceScopes(project.serviceFolders, app.filter((path) => !operations.includes(path)), "**/{actions,queries}/**/*.ts"), {
       "arch/files-restricted": ["error", { message: "Use domain-action.name.ts or domain-query.name.ts." }]
     })
   ];
@@ -878,6 +1276,10 @@ var limitsGroup = (project, settings) => [
 
 // src/preset/groups/naming.ts
 var namingOperationMessage = "Use domain-action.name.ts or domain-query.name.ts.";
+var namingFrontendPrefix = { ...presetExportPrefix, scope: "functions", services: true, allow: "^\\*$" };
+function namingOperationPrefix(role) {
+  return { ...presetExportPrefix, roles: [role], scope: "functions", allow: "^\\*$" };
+}
 function namingOperation(role, file) {
   return { mode: "template", file, export: `{domain}${role === "action" ? "Action" : "Query"}{Name}`, placeholder: "[a-z0-9-]+", camelCase: true };
 }
@@ -885,7 +1287,7 @@ var namingGroup = (project, settings, owner) => {
   const { web, serviceRoots, app, ui, testFiles, components, hooks, operations } = project;
   const flatApp = app.filter((path) => !operations.includes(path));
   const folderApp = app.filter((path) => operations.includes(path));
-  const frontendEntries = [...presetScopes(web, "services/**/*.{client,server,rsc}.ts"), ...presetScopes(web, "services/**/*.rsc.tsx")];
+  const frontendEntries = [...presetServiceScopes(project.serviceFolders, web, "**/*.{client,server,rsc}.ts"), ...presetServiceScopes(project.serviceFolders, web, "**/*.rsc.tsx")];
   const ungroupedWeb = web.filter((path) => !project.layouts.some((scope) => scope.path === `${path}/components`));
   const overrides = [];
   const { files: filesPattern, exports: exportsPattern, unique } = settings;
@@ -923,8 +1325,8 @@ var namingGroup = (project, settings, owner) => {
   add("files", [`**/${presetExtensions}`], presetNamingRules);
   add("files", presetScopes(app, "types/**/*.ts"), { "arch/naming-file": ["error", { pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*[.]types[.]ts$", message: "Use domain.types.ts filenames." }] }, ["**/*.constants.ts"]);
   add("exports", presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/naming-exports": ["error", presetExportPrefix] }, [...ui, ...presetScopes(serviceRoots, "entry.*.ts")]);
-  add("exports", frontendEntries, { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "functions", services: true, allow: "^\\*$" }] }, testFiles);
-  add("exports", presetScopes(web, "services/**/*.constants.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "declarations", allow: "^\\*$" }] }, testFiles);
+  add("exports", frontendEntries, { "arch/naming-exports": ["error", namingFrontendPrefix] }, testFiles);
+  add("exports", presetServiceScopes(project.serviceFolders, web, "**/*.constants.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "declarations", allow: "^\\*$" }] }, testFiles);
   add("exports", presetScopes(app, "**/*.utils.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "functions", allow: "^\\*$" }] }, ui);
   add("files", hooks, {
     "arch/naming-file": [
@@ -939,20 +1341,20 @@ var namingGroup = (project, settings, owner) => {
   add("exports", components, { "arch/files-components-only": ["error", { filename: true, types: true, roles: ["illustration"] }] }, [...ui, ...testFiles]);
   add("folders", presetScopes(ungroupedWeb, "components/**/*.tsx"), { "arch/naming-folder": ["error", { singularize: "trailing-s", separators: ["-"] }] }, [...ui, ...testFiles]);
   for (const role of ["action", "query"]) {
-    const files = [...presetScopes(flatApp, `services/**/*-${role}.*.ts`), ...presetScopes(web, `services/**/*-${role}.*.rsc.tsx`)];
+    const files = [...presetServiceScopes(project.serviceFolders, flatApp, `**/*-${role}.*.ts`), ...presetServiceScopes(project.serviceFolders, web, `**/*-${role}.*.rsc.tsx`)];
     add("files", files, {
       "arch/naming-file": ["error", { pattern: `^[a-z0-9]+(?:-[a-z0-9]+)*-${role}\\.[a-z0-9]+(?:-[a-z0-9]+)*\\.ts$`, message: namingOperationMessage }]
-    });
+    }, testFiles);
     add("exports", files, {
       "arch/naming-exports": [
         "error",
-        { ...presetExportPrefix, roles: [role], scope: "functions", allow: "^\\*$" },
+        namingOperationPrefix(role),
         namingOperation(role, `{domain}-${role}.{name}.ts`)
       ]
-    });
+    }, testFiles);
   }
   for (const [role, folder, separator] of [["action", "actions", "."], ["query", "queries", "-"]]) {
-    const files = presetScopes(folderApp, `services/*/${folder}/*.ts`);
+    const files = presetServiceScopes(project.serviceFolders, folderApp, `*/${folder}/*.ts`);
     add("files", files, {
       "arch/naming-file": [
         "error",
@@ -961,17 +1363,17 @@ var namingGroup = (project, settings, owner) => {
           message: "Use domain-action.name.ts in actions/ and domain-query-name.ts in queries/."
         }
       ]
-    });
+    }, testFiles);
     add("exports", files, {
       "arch/naming-exports": [
         "error",
         { mode: "template", file: `{domain}-${role}${separator}{name}.ts`, export: `make{Domain}${role === "action" ? "Action" : "Query"}{Name}`, placeholder: "[a-z0-9-]+" }
       ]
-    });
+    }, testFiles);
   }
   for (const role of ["action", "query"]) {
     for (const suffix of ["client.ts", "server.ts", "rsc.ts", "rsc.tsx"]) {
-      const files = presetScopes(web, `services/**/*-${role}.*.${suffix}`);
+      const files = presetServiceScopes(project.serviceFolders, web, `**/*-${role}.*.${suffix}`);
       add("files", files, {
         "arch/naming-file": [
           "error",
@@ -980,11 +1382,11 @@ var namingGroup = (project, settings, owner) => {
             message: "Frontend operations retain a client, server or rsc runtime suffix."
           }
         ]
-      });
-      add("exports", files, { "arch/naming-exports": ["error", namingOperation(role, `{domain}-${role}.{name}.${suffix}`)] });
+      }, testFiles);
+      add("exports", files, { "arch/naming-exports": ["error", namingOperationPrefix(role), namingOperation(role, `{domain}-${role}.{name}.${suffix}`)] }, testFiles);
     }
   }
-  add("exports", presetScopes(web, "services/**/*.rsc.{ts,tsx}"), { "arch/naming-exports": ["error", { mode: "pattern", pattern: "^[a-z][a-z0-9]*Rsc[A-Z][a-zA-Z0-9]*$" }] }, ["**/*-{action,query}.*.rsc.{ts,tsx}"]);
+  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]);
   if (typeof exportsPattern === "string") {
     overrides.push(presetOverride([`**/${presetExtensions}`], { "arch/naming-exports": ["error", { mode: "pattern", pattern: exportsPattern, types: true }] }));
   }
@@ -1118,7 +1520,7 @@ var shadcnGroup = (project) => {
 
 // src/preset/groups/sql.ts
 var sqlGroup = (project, settings) => [
-  presetOverride(presetScopes(project.serviceRoots, "services/**/*.ts"), {
+  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), {
     "arch/backend-sql-like": [
       "error",
       { methods: ["like", "ilike"], operators: ["where"], sanitizers: settings.sanitizers, bindings: true }
@@ -1179,7 +1581,7 @@ var tanstackGroup = (project, settings) => {
           patterns: project.baseImports
         }
       ]
-    }, presetScopes(tanstackWeb, "services/**/*.rsc.{ts,tsx}")),
+    }, presetServiceScopes(project.serviceFolders, tanstackWeb, "**/*.rsc.{ts,tsx}")),
     ...presetRuntime(project, settings, "tanstack", "arch/boundaries-tanstack")
   ];
 };
@@ -1209,8 +1611,12 @@ function optionsPatternsTest(patterns, value) {
   });
 }
 function optionsGlob(pattern) {
-  const source = pattern.replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
-  return new RegExp(`^${source}$`);
+  const negated = [];
+  const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    return `\x02${negated.length - 1}\x03`;
+  }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
+  return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
 }
 function optionsPatternLabel(pattern) {
   return pattern === undefined ? "" : [pattern].flat().filter((source) => source !== "").join(" | ");
@@ -1260,6 +1666,7 @@ var testsGroup = (project, settings) => {
   }
   return [
     presetOverride(project.testFiles, rules),
+    presetOverride(presetScopes(project.units.map((unit) => unit.source), "**/*.{test,spec}.{ts,tsx,mts,cts}"), { "arch/files-restricted": ["error", { message: "Tests live in a tests/ folder, not next to the code." }] }, ["**/tests/**", "**/test/**"]),
     presetOverride(presetScopes(project.backendRoots, "tests/**/*.ts"), backendRules),
     ...allow.map((entry) => presetOverride(entry.files, { "dillon-anti-slop/no-module-mocking": entry.apis.includes("*") ? "off" : mockingRule(entry.apis) }))
   ];
@@ -1322,254 +1729,151 @@ var typesGroup = (project, settings) => {
 };
 
 // src/preset/preset-folders.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, realpathSync, statSync as statSync2 } from "node:fs";
-import { posix as posix4, resolve as resolve5 } from "node:path";
-
-// src/preset/preset-detect.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
-import { posix as posix3, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync3, readdirSync as readdirSync4, realpathSync as realpathSync2 } from "node:fs";
+import { posix as posix7, resolve as resolve7 } from "node:path";
 
-// src/preset/preset-recipes.ts
-var presetUi = { react: true, kit: true, tailwind: true };
-var presetRecipes = {
-  tanstack: { react: true, tanstack: true, tailwind: true, shadcn: true, schemas: true, forms: true },
-  next: { react: true, next: true, tailwind: true, shadcn: true, schemas: true, forms: true },
-  expo: { react: true, expo: true, schemas: true, forms: true },
-  backend: { backend: true, schemas: true, sql: true, layout: { strict: true } },
-  react: { react: true, tailwind: true, schemas: true },
-  desktop: { console: true },
-  library: { schemas: true },
-  ui: presetUi,
-  kit: presetUi,
-  cli: { console: true }
-};
-var presetTemplates = {
-  monorepo: {
-    "apps/web": presetRecipes.tanstack,
-    "apps/server": presetRecipes.backend,
-    "packages/*": presetRecipes.library,
-    scripts: presetRecipes.cli
-  }
-};
-
-// src/preset/preset-detect.ts
-function presetManifest(root, directory) {
-  try {
-    return JSON.parse(readFileSync2(resolve4(root, directory, "package.json"), "utf8"));
-  } catch {
-    return {};
+// 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";
+function presetTailwindEntry(css) {
+  const code = css.replaceAll(/\/\*[\s\S]*?\*\//g, "");
+  return /(?:^|[;{}])\s*@(?:import\s+(?:url\(\s*(["']?)tailwindcss(?:\/[^"')\s]*)?\1\s*\)|(["'])tailwindcss(?:\/[^"']*)?\2)|tailwind\s)/.test(code);
+}
+function presetStylesheet(root, directory) {
+  const found = [];
+  const queue = [directory];
+  const visited = new Set;
+  while (queue.length > 0) {
+    const folder = queue.shift() ?? directory;
+    const real = realpathSync(resolve5(root, folder));
+    if (visited.has(real)) {
+      continue;
+    }
+    visited.add(real);
+    for (const name of readdirSync2(resolve5(root, folder))) {
+      const path = posix5.join(folder, name);
+      const full = resolve5(root, path);
+      const depth = posix5.relative(directory, path).split("/").length;
+      if (presetIsDirectory(full)) {
+        if (!name.startsWith(".") && !presetDetectSkip.includes(name) && depth < 8) {
+          queue.push(path);
+        }
+      } else if (name.endsWith(".css") && presetIsFile(full) && presetTailwindEntry(readFileSync3(full, "utf8"))) {
+        found.push(path);
+      }
+    }
   }
+  const rank = (path) => {
+    const index = presetStylesheetNames.indexOf(posix5.basename(path, ".css"));
+    return index === -1 ? presetStylesheetNames.length : index;
+  };
+  return found.toSorted((left, right) => rank(left) - rank(right) || left.length - right.length).at(0);
 }
-function presetDirectories(root, base) {
-  if (!existsSync2(resolve4(root, base))) {
-    return [];
+
+// 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";
+var presetFrameworks = ["tanstack", "next", "expo"];
+var presetKindGroups = [...presetFrameworks, "backend", "console"];
+function presetUnitSource(root, key, kind, source) {
+  if (source !== undefined) {
+    if (source !== "." && !source.split("/").every((segment) => presetLiteralSegment.test(segment))) {
+      throw new PresetError(`Folder \`${key}\` source must be \`.\` or a literal relative path.`);
+    }
+    return posix6.join(key, source);
   }
-  return readdirSync(resolve4(root, base)).filter((name) => !name.startsWith(".") && statSync(resolve4(root, base, name)).isDirectory()).map((name) => posix3.join(base, name));
+  return kind === "console" || !existsSync2(resolve6(root, key, "src")) ? key : posix6.join(key, "src");
 }
-function presetSource(root, directory) {
-  return existsSync2(resolve4(root, directory, "src")) ? posix3.join(directory, "src") : directory;
+function presetSets(folder, name) {
+  return folder[name] !== undefined && folder[name] !== false;
 }
-function presetRecipe(root, directory, app) {
-  const manifest = presetManifest(root, directory);
-  const dependencies = new Set(Object.keys({ ...manifest.dependencies, ...manifest.devDependencies }));
-  const has = (names) => names.some((name) => dependencies.has(name));
-  const source = presetSource(root, directory);
-  const framework = presetDetectFrameworks.find(([, names]) => has(names))?.[0];
-  const services = resolve4(root, source, "services");
-  const entries = existsSync2(services) ? readdirSync(services, { withFileTypes: true }) : [];
-  const flat = entries.filter((entry) => entry.isFile() && /\.tsx?$/.test(entry.name)).length > entries.filter((entry) => entry.isDirectory()).length;
-  if (framework) {
-    return flat ? { ...presetRecipes[framework], layout: { services: "flat" } } : presetRecipes[framework];
-  }
-  if (has(presetDetectDesktop)) {
-    return presetRecipes.desktop;
+function presetKind(key, enabled) {
+  const frameworks = presetFrameworks.filter(enabled);
+  if (frameworks.length > 1) {
+    throw new PresetError(`Folder \`${key}\` enables more than one of tanstack, next and expo.`);
   }
-  if (has(presetDetectBackend) && (app || existsSync2(services))) {
-    return presetRecipes.backend;
+  const [framework] = frameworks;
+  if (frameworks.length > 0 && enabled("backend")) {
+    throw new PresetError(`Folder \`${key}\` is either an app (tanstack, next, expo) or a backend, not both.`);
   }
-  if (has(["react"]) && existsSync2(resolve4(root, source, "components"))) {
-    return app ? presetRecipes.react : presetRecipes.ui;
+  let kind = "library";
+  if (frameworks.length > 0) {
+    kind = "web";
+  } else if (enabled("backend")) {
+    kind = "backend";
+  } else if (enabled("console")) {
+    kind = "console";
   }
-  return presetRecipes.library;
+  return { kind, framework };
 }
-function presetMergeObject(base, top, depth) {
-  const merged = { ...base };
-  for (const [key, value] of Object.entries(top)) {
-    const previous = merged[key];
-    const nested = previous instanceof Object && value instanceof Object && !Array.isArray(previous) && !Array.isArray(value);
-    if (nested && depth > 0) {
-      merged[key] = presetMergeObject(previous, value, depth - 1);
-    } else if (value !== true || !(previous instanceof Object)) {
-      merged[key] = value;
-    }
+function presetHasManifest(root, key) {
+  if (key === ".") {
+    return false;
   }
-  return merged;
-}
-function presetMerge(base, top) {
-  if (!(base instanceof Object) || !(top instanceof Object)) {
-    return top === true && base instanceof Object ? base : top;
+  if (!key.endsWith("/*")) {
+    return existsSync2(resolve6(root, key, "package.json"));
   }
-  return presetMergeObject(base, top, 2);
+  const base = resolve6(root, key.slice(0, -2));
+  return presetIsDirectory(base) && readdirSync3(base).some((name) => existsSync2(resolve6(base, name, "package.json")));
 }
-function presetSpecifiers(manifest, target) {
-  return Object.entries(manifest.imports ?? {}).flatMap(([key, value]) => {
-    const prefix = typeof value === "string" && value.endsWith("/*") && key.endsWith("/*") ? posix3.normalize(value.slice(0, -2)) : undefined;
-    if (prefix === undefined || target !== prefix && !target.startsWith(`${prefix}/`)) {
-      return [];
-    }
-    return [`${key.slice(0, -2)}${target.slice(prefix.length)}`];
-  });
-}
-function presetDeny(imports) {
-  return { deny: { imports } };
-}
-function presetBackendConventions(root, key, manifest) {
-  const source = presetSource(root, key);
-  const local = posix3.relative(key, source) || ".";
-  const at = (path) => local === "." ? path : posix3.join(local, path);
-  const exists = (path) => existsSync2(resolve4(root, key, path));
-  const registry = presetRegistryFiles.map(at).find(exists);
-  const services = presetSpecifiers(manifest, at("services"));
-  const operations = Object.fromEntries(services.flatMap((prefix) => presetOperationImports.map((pattern) => [`${prefix}/${pattern}`, "Use the service API, not another service’s operations."])));
-  const registryImports = registry ? Object.fromEntries(presetSpecifiers(manifest, registry.replace(/\.ts$/, "")).map((specifier) => [specifier, "Only the composition root imports the service registry."])) : {};
-  const entries = Object.fromEntries(presetServerEntries.map((entry) => [`${manifest.name}/${entry}`, "Server code imports its own modules, not the package entries."]));
-  const conventions = {
-    [at("services")]: presetDeny({
-      ...registryImports,
-      ...operations,
-      ...manifest.name ? entries : {}
-    }),
-    [at("core")]: presetDeny(operations),
-    [at("rpc")]: presetDeny(registryImports),
-    [at("routes")]: presetDeny(registryImports),
-    [at("cli")]: {
-      naming: { files: presetCliFiles },
-      ...presetDeny({ ...operations, ...Object.fromEntries(services.map((prefix) => [`${prefix}/*/*.service`, "Reach services through the registry."])) })
-    }
-  };
-  for (const tests of ["tests", "test"]) {
-    if (exists(posix3.join(tests, "kits"))) {
-      conventions[tests] = presetDeny(Object.fromEntries(presetKitImports.map((pattern) => [pattern, "Import the kit file you need."])));
-      conventions[posix3.join(tests, "kits")] = { naming: { files: presetKitFiles } };
-    }
-  }
-  const queue = ["."];
-  while (queue.length > 0) {
-    const folder = queue.shift() ?? ".";
-    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 < 6 && !presetDetectSkip.includes(posix3.basename(child))) {
-        queue.push(child);
+function presetUnit(root, key, scope) {
+  const { effective } = scope;
+  const wildcard = scope.parent && scope.parent.depth === scope.depth && scope.parent.key.includes("*") ? scope.parent.folder : {};
+  const folder = { ...wildcard, ...scope.folder };
+  const own = presetKindGroups.some((name) => presetSets(folder, name)) || presetHasManifest(root, key);
+  const { kind, framework } = presetKind(key, (name) => own ? presetSets(folder, name) : Boolean(effective[name]));
+  const layout = {};
+  const settings = effective.layout;
+  if (settings) {
+    const services2 = settings.services ?? (kind === "console" ? false : "domain");
+    const hooks = settings.hooks ?? (kind === "web" ? "flat" : false);
+    const modes = { services: services2, hooks, components: settings.components ?? false };
+    for (const [name, mode] of Object.entries(modes)) {
+      if (mode === "flat" || mode === "domain") {
+        layout[name] = mode;
       }
     }
   }
-  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 presetWebConventions(root, key, servers) {
-  const source = posix3.relative(key, presetSource(root, key)) || ".";
-  const at = (path) => source === "." ? path : posix3.join(source, path);
-  const exists = (path) => existsSync2(resolve4(root, key, path));
-  const internals = servers.flatMap((manifest) => Object.keys(manifest.imports ?? {}).map((specifier) => specifier.replace(/\*$/, "**")));
-  const named = servers.flatMap((manifest) => manifest.name ? [manifest.name] : []);
-  const entries = Object.fromEntries(named.flatMap((name) => presetServerEntries.map((entry) => [`${name}/${entry}`, "UI code imports the client entry."])));
-  const clients = Object.fromEntries(named.map((name) => [`${name}/client`, "Route handlers run on the server; import the server entry."]));
-  const conventions = {
-    ".": presetDeny({
-      ...Object.fromEntries(internals.map((specifier) => [specifier, "Import the backend through its client entry."])),
-      ...servers.length > 0 ? { "**/services/*.service": "Import the client or rsc service file, not a server service." } : {}
-    }),
-    [at("components")]: presetDeny(entries),
-    [at("routes")]: presetDeny(entries),
-    [at("routes/handlers")]: { deny: { imports: { ...clients, ...Object.fromEntries(Object.keys(entries).map((entry) => [entry, false])) } } }
-  };
-  return Object.fromEntries(Object.entries(conventions).filter(([path]) => path === "." || exists(path)));
+  const source = presetUnitSource(root, key, kind, folder.source);
+  const services = presetServicesFolder(root, source, folder.services, kind === "web" || kind === "backend");
+  return { key, scope, kind, framework, source, services, layout };
 }
-function presetDetect(root, folders) {
-  const manifest = presetManifest(root, ".");
-  const workspaces = Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? [];
-  const directories = workspaces.flatMap((pattern) => pattern.endsWith("/*") ? presetDirectories(root, pattern.slice(0, -2)) : [pattern]).filter((directory) => existsSync2(resolve4(root, directory, "package.json")));
-  const detected = Object.fromEntries(directories.map((directory) => [directory, presetRecipe(root, directory, !directory.startsWith("packages/"))]));
-  if (directories.length === 0) {
-    const recipe = presetRecipe(root, ".", true);
-    if (recipe !== presetRecipes.library) {
-      detected["."] = recipe;
-    }
-  }
-  if (existsSync2(resolve4(root, "scripts")) && !directories.includes("scripts")) {
-    detected.scripts = presetRecipes.cli;
-  }
-  const keys = Object.keys(folders);
-  const covered = (key) => keys.some((user) => user !== key && user !== "." && (key.startsWith(`${user}/`) || user.endsWith("/*") && posix3.dirname(key) === user.slice(0, -2)));
-  const merged = { ".": presetDeny(presetRootImports) };
-  for (const [key, value] of Object.entries(detected)) {
-    if (!covered(key)) {
-      merged[key] = presetMerge(merged[key], value);
-    }
-  }
-  for (const [key, value] of Object.entries(folders)) {
-    merged[key] = key in merged ? presetMerge(merged[key], value) : value;
-  }
-  const units = Object.entries(merged).filter(([key]) => !key.includes("*"));
-  const servers = units.filter(([, value]) => value instanceof Object && Boolean(value.backend)).map(([key]) => presetManifest(root, key));
-  const internals = servers.flatMap((server) => Object.keys(server.imports ?? {}).map((specifier) => specifier.replace(/\*$/, "**")));
-  const add = (key, folder) => {
-    merged[key] = key in merged ? presetMerge(folder, merged[key]) : folder;
-  };
-  for (const [key, value] of units) {
-    if (!(value instanceof Object)) {
-      continue;
-    }
-    if (value.backend) {
-      for (const [path, folder] of Object.entries(presetBackendConventions(root, key, presetManifest(root, key)))) {
-        add(path === "." ? key : posix3.join(key, path), folder);
-      }
-    } else if (value.tanstack || value.next) {
-      for (const [path, folder] of Object.entries(presetWebConventions(root, key, servers))) {
-        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 ?? {}).map((specifier) => specifier.replace(/\*$/, "**"));
-      const message = presetPackageImports["../../apps/**"];
-      const appImports = internals.filter((specifier) => !own.includes(specifier)).map((specifier) => [specifier, message]);
-      add(key, presetDeny({ ...presetPackageImports, ...Object.fromEntries(appImports) }));
+function presetUnits(root, scopes, ignored) {
+  const [rootScope] = scopes;
+  const rootKind = presetKind(".", (name) => Boolean(rootScope.effective[name])).kind;
+  const candidates = [];
+  for (const scope of scopes) {
+    const manifest = presetHasManifest(root, scope.key);
+    const own = presetKindGroups.some((name) => presetSets(scope.folder, name)) || manifest;
+    const top = scope.parent?.key === "." && (rootKind === "library" || own);
+    const sibling = scope.parent !== null && candidates.includes(scope.parent) && scope.parent.depth === scope.depth && !scope.key.includes("*");
+    const workspace = scope.parent !== null && scope.parent.key !== "." && manifest;
+    if (top || sibling || workspace) {
+      candidates.push(scope);
     }
   }
-  return merged;
-}
-function presetStylesheet(root, directory) {
-  const found = [];
-  const queue = [directory];
-  while (queue.length > 0) {
-    const folder = queue.shift() ?? directory;
-    for (const child of readdirSync(resolve4(root, folder), { withFileTypes: true })) {
-      const path = posix3.join(folder, child.name);
-      if (child.isDirectory() && !child.name.startsWith(".") && !presetDetectSkip.includes(child.name) && path.split("/").length < 8) {
-        queue.push(path);
-      } else if (child.isFile() && child.name.endsWith(".css") && /@import\s+["']tailwindcss|@tailwind\s/.test(readFileSync2(resolve4(root, path), "utf8"))) {
-        found.push(path);
-      }
+  const unitScopes = candidates.filter((scope) => !ignored.has(scope.key));
+  const explicit = new Set(unitScopes.map((scope) => scope.key));
+  const rootSource = presetUnitSource(root, ".", rootKind, rootScope.folder.source);
+  const overlaps = (left, right) => left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+  const rootOwnsSource = rootSource !== "." && !unitScopes.some((scope) => overlaps(scope.key.replace(/\/\*$/, ""), rootSource));
+  const rootUnit = rootKind !== "library" || rootOwnsSource || unitScopes.every((scope) => presetUnit(root, scope.key, scope).kind === "console");
+  return [...rootUnit ? [rootScope] : [], ...unitScopes].flatMap((scope) => {
+    if (!scope.key.endsWith("/*")) {
+      return [presetUnit(root, scope.key, scope)];
     }
-  }
-  const rank = (path) => {
-    const index = presetStylesheetNames.indexOf(posix3.basename(path, ".css"));
-    return index === -1 ? presetStylesheetNames.length : index;
-  };
-  return found.toSorted((left, right) => rank(left) - rank(right) || left.length - right.length).at(0);
+    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));
+  });
 }
 
 // src/preset/preset-folders.ts
-var presetFrameworks = ["tanstack", "next", "expo"];
-var presetKindGroups = [...presetFrameworks, "backend", "console"];
 function presetNormalizeKey(key) {
   const portable = key.replaceAll("\\", "/");
-  if (!portable.trim() || posix4.isAbsolute(portable) || /^[a-z]:/i.test(portable)) {
+  if (!portable.trim() || posix7.isAbsolute(portable) || /^[a-z]:/i.test(portable)) {
     throw new PresetError(`Folder keys must be project-relative paths: ${key}`);
   }
-  const normalized = posix4.normalize(portable).replace(/\/$/, "");
+  const normalized = posix7.normalize(portable).replace(/\/$/, "");
   if (normalized === ".." || normalized.startsWith("../")) {
     throw new PresetError(`Folder keys must stay inside the project: ${key}`);
   }
@@ -1607,7 +1911,14 @@ function presetGroupValue(name, value, inherited, severity) {
   if (unknown) {
     throw new PresetError(`Unknown option \`${name}.${unknown}\`.`);
   }
-  return { ...base, ...changes, level: severity ?? base.level };
+  const plain = (option) => option instanceof Object && !Array.isArray(option);
+  const merged = Object.fromEntries(Object.entries(changes).map(([key, option]) => {
+    const stored = Object(base)[key];
+    const field = presetShorthandOptions.find(([group, setting]) => group === name && setting === key)?.[2];
+    const previous = typeof stored === "string" && field !== undefined && plain(option) ? { [field]: stored } : stored;
+    return [key, plain(previous) && plain(option) ? { ...Object(previous), ...Object(option) } : option];
+  }));
+  return { ...base, ...merged, level: severity ?? base.level };
 }
 function presetDenyEntries(inherited, changes) {
   return Object.fromEntries(Object.entries({ ...inherited, ...changes }).flatMap(([key, message]) => {
@@ -1653,55 +1964,6 @@ function presetFolder(key, value) {
   }
   return folder;
 }
-function presetUnitSource(root, key, kind, source) {
-  if (source !== undefined) {
-    if (source !== "." && !source.split("/").every((segment) => presetLiteralSegment.test(segment))) {
-      throw new PresetError(`Folder \`${key}\` source must be \`.\` or a literal relative path.`);
-    }
-    return posix4.join(key, source);
-  }
-  return kind === "console" || key === "." && !existsSync3(resolve5(root, "src")) ? key : posix4.join(key, "src");
-}
-function presetSets(folder, name) {
-  return folder[name] !== undefined && folder[name] !== false;
-}
-function presetKind(key, enabled) {
-  const frameworks = presetFrameworks.filter(enabled);
-  if (frameworks.length > 1) {
-    throw new PresetError(`Folder \`${key}\` enables more than one of tanstack, next and expo.`);
-  }
-  const [framework] = frameworks;
-  if (frameworks.length > 0 && enabled("backend")) {
-    throw new PresetError(`Folder \`${key}\` is either an app (tanstack, next, expo) or a backend, not both.`);
-  }
-  let kind = "library";
-  if (frameworks.length > 0) {
-    kind = "web";
-  } else if (enabled("backend")) {
-    kind = "backend";
-  } else if (enabled("console")) {
-    kind = "console";
-  }
-  return { kind, framework };
-}
-function presetUnit(root, key, scope) {
-  const { folder, effective } = scope;
-  const own = presetKindGroups.some((name) => presetSets(folder, name));
-  const { kind, framework } = presetKind(key, (name) => own ? presetSets(folder, name) : Boolean(effective[name]));
-  const layout = {};
-  const settings = effective.layout;
-  if (settings) {
-    const services = settings.services ?? (kind === "console" ? false : "domain");
-    const hooks = settings.hooks ?? (kind === "web" ? "flat" : false);
-    const modes = { services, hooks, components: settings.components ?? false };
-    for (const [name, mode] of Object.entries(modes)) {
-      if (mode === "flat" || mode === "domain") {
-        layout[name] = mode;
-      }
-    }
-  }
-  return { key, scope, kind, framework, source: presetUnitSource(root, key, kind, scope.folder.source), layout };
-}
 function presetScopesTree(root, folders) {
   const entries = Object.entries(folders).map(([key, value]) => [presetNormalizeKey(key), value]);
   const keys = entries.map(([key]) => key);
@@ -1711,7 +1973,7 @@ function presetScopesTree(root, folders) {
   }
   for (const key of keys) {
     const base = key.endsWith("/*") ? key.slice(0, -2) : key;
-    if (!existsSync3(resolve5(root, base))) {
+    if (!existsSync3(resolve7(root, base))) {
       throw new PresetError(`Folder \`${key}\` does not exist.`);
     }
   }
@@ -1743,38 +2005,28 @@ function presetScopesTree(root, folders) {
   return scopes;
 }
 function presetProject(config) {
-  const given = resolve5(config.root ?? process.cwd());
-  const root = existsSync3(given) ? realpathSync(given) : given;
-  const folders = config.detect === false ? config.folders ?? {} : presetDetect(root, config.folders ?? {});
+  const given = resolve7(config.root ?? process.cwd());
+  const root = existsSync3(given) ? realpathSync2(given) : given;
+  const listed = Object.entries(config.folders ?? {}).map(([key, value]) => [presetNormalizeKey(key), value]);
+  const twice = listed.find(([key], index) => listed.findIndex(([other]) => other === key) !== index);
+  if (twice) {
+    throw new PresetError(`Folder \`${twice[0]}\` is listed twice.`);
+  }
+  const folders = config.detect === false ? Object.fromEntries(listed) : presetDetect(root, Object.fromEntries(listed));
   const scopes = presetScopesTree(root, folders);
   const ignored = new Set(Object.entries(folders).flatMap(([key, value]) => value === false ? [presetNormalizeKey(key)] : []));
   const live = scopes.filter((scope) => !ignored.has(scope.key));
-  const [rootScope] = scopes;
-  const rootKind = presetKind(".", (name) => Boolean(rootScope.effective[name])).kind;
   const dead = live.find((scope) => scope.parent && ignored.has(scope.parent.key) && scope.parent.depth < scope.depth);
   if (dead) {
     throw new PresetError(`Folder \`${dead.key}\` sits inside the skipped folder \`${dead.parent?.key}\`.`);
   }
-  const candidates = [];
-  for (const scope of scopes) {
-    const top = scope.parent?.key === "." && (rootKind === "library" || presetKindGroups.some((name) => presetSets(scope.folder, name)));
-    const sibling = scope.parent !== null && candidates.includes(scope.parent) && scope.parent.depth === scope.depth && !scope.key.includes("*");
-    if (top || sibling) {
-      candidates.push(scope);
-    }
-  }
-  const unitScopes = candidates.filter((scope) => !ignored.has(scope.key));
-  const explicit = new Set(unitScopes.map((scope) => scope.key));
-  const rootUnit = rootKind !== "library" || unitScopes.length === 0;
-  const units = [...rootUnit ? [rootScope] : [], ...unitScopes].flatMap((scope) => {
-    if (!scope.key.endsWith("/*")) {
-      return [presetUnit(root, scope.key, scope)];
-    }
-    const base = scope.key.slice(0, -2);
-    return readdirSync2(resolve5(root, base)).filter((name) => !name.startsWith(".") && statSync2(resolve5(root, base, name)).isDirectory()).map((name) => posix4.join(base, name)).filter((key) => !explicit.has(key) && !ignored.has(key)).map((key) => presetUnit(root, key, scope));
-  });
+  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);
+  const servicesKey = live.find((scope) => !unitKeys.has(scope.key) && scope.folder.services !== undefined);
+  if (servicesKey) {
+    throw new PresetError(`Set services on an app or package folder, not on \`${servicesKey.key}\`.`);
+  }
   if (misplaced) {
     throw new PresetError(`Set layout.operations on an app or package folder, not on \`${misplaced.key}\`.`);
   }
@@ -1791,6 +2043,7 @@ function presetProject(config) {
   const libraryUnits = of("library");
   const packageSources = libraryUnits.map((unit) => unit.source);
   const app = [...web, ...backend, ...packageSources];
+  const serviceFolders = Object.fromEntries(units.map((unit) => [unit.source, unit.services]));
   const appFiles = presetScopes(app);
   const webFiles = presetScopes(web);
   const effective = live.map((scope) => scope.effective);
@@ -1804,9 +2057,9 @@ function presetProject(config) {
   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) => posix4.join(unit.source, "services", unit.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts")) : [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 kitUnits = units.filter((unit) => unit.scope.effective.kit);
-  const uiRoots = [...new Set([...web.map((path) => posix4.join(path, "components/ui")), ...kitUnits.map((unit) => unit.source)])];
+  const uiRoots = [...new Set([...web.map((path) => posix7.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;
@@ -1814,7 +2067,7 @@ function presetProject(config) {
       return;
     }
     const css = tailwind.css ?? presetStylesheet(root, unit.key);
-    return css === undefined ? undefined : resolve5(root, css);
+    return css === undefined ? undefined : resolve7(root, css);
   };
   const webCss = Object.fromEntries(webUnits.flatMap((unit) => {
     const css = stylesheet(unit);
@@ -1848,20 +2101,21 @@ function presetProject(config) {
       return [key];
     }
     const base = key.slice(0, -2);
-    return readdirSync2(resolve5(root, base)).filter((name) => statSync2(resolve5(root, base, name)).isDirectory()).map((name) => posix4.join(base, name)).filter((path) => !live.some((scope) => scope.key === path));
+    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 {
     root,
+    serviceFolders,
     scopes: live,
     units,
     suffixes,
     colocated: listOf(effective.map((groups) => groups.types?.colocated)),
     orpc: {
-      public: publicProcedures.length > 0 ? publicProcedures : backendUnits.map((unit) => posix4.join(unit.source, "rpc/api")).filter((path) => existsSync3(resolve5(root, path))).map((path) => `${path}/**`),
+      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)),
       client: client ?? ""
     },
-    layouts: units.flatMap((unit) => Object.entries(unit.layout).map(([folder, mode]) => ({ path: posix4.join(unit.source, folder), folder, mode }))),
+    layouts: units.flatMap((unit) => Object.entries(unit.layout).map(([folder, mode]) => ({ path: folder === "services" ? unit.services : posix7.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),
@@ -1884,7 +2138,7 @@ function presetProject(config) {
       ...presetScopes(packageSources, `hooks/**/${presetExtensions}`)
     ],
     backendFiles: presetScopes(backend),
-    services: presetScopes(app, `services/**/${presetExtensions}`),
+    services: presetServiceScopes(serviceFolders, app),
     utilities: ["**/*.utils.ts", "**/*.constants.ts", "**/*.types.ts"],
     types: presetScopes(app, "types/**"),
     uiRoots,
@@ -1898,7 +2152,9 @@ function presetProject(config) {
     publicEntrypoints,
     baseImports: presetBaseImports,
     css: { ...webCss, ...kitCss },
-    ignores: skipped.map((key) => `${key}/**`)
+    registries: backendUnits.flatMap((unit) => presetRegistryFile(root, unit.source, unit.scope.effective.backend?.registry, unit.services) ?? []),
+    ignores: skipped.map((key) => `${key}/**`),
+    outputs: [".", ...units.map((unit) => unit.key)].flatMap((key) => presetOutputFolders.map((folder) => key === "." ? `${folder}/**` : `${key}/${folder}/**`))
   };
 }
 
@@ -2048,10 +2304,7 @@ function preset(config) {
     plugins: ["typescript", "react", "react-perf", "jsx-a11y", "import", "unicorn", "promise", "vitest", "node", "oxc"],
     ignorePatterns: [
       "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/coverage/**",
-      "**/.output/**",
+      ...project.outputs,
       ...project.nextWeb.length > 0 ? ["**/.next/**", "**/next-env.d.ts"] : [],
       ...project.expoWeb.length > 0 ? ["**/.expo/**", "**/expo-env.d.ts"] : [],
       ...project.generated,