@morriconeluca/eslint-plugin-faf 0.1.1

package/dist/main.cjs

@@ -0,0 +1,1420 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  configs: () => configs,
+  default: () => main_default,
+  rules: () => rules
+});
+module.exports = __toCommonJS(main_exports);
+
+// package.json
+var package_default = {
+  name: "@morriconeluca/eslint-plugin-faf",
+  version: "0.1.1",
+  description: "An ESLint plugin for FAF projects.",
+  main: "./dist/main.cjs",
+  module: "./dist/main.js",
+  types: "./dist/main.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/main.d.ts",
+      import: "./dist/main.js",
+      require: "./dist/main.cjs"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  imports: {
+    "#_rules@shared/*": "./src/_rules/_rules@shared/*",
+    "#_utils@shared/*": "./src/_rules/_rules@shared/_utils/_utils@shared/*"
+  },
+  type: "module",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "npm run lint && tsup",
+    test: "vitest run",
+    dev: "vitest",
+    lint: "npm run lint:types && npm run lint:eslint",
+    "lint:eslint": "eslint .",
+    "lint:types": "tsc --noEmit",
+    "lint:fix": "eslint --fix .",
+    format: "prettier --write .",
+    "check-format": "prettier --check .",
+    ci: "npm run build && npm run check-format && npm run test",
+    prepublishOnly: "npm run ci",
+    "local-release": "changeset version && changeset publish",
+    prepare: "husky"
+  },
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "faf"
+  ],
+  author: "Luca Morricone",
+  license: "MIT",
+  peerDependencies: {
+    eslint: "^8.57.0 || ^9.0.0 || ^10.0.0"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.31.0",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "@eslint/js": "^10.0.1",
+    "@types/eslint": "^9.6.1",
+    "@types/node": "^25.9.3",
+    "@typescript-eslint/utils": "^8.24.1",
+    "dependency-cruiser": "^17.4.3",
+    eslint: "^10.5.0",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import-x": "^4.16.2",
+    "eslint-plugin-perfectionist": "^5.9.0",
+    husky: "^9.1.7",
+    "lint-staged": "^17.0.7",
+    prettier: "^3.8.4",
+    tsup: "^8.3.6",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.61.0",
+    vitest: "^4.1.9"
+  },
+  "lint-staged": {
+    "*": "prettier --write --ignore-unknown",
+    "src/**/*.ts": "eslint --fix"
+  }
+};
+
+// src/_rules/category-mutually-exclusive/category-mutually-exclusive.rule.ts
+var import_path5 = __toESM(require("path"), 1);
+
+// src/_rules/_rules@shared/_utils/_aggregates/classify-folder/classify-folder.util.ts
+var import_path3 = __toESM(require("path"), 1);
+
+// src/_rules/_rules@shared/_utils/_utils@shared/_stores/cache/cache.store.ts
+var state = {
+  categoryConfigCache: /* @__PURE__ */ new Map(),
+  classifyCache: /* @__PURE__ */ new Map(),
+  dirCache: {},
+  packageImports: null,
+  projectRoot: process.cwd(),
+  resolvedImportPathCache: /* @__PURE__ */ new Map(),
+  rolesCache: /* @__PURE__ */ new WeakMap(),
+  treeConfigCache: /* @__PURE__ */ new Map(),
+  treeConfigIncludingExcludedCache: /* @__PURE__ */ new Map()
+};
+
+// src/_rules/_rules@shared/_utils/_primitives/get-root-fragment-config/get-root-fragment-config.util.ts
+function getRootFragmentConfig(relDirPath, config) {
+  const checkConfig = (rfConfig) => {
+    if (rfConfig.paths.includes(relDirPath)) {
+      return rfConfig;
+    }
+    if (rfConfig.subRootFragments) {
+      for (const sub of rfConfig.subRootFragments) {
+        const res = checkConfig(sub);
+        if (res) return res;
+      }
+    }
+    return null;
+  };
+  if (config.rootFragments) {
+    for (const rf of config.rootFragments) {
+      const res = checkConfig(rf);
+      if (res) return res;
+    }
+  }
+  return null;
+}
+
+// src/_rules/_rules@shared/_utils/_compounds/is-root-fragment/is-root-fragment.util.ts
+function isRootFragment(relDirPath, config) {
+  return getRootFragmentConfig(relDirPath, config) !== null;
+}
+
+// src/_rules/_rules@shared/_utils/_primitives/get-category-config/get-category-config.util.ts
+var import_path = __toESM(require("path"), 1);
+function getCategoryConfig(relDirPath, config) {
+  const cached = state.categoryConfigCache.get(relDirPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let result = null;
+  let current = relDirPath;
+  while (current && current !== "." && current !== "/") {
+    const folderName = import_path.default.basename(current);
+    if (folderName.startsWith("_") && !folderName.includes("@shared")) {
+      const catConfig = config.categories?.find((c) => c.name === folderName);
+      if (catConfig) {
+        result = catConfig;
+        break;
+      }
+    } else {
+      break;
+    }
+    const parent = import_path.default.dirname(current).replace(/\\/g, "/");
+    if (parent === current) break;
+    current = parent;
+  }
+  state.categoryConfigCache.set(relDirPath, result);
+  return result;
+}
+
+// src/_rules/_rules@shared/_utils/_primitives/read-dir-cached/read-dir-cached.util.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function readDirCached(relDirPath) {
+  const absPath = import_path2.default.resolve(state.projectRoot, relDirPath).replace(/\\/g, "/");
+  if (state.dirCache[absPath]) {
+    return state.dirCache[absPath];
+  }
+  try {
+    const entries = import_fs.default.readdirSync(absPath, { withFileTypes: true });
+    const files = [];
+    const dirs = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        files.push(entry.name);
+      } else if (entry.isDirectory()) {
+        dirs.push(entry.name);
+      }
+    }
+    state.dirCache[absPath] = { dirs, files };
+    return state.dirCache[absPath];
+  } catch {
+    return { dirs: [], files: [] };
+  }
+}
+
+// src/_rules/_rules@shared/_utils/_aggregates/classify-folder/classify-folder.util.ts
+function classifyFolder(relDirPath, config) {
+  const cached = state.classifyCache.get(relDirPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const result = _classifyFolder(relDirPath, config);
+  state.classifyCache.set(relDirPath, result);
+  return result;
+}
+function _classifyFolder(relDirPath, config) {
+  const isExcluded = config.excludes?.some(
+    (exc) => relDirPath === exc || relDirPath.startsWith(exc + "/")
+  );
+  if (isExcluded) {
+    return "foreign";
+  }
+  if (isRootFragment(relDirPath, config)) {
+    return "root-fragment";
+  }
+  const folderName = import_path3.default.basename(relDirPath);
+  if (folderName.startsWith("_") && folderName.includes("@shared")) {
+    return "fractal-branch";
+  }
+  const contents = readDirCached(relDirPath);
+  const hasAccessNode = contents.files.some(
+    (f) => f === "index.ts" || f === "index.js"
+  );
+  const isRoute = config.routeHierarchies && config.routeHierarchies.some(
+    (rh) => rh.paths.some((rp) => {
+      if (relDirPath.startsWith(rp + "/")) {
+        const remainder = relDirPath.substring(rp.length + 1);
+        const segments = remainder.split("/");
+        return !segments.some(
+          (seg) => seg.endsWith("@shared") || seg.includes("@shared")
+        );
+      }
+      return false;
+    })
+  );
+  if (isRoute && !hasAccessNode) {
+    return "layer";
+  }
+  if (folderName.startsWith("_")) {
+    const catConfig = getCategoryConfig(relDirPath, config);
+    if (catConfig) {
+      return "category";
+    }
+    return "layer";
+  }
+  const isCategory = config.categories && config.categories.some((c) => c.name === "_" + folderName);
+  if (isCategory && !hasAccessNode) {
+    return "category";
+  }
+  if (hasAccessNode) {
+    return "fragment";
+  }
+  return "invalid-fragment";
+}
+
+// src/_rules/_rules@shared/_utils/_primitives/find-tree-config/find-tree-config.util.ts
+function findTreeConfig(relPath, settings) {
+  if (!settings || !settings.trees) {
+    return null;
+  }
+  const cached = state.treeConfigCache.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 + "/")
+    );
+    const isExcluded = tree.excludes?.some(
+      (exc) => relPath === exc || relPath.startsWith(exc + "/")
+    );
+    if (isIncluded && !isExcluded) {
+      result = tree;
+      break;
+    }
+  }
+  state.treeConfigCache.set(relPath, result);
+  return result;
+}
+
+// src/_rules/_rules@shared/_utils/_primitives/to-relative-path/to-relative-path.util.ts
+var import_path4 = __toESM(require("path"), 1);
+function toRelativePath(absoluteOrRelative) {
+  let abs = absoluteOrRelative;
+  if (!import_path4.default.isAbsolute(abs)) {
+    abs = import_path4.default.resolve(state.projectRoot, abs);
+  }
+  const rel = import_path4.default.relative(state.projectRoot, abs);
+  return rel.replace(/\\/g, "/");
+}
+
+// src/_rules/category-mutually-exclusive/category-mutually-exclusive.rule.ts
+var rule = {
+  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 relDir = import_path5.default.dirname(relPath);
+    const parentType = classifyFolder(relDir, config);
+    if (parentType !== "category") {
+      return {};
+    }
+    const fileName = import_path5.default.basename(relPath);
+    return {
+      Program(node) {
+        const contents = readDirCached(relDir);
+        const activeFiles = contents.files.filter(
+          (f) => f !== "README.md" && f !== "package.json" && !f.startsWith(".")
+        );
+        const activeDirs = contents.dirs.filter((d) => !d.startsWith("_"));
+        const hasFiles = activeFiles.length > 0;
+        const hasDirs = activeDirs.length > 0;
+        if (hasFiles && hasDirs) {
+          context.report({
+            loc: { column: 0, line: 1 },
+            message: `Mutua Esclusivit\xE0 violation in Category "${import_path5.default.basename(relDir)}": cannot mix single files (${activeFiles.join(", ")}) and Fragment directories (${activeDirs.join(", ")}).`,
+            node
+          });
+        }
+        if (hasFiles) {
+          const folderName = import_path5.default.basename(relDir);
+          const catConfig = getCategoryConfig(relDir, config);
+          if (catConfig) {
+            const ext = import_path5.default.extname(fileName);
+            const isAllowedAsset = catConfig.allowedExtensions?.includes(ext) ?? false;
+            if (!catConfig.allowSingleFiles && !isAllowedAsset) {
+              context.report({
+                message: `Category "${folderName}" cannot contain file nodes directly. File "${fileName}" must be encapsulated inside a Fragment.`,
+                node
+              });
+            }
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce that Categories contain either only file nodes or only Fragment folders, and check whitelist roles"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var category_mutually_exclusive_rule_default = rule;
+
+// src/_rules/enforce-access-node/enforce-access-node.rule.ts
+var import_path6 = __toESM(require("path"), 1);
+var rule2 = {
+  create(context) {
+    const absPath = context.filename;
+    const relPath = toRelativePath(absPath);
+    const fileName = import_path6.default.basename(relPath);
+    if (fileName !== "index.ts" && fileName !== "index.js") {
+      return {};
+    }
+    const settings = context.settings;
+    if (!settings.faf) {
+      return {};
+    }
+    const config = findTreeConfig(relPath, settings.faf);
+    if (!config) {
+      return {};
+    }
+    const relDir = import_path6.default.dirname(relPath);
+    const parentType = classifyFolder(relDir, config);
+    if (parentType !== "fragment") {
+      return {};
+    }
+    function checkSource(node, sourceVal) {
+      const isValidSibling = /^\.\/[^/]+$/.test(sourceVal);
+      if (!isValidSibling) {
+        context.report({
+          message: `Access Node (index file) can only import or export its own sibling Fragment Nodes using simple relative paths (e.g. "./example.component"). Got "${sourceVal}".`,
+          node
+        });
+        return;
+      }
+      const importedFilename = import_path6.default.basename(sourceVal);
+      if (importedFilename === "index" || importedFilename === "index.ts" || importedFilename === "index.js" || importedFilename === "README.md" || importedFilename === "package.json") {
+        return;
+      }
+      const fragmentName = import_path6.default.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}".`,
+          node
+        });
+      }
+    }
+    return {
+      ExportAllDeclaration(node) {
+        checkSource(node, node.source.value);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkSource(node, node.source.value);
+        }
+      },
+      ImportDeclaration(node) {
+        checkSource(node, node.source.value);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce Access Node rules for Fragments"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var enforce_access_node_rule_default = rule2;
+
+// src/_rules/naming-conventions/naming-conventions.rule.ts
+var import_path7 = __toESM(require("path"), 1);
+
+// 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/_rules@shared/_utils/_primitives/get-project-root/get-project-root.util.ts
+function getProjectRoot() {
+  return state.projectRoot;
+}
+
+// src/_rules/naming-conventions/naming-conventions.rule.ts
+var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+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) {
+          return;
+        }
+        const relDir = import_path7.default.dirname(relPath);
+        const folderName = import_path7.default.basename(relDir);
+        const parentType = classifyFolder(relDir, config);
+        if (parentType === "foreign") {
+          return;
+        }
+        const fileName = import_path7.default.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 currentFolderName = import_path7.default.basename(currentDir);
+          const currentType = classifyFolder(currentDir, config);
+          if ((currentType === "layer" || currentType === "category") && !currentFolderName.startsWith("_")) {
+            context.report({
+              message: `Layer/Category directory "${currentFolderName}" must be prefixed with an underscore (e.g. "_${currentFolderName}").`,
+              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
+              });
+            }
+          }
+          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
+              });
+            }
+          }
+          if (currentType === "fractal-branch") {
+            const expectedScope = import_path7.default.basename(import_path7.default.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
+              });
+            }
+          }
+          if (currentType === "invalid-fragment") {
+            context.report({
+              message: `Fragment directory "${currentFolderName}" is missing an Access Node (index.ts/index.js).`,
+              node
+            });
+          }
+          const relParentDir = import_path7.default.dirname(currentDir).replace(/\\/g, "/");
+          const parentFolderName = import_path7.default.basename(relParentDir);
+          const relParentType = relParentDir === "." || relParentDir === "/" ? "unknown" : classifyFolder(relParentDir, config);
+          if (currentType === "root-fragment") {
+            if (relParentType !== "root-fragment" && relParentType !== "unknown") {
+              context.report({
+                message: `Root Fragment directory "${currentFolderName}" must be placed directly inside a Root Container or another Root Fragment, not inside "${parentFolderName}" (classified as ${relParentType}).`,
+                node
+              });
+            }
+          }
+          if (currentType === "layer") {
+            if (relParentType === "fragment" || relParentType === "invalid-fragment") {
+              context.report({
+                message: `Layer directory "${currentFolderName}" cannot be placed inside "${parentFolderName}" (classified as ${relParentType}). Layers cannot reside within Fragments.`,
+                node
+              });
+            }
+          }
+          if (currentType === "fragment" || currentType === "invalid-fragment") {
+            const isParentRootContainer = config.includes.includes(relParentDir);
+            if (relParentType === "layer") {
+              const isParentRoute = config.routeHierarchies && config.routeHierarchies.some(
+                (rh) => rh.paths.some(
+                  (rp) => relParentDir === rp || relParentDir.startsWith(rp + "/")
+                )
+              );
+              if (!isParentRoute) {
+                context.report({
+                  message: `Fragment directory "${currentFolderName}" cannot be placed directly inside Layer "${parentFolderName}". Fragments must be contained within a Category.`,
+                  node
+                });
+              }
+            } else if (relParentType === "fragment" || relParentType === "invalid-fragment") {
+              context.report({
+                message: `Fragment directory "${currentFolderName}" cannot be placed directly inside Fragment "${parentFolderName}". Sub-Fragments must be contained within a Private Category.`,
+                node
+              });
+            } else if (relParentType === "fractal-branch") {
+              context.report({
+                message: `Fragment directory "${currentFolderName}" cannot be placed directly inside Fractal Branch "${parentFolderName}". Fragments must be contained within a Category.`,
+                node
+              });
+            } else if (relParentType === "root-fragment" && !isParentRootContainer) {
+              context.report({
+                message: `Fragment directory "${currentFolderName}" cannot be placed directly inside Root Fragment "${parentFolderName}". Fragments must be contained within a Category.`,
+                node
+              });
+            }
+          }
+          if (currentType === "fractal-branch") {
+            if (relParentType === "fractal-branch") {
+              context.report({
+                message: `Fractal Branch "${currentFolderName}" cannot be placed inside another Fractal Branch "${parentFolderName}".`,
+                node
+              });
+            }
+          }
+          currentDir = import_path7.default.dirname(currentDir).replace(/\\/g, "/");
+        }
+        if (parentType === "layer") {
+          context.report({
+            message: `Layers cannot contain files directly. File "${fileName}" is placed directly inside Layer "${folderName}".`,
+            node
+          });
+          return;
+        }
+        if (parentType === "fractal-branch") {
+          context.report({
+            message: `Fractal Branches cannot contain files directly. File "${fileName}" is placed directly inside Fractal Branch "${folderName}".`,
+            node
+          });
+          return;
+        }
+        if (parentType === "invalid-fragment") {
+          return;
+        }
+        if (fileName === "index.ts" || fileName === "index.js") {
+          if (parentType !== "fragment") {
+            context.report({
+              message: `Access Nodes ("index.ts/index.js") are exclusive to Fragments. Found index file directly inside "${folderName}" (classified as ${parentType}).`,
+              node
+            });
+          }
+          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 = import_path7.default.resolve(getProjectRoot(), rfPath, rn);
+              return toRelativePath(absRn) === relPath;
+            }
+            return rn === fileName;
+          });
+          if (isMatchedRootNode) {
+            return;
+          }
+        }
+        if (fileName === "README.md" || fileName === "package.json" || fileName === "tsconfig.json") {
+          return;
+        }
+        const role = getFileRole(fileName, config);
+        const ext = import_path7.default.extname(fileName);
+        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
+              });
+            }
+          }
+          let currentParent = import_path7.default.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 = import_path7.default.basename(currentParent);
+              break;
+            } else if (parentType2 === "fragment" || parentType2 === "root-fragment" || parentType2 === "layer") {
+              break;
+            }
+            const nextParent = import_path7.default.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 (!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
+            });
+          }
+        }
+        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 (role && role !== catConfig.role) {
+                context.report({
+                  message: `Role "${role}" for asset "${fileName}" does not match the expected Category role "${catConfig.role}".`,
+                  node
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  },
+  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
+var import_path9 = __toESM(require("path"), 1);
+
+// src/_rules/_rules@shared/_utils/_aggregates/resolve-import-path/resolve-import-path.util.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path8 = __toESM(require("path"), 1);
+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 = import_path8.default.resolve(state.projectRoot, target + remainder);
+      relResolved = toRelativePath(absTarget);
+    } else {
+      return "";
+    }
+  } else {
+    if (importPath.startsWith(".") || importPath.startsWith("/")) {
+      const absCurrentDir = import_path8.default.dirname(
+        import_path8.default.resolve(state.projectRoot, currentFileRelative)
+      );
+      const absResolved = import_path8.default.resolve(absCurrentDir, importPath);
+      relResolved = toRelativePath(absResolved);
+    } else {
+      return "";
+    }
+  }
+  return finalizeResolvedPath(relResolved);
+}
+function finalizeResolvedPath(relResolved) {
+  const resolvedDir = import_path8.default.dirname(relResolved).replace(/\\/g, "/");
+  const resolvedBase = import_path8.default.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 matchWithExt = parentContents.files.find(
+      (f) => f.startsWith(resolvedBase + ".")
+    );
+    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 = import_path8.default.resolve(projectRootPath, "package.json");
+  if (import_fs2.default.existsSync(pkgPath)) {
+    try {
+      const pkgContent = import_fs2.default.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/no-direct-fragment-import/no-direct-fragment-import.rule.ts
+var rule4 = {
+  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 {};
+    }
+    function checkImport(node, importValue) {
+      const resolvedRelPath = resolveImportPath(
+        importValue,
+        relPath,
+        settings.faf
+      );
+      if (!resolvedRelPath) {
+        return;
+      }
+      const importedDir = import_path9.default.dirname(resolvedRelPath);
+      const importedFile = import_path9.default.basename(resolvedRelPath);
+      const importedFolderType = classifyFolder(importedDir, config);
+      if (importedFolderType === "fragment") {
+        const isAccessNode = importedFile === "index.ts" || importedFile === "index.js";
+        if (!isAccessNode) {
+          const isInside = relPath === importedDir || relPath.startsWith(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}".`,
+              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: "Prevent direct import of Fragment internal files from outside the Fragment"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_direct_fragment_import_rule_default = rule4;
+
+// src/_rules/no-fractal-branch-leak/no-fractal-branch-leak.rule.ts
+var import_path11 = __toESM(require("path"), 1);
+
+// src/_rules/_rules@shared/_utils/_systems/get-private-category-owner/get-private-category-owner.util.ts
+var import_path10 = __toESM(require("path"), 1);
+function getPrivateCategoryOwner(relPath, config) {
+  let current = relPath;
+  while (current && current !== "." && current !== "/") {
+    const parent = import_path10.default.dirname(current).replace(/\\/g, "/");
+    if (parent === current) {
+      break;
+    }
+    const currentType = classifyFolder(current, config);
+    const parentType = classifyFolder(parent, config);
+    if (currentType === "category" && (parentType === "fragment" || parentType === "root-fragment")) {
+      return parent;
+    }
+    current = parent;
+  }
+  return null;
+}
+
+// src/_rules/no-fractal-branch-leak/no-fractal-branch-leak.rule.ts
+function getFractalBranchOwner(relPath) {
+  let current = relPath;
+  while (current && current !== "." && current !== "/") {
+    const folderName = import_path11.default.basename(current);
+    if (folderName.startsWith("_") && folderName.includes("@shared")) {
+      return import_path11.default.dirname(current).replace(/\\/g, "/");
+    }
+    const parent = import_path11.default.dirname(current).replace(/\\/g, "/");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var rule5 = {
+  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 {};
+    }
+    function checkImport(node, importValue) {
+      const resolvedRelPath = resolveImportPath(
+        importValue,
+        relPath,
+        settings.faf
+      );
+      if (!resolvedRelPath) {
+        return;
+      }
+      const importedDir = import_path11.default.dirname(resolvedRelPath);
+      const owner = getFractalBranchOwner(importedDir);
+      if (owner) {
+        const isDescendant = relPath === owner || relPath.startsWith(owner + "/");
+        if (!isDescendant) {
+          context.report({
+            message: `Importing from Fractal Branch is forbidden. The imported resource is private to "${owner}" and its descendants.`,
+            node
+          });
+        } else {
+          const privateOwner = getPrivateCategoryOwner(importedDir, config);
+          if (privateOwner) {
+            const isPrivateDescendant = relPath === privateOwner || relPath.startsWith(privateOwner + "/");
+            if (!isPrivateDescendant) {
+              context.report({
+                message: `Importing from Private Category is forbidden. The imported resource is private to "${privateOwner}".`,
+                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: "Prevent leakage of Fractal Branch internals outside their owner scope"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_fractal_branch_leak_rule_default = rule5;
+
+// src/_rules/no-peer-dependency/no-peer-dependency.rule.ts
+var import_path12 = __toESM(require("path"), 1);
+
+// 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/_rules@shared/_utils/_primitives/get-lca-and-sub-branches/get-lca-and-sub-branches.util.ts
+function getLcaAndSubBranches(pathA, pathB) {
+  const partsA = pathA.split("/");
+  const partsB = pathB.split("/");
+  let commonLength = 0;
+  while (commonLength < partsA.length && commonLength < partsB.length && partsA[commonLength] === partsB[commonLength]) {
+    commonLength++;
+  }
+  if (commonLength === 0) {
+    return null;
+  }
+  const lca = partsA.slice(0, commonLength).join("/");
+  const subA = partsA[commonLength] || "";
+  const subB = partsB[commonLength] || "";
+  return { lca, subA, subB };
+}
+
+// src/_rules/_rules@shared/_utils/_primitives/get-role-hierarchy-index/get-role-hierarchy-index.util.ts
+function getRoleHierarchyIndex(role, config) {
+  for (let i = 0; i < config.roles.length; i++) {
+    const roleGroup = config.roles[i];
+    if (roleGroup && roleGroup.includes(role)) {
+      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(
+    (lh) => lh.paths.includes(lcaPath)
+  );
+  if (local) {
+    const idxA = local.hierarchies.findIndex((group) => group.includes(subA));
+    const idxB = local.hierarchies.findIndex((group) => group.includes(subB));
+    if (idxA !== -1 && idxB !== -1) {
+      return { allowed: idxB < idxA, defined: true };
+    }
+  }
+  const globalHierarchies = config.globalHorizontalHierarchies || [];
+  for (const gh of globalHierarchies) {
+    const idxA = gh.findIndex((group) => group.includes(subA));
+    const idxB = gh.findIndex((group) => group.includes(subB));
+    if (idxA !== -1 && idxB !== -1) {
+      return { allowed: idxB < idxA, defined: true };
+    }
+  }
+  return { allowed: false, defined: false };
+}
+
+// src/_rules/no-peer-dependency/no-peer-dependency.rule.ts
+function getDirectoryRole(dirPath, config) {
+  const folderName = import_path12.default.basename(dirPath);
+  if (folderName.startsWith("_")) {
+    return getRoleFromFolderName(folderName, config);
+  }
+  const contents = readDirCached(dirPath);
+  for (const file of contents.files) {
+    if (file.startsWith(folderName + ".")) {
+      const role = getFileRole(file, config);
+      if (role) return role;
+    }
+  }
+  return null;
+}
+function getRoleFromFolderName(name, config) {
+  const catConfig = config.categories?.find((c) => c.name === name);
+  return catConfig ? catConfig.role ?? null : null;
+}
+function getRootNodeIndex(relPath, rfConfig, lcaPath) {
+  const relToLca = import_path12.default.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;
+}
+function isInsidePrivateCategoryOfLca(relPathB, lcaPath, config) {
+  let current = relPathB;
+  while (current && current !== "." && current !== "/" && current !== lcaPath) {
+    const parent = import_path12.default.dirname(current).replace(/\\/g, "/");
+    if (parent === current) {
+      break;
+    }
+    const currentType = classifyFolder(current, config);
+    const parentType = classifyFolder(parent, config);
+    if (currentType === "category" && (parentType === "fragment" || parentType === "root-fragment") && parent === lcaPath) {
+      return true;
+    }
+    current = parent;
+  }
+  return false;
+}
+var rule6 = {
+  create(context) {
+    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 currentDir = import_path12.default.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) {
+        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 = import_path12.default.dirname(resolvedRelPath);
+      if (currentDir === importedDir) {
+        const fileA = import_path12.default.basename(relPath);
+        const fileB = import_path12.default.basename(resolvedRelPath);
+        const roleA = getFileRole(fileA, config);
+        const roleB = getFileRole(fileB, config);
+        if (roleA && roleB) {
+          const idxA = getRoleHierarchyIndex(roleA, config);
+          const idxB = getRoleHierarchyIndex(roleB, config);
+          if (idxA !== -1 && idxB !== -1) {
+            if (idxB >= idxA) {
+              context.report({
+                message: `Sibling import violation: "${fileA}" (role "${roleA}", level ${idxA}) cannot import from "${fileB}" (role "${roleB}", level ${idxB}). Imports must flow from lower to higher levels.`,
+                node
+              });
+            }
+          }
+        }
+        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: "${import_path12.default.basename(relPath)}" cannot import from "${import_path12.default.basename(resolvedRelPath)}" under Root Fragment "${lca}".`,
+              node
+            });
+          }
+          return;
+        }
+      }
+      const { allowed, defined: hasDefinedHierarchy } = resolveHorizontalHierarchy(lca, subA, subB, config);
+      if (hasDefinedHierarchy) {
+        if (!allowed) {
+          context.report({
+            message: `Horizontal hierarchy violation: "${subA}" cannot import from "${subB}" under parent "${lca}".`,
+            node
+          });
+        }
+      } else {
+        const roleA = getDirectoryRole(import_path12.default.posix.join(lca, subA), config);
+        const roleB = getDirectoryRole(import_path12.default.posix.join(lca, subB), config);
+        const idxA = roleA ? getRoleHierarchyIndex(roleA, config) : -1;
+        const idxB = roleB ? getRoleHierarchyIndex(roleB, config) : -1;
+        if (idxA !== -1 && idxB !== -1) {
+          if (idxB >= idxA) {
+            context.report({
+              message: `Horizontal hierarchy violation (fallback to roles): sibling directory "${subA}" (mapped to role "${roleA}", level ${idxA}) cannot import from "${subB}" (mapped to role "${roleB}", level ${idxB}) under parent "${lca}".`,
+              node
+            });
+          }
+        } else {
+          context.report({
+            message: `Peer separation violation: sibling directories "${subA}" and "${subB}" cannot import each other because no horizontal hierarchy is defined under parent "${lca}".`,
+            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 the Law of Separation between Peers (no-peer-dependency)"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_peer_dependency_rule_default = rule6;
+
+// src/_rules/no-private-category-leak/no-private-category-leak.rule.ts
+var import_path13 = __toESM(require("path"), 1);
+var rule7 = {
+  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 {};
+    }
+    function checkImport(node, importValue) {
+      const resolvedRelPath = resolveImportPath(
+        importValue,
+        relPath,
+        settings.faf
+      );
+      if (!resolvedRelPath) {
+        return;
+      }
+      const importedDir = import_path13.default.dirname(resolvedRelPath);
+      const owner = getPrivateCategoryOwner(importedDir, config);
+      if (owner) {
+        const isDescendant = relPath === owner || relPath.startsWith(owner + "/");
+        if (!isDescendant) {
+          context.report({
+            message: `Importing from Private Category is forbidden. The imported resource is private to "${owner}".`,
+            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: "Prevent leakage and unauthorized imports of Private Category internals"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_private_category_leak_rule_default = rule7;
+
+// src/rules.ts
+var rules = {
+  "category-mutually-exclusive": category_mutually_exclusive_rule_default,
+  "enforce-access-node": enforce_access_node_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
+};
+
+// src/configs.ts
+var configs = {
+  recommended: {
+    plugins: {
+      faf: {
+        rules
+      }
+    },
+    rules: {
+      "faf/category-mutually-exclusive": "error",
+      "faf/enforce-access-node": "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"
+    }
+  }
+};
+
+// src/main.ts
+var plugin = {
+  configs,
+  meta: {
+    name: "@morriconeluca/eslint-plugin-faf",
+    version: package_default.version
+  },
+  rules
+};
+var main_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configs,
+  rules
+});
+//# sourceMappingURL=main.cjs.map