oxlint-plugin-arch 0.12.1 → 0.12.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.12.2
+
+### Added
+
+- Preset: folder key `services` names an app's or package's service folder inside `source` (default `services`). An app or backend without `services/` uses `lib/` as its service folder, so a flat `lib/` gets the same layout, naming, import-boundary and registry checks; next to `services/`, `lib/` stays portable helpers. `arch/boundaries-imports` gets the matching `services` option.
+
+### Fixed
+
+- `arch/schemas-local` no longer reports `z.config(...)` and zod's error formatters (`prettifyError`, `treeifyError`, `flattenError`, `formatError`), or an import used only for them; they build no schema. The new `calls` option sets that list.
+
 ## 0.12.1
 
 ### Changed

package/dist/index.js

@@ -1111,15 +1111,19 @@ function boundariesContains(directory, candidate) {
 function boundariesStripExtension(path) {
   return path.replace(/\.[cm]?[jt]sx?$/, "");
 }
-function boundariesDomain(path, appRoot) {
+function boundariesServiceFolder(options, root) {
+  const nested = [...options.web, ...options.backend].filter((other) => other.length > root.length && boundariesContains(root, other));
+  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/services`;
+}
+function boundariesDomain(path, appRoot, services) {
   const relative = path.slice(appRoot.length + 1);
   if (relative.startsWith("types/") && relative.endsWith(".types.ts")) {
     return relative.slice("types/".length).split(".")[0];
   }
-  if (!relative.startsWith("services/")) {
+  if (!boundariesContains(services, path) || path === services) {
     return;
   }
-  const parts = relative.slice("services/".length).split("/");
+  const parts = path.slice(services.length + 1).split("/");
   return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(/-(?:action|query|driver)$/, "");
 }
 function boundariesPrivateDomain({ options, file, target, reExport, roots, owner }) {
@@ -1128,8 +1132,8 @@ function boundariesPrivateDomain({ options, file, target, reExport, roots, owner
     return;
   }
   const targetOwner = roots.find((path) => boundariesContains(path, target));
-  const fileDomain = owner ? boundariesDomain(file, owner) : undefined;
-  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner) : undefined;
+  const fileDomain = owner ? boundariesDomain(file, owner, boundariesServiceFolder(options, owner)) : undefined;
+  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
   const sameDomain = owner && owner === targetOwner && fileDomain && fileDomain === targetDomain;
   const targetStem = boundariesStripExtension(target);
   const publicSurface = boundariesPublicSurface.test(targetStem) && !boundariesActionOrQuery.test(targetStem);
@@ -1144,11 +1148,11 @@ function boundariesPrivateDomain({ options, file, target, reExport, roots, owner
 }
 function boundariesPortableLib(check) {
   const { options, file, source, target, typeOnly, reExport, roots, web, backendImport } = check;
-  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file)) {
+  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file) || boundariesServiceFolder(options, web) === `${web}/lib`) {
     return;
   }
   const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
-  const appService = roots.some((path) => boundariesContains(`${path}/services`, portableTarget));
+  const appService = roots.some((path) => boundariesContains(boundariesServiceFolder(options, path), portableTarget));
   const backendTarget = options.backend.some((path) => boundariesContains(path, portableTarget));
   const appPackage = boundariesMatchesImport(options.appPackages, source);
   if (backendImport || backendTarget || appService || appPackage) {
@@ -1175,6 +1179,7 @@ var boundariesImports = defineRule7({
           backend: { type: "array", items: { type: "string" } },
           packages: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
           roles: { type: "array", items: { type: "string" } },
+          services: { type: "array", items: { type: "string" } },
           portable: { type: "boolean" },
           backendPackages: { type: "array", items: { type: "string" } },
           entrypoints: { type: "array", items: { type: "string" } },
@@ -1200,11 +1205,14 @@ var boundariesImports = defineRule7({
       const imported = { options, file, source, target, typeOnly, reExport, roots, owner, web, backendImport };
       const inPackage = [options.packages].flat().some((path) => path && boundariesContains(path, file));
       const appTarget = backendImport || options.web.some((path) => boundariesContains(path, target)) || boundariesMatchesImport(options.appPackages, source);
-      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && /\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target);
+      const serviceFolders = roots.map((path) => boundariesServiceFolder(options, path));
+      const serviceTarget = serviceFolders.find((folder) => boundariesContains(folder, target));
+      const serviceFile = serviceFolders.find((folder) => boundariesContains(folder, file));
+      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && (/\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target) || serviceTarget !== undefined && /\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/)/.test(target.slice(serviceTarget.length)));
       const reason = [
         web && backendImport && !options.entrypoints.includes(source) ? "frontend code uses only public backend entry points" : undefined,
         inPackage && appTarget ? "shared packages do not import app internals" : undefined,
-        file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
+        (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) || serviceFile !== undefined && /^\/service(?:\.ts)?$/.test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
         domainContract ? "domain types/constants use type-only imports from implementations" : undefined,
         file.endsWith(".client.ts") && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
         boundariesPrivateDomain(imported),
@@ -1245,9 +1253,9 @@ var boundariesImports = defineRule7({
         }
       },
       TSImportType(node) {
-        const { portable: portableLib, web } = { ...boundariesImportsDefaults, ...optionsFirst(context) };
+        const options = { ...boundariesImportsDefaults, ...optionsFirst(context) };
         const file = context.filename.replaceAll("\\", "/");
-        if (portableLib && web.some((path) => file.startsWith(`${path}/lib/`))) {
+        if (options.portable && options.web.some((path) => file.startsWith(`${path}/lib/`) && boundariesServiceFolder(options, path) !== `${path}/lib`)) {
           check(node, node.source.value, true);
         }
       }
@@ -5394,6 +5402,7 @@ var schemasInline = defineRule46({
 import { defineRule as defineRule47 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
+var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
 var schemasLocal = defineRule47({
   meta: {
     type: "problem",
@@ -5404,6 +5413,7 @@ var schemasLocal = defineRule47({
         properties: {
           packages: { type: "array", items: { type: "string" } },
           namespaces: { type: "array", items: { type: "string" } },
+          calls: { type: "array", items: { type: "string" } },
           allow: { type: "array", items: { type: "string" } },
           patterns: { type: "array", items: { type: "string" } },
           message: { type: "string" },
@@ -5421,8 +5431,15 @@ var schemasLocal = defineRule47({
   createOnce(context) {
     let constructors = new Set;
     let packages = new Set;
+    let calls = new Set;
+    let pending = [];
+    let schemaUses = new Set;
+    let callUses = new Set;
     let importMessage = schemasLocalImportMessage;
     let constructionMessage = schemasLocalConstructionMessage;
+    function isAllowedCall(node, member) {
+      return member?.type === "MemberExpression" && member.object === node && !member.computed && member.property.type === "Identifier" && calls.has(member.property.name) && member.parent.type === "CallExpression" && member.parent.callee === member;
+    }
     function isPackage(source) {
       return packages.has(source) || [...packages].some((name) => source.startsWith(`${name}/`));
     }
@@ -5447,6 +5464,10 @@ var schemasLocal = defineRule47({
         const filename = context.filename.replaceAll("\\", "/");
         constructors = new Set(options.namespaces);
         packages = new Set(options.packages);
+        calls = new Set(options.calls ?? schemasLocalCalls);
+        pending = [];
+        schemaUses = new Set;
+        callUses = new Set;
         importMessage = options.importMessage ?? options.message ?? schemasLocalImportMessage;
         constructionMessage = options.constructionMessage ?? options.message ?? schemasLocalConstructionMessage;
         if ((options.allow ?? []).some((suffix) => filename.endsWith(suffix)) || (options.patterns ?? []).some((pattern) => new RegExp(pattern).test(filename))) {
@@ -5464,7 +5485,27 @@ var schemasLocal = defineRule47({
         for (const name of locals) {
           constructors.add(name);
         }
-        reportRuntimeImport(node, node.source.value);
+        if (locals.length === 0) {
+          reportRuntimeImport(node, node.source.value);
+          return;
+        }
+        pending.push({ node, locals });
+      },
+      Identifier(node) {
+        if (!constructors.has(node.name) || node.parent.type.startsWith("Import")) {
+          return;
+        }
+        if (isAllowedCall(node, node.parent)) {
+          callUses.add(node.name);
+          return;
+        }
+        schemaUses.add(node.name);
+      },
+      "Program:exit"() {
+        const runtime = pending.filter(({ locals }) => locals.some((name) => schemaUses.has(name) || !callUses.has(name)));
+        for (const { node } of runtime) {
+          reportRuntimeImport(node, node.source.value);
+        }
       },
       ExportNamedDeclaration: checkReexport,
       ExportAllDeclaration: checkReexport,
@@ -5473,7 +5514,7 @@ var schemasLocal = defineRule47({
         while (root.type === "MemberExpression") {
           root = root.object;
         }
-        if (root.type !== "Identifier" || !constructors.has(root.name)) {
+        if (root.type !== "Identifier" || !constructors.has(root.name) || node.callee.type === "MemberExpression" && node.callee.object === root && isAllowedCall(root, root.parent)) {
           return;
         }
         context.report({

package/dist/preset/preset-detect.d.ts

@@ -1,3 +1,3 @@
 import type * as PresetTypes from '../types/preset.types.ts';
-export declare function presetRegistryFile(root: string, source: string, configured: PresetTypes.PresetBackendOptions['registry']): string | undefined;
+export declare function presetRegistryFile(root: string, source: string, configured: PresetTypes.PresetBackendOptions['registry'], services: string): string | undefined;
 export declare function presetDetect(root: string, folders: PresetTypes.PresetFolders): PresetTypes.PresetFolders;

package/dist/preset/preset.js

@@ -2,11 +2,11 @@
 import { createRequire } from "node:module";
 
 // src/preset/groups/backend.ts
-import { posix as posix2, resolve as resolve3 } 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, resolve as resolve2 } from "node:path";
+import { matchesGlob, posix as posix2, resolve as resolve2 } from "node:path";
 
 // src/preset/preset-recipes.ts
 var presetUi = { react: true, kit: true, tailwind: true };
@@ -464,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",
@@ -514,7 +514,7 @@ var presetDetectDesktop = ["electrobun", "electron", "@tauri-apps/api", "@tauri-
 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/*"];
@@ -528,12 +528,15 @@ var presetPackageImports = { "../../apps/**": "Packages stay app-agnostic; do no
 
 // src/preset/preset.utils.ts
 import { readFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+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,
@@ -611,7 +614,7 @@ 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]
       })
     ];
@@ -631,6 +634,16 @@ function presetIsDirectory(path) {
     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;
@@ -644,35 +657,36 @@ function presetDirectories(root, base, skip = presetDetectSkip) {
   if (!presetIsDirectory(resolve2(root, base))) {
     return [];
   }
-  return readdirSync(resolve2(root, base)).filter((name) => !name.startsWith(".") && !skip.includes(name) && presetIsDirectory(resolve2(root, base, name))).map((name) => posix.join(base, name));
+  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 posix.join(directory, configured);
+    return posix2.join(directory, configured);
   }
-  return existsSync(resolve2(root, directory, "src")) ? posix.join(directory, "src") : directory;
+  return existsSync(resolve2(root, directory, "src")) ? posix2.join(directory, "src") : directory;
 }
-function presetRegistryFile(root, source, configured) {
+function presetRegistryFile(root, source, configured, services) {
   if (configured === false) {
     return;
   }
   const file = typeof configured === "string" ? configured : configured?.file;
   if (file !== undefined) {
-    return posix.normalize(file);
+    return posix2.normalize(file);
   }
-  return presetRegistryFiles.map((path) => posix.join(source, path)).find((path) => existsSync(resolve2(root, path)));
+  return [posix2.join(services, "service.ts"), ...presetRegistryFiles.map((path) => posix2.join(source, path))].find((path) => existsSync(resolve2(root, path)));
 }
-function presetDomains(root, source) {
-  return presetDirectories(root, posix.join(source, "services"), presetNamedSkip).map((path) => posix.basename(path)).filter((name) => existsSync(resolve2(root, source, "services", name, `${name}.service.ts`)));
+function 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, configured) {
+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, configured);
+  const source = presetSource(root, directory, folder.source);
   const framework = presetDetectFrameworks.find(([, names]) => has(names))?.[0];
-  const services = resolve2(root, source, "services");
+  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;
@@ -682,7 +696,7 @@ function presetRecipe(root, directory, app, configured) {
   if (has(presetDetectDesktop)) {
     return presetRecipes.desktop;
   }
-  if (presetDomains(root, source).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services))) {
+  if (presetDomains(root, servicesFolder).length > 0 || has(presetDetectBackend) && (app || presetIsDirectory(services))) {
     return presetRecipes.backend;
   }
   if (has(["react"]) && presetIsDirectory(resolve2(root, source, "components"))) {
@@ -720,7 +734,7 @@ function presetImportTargets(value) {
 }
 function presetSpecifiers(manifest, target, file = false) {
   const specifiers = Object.entries(manifest.imports ?? {}).flatMap(([key, value]) => presetImportTargets(value).flatMap((mapped) => {
-    const path = posix.normalize(mapped);
+    const path = posix2.normalize(mapped);
     const parts = path.split("*");
     const keyParts = key.split("*");
     if (parts.length === 1 && keyParts.length === 1) {
@@ -758,13 +772,15 @@ function presetFilled(conventions, exists) {
 function presetBackendConventions(root, key, value, denied) {
   const manifest = presetManifest(root, key);
   const source = presetSource(root, key, value.source);
-  const local = posix.relative(key, source) || ".";
-  const at = (path) => local === "." ? path : posix.join(local, path);
+  const 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 registryFile = presetRegistryFile(root, source, configured);
-  const registry = registryFile === undefined ? undefined : posix.relative(key, registryFile);
-  const services = presetSpecifiers(manifest, at("services"));
+  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."])) : {};
@@ -774,7 +790,7 @@ function presetBackendConventions(root, key, value, denied) {
     Object.assign(serviceImports, entries);
   }
   const conventions = {
-    [at("services")]: presetDeny(serviceImports),
+    [servicesKey]: presetDeny(serviceImports),
     [at("core")]: presetDeny(operations),
     [at("rpc")]: presetDeny(registryImports),
     [at("routes")]: presetDeny(registryImports),
@@ -783,24 +799,24 @@ function presetBackendConventions(root, key, value, denied) {
       ...presetDeny({ ...operations, ...Object.fromEntries(services.map((prefix) => [`${prefix}/*/*.service`, "Reach services through the registry."])) })
     }
   };
-  for (const domain of presetDirectories(root, posix.join(source, "services"), presetNamedSkip).map((path) => posix.basename(path))) {
+  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[at(`services/${domain}`)] = presetDeny(Object.fromEntries(imports));
+    conventions[posix2.join(servicesKey, domain)] = presetDeny(Object.fromEntries(imports));
   }
   for (const tests of ["tests", "test"]) {
-    if (exists(posix.join(tests, "kits"))) {
+    if (exists(posix2.join(tests, "kits"))) {
       conventions[tests] = presetDeny(Object.fromEntries(presetKitImports.map((pattern) => [pattern, "Import the kit file you need."])));
-      conventions[posix.join(tests, "kits")] = { naming: { files: presetKitFiles } };
+      conventions[posix2.join(tests, "kits")] = { naming: { files: presetKitFiles } };
     }
   }
   const queue = ["."];
   while (queue.length > 0) {
     const folder = queue.shift() ?? ".";
-    for (const child of presetDirectories(root, posix.join(key, folder)).map((path) => posix.relative(key, path))) {
-      if (posix.basename(child) === "migrations") {
+    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);
@@ -810,8 +826,8 @@ function presetBackendConventions(root, key, value, denied) {
   return presetFilled(conventions, exists);
 }
 function presetWebConventions(root, key, value, servers) {
-  const source = posix.relative(key, presetSource(root, key, value.source)) || ".";
-  const at = (path) => source === "." ? path : posix.join(source, path);
+  const 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(/\*$/, "**")));
@@ -856,7 +872,7 @@ function presetWorkspacePatterns(root, manifest) {
   return patterns;
 }
 function presetWorkspaces(root, patterns) {
-  const clean = (pattern) => posix.normalize(pattern.replace(/^\.\//, "")).replace(/\/$/, "");
+  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));
@@ -895,16 +911,16 @@ function presetGroupOff(folders, path, group) {
 }
 function presetDetect(root, folders) {
   const manifest = presetManifest(root, ".");
-  const configuredSource = (key) => {
+  const configured = (key) => {
     const value = folders[key];
-    return value instanceof Object ? value.source : undefined;
+    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/"), configuredSource(directory))]));
-  const rootRecipe = presetRecipe(root, ".", true, configuredSource("."));
+  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, ".", configuredSource(".")) !== ".";
+  const rootApp = rootRecipe !== presetRecipes.library && presetSource(root, ".", configured(".").source) !== ".";
   if (patterns.length === 0 ? single : rootApp) {
     detected["."] = rootRecipe;
   }
@@ -912,7 +928,7 @@ function presetDetect(root, folders) {
     detected.scripts = presetRecipes.cli;
   }
   const keys = Object.keys(folders);
-  const covered = (key) => keys.some((user) => user !== key && user !== "." && (key.startsWith(`${user}/`) || user.endsWith("/*") && posix.dirname(key) === user.slice(0, -2)));
+  const 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)) {
@@ -953,11 +969,11 @@ function presetDetect(root, folders) {
     }
     if (value.backend) {
       for (const [path, folder] of Object.entries(presetBackendConventions(root, key, value, denied))) {
-        add(path === "." ? key : posix.join(key, path), folder);
+        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 : posix.join(key, path), folder);
+        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 ?? {});
@@ -985,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 : posix2.normalize(configured.file);
+  const file = configured.file === undefined ? undefined : posix3.normalize(configured.file);
   const registries = file === undefined ? backendUnits.flatMap((unit) => {
-    const found = presetRegistryFile(project.root, unit.source, undefined);
+    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) {
@@ -996,7 +1012,7 @@ var backendGroup = (project, settings) => {
     }
     const options = {
       registry: resolve3(project.root, registry.file),
-      services: resolve3(project.root, registry.unit.source, "services"),
+      services: resolve3(project.root, registry.unit.services),
       skip: configured.skip ?? (file === undefined ? presetRegistrySkip : [])
     };
     if (configured.object !== undefined) {
@@ -1014,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." }] })] : [],
@@ -1045,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 } }] }));
@@ -1151,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"]),
@@ -1163,18 +1180,18 @@ var importsGroup = (project, settings) => {
 };
 
 // src/preset/groups/layout.ts
-import { posix as posix3 } 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 === posix3.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) => posix3.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": [
@@ -1207,7 +1224,7 @@ var layoutGroup = (project, settings) => {
     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",
         {
@@ -1217,7 +1234,7 @@ 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,
       ...testFiles
@@ -1227,22 +1244,22 @@ var layoutGroup = (project, settings) => {
       "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([...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(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, 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." }]
     })
   ];
@@ -1270,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;
@@ -1309,7 +1326,7 @@ var namingGroup = (project, settings, owner) => {
   add("files", presetScopes(app, "types/**/*.ts"), { "arch/naming-file": ["error", { pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*[.]types[.]ts$", message: "Use domain.types.ts filenames." }] }, ["**/*.constants.ts"]);
   add("exports", presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/naming-exports": ["error", presetExportPrefix] }, [...ui, ...presetScopes(serviceRoots, "entry.*.ts")]);
   add("exports", frontendEntries, { "arch/naming-exports": ["error", namingFrontendPrefix] }, testFiles);
-  add("exports", presetScopes(web, "services/**/*.constants.ts"), { "arch/naming-exports": ["error", { ...presetExportPrefix, scope: "declarations", allow: "^\\*$" }] }, testFiles);
+  add("exports", 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": [
@@ -1324,7 +1341,7 @@ 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);
@@ -1337,7 +1354,7 @@ var namingGroup = (project, settings, owner) => {
     }, 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",
@@ -1356,7 +1373,7 @@ var namingGroup = (project, settings, owner) => {
   }
   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",
@@ -1369,7 +1386,7 @@ var namingGroup = (project, settings, owner) => {
       add("exports", files, { "arch/naming-exports": ["error", namingOperationPrefix(role), namingOperation(role, `{domain}-${role}.{name}.${suffix}`)] }, testFiles);
     }
   }
-  add("exports", presetScopes(web, "services/**/*.rsc.{ts,tsx}"), { "arch/naming-exports": ["error", namingFrontendPrefix, { mode: "pattern", pattern: "^[a-z][a-z0-9]*Rsc[A-Z][a-zA-Z0-9]*$" }] }, ["**/*-{action,query}.*.rsc.{ts,tsx}", ...testFiles]);
+  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 }] }));
   }
@@ -1503,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 }
@@ -1564,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")
   ];
 };
@@ -1713,11 +1730,11 @@ var typesGroup = (project, settings) => {
 
 // src/preset/preset-folders.ts
 import { existsSync as existsSync3, readdirSync as readdirSync4, realpathSync as realpathSync2 } from "node:fs";
-import { posix as posix6, resolve as resolve7 } from "node:path";
+import { posix as posix7, resolve as resolve7 } from "node:path";
 
 // src/preset/preset-stylesheet.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync } from "node:fs";
-import { posix as posix4, resolve as resolve5 } from "node:path";
+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);
@@ -1734,9 +1751,9 @@ function presetStylesheet(root, directory) {
     }
     visited.add(real);
     for (const name of readdirSync2(resolve5(root, folder))) {
-      const path = posix4.join(folder, name);
+      const path = posix5.join(folder, name);
       const full = resolve5(root, path);
-      const depth = posix4.relative(directory, path).split("/").length;
+      const depth = posix5.relative(directory, path).split("/").length;
       if (presetIsDirectory(full)) {
         if (!name.startsWith(".") && !presetDetectSkip.includes(name) && depth < 8) {
           queue.push(path);
@@ -1747,7 +1764,7 @@ function presetStylesheet(root, directory) {
     }
   }
   const rank = (path) => {
-    const index = presetStylesheetNames.indexOf(posix4.basename(path, ".css"));
+    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);
@@ -1755,7 +1772,7 @@ function presetStylesheet(root, directory) {
 
 // src/preset/preset-units.ts
 import { existsSync as existsSync2, readdirSync as readdirSync3 } from "node:fs";
-import { posix as posix5, resolve as resolve6 } from "node:path";
+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) {
@@ -1763,9 +1780,9 @@ function presetUnitSource(root, key, kind, source) {
     if (source !== "." && !source.split("/").every((segment) => presetLiteralSegment.test(segment))) {
       throw new PresetError(`Folder \`${key}\` source must be \`.\` or a literal relative path.`);
     }
-    return posix5.join(key, source);
+    return posix6.join(key, source);
   }
-  return kind === "console" || !existsSync2(resolve6(root, key, "src")) ? key : posix5.join(key, "src");
+  return kind === "console" || !existsSync2(resolve6(root, key, "src")) ? key : posix6.join(key, "src");
 }
 function presetSets(folder, name) {
   return folder[name] !== undefined && folder[name] !== false;
@@ -1808,16 +1825,18 @@ function presetUnit(root, key, scope) {
   const layout = {};
   const settings = effective.layout;
   if (settings) {
-    const services = settings.services ?? (kind === "console" ? false : "domain");
+    const services2 = settings.services ?? (kind === "console" ? false : "domain");
     const hooks = settings.hooks ?? (kind === "web" ? "flat" : false);
-    const modes = { services, hooks, components: settings.components ?? 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 { key, scope, kind, framework, source: presetUnitSource(root, key, kind, folder.source), layout };
+  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 presetUnits(root, scopes, ignored) {
   const [rootScope] = scopes;
@@ -1844,17 +1863,17 @@ function presetUnits(root, scopes, ignored) {
       return [presetUnit(root, scope.key, scope)];
     }
     const base = scope.key.slice(0, -2);
-    return readdirSync3(resolve6(root, base)).filter((name) => !name.startsWith(".") && presetIsDirectory(resolve6(root, base, name))).map((name) => posix5.join(base, name)).filter((key) => !explicit.has(key) && !ignored.has(key)).map((key) => presetUnit(root, key, scope));
+    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
 function presetNormalizeKey(key) {
   const portable = key.replaceAll("\\", "/");
-  if (!portable.trim() || posix6.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 = posix6.normalize(portable).replace(/\/$/, "");
+  const normalized = posix7.normalize(portable).replace(/\/$/, "");
   if (normalized === ".." || normalized.startsWith("../")) {
     throw new PresetError(`Folder keys must stay inside the project: ${key}`);
   }
@@ -2004,6 +2023,10 @@ function presetProject(config) {
   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}\`.`);
   }
@@ -2020,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);
@@ -2033,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) => posix6.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) => posix6.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;
@@ -2077,20 +2101,21 @@ function presetProject(config) {
       return [key];
     }
     const base = key.slice(0, -2);
-    return readdirSync4(resolve7(root, base)).filter((name) => presetIsDirectory(resolve7(root, base, name))).map((name) => posix6.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) => posix6.join(unit.source, "rpc/api")).filter((path) => existsSync3(resolve7(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: posix6.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),
@@ -2113,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,
@@ -2127,7 +2152,7 @@ function presetProject(config) {
     publicEntrypoints,
     baseImports: presetBaseImports,
     css: { ...webCss, ...kitCss },
-    registries: backendUnits.flatMap((unit) => presetRegistryFile(root, unit.source, unit.scope.effective.backend?.registry) ?? []),
+    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}/**`))
   };

package/dist/preset/preset.utils.d.ts

@@ -3,6 +3,7 @@ import type { OxlintOverride } from 'oxlint';
 export declare class PresetError extends Error {
 }
 export declare function presetScopes(roots: string[], suffix?: string): string[];
+export declare function presetServiceScopes(folders: Record<string, string>, sources: string[], suffix?: string): string[];
 export declare function presetOverride(files: string[], rules: PresetTypes.PresetRules, excludeFiles?: string[]): OxlintOverride;
 export declare function presetSeverity(rules: PresetTypes.PresetRules, level: PresetTypes.PresetLevel): PresetTypes.PresetRules;
 export declare function presetPackageName(root: string, directory: string): string | undefined;
@@ -11,4 +12,5 @@ export declare function presetAliases(root: string, aliases: Record<string, stri
 export declare function presetRuntime(project: PresetTypes.PresetProject, settings: Required<PresetTypes.PresetFrameworkOptions>, framework: PresetTypes.PresetFramework, rule: string): OxlintOverride[];
 export declare function presetManifest(root: string, directory: string): PresetTypes.PresetManifest;
 export declare function presetIsDirectory(path: string): boolean;
+export declare function presetServicesFolder(root: string, source: string, configured?: string, fallback?: boolean): string;
 export declare function presetIsFile(path: string): boolean;

package/dist/types/boundaries.types.d.ts

@@ -4,6 +4,7 @@ export interface BoundariesOptions {
     backend: string[];
     packages: string | string[];
     roles?: string[];
+    services?: string[];
     portable?: boolean;
     backendPackages: string[];
     appPackages: string[];

package/dist/types/preset.types.d.ts

@@ -153,6 +153,7 @@ export type PresetGroupName = keyof PresetGroups;
 export interface PresetFolder extends PresetGroups {
     severity?: PresetLevel;
     source?: string;
+    services?: string;
     rules?: PresetRules;
 }
 export type PresetFolders = Record<string, boolean | PresetFolder>;
@@ -224,6 +225,7 @@ export interface PresetUnit {
     kind: PresetKind;
     framework?: PresetFramework;
     source: string;
+    services: string;
     layout: Record<string, PresetLayoutMode>;
 }
 export interface PresetLayoutScope {
@@ -261,6 +263,7 @@ export interface PresetManifest {
 }
 export interface PresetProject {
     root: string;
+    serviceFolders: Record<string, string>;
     scopes: PresetScope[];
     units: PresetUnit[];
     suffixes: string[];

package/dist/types/schemas.types.d.ts

@@ -7,6 +7,7 @@ export interface SchemasElementOptions {
 export interface SchemasLocalOptions {
     packages: string[];
     namespaces: string[];
+    calls?: string[];
     allow?: string[];
     patterns?: string[];
     message?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",