@clearlydev/nx-archweave 0.1.0 → 0.2.0

package/README.md

@@ -32,7 +32,7 @@ bun nx g @clearlydev/nx-archweave:doctor           # bun
 - **Requirements:** Node >= 22.18, plus one of npm, pnpm >= 10, yarn (classic or berry) or bun. All four package managers are first-class.
 - Generators detect the workspace's real package manager from its lockfiles.
 - The examples below use `pnpm nx g`. With another package manager, run the same generator the way the `doctor` commands above show.
-- The package ships as a self-contained bundle. Its only runtime dependencies are `@nx/devkit` and `tslib`.
+- The package ships as a self-contained bundle. Its only runtime dependency is `@nx/devkit`.
 
 ## Quick start
 
@@ -49,7 +49,7 @@ pnpm nx g @clearlydev/nx-archweave:init --preset=team --frontend=next
 ```
 
 - `init` runs the content generators below according to the preset (`quick-start` | `solo` | `team`).
-- `init` requires a clean git working tree. That way you can always undo a partial run with a single `git restore .`.
+- `init` requires a clean git working tree, so a partial run can be undone exactly: the report lists the files it modified (`git restore -- …`) and the files it created.
 - `--allowDirty` opts out of the clean-tree check. The report then warns you that the rollback scope is wider.
 - `--locale=ko|en` sets the language of generated content. Reports are always in English.
 

package/dist/eslint/fsd-boundaries.d.ts

@@ -1,3 +1,4 @@
+import { type FsdPolicy } from './fsd-policy.ts';
 /**
  * `archweave/fsd-boundaries` — canonical FSD import rules inside one frontend app.
  * Three findings:
@@ -6,33 +7,41 @@
  * - cross-slice: two slices on the same sliced layer import each other — unless through the
  *                target slice's `@x/<importer-slice>` public API (FSD's cross-import notation)
  * - sidestep:    a slice's (or a shared segment's) internal file is imported past its index
+ *                (or a folder that only groups slices is imported as if it were one)
  *
  * Only relative specifiers and the configured aliases are judged; package specifiers
  * (`react`, `firebase/app`) are never touched — string-matching layer names in them was the
- * measured source of false positives. Locations are computed from path strings alone: the
- * rule never reads the file system.
+ * measured source of false positives. Locations come from path strings, plus one look at the
+ * file system for slice groups (`slice-groups.ts`); everything else follows the policy
+ * (`fsd-policy.ts`).
  *
- * Self-contained on purpose: no `eslint` import, so the plugin's runtime dependencies stay
- * @nx/devkit + tslib. The handful of ESLint shapes it touches are typed structurally below.
+ * Self-contained on purpose: no `eslint` import, so the plugin's only runtime dependency stays
+ * @nx/devkit. The handful of ESLint shapes it touches are typed structurally below.
  */
 export type FsdEnforcementSeverity = 'error' | 'warn';
 export interface FsdBoundariesOptions {
-    /** The app's source root, relative to ESLint's cwd (Nx lints from the project root). */
+    /** The app's source root: absolute (what `fsdBoundaries` passes), or relative to ESLint's cwd. */
     root: string;
-    /** Import-prefix aliases → directories relative to cwd, e.g. `{ '@/': 'src' }`. */
+    /** Import-prefix aliases → directories, absolute or relative to ESLint's cwd, e.g. `{ '@/': 'src' }`. */
     aliases: Record<string, string>;
+    /** How the tree is read; omitted keys take the `basic` preset's values. */
+    policy?: Partial<FsdPolicy>;
 }
 declare const LAYER_ORDER: readonly ["app", "pages", "widgets", "features", "entities", "shared"];
 type FsdLayer = (typeof LAYER_ORDER)[number];
-/** Where a file sits inside the FSD tree. `unit` is the slice on a sliced layer, the segment
- * on `shared` (its segments carry a public API too), null on `app`. `rest` is the path below
- * the unit, with a trailing `index[.ext]` dropped. */
+/** Where a file sits inside the FSD tree. `unit` is the slice on a sliced layer (`<group>/<slice>`
+ * inside a slice group), the public-API unit on `shared` (its segments carry a public API too),
+ * null on `app`. `rest` is the path below the unit, with a trailing `index[.ext]` dropped.
+ * `group` marks a path that stops at a slice-group folder. */
 interface Location {
     layer: FsdLayer;
     unit: string | null;
     rest: string[];
+    group?: true;
 }
-export declare function locate(rootRelativePath: string): Location | null;
+export declare function indexFilePattern(platformSuffixes: string[]): RegExp;
+/** `isGroup(layerDir, name)` says whether a folder on a sliced layer only groups slices. */
+export declare function locate(rootRelativePath: string, policy?: FsdPolicy, isGroup?: (layerDir: string, name: string) => boolean): Location | null;
 export type FsdViolation = {
     kind: 'upward';
     from: Location;
@@ -45,6 +54,10 @@ export type FsdViolation = {
     kind: 'sidestep';
     from: Location;
     to: Location;
+} | {
+    kind: 'group';
+    from: Location;
+    to: Location;
 };
 /** Pure core: the violation (if any) of `from` importing `to`. */
 export declare function judge(from: Location, to: Location): FsdViolation | null;
@@ -94,6 +107,9 @@ export declare const fsdBoundariesRule: {
                         type: string;
                     };
                 };
+                policy: {
+                    type: string;
+                };
             };
             additionalProperties: boolean;
         }[];
@@ -101,6 +117,7 @@ export declare const fsdBoundariesRule: {
             upward: string;
             crossSlice: string;
             sidestep: string;
+            group: string;
         };
     };
     create(context: RuleContext): {

package/dist/eslint/fsd-policy.d.ts

@@ -0,0 +1,38 @@
+/**
+ * How strictly `archweave/fsd-boundaries` reads an FSD tree. `basic` is canonical FSD; `practical`
+ * accepts the variants common in existing apps. A preset is only a set of values for these
+ * options — each can be set on its own, and an explicit value always wins over the preset.
+ */
+export interface FsdPolicy {
+    /** Folders on a sliced layer that only group slices (`features/mypage/{order,claims}`):
+     * detected (`auto`), forced (`include`) or ruled out (`exclude`), as `<layer dir>/<name>`. */
+    sliceGroups: false | {
+        auto: boolean;
+        include: string[];
+        exclude: string[];
+    };
+    /** The public-API unit of `shared`: a segment (`shared/ui`), a component inside a segment
+     * (`shared/ui/button`), or any file (no sidestep check inside shared). */
+    sharedPublicApi: 'segment' | 'component' | 'file';
+    /** Globs (relative to the source root) of test files, which may import another slice's
+     * internals; `false` treats them like any other file. Upward imports are reported either way. */
+    testFiles: false | string[];
+    /** Extra folder names that are segments, never slices, for group detection. */
+    segments: string[];
+    /** Platform suffixes whose `index.<suffix>.<ext>` is a public API too (React Native). */
+    platformSuffixes: string[];
+    /** Folders a framework's router owns (Next.js's Pages Router `pages/`): read as the
+     * composition root (the app layer), so they may re-export any layer below. */
+    routerDirs: string[];
+}
+export type FsdPreset = 'basic' | 'practical';
+/** The policy from a recorded `fsd` object (its preset, then its own keys), then `overrides`.
+ * Unknown or malformed values fall back to the preset's. */
+export declare function resolveFsdPolicy(recorded: unknown, overrides?: Partial<FsdPolicy>): FsdPolicy;
+/** The `fsd` object of the nearest toolkit.config.json at or above `from`; undefined when there
+ * is none or it cannot be read. */
+export declare function readRecordedFsd(from: string): unknown;
+/** A glob (`**`, `*`, `?`, `{a,b}`) as a regular expression over `/`-separated paths. A brace
+ * without its closing `}` is a literal character. */
+export declare function globToRegExp(glob: string): RegExp;
+//# sourceMappingURL=fsd-policy.d.ts.map

package/dist/eslint/index.d.ts

@@ -1,6 +1,8 @@
 import { type FsdEnforcementSeverity } from './fsd-boundaries.ts';
+import { type FsdPolicy } from './fsd-policy.ts';
 export { fsdBoundariesRule, type FsdBoundariesOptions, type FsdEnforcementSeverity } from './fsd-boundaries.ts';
 export { aliasesFromTsconfig } from './tsconfig-aliases.ts';
+export { resolveFsdPolicy, type FsdPolicy, type FsdPreset } from './fsd-policy.ts';
 /** The ESLint plugin object — `plugins: { archweave: archweavePlugin }`. */
 export declare const archweavePlugin: {
     meta: {
@@ -27,6 +29,9 @@ export declare const archweavePlugin: {
                                 type: string;
                             };
                         };
+                        policy: {
+                            type: string;
+                        };
                     };
                     additionalProperties: boolean;
                 }[];
@@ -34,6 +39,7 @@ export declare const archweavePlugin: {
                     upward: string;
                     crossSlice: string;
                     sidestep: string;
+                    group: string;
                 };
             };
             create(context: import("./fsd-boundaries.ts").RuleContext): {
@@ -50,7 +56,7 @@ export declare const archweavePlugin: {
         };
     };
 };
-export interface FsdBoundariesConfigOptions {
+export interface FsdBoundariesConfigOptions extends Partial<FsdPolicy> {
     /** `error` (Team preset) or `warn` (Solo / Quick Start). Default `error`. */
     severity?: FsdEnforcementSeverity;
     /** The app's source root, relative to the config file's directory. Default `src`. */
@@ -62,17 +68,12 @@ export interface FsdBoundariesConfigOptions {
     /** The tsconfig whose `compilerOptions.paths` (and its `extends` chain) add to the default
      * aliases, relative to `cwd`. Default `tsconfig.json`; `false` turns the lookup off. */
     tsconfig?: string | false;
-    /** The directory the config is evaluated from — Nx lints from the project root. Default
-     * `process.cwd()`. */
+    /** The directory `root`, `aliases` and `tsconfig` are relative to: the config file's own
+     * directory (`import.meta.dirname`), so the rule checks the same files whether ESLint runs
+     * from the project (`nx lint`), the workspace root or an editor. Default `process.cwd()`. */
     cwd?: string;
     /** Override the files the rule applies to. Default: everything under `root`. */
     files?: string[];
 }
-/**
- * The one flat-config entry add-fsd-lite adds to a frontend app's eslint.config.mjs:
- *
- *   import { fsdBoundaries } from '@clearlydev/nx-archweave/eslint';
- *   export default [...baseConfig, ...fsdBoundaries({ severity: 'error' })];
- */
 export declare function fsdBoundaries(options?: FsdBoundariesConfigOptions): object[];
 //# sourceMappingURL=index.d.ts.map

package/dist/eslint/index.js

@@ -1,10 +1,164 @@
 // src/eslint/index.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname2, join } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join3, posix as posix2, resolve as resolve3, sep as sep3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/eslint/fsd-boundaries.ts
 import { posix, relative, resolve, sep } from "node:path";
+
+// src/eslint/fsd-policy.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var PRESETS = {
+  basic: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "segment",
+    testFiles: false,
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  },
+  practical: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "file",
+    testFiles: ["**/*.{spec,test}.*", "**/__tests__/**"],
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  }
+};
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function resolveFsdPolicy(recorded, overrides = {}) {
+  const fsd = typeof recorded === "object" && recorded !== null ? recorded : {};
+  const preset = fsd["preset"] === "practical" ? "practical" : "basic";
+  const policy = { ...PRESETS[preset] };
+  const groups = fsd["sliceGroups"];
+  if (groups === false) policy.sliceGroups = false;
+  else if (groups === "auto") policy.sliceGroups = { auto: true, include: [], exclude: [] };
+  else if (typeof groups === "object" && groups !== null) {
+    const value = groups;
+    policy.sliceGroups = {
+      auto: value["auto"] !== false,
+      include: isStringArray(value["include"]) ? value["include"] : [],
+      exclude: isStringArray(value["exclude"]) ? value["exclude"] : []
+    };
+  }
+  const shared = fsd["sharedPublicApi"];
+  if (shared === "segment" || shared === "component" || shared === "file") policy.sharedPublicApi = shared;
+  const tests = fsd["testFiles"];
+  if (tests === false || isStringArray(tests)) policy.testFiles = tests;
+  if (isStringArray(fsd["segments"])) policy.segments = fsd["segments"];
+  if (isStringArray(fsd["platformSuffixes"])) policy.platformSuffixes = fsd["platformSuffixes"];
+  if (isStringArray(fsd["routerDirs"])) policy.routerDirs = fsd["routerDirs"];
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value !== void 0) policy[key] = value;
+  }
+  return policy;
+}
+function readRecordedFsd(from) {
+  for (let dir = from; ; dir = dirname(dir)) {
+    const file = join(dir, "toolkit.config.json");
+    if (existsSync(file)) {
+      try {
+        return JSON.parse(readFileSync(file, "utf-8"))["fsd"];
+      } catch {
+        return void 0;
+      }
+    }
+    if (dirname(dir) === dir) return void 0;
+  }
+}
+var escapeLiteral = (text) => text.replace(/[.+^$()|[\]\\{}]/g, "\\$&");
+function wildcardsToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*" && glob[i + 1] === "*") {
+      const slash = glob[i + 2] === "/";
+      source += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += escapeLiteral(ch);
+  }
+  return source;
+}
+function globToRegExp(glob) {
+  let source = "";
+  let rest = glob;
+  for (; ; ) {
+    const open = rest.indexOf("{");
+    const close = open === -1 ? -1 : rest.indexOf("}", open);
+    if (open === -1 || close === -1) {
+      source += wildcardsToRegExp(rest);
+      break;
+    }
+    source += wildcardsToRegExp(rest.slice(0, open));
+    source += `(?:${rest.slice(open + 1, close).split(",").map(wildcardsToRegExp).join("|")})`;
+    rest = rest.slice(close + 1);
+  }
+  return new RegExp(`^${source}$`);
+}
+
+// src/eslint/slice-groups.ts
+import { readdirSync, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+var SEGMENTS = [
+  "ui",
+  "model",
+  "api",
+  "lib",
+  "config",
+  "components",
+  "hooks",
+  "types",
+  "utils",
+  "helpers",
+  "constants",
+  "consts",
+  "store",
+  "stores",
+  "styles",
+  "assets",
+  "services",
+  "context"
+];
+var IGNORED = /^(\.|readme(\.|$))/i;
+var listings = /* @__PURE__ */ new Map();
+function list(dir) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(dir).mtimeMs;
+  } catch {
+    listings.delete(dir);
+    return null;
+  }
+  const cached = listings.get(dir);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.entries;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({ name: entry.name, directory: entry.isDirectory() }));
+    listings.set(dir, { mtimeMs, entries });
+    return entries;
+  } catch {
+    return null;
+  }
+}
+function createGroupDetector(rootAbsolute, policy, isIndexFile, listDirectory = list) {
+  const groups = policy.sliceGroups;
+  if (groups === false) return () => false;
+  const segments = /* @__PURE__ */ new Set([...SEGMENTS, ...policy.segments]);
+  return (layerDir, name) => {
+    const key = `${layerDir}/${name}`;
+    if (groups.include.includes(key)) return true;
+    if (groups.exclude.includes(key) || !groups.auto) return false;
+    const entries = listDirectory(join2(rootAbsolute, layerDir, name))?.filter((entry) => !IGNORED.test(entry.name)) ?? null;
+    if (entries === null || entries.length === 0) return false;
+    if (entries.some((entry) => !entry.directory || segments.has(entry.name))) return false;
+    return entries.some((entry) => listDirectory(join2(rootAbsolute, layerDir, name, entry.name))?.some((child) => !child.directory && isIndexFile(child.name)) ?? false);
+  };
+}
+
+// src/eslint/fsd-boundaries.ts
 var LAYER_ORDER = ["app", "pages", "widgets", "features", "entities", "shared"];
 var LAYER_BY_DIR = {
   app: "app",
@@ -17,24 +171,45 @@ var LAYER_BY_DIR = {
   shared: "shared"
 };
 var SLICED_LAYERS = /* @__PURE__ */ new Set(["pages", "widgets", "features", "entities"]);
-var INDEX_FILE = /^index(\.[cm]?[jt]sx?)?$/;
-function locate(rootRelativePath) {
+function indexFilePattern(platformSuffixes) {
+  const platforms = platformSuffixes.length === 0 ? "" : `(\\.(${platformSuffixes.map((suffix) => suffix.replace(/[^a-z0-9-]/gi, "")).join("|")}))?`;
+  return new RegExp(`^index${platforms}(\\.[cm]?[jt]sx?)?$`);
+}
+var DEFAULT_POLICY = resolveFsdPolicy(void 0);
+var NO_GROUPS = () => false;
+function locate(rootRelativePath, policy = DEFAULT_POLICY, isGroup = NO_GROUPS) {
   const segments = rootRelativePath.split("/").filter((s) => s.length > 0 && s !== ".");
   if (segments.length === 0) return null;
-  const layer = LAYER_BY_DIR[segments[0]];
+  const layer = policy.routerDirs.includes(segments[0]) ? "app" : LAYER_BY_DIR[segments[0]];
   if (layer === void 0) return null;
-  const hasUnit = layer !== "app";
-  const unit = hasUnit ? segments[1] ?? null : null;
-  const rest = segments.slice(hasUnit ? 2 : 1);
-  if (rest.length > 0 && INDEX_FILE.test(rest[rest.length - 1])) rest.pop();
+  let unit;
+  let rest;
+  if (layer === "app") {
+    unit = null;
+    rest = segments.slice(1);
+  } else if (layer === "shared") {
+    const component = policy.sharedPublicApi === "component" && segments.length > 2;
+    unit = segments[1] === void 0 ? null : component ? `${segments[1]}/${segments[2]}` : segments[1];
+    rest = policy.sharedPublicApi === "file" ? [] : segments.slice(component ? 3 : 2);
+  } else if (segments[1] !== void 0 && isGroup(segments[0], segments[1])) {
+    if (segments[2] === void 0) return { layer, unit: segments[1], rest: [], group: true };
+    unit = `${segments[1]}/${segments[2]}`;
+    rest = segments.slice(3);
+  } else {
+    unit = segments[1] ?? null;
+    rest = segments.slice(2);
+  }
+  if (rest.length > 0 && indexFilePattern(policy.platformSuffixes).test(rest[rest.length - 1])) rest.pop();
   return { layer, unit, rest };
 }
 function judge(from, to) {
   if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer)) return { kind: "upward", from, to };
   if (to.unit === null) return null;
+  if (to.group) return { kind: "group", from, to };
   const sameUnit = from.layer === to.layer && from.unit === to.unit;
   if (sameUnit) return null;
-  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === from.unit && from.layer === to.layer;
+  const importerSlice = from.unit?.split("/").pop();
+  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === importerSlice && from.layer === to.layer;
   if (viaCrossImportApi) return null;
   if (from.layer === to.layer && SLICED_LAYERS.has(to.layer)) return { kind: "cross-slice", from, to };
   if (to.rest.length > 0) return { kind: "sidestep", from, to };
@@ -50,9 +225,8 @@ function resolveSpecifier(specifier, importerRootRelative, options) {
   } else {
     for (const [prefix, target] of Object.entries(options.aliases)) {
       if (!specifier.startsWith(prefix)) continue;
-      const targetAbsolute = resolve(options.cwd, target);
-      const targetRootRelative = toPosix(relative(options.rootAbsolute, targetAbsolute));
-      rootRelative = posix.normalize(posix.join(targetRootRelative === "" ? "." : targetRootRelative, specifier.slice(prefix.length)));
+      const absolute = resolve(resolve(options.cwd, target), specifier.slice(prefix.length));
+      rootRelative = toPosix(relative(options.rootAbsolute, absolute)) || ".";
       break;
     }
   }
@@ -75,7 +249,8 @@ var fsdBoundariesRule = {
         type: "object",
         properties: {
           root: { type: "string" },
-          aliases: { type: "object", additionalProperties: { type: "string" } }
+          aliases: { type: "object", additionalProperties: { type: "string" } },
+          policy: { type: "object" }
         },
         additionalProperties: false
       }
@@ -83,7 +258,8 @@ var fsdBoundariesRule = {
     messages: {
       upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
       crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" \u2014 move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
-      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".'
+      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".',
+      group: 'FSD: "{{to}}" is a group of slices, not a slice \u2014 import one of its slices through its index.ts.'
     }
   },
   create(context) {
@@ -94,20 +270,24 @@ var fsdBoundariesRule = {
     const rootAbsolute = resolve(cwd, root);
     const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
     if (importerRootRelative === "" || importerRootRelative.startsWith("..")) return {};
-    const from = locate(importerRootRelative);
+    const policy = resolveFsdPolicy(void 0, options.policy ?? {});
+    const isIndexFile = (name) => indexFilePattern(policy.platformSuffixes).test(name);
+    const isGroup = createGroupDetector(rootAbsolute, policy, isIndexFile);
+    const from = locate(importerRootRelative, policy, isGroup);
     if (from === null) return {};
+    const isTestFile = policy.testFiles !== false && policy.testFiles.some((glob) => globToRegExp(glob).test(importerRootRelative));
     const check = (node, specifier) => {
       if (typeof specifier !== "string") return;
       const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
       if (target === null) return;
-      const to = locate(target);
+      const to = locate(target, policy, isGroup);
       if (to === null) return;
       const violation = judge(from, to);
-      if (violation === null) return;
-      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit ?? "", path: target };
+      if (violation === null || isTestFile && violation.kind !== "upward") return;
+      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit?.split("/").pop() ?? "", path: target };
       context.report({
         node,
-        messageId: violation.kind === "upward" ? "upward" : violation.kind === "cross-slice" ? "crossSlice" : "sidestep",
+        messageId: violation.kind === "cross-slice" ? "crossSlice" : violation.kind,
         data
       });
     };
@@ -125,8 +305,8 @@ var fsdBoundariesRule = {
 };
 
 // src/eslint/tsconfig-aliases.ts
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 }) {
   const aliases = {};
   let current = resolve2(cwd, tsconfig);
@@ -138,7 +318,7 @@ function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 })
     const compilerOptions = asRecord(config["compilerOptions"]);
     const paths = asRecord(compilerOptions?.["paths"]);
     if (paths) {
-      const baseUrl = typeof compilerOptions?.["baseUrl"] === "string" ? resolve2(dirname(current), compilerOptions["baseUrl"]) : dirname(current);
+      const baseUrl = typeof compilerOptions?.["baseUrl"] === "string" ? resolve2(dirname2(current), compilerOptions["baseUrl"]) : dirname2(current);
       for (const [pattern, targets] of Object.entries(paths)) {
         if (!pattern.endsWith("*")) continue;
         const prefix = pattern.slice(0, -1);
@@ -151,13 +331,13 @@ function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 })
     }
     const parent = config["extends"];
     const parentPath = typeof parent === "string" ? parent : Array.isArray(parent) ? parent.find((p) => typeof p === "string") : void 0;
-    current = parentPath !== void 0 && (parentPath.startsWith(".") || isAbsolute(parentPath)) ? resolveExtends(dirname(current), parentPath) : null;
+    current = parentPath !== void 0 && (parentPath.startsWith(".") || isAbsolute(parentPath)) ? resolveExtends(dirname2(current), parentPath) : null;
   }
   return aliases;
 }
 function resolveExtends(fromDir, target) {
   const candidates = [resolve2(fromDir, target), resolve2(fromDir, `${target}.json`)];
-  return candidates.find((candidate) => existsSync(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync2(candidate)) ?? null;
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
@@ -168,7 +348,7 @@ function toPosix2(path) {
 function readJsonc(path) {
   let text;
   try {
-    text = readFileSync(path, "utf-8");
+    text = readFileSync2(path, "utf-8");
   } catch {
     return null;
   }
@@ -218,14 +398,14 @@ function readJsonc(path) {
 
 // src/eslint/index.ts
 function ownVersion() {
-  let dir = dirname2(fileURLToPath(import.meta.url));
+  let dir = dirname3(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const manifest = join(dir, "package.json");
-    if (existsSync2(manifest)) {
-      const pkg = JSON.parse(readFileSync2(manifest, "utf-8"));
+    const manifest = join3(dir, "package.json");
+    if (existsSync3(manifest)) {
+      const pkg = JSON.parse(readFileSync3(manifest, "utf-8"));
       if (pkg.name === "@clearlydev/nx-archweave" && pkg.version) return pkg.version;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) throw new Error("@clearlydev/nx-archweave: its own package.json was not found");
     dir = parent;
   }
@@ -234,15 +414,27 @@ var archweavePlugin = {
   meta: { name: "@clearlydev/nx-archweave", version: ownVersion() },
   rules: { "fsd-boundaries": fsdBoundariesRule }
 };
+var OUTPUT_DIRS = [".next/**", ".expo/**", "dist/**", "out/**", "build/**", "coverage/**"];
 function fsdBoundaries(options = {}) {
   const root = options.root ?? "src";
   const cwd = options.cwd ?? process.cwd();
   const fromTsconfig = options.aliases === void 0 && options.tsconfig !== false ? aliasesFromTsconfig({ cwd, tsconfig: options.tsconfig }) : {};
-  const ruleOptions = { root, aliases: options.aliases ?? { "@/": root, ...fromTsconfig } };
+  const aliases = options.aliases ?? { "@/": root, ...fromTsconfig };
+  const anchor = (dir) => options.cwd === void 0 ? dir : resolve3(options.cwd, dir);
+  const { sliceGroups, sharedPublicApi, testFiles, segments, platformSuffixes, routerDirs } = options;
+  const policy = resolveFsdPolicy(readRecordedFsd(cwd), { sliceGroups, sharedPublicApi, testFiles, segments, platformSuffixes, routerDirs });
+  const ruleOptions = {
+    root: anchor(root),
+    aliases: Object.fromEntries(Object.entries(aliases).map(([prefix, dir]) => [prefix, anchor(dir)])),
+    policy
+  };
+  const rootGlob = posix2.normalize(root.split(sep3).join("/"));
+  const atAppRoot = rootGlob === "." || rootGlob === "./";
   return [
     {
       name: "nx-archweave/fsd-boundaries",
-      files: options.files ?? [`${root}/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`],
+      files: options.files ?? [`${atAppRoot ? "" : `${rootGlob.replace(/\/$/, "")}/`}**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`],
+      ...atAppRoot ? { ignores: OUTPUT_DIRS } : {},
       plugins: { archweave: archweavePlugin },
       rules: { "archweave/fsd-boundaries": [options.severity ?? "error", ruleOptions] }
     }
@@ -252,5 +444,6 @@ export {
   aliasesFromTsconfig,
   archweavePlugin,
   fsdBoundaries,
-  fsdBoundariesRule
+  fsdBoundariesRule,
+  resolveFsdPolicy
 };

package/dist/eslint/slice-groups.d.ts

@@ -0,0 +1,12 @@
+import type { FsdPolicy } from './fsd-policy.ts';
+export type DirectoryLister = (dir: string) => {
+    name: string;
+    directory: boolean;
+}[] | null;
+/**
+ * Whether `<rootAbsolute>/<layerDir>/<name>` groups slices instead of being one. A group has no
+ * files of its own (so no index), none of its folders is a segment, and at least one of its
+ * folders has an index. `include` / `exclude` (`<layerDir>/<name>`) decide before detection.
+ */
+export declare function createGroupDetector(rootAbsolute: string, policy: FsdPolicy, isIndexFile: (name: string) => boolean, listDirectory?: DirectoryLister): (layerDir: string, name: string) => boolean;
+//# sourceMappingURL=slice-groups.d.ts.map