@morriconeluca/eslint-plugin-faf 0.4.0 → 0.5.0

package/dist/main.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@morriconeluca/eslint-plugin-faf",
-  version: "0.4.0",
+  version: "0.5.0",
   description: "An ESLint plugin for FAF projects.",
   repository: {
     type: "git",
@@ -89,6 +89,7 @@ import path3 from "path";
 
 // src/_rules/_rules@shared/_utils/_utils@shared/_stores/cache/cache.store.ts
 var state = {
+  ancestorChainCache: /* @__PURE__ */ new Map(),
   categoryConfigCache: /* @__PURE__ */ new Map(),
   classifyCache: /* @__PURE__ */ new Map(),
   dirCache: {},
@@ -345,27 +346,139 @@ var rule = {
 var category_mutually_exclusive_rule_default = rule;
 
 // src/_rules/enforce-access-node/enforce-access-node.rule.ts
+import path7 from "path";
+
+// src/_rules/_rules@shared/_utils/_primitives/get-project-root/get-project-root.util.ts
+function getProjectRoot() {
+  return state.projectRoot;
+}
+
+// src/_rules/_rules@shared/_utils/_systems/walk-ancestors/walk-ancestors.util.ts
 import path6 from "path";
+function walkAncestors(relDir, config) {
+  const cached = state.ancestorChainCache.get(relDir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const result = [];
+  let currentDir = relDir;
+  while (currentDir && currentDir !== "." && currentDir !== "/") {
+    const isInTree = config.includes.some(
+      (inc) => currentDir === inc || currentDir.startsWith(inc + "/")
+    );
+    const isExcluded = config.excludes?.some(
+      (exc) => currentDir === exc || currentDir.startsWith(exc + "/")
+    ) ?? false;
+    if (!isInTree || isExcluded) {
+      break;
+    }
+    const folderName = path6.basename(currentDir);
+    const type = classifyFolder(currentDir, config);
+    const parentDir = path6.dirname(currentDir).replace(/\\/g, "/");
+    const parentFolderName = path6.basename(parentDir);
+    const parentType = parentDir === "." || parentDir === "/" ? "unknown" : classifyFolder(parentDir, config);
+    result.push({
+      dir: currentDir,
+      folderName,
+      parentDir,
+      parentFolderName,
+      parentType,
+      type
+    });
+    currentDir = parentDir;
+  }
+  state.ancestorChainCache.set(relDir, result);
+  return result;
+}
+
+// src/_rules/enforce-access-node/enforce-access-node.rule.ts
 var rule2 = {
   create(context) {
     const absPath = context.filename;
     const relPath = toRelativePath(absPath);
-    const fileName = path6.basename(relPath);
+    const settings = context.settings;
+    const listeners = {
+      Program(node) {
+        if (!settings.faf) {
+          return;
+        }
+        const config2 = findTreeConfig(relPath, settings.faf);
+        if (!config2) {
+          return;
+        }
+        const relDir2 = path7.dirname(relPath);
+        const folderName = path7.basename(relDir2);
+        const parentType2 = classifyFolder(relDir2, config2);
+        if (parentType2 === "foreign") {
+          return;
+        }
+        const fileName2 = path7.basename(relPath);
+        for (const {
+          folderName: currentFolderName,
+          type: currentType
+        } of walkAncestors(relDir2, config2)) {
+          if (currentType === "invalid-fragment") {
+            context.report({
+              message: `Fragment directory "${currentFolderName}" is missing an Access Node (index.ts/index.js).`,
+              node
+            });
+          }
+        }
+        if (parentType2 === "layer" || parentType2 === "fractal-branch" || parentType2 === "invalid-fragment") {
+          return;
+        }
+        const rfConfig = getRootFragmentConfig(relDir2, config2);
+        if (rfConfig) {
+          const flatRootNodes = rfConfig.rootNodes.flat();
+          const isMatchedRootNode = flatRootNodes.some((rn) => {
+            if (rn.includes("/")) {
+              const rfPath = rfConfig.paths[0] ?? "";
+              const absRn = path7.resolve(getProjectRoot(), rfPath, rn);
+              return toRelativePath(absRn) === relPath;
+            }
+            return rn === fileName2;
+          });
+          if (isMatchedRootNode) {
+            return;
+          }
+        }
+        if (fileName2 !== "index.ts" && fileName2 !== "index.js") {
+          return;
+        }
+        if (parentType2 !== "fragment") {
+          context.report({
+            message: `Access Nodes ("index.ts/index.js") are exclusive to Fragments. Found index file directly inside "${folderName}" (classified as ${parentType2}).`,
+            node
+          });
+          return;
+        }
+        const contents = readDirCached(relDir2);
+        const hasFragmentNode = contents.files.some(
+          (f) => f !== "index.ts" && f !== "index.js" && f !== "README.md" && f !== "package.json" && f !== "tsconfig.json"
+        );
+        if (!hasFragmentNode) {
+          context.report({
+            message: `Fragment "${folderName}" has no Master Node. Every Fragment must contain at least one Fragment Node establishing its Role.`,
+            node
+          });
+        }
+      }
+    };
+    const fileName = path7.basename(relPath);
     if (fileName !== "index.ts" && fileName !== "index.js") {
-      return {};
+      return listeners;
     }
-    const settings = context.settings;
     if (!settings.faf) {
-      return {};
+      return listeners;
     }
     const config = findTreeConfig(relPath, settings.faf);
     if (!config) {
-      return {};
+      return listeners;
     }
-    const relDir = path6.dirname(relPath);
+    const relDir = path7.dirname(relPath);
     const parentType = classifyFolder(relDir, config);
     if (parentType !== "fragment") {
-      return {};
+      return listeners;
     }
     function checkSource(node, sourceVal) {
       const isValidSibling = /^\.\/[^/]+$/.test(sourceVal);
@@ -376,11 +489,11 @@ var rule2 = {
         });
         return;
       }
-      const importedFilename = path6.basename(sourceVal);
+      const importedFilename = path7.basename(sourceVal);
       if (importedFilename === "index" || importedFilename === "index.ts" || importedFilename === "index.js" || importedFilename === "README.md" || importedFilename === "package.json") {
         return;
       }
-      const fragmentName = path6.basename(relDir);
+      const fragmentName = path7.basename(relDir);
       if (!importedFilename.startsWith(fragmentName + ".")) {
         context.report({
           message: `Access Node (index file) can only re-export its own Fragment Nodes (names starting with "${fragmentName}."). Got "${importedFilename}".`,
@@ -388,23 +501,22 @@ var rule2 = {
         });
       }
     }
-    return {
-      ExportAllDeclaration(node) {
-        checkSource(node, node.source.value);
-      },
-      ExportNamedDeclaration(node) {
-        if (node.source) {
-          checkSource(node, node.source.value);
-        }
-      },
-      ImportDeclaration(node) {
+    listeners.ExportAllDeclaration = (node) => {
+      checkSource(node, node.source.value);
+    };
+    listeners.ExportNamedDeclaration = (node) => {
+      if (node.source) {
         checkSource(node, node.source.value);
       }
     };
+    listeners.ImportDeclaration = (node) => {
+      checkSource(node, node.source.value);
+    };
+    return listeners;
   },
   meta: {
     docs: {
-      description: "Enforce Access Node rules for Fragments"
+      description: "Enforce Access Node integrity for Fragments"
     },
     schema: [],
     type: "problem"
@@ -412,136 +524,410 @@ var rule2 = {
 };
 var enforce_access_node_rule_default = rule2;
 
-// src/_rules/naming-conventions/naming-conventions.rule.ts
-import path7 from "path";
-
-// src/_rules/_rules@shared/_utils/_primitives/get-file-role/get-file-role.util.ts
-function getFileRole(fileName, config) {
-  if (fileName === "index.ts" || fileName === "index.js") {
-    return "index";
+// src/_rules/_rules@shared/_utils/_aggregates/resolve-import-path/resolve-import-path.util.ts
+import fs2 from "fs";
+import path8 from "path";
+function resolveImportPath(importPath, currentFileRelative, settings) {
+  const cacheKey = `${currentFileRelative}::${importPath}`;
+  const cached = state.resolvedImportPathCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
   }
-  const parts = fileName.split(".");
-  let allRoles = state.rolesCache.get(config);
-  if (!allRoles) {
-    allRoles = new Set(config.roles.flat());
-    state.rolesCache.set(config, allRoles);
+  const result = _resolveImportPath(importPath, currentFileRelative, settings);
+  state.resolvedImportPathCache.set(cacheKey, result);
+  return result;
+}
+function _resolveImportPath(importPath, currentFileRelative, settings) {
+  const pkgImports = loadPackageImports(state.projectRoot);
+  const aliases = Object.keys(pkgImports).length > 0 ? pkgImports : settings?.aliases || {};
+  let matchedAlias = null;
+  let longestMatch = 0;
+  for (const alias of Object.keys(aliases)) {
+    if (importPath === alias || importPath.startsWith(alias + "/")) {
+      if (alias.length > longestMatch) {
+        longestMatch = alias.length;
+        matchedAlias = alias;
+      }
+    }
   }
-  for (let i = parts.length - 2; i >= 1; i--) {
-    const part = parts[i];
-    if (part && allRoles.has(part)) {
-      return part;
+  let relResolved;
+  if (matchedAlias) {
+    const target = aliases[matchedAlias];
+    if (target) {
+      const remainder = importPath.substring(matchedAlias.length);
+      const absTarget = path8.resolve(state.projectRoot, target + remainder);
+      relResolved = toRelativePath(absTarget);
+    } else {
+      return "";
+    }
+  } else {
+    if (importPath.startsWith(".") || importPath.startsWith("/")) {
+      const absCurrentDir = path8.dirname(
+        path8.resolve(state.projectRoot, currentFileRelative)
+      );
+      const absResolved = path8.resolve(absCurrentDir, importPath);
+      relResolved = toRelativePath(absResolved);
+    } else {
+      return "";
     }
   }
-  return null;
+  return finalizeResolvedPath(relResolved);
+}
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "cjs",
+  "cts",
+  "js",
+  "jsx",
+  "mjs",
+  "mts",
+  "ts",
+  "tsx"
+]);
+function finalizeResolvedPath(relResolved) {
+  const resolvedDir = path8.dirname(relResolved).replace(/\\/g, "/");
+  const resolvedBase = path8.basename(relResolved);
+  const dirContents = readDirCached(relResolved);
+  if (dirContents.files.includes("index.ts")) {
+    return (relResolved === "." ? "" : relResolved + "/") + "index.ts";
+  }
+  if (dirContents.files.includes("index.js")) {
+    return (relResolved === "." ? "" : relResolved + "/") + "index.js";
+  }
+  const parentContents = readDirCached(resolvedDir);
+  const exactMatch = parentContents.files.find((f) => f === resolvedBase);
+  if (!exactMatch) {
+    const candidates = parentContents.files.filter(
+      (f) => f.startsWith(resolvedBase + ".")
+    );
+    const matchWithExt = candidates.find(
+      (f) => SCRIPT_EXTENSIONS.has(f.slice(resolvedBase.length + 1))
+    ) ?? candidates[0];
+    if (matchWithExt) {
+      return (resolvedDir === "." ? "" : resolvedDir + "/") + matchWithExt;
+    }
+  }
+  return relResolved;
+}
+function loadPackageImports(projectRootPath) {
+  if (state.packageImports !== null) {
+    return state.packageImports;
+  }
+  state.packageImports = {};
+  const isTest = typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.VITEST === "true");
+  if (isTest) {
+    return state.packageImports;
+  }
+  const pkgPath = path8.resolve(projectRootPath, "package.json");
+  if (fs2.existsSync(pkgPath)) {
+    try {
+      const pkgContent = fs2.readFileSync(pkgPath, "utf8");
+      const pkg = JSON.parse(pkgContent);
+      if (pkg.imports) {
+        for (const [key, val] of Object.entries(pkg.imports)) {
+          if (typeof val === "string") {
+            const cleanKey = key.endsWith("/*") ? key.slice(0, -2) : key.endsWith("*") ? key.slice(0, -1) : key;
+            let cleanVal = val.endsWith("/*") ? val.slice(0, -2) : val.endsWith("*") ? val.slice(0, -1) : val;
+            if (cleanVal.startsWith("./")) {
+              cleanVal = cleanVal.substring(2);
+            } else if (cleanVal.startsWith("/")) {
+              cleanVal = cleanVal.substring(1);
+            }
+            state.packageImports[cleanKey] = cleanVal;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return state.packageImports;
 }
 
-// src/_rules/_rules@shared/_utils/_primitives/get-project-root/get-project-root.util.ts
-function getProjectRoot() {
-  return state.projectRoot;
+// src/_rules/_rules@shared/_utils/_primitives/find-tree-config-including-excluded/find-tree-config-including-excluded.util.ts
+function findTreeConfigIncludingExcluded(relPath, settings) {
+  if (!settings || !settings.trees) {
+    return null;
+  }
+  const cached = state.treeConfigIncludingExcludedCache.get(relPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let result = null;
+  for (const tree of settings.trees) {
+    const isIncluded = tree.includes.some(
+      (inc) => relPath === inc || relPath.startsWith(inc + "/")
+    );
+    if (isIncluded) {
+      result = tree;
+      break;
+    }
+  }
+  state.treeConfigIncludingExcludedCache.set(relPath, result);
+  return result;
 }
 
-// src/_rules/naming-conventions/naming-conventions.rule.ts
-var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-var DEFAULT_HTTP_METHODS = [
-  "connect",
-  "delete",
-  "get",
-  "head",
-  "options",
-  "patch",
-  "post",
-  "put",
-  "trace"
-];
+// src/_rules/foreign-domain-isolation/foreign-domain-isolation.rule.ts
 var rule3 = {
   create(context) {
-    return {
-      Program(node) {
-        const absPath = context.filename;
-        const relPath = toRelativePath(absPath);
-        const settings = context.settings;
-        if (!settings.faf) {
-          return;
-        }
-        const config = findTreeConfig(relPath, settings.faf);
-        if (!config) {
+    const absPath = context.filename;
+    const relPath = toRelativePath(absPath);
+    const settings = context.settings;
+    if (!settings.faf) {
+      return {};
+    }
+    const config = findTreeConfigIncludingExcluded(relPath, settings.faf);
+    if (!config) {
+      return {};
+    }
+    const isCurrentFileExcluded = config.excludes?.some(
+      (exc) => relPath === exc || relPath.startsWith(exc + "/")
+    ) ?? false;
+    function checkImport(node, importValue) {
+      const resolvedRelPath = resolveImportPath(
+        importValue,
+        relPath,
+        settings.faf
+      );
+      if (!resolvedRelPath) {
+        return;
+      }
+      const isImportedFileExcluded = config?.excludes?.some(
+        (exc) => resolvedRelPath === exc || resolvedRelPath.startsWith(exc + "/")
+      ) ?? false;
+      if (!isCurrentFileExcluded && isImportedFileExcluded) {
+        context.report({
+          message: `Importing from Foreign Domain "${resolvedRelPath}" is forbidden for Logical Nodes.`,
+          node
+        });
+        return;
+      }
+      if (isCurrentFileExcluded && !isImportedFileExcluded) {
+        context.report({
+          message: `Foreign Domain files cannot import Logical Nodes from FAF tree ("${resolvedRelPath}").`,
+          node
+        });
+      }
+    }
+    return {
+      ExportAllDeclaration(node) {
+        checkImport(node, node.source.value);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkImport(node, node.source.value);
+        }
+      },
+      ImportDeclaration(node) {
+        checkImport(node, node.source.value);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce isolation between Foreign Domains and Logical Nodes"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var foreign_domain_isolation_rule_default = rule3;
+
+// src/_rules/fragment-master-node/fragment-master-node.rule.ts
+import path9 from "path";
+
+// src/_rules/_rules@shared/_utils/_primitives/get-file-role/get-file-role.util.ts
+function getFileRole(fileName, config) {
+  if (fileName === "index.ts" || fileName === "index.js") {
+    return "index";
+  }
+  const parts = fileName.split(".");
+  let allRoles = state.rolesCache.get(config);
+  if (!allRoles) {
+    allRoles = new Set(config.roles.flat());
+    state.rolesCache.set(config, allRoles);
+  }
+  for (let i = parts.length - 2; i >= 1; i--) {
+    const part = parts[i];
+    if (part && allRoles.has(part)) {
+      return part;
+    }
+  }
+  return null;
+}
+
+// src/_rules/fragment-master-node/fragment-master-node.rule.ts
+var DEFAULT_HTTP_METHODS = [
+  "connect",
+  "delete",
+  "get",
+  "head",
+  "options",
+  "patch",
+  "post",
+  "put",
+  "trace"
+];
+var rule4 = {
+  create(context) {
+    return {
+      Program(node) {
+        const absPath = context.filename;
+        const relPath = toRelativePath(absPath);
+        const settings = context.settings;
+        if (!settings.faf) {
+          return;
+        }
+        const config = findTreeConfig(relPath, settings.faf);
+        if (!config) {
           return;
         }
-        const relDir = path7.dirname(relPath);
-        const folderName = path7.basename(relDir);
+        const relDir = path9.dirname(relPath);
+        const folderName = path9.basename(relDir);
         const parentType = classifyFolder(relDir, config);
-        if (parentType === "foreign") {
+        if (parentType !== "fragment") {
           return;
         }
-        const fileName = path7.basename(relPath);
-        let currentDir = relDir;
-        while (currentDir && currentDir !== "." && currentDir !== "/") {
-          const isInTree = config.includes.some(
-            (inc) => currentDir === inc || currentDir.startsWith(inc + "/")
-          );
-          const isExcluded = config.excludes?.some(
-            (exc) => currentDir === exc || currentDir.startsWith(exc + "/")
-          ) ?? false;
-          if (!isInTree || isExcluded) {
-            break;
+        const fileName = path9.basename(relPath);
+        const rfConfig = getRootFragmentConfig(relDir, config);
+        if (rfConfig) {
+          const flatRootNodes = rfConfig.rootNodes.flat();
+          const isMatchedRootNode = flatRootNodes.some((rn) => {
+            if (rn.includes("/")) {
+              const rfPath = rfConfig.paths[0] ?? "";
+              const absRn = path9.resolve(getProjectRoot(), rfPath, rn);
+              return toRelativePath(absRn) === relPath;
+            }
+            return rn === fileName;
+          });
+          if (isMatchedRootNode) {
+            return;
           }
-          const currentFolderName = path7.basename(currentDir);
-          const currentType = classifyFolder(currentDir, config);
-          if ((currentType === "layer" || currentType === "category") && !currentFolderName.startsWith("_")) {
+        }
+        if (fileName === "index.ts" || fileName === "index.js") {
+          return;
+        }
+        if (fileName === "README.md" || fileName === "package.json" || fileName === "tsconfig.json") {
+          return;
+        }
+        const role = getFileRole(fileName, config);
+        const ext = path9.extname(fileName);
+        const allRoleNames = new Set(config.roles.flat());
+        const roleSegments = fileName.slice(0, fileName.length - ext.length).split(".").slice(1).filter((part) => allRoleNames.has(part));
+        const matchedRoute = config.routeHierarchies?.find(
+          (rh) => rh.paths.some((rp) => relDir === rp || relDir.startsWith(rp + "/"))
+        );
+        if (matchedRoute) {
+          const contents = readDirCached(relDir);
+          const fileRoles = contents.files.map((f) => getFileRole(f, config));
+          if (!fileRoles.includes(matchedRoute.role)) {
             context.report({
-              message: `Layer/Category directory "${currentFolderName}" must be prefixed with an underscore (e.g. "_${currentFolderName}").`,
+              message: `Route terminal Fragment "${folderName}" must contain a Master Node with role "${matchedRoute.role}" (e.g. "${folderName}.${matchedRoute.role}.ts").`,
               node
             });
           }
-          if (currentFolderName.startsWith("_") && !currentFolderName.includes("@shared")) {
-            const contents = readDirCached(currentDir);
-            const hasIndex = contents.files.includes("index.ts") || contents.files.includes("index.js");
-            if (hasIndex) {
-              context.report({
-                message: `Directory "${currentFolderName}" has an Access Node (index.ts) but its name starts with "_". Fragments must not be prefixed with underscore.`,
-                node
-              });
-            }
+          const httpMethods = matchedRoute.httpMethods ?? DEFAULT_HTTP_METHODS;
+          const routeNameRegex = new RegExp(
+            `^(${httpMethods.join("|")})-[a-z0-9]+(-[a-z0-9]+)*$`
+          );
+          if (!routeNameRegex.test(folderName)) {
+            context.report({
+              message: `Route terminal Fragment "${folderName}" must follow the "<method>-<object>" pattern with a lowercase HTTP method (${httpMethods.join(", ")}).`,
+              node
+            });
           }
-          if (currentFolderName !== "src") {
-            let baseFolderName = currentFolderName.replace(/@shared$/, "");
-            if (baseFolderName.startsWith("_")) {
-              baseFolderName = baseFolderName.substring(1);
-            }
-            if (baseFolderName.startsWith("[") && baseFolderName.endsWith("]")) {
-              baseFolderName = baseFolderName.substring(
-                1,
-                baseFolderName.length - 1
-              );
-            }
-            const isKebab = KEBAB_CASE_REGEX.test(baseFolderName);
-            if (!isKebab) {
-              context.report({
-                message: `Folder name "${currentFolderName}" must be in kebab-case (e.g. "_my-folder" or "_[my-param]").`,
-                node
-              });
-            }
+        }
+        let currentParent = path9.dirname(relDir).replace(/\\/g, "/");
+        let categoryConfig = null;
+        let categoryFolderName = "";
+        while (currentParent && currentParent !== "." && currentParent !== "/") {
+          const currentParentType = classifyFolder(currentParent, config);
+          if (currentParentType === "category") {
+            categoryConfig = getCategoryConfig(currentParent, config);
+            categoryFolderName = path9.basename(currentParent);
+            break;
+          } else if (currentParentType === "fragment" || currentParentType === "root-fragment" || currentParentType === "layer") {
+            break;
           }
-          if (currentType === "fractal-branch") {
-            const expectedScope = path7.basename(path7.dirname(currentDir));
-            const normalizedExpectedScope = expectedScope.startsWith("_") ? expectedScope.substring(1) : expectedScope;
-            const expectedName = `_${normalizedExpectedScope}@shared`;
-            if (currentFolderName !== expectedName) {
-              context.report({
-                message: `Fractal Branch name "${currentFolderName}" must match its parent scope name: "${expectedName}".`,
-                node
-              });
-            }
+          const nextParent = path9.dirname(currentParent).replace(/\\/g, "/");
+          if (nextParent === currentParent) break;
+          currentParent = nextParent;
+        }
+        if (categoryConfig && categoryConfig.role) {
+          const contents = readDirCached(relDir);
+          const fileRoles = contents.files.map((f) => getFileRole(f, config));
+          if (!fileRoles.includes(categoryConfig.role)) {
+            context.report({
+              message: `Fragment "${folderName}" inside Category "${categoryFolderName}" must contain a Master Node with role "${categoryConfig.role}" (e.g. "${folderName}.${categoryConfig.role}.ts").`,
+              node
+            });
           }
-          if (currentType === "invalid-fragment") {
+        }
+        if (!fileName.startsWith(folderName + ".")) {
+          context.report({
+            message: `Fragment Node "${fileName}" must share the parent Fragment name: "${folderName}.<role>${ext}".`,
+            node
+          });
+        }
+        if (!role) {
+          context.report({
+            message: `File "${fileName}" inside Fragment "${folderName}" must have an explicit role suffix (e.g. "${folderName}.style${ext}").`,
+            node
+          });
+        } else if (roleSegments.length > 1) {
+        } else {
+          const contents = readDirCached(relDir);
+          const duplicate = contents.files.find(
+            (f) => f !== fileName && f !== "index.ts" && f !== "index.js" && getFileRole(f, config) === role
+          );
+          if (duplicate) {
             context.report({
-              message: `Fragment directory "${currentFolderName}" is missing an Access Node (index.ts/index.js).`,
+              message: `Fragment Node "${fileName}" shares Role "${role}" with sibling "${duplicate}". Each Fragment Node must have a unique Role within its Fragment.`,
               node
             });
           }
-          const relParentDir = path7.dirname(currentDir).replace(/\\/g, "/");
-          const parentFolderName = path7.basename(relParentDir);
-          const relParentType = relParentDir === "." || relParentDir === "/" ? "unknown" : classifyFolder(relParentDir, config);
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce Fragment Node identity and Master Node integrity in FAF Fragments"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var fragment_master_node_rule_default = rule4;
+
+// src/_rules/logical-domain-placement/logical-domain-placement.rule.ts
+import path10 from "path";
+var rule5 = {
+  create(context) {
+    return {
+      Program(node) {
+        const absPath = context.filename;
+        const relPath = toRelativePath(absPath);
+        const settings = context.settings;
+        if (!settings.faf) {
+          return;
+        }
+        const config = findTreeConfig(relPath, settings.faf);
+        if (!config) {
+          return;
+        }
+        const relDir = path10.dirname(relPath);
+        const folderName = path10.basename(relDir);
+        const parentType = classifyFolder(relDir, config);
+        if (parentType === "foreign") {
+          return;
+        }
+        const fileName = path10.basename(relPath);
+        for (const {
+          folderName: currentFolderName,
+          parentDir: relParentDir,
+          parentFolderName,
+          parentType: relParentType,
+          type: currentType
+        } of walkAncestors(relDir, config)) {
           if (currentType === "root-fragment") {
             if (relParentType !== "root-fragment" && relParentType !== "unknown") {
               context.report({
@@ -597,7 +983,6 @@ var rule3 = {
               });
             }
           }
-          currentDir = path7.dirname(currentDir).replace(/\\/g, "/");
         }
         if (parentType === "layer") {
           context.report({
@@ -611,309 +996,187 @@ var rule3 = {
             message: `Fractal Branches cannot contain files directly. File "${fileName}" is placed directly inside Fractal Branch "${folderName}".`,
             node
           });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce topological placement constraints between FAF Logical Domains"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var logical_domain_placement_rule_default = rule5;
+
+// src/_rules/naming-conventions/naming-conventions.rule.ts
+import path11 from "path";
+var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var rule6 = {
+  create(context) {
+    return {
+      Program(node) {
+        const absPath = context.filename;
+        const relPath = toRelativePath(absPath);
+        const settings = context.settings;
+        if (!settings.faf) {
           return;
         }
-        if (parentType === "invalid-fragment") {
+        const config = findTreeConfig(relPath, settings.faf);
+        if (!config) {
           return;
         }
-        const rfConfig = getRootFragmentConfig(relDir, config);
-        if (rfConfig) {
-          const flatRootNodes = rfConfig.rootNodes.flat();
-          const isMatchedRootNode = flatRootNodes.some((rn) => {
-            if (rn.includes("/")) {
-              const rfPath = rfConfig.paths[0] ?? "";
-              const absRn = path7.resolve(getProjectRoot(), rfPath, rn);
-              return toRelativePath(absRn) === relPath;
-            }
-            return rn === fileName;
-          });
-          if (isMatchedRootNode) {
-            return;
-          }
+        const relDir = path11.dirname(relPath);
+        const parentType = classifyFolder(relDir, config);
+        if (parentType === "foreign") {
+          return;
         }
-        if (fileName === "index.ts" || fileName === "index.js") {
-          if (parentType !== "fragment") {
+        const fileName = path11.basename(relPath);
+        for (const {
+          dir: currentDir,
+          folderName: currentFolderName,
+          type: currentType
+        } of walkAncestors(relDir, config)) {
+          if ((currentType === "layer" || currentType === "category") && !currentFolderName.startsWith("_")) {
             context.report({
-              message: `Access Nodes ("index.ts/index.js") are exclusive to Fragments. Found index file directly inside "${folderName}" (classified as ${parentType}).`,
+              message: `Layer/Category directory "${currentFolderName}" must be prefixed with an underscore (e.g. "_${currentFolderName}").`,
               node
             });
-          } else {
-            const contents = readDirCached(relDir);
-            const hasFragmentNode = contents.files.some(
-              (f) => f !== "index.ts" && f !== "index.js" && f !== "README.md" && f !== "package.json" && f !== "tsconfig.json"
-            );
-            if (!hasFragmentNode) {
-              context.report({
-                message: `Fragment "${folderName}" has no Master Node. Every Fragment must contain at least one Fragment Node establishing its Role.`,
-                node
-              });
-            }
           }
-          return;
-        }
-        if (fileName === "README.md" || fileName === "package.json" || fileName === "tsconfig.json") {
-          return;
-        }
-        const role = getFileRole(fileName, config);
-        const ext = path7.extname(fileName);
-        const allRoleNames = new Set(config.roles.flat());
-        const roleSegments = fileName.slice(0, fileName.length - ext.length).split(".").slice(1).filter((part) => allRoleNames.has(part));
-        const multiRoleMessage = `File "${fileName}" composes multiple Roles ("${roleSegments.join('", "')}") in its name. A Logical Node may declare only one Role; promote the detail that needs its own Role to an autonomous Sub-Fragment.`;
-        if (parentType === "fragment") {
-          const matchedRoute = config.routeHierarchies?.find(
-            (rh) => rh.paths.some((rp) => relDir === rp || relDir.startsWith(rp + "/"))
-          );
-          if (matchedRoute) {
-            const contents = readDirCached(relDir);
-            const fileRoles = contents.files.map((f) => getFileRole(f, config));
-            if (!fileRoles.includes(matchedRoute.role)) {
-              context.report({
-                message: `Route terminal Fragment "${folderName}" must contain a Master Node with role "${matchedRoute.role}" (e.g. "${folderName}.${matchedRoute.role}.ts").`,
-                node
-              });
-            }
-            const httpMethods = matchedRoute.httpMethods ?? DEFAULT_HTTP_METHODS;
-            const routeNameRegex = new RegExp(
-              `^(${httpMethods.join("|")})-[a-z0-9]+(-[a-z0-9]+)*$`
-            );
-            if (!routeNameRegex.test(folderName)) {
+          if (currentFolderName.startsWith("_") && !currentFolderName.includes("@shared")) {
+            const contents = readDirCached(currentDir);
+            const hasIndex = contents.files.includes("index.ts") || contents.files.includes("index.js");
+            if (hasIndex) {
               context.report({
-                message: `Route terminal Fragment "${folderName}" must follow the "<method>-<object>" pattern with a lowercase HTTP method (${httpMethods.join(", ")}).`,
+                message: `Directory "${currentFolderName}" has an Access Node (index.ts) but its name starts with "_". Fragments must not be prefixed with underscore.`,
                 node
               });
             }
           }
-          let currentParent = path7.dirname(relDir).replace(/\\/g, "/");
-          let categoryConfig = null;
-          let categoryFolderName = "";
-          while (currentParent && currentParent !== "." && currentParent !== "/") {
-            const parentType2 = classifyFolder(currentParent, config);
-            if (parentType2 === "category") {
-              categoryConfig = getCategoryConfig(currentParent, config);
-              categoryFolderName = path7.basename(currentParent);
-              break;
-            } else if (parentType2 === "fragment" || parentType2 === "root-fragment" || parentType2 === "layer") {
-              break;
+          if (currentFolderName !== "src") {
+            let baseFolderName = currentFolderName.replace(/@shared$/, "");
+            if (baseFolderName.startsWith("_")) {
+              baseFolderName = baseFolderName.substring(1);
             }
-            const nextParent = path7.dirname(currentParent).replace(/\\/g, "/");
-            if (nextParent === currentParent) break;
-            currentParent = nextParent;
-          }
-          if (categoryConfig && categoryConfig.role) {
-            const contents = readDirCached(relDir);
-            const fileRoles = contents.files.map((f) => getFileRole(f, config));
-            if (!fileRoles.includes(categoryConfig.role)) {
+            if (baseFolderName.startsWith("[") && baseFolderName.endsWith("]")) {
+              baseFolderName = baseFolderName.substring(
+                1,
+                baseFolderName.length - 1
+              );
+            }
+            const isKebab = KEBAB_CASE_REGEX.test(baseFolderName);
+            if (!isKebab) {
               context.report({
-                message: `Fragment "${folderName}" inside Category "${categoryFolderName}" must contain a Master Node with role "${categoryConfig.role}" (e.g. "${folderName}.${categoryConfig.role}.ts").`,
+                message: `Folder name "${currentFolderName}" must be in kebab-case (e.g. "_my-folder" or "_[my-param]").`,
                 node
               });
             }
           }
-          if (!fileName.startsWith(folderName + ".")) {
-            context.report({
-              message: `Fragment Node "${fileName}" must share the parent Fragment name: "${folderName}.<role>${ext}".`,
-              node
-            });
-          }
-          if (!role) {
-            context.report({
-              message: `File "${fileName}" inside Fragment "${folderName}" must have an explicit role suffix (e.g. "${folderName}.style${ext}").`,
-              node
-            });
-          } else if (roleSegments.length > 1) {
-            context.report({ message: multiRoleMessage, node });
-          } else {
-            const contents = readDirCached(relDir);
-            const duplicate = contents.files.find(
-              (f) => f !== fileName && f !== "index.ts" && f !== "index.js" && getFileRole(f, config) === role
-            );
-            if (duplicate) {
+          if (currentType === "fractal-branch") {
+            const expectedScope = path11.basename(path11.dirname(currentDir));
+            const normalizedExpectedScope = expectedScope.startsWith("_") ? expectedScope.substring(1) : expectedScope;
+            const expectedName = `_${normalizedExpectedScope}@shared`;
+            if (currentFolderName !== expectedName) {
               context.report({
-                message: `Fragment Node "${fileName}" shares Role "${role}" with sibling "${duplicate}". Each Fragment Node must have a unique Role within its Fragment.`,
+                message: `Fractal Branch name "${currentFolderName}" must match its parent scope name: "${expectedName}".`,
                 node
               });
             }
           }
         }
-        if (parentType === "category") {
-          const catConfig = getCategoryConfig(relDir, config);
-          if (catConfig) {
-            const allowedExts = catConfig.allowedExtensions ?? [
-              ".js",
-              ".jsx",
-              ".ts",
-              ".tsx"
-            ];
-            if (!allowedExts.includes(ext)) {
-              context.report({
-                message: `File extension "${ext}" is not allowed in Category "${folderName}". Allowed extensions: ${allowedExts.join(", ")}.`,
-                node
-              });
-              return;
-            }
-            const isCodeExt = [".js", ".jsx", ".ts", ".tsx"].includes(ext);
-            if (isCodeExt) {
-              if (!role) {
-                context.report({
-                  message: `Logical Node "${fileName}" inside Category "${folderName}" must have a role suffix.`,
-                  node
-                });
-              } else if (role !== catConfig.role) {
-                context.report({
-                  message: `Role "${role}" for file "${fileName}" does not match the expected Category role "${catConfig.role}".`,
-                  node
-                });
-              } else if (roleSegments.length > 1) {
-                context.report({ message: multiRoleMessage, node });
-              }
-            } else {
-              if (role && role !== catConfig.role) {
-                context.report({
-                  message: `Role "${role}" for asset "${fileName}" does not match the expected Category role "${catConfig.role}".`,
-                  node
-                });
-              } else if (role && roleSegments.length > 1) {
-                context.report({ message: multiRoleMessage, node });
-              }
+        if (parentType === "layer" || parentType === "fractal-branch" || parentType === "invalid-fragment") {
+          return;
+        }
+        const rfConfig = getRootFragmentConfig(relDir, config);
+        if (rfConfig) {
+          const flatRootNodes = rfConfig.rootNodes.flat();
+          const isMatchedRootNode = flatRootNodes.some((rn) => {
+            if (rn.includes("/")) {
+              const rfPath = rfConfig.paths[0] ?? "";
+              const absRn = path11.resolve(getProjectRoot(), rfPath, rn);
+              return toRelativePath(absRn) === relPath;
             }
+            return rn === fileName;
+          });
+          if (isMatchedRootNode) {
+            return;
           }
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      description: "Enforce naming conventions and folder taxonomy in FAF architecture"
-    },
-    schema: [],
-    type: "problem"
-  }
-};
-var naming_conventions_rule_default = rule3;
-
-// src/_rules/no-direct-fragment-import/no-direct-fragment-import.rule.ts
-import path9 from "path";
-
-// src/_rules/_rules@shared/_utils/_aggregates/resolve-import-path/resolve-import-path.util.ts
-import fs2 from "fs";
-import path8 from "path";
-function resolveImportPath(importPath, currentFileRelative, settings) {
-  const cacheKey = `${currentFileRelative}::${importPath}`;
-  const cached = state.resolvedImportPathCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const result = _resolveImportPath(importPath, currentFileRelative, settings);
-  state.resolvedImportPathCache.set(cacheKey, result);
-  return result;
-}
-function _resolveImportPath(importPath, currentFileRelative, settings) {
-  const pkgImports = loadPackageImports(state.projectRoot);
-  const aliases = Object.keys(pkgImports).length > 0 ? pkgImports : settings?.aliases || {};
-  let matchedAlias = null;
-  let longestMatch = 0;
-  for (const alias of Object.keys(aliases)) {
-    if (importPath === alias || importPath.startsWith(alias + "/")) {
-      if (alias.length > longestMatch) {
-        longestMatch = alias.length;
-        matchedAlias = alias;
-      }
-    }
-  }
-  let relResolved;
-  if (matchedAlias) {
-    const target = aliases[matchedAlias];
-    if (target) {
-      const remainder = importPath.substring(matchedAlias.length);
-      const absTarget = path8.resolve(state.projectRoot, target + remainder);
-      relResolved = toRelativePath(absTarget);
-    } else {
-      return "";
-    }
-  } else {
-    if (importPath.startsWith(".") || importPath.startsWith("/")) {
-      const absCurrentDir = path8.dirname(
-        path8.resolve(state.projectRoot, currentFileRelative)
-      );
-      const absResolved = path8.resolve(absCurrentDir, importPath);
-      relResolved = toRelativePath(absResolved);
-    } else {
-      return "";
-    }
-  }
-  return finalizeResolvedPath(relResolved);
-}
-var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
-  "cjs",
-  "cts",
-  "js",
-  "jsx",
-  "mjs",
-  "mts",
-  "ts",
-  "tsx"
-]);
-function finalizeResolvedPath(relResolved) {
-  const resolvedDir = path8.dirname(relResolved).replace(/\\/g, "/");
-  const resolvedBase = path8.basename(relResolved);
-  const dirContents = readDirCached(relResolved);
-  if (dirContents.files.includes("index.ts")) {
-    return (relResolved === "." ? "" : relResolved + "/") + "index.ts";
-  }
-  if (dirContents.files.includes("index.js")) {
-    return (relResolved === "." ? "" : relResolved + "/") + "index.js";
-  }
-  const parentContents = readDirCached(resolvedDir);
-  const exactMatch = parentContents.files.find((f) => f === resolvedBase);
-  if (!exactMatch) {
-    const candidates = parentContents.files.filter(
-      (f) => f.startsWith(resolvedBase + ".")
-    );
-    const matchWithExt = candidates.find(
-      (f) => SCRIPT_EXTENSIONS.has(f.slice(resolvedBase.length + 1))
-    ) ?? candidates[0];
-    if (matchWithExt) {
-      return (resolvedDir === "." ? "" : resolvedDir + "/") + matchWithExt;
-    }
-  }
-  return relResolved;
-}
-function loadPackageImports(projectRootPath) {
-  if (state.packageImports !== null) {
-    return state.packageImports;
-  }
-  state.packageImports = {};
-  const isTest = typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.VITEST === "true");
-  if (isTest) {
-    return state.packageImports;
-  }
-  const pkgPath = path8.resolve(projectRootPath, "package.json");
-  if (fs2.existsSync(pkgPath)) {
-    try {
-      const pkgContent = fs2.readFileSync(pkgPath, "utf8");
-      const pkg = JSON.parse(pkgContent);
-      if (pkg.imports) {
-        for (const [key, val] of Object.entries(pkg.imports)) {
-          if (typeof val === "string") {
-            const cleanKey = key.endsWith("/*") ? key.slice(0, -2) : key.endsWith("*") ? key.slice(0, -1) : key;
-            let cleanVal = val.endsWith("/*") ? val.slice(0, -2) : val.endsWith("*") ? val.slice(0, -1) : val;
-            if (cleanVal.startsWith("./")) {
-              cleanVal = cleanVal.substring(2);
-            } else if (cleanVal.startsWith("/")) {
-              cleanVal = cleanVal.substring(1);
+        }
+        if (fileName === "index.ts" || fileName === "index.js") {
+          return;
+        }
+        if (fileName === "README.md" || fileName === "package.json" || fileName === "tsconfig.json") {
+          return;
+        }
+        const role = getFileRole(fileName, config);
+        const ext = path11.extname(fileName);
+        const allRoleNames = new Set(config.roles.flat());
+        const roleSegments = fileName.slice(0, fileName.length - ext.length).split(".").slice(1).filter((part) => allRoleNames.has(part));
+        const multiRoleMessage = `File "${fileName}" composes multiple Roles ("${roleSegments.join('", "')}") in its name. A Logical Node may declare only one Role; promote the detail that needs its own Role to an autonomous Sub-Fragment.`;
+        if (parentType === "fragment" && role && roleSegments.length > 1) {
+          context.report({ message: multiRoleMessage, node });
+        }
+        if (parentType === "category") {
+          const folderName = path11.basename(relDir);
+          const catConfig = getCategoryConfig(relDir, config);
+          if (catConfig) {
+            const allowedExts = catConfig.allowedExtensions ?? [
+              ".js",
+              ".jsx",
+              ".ts",
+              ".tsx"
+            ];
+            if (!allowedExts.includes(ext)) {
+              context.report({
+                message: `File extension "${ext}" is not allowed in Category "${folderName}". Allowed extensions: ${allowedExts.join(", ")}.`,
+                node
+              });
+              return;
+            }
+            const isCodeExt = [".js", ".jsx", ".ts", ".tsx"].includes(ext);
+            if (isCodeExt) {
+              if (!role) {
+                context.report({
+                  message: `Logical Node "${fileName}" inside Category "${folderName}" must have a role suffix.`,
+                  node
+                });
+              } else if (role !== catConfig.role) {
+                context.report({
+                  message: `Role "${role}" for file "${fileName}" does not match the expected Category role "${catConfig.role}".`,
+                  node
+                });
+              } else if (roleSegments.length > 1) {
+                context.report({ message: multiRoleMessage, node });
+              }
+            } else {
+              if (role && role !== catConfig.role) {
+                context.report({
+                  message: `Role "${role}" for asset "${fileName}" does not match the expected Category role "${catConfig.role}".`,
+                  node
+                });
+              } else if (role && roleSegments.length > 1) {
+                context.report({ message: multiRoleMessage, node });
+              }
             }
-            state.packageImports[cleanKey] = cleanVal;
           }
         }
       }
-    } catch {
-    }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce lexical naming conventions for FAF folders and Logical Nodes"
+    },
+    schema: [],
+    type: "problem"
   }
-  return state.packageImports;
-}
+};
+var naming_conventions_rule_default = rule6;
 
 // src/_rules/no-direct-fragment-import/no-direct-fragment-import.rule.ts
-var rule4 = {
+import path12 from "path";
+var rule7 = {
   create(context) {
     const absPath = context.filename;
     const relPath = toRelativePath(absPath);
@@ -934,13 +1197,13 @@ var rule4 = {
       if (!resolvedRelPath) {
         return;
       }
-      const importedDir = path9.dirname(resolvedRelPath);
-      const importedFile = path9.basename(resolvedRelPath);
+      const importedDir = path12.dirname(resolvedRelPath);
+      const importedFile = path12.basename(resolvedRelPath);
       const importedFolderType = classifyFolder(importedDir, config);
       if (importedFolderType === "fragment") {
         const isAccessNode = importedFile === "index.ts" || importedFile === "index.js";
         if (!isAccessNode) {
-          const isInside = path9.dirname(relPath) === importedDir;
+          const isInside = path12.dirname(relPath) === importedDir;
           if (!isInside) {
             context.report({
               message: `Direct import of Fragment internal file "${importedFile}" is forbidden. You must import through its Access Node (index file) in "${importedDir}".`,
@@ -972,21 +1235,21 @@ var rule4 = {
     type: "problem"
   }
 };
-var no_direct_fragment_import_rule_default = rule4;
+var no_direct_fragment_import_rule_default = rule7;
 
 // src/_rules/no-fractal-branch-leak/no-fractal-branch-leak.rule.ts
-import path12 from "path";
+import path15 from "path";
 
 // src/_rules/_rules@shared/_utils/_primitives/get-fractal-branch-owner/get-fractal-branch-owner.util.ts
-import path10 from "path";
+import path13 from "path";
 function getFractalBranchOwner(relPath) {
   let current = relPath;
   while (current && current !== "." && current !== "/") {
-    const folderName = path10.basename(current);
+    const folderName = path13.basename(current);
     if (folderName.startsWith("_") && folderName.includes("@shared")) {
-      return path10.dirname(current).replace(/\\/g, "/");
+      return path13.dirname(current).replace(/\\/g, "/");
     }
-    const parent = path10.dirname(current).replace(/\\/g, "/");
+    const parent = path13.dirname(current).replace(/\\/g, "/");
     if (parent === current) {
       break;
     }
@@ -1006,11 +1269,11 @@ function getImmediateSubDomain(relPath, privateCategoryPath) {
 }
 
 // src/_rules/_rules@shared/_utils/_systems/get-private-category-info/get-private-category-info.util.ts
-import path11 from "path";
+import path14 from "path";
 function getPrivateCategoryInfo(relPath, config) {
   let current = relPath;
   while (current && current !== "." && current !== "/") {
-    const parent = path11.dirname(current).replace(/\\/g, "/");
+    const parent = path14.dirname(current).replace(/\\/g, "/");
     if (parent === current) {
       break;
     }
@@ -1025,7 +1288,22 @@ function getPrivateCategoryInfo(relPath, config) {
 }
 
 // src/_rules/no-fractal-branch-leak/no-fractal-branch-leak.rule.ts
-var rule5 = {
+function getFractalBranchPath(relPath) {
+  let current = relPath;
+  while (current && current !== "." && current !== "/") {
+    const folderName = path15.basename(current);
+    if (folderName.startsWith("_") && folderName.includes("@shared")) {
+      return current;
+    }
+    const parent = path15.dirname(current).replace(/\\/g, "/");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var rule8 = {
   create(context) {
     const absPath = context.filename;
     const relPath = toRelativePath(absPath);
@@ -1046,7 +1324,7 @@ var rule5 = {
       if (!resolvedRelPath) {
         return;
       }
-      const importedDir = path12.dirname(resolvedRelPath);
+      const importedDir = path15.dirname(resolvedRelPath);
       const fractalBranchOwner = getFractalBranchOwner(importedDir);
       if (fractalBranchOwner) {
         const isDescendant = relPath === fractalBranchOwner || relPath.startsWith(fractalBranchOwner + "/");
@@ -1059,7 +1337,7 @@ var rule5 = {
           const info = getPrivateCategoryInfo(importedDir, config);
           if (info) {
             const { owner, privateCategoryPath } = info;
-            const isPrivateDirectChild = path12.dirname(relPath) === owner;
+            const isPrivateDirectChild = path15.dirname(relPath) === owner;
             const importerSubDomain = getImmediateSubDomain(
               relPath,
               privateCategoryPath
@@ -1079,6 +1357,18 @@ var rule5 = {
           }
         }
       }
+      const importerBranchPath = getFractalBranchPath(path15.dirname(relPath));
+      if (importerBranchPath) {
+        const importerBranchOwner = path15.dirname(importerBranchPath).replace(/\\/g, "/");
+        const isImportedInsideOwnBranch = resolvedRelPath === importerBranchPath || resolvedRelPath.startsWith(importerBranchPath + "/");
+        const isImportedInsideServedSubtree = resolvedRelPath === importerBranchOwner || resolvedRelPath.startsWith(importerBranchOwner + "/");
+        if (isImportedInsideServedSubtree && !isImportedInsideOwnBranch) {
+          context.report({
+            message: `Fractal Branch "${importerBranchPath}" cannot depend on "${resolvedRelPath}" from the subtree it serves. A Fractal Branch may only provide implementation details to its parent scope; it must never depend on it, not even indirectly.`,
+            node
+          });
+        }
+      }
     }
     return {
       ExportAllDeclaration(node) {
@@ -1102,33 +1392,10 @@ var rule5 = {
     type: "problem"
   }
 };
-var no_fractal_branch_leak_rule_default = rule5;
+var no_fractal_branch_leak_rule_default = rule8;
 
 // src/_rules/no-peer-dependency/no-peer-dependency.rule.ts
-import path13 from "path";
-
-// src/_rules/_rules@shared/_utils/_primitives/find-tree-config-including-excluded/find-tree-config-including-excluded.util.ts
-function findTreeConfigIncludingExcluded(relPath, settings) {
-  if (!settings || !settings.trees) {
-    return null;
-  }
-  const cached = state.treeConfigIncludingExcludedCache.get(relPath);
-  if (cached !== void 0) {
-    return cached;
-  }
-  let result = null;
-  for (const tree of settings.trees) {
-    const isIncluded = tree.includes.some(
-      (inc) => relPath === inc || relPath.startsWith(inc + "/")
-    );
-    if (isIncluded) {
-      result = tree;
-      break;
-    }
-  }
-  state.treeConfigIncludingExcludedCache.set(relPath, result);
-  return result;
-}
+import path18 from "path";
 
 // src/_rules/_rules@shared/_utils/_primitives/get-lca-and-sub-branches/get-lca-and-sub-branches.util.ts
 function getLcaAndSubBranches(pathA, pathB) {
@@ -1158,6 +1425,19 @@ function getRoleHierarchyIndex(role, config) {
   return -1;
 }
 
+// src/_rules/_rules@shared/_utils/_primitives/get-root-node-index/get-root-node-index.util.ts
+import path16 from "path";
+function getRootNodeIndex(relPath, rfConfig, lcaPath) {
+  const relToLca = path16.relative(lcaPath, relPath).replace(/\\/g, "/");
+  for (let i = 0; i < rfConfig.rootNodes.length; i++) {
+    const group = rfConfig.rootNodes[i];
+    if (group && group.includes(relToLca)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 // src/_rules/_rules@shared/_utils/_primitives/resolve-horizontal-hierarchy/resolve-horizontal-hierarchy.util.ts
 function resolveHorizontalHierarchy(lcaPath, subA, subB, config) {
   const local = config.localHorizontalHierarchies?.find(
@@ -1181,21 +1461,12 @@ function resolveHorizontalHierarchy(lcaPath, subA, subB, config) {
   return { allowed: false, defined: false };
 }
 
-// src/_rules/no-peer-dependency/no-peer-dependency.rule.ts
-function getRootNodeIndex(relPath, rfConfig, lcaPath) {
-  const relToLca = path13.relative(lcaPath, relPath).replace(/\\/g, "/");
-  for (let i = 0; i < rfConfig.rootNodes.length; i++) {
-    const group = rfConfig.rootNodes[i];
-    if (group && group.includes(relToLca)) {
-      return i;
-    }
-  }
-  return -1;
-}
+// src/_rules/_rules@shared/_utils/_systems/is-inside-private-category-of-lca/is-inside-private-category-of-lca.util.ts
+import path17 from "path";
 function isInsidePrivateCategoryOfLca(relPathB, lcaPath, config) {
   let current = relPathB;
   while (current && current !== "." && current !== "/" && current !== lcaPath) {
-    const parent = path13.dirname(current).replace(/\\/g, "/");
+    const parent = path17.dirname(current).replace(/\\/g, "/");
     if (parent === current) {
       break;
     }
@@ -1208,7 +1479,9 @@ function isInsidePrivateCategoryOfLca(relPathB, lcaPath, config) {
   }
   return false;
 }
-var rule6 = {
+
+// src/_rules/no-peer-dependency/no-peer-dependency.rule.ts
+var rule9 = {
   create(context) {
     const absPath = context.filename;
     const relPath = toRelativePath(absPath);
@@ -1216,11 +1489,11 @@ var rule6 = {
     if (!settings.faf) {
       return {};
     }
-    const config = findTreeConfigIncludingExcluded(relPath, settings.faf);
+    const config = findTreeConfig(relPath, settings.faf);
     if (!config) {
       return {};
     }
-    const currentDir = path13.dirname(relPath);
+    const currentDir = path18.dirname(relPath);
     const isCurrentFileExcluded = config.excludes?.some(
       (exc) => relPath === exc || relPath.startsWith(exc + "/")
     ) ?? false;
@@ -1236,27 +1509,13 @@ var rule6 = {
       const isImportedFileExcluded = config?.excludes?.some(
         (exc) => resolvedRelPath === exc || resolvedRelPath.startsWith(exc + "/")
       ) ?? false;
-      if (!isCurrentFileExcluded && isImportedFileExcluded) {
-        context.report({
-          message: `Importing from Foreign Domain "${resolvedRelPath}" is forbidden for Logical Nodes.`,
-          node
-        });
-        return;
-      }
-      if (isCurrentFileExcluded && !isImportedFileExcluded) {
-        context.report({
-          message: `Foreign Domain files cannot import Logical Nodes from FAF tree ("${resolvedRelPath}").`,
-          node
-        });
-        return;
-      }
       if (isCurrentFileExcluded || isImportedFileExcluded) {
         return;
       }
-      const importedDir = path13.dirname(resolvedRelPath);
+      const importedDir = path18.dirname(resolvedRelPath);
       if (currentDir === importedDir) {
-        const fileA = path13.basename(relPath);
-        const fileB = path13.basename(resolvedRelPath);
+        const fileA = path18.basename(relPath);
+        const fileB = path18.basename(resolvedRelPath);
         const roleA = getFileRole(fileA, config);
         const roleB = getFileRole(fileB, config);
         if (roleA && roleB) {
@@ -1296,22 +1555,12 @@ var rule6 = {
         const idxRootA = getRootNodeIndex(relPath, rfConfig, lca);
         const idxRootB = getRootNodeIndex(resolvedRelPath, rfConfig, lca);
         if (idxRootA !== -1 && idxRootB !== -1) {
-          if (idxRootB >= idxRootA) {
-            context.report({
-              message: `Root Node import violation: "${path13.basename(relPath)}" cannot import from "${path13.basename(resolvedRelPath)}" under Root Fragment "${lca}".`,
-              node
-            });
-          }
           return;
         }
       }
-      const isSubARootFragment = classifyFolder(path13.posix.join(lca, subA), config) === "root-fragment";
-      const isSubBRootFragment = classifyFolder(path13.posix.join(lca, subB), config) === "root-fragment";
+      const isSubARootFragment = classifyFolder(path18.posix.join(lca, subA), config) === "root-fragment";
+      const isSubBRootFragment = classifyFolder(path18.posix.join(lca, subB), config) === "root-fragment";
       if (isSubARootFragment || isSubBRootFragment) {
-        context.report({
-          message: `Root Node import violation: "${relPath}" cannot import from "${resolvedRelPath}" because no "rootNodes" relationship is configured under Root Fragment "${lca}". Relationships between Root Nodes must always be explicitly authorized by the architect.`,
-          node
-        });
         return;
       }
       const { allowed, defined: hasDefinedHierarchy } = resolveHorizontalHierarchy(lca, subA, subB, config);
@@ -1351,11 +1600,11 @@ var rule6 = {
     type: "problem"
   }
 };
-var no_peer_dependency_rule_default = rule6;
+var no_peer_dependency_rule_default = rule9;
 
 // src/_rules/no-private-category-leak/no-private-category-leak.rule.ts
-import path14 from "path";
-var rule7 = {
+import path19 from "path";
+var rule10 = {
   create(context) {
     const absPath = context.filename;
     const relPath = toRelativePath(absPath);
@@ -1376,7 +1625,7 @@ var rule7 = {
       if (!resolvedRelPath) {
         return;
       }
-      const importedDir = path14.dirname(resolvedRelPath);
+      const importedDir = path19.dirname(resolvedRelPath);
       const info = getPrivateCategoryInfo(importedDir, config);
       if (info) {
         const { owner, privateCategoryPath } = info;
@@ -1390,7 +1639,7 @@ var rule7 = {
             isFractalBranchAllowed = relPath === fbOwner || relPath.startsWith(fbOwner + "/");
           }
         }
-        const isDirectChild = path14.dirname(relPath) === owner;
+        const isDirectChild = path19.dirname(relPath) === owner;
         const importerSubDomain = getImmediateSubDomain(
           relPath,
           privateCategoryPath
@@ -1431,17 +1680,119 @@ var rule7 = {
     type: "problem"
   }
 };
-var no_private_category_leak_rule_default = rule7;
+var no_private_category_leak_rule_default = rule10;
+
+// src/_rules/root-node-dependency-direction/root-node-dependency-direction.rule.ts
+import path20 from "path";
+var rule11 = {
+  create(context) {
+    const absPath = context.filename;
+    const relPath = toRelativePath(absPath);
+    const settings = context.settings;
+    if (!settings.faf) {
+      return {};
+    }
+    const config = findTreeConfig(relPath, settings.faf);
+    if (!config) {
+      return {};
+    }
+    const currentDir = path20.dirname(relPath);
+    const isCurrentFileExcluded = config.excludes?.some(
+      (exc) => relPath === exc || relPath.startsWith(exc + "/")
+    ) ?? false;
+    function checkImport(node, importValue) {
+      const resolvedRelPath = resolveImportPath(
+        importValue,
+        relPath,
+        settings.faf
+      );
+      if (!resolvedRelPath) {
+        return;
+      }
+      const isImportedFileExcluded = config?.excludes?.some(
+        (exc) => resolvedRelPath === exc || resolvedRelPath.startsWith(exc + "/")
+      ) ?? false;
+      if (isCurrentFileExcluded || isImportedFileExcluded) {
+        return;
+      }
+      const importedDir = path20.dirname(resolvedRelPath);
+      if (currentDir === importedDir) {
+        return;
+      }
+      const lcaInfo = getLcaAndSubBranches(currentDir, importedDir);
+      if (!lcaInfo) {
+        return;
+      }
+      const { lca, subA, subB } = lcaInfo;
+      if (subB.startsWith("_") && subB.includes("@shared")) {
+        return;
+      }
+      if (isInsidePrivateCategoryOfLca(importedDir, lca, config)) {
+        return;
+      }
+      if (subB === "" && classifyFolder(lca, config) === "fragment") {
+        return;
+      }
+      const rfConfig = getRootFragmentConfig(lca, config);
+      if (rfConfig) {
+        const idxRootA = getRootNodeIndex(relPath, rfConfig, lca);
+        const idxRootB = getRootNodeIndex(resolvedRelPath, rfConfig, lca);
+        if (idxRootA !== -1 && idxRootB !== -1) {
+          if (idxRootB >= idxRootA) {
+            context.report({
+              message: `Root Node import violation: "${path20.basename(relPath)}" cannot import from "${path20.basename(resolvedRelPath)}" under Root Fragment "${lca}".`,
+              node
+            });
+          }
+          return;
+        }
+      }
+      const isSubARootFragment = classifyFolder(path20.posix.join(lca, subA), config) === "root-fragment";
+      const isSubBRootFragment = classifyFolder(path20.posix.join(lca, subB), config) === "root-fragment";
+      if (isSubARootFragment || isSubBRootFragment) {
+        context.report({
+          message: `Root Node import violation: "${relPath}" cannot import from "${resolvedRelPath}" because no "rootNodes" relationship is configured under Root Fragment "${lca}". Relationships between Root Nodes must always be explicitly authorized by the architect.`,
+          node
+        });
+      }
+    }
+    return {
+      ExportAllDeclaration(node) {
+        checkImport(node, node.source.value);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkImport(node, node.source.value);
+        }
+      },
+      ImportDeclaration(node) {
+        checkImport(node, node.source.value);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce explicit, non-Role-based dependency direction between Root Nodes"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var root_node_dependency_direction_rule_default = rule11;
 
 // src/rules.ts
 var rules = {
   "category-mutually-exclusive": category_mutually_exclusive_rule_default,
   "enforce-access-node": enforce_access_node_rule_default,
+  "foreign-domain-isolation": foreign_domain_isolation_rule_default,
+  "fragment-master-node": fragment_master_node_rule_default,
+  "logical-domain-placement": logical_domain_placement_rule_default,
   "naming-conventions": naming_conventions_rule_default,
   "no-direct-fragment-import": no_direct_fragment_import_rule_default,
   "no-fractal-branch-leak": no_fractal_branch_leak_rule_default,
   "no-peer-dependency": no_peer_dependency_rule_default,
-  "no-private-category-leak": no_private_category_leak_rule_default
+  "no-private-category-leak": no_private_category_leak_rule_default,
+  "root-node-dependency-direction": root_node_dependency_direction_rule_default
 };
 
 // src/configs.ts
@@ -1455,11 +1806,15 @@ var configs = {
     rules: {
       "faf/category-mutually-exclusive": "error",
       "faf/enforce-access-node": "error",
+      "faf/foreign-domain-isolation": "error",
+      "faf/fragment-master-node": "error",
+      "faf/logical-domain-placement": "error",
       "faf/naming-conventions": "error",
       "faf/no-direct-fragment-import": "error",
       "faf/no-fractal-branch-leak": "error",
       "faf/no-peer-dependency": "error",
-      "faf/no-private-category-leak": "error"
+      "faf/no-private-category-leak": "error",
+      "faf/root-node-dependency-direction": "error"
     }
   }
 };