oxlint-plugin-arch 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.11.0
+
+- `modules/no-unknown` allows `unknown` on the narrowed parameter of a type guard (`function isAppError(error: unknown): error is AppError`) and on the error parameter of a catch callback (`catch: (error: unknown) => E`, `.catch((error: unknown) => …)`). Other uses still fail. This applies to every root.
+- `arch/no-trivial-functions` no longer reports type guards with a predicate return type as pass-through wrappers. Banned names and structurally generic guards are still reported.
+- Package schemas: construction is allowed only in `types/**`. Package `*.types.ts` files outside `types/` are reported again (fix: move them to `src/types/`), matching `arch/no-restricted-files`.
+- Hook filenames accept a React Native platform suffix: `use-chat-draft.web.ts`, `.native.ts`, `.ios.ts` and `.android.ts`. This applies to web roots and packages.
+- A UI kit outside every web root, resolved from `shadcn.ui`, gets the Tailwind checks. Its stylesheet is `tailwind.cssEntryPointsByRoot` for the kit's package folder or architecture root, otherwise the one stylesheet the web roots share. With several web stylesheets and no entry, the preset throws and names `cssEntryPointsByRoot`.
+
+| Fix | Rules |
+| --- | --- |
+| Auto-fix (`--fix`) | `tailwindcss/*` sort, canonical, shorthand and whitespace rules on a kit package |
+| Move | `arch/no-local-schema-construction` in package `*.types.ts` outside `types/` (to `src/types/`) |
+| Reshape | `tailwindcss/no-conflicting-classes`, `tailwindcss/no-deprecated-classes` on a kit package |
+
+## 0.10.0
+
+**Breaking:** `packages` roots now get the app rules. Until now they only got the shared baseline (formatting, imports, stock TypeScript/JavaScript rules and `modules/import-boundaries`), so expect new errors in package `src` folders.
+
+- A packages root with its own `package.json` is one package. Without one, each child folder is a package, so `packages: 'packages'` covers every `packages/*/src`. Per-package entries keep working. Files outside `src` keep the baseline only.
+- Every package file gets the app-wide rules: `arch/no-comments` (with the stricter `*.types.ts`/`*.constants.ts` variant), the `typeSafety` set (including the `dillon-anti-slop/*` rules), `arch/no-type-declarations`, `arch/no-local-schema-construction`, `arch/no-rederive-schema`, `arch/no-module-mutable-state`, `modules/double-negation`, `arch/no-trivial-functions`, `max-lines` and `complexity`.
+- Services, types and file roles in packages follow the server-root rules: `modules/service-functions`, `modules/service-types`, `modules/domain-constants`, `arch/require-object-params`, `arch/no-extra-exports`, `arch/no-inline-types`, `arch/export-file-prefix`, `arch/no-restricted-files`, `arch/no-top-level-functions`, `arch/filename-match`, `arch/filename-export-name`, `arch/folder-prefix` and `arch/no-unescaped-like`. Packages default to the `services: 'domain'` layout, and `layout` keys on a packages root now resolve inside `src`. `entry.*.ts` files stay exempt from `arch/export-file-prefix`, as in server roots.
+- React code in packages (`*.tsx`, `components/**`, `hooks/**`) follows the web-root rules: the React, effects, memoization and forms policies, `arch/jsx-attributes-multiline`, `arch/no-file-level-helpers`, `arch/component-props`, `arch/declaration-name`, `modules/local-type-alias`, `modules/pascal-interface`, `arch/only-export-components` and the hook naming rules. The React plugins now load when packages exist, even without a web root.
+- Package `types/**` and `*.types.ts` files may construct schemas, like backend `types/**`.
+- Never on packages: `modules/backend-switch`, `modules/rpc-database`, `arch/require-orpc-output`, `modules/tanstack-runtime`, `arch/no-restricted-token`, `arch/no-runtime-in-types` and `modules/dynamic-classes`. Routes, Tailwind and shadcn usage rules stay with web roots.
+- Rename `shadcn.uiImportPath` to `shadcn.ui` and `shadcn.componentImportSources` to `shadcn.components`, matching the components.json alias names. The old names throw. Migration: `shadcn: { uiImportPath: '@ui' }` becomes `shadcn: { ui: '@ui' }`.
+- `shadcn.ui` also selects the UI kit files, which keep the existing kit exceptions (type safety, formatting and layout are still checked). Use a workspace package name (`'@app/ui'` → that package's `src/**`) or a tsconfig `paths` alias (`'@/kit'` → `<root>/src/kit/**`). A value that resolves to nothing throws. When unset, the kit stays `<web source>/components/ui/**`. A UI kit in a package needs `shadcn: { ui: '<package name>' }`; without it, the kit gets the full package rules.
+
+How to fix what the new rules report:
+
+| Fix | Rules |
+| --- | --- |
+| Auto-fix (`--fix`) | `arch/no-comments`, `arch/jsx-attributes-multiline`, the `react-extra/jsx-*` layout rules |
+| Rename | `arch/export-file-prefix`, `arch/filename-match`, `arch/filename-export-name`, `arch/folder-prefix`, `arch/declaration-name`, `arch/export-name-pattern`, `modules/pascal-interface`, `modules/shape-suffix` |
+| Move | `arch/no-type-declarations` (to `types/`), `arch/no-local-schema-construction` (to `types/` or `*.types.ts`), `arch/no-restricted-files`, `arch/no-extra-exports`, `arch/only-export-components`, `arch/no-file-level-helpers`, `modules/domain-constants`, `modules/service-types`, `modules/local-type-alias`, `max-lines` |
+| Reshape | `arch/require-object-params`, `arch/component-props`, `arch/no-inline-types`, `arch/no-trivial-functions`, `arch/no-module-mutable-state`, `arch/no-restricted-constructor`, `modules/service-functions`, `modules/no-unknown`, `modules/memoization`, `typescript/no-explicit-any`, the `dillon-anti-slop/*` rules, the React and effects rules, `complexity` |
+
+To defer a package, turn single rules off for it: `ruleExclusions: { '<rule>': ['packages/foo/**'] }`.
+
 ## 0.9.0
 
 - Add `limits.maxTypeFileLines` (default `1000`): the preset applies this `max-lines` limit to `*.types.ts` files in app roots instead of `limits.maxFileLines`. Other files keep `maxFileLines`.

package/dist/index.js

@@ -4089,7 +4089,7 @@ var noTrivialFunctions = defineRule32({
           }
           seen.add(key);
           checkHelper(item.node);
-          if (reported.has(item.node.start))
+          if (reported.has(item.node.start) || item.node.returnType?.typeAnnotation.type === "TSTypePredicate")
             continue;
           const expression = trivialExpression(item.node);
           const trivial2 = mode === "legacy" ? declarationsIsTrivialFunction(item.node) : expression ? trivialIsForwarder(item.node, expression) : declarationsIsTrivialFunction(item.node);

package/dist/presets/index.js

@@ -1,6 +1,6 @@
 // src/utils/helpers/preset.ts
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
 
 // src/constants/preset.constants.ts
 var presetExtensions = "*.{ts,tsx,mts,cts}";
@@ -504,6 +504,61 @@ function presetSeverity(rules, level) {
   }
   return result;
 }
+function presetReadJsonc(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return;
+  }
+  let output = "";
+  for (let index = 0;index < text.length; index++) {
+    const character = text[index];
+    if (character === '"') {
+      const end = /"(?:[^"\\]|\\.)*"/y;
+      end.lastIndex = index;
+      const literal = end.exec(text)?.[0] ?? text.slice(index);
+      output += literal;
+      index += literal.length - 1;
+    } else if (character === "/" && text[index + 1] === "/") {
+      index = text.indexOf(`
+`, index) === -1 ? text.length : text.indexOf(`
+`, index) - 1;
+    } else if (character === "/" && text[index + 1] === "*") {
+      index = text.indexOf("*/", index + 2) === -1 ? text.length : text.indexOf("*/", index + 2) + 1;
+    } else if (character === "}" || character === "]") {
+      output = output.replace(/,\s*$/, "") + character;
+    } else {
+      output += character;
+    }
+  }
+  try {
+    return JSON.parse(output);
+  } catch {
+    return;
+  }
+}
+function presetTsconfigAliasTargets(root, directory, specifier) {
+  const config = presetReadJsonc(resolve(root, directory, "tsconfig.json"));
+  if (!config || typeof config !== "object" || !("compilerOptions" in config))
+    return [];
+  const { compilerOptions } = config;
+  if (!compilerOptions || typeof compilerOptions !== "object" || !("paths" in compilerOptions))
+    return [];
+  const { paths } = compilerOptions;
+  const baseUrl = "baseUrl" in compilerOptions && typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : ".";
+  if (!paths || typeof paths !== "object")
+    return [];
+  return Object.entries(paths).flatMap(([pattern, targets]) => {
+    const [prefix, suffix = ""] = pattern.split("*");
+    const wildcard = pattern.includes("*");
+    const matches = wildcard ? specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length : specifier === pattern;
+    if (!matches || !Array.isArray(targets))
+      return [];
+    const captured = wildcard ? specifier.slice(prefix.length, specifier.length - suffix.length) : "";
+    return targets.filter((target) => typeof target === "string").map((target) => relative(root, resolve(root, directory, baseUrl, target.replace("*", captured))).replaceAll("\\", "/")).filter((target) => target && !target.startsWith("..") && existsSync(resolve(root, target)));
+  });
+}
 
 // src/configs/source.ts
 function presetSourceConfig(context) {
@@ -591,6 +646,8 @@ function presetTypesConfig(context) {
     options,
     web,
     backend,
+    packageSources,
+    serviceRoots,
     app,
     appFiles,
     webFiles,
@@ -640,7 +697,11 @@ function presetTypesConfig(context) {
     presetOverride(presetScopes(app, "**/*.{utils,constants}.ts"), {
       "arch/no-type-declarations": "error"
     }, [...ui, ...testFiles]),
-    presetOverride([...presetScopes(schemaOwners, "types/**/*.types.ts"), ...colocatedTypes, ...presetScopes(app, "**/*.constants.ts")], {
+    presetOverride([
+      ...presetScopes([...schemaOwners, ...packageSources], "types/**/*.types.ts"),
+      ...colocatedTypes,
+      ...presetScopes(app, "**/*.constants.ts")
+    ], {
       "arch/no-top-level-functions": ["error", { banReExports: false }]
     }),
     ...runtimeFreeTypes.length ? [
@@ -684,8 +745,12 @@ function presetTypesConfig(context) {
   policies.schemas = [
     presetOverride(appFiles, {
       "arch/no-local-schema-construction": ["error", { packages: ["zod"], namespaces: ["z"] }]
-    }, [...presetScopes(schemaOwners, "types/**"), ...colocatedTypes, ...ui]),
-    presetOverride(webFiles, {
+    }, [
+      ...presetScopes([...schemaOwners, ...packageSources], "types/**"),
+      ...colocatedTypes,
+      ...ui
+    ]),
+    presetOverride([...webFiles, ...presetScopes(packageSources)], {
       "arch/no-rederive-schema": [
         "error",
         {
@@ -695,7 +760,7 @@ function presetTypesConfig(context) {
         }
       ]
     }),
-    presetOverride(presetScopes(backend, "services/**/*.ts"), {
+    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), {
       "arch/no-unescaped-like": [
         "error",
         {
@@ -725,7 +790,7 @@ function presetTypesConfig(context) {
 // src/configs/modules.ts
 import { posix } from "node:path";
 function presetModulesConfig(context) {
-  const { web, nextWeb, backend, app, services, utilities, ui, testFiles, components, hooks, options } = context;
+  const { web, nextWeb, serviceRoots, app, services, utilities, ui, testFiles, components, hooks, options } = context;
   const conceptFiles = (options.modules?.customFileRoles ?? []).map((role) => `**/*.${role}.ts`);
   const migrations = options.modules?.migrationFiles ?? [];
   const frontendEntries = [
@@ -822,7 +887,7 @@ function presetModulesConfig(context) {
         }
       ]
     }, testFiles),
-    presetOverride(presetScopes(backend, "services/**/*.ts"), { "modules/domain-constants": "error" }, [
+    presetOverride(presetScopes(serviceRoots, "services/**/*.ts"), { "modules/domain-constants": "error" }, [
       ...utilities,
       ...testFiles
     ]),
@@ -832,11 +897,11 @@ function presetModulesConfig(context) {
     presetOverride(frontendEntries, {
       "modules/domain-constants": ["error", { includeData: true, allowServiceMethods: true }]
     }, testFiles),
-    presetOverride([...presetScopes(backend, "services/**/*-{action,query}.*.ts"), ...frontendEntries], { "arch/require-object-params": ["error", { maxParams: 2 }] }, testFiles),
+    presetOverride([...presetScopes(serviceRoots, "services/**/*-{action,query}.*.ts"), ...frontendEntries], { "arch/require-object-params": ["error", { maxParams: 2 }] }, testFiles),
     presetOverride(frontendEntries, {
       "arch/require-object-params": ["error", { maxParams: 2, serviceMethods: true }]
     }, testFiles),
-    presetOverride(presetScopes(backend, "services/**/*.service.ts"), {
+    presetOverride(presetScopes(serviceRoots, "services/**/*.service.ts"), {
       "arch/no-extra-exports": [
         "error",
         {
@@ -864,7 +929,7 @@ function presetModulesConfig(context) {
         }
       ]
     }, ["**/*.constants.ts"]),
-    presetOverride(presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/export-file-prefix": ["error", presetExportPrefix] }, [...ui, ...presetScopes(backend, "entry.*.ts")]),
+    presetOverride(presetScopes(app, "**/*.{constants,utils,handler,service,types,client,server,rsc}.ts"), { "arch/export-file-prefix": ["error", presetExportPrefix] }, [...ui, ...presetScopes(serviceRoots, "entry.*.ts")]),
     presetOverride(frontendEntries, {
       "arch/export-file-prefix": [
         "error",
@@ -891,13 +956,13 @@ function presetModulesConfig(context) {
       "arch/filename-match": [
         "error",
         {
-          pattern: "^use-[a-z0-9]+(?:-[a-z0-9]+)*[.]ts$",
-          message: "Hooks use use-domain.ts filenames."
+          pattern: "^use-[a-z0-9]+(?:-[a-z0-9]+)*(?:[.](?:web|native|ios|android))?[.]ts$",
+          message: "Hooks use use-domain.ts filenames, with an optional .web, .native, .ios or .android platform suffix."
         }
       ],
       "arch/export-file-prefix": "error",
       "arch/export-name-pattern": ["error", { pattern: "^use[A-Z]", ignoreTypeExports: true }]
-    }),
+    }, ui),
     presetOverride(components, {
       "arch/only-export-components": ["error", { matchFileName: true, allowTypeExports: true, trailingRoles: ["illustration"] }]
     }, [...ui, ...testFiles]),
@@ -1043,11 +1108,11 @@ function presetTestsConfig(context) {
 
 // src/configs/react.ts
 function presetReactConfig(context) {
-  const { options, web, tanstackWeb, nextWeb, webFiles, ui, testFiles, components, css } = context;
+  const { options, web, tanstackWeb, nextWeb, webFiles, reactFiles, webUiRoots, ui, testFiles, components, css } = context;
   const policies = {};
-  if (web.length) {
+  if (reactFiles.length) {
     policies.react = [
-      presetOverride(webFiles, {
+      presetOverride(reactFiles, {
         ...presetReactRules,
         ...options.react?.compiler === false ? {
           "react-perf/jsx-no-new-object-as-prop": "error",
@@ -1062,8 +1127,8 @@ function presetReactConfig(context) {
       }, [...ui, ...testFiles])
     ];
   }
-  if (web.length) {
-    policies.effects = [presetOverride(webFiles, { ...presetEffectsRules, "modules/empty-effect": "error" }, ui)];
+  if (reactFiles.length) {
+    policies.effects = [presetOverride(reactFiles, { ...presetEffectsRules, "modules/empty-effect": "error" }, ui)];
   }
   const nextPage = { bannedHooks: ["useState", "useEffect", "useMutation"], inspectExports: true };
   const routes = [
@@ -1125,9 +1190,9 @@ function presetReactConfig(context) {
   if (routes.length) {
     policies.routes = routes;
   }
-  if (web.length) {
+  if (reactFiles.length) {
     policies.forms = [
-      presetOverride(webFiles, {
+      presetOverride(reactFiles, {
         "arch/require-paired-call": [
           "error",
           {
@@ -1138,8 +1203,8 @@ function presetReactConfig(context) {
       }, ui)
     ];
   }
-  if (web.length && options.react?.compiler !== false) {
-    policies.memoization = [presetOverride(webFiles, { "modules/memoization": "error" }, ui)];
+  if (reactFiles.length && options.react?.compiler !== false) {
+    policies.memoization = [presetOverride(reactFiles, { "modules/memoization": "error" }, ui)];
   }
   if (web.length) {
     policies.rpcClientOwnership = [
@@ -1154,7 +1219,7 @@ function presetReactConfig(context) {
               },
               {
                 token: "createContext",
-                allowPathPatterns: [...presetScopes(web, "context/"), ...presetScopes(web, "components/ui/")]
+                allowPathPatterns: [...presetScopes(web, "context/"), ...webUiRoots.map((path) => `${path}/`)]
               }
             ]
           }
@@ -1224,7 +1289,7 @@ function presetReactConfig(context) {
       presetOverride(webFiles, {
         "shadcn/no-unknown-classes": ["error", { allow: [] }]
       }),
-      presetOverride(presetScopes(web, "components/ui/sonner.tsx"), {
+      presetOverride(presetScopes(webUiRoots, "sonner.tsx"), {
         "shadcn/no-unknown-classes": ["error", { allow: ["toaster", "toast"] }]
       })
     ];
@@ -1307,7 +1372,7 @@ function presetBoundariesConfig(context) {
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
 function presetPluginsConfig(context) {
-  const { options, web, css } = context;
+  const { options, reactFiles, css } = context;
   const jsPlugins = [
     { name: "eslint-js", specifier: require2.resolve("oxlint-plugin-eslint") },
     {
@@ -1336,7 +1401,7 @@ function presetPluginsConfig(context) {
     react: { version: "19" },
     "import/resolver": { node: { extensions: [".js", ".jsx", ".ts", ".tsx", ".mts", ".cts"] } }
   };
-  if (web.length) {
+  if (reactFiles.length) {
     jsPlugins.push({
       name: "react-extra",
       specifier: require2.resolve("eslint-plugin-react")
@@ -1348,8 +1413,8 @@ function presetPluginsConfig(context) {
     if (options.shadcn !== false) {
       jsPlugins.push(require2.resolve("@shadcn/lint"));
       settings.shadcn = {
-        ui: options.shadcn?.uiImportPath ?? "@/components/ui",
-        componentImports: options.shadcn?.componentImportSources ?? ["^@/components/"]
+        ui: options.shadcn?.ui ?? "@/components/ui",
+        componentImports: options.shadcn?.components ?? ["^@/components/"]
       };
     }
   }
@@ -1357,6 +1422,7 @@ function presetPluginsConfig(context) {
 }
 
 // src/services/preset-context.ts
+import { existsSync as existsSync2, readdirSync } from "node:fs";
 import { resolve as resolve3, posix as posix2 } from "node:path";
 function presetResolveContext(options) {
   const generated = presetGeneratedFiles;
@@ -1396,7 +1462,7 @@ function presetResolveContext(options) {
     if (entry.layout !== undefined && (!entry.layout || typeof entry.layout !== "object" || Array.isArray(entry.layout)))
       throw new Error("Folder layout must be a path-to-mode object.");
     const layout = {};
-    if (role === "web" || role === "server" || role === "runner") {
+    if (role !== "scripts") {
       layout.services = "domain";
     }
     if (role === "web") {
@@ -1453,6 +1519,8 @@ function presetResolveContext(options) {
   if (options.framework !== undefined && options.framework !== "tanstack-start" && options.framework !== "next")
     throw new Error(`Unknown framework: ${options.framework}`);
   const source = (path, entry) => posix2.join(path, entry.sourceDir ?? "src");
+  const isPackage = (path) => existsSync2(resolve3(root, path, "package.json"));
+  const packageSource = (path) => posix2.join(path, isPackage(path) ? "src" : "*/src");
   const web = entries.filter(([, { role }]) => role === "web").map(([path, entry]) => source(path, entry));
   const webFor = (framework) => entries.filter(([, entry]) => entry.framework === framework).map(([path, entry]) => source(path, entry));
   const tanstackWeb = webFor("tanstack-start");
@@ -1461,25 +1529,56 @@ function presetResolveContext(options) {
   const backendRoots = backendEntries.map(([path]) => path);
   const backend = backendEntries.map(([path, entry]) => source(path, entry));
   const packages = entries.filter(([, { role }]) => role === "packages").map(([path]) => path);
+  const packageSources = packages.map(packageSource);
+  const serviceRoots = [...backend, ...packageSources];
   const scripts = entries.filter(([, { role }]) => role === "scripts").map(([path]) => path);
   const folders = entries.flatMap(([path, entry]) => Object.entries(entry.layout).map(([folder, mode]) => ({
-    path: posix2.join(["web", "server", "runner"].includes(entry.role) ? source(path, entry) : path, folder),
+    path: posix2.join(entry.role === "scripts" ? path : entry.role === "packages" ? packageSource(path) : source(path, entry), folder),
     folder,
     mode
   })));
   const rpcClients = entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => posix2.join(source(path, entry), "services", entry.layout.services === "domain" ? "rpc/rpc.client.ts" : "rpc.client.ts"));
-  const app = [...web, ...backend];
+  const app = [...web, ...backend, ...packageSources];
   const appFiles = presetScopes(app);
   const webFiles = presetScopes(web);
+  const reactFiles = [
+    ...webFiles,
+    ...presetScopes(packageSources, "**/*.tsx"),
+    ...presetScopes(packageSources, `components/**/${presetExtensions}`),
+    ...presetScopes(packageSources, `hooks/**/${presetExtensions}`)
+  ];
   const backendFiles = presetScopes(backend);
   const services = presetScopes(app, `services/**/${presetExtensions}`);
   const utilities = ["**/*.utils.ts", "**/*.constants.ts", "**/*.types.ts"];
   const types = presetScopes(app, "types/**");
-  const ui = presetScopes(web, "components/ui/**");
+  const resolveUi = (value) => {
+    if (typeof value !== "string" || !value)
+      throw new Error("shadcn.ui must be a nonempty import path.");
+    const manifests = entries.flatMap(([path, entry]) => {
+      const children = entry.role === "packages" && existsSync2(resolve3(root, path)) && !isPackage(path) ? readdirSync(resolve3(root, path), { withFileTypes: true }).filter((child) => child.isDirectory() && isPackage(posix2.join(path, child.name))).map((child) => ({ directory: posix2.join(path, child.name), sources: posix2.join(path, child.name, "src") })) : [];
+      const sources = ["web", "server", "runner"].includes(entry.role) ? source(path, entry) : posix2.join(path, "src");
+      return [{ directory: path, sources }, ...children];
+    });
+    const named = manifests.filter(({ directory }) => presetPackageName(root, directory) === value);
+    if (named.length)
+      return named.map(({ sources }) => sources);
+    const aliased = [...new Set([".", ...manifests.map(({ directory }) => directory)].flatMap((directory) => presetTsconfigAliasTargets(root, directory, value)))];
+    if (aliased.length)
+      return aliased;
+    throw new Error(`shadcn.ui ${JSON.stringify(value)} matches no workspace package name or existing tsconfig paths alias target.`);
+  };
+  const shadcn = options.shadcn || {};
+  if ("uiImportPath" in shadcn)
+    throw new Error("shadcn.uiImportPath was renamed to shadcn.ui.");
+  if ("componentImportSources" in shadcn)
+    throw new Error("shadcn.componentImportSources was renamed to shadcn.components.");
+  const uiRoots = shadcn.ui === undefined ? web.map((path) => posix2.join(path, "components/ui")) : resolveUi(shadcn.ui);
+  const ui = presetScopes(uiRoots, "**");
+  const webUiRoots = uiRoots.filter((path) => web.some((webRoot) => webRoot === "." || path === webRoot || path.startsWith(webRoot + "/")));
   const testFiles = ["**/{test,tests,e2e}/**/*.{ts,tsx,mts,cts}", "**/*.{test,spec}.{ts,tsx,mts,cts}"];
   const safetyFiles = [...appFiles, ...testFiles];
-  const components = presetScopes(web, "components/**/*.tsx");
-  const hooks = presetScopes(web, "hooks/**/*.ts");
+  const components = presetScopes([...web, ...packageSources], "components/**/*.tsx");
+  const hooks = presetScopes([...web, ...packageSources], "hooks/**/*.ts");
   const level = options.severity ?? "error";
   const publicEntrypoints = options.imports?.backendEntryPoints ?? backendRoots.flatMap((directory) => {
     const name = presetPackageName(root, directory);
@@ -1496,7 +1595,7 @@ function presetResolveContext(options) {
     posix2.normalize(path.replaceAll("\\", "/")).replace(/\/$/, ""),
     entry
   ]));
-  const css = tailwind === false ? {} : Object.fromEntries(entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => {
+  const webCss = tailwind === false ? {} : Object.fromEntries(entries.filter(([, entry]) => entry.role === "web").map(([path, entry]) => {
     const sourcePath = source(path, entry);
     const fallback = entry.framework === "next" ? "app/globals.css" : "application/styles.css";
     return [
@@ -1504,6 +1603,22 @@ function presetResolveContext(options) {
       resolve3(root, entryPoints[path] ?? tailwind?.cssEntryPoint ?? posix2.join(sourcePath, fallback))
     ];
   }));
+  const webStylesheets = [...new Set(Object.values(webCss))];
+  const kitCss = Object.fromEntries((tailwind === false ? [] : uiRoots.filter((path) => !webUiRoots.includes(path))).map((path) => {
+    const owners = packages.flatMap((packageRoot) => {
+      if (path !== packageRoot && !path.startsWith(packageRoot + "/"))
+        return [];
+      const child = path.slice(packageRoot.length + 1).split("/")[0];
+      return isPackage(packageRoot) || !child ? [packageRoot] : [posix2.join(packageRoot, child), packageRoot];
+    });
+    const entry = owners.map((owner) => entryPoints[owner]).find(Boolean);
+    if (entry)
+      return [path, resolve3(root, entry)];
+    if (webStylesheets.length === 1)
+      return [path, webStylesheets[0]];
+    throw new Error(`The UI kit ${path} needs a Tailwind stylesheet: set tailwind.cssEntryPointsByRoot for ${owners[0] ?? path}.`);
+  }));
+  const css = { ...webCss, ...kitCss };
   return {
     options,
     root,
@@ -1517,13 +1632,18 @@ function presetResolveContext(options) {
     nextWeb,
     backend,
     backendRoots,
+    packageSources,
+    serviceRoots,
     app,
     appFiles,
     webFiles,
+    reactFiles,
     backendFiles,
     services,
     utilities,
     types,
+    uiRoots,
+    webUiRoots,
     ui,
     generated,
     testFiles,