@morriconeluca/eslint-plugin-faf 0.6.0 → 0.6.1

package/dist/main.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(main_exports);
 // package.json
 var package_default = {
   name: "@morriconeluca/eslint-plugin-faf",
-  version: "0.6.0",
+  version: "0.6.1",
   description: "An ESLint plugin for FAF projects.",
   repository: {
     type: "git",
@@ -115,12 +115,12 @@ var package_default = {
     "@stryker-mutator/core": "^10.1.1",
     "@stryker-mutator/vitest-runner": "^10.1.1",
     "@types/node": "^25.9.3",
-    "@typescript-eslint/utils": "^8.24.1",
+    "@typescript-eslint/utils": "^8.72.2",
     "@vitest/coverage-v8": "^4.1.12",
     "dependency-cruiser": "^17.4.3",
     eslint: "^10.14.0",
     "eslint-import-resolver-typescript": "^4.4.5",
-    "eslint-plugin-import-x": "^4.16.2",
+    "eslint-plugin-import-x": "^4.18.1",
     "eslint-plugin-jsdoc": "^65.4.2",
     "eslint-plugin-perfectionist": "^5.9.0",
     "eslint-plugin-sonarjs": "^4.2.2",
@@ -132,9 +132,14 @@ var package_default = {
     publint: "^0.3.25",
     tsup: "^8.3.6",
     typescript: "^6.0.3",
-    "typescript-eslint": "^8.61.0",
+    "typescript-eslint": "^8.72.2",
     vitest: "^4.1.9"
   },
+  overrides: {
+    esbuild: "^0.28.2",
+    minimatch: "^11.0.5",
+    qs: "^6.17.1"
+  },
   "lint-staged": {
     "*": "prettier --write --ignore-unknown",
     "src/**/*.ts": "eslint --fix"
@@ -176,12 +181,15 @@ var REFERENCE_D_08 = "D-08";
 var REFERENCE_D_09 = "D-09";
 var REFERENCE_D_14 = "D-14";
 var REFERENCE_FAF_4 = "FAF \xA74";
+var REFERENCE_FAF_4_6_3_1 = "FAF \xA74, \xA76.3.1";
 var REFERENCE_FAF_4_6_3_5_6_6 = "FAF \xA74, \xA76.3.5, \xA76.6";
 var REFERENCE_FAF_4_6_7 = "FAF \xA74, \xA76.7";
 var REFERENCE_FAF_5 = "FAF \xA75";
 var REFERENCE_FAF_6 = "FAF \xA76";
 var REFERENCE_FAF_6_1_1 = "FAF \xA76.1.1";
 var REFERENCE_FAF_6_1_3 = "FAF \xA76.1.3";
+var REFERENCE_FAF_6_2 = "FAF \xA76.2";
+var REFERENCE_FAF_6_2_1 = "FAF \xA76.2.1";
 var REFERENCE_FAF_6_2_2 = "FAF \xA76.2.2";
 var REFERENCE_FAF_6_3_1 = "FAF \xA76.3.1";
 var REFERENCE_FAF_6_3_2_MULTIPLE = "FAF \xA76.3.2, \xA76.4.1, \xA76.5.1, \xA76.6.1";
@@ -478,8 +486,8 @@ var OUTCOME_CATALOG = {
   "configuration/invalid-file-name": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_4,
-    predicate: "must adhere to kebab-case grammar"
+    normativeReference: REFERENCE_D_05,
+    predicate: "must be a direct child file name without path separators"
   },
   "configuration/invalid-foreign-pattern": {
     family: "configuration",
@@ -490,8 +498,8 @@ var OUTCOME_CATALOG = {
   "configuration/invalid-implicit-extension": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_6_3_1,
-    predicate: "must start with a dot and contain only lowercase letters"
+    normativeReference: REFERENCE_FAF_4_6_3_1,
+    predicate: "must be a dot-prefixed asset extension reserved to non-script files"
   },
   "configuration/invalid-literal-path": {
     family: "configuration",
@@ -568,7 +576,7 @@ var OUTCOME_CATALOG = {
   "configuration/nested-root-fragment-not-direct-child": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_6_2_2,
+    normativeReference: REFERENCE_FAF_6_2,
     predicate: "must be a direct child directory of the root fragment"
   },
   "configuration/non-existent-path": {
@@ -646,7 +654,7 @@ var OUTCOME_CATALOG = {
   "configuration/root-node-not-direct-child": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_6_2_2,
+    normativeReference: REFERENCE_FAF_6_2_1,
     predicate: "must be a direct child root node of the root fragment"
   },
   "configuration/scope-mismatch": {
@@ -682,13 +690,13 @@ var OUTCOME_CATALOG = {
   "configuration/undeclared-sub-root-fragment": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_6_2_2,
+    normativeReference: REFERENCE_FAF_6_2,
     predicate: "must be declared in subRootFragments"
   },
   "configuration/unenumerated-root-file": {
     family: "configuration",
     form: "element",
-    normativeReference: REFERENCE_FAF_6_2_2,
+    normativeReference: REFERENCE_FAF_6_2_1,
     predicate: "must be either enumerated as a Root Node or designated as a Foreign Node"
   },
   "configuration/unknown-property": {
@@ -1649,7 +1657,7 @@ function resolveSpecifiers(baseDirectory, aliases) {
   const tsconfigCandidate = import_node_path10.default.join(resolvedBase, "tsconfig.json");
   const hasTsconfig = import_node_fs10.default.existsSync(tsconfigCandidate);
   const tsconfig = hasTsconfig ? { configFile: tsconfigCandidate, references: "auto" } : void 0;
-  const resolver = new import_oxc_resolver.ResolverFactory({
+  const resolverOptions = {
     builtinModules: true,
     conditionNames: ["import", "require", "node", "types", "style", "default"],
     extensionAlias: {
@@ -1670,9 +1678,13 @@ function resolveSpecifiers(baseDirectory, aliases) {
       ".json",
       ".css"
     ],
-    importsFields: [["imports"]],
+    importsFields: [["imports"]]
+  };
+  const resolver = new import_oxc_resolver.ResolverFactory({
+    ...resolverOptions,
     tsconfig
   });
+  const noTsconfigResolver = hasTsconfig ? new import_oxc_resolver.ResolverFactory(resolverOptions) : null;
   const resolutionCache = /* @__PURE__ */ new Map();
   const toCanonicalPath = (filePath) => {
     try {
@@ -1681,17 +1693,58 @@ function resolveSpecifiers(baseDirectory, aliases) {
       return filePath;
     }
   };
+  const isCandidateForDiscordanceCheck = (cleanSpecifier, aliasUsed, hasUsedRelativeFallback, isBuiltin, resolvedPath) => {
+    const isContextEligible = hasTsconfig && aliasUsed === null && !hasUsedRelativeFallback;
+    const isBare = !cleanSpecifier.startsWith(".") && !cleanSpecifier.startsWith("/");
+    const isLocal = !isBuiltin && resolvedPath !== void 0;
+    const isOutsideNodeModules = resolvedPath !== void 0 && !toPosixPath(resolvedPath).includes(NODE_MODULES_MARKER);
+    return isContextEligible && isBare && isLocal && isOutsideNodeModules;
+  };
+  const resolveWithoutTsconfig = (directory, specifier) => {
+    if (noTsconfigResolver === null) {
+      return null;
+    }
+    try {
+      const result = noTsconfigResolver.sync(directory, specifier);
+      if (result.path === void 0) {
+        return null;
+      }
+      const cleanPath = result.path.split("?", 1)[0] ?? result.path;
+      return toCanonicalPath(cleanPath);
+    } catch {
+      return null;
+    }
+  };
+  const resolveWithFallback = (directory, specifier, canFallbackToBare) => {
+    let result = resolver.sync(directory, specifier);
+    if (canFallbackToBare && result.path === void 0 && specifier.startsWith("./")) {
+      result = resolver.sync(directory, specifier.slice(2));
+      return { hasUsedFallback: true, result };
+    }
+    return { hasUsedFallback: false, result };
+  };
+  const acquireCanonicalResult = (rawResult) => {
+    if (rawResult.path === void 0) {
+      return rawResult;
+    }
+    const cleanPath = rawResult.path.split("?", 1)[0] ?? rawResult.path;
+    return {
+      ...rawResult,
+      path: toCanonicalPath(cleanPath)
+    };
+  };
   const resolveSingle = (directory, specifier, canFallbackToBare) => {
     const cleanSpecifier = specifier.split("?", 1)[0] ?? specifier;
     const matchedAlias = matchPathAlias(cleanSpecifier, aliases);
     const aliasUsed = matchedAlias?.alias.prefix ?? null;
     const aliasAlternatives = matchedAlias?.targets ?? [];
-    let resolveResult;
+    let fallbackOutcome;
     try {
-      resolveResult = resolver.sync(directory, specifier);
-      if (canFallbackToBare && resolveResult.path === void 0 && specifier.startsWith("./")) {
-        resolveResult = resolver.sync(directory, specifier.slice(2));
-      }
+      fallbackOutcome = resolveWithFallback(
+        directory,
+        specifier,
+        canFallbackToBare
+      );
     } catch (error) {
       assertInvariant(error instanceof Error, "Expected resolver error");
       return {
@@ -1703,13 +1756,28 @@ function resolveSpecifiers(baseDirectory, aliases) {
         }
       };
     }
-    let acquiredResolveResult = resolveResult;
-    if (resolveResult.path !== void 0) {
-      const cleanResolvedPath = resolveResult.path.split("?", 1)[0] ?? resolveResult.path;
-      acquiredResolveResult = {
-        ...resolveResult,
-        path: toCanonicalPath(cleanResolvedPath)
-      };
+    const acquiredResolveResult = acquireCanonicalResult(
+      fallbackOutcome.result
+    );
+    const isCandidate = isCandidateForDiscordanceCheck(
+      cleanSpecifier,
+      aliasUsed,
+      fallbackOutcome.hasUsedFallback,
+      acquiredResolveResult.builtin !== void 0,
+      acquiredResolveResult.path
+    );
+    if (isCandidate) {
+      const nonTsconfigPath = resolveWithoutTsconfig(directory, specifier);
+      if (nonTsconfigPath === null || nonTsconfigPath !== acquiredResolveResult.path) {
+        return {
+          aliasAlternatives,
+          aliasUsed,
+          target: {
+            reason: DISCORDANCE_REASON,
+            type: "unresolved"
+          }
+        };
+      }
     }
     const target = classifyResolutionTarget({
       aliasAlternatives,
@@ -2105,6 +2173,13 @@ function extractDefaultExport(statement, rootSymbols, importedBindings, locator)
   };
 }
 
+// src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-module-exports/_utils/extract-named-specifiers-exports/_utils/extract-local-specifiers/_utils/is-local-type-export/is-local-type-export.util.ts
+function isLocalTypeExport(isExplicitlyTypeOnly, binding, localName, rootSymbols) {
+  return isExplicitlyTypeOnly && binding !== void 0 && !binding.isTypeOnly && rootSymbols.some(
+    (symbol) => symbol.name === localName && symbol.space === "type"
+  );
+}
+
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-module-exports/_utils/extract-named-specifiers-exports/_utils/extract-local-specifiers/extract-local-specifiers.util.ts
 function extractLocalSpecifiers(statement, rootSymbols, importedBindings, locator, exports2) {
   const isDeclarationTypeOnly = statement.exportKind === "type";
@@ -2113,8 +2188,9 @@ function extractLocalSpecifiers(statement, rootSymbols, importedBindings, locato
     const localName = getExportedName(specifier.local);
     const position = locator(specifier.start);
     const binding = importedBindings.get(localName);
-    if (binding === void 0) {
-      const isTypeOnly = isDeclarationTypeOnly || specifier.exportKind === "type" || isAllTypeSpace(localName, rootSymbols);
+    const isExplicitlyTypeOnly = isDeclarationTypeOnly || specifier.exportKind === "type";
+    if (binding === void 0 || isLocalTypeExport(isExplicitlyTypeOnly, binding, localName, rootSymbols)) {
+      const isTypeOnly = isExplicitlyTypeOnly || isAllTypeSpace(localName, rootSymbols);
       exports2.push({
         exportedName,
         isTypeOnly,
@@ -2122,7 +2198,7 @@ function extractLocalSpecifiers(statement, rootSymbols, importedBindings, locato
         position
       });
     } else {
-      const isTypeOnly = isDeclarationTypeOnly || specifier.exportKind === "type" || binding.isTypeOnly;
+      const isTypeOnly = isExplicitlyTypeOnly || binding.isTypeOnly;
       const origin = binding.isNamespace ? { specifier: binding.specifier, type: NAMESPACE_ORIGIN } : {
         importedName: binding.importedName,
         specifier: binding.specifier,
@@ -2621,64 +2697,67 @@ var BINDING_PATTERN_TYPES = /* @__PURE__ */ new Set([
   "ObjectPattern",
   "RestElement"
 ]);
+var EXPORTS_NAME = "exports";
 var FUNCTION_AST_TYPES = /* @__PURE__ */ new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
   "FunctionExpression"
 ]);
+var MODULE_NAME = "module";
 var REQUIRE_NAME = "require";
+var UNSUPPORTED_COMMONJS_MESSAGE = "CommonJS export assignment (module.exports / exports) is unsupported";
 var UNSUPPORTED_REQUIRE_MESSAGE = "Unsupported non-literal require call";
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/does-node-declare-require/_does-node-declare-require@shared/_utils/_primitives/does-pattern-bind-require/does-pattern-bind-require.util.ts
-function doesPatternBindRequire(pattern) {
+function doesPatternBindRequire(pattern, name = REQUIRE_NAME) {
   let current = pattern;
   while (current.type === "AssignmentPattern" || current.type === "RestElement") {
     current = current.type === "AssignmentPattern" ? current.left : current.argument;
   }
   if (current.type === "Identifier") {
-    return current.name === REQUIRE_NAME;
+    return current.name === name;
   }
   if (current.type === "ArrayPattern") {
     return current.elements.some(
-      (element) => element !== null && doesPatternBindRequire(element)
+      (element) => element !== null && doesPatternBindRequire(element, name)
     );
   }
   return current.properties.some((property) => {
     const next = property.type === "Property" ? property.value : property.argument;
-    return doesPatternBindRequire(next);
+    return doesPatternBindRequire(next, name);
   });
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/does-node-declare-require/_does-node-declare-require@shared/_utils/_compounds/does-statement-declare-require/_utils/does-target-declare-require/does-target-declare-require.util.ts
-function doesTargetDeclareRequire(statement) {
+function doesTargetDeclareRequire(statement, name = REQUIRE_NAME) {
   if (statement.type === "TSModuleDeclaration") {
-    return "name" in statement.id && statement.id.name === REQUIRE_NAME;
+    return "name" in statement.id && statement.id.name === name;
   }
   if (statement.type === "ClassDeclaration" || statement.type === "FunctionDeclaration" || statement.type === "TSEnumDeclaration") {
-    return statement.id?.name === REQUIRE_NAME;
+    return statement.id?.name === name;
   }
   return false;
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/does-node-declare-require/_does-node-declare-require@shared/_utils/_compounds/does-statement-declare-require/does-statement-declare-require.util.ts
-function doesStatementDeclareRequire(statement) {
+function doesStatementDeclareRequire(statement, name = REQUIRE_NAME) {
   if (statement.type === "ExportNamedDeclaration") {
-    return statement.declaration !== null && doesStatementDeclareRequire(statement.declaration);
+    return statement.declaration !== null && doesStatementDeclareRequire(statement.declaration, name);
   }
   if (statement.type === "VariableDeclaration") {
     return statement.declarations.some(
-      (declarator) => doesPatternBindRequire(declarator.id)
+      (declarator) => doesPatternBindRequire(declarator.id, name)
     );
   }
   if (statement.type === "ImportDeclaration") {
     return statement.specifiers.some(
-      (specifier) => specifier.local.name === REQUIRE_NAME
+      (specifier) => specifier.local.name === name
     );
   }
   if (statement.type === "TSImportEqualsDeclaration") {
-    return statement.id.name === REQUIRE_NAME;
+    return statement.id.name === name;
   }
-  return doesTargetDeclareRequire(statement);
+  return doesTargetDeclareRequire(statement, name);
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_traverse-ast@shared/_utils/is-ast-node/is-ast-node.util.ts
@@ -2698,14 +2777,14 @@ function isStatement(value) {
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/does-node-declare-require/_utils/does-function-declare-require/does-function-declare-require.util.ts
-function doesFunctionDeclareRequire(node) {
+function doesFunctionDeclareRequire(node, name = REQUIRE_NAME) {
   const id = node["id"];
-  if (isAstNode(id) && id["name"] === REQUIRE_NAME) {
+  if (isAstNode(id) && id["name"] === name) {
     return true;
   }
   const parameters = node["params"];
   if (Array.isArray(parameters) && parameters.some(
-    (parameter) => isBindingPattern(parameter) && doesPatternBindRequire(parameter)
+    (parameter) => isBindingPattern(parameter) && doesPatternBindRequire(parameter, name)
   )) {
     return true;
   }
@@ -2713,24 +2792,24 @@ function doesFunctionDeclareRequire(node) {
   if (isAstNode(body)) {
     const inner = body["body"];
     if (Array.isArray(inner)) {
-      return inner.filter(isStatement).some((statement) => doesStatementDeclareRequire(statement));
+      return inner.filter(isStatement).some((statement) => doesStatementDeclareRequire(statement, name));
     }
   }
   return false;
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/does-node-declare-require/does-node-declare-require.util.ts
-function doesNodeDeclareRequire(node) {
+function doesNodeDeclareRequire(node, name = REQUIRE_NAME) {
   if (node.type === "Program" || node.type === "BlockStatement") {
     const body = node["body"];
-    return Array.isArray(body) && body.filter(isStatement).some((statement) => doesStatementDeclareRequire(statement));
+    return Array.isArray(body) && body.filter(isStatement).some((statement) => doesStatementDeclareRequire(statement, name));
   }
   if (FUNCTION_AST_TYPES.has(node.type)) {
-    return doesFunctionDeclareRequire(node);
+    return doesFunctionDeclareRequire(node, name);
   }
   if (node.type === "CatchClause") {
     const parameter = node["param"];
-    return isBindingPattern(parameter) && doesPatternBindRequire(parameter);
+    return isBindingPattern(parameter) && doesPatternBindRequire(parameter, name);
   }
   return false;
 }
@@ -2827,20 +2906,69 @@ function handleTsImportType(importType, locator, inlineImports) {
   });
 }
 
+// src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/handle-specific-node/_utils/handle-unsupported-syntax/_utils/is-commonjs-export-assignment/_utils/is-exports-property/is-exports-property.util.ts
+function isExportsProperty(node) {
+  const property = node["property"];
+  if (!isAstNode(property)) {
+    return false;
+  }
+  if (node["computed"] === true) {
+    return extractStaticSpecifier(property) === EXPORTS_NAME;
+  }
+  return property.type === "Identifier" && property["name"] === EXPORTS_NAME;
+}
+
+// src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/handle-specific-node/_utils/handle-unsupported-syntax/_utils/is-commonjs-export-assignment/is-commonjs-export-assignment.util.ts
+function isCommonJsExportAssignment(left, isModuleShadowed, isExportsShadowed) {
+  if (left.type !== "MemberExpression") {
+    return false;
+  }
+  let current = left;
+  let innermostOnModule = null;
+  while (current.type === "MemberExpression") {
+    const object = current["object"];
+    if (!isAstNode(object)) {
+      return false;
+    }
+    if (object.type === "Identifier") {
+      if (object["name"] === EXPORTS_NAME) {
+        return !isExportsShadowed;
+      }
+      if (object["name"] === MODULE_NAME) {
+        innermostOnModule = current;
+      }
+    }
+    current = object;
+  }
+  return innermostOnModule !== null && !isModuleShadowed && isExportsProperty(innermostOnModule);
+}
+
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/handle-specific-node/_utils/handle-unsupported-syntax/handle-unsupported-syntax.util.ts
-function handleUnsupportedSyntax(node, locator, unsupportedSyntaxes) {
-  if (node.type !== "TSExportAssignment") {
+function handleUnsupportedSyntax(node, isModuleShadowed, isExportsShadowed, locator, unsupportedSyntaxes) {
+  if (node.type === "TSExportAssignment") {
+    const start2 = typeof node["start"] === "number" ? node["start"] : 0;
+    unsupportedSyntaxes.push({
+      description: "TypeScript export assignment (export =) is unsupported",
+      position: locator(start2)
+    });
+    return;
+  }
+  if (node.type !== "AssignmentExpression") {
+    return;
+  }
+  const left = node["left"];
+  if (!isAstNode(left) || !isCommonJsExportAssignment(left, isModuleShadowed, isExportsShadowed)) {
     return;
   }
   const start = typeof node["start"] === "number" ? node["start"] : 0;
   unsupportedSyntaxes.push({
-    description: "TypeScript export assignment (export =) is unsupported",
+    description: UNSUPPORTED_COMMONJS_MESSAGE,
     position: locator(start)
   });
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/handle-specific-node/handle-specific-node.util.ts
-function handleSpecificNode(node, isRequireShadowed, locator, inlineImports, unsupportedSyntaxes) {
+function handleSpecificNode(node, isRequireShadowed, isModuleShadowed, isExportsShadowed, locator, inlineImports, unsupportedSyntaxes) {
   if (node.type === "CallExpression") {
     const callee = node["callee"];
     if (!isRequireShadowed && isAstNode(callee) && callee.type === "Identifier" && callee["name"] === REQUIRE_NAME) {
@@ -2856,7 +2984,13 @@ function handleSpecificNode(node, isRequireShadowed, locator, inlineImports, uns
     handleTsImportType(node, locator, inlineImports);
     return;
   }
-  handleUnsupportedSyntax(node, locator, unsupportedSyntaxes);
+  handleUnsupportedSyntax(
+    node,
+    isModuleShadowed,
+    isExportsShadowed,
+    locator,
+    unsupportedSyntaxes
+  );
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/_utils/visit-children/visit-children.util.ts
@@ -2870,12 +3004,16 @@ function visitChildren(node, visitor) {
 }
 
 // src/_rules/conformity/_stores/session/_services/verify-project/_adapters/collect-modules/_utils/produce-module-record-by-extension/_utils/extract-script-module-record/_utils/extract-traversal-entries/_utils/traverse-ast/traverse-ast.util.ts
-function traverseAst(node, isRequireShadowed, locator, inlineImports, unsupportedSyntaxes) {
+function traverseAst(node, isRequireShadowed, isModuleShadowed, isExportsShadowed, locator, inlineImports, unsupportedSyntaxes) {
   const astNode = { ...node, type: node.type };
-  const isNextShadowed = isRequireShadowed || doesNodeDeclareRequire(astNode);
+  const isNextRequireShadowed = isRequireShadowed || doesNodeDeclareRequire(astNode, REQUIRE_NAME);
+  const isNextModuleShadowed = isModuleShadowed || doesNodeDeclareRequire(astNode, MODULE_NAME);
+  const isNextExportsShadowed = isExportsShadowed || doesNodeDeclareRequire(astNode, EXPORTS_NAME);
   handleSpecificNode(
     astNode,
-    isNextShadowed,
+    isNextRequireShadowed,
+    isNextModuleShadowed,
+    isNextExportsShadowed,
     locator,
     inlineImports,
     unsupportedSyntaxes
@@ -2883,7 +3021,9 @@ function traverseAst(node, isRequireShadowed, locator, inlineImports, unsupporte
   visitChildren(astNode, (child) => {
     traverseAst(
       child,
-      isNextShadowed,
+      isNextRequireShadowed,
+      isNextModuleShadowed,
+      isNextExportsShadowed,
       locator,
       inlineImports,
       unsupportedSyntaxes
@@ -2895,7 +3035,15 @@ function traverseAst(node, isRequireShadowed, locator, inlineImports, unsupporte
 function extractTraversalEntries(program, locator) {
   const inlineImports = [];
   const unsupportedSyntaxes = [];
-  traverseAst(program, false, locator, inlineImports, unsupportedSyntaxes);
+  traverseAst(
+    program,
+    false,
+    false,
+    false,
+    locator,
+    inlineImports,
+    unsupportedSyntaxes
+  );
   return {
     inlineImports,
     unsupportedSyntaxes
@@ -6036,21 +6184,28 @@ function isViolatingDomainName(classification, inventory, trees) {
 // src/_rules/conformity/_stores/session/_services/verify-project/_norms/nomenclature/_utils/is-violating-unit-name/_utils/is-violating-path-fragment-name/is-violating-path-fragment-name.util.ts
 function isViolatingPathFragmentName(name, lookupPath, mimeticStructures) {
   const isKebab = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name);
-  const matched = mimeticStructures.find(
-    (structure) => structure.paths.some(
+  const matchingCandidates = mimeticStructures.flatMap(
+    (structure) => structure.paths.filter(
       (prefix) => lookupPath === prefix || lookupPath.startsWith(`${prefix}/`)
-    )
+    ).map((prefix) => ({
+      prefixLength: prefix.length,
+      structure
+    }))
   );
+  matchingCandidates.sort(
+    (left, right) => right.prefixLength - left.prefixLength
+  );
+  const matched = matchingCandidates[0]?.structure;
   const actions = matched?.actions ?? [];
   if (actions.length === 0) {
     return !isKebab;
   }
   const matchingActions = actions.filter(
-    (action) => name.startsWith(`${action}-`)
+    (action) => name === action || name.startsWith(`${action}-`)
   );
   matchingActions.sort((left, right) => right.length - left.length);
   const longestAction = matchingActions[0];
-  if (longestAction === void 0) {
+  if (longestAction === void 0 || name === longestAction) {
     return true;
   }
   const target = name.slice(longestAction.length + 1);
@@ -7368,42 +7523,105 @@ function readPackageJson(input) {
 // src/_rules/conformity/_stores/session/_services/verify-project/_services/prepare-project/_adapters/include-external-targets/include-external-targets.adapter.ts
 var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_path12 = __toESM(require("path"), 1);
-function includeExternalTargets(inventory, config, baseDirectory) {
+function includeExternalTargets(inventory, config, baseDirectory, origins) {
+  const skippedDirectoryNames = /* @__PURE__ */ new Set([
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "out",
+    "reports",
+    "tmp"
+  ]);
   const items = [...inventory.items];
   const pathToId = new Map(inventory.pathToId);
   const realPathToId = new Map(inventory.realPathToId);
+  const resolveTargetKind = (target) => {
+    const normalized = toPosixPath(target);
+    if (pathToId.has(normalized)) {
+      return null;
+    }
+    const absolute = import_node_path12.default.resolve(baseDirectory, normalized);
+    const stats = import_node_fs12.default.statSync(absolute, { throwIfNoEntry: false });
+    if (stats?.isDirectory() === true) {
+      return { absolute, kind: "directory", normalized };
+    }
+    if (stats?.isFile() === true) {
+      return { absolute, kind: "file", normalized };
+    }
+    return null;
+  };
+  const declaredOriginList = origins ?? config.faf.locals.flatMap((local) => [
+    ...local.rootLayers ?? [],
+    ...local.rootFragments?.map((rootFragment) => rootFragment.path) ?? []
+  ]);
+  const declaredOrigins = new Set(
+    declaredOriginList.map((origin) => toPosixPath(origin))
+  );
+  const collectExternalCandidates = () => {
+    if (declaredOrigins.has(".") || !import_node_fs12.default.existsSync(baseDirectory)) {
+      return [];
+    }
+    const readDirectory = (directory) => {
+      try {
+        return import_node_fs12.default.readdirSync(directory, {
+          withFileTypes: true
+        });
+      } catch {
+        return [];
+      }
+    };
+    const candidates = [];
+    const directoryQueue = [baseDirectory];
+    const processDirent2 = (dirent, currentDirectory) => {
+      if (dirent.name.startsWith(".") || dirent.isSymbolicLink()) {
+        return;
+      }
+      const fullPath = import_node_path12.default.join(currentDirectory, dirent.name);
+      const relativePath = toPosixPath(
+        import_node_path12.default.relative(baseDirectory, fullPath)
+      );
+      if (dirent.isDirectory() && !skippedDirectoryNames.has(dirent.name) && !declaredOrigins.has(relativePath)) {
+        directoryQueue.push(fullPath);
+      }
+      if (relativePath !== "fafconfig.ts" && dirent.isFile() && LINTABLE_EXTENSIONS.some((extension) => dirent.name.endsWith(extension))) {
+        candidates.push(relativePath);
+      }
+    };
+    for (const currentDirectory of directoryQueue) {
+      for (const dirent of readDirectory(currentDirectory)) {
+        processDirent2(dirent, currentDirectory);
+      }
+    }
+    candidates.sort(compareOrdinal);
+    return candidates;
+  };
   const sections = [
     config.faf.common?.externalDependencies,
     ...config.faf.locals.map((local) => local.externalDependencies)
   ];
-  const targets = sections.flatMap((section) => section ?? []).flatMap((edge) => edge.to);
-  const dirents = import_node_fs12.default.existsSync(baseDirectory) ? import_node_fs12.default.readdirSync(baseDirectory, { withFileTypes: true }) : [];
-  for (const dirent of dirents) {
-    const isRootCandidate = dirent.isFile() && dirent.name !== "fafconfig.ts" && LINTABLE_EXTENSIONS.some((extension) => dirent.name.endsWith(extension));
-    if (isRootCandidate) {
-      targets.push(dirent.name);
-    }
-  }
+  const targets = [
+    ...sections.flatMap((section) => section ?? []).flatMap((edge) => edge.to),
+    ...Object.values(config.faf.common?.aliases ?? {}),
+    ...collectExternalCandidates()
+  ];
   for (const target of targets) {
-    const normalized = toPosixPath(target);
-    const absolute = import_node_path12.default.resolve(baseDirectory, normalized);
-    const stats = import_node_fs12.default.statSync(absolute, { throwIfNoEntry: false });
-    const isRegularFile = stats?.isFile() === true;
-    if (!isRegularFile || pathToId.has(normalized)) {
+    const resolved = resolveTargetKind(target);
+    if (resolved === null) {
       continue;
     }
     const id = items.length;
-    const isSymlink = import_node_fs12.default.lstatSync(absolute).isSymbolicLink();
+    const isSymlink = import_node_fs12.default.lstatSync(resolved.absolute).isSymbolicLink();
     const item = {
       depth: 0,
       id,
       isSymlink,
-      kind: "file",
+      kind: resolved.kind,
       parentId: null,
-      path: normalized,
+      path: resolved.normalized,
       preorderEnd: id,
       preorderStart: id,
-      realPath: import_node_fs12.default.realpathSync(absolute),
+      realPath: import_node_fs12.default.realpathSync(resolved.absolute),
       treeOrigin: null
     };
     items.push(item);
@@ -8777,6 +8995,9 @@ function isLiteralConfigPath(path5) {
   if (path5 === ".") {
     return true;
   }
+  if (path5.includes("\\")) {
+    return false;
+  }
   const segments = path5.split("/");
   return segments.every(
     (segment) => !INVALID_CONFIG_PATH_SEGMENTS.has(segment)
@@ -9260,7 +9481,7 @@ var aliasesSchema = import_zod6.z.record(
         path: [key]
       });
     }
-    if (value.length > 0 && !formFields.isLiteralPath(value)) {
+    if (value.includes("*") || value.length > 0 && !formFields.isLiteralPath(value)) {
       context.addIssue({
         code: "custom",
         message: formFields.fixed(CONSTRAINT_INVALID_LITERAL_PATH),
@@ -10036,6 +10257,9 @@ var CONSTRAINT_INVALID_IMPLICIT_EXT = "configuration/invalid-implicit-extension"
 var FORBIDDEN_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".cjs",
   ".cts",
+  ".d.cts",
+  ".d.mts",
+  ".d.ts",
   ".js",
   ".jsx",
   ".mjs",
@@ -10528,6 +10752,36 @@ var validateConfigFormat = /* @__PURE__ */ (() => {
   };
 })();
 
+// src/_rules/conformity/_stores/session/_services/verify-project/_services/prepare-project/_utils/validate-config-references/_utils/validate-alias-references/validate-alias-references.util.ts
+function validateAliasReferences(config, context) {
+  const outcomes = [];
+  const entries = Object.entries(config.faf.common?.aliases ?? {});
+  for (const [key, basePath] of entries) {
+    const id = context.inventory.pathToId.get(basePath);
+    if (id === void 0) {
+      outcomes.push(
+        createOutcome("configuration/non-existent-path", {
+          detail: `Alias base "${basePath}" does not exist under configuration base "${context.baseDirectory}".`,
+          element: basePath,
+          propertyPath: `faf.common.aliases.${key}`
+        })
+      );
+      continue;
+    }
+    const item = context.inventory.items[id];
+    if (item === void 0 || item.kind !== "directory") {
+      outcomes.push(
+        createOutcome("configuration/expected-directory", {
+          detail: `Alias base "${basePath}" must be a directory.`,
+          element: basePath,
+          propertyPath: `faf.common.aliases.${key}`
+        })
+      );
+    }
+  }
+  return outcomes;
+}
+
 // src/_rules/conformity/_stores/session/_services/verify-project/_services/prepare-project/_utils/validate-config-references/_validate-config-references@shared/_utils/reject-directory-in-scope/_utils/reject-directory-scope/reject-directory-scope.util.ts
 function rejectDirectoryScope(check, item, _family) {
   if (item.treeOrigin === null) {
@@ -11561,7 +11815,8 @@ function validateConfigReferences(config, declarations, inventory) {
     ...validateRootReferences(config, context),
     ...validateForeignReferences(config, context),
     ...validateStructuralReferences(config, context),
-    ...validateFrontierReferences(config, context)
+    ...validateFrontierReferences(config, context),
+    ...validateAliasReferences(config, context)
   ]);
 }
 
@@ -11628,7 +11883,11 @@ function prepareProject(configPath) {
       declarations.outcomes
     );
   }
-  const origins = declarations.value.trees.map((tree) => tree.originPath);
+  const effectiveDeclarations = {
+    ...declarations.value,
+    aliases: aliases.value
+  };
+  const origins = effectiveDeclarations.trees.map((tree) => tree.originPath);
   const entries = listEntries(loaded.value.configDirectory, origins);
   if (!entries.ok) {
     return blocked(
@@ -11642,11 +11901,12 @@ function prepareProject(configPath) {
   const inventory = includeExternalTargets(
     built.inventory,
     formatted.value,
-    loaded.value.configDirectory
+    loaded.value.configDirectory,
+    origins
   );
   const references = validateConfigReferences(
     formatted.value,
-    declarations.value,
+    effectiveDeclarations,
     inventory
   );
   if (references.length > 0) {
@@ -11661,7 +11921,7 @@ function prepareProject(configPath) {
     aliases: aliases.value,
     baseDirectory: loaded.value.configDirectory,
     configPath: loaded.value.configPath,
-    declarations: declarations.value,
+    declarations: effectiveDeclarations,
     inventory,
     inventoryOutcomes: built.outcomes,
     kind: "ready",