@archpilotlabs/archpilot 0.2.2 → 0.2.3

package/dist/archpilot-cli.js

@@ -215175,9 +215175,9 @@ function pathHasFileExtension(value) {
 function isRelativeImport(importSpecifier) {
   return importSpecifier === "." || importSpecifier === ".." || importSpecifier.startsWith("./") || importSpecifier.startsWith("../");
 }
-function isPathInsideOrEqual(childPath, parentPath) {
-  const child = normalizePath2(childPath).toLowerCase();
-  const parent = normalizePath2(parentPath).toLowerCase();
+function isNormalizedPathInsideOrEqual(normalizedChildPath, normalizedParentPath) {
+  const child = normalizedChildPath.toLowerCase();
+  const parent = normalizedParentPath.toLowerCase();
   return child === parent || child.startsWith(`${parent}/`);
 }
 function toEndpoint(candidate) {
@@ -215196,38 +215196,43 @@ function compareCandidates(left, right) {
   }
   return left.component.id.localeCompare(right.component.id);
 }
-function modulePathMatchScore(inputPath, modulePath) {
-  const normalizedModulePath = normalizePath2(modulePath);
+function normalizedModulePathMatchScore(normalizedInputPath, normalizedModulePath) {
   if (pathHasFileExtension(normalizedModulePath)) {
-    return isPathInsideOrEqual(inputPath, normalizedModulePath) || isPathInsideOrEqual(normalizedModulePath, inputPath) ? normalizedModulePath.length + 1e3 : void 0;
+    return isNormalizedPathInsideOrEqual(normalizedInputPath, normalizedModulePath) || isNormalizedPathInsideOrEqual(normalizedModulePath, normalizedInputPath) ? normalizedModulePath.length + 1e3 : void 0;
   }
-  return isPathInsideOrEqual(inputPath, normalizedModulePath) ? normalizedModulePath.length + 1e3 : void 0;
+  return isNormalizedPathInsideOrEqual(normalizedInputPath, normalizedModulePath) ? normalizedModulePath.length + 1e3 : void 0;
+}
+function modulePathMatchScore(inputPath, modulePath) {
+  return normalizedModulePathMatchScore(normalizePath2(inputPath), normalizePath2(modulePath));
 }
 function findComponentForPath(components, inputPath) {
   const normalizedInputPath = normalizePath2(inputPath);
   const candidates = [];
   for (const component of components) {
-    for (const [moduleId, moduleReference] of Object.entries(component.modules)) {
-      if (!moduleReference.path) {
+    for (const moduleReference of component.modules) {
+      if (!moduleReference.normalizedPath) {
         continue;
       }
-      const score = modulePathMatchScore(normalizedInputPath, moduleReference.path);
+      const score = normalizedModulePathMatchScore(
+        normalizedInputPath,
+        moduleReference.normalizedPath
+      );
       if (score !== void 0) {
         candidates.push({
-          component,
-          moduleId,
+          component: component.component,
+          moduleId: moduleReference.moduleId,
           path: moduleReference.path,
           ownership: "module-path",
           score
         });
       }
     }
-    if (component.path && isPathInsideOrEqual(normalizedInputPath, component.path)) {
+    if (component.normalizedPath && isNormalizedPathInsideOrEqual(normalizedInputPath, component.normalizedPath)) {
       candidates.push({
-        component,
-        path: component.path,
+        component: component.component,
+        path: component.component.path,
         ownership: "component-path",
-        score: normalizePath2(component.path).length
+        score: component.normalizedPath.length
       });
     }
   }
@@ -215238,19 +215243,20 @@ function findComponentForModuleSpecifier(components, importSpecifier) {
   const normalizedSegments = normalizedImport.split("/").filter((segment) => segment.length > 0);
   const candidates = [];
   for (const component of components) {
-    for (const [moduleId, moduleReference] of Object.entries(component.modules)) {
+    for (const moduleReference of component.modules) {
+      const moduleId = moduleReference.moduleId;
       if (normalizedImport === moduleId || normalizedImport.startsWith(`${moduleId}/`)) {
         candidates.push({
-          component,
+          component: component.component,
           moduleId,
           ...moduleReference.path ? { path: moduleReference.path } : {},
           ownership: moduleReference.path ? "module-path" : "component-path",
           score: moduleId.length + 500
         });
       }
-      if (component.id === VIRTUAL_WORKSPACE_COMPONENT_ID && normalizedSegments.includes(moduleId)) {
+      if (component.component.id === VIRTUAL_WORKSPACE_COMPONENT_ID && normalizedSegments.includes(moduleId)) {
         candidates.push({
-          component,
+          component: component.component,
           moduleId,
           ...moduleReference.path ? { path: moduleReference.path } : {},
           ownership: "virtual-workspace",
@@ -215258,20 +215264,20 @@ function findComponentForModuleSpecifier(components, importSpecifier) {
         });
       }
     }
-    if (component.path && isPathInsideOrEqual(normalizedImport, component.path)) {
+    if (component.normalizedPath && isNormalizedPathInsideOrEqual(normalizedImport, component.normalizedPath)) {
       candidates.push({
-        component,
-        path: component.path,
+        component: component.component,
+        path: component.component.path,
         ownership: "component-path",
-        score: normalizePath2(component.path).length
+        score: component.normalizedPath.length
       });
     }
-    if (normalizedImport === component.id || normalizedImport.startsWith(`${component.id}/`)) {
+    if (normalizedImport === component.component.id || normalizedImport.startsWith(`${component.component.id}/`)) {
       candidates.push({
-        component,
-        ...component.path ? { path: component.path } : {},
-        ownership: component.path ? "component-path" : "virtual-workspace",
-        score: component.id.length
+        component: component.component,
+        ...component.component.path ? { path: component.component.path } : {},
+        ownership: component.component.path ? "component-path" : "virtual-workspace",
+        score: component.component.id.length
       });
     }
   }
@@ -215315,12 +215321,12 @@ function resolveSourceCandidate(contract, components, sourceFile) {
     return directMatch;
   }
   const virtualComponent = components.find(
-    (component) => component.id === VIRTUAL_WORKSPACE_COMPONENT_ID
-  );
+    (component) => component.component.id === VIRTUAL_WORKSPACE_COMPONENT_ID
+  )?.component;
   if (virtualComponent) {
     return resolveLegacyVirtualSource(contract, sourceFile, virtualComponent);
   }
-  const fallback = [...components].sort((left, right) => left.id.localeCompare(right.id))[0];
+  const fallback = [...components].map((component) => component.component).sort((left, right) => left.id.localeCompare(right.id))[0];
   if (fallback) {
     return {
       component: fallback,
@@ -215331,7 +215337,7 @@ function resolveSourceCandidate(contract, components, sourceFile) {
   }
   throw new Error("Architecture dependency context requires at least one normalized component.");
 }
-function resolveTargetCandidate(components, sourceFile, importSpecifier) {
+function resolveTargetCandidate(contract, components, sourceFile, importSpecifier) {
   if (isRelativeImport(importSpecifier)) {
     const resolvedTargetPath = resolveRelativeImportPath(sourceFile, importSpecifier);
     return {
@@ -215340,7 +215346,8 @@ function resolveTargetCandidate(components, sourceFile, importSpecifier) {
     };
   }
   const normalizedImport = normalizeImportPath(importSpecifier);
-  if (normalizedImport.startsWith("src/") || normalizedImport.startsWith("apps/") || normalizedImport.startsWith("services/") || normalizedImport.startsWith("packages/") || normalizedImport.startsWith("libs/") || normalizedImport.startsWith("libraries/") || normalizedImport.startsWith("workers/")) {
+  const normalizedModulesRoot = normalizePath2(resolveModulesRootFromContract(contract));
+  if (normalizedModulesRoot.length > 0 && normalizedImport.startsWith(`${normalizedModulesRoot}/`) || normalizedImport.startsWith("src/") || normalizedImport.startsWith("app/") || normalizedImport.startsWith("apps/") || normalizedImport.startsWith("services/") || normalizedImport.startsWith("packages/") || normalizedImport.startsWith("libs/") || normalizedImport.startsWith("libraries/") || normalizedImport.startsWith("workers/")) {
     return {
       candidate: findComponentForPath(components, normalizedImport),
       resolvedTargetPath: normalizedImport
@@ -215352,20 +215359,28 @@ function resolveTargetCandidate(components, sourceFile, importSpecifier) {
   }
   return {};
 }
-function resolveDependencyContext(contract, input2) {
-  const model = normalizeArchitectureWorkspaceModel(contract);
-  const sourceCandidate = resolveSourceCandidate(contract, model.components, input2.sourceFile);
+function prepareComponentReferences(components) {
+  return components.map((component) => ({
+    component,
+    ...component.path ? { normalizedPath: normalizePath2(component.path) } : {},
+    modules: Object.entries(component.modules).map(([moduleId, moduleReference]) => ({
+      moduleId,
+      ...moduleReference.path ? {
+        path: moduleReference.path,
+        normalizedPath: normalizePath2(moduleReference.path)
+      } : {}
+    }))
+  }));
+}
+function resolveDependencyContextWithPreparedComponents(contract, components, input2) {
+  const sourceCandidate = resolveSourceCandidate(contract, components, input2.sourceFile);
   const { candidate: resolvedTargetCandidate, resolvedTargetPath } = resolveTargetCandidate(
-    model.components,
+    contract,
+    components,
     input2.sourceFile,
     input2.importSpecifier
   );
-  const targetCandidate = resolvedTargetCandidate ?? (resolvedTargetPath ? {
-    ...sourceCandidate,
-    path: resolvedTargetPath,
-    ownership: sourceCandidate.ownership,
-    score: 0
-  } : void 0);
+  const targetCandidate = resolvedTargetCandidate ?? (resolvedTargetPath ? resolveSourceCandidate(contract, components, resolvedTargetPath) : void 0);
   if (!targetCandidate) {
     return {
       dependencyType: "external",
@@ -215386,6 +215401,19 @@ function resolveDependencyContext(contract, input2) {
     isExternal: false
   };
 }
+function createArchitectureDependencyContextResolver(contract) {
+  const model = normalizeArchitectureWorkspaceModel(contract);
+  const components = prepareComponentReferences(model.components);
+  return {
+    contract,
+    model,
+    resolve: (input2) => resolveDependencyContextWithPreparedComponents(
+      contract,
+      components,
+      input2
+    )
+  };
+}
 var path6;
 var init_architectureDependencyContext = __esm({
   "../core/src/architectureDependencyContext.ts"() {
@@ -215474,7 +215502,7 @@ function toSafeContractModuleFileStem(moduleName) {
 function normalizeAbsolutePath(filePath) {
   return normalizePath4(path7.resolve(filePath)).toLowerCase();
 }
-function isPathInsideOrEqual2(childPath, parentPath) {
+function isPathInsideOrEqual(childPath, parentPath) {
   const child = normalizeAbsolutePath(childPath);
   const parent = normalizeAbsolutePath(parentPath);
   return child === parent || child.startsWith(`${parent}/`);
@@ -215555,6 +215583,9 @@ function buildChildModulesByParent(hierarchyEdges) {
     ])
   );
 }
+function isIsolatedContractlessHierarchyModule(input2) {
+  return !input2.hasContract && input2.parentModule !== void 0 && input2.declaredDependencies.length === 0 && input2.actualDependencies.length === 0 && input2.inboundDeclaredFrom.length === 0 && input2.inboundActualFrom.length === 0 && input2.unusedDeclaredDependencies.length === 0 && input2.undeclaredActualDependencies.length === 0;
+}
 function getScriptKind(filePath) {
   const extension = path7.extname(filePath).toLowerCase();
   switch (extension) {
@@ -215712,7 +215743,7 @@ async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
       const isWildcard = /\/\*$/u.test(aliasPattern) && /\/\*$/u.test(targetPattern);
       const normalizedTarget = normalizePath4(targetPattern).replace(/\/\*$/u, "");
       const absoluteTarget = path7.join(workspaceRoot, ...normalizedTarget.split("/"));
-      const moduleEntry = [...moduleRoots.entries()].filter(([, moduleRoot2]) => isPathInsideOrEqual2(absoluteTarget, moduleRoot2)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
+      const moduleEntry = [...moduleRoots.entries()].filter(([, moduleRoot2]) => isPathInsideOrEqual(absoluteTarget, moduleRoot2)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
       if (!moduleEntry) {
         continue;
       }
@@ -215947,7 +215978,7 @@ async function collectSourceFiles(directoryPath, adapter, scanRootPath = directo
     const fullPath = path7.join(directoryPath, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirectoryRoots.some(
-        (excludedRoot) => isPathInsideOrEqual2(fullPath, excludedRoot)
+        (excludedRoot) => isPathInsideOrEqual(fullPath, excludedRoot)
       )) {
         continue;
       }
@@ -216172,7 +216203,7 @@ async function buildJavaImportIndex(workspaceRoot, moduleRoots, adapter) {
   for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
   )) {
-    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleId && isPathInsideOrEqual2(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
+    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleId && isPathInsideOrEqual(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
     const sourceFiles = await collectSourceFiles(moduleRoot, adapter, moduleRoot, childModuleRoots);
     for (const sourceFilePath of sourceFiles) {
       const relativePath = normalizePath4(path7.relative(workspaceRoot, sourceFilePath));
@@ -216780,7 +216811,7 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   if (!resolvedPath) {
     return void 0;
   }
-  const targetModuleEntry = packageAliasTargetModule && packageAliasTargetModuleRoot ? [packageAliasTargetModule, packageAliasTargetModuleRoot] : [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual2(resolvedPath, moduleRoot)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
+  const targetModuleEntry = packageAliasTargetModule && packageAliasTargetModuleRoot ? [packageAliasTargetModule, packageAliasTargetModuleRoot] : [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual(resolvedPath, moduleRoot)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
   if (!targetModuleEntry) {
     const standaloneTargetModule = explicitStandaloneModuleByPath.get(
       normalizePath4(path7.relative(workspaceRoot, resolvedPath))
@@ -216826,7 +216857,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
   for (const [moduleName, moduleRoot] of [...moduleRoots.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
   )) {
-    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual2(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
+    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
     const sourceFiles = await collectSourceFiles(
       moduleRoot,
       adapter,
@@ -216962,15 +216993,15 @@ function toDependencyContextMetadata(context) {
     isExternal: context.isExternal
   };
 }
-function resolveImportDependencyContextMetadata(architectureContract, dependencyImport) {
-  const directContext = resolveDependencyContext(architectureContract, {
+function resolveImportDependencyContextMetadata(architectureContract, dependencyImport, resolver = createArchitectureDependencyContextResolver(architectureContract)) {
+  const directContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.importSpecifier
   });
   if (!directContext.isExternal) {
     return toDependencyContextMetadata(directContext);
   }
-  const moduleTargetContext = resolveDependencyContext(architectureContract, {
+  const moduleTargetContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.targetModule
   });
@@ -216981,7 +217012,7 @@ function resolveImportDependencyContextMetadata(architectureContract, dependency
       resolvedTargetPath: dependencyImport.resolvedTargetRelativePath
     });
   }
-  const resolvedPathContext = resolveDependencyContext(architectureContract, {
+  const resolvedPathContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.resolvedTargetRelativePath
   });
@@ -217019,11 +217050,15 @@ function validateComponentDependencyPolicies(architectureContract, imports) {
   if (!architectureContract || policies.size === 0) {
     return [];
   }
+  const dependencyContextResolver = createArchitectureDependencyContextResolver(
+    architectureContract
+  );
   const findings = [];
   for (const dependencyImport of imports) {
     const dependencyMetadata = resolveImportDependencyContextMetadata(
       architectureContract,
-      dependencyImport
+      dependencyImport,
+      dependencyContextResolver
     );
     if (dependencyMetadata.dependencyType !== "cross-component" || dependencyMetadata.isExternal || !dependencyMetadata.sourceComponentId || !dependencyMetadata.targetComponentId) {
       continue;
@@ -217059,7 +217094,7 @@ function validateComponentDependencyPolicies(architectureContract, imports) {
   }
   return findings;
 }
-function isModuleScopedDependencyImport(architectureContract, dependencyImport) {
+function isModuleScopedDependencyImport(architectureContract, dependencyImport, resolver) {
   if (dependencyImport.sourceModule === dependencyImport.targetModule || isParentChildModuleRelationship(
     dependencyImport.sourceModule,
     dependencyImport.targetModule
@@ -217071,7 +217106,8 @@ function isModuleScopedDependencyImport(architectureContract, dependencyImport)
   }
   const dependencyMetadata = resolveImportDependencyContextMetadata(
     architectureContract,
-    dependencyImport
+    dependencyImport,
+    resolver
   );
   return !dependencyMetadata.isExternal;
 }
@@ -217421,34 +217457,42 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
   const inboundDeclared = buildInboundDependencyMap(declaredBySource, moduleIds);
   const inboundActual = buildInboundDependencyMap(actualBySource, moduleIds);
   const hierarchyEdges = buildModuleHierarchyEdges(moduleIds);
-  const childModulesByParent = buildChildModulesByParent(hierarchyEdges);
   const parentModuleByChild = new Map(
     hierarchyEdges.map((edge) => [edge.childModule, edge.parentModule])
   );
+  const moduleSummaries = moduleIds.map((moduleId) => {
+    const declaredDependencies = sortUnique2(declaredBySource.get(moduleId) ?? []);
+    const actualDependencies = sortUnique2(actualBySource.get(moduleId) ?? []);
+    const unusedDeclaredDependencies = declaredDependencies.filter(
+      (declaredDependency) => !actualDependencies.includes(declaredDependency)
+    );
+    const undeclaredActualDependencies = actualDependencies.filter(
+      (actualDependency) => !declaredDependencies.includes(actualDependency)
+    );
+    return {
+      module: moduleId,
+      hasContract: hasContractByModule.get(moduleId) ?? false,
+      ...parentModuleByChild.has(moduleId) ? { parentModule: parentModuleByChild.get(moduleId) } : {},
+      childModules: [],
+      declaredDependencies,
+      actualDependencies,
+      inboundDeclaredFrom: inboundDeclared.get(moduleId) ?? [],
+      inboundActualFrom: inboundActual.get(moduleId) ?? [],
+      unusedDeclaredDependencies,
+      undeclaredActualDependencies
+    };
+  }).filter((moduleSummary) => !isIsolatedContractlessHierarchyModule(moduleSummary));
+  const retainedModuleIds = new Set(moduleSummaries.map((moduleSummary) => moduleSummary.module));
+  const retainedHierarchyEdges = hierarchyEdges.filter(
+    (edge) => retainedModuleIds.has(edge.parentModule) && retainedModuleIds.has(edge.childModule)
+  );
+  const childModulesByParent = buildChildModulesByParent(retainedHierarchyEdges);
   return {
-    modules: moduleIds.map((moduleId) => {
-      const declaredDependencies = sortUnique2(declaredBySource.get(moduleId) ?? []);
-      const actualDependencies = sortUnique2(actualBySource.get(moduleId) ?? []);
-      const unusedDeclaredDependencies = declaredDependencies.filter(
-        (declaredDependency) => !actualDependencies.includes(declaredDependency)
-      );
-      const undeclaredActualDependencies = actualDependencies.filter(
-        (actualDependency) => !declaredDependencies.includes(actualDependency)
-      );
-      return {
-        module: moduleId,
-        hasContract: hasContractByModule.get(moduleId) ?? false,
-        ...parentModuleByChild.has(moduleId) ? { parentModule: parentModuleByChild.get(moduleId) } : {},
-        childModules: childModulesByParent.get(moduleId) ?? [],
-        declaredDependencies,
-        actualDependencies,
-        inboundDeclaredFrom: inboundDeclared.get(moduleId) ?? [],
-        inboundActualFrom: inboundActual.get(moduleId) ?? [],
-        unusedDeclaredDependencies,
-        undeclaredActualDependencies
-      };
-    }),
-    hierarchyEdges
+    modules: moduleSummaries.map((moduleSummary) => ({
+      ...moduleSummary,
+      childModules: childModulesByParent.get(moduleSummary.module) ?? []
+    })),
+    hierarchyEdges: retainedHierarchyEdges
   };
 }
 async function validateDependencyContractBoundaries(workspaceRoot, architectureContract, options) {
@@ -217478,9 +217522,16 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     workspacePackageAliases,
     adapter
   );
+  const dependencyContextResolver = createArchitectureDependencyContextResolver(
+    architectureContract
+  );
   const peerImports = filterPeerModuleImports(imports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      architectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
@@ -217490,7 +217541,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217622,7 +217674,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217881,9 +217934,14 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     workspacePackageAliases,
     adapter
   );
+  const dependencyContextResolver = parsedArchitectureContract ? createArchitectureDependencyContextResolver(parsedArchitectureContract) : void 0;
   const peerImports = filterPeerModuleImports(imports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(parsedArchitectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      parsedArchitectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
@@ -217942,7 +218000,8 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
-            dependencyImport
+            dependencyImport,
+            dependencyContextResolver
           );
           if (dependencyMetadata.isExternal) {
             return false;
@@ -217966,7 +218025,11 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         });
       } else {
         for (const violation of violations) {
-          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation) : void 0;
+          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(
+            parsedArchitectureContract,
+            violation,
+            dependencyContextResolver
+          ) : void 0;
           const allowedDependencies = dependencyRules.modules[violation.sourceModule]?.allowedDependencies ?? [];
           const allowedDescription = allowedDependencies.length === 0 ? "may not depend on any other modules" : `may only depend on: ${allowedDependencies.join(", ")}`;
           findings.push({
@@ -218008,7 +218071,8 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
-            dependencyImport
+            dependencyImport,
+            dependencyContextResolver
           );
           if (dependencyMetadata.isExternal) {
             continue;
@@ -218057,7 +218121,11 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         });
       } else {
         for (const violation of violations) {
-          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation) : void 0;
+          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(
+            parsedArchitectureContract,
+            violation,
+            dependencyContextResolver
+          ) : void 0;
           const publicImportGuidance = await describeModulePublicImportGuidance(
             workspaceRoot,
             violation.targetModule,
@@ -221079,7 +221147,7 @@ async function generateMissingModuleContracts(workspaceRoot) {
       });
       createdContracts.push(contractPath);
     }
-    if (isRegistryEntryDifferent({
+    if (moduleEntry.discoverySource === "architecture.json" && isRegistryEntryDifferent({
       contract,
       moduleName: moduleEntry.moduleName,
       sourcePath,
@@ -226727,17 +226795,40 @@ function getModulePathForName(contract, moduleName) {
   const reference = contract.modules?.[moduleName];
   return normalizePath11(reference?.path ?? `${modulesRoot}/${moduleName}`);
 }
-function getPathSegmentsInsideModule(relativePath, modulePath) {
+function getComponentEntries2(contract) {
+  const components = contract.components;
+  if (!components) {
+    return [];
+  }
+  return Array.isArray(components) ? components.map((component, index) => [
+    typeof component.id === "string" && component.id.trim().length > 0 ? component.id.trim() : `component-${index}`,
+    component
+  ]) : Object.entries(components);
+}
+function getComponentPathForFile(contract, relativePath) {
   const normalized = normalizePath11(relativePath).toLowerCase();
-  if (!modulePath) {
+  const candidates = getComponentEntries2(contract).map(([, component]) => component.path).filter(
+    (componentPath) => typeof componentPath === "string" && componentPath.trim().length > 0
+  ).map((componentPath) => normalizePath11(componentPath)).filter((componentPath) => {
+    const normalizedComponentPath = componentPath.toLowerCase();
+    return normalized === normalizedComponentPath || normalized.startsWith(`${normalizedComponentPath}/`);
+  }).sort((left, right) => right.length - left.length || left.localeCompare(right));
+  return candidates[0];
+}
+function getOwnershipPathForFile(contract, relativePath, moduleName) {
+  return getModulePathForName(contract, moduleName) ?? getComponentPathForFile(contract, relativePath);
+}
+function getPathSegmentsInsideModule(relativePath, ownershipPath) {
+  const normalized = normalizePath11(relativePath).toLowerCase();
+  if (!ownershipPath) {
     return normalized.split("/");
   }
-  const normalizedModulePath = normalizePath11(modulePath).toLowerCase();
-  if (normalized === normalizedModulePath) {
+  const normalizedOwnershipPath = normalizePath11(ownershipPath).toLowerCase();
+  if (normalized === normalizedOwnershipPath) {
     return [];
   }
-  if (normalized.startsWith(`${normalizedModulePath}/`)) {
-    return normalized.slice(normalizedModulePath.length + 1).split("/");
+  if (normalized.startsWith(`${normalizedOwnershipPath}/`)) {
+    return normalized.slice(normalizedOwnershipPath.length + 1).split("/");
   }
   return normalized.split("/");
 }
@@ -226873,7 +226964,10 @@ function createFinding(input2) {
 function hasRepositoryLayer(files, contract) {
   return files.some((file) => {
     const moduleName = inferModuleForPath2(contract, file.relativePath);
-    return classifySourceFile(file, getModulePathForName(contract, moduleName)).isRepository;
+    return classifySourceFile(
+      file,
+      getOwnershipPathForFile(contract, file.relativePath, moduleName)
+    ).isRepository;
   });
 }
 function hasServiceLayer(files) {
@@ -227195,7 +227289,7 @@ async function detectApplicationLayeringFindings(input2) {
     const moduleName = inferModuleForPath2(input2.contract, file.relativePath);
     const classification = classifySourceFile(
       file,
-      getModulePathForName(input2.contract, moduleName),
+      getOwnershipPathForFile(input2.contract, file.relativePath, moduleName),
       input2.astCache
     );
     const candidates = [
@@ -245446,7 +245540,15 @@ function readMavenMetadata(workspaceRoot, componentPath) {
     artifactId: readFirstXmlTag(normalizedPom, "artifactId"),
     name: readFirstXmlTag(normalizedPom, "name"),
     hasPom: true,
+    hasModules: /<modules\b/iu.test(normalizedPom),
     hasDependencyManagement: /<dependencyManagement\b/iu.test(normalizedPom),
+    hasSpringBootPlugin: /\bspring-boot-maven-plugin\b/iu.test(normalizedPom),
+    hasSpringBootRepackageGoal: /<goal>\s*repackage\s*<\/goal>/iu.test(normalizedPom),
+    configuredMainClass: readFirstXmlTag(normalizedPom, "mainClass") ?? readFirstXmlTag(normalizedPom, "start-class"),
+    hasSpringBootStarterDependency: dependencyBlocks.some((block) => /<artifactId>\s*spring-boot-starter(?:-[^<]+)?\s*<\/artifactId>/iu.test(block)),
+    hasSpringBootAutoconfigureDependency: dependencyBlocks.some((block) => /<artifactId>\s*spring-boot-autoconfigure\s*<\/artifactId>/iu.test(block)),
+    hasSpringBootAutoconfigureProcessor: /spring-boot-autoconfigure-processor|spring-boot-configuration-processor/iu.test(normalizedPom),
+    hasDocumentationTooling: /asciidoctor-maven-plugin|maven-site-plugin|doxia|antora|javadoc|<goal>\s*site\s*<\/goal>/iu.test(normalizedPom),
     testScopedDependencyCount: dependencyBlocks.filter((block) => /<scope>\s*test\s*<\/scope>/iu.test(block)).length,
     totalDependencyCount: dependencyBlocks.length,
     hasMavenPluginConfiguration: packaging === "maven-plugin" || /maven-plugin-plugin|<goalPrefix>|<mojo/iu.test(normalizedPom),
@@ -245563,6 +245665,291 @@ function hasRunnableFrontendComponentEvidence(workspaceRoot, componentPath) {
 function isUnderJvmResourceRoot4(componentPath) {
   return /(^|\/)src\/main\/resources(?:\/|$)/u.test(normalizePath25(componentPath).toLowerCase());
 }
+function hasFileUnderRoot(root, pattern) {
+  if (!pathExists19(root)) {
+    return false;
+  }
+  const entries = fs58.readdirSync(root, { recursive: true, withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && pattern.test(entry.name));
+}
+var javaMainMethodPattern = /\bpublic\s+static\s+void\s+main\s*\(\s*String\s*(?:(?:\[\s*\]\s*)|\.\.\.\s*)[A-Za-z_$][\w$]*\s*(?:\[\s*\])?\s*\)/u;
+function stripJavaLikeCommentsAndStrings(value) {
+  let result = "";
+  let index = 0;
+  let state = "code";
+  while (index < value.length) {
+    const current = value[index] ?? "";
+    const next = value[index + 1] ?? "";
+    const nextTwo = value.slice(index, index + 3);
+    if (state === "code") {
+      if (current === "/" && next === "/") {
+        result += "  ";
+        index += 2;
+        state = "line-comment";
+        continue;
+      }
+      if (current === "/" && next === "*") {
+        result += "  ";
+        index += 2;
+        state = "block-comment";
+        continue;
+      }
+      if (nextTwo === '"""') {
+        result += "   ";
+        index += 3;
+        state = "text-block";
+        continue;
+      }
+      if (current === '"') {
+        result += " ";
+        index += 1;
+        state = "string";
+        continue;
+      }
+      if (current === "'") {
+        result += " ";
+        index += 1;
+        state = "char";
+        continue;
+      }
+      result += current;
+      index += 1;
+      continue;
+    }
+    if (state === "line-comment") {
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      if (current === "\n") {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "block-comment") {
+      if (current === "*" && next === "/") {
+        result += "  ";
+        index += 2;
+        state = "code";
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      continue;
+    }
+    if (state === "text-block") {
+      if (nextTwo === '"""') {
+        result += "   ";
+        index += 3;
+        state = "code";
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      continue;
+    }
+    if (state === "string") {
+      if (current === "\\") {
+        result += " ";
+        index += next ? 2 : 1;
+        if (next) {
+          result += " ";
+        }
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      if (current === '"') {
+        state = "code";
+      }
+      continue;
+    }
+    if (current === "\\") {
+      result += " ";
+      index += next ? 2 : 1;
+      if (next) {
+        result += " ";
+      }
+      continue;
+    }
+    result += current === "\n" || current === "\r" ? current : " ";
+    index += 1;
+    if (current === "'") {
+      state = "code";
+    }
+  }
+  return result;
+}
+function readMavenProductionSourceFiles(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  const mainRoots = [
+    path64.join(absoluteRoot, "src", "main", "java"),
+    path64.join(absoluteRoot, "src", "main", "kotlin"),
+    path64.join(absoluteRoot, "src", "main", "scala")
+  ];
+  const files = [];
+  for (const sourceRoot of mainRoots) {
+    if (!pathExists19(sourceRoot)) {
+      continue;
+    }
+    const entries = fs58.readdirSync(sourceRoot, { recursive: true, withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !/\.(?:java|kt|scala)$/iu.test(entry.name)) {
+        continue;
+      }
+      const contents = readTextFileSafe(path64.join(entry.parentPath, entry.name));
+      if (contents) {
+        files.push({ fileName: entry.name, contents });
+      }
+    }
+  }
+  return files;
+}
+function findMatchingBrace6(value, openBraceIndex) {
+  let depth = 0;
+  for (let index = openBraceIndex; index < value.length; index += 1) {
+    const current = value[index];
+    if (current === "{") {
+      depth += 1;
+    } else if (current === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function getDeclaredPackageName(value) {
+  return value.match(/\bpackage\s+([a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*)\s*;/u)?.[1];
+}
+function classNameMatchesConfiguredMainClass(className, packageName, configuredMainClass) {
+  const normalized = configuredMainClass.trim();
+  if (normalized.length === 0) {
+    return false;
+  }
+  return normalized === className || (packageName ? normalized === `${packageName}.${className}` : false);
+}
+function normalizeAnnotationName(value) {
+  return value.slice(value.lastIndexOf(".") + 1);
+}
+function hasAnnotation(annotations, annotationNames) {
+  return annotations.some((annotation) => annotationNames.has(normalizeAnnotationName(annotation)));
+}
+function extractAnnotations(annotationBlock) {
+  return [...annotationBlock.matchAll(/@\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/gu)].map((match) => match[1]).filter((annotation) => Boolean(annotation));
+}
+function extractConcreteClassDeclarations(contents) {
+  const sanitized = stripJavaLikeCommentsAndStrings(contents);
+  const packageName = getDeclaredPackageName(sanitized);
+  const classPattern = /((?:@\s*[\w.]+(?:\s*\([^)]*\))?\s*)*)(?:public\s+|protected\s+|private\s+|abstract\s+|final\s+|sealed\s+|non-sealed\s+|static\s+)*class\s+([A-Za-z_$][\w$]*)[^{]*\{/gu;
+  const declarations = [];
+  for (const match of sanitized.matchAll(classPattern)) {
+    const annotationBlock = match[1] ?? "";
+    const className = match[2] ?? "";
+    const openBraceIndex = (match.index ?? 0) + match[0].length - 1;
+    const closeBraceIndex = findMatchingBrace6(sanitized, openBraceIndex);
+    if (closeBraceIndex < 0) {
+      continue;
+    }
+    declarations.push({
+      className,
+      ...packageName ? { packageName } : {},
+      annotations: extractAnnotations(annotationBlock),
+      body: sanitized.slice(openBraceIndex + 1, closeBraceIndex)
+    });
+  }
+  return declarations;
+}
+function extractApplicationAnnotationNames(sourceFiles) {
+  const applicationAnnotations = /* @__PURE__ */ new Set(["SpringBootApplication"]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const sourceFile of sourceFiles) {
+      const sanitized = stripJavaLikeCommentsAndStrings(sourceFile.contents);
+      const annotationPattern = /((?:@\s*[\w.]+(?:\s*\([^)]*\))?\s*)*)public\s+@interface\s+([A-Za-z_$][\w$]*)\b/gu;
+      for (const match of sanitized.matchAll(annotationPattern)) {
+        const annotations = extractAnnotations(match[1] ?? "");
+        const annotationName = match[2];
+        if (annotationName && !applicationAnnotations.has(annotationName) && hasAnnotation(annotations, applicationAnnotations)) {
+          applicationAnnotations.add(annotationName);
+          changed = true;
+        }
+      }
+    }
+  }
+  return applicationAnnotations;
+}
+function hasSpringApplicationRunForClass(body, className) {
+  return new RegExp(`\\bSpringApplication\\.run\\s*\\(\\s*${className}\\.class\\b`, "u").test(body);
+}
+function hasIndirectSpringApplicationRunForClass(body, className) {
+  const helperCalls = [...body.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(\s*([A-Za-z_$][\w$]*)\.class\s*,/gu)].filter((match) => match[2] === className).map((match) => match[1]).filter((methodName) => Boolean(methodName));
+  return helperCalls.some(
+    (methodName) => new RegExp(`\\b${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\bSpringApplication\\.run\\s*\\(`, "u").test(body)
+  );
+}
+function hasConcreteSpringBootApplicationBootstrap(sourceFiles) {
+  const applicationAnnotations = extractApplicationAnnotationNames(sourceFiles);
+  const declarations = sourceFiles.flatMap((sourceFile) => extractConcreteClassDeclarations(sourceFile.contents));
+  const applicationClassNames = new Set(
+    declarations.filter((declaration) => hasAnnotation(declaration.annotations, applicationAnnotations)).map((declaration) => declaration.className)
+  );
+  if (applicationClassNames.size === 0) {
+    return false;
+  }
+  const hasLauncherForApplicationClass = (declaration) => javaMainMethodPattern.test(declaration.body) && [...applicationClassNames].some(
+    (applicationClassName) => hasSpringApplicationRunForClass(declaration.body, applicationClassName) || applicationClassName === declaration.className && hasIndirectSpringApplicationRunForClass(declaration.body, applicationClassName)
+  );
+  if (declarations.some(hasLauncherForApplicationClass)) {
+    return true;
+  }
+  for (const sourceFile of sourceFiles) {
+    for (const declaration of extractConcreteClassDeclarations(sourceFile.contents)) {
+      if (!hasAnnotation(declaration.annotations, applicationAnnotations)) {
+        continue;
+      }
+      if (javaMainMethodPattern.test(declaration.body) && (hasSpringApplicationRunForClass(declaration.body, declaration.className) || hasIndirectSpringApplicationRunForClass(declaration.body, declaration.className))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasConfiguredMainClassEntrypoint(contents, configuredMainClass) {
+  for (const declaration of extractConcreteClassDeclarations(contents)) {
+    if (!classNameMatchesConfiguredMainClass(declaration.className, declaration.packageName, configuredMainClass)) {
+      continue;
+    }
+    if (javaMainMethodPattern.test(declaration.body)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasMavenMainEntrypoint(workspaceRoot, componentPath) {
+  return hasConcreteSpringBootApplicationBootstrap(readMavenProductionSourceFiles(workspaceRoot, componentPath));
+}
+function hasMavenConfiguredMainClassEntrypoint(workspaceRoot, componentPath, configuredMainClass) {
+  if (!configuredMainClass) {
+    return false;
+  }
+  return readMavenProductionSourceFiles(workspaceRoot, componentPath).some((sourceFile) => hasConfiguredMainClassEntrypoint(sourceFile.contents, configuredMainClass));
+}
+function hasMavenAutoConfigurationMetadata(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  return [
+    path64.join(absoluteRoot, "src", "main", "resources", "META-INF", "spring.factories"),
+    path64.join(absoluteRoot, "src", "main", "resources", "META-INF", "spring", "org.springframework.boot.autoconfigure.AutoConfiguration.imports")
+  ].some(pathExists19);
+}
+function hasMavenMainJvmSource(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  return [
+    path64.join(absoluteRoot, "src", "main", "java"),
+    path64.join(absoluteRoot, "src", "main", "kotlin"),
+    path64.join(absoluteRoot, "src", "main", "scala")
+  ].some((root) => hasFileUnderRoot(root, /\.(?:java|kt|scala)$/iu));
+}
 function hasRuntimeSourceFiles(workspaceRoot, componentPath) {
   if (isUnderJvmResourceRoot4(componentPath)) {
     return false;
@@ -245588,11 +245975,24 @@ function hasRuntimeSourceFiles(workspaceRoot, componentPath) {
 function resolveKind(workspaceRoot, candidate, localProjectKinds) {
   const lowerPath = candidate.path.toLowerCase();
   const packageJson = readPackageJson(workspaceRoot, candidate.path);
+  const maven = readMavenMetadata(workspaceRoot, candidate.path);
   const hasRunnableFrontendEvidence = hasRunnableFrontendComponentEvidence(workspaceRoot, candidate.path);
   const hasPublishSurface = hasPackagePublishSurface(packageJson);
+  const hasMavenRunnableEvidence = Boolean(
+    maven && (hasMavenMainEntrypoint(workspaceRoot, candidate.path) || hasMavenConfiguredMainClassEntrypoint(workspaceRoot, candidate.path, maven.configuredMainClass) || maven.hasSpringBootPlugin && maven.hasSpringBootRepackageGoal && hasMavenMainEntrypoint(workspaceRoot, candidate.path) || maven.packaging === "war" && hasMavenMainEntrypoint(workspaceRoot, candidate.path))
+  );
+  const hasMavenLibraryEvidence = Boolean(
+    maven && !hasMavenRunnableEvidence && (maven.packaging === "jar" || maven.packaging === "maven-plugin" || maven.packaging === "pom") && (hasMavenMainJvmSource(workspaceRoot, candidate.path) || maven.hasMainResources || maven.hasDependencyManagement || maven.hasSpringBootAutoconfigureDependency || maven.hasSpringBootAutoconfigureProcessor || hasMavenAutoConfigurationMetadata(workspaceRoot, candidate.path) || maven.hasDocumentationTooling || maven.hasTestJava || maven.hasTestResources)
+  );
   if (lowerPath.endsWith("/db") || lowerPath.endsWith("/database") || lowerPath.endsWith("/data")) {
     return "data";
   }
+  if (hasMavenLibraryEvidence) {
+    return "library";
+  }
+  if (maven && !hasMavenRunnableEvidence && localProjectKinds.primaryKind === "backend") {
+    return "library";
+  }
   const classification = candidate.architectureRoot?.classification;
   if (classification === "frontend_app") {
     return hasPublishSurface && !hasRunnableFrontendEvidence ? "library" : "frontend";
@@ -245687,6 +246087,11 @@ function classifyGovernanceRole(input2) {
   const mavenMetadataText = `${maven?.artifactId ?? ""} ${maven?.name ?? ""}`.toLowerCase();
   const hasMavenMainSource = Boolean(maven?.hasMainJava || maven?.hasMainResources);
   const hasMavenTestSource = Boolean(maven?.hasTestJava || maven?.hasTestResources);
+  const hasMavenMainEntrypointEvidence = Boolean(maven && hasMavenMainEntrypoint(input2.workspaceRoot, input2.candidate.path));
+  const hasMavenMainJvmSourceEvidence = Boolean(maven && hasMavenMainJvmSource(input2.workspaceRoot, input2.candidate.path));
+  const hasMavenAutoConfigurationEvidence = Boolean(maven && (hasMavenAutoConfigurationMetadata(input2.workspaceRoot, input2.candidate.path) || maven.hasSpringBootAutoconfigureDependency || maven.hasSpringBootAutoconfigureProcessor));
+  const hasMavenExecutableConfiguration = Boolean(maven && (hasMavenConfiguredMainClassEntrypoint(input2.workspaceRoot, input2.candidate.path, maven.configuredMainClass) || maven.hasSpringBootPlugin && maven.hasSpringBootRepackageGoal && hasMavenMainEntrypointEvidence || maven.packaging === "war" && hasMavenMainEntrypointEvidence));
+  const hasMavenRunnableApplicationEvidence = Boolean(hasMavenMainEntrypointEvidence || hasMavenExecutableConfiguration);
   const isMavenPomOnly = Boolean(maven?.packaging === "pom" && !hasMavenMainSource && !hasMavenTestSource);
   const hasMavenTestContext = hasAnyToken(pathText, [
     /(^|\/)(test-framework|testsuite|integration-tests?|test-apps)(\/|$)/u
@@ -245725,17 +246130,19 @@ function classifyGovernanceRole(input2) {
   if (maven?.hasPom) {
     addEvidence6(evidence, `Maven packaging ${maven.packaging ?? "jar"}`);
   }
-  if (maven && (maven.packaging === "jar" || maven.packaging === "war") && hasMavenMainSource) {
+  if (maven && (maven.packaging === "jar" || maven.packaging === "war") && hasMavenRunnableApplicationEvidence) {
     runtimeScore += 3;
-    addEvidence6(evidence, "Maven runtime source layout");
+    addEvidence6(evidence, "Maven executable application evidence");
   }
-  if (maven?.packaging === "war" && hasMavenMainSource) {
+  if (maven?.packaging === "war" && hasMavenMainJvmSourceEvidence) {
     runtimeScore += 1;
     addEvidence6(evidence, "Maven deployable WAR artifact");
   }
-  if (maven && hasMavenMainSource && !hasMavenTestContext && !hasMavenBomEvidence && maven.packaging !== "maven-plugin") {
-    runtimeScore += 1;
-    addEvidence6(evidence, "Maven main source/resource surface");
+  if (maven && hasMavenMainSource && !hasMavenRunnableApplicationEvidence && !hasMavenTestContext && !hasMavenBomEvidence && maven.packaging !== "maven-plugin") {
+    addEvidence6(evidence, "Maven library main source/resource surface");
+  }
+  if (hasMavenAutoConfigurationEvidence && !hasMavenRunnableApplicationEvidence) {
+    addEvidence6(evidence, "Maven Spring Boot auto-configuration/starter library evidence");
   }
   if (hasAnyToken(descriptiveManifestText, [/\b(e2e|end-to-end|testing|test helper|test utilities|fixtures?)\b/u])) {
     supportScore += 3;
@@ -245776,6 +246183,10 @@ function classifyGovernanceRole(input2) {
     supportScore += 5;
     addEvidence6(evidence, "Maven plugin/build-tooling module");
   }
+  if (maven?.hasDocumentationTooling && !hasMavenMainJvmSourceEvidence) {
+    supportScore += 4;
+    addEvidence6(evidence, "Maven documentation tooling without JVM runtime source");
+  }
   if (hasMavenBomEvidence) {
     supportScore += 5;
     addEvidence6(evidence, "Maven BOM/dependency-management module without runtime source");
@@ -246168,7 +246579,7 @@ function isCliSupportCandidate(component, allComponents) {
 }
 function hasIndependentRuntimeEvidence(component) {
   const text = componentEvidenceText(component);
-  return component.governanceRole === "runtime" && (/Maven runtime source layout/iu.test(text) || /Maven main source\/resource surface/iu.test(text) || /Published package surface signal/iu.test(text) && !/Path contains support\/tooling role tokens/iu.test(text));
+  return component.governanceRole === "runtime" && (/Maven executable application evidence/iu.test(text) || /Maven deployable WAR artifact/iu.test(text) || /Published package surface signal/iu.test(text) && !/Path contains support\/tooling role tokens/iu.test(text));
 }
 function hasSupportRoleEvidence(component) {
   const text = componentEvidenceText(component);