@archpilotlabs/archpilot 0.2.2 → 0.2.4

package/dist/archpilot-cli.js

@@ -13660,11 +13660,11 @@ ${lanes.join("\n")}
           return toComponents;
         }
         const components = toComponents.slice(start);
-        const relative17 = [];
+        const relative18 = [];
         for (; start < fromComponents.length; start++) {
-          relative17.push("..");
+          relative18.push("..");
         }
-        return ["", ...relative17, ...components];
+        return ["", ...relative18, ...components];
       }
       function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
         Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
@@ -52233,11 +52233,11 @@ ${lanes.join("\n")}
             if (i < rootLength) {
               return void 0;
             }
-            const sep = directory.lastIndexOf(directorySeparator, i - 1);
-            if (sep === -1) {
+            const sep2 = directory.lastIndexOf(directorySeparator, i - 1);
+            if (sep2 === -1) {
               return void 0;
             }
-            return directory.substr(0, Math.max(sep, rootLength));
+            return directory.substr(0, Math.max(sep2, rootLength));
           }
         }
       }
@@ -58143,9 +58143,9 @@ ${lanes.join("\n")}
               if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
                 return;
               }
-              const relative17 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+              const relative18 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
               for (const symlinkDirectory of symlinkDirectories) {
-                const option = resolvePath(symlinkDirectory, relative17);
+                const option = resolvePath(symlinkDirectory, relative18);
                 const result2 = cb(option, target === referenceRedirect);
                 shouldFilterIgnoredPaths = true;
                 if (result2) return result2;
@@ -127982,7 +127982,7 @@ ${lanes.join("\n")}
           }
         }
         function createImportCallExpressionAMD(arg, containsLexicalThis) {
-          const resolve9 = factory2.createUniqueName("resolve");
+          const resolve10 = factory2.createUniqueName("resolve");
           const reject = factory2.createUniqueName("reject");
           const parameters = [
             factory2.createParameterDeclaration(
@@ -127991,7 +127991,7 @@ ${lanes.join("\n")}
               /*dotDotDotToken*/
               void 0,
               /*name*/
-              resolve9
+              resolve10
             ),
             factory2.createParameterDeclaration(
               /*modifiers*/
@@ -128008,7 +128008,7 @@ ${lanes.join("\n")}
                 factory2.createIdentifier("require"),
                 /*typeArguments*/
                 void 0,
-                [factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve9, reject]
+                [factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve10, reject]
               )
             )
           ]);
@@ -214726,8 +214726,8 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
         installPackage(options) {
           this.packageInstallId++;
           const request3 = { kind: "installPackage", ...options, id: this.packageInstallId };
-          const promise = new Promise((resolve9, reject) => {
-            (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve: resolve9, reject });
+          const promise = new Promise((resolve10, reject) => {
+            (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve: resolve10, reject });
           });
           this.installer.send(request3);
           return promise;
@@ -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"() {
@@ -215416,6 +215444,8 @@ function classifyValidationSourceScope(relativePath) {
   const isFixture = hasPathSegment(normalized, /^(?:fixtures?|__fixtures__)$/u);
   const isTestPlugin = hasPathSegment(normalized, /^(?:test-plugins?|testing-plugins?)$/u);
   const isExamplePlugin = hasPathSegment(normalized, /^example-plugins?$/u) || hasTopLevelPathSegment(normalized, /^examples?$/u);
+  const isMavenIntegrationTestModule = hasTopLevelPathSegment(normalized, /^[a-z0-9_.-]+-integration-tests?$/u) || hasTopLevelPathSegment(normalized, /^[a-z0-9_.-]+-it$/u);
+  const isMavenExampleModule = hasTopLevelPathSegment(normalized, /^[a-z0-9_.-]+-examples?$/u);
   const isGenerated = hasPathSegment(normalized, /^(?:generated|__generated__|gen|templates?)$/u) || /\.(?:generated|gen|g)\.(?:ts|tsx|js|jsx|java|cs|py|php|go)$/u.test(fileName) || /\.d\.ts$/u.test(fileName);
   const isMigration = hasPathSegment(normalized, /^(?:migrations?|schema-migrations?|data-migrations|migration-utils?)$/u);
   const isCliTooling = hasPathSegment(normalized, /^(?:cli|bin|scripts?|tools?|scaffold|scaffolding|generators?)$/u) || /(?:^|[./_-])(?:cli|script|tool|generator|scaffold)(?:[./_-]|$)/u.test(fileName);
@@ -215426,11 +215456,11 @@ function classifyValidationSourceScope(relativePath) {
     category = "generated";
   } else if (isE2e) {
     category = "e2e";
-  } else if (isTestFile || hasPathSegment(normalized, /^(?:test|tests|__tests__|spec|specs|__mocks__|cypress|cypress-tests)$/u)) {
+  } else if (isTestFile || isMavenIntegrationTestModule || hasPathSegment(normalized, /^(?:test|tests|__tests__|spec|specs|__mocks__|cypress|cypress-tests)$/u)) {
     category = "test";
   } else if (isTestPlugin) {
     category = "test-plugin";
-  } else if (isExamplePlugin) {
+  } else if (isExamplePlugin || isMavenExampleModule) {
     category = "example-plugin";
   } else if (isFixture) {
     category = "fixture";
@@ -215474,7 +215504,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 +215585,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 +215745,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;
       }
@@ -215939,6 +215972,41 @@ async function buildExplicitStandaloneModulePathMap(workspaceRoot, architectureC
 function isTestSourcePath(relativePath) {
   return classifyValidationSourceScope(relativePath).isTestLike;
 }
+function hasStandardTestSourceRoot(relativePath) {
+  const normalized = normalizePath4(relativePath);
+  return /(?:^|\/)src\/(?:test|it|integration-test|integration-tests)\//u.test(normalized) || /(?:^|\/)(?:test|tests|__tests__|spec|specs|e2e|cypress)\//u.test(normalized) || /\.(?:spec|test|e2e-spec|integration-test)\.(?:ts|tsx|js|jsx|mjs|cjs|java|cs|py|php|go)$/u.test(
+    normalized.split("/").at(-1) ?? normalized
+  );
+}
+function shouldSkipDependencySource(relativePath, moduleRoot, workspaceRoot, includeTestFiles, includeConfiguredNonProductionModuleSources) {
+  if (includeTestFiles) {
+    return false;
+  }
+  const moduleRootRelativePath = normalizePath4(path7.relative(workspaceRoot, moduleRoot));
+  const moduleRootScope = classifyValidationSourceScope(moduleRootRelativePath);
+  if (hasStandardTestSourceRoot(relativePath)) {
+    return !includeConfiguredNonProductionModuleSources || moduleRootScope.isProduction || moduleRootScope.isTestLike;
+  }
+  if (!isTestSourcePath(relativePath)) {
+    return false;
+  }
+  return !includeConfiguredNonProductionModuleSources || !moduleRootScope.isTestLike;
+}
+function filterImportsForBoundaryChecks(imports, moduleRoots, workspaceRoot) {
+  return imports.filter((dependencyImport) => {
+    const moduleRoot = moduleRoots.get(dependencyImport.sourceModule);
+    if (!moduleRoot) {
+      return true;
+    }
+    return !shouldSkipDependencySource(
+      dependencyImport.sourceFileRelativePath,
+      moduleRoot,
+      workspaceRoot,
+      false,
+      false
+    );
+  });
+}
 async function collectSourceFiles(directoryPath, adapter, scanRootPath = directoryPath, excludedDirectoryRoots = []) {
   const entries = await import_node_fs6.promises.readdir(directoryPath, { withFileTypes: true });
   entries.sort((left, right) => left.name.localeCompare(right.name));
@@ -215947,7 +216015,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;
       }
@@ -216166,17 +216234,23 @@ function extractJavaPackageName(sourceText) {
   const match = /^\s*package\s+([a-zA-Z_][\w.]*)\s*;/mu.exec(sourceText);
   return match?.[1];
 }
-async function buildJavaImportIndex(workspaceRoot, moduleRoots, adapter) {
+async function buildJavaImportIndex(workspaceRoot, moduleRoots, adapter, options) {
   const classes = /* @__PURE__ */ new Map();
   const packageCandidates = /* @__PURE__ */ new Map();
   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));
-      if (isTestSourcePath(relativePath)) {
+      if (shouldSkipDependencySource(
+        relativePath,
+        moduleRoot,
+        workspaceRoot,
+        false,
+        options?.includeConfiguredNonProductionModuleSources === true
+      )) {
         continue;
       }
       const sourceText = await readTextFileIfExists2(sourceFilePath);
@@ -216780,7 +216854,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))
@@ -216819,14 +216893,17 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
 async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter, options) {
   const imports = [];
   const includeTestFiles = options?.includeTestFiles === true;
+  const includeConfiguredNonProductionModuleSources = options?.includeConfiguredNonProductionModuleSources === true;
   if (!supportsDependencyImportParsing(adapter)) {
     return imports;
   }
-  const javaImportIndex = usesJavaImportParser(adapter) ? await buildJavaImportIndex(workspaceRoot, moduleRoots, adapter) : void 0;
+  const javaImportIndex = usesJavaImportParser(adapter) ? await buildJavaImportIndex(workspaceRoot, moduleRoots, adapter, {
+    includeConfiguredNonProductionModuleSources
+  }) : void 0;
   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,
@@ -216837,7 +216914,13 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
       const sourceFileRelativePath = normalizePath4(
         path7.relative(workspaceRoot, sourceFilePath)
       );
-      if (!includeTestFiles && isTestSourcePath(sourceFileRelativePath)) {
+      if (shouldSkipDependencySource(
+        sourceFileRelativePath,
+        moduleRoot,
+        workspaceRoot,
+        includeTestFiles,
+        includeConfiguredNonProductionModuleSources
+      )) {
         continue;
       }
       const sourceText = await readTextFileIfExists2(sourceFilePath);
@@ -216962,15 +217045,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 +217064,7 @@ function resolveImportDependencyContextMetadata(architectureContract, dependency
       resolvedTargetPath: dependencyImport.resolvedTargetRelativePath
     });
   }
-  const resolvedPathContext = resolveDependencyContext(architectureContract, {
+  const resolvedPathContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.resolvedTargetRelativePath
   });
@@ -217019,11 +217102,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 +217146,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 +217158,8 @@ function isModuleScopedDependencyImport(architectureContract, dependencyImport)
   }
   const dependencyMetadata = resolveImportDependencyContextMetadata(
     architectureContract,
-    dependencyImport
+    dependencyImport,
+    resolver
   );
   return !dependencyMetadata.isExternal;
 }
@@ -217382,7 +217470,10 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
     explicitStandaloneModuleByPath,
     workspacePackageAliases,
     adapter,
-    { resolutionContext }
+    {
+      includeConfiguredNonProductionModuleSources: true,
+      resolutionContext
+    }
   );
   options?.onCollectedImports?.(imports);
   options?.onResolutionStats?.(resolutionContext.getStats());
@@ -217421,34 +217512,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 +217577,17 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     workspacePackageAliases,
     adapter
   );
-  const peerImports = filterPeerModuleImports(imports);
+  const boundaryImports = filterImportsForBoundaryChecks(imports, moduleRoots, workspaceRoot);
+  const dependencyContextResolver = createArchitectureDependencyContextResolver(
+    architectureContract
+  );
+  const peerImports = filterPeerModuleImports(boundaryImports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      architectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
@@ -217490,7 +217597,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217622,7 +217730,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217783,7 +217892,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
         workspaceRoot,
         canonicalModuleRoots
       ),
-      adapter
+      adapter,
+      { includeConfiguredNonProductionModuleSources: true }
     );
     const canonicalPeerImports = filterPeerModuleImports(canonicalImports).filter(
       (dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport)
@@ -217881,9 +217991,15 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     workspacePackageAliases,
     adapter
   );
-  const peerImports = filterPeerModuleImports(imports);
+  const boundaryImports = filterImportsForBoundaryChecks(imports, moduleRoots, workspaceRoot);
+  const dependencyContextResolver = parsedArchitectureContract ? createArchitectureDependencyContextResolver(parsedArchitectureContract) : void 0;
+  const peerImports = filterPeerModuleImports(boundaryImports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(parsedArchitectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      parsedArchitectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
@@ -217942,7 +218058,8 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
-            dependencyImport
+            dependencyImport,
+            dependencyContextResolver
           );
           if (dependencyMetadata.isExternal) {
             return false;
@@ -217966,7 +218083,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 +218129,8 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
-            dependencyImport
+            dependencyImport,
+            dependencyContextResolver
           );
           if (dependencyMetadata.isExternal) {
             continue;
@@ -218057,7 +218179,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,
@@ -218123,7 +218249,8 @@ async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
     moduleRoots,
     explicitStandaloneModuleByPath,
     workspacePackageAliases,
-    adapter
+    adapter,
+    { includeConfiguredNonProductionModuleSources: true }
   );
   const imports = filterPeerModuleImports(allImports).filter(
     (dependencyImport) => moduleSet.has(dependencyImport.sourceModule) && moduleSet.has(dependencyImport.targetModule)
@@ -221079,7 +221206,7 @@ async function generateMissingModuleContracts(workspaceRoot) {
       });
       createdContracts.push(contractPath);
     }
-    if (isRegistryEntryDifferent({
+    if (moduleEntry.discoverySource === "architecture.json" && isRegistryEntryDifferent({
       contract,
       moduleName: moduleEntry.moduleName,
       sourcePath,
@@ -222149,7 +222276,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
           "AP-ARCH-005",
           "error",
           true,
-          "No modules are registered in architecture.json. Module registry path checks are not applicable."
+          "No explicit root modules are registered in architecture.json. Root module registry path checks are not applicable; component-backed contracts are validated by dependency checks."
         )
       });
     }
@@ -222159,7 +222286,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
           "AP-ARCH-006",
           "error",
           true,
-          "No modules are registered in architecture.json. Module contract file checks are not applicable."
+          "No explicit root modules are registered in architecture.json. Root module contract file checks are not applicable; component-backed contracts are validated by dependency checks."
         )
       });
     }
@@ -222169,7 +222296,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
           "AP-ARCH-007",
           "error",
           true,
-          "No modules are registered in architecture.json. Module contract identity checks are not applicable."
+          "No explicit root modules are registered in architecture.json. Root module contract identity checks are not applicable; component-backed contracts are validated by dependency checks."
         )
       });
     }
@@ -222179,7 +222306,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
           "AP-ARCH-008",
           "error",
           true,
-          "No modules are registered in architecture.json. Module public entrypoint alignment checks are not applicable."
+          "No explicit root modules are registered in architecture.json. Root module public entrypoint alignment checks are not applicable; component-backed contracts are validated by dependency checks."
         )
       });
     }
@@ -223128,7 +223255,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
     "info",
     `Remote policy configured. Loading policy from ${policySourceUrl}.`
   );
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const request3 = https.request(
       {
         protocol: validated.url.protocol,
@@ -223155,7 +223282,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
               "warn",
               `Remote policy request failed with HTTP ${statusCode}. Using local policy only.`
             );
-            resolve9({
+            resolve10({
               message: `Remote policy request failed with HTTP ${statusCode}. Using local policy only.`
             });
             return;
@@ -223169,7 +223296,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
               "warn",
               "Remote policy payload is invalid JSON. Using local policy only."
             );
-            resolve9({
+            resolve10({
               message: "Remote policy payload is invalid JSON. Using local policy only."
             });
             return;
@@ -223181,7 +223308,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
               "warn",
               "Remote policy payload has an invalid structure. Using local policy only."
             );
-            resolve9({
+            resolve10({
               message: "Remote policy payload has an invalid structure. Using local policy only."
             });
             return;
@@ -223191,7 +223318,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
             "info",
             "Remote policy loaded successfully."
           );
-          resolve9({
+          resolve10({
             policy: normalized,
             message: "Remote policy loaded successfully."
           });
@@ -223207,7 +223334,7 @@ async function loadRemotePolicyWithStatus(policySourceUrl, options) {
         "warn",
         "Remote policy unavailable. Using local policy only."
       );
-      resolve9({
+      resolve10({
         message: "Remote policy unavailable. Using local policy only."
       });
     });
@@ -225533,6 +225660,15 @@ function hasPaginationEvidence(statement) {
     statement
   );
 }
+function hasEqualityPredicate(statement, columnPattern) {
+  return new RegExp(
+    `\\bwhere\\b[\\s\\S]*\\b(?:${columnPattern})\\b\\s*=\\s*(?:[\\w$:@?]+|'[^']+'|"[^"]+"|\\d+)`,
+    "iu"
+  ).test(statement);
+}
+function isCatalogIdentifierPointLookup(statement) {
+  return /\bfrom\s+information_schema\.schemata\b/iu.test(statement) && hasEqualityPredicate(statement, "schema_name");
+}
 function isObviousPointLookup(statement) {
   const normalized = statement.toLowerCase();
   if (!normalized.includes("where")) {
@@ -225541,7 +225677,7 @@ function isObviousPointLookup(statement) {
   if (normalized.includes(" or ")) {
     return false;
   }
-  return /\bwhere\b[\s\S]*\b([a-z_]*id)\b\s*=\s*([\w$:@?]+|'[^']+'|\d+)/i.test(normalized);
+  return hasEqualityPredicate(normalized, "id|uuid|slug|email|identifier") || isCatalogIdentifierPointLookup(normalized);
 }
 function listModulePathEntries(contract) {
   return Object.entries(contract.modules ?? {}).map(([moduleName, reference]) => {
@@ -226122,13 +226258,14 @@ function detectRepeatedQueryPattern(method) {
 }
 function extractSqlQueryLiterals(content) {
   const queries = [];
+  const searchableContent = maskSourceComments(content);
   const patterns = [
     /(?:\b(?:[\w$]+\.)?(?:query|execute|executeQuery|createNativeQuery|createQuery|FromSqlRaw|FromSqlInterpolated|Query|QueryContext|QueryRow|QueryRowContext|Exec|ExecContext|Raw|text)|\$queryRaw|\$executeRaw)\s*\([^'"`)]{0,180}?(['"`])([\s\S]{0,900}?)\1/giu,
     /\b(?:DB::select|DB::statement|DB::raw|DB::table)\s*\([^'"`)]{0,180}?(['"`])([\s\S]{0,900}?)\1/gu,
     /@Query\s*\(\s*(['"`])([\s\S]{0,900}?)\1/gu
   ];
   for (const pattern of patterns) {
-    for (const match of content.matchAll(pattern)) {
+    for (const match of searchableContent.matchAll(pattern)) {
       const sql = match[2];
       if (!sql || !/\b(?:select|update|delete|insert)\b/iu.test(sql)) {
         continue;
@@ -226141,6 +226278,71 @@ function extractSqlQueryLiterals(content) {
   }
   return queries;
 }
+function maskSourceComments(content) {
+  let masked = "";
+  let index = 0;
+  let state = "code";
+  let escaped = false;
+  while (index < content.length) {
+    const current = content[index] ?? "";
+    const next = content[index + 1] ?? "";
+    if (state === "line-comment") {
+      if (current === "\r" || current === "\n") {
+        masked += current;
+        state = "code";
+      } else {
+        masked += " ";
+      }
+      index += 1;
+      continue;
+    }
+    if (state === "block-comment") {
+      if (current === "*" && next === "/") {
+        masked += "  ";
+        index += 2;
+        state = "code";
+        continue;
+      }
+      masked += current === "\r" || current === "\n" ? current : " ";
+      index += 1;
+      continue;
+    }
+    if (state === "single" || state === "double" || state === "template") {
+      masked += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (state === "single" && current === "'" || state === "double" && current === '"' || state === "template" && current === "`") {
+        state = "code";
+      }
+      index += 1;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      masked += "  ";
+      index += 2;
+      state = "line-comment";
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      masked += "  ";
+      index += 2;
+      state = "block-comment";
+      continue;
+    }
+    if (current === "'") {
+      state = "single";
+    } else if (current === '"') {
+      state = "double";
+    } else if (current === "`") {
+      state = "template";
+    }
+    masked += current;
+    index += 1;
+  }
+  return masked;
+}
 function detectCodeSqlQueryShapeFindings(file, config) {
   const findings = [];
   for (const query of extractSqlQueryLiterals(file.content)) {
@@ -226230,12 +226432,18 @@ function hasAssignedBuilderBoundedTerminal(methodBody, snippet) {
   }
   return new RegExp(`\\b${variableName}\\s*\\.\\s*(?:getOne|getRawOne|loadOne|getCount|getExists)\\s*\\(`, "iu").test(methodBody);
 }
+function hasIdentifierPredicateEvidence(snippet) {
+  return /\.(?:where|andWhere|orWhere)\s*\(\s*['"`][^'"`]{0,240}\b(?:\w*id|uuid|slug|email|identifier)\b[^'"`]{0,120}(?:=| in\b|IN\b)/iu.test(snippet) || /\bwhere\s*:\s*\{[\s\S]{0,420}\b(?:id|uuid|slug|email|identifier|channelId|orderId|customerId|userId|productId|variantId)\b\s*[:=]/iu.test(snippet);
+}
+function hasQueryBuilderTerminalEvidence(snippet, methodBody) {
+  return /\.(?:getMany|getRawMany|loadMany|getOne|getRawOne|loadOne|getCount|getExists|execute)\s*\(/iu.test(snippet) || hasAssignedBuilderBoundedTerminal(methodBody, snippet);
+}
 function isNonCollectionOrmRead(label, snippet, methodBody = snippet) {
   const terminal = getOrmTerminalOperation(snippet);
   return /\b(?:findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|count|exists|aggregate)\b/iu.test(label) || !!terminal && /^(?:getOne|getRawOne|loadOne|getCount|getExists|findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|count|exists|update|delete|remove|save|insert|execute)$/iu.test(terminal) || isScopedRelationLoad(snippet) || hasAssignedBuilderBoundedTerminal(methodBody, snippet);
 }
 function hasOrmBoundEvidence(snippet) {
-  return codePaginationEvidencePattern.test(snippet) || /\.(?:take|limit|offset|skip)\s*\(/iu.test(snippet) || /\b(?:maxResults|setMaxResults|firstResult|setFirstResult)\s*\(/iu.test(snippet) || /\b(?:pageSize|perPage|limit|take)\s*[:=]\s*\d+\b/iu.test(snippet);
+  return codePaginationEvidencePattern.test(snippet) || /\.(?:take|limit|offset|skip)\s*\(/iu.test(snippet) || /\b(?:maxResults|setMaxResults|firstResult|setFirstResult)\s*\(/iu.test(snippet) || /\b(?:pageSize|perPage|limit|take)\s*[:=]\s*\d+\b/iu.test(snippet) || hasIdentifierPredicateEvidence(snippet);
 }
 function getOrmQueryTarget(method, label, snippet) {
   const terminal = getOrmTerminalOperation(snippet);
@@ -226258,6 +226466,9 @@ function getOrmQueryLabel(method, label, snippet) {
 function detectOrmQueryShapeFindings(method, config) {
   const findings = [];
   for (const evidence of collectOrmReadEvidence(method)) {
+    if (evidence.label === "node.query" && !hasQueryBuilderTerminalEvidence(evidence.snippet, method.body)) {
+      continue;
+    }
     if (config.tenantModel === "same_db_same_schema" && !tenantPredicatePattern.test(evidence.snippet)) {
       findings.push(createCodeFinding({
         id: "AP-DQR-001",
@@ -226727,17 +226938,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 +227107,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) {
@@ -226940,7 +227177,7 @@ function detectControllerBusinessLogic(entry, classification, moduleName, contex
   });
 }
 function detectRepositoryBusinessLogic(entry, classification, moduleName) {
-  if (!classification.isRepository) {
+  if (!classification.isRepository || !isProductionBackendGovernanceScope(classification.scope)) {
     return void 0;
   }
   if (entry.extension === ".java" && isPureSpringDataRepositoryInterface(entry.content)) {
@@ -227195,7 +227432,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 = [
@@ -227268,7 +227505,7 @@ var publicEvidencePattern = /@Public\b|@PermitAll\b|\[AllowAnonymous\b[^\]]*\]|p
 var roleEvidencePattern = /@(?:Roles|Permissions|RequirePermission|PreAuthorize|Secured|RolesAllowed)\s*(?:\(|\b)([^)\n]*)|\[Authorize\s*\([^)\]]*(?:Roles|Policy)\s*=|(?:requireRole\w*|RequireRole\w*|require_role|RoleChecker|adminMiddleware|can:|permission:|scopes?\s*=|Security\s*\([^)]*scopes)\b/u;
 var tenantSignalPattern = /\b(?:tenantId|tenant_id|organizationId|organization_id|orgId|org_id|workspaceId|workspace_id|accountId|account_id|companyId|company_id|customerId|customer_id|TenantContext|CurrentTenant|TenantResolver|TenantProvider|request\.tenant|req\.tenant|user\.tenantId|user\.tenant_id|user\.organizationId|user\.organization_id|user\.orgId|user\.accountId|user\.workspaceId|user\.companyId|user\.customerId|HibernateFilter|CurrentTenant)\b/u;
 var tenantPredicateEvidencePattern = /\b(?:tenantId|tenant_id|organizationId|organization_id|orgId|org_id|workspaceId|workspace_id|accountId|account_id|companyId|company_id|customerId|customer_id|TenantContext|CurrentTenant|TenantResolver|TenantProvider|request\.tenant|req\.tenant|user\.tenantId|user\.tenant_id|user\.organizationId|user\.organization_id|user\.orgId|user\.accountId|user\.workspaceId|user\.companyId|user\.customerId|HibernateFilter|CurrentTenant)\b/u;
-var repositoryRolePattern = /\b(?:role|roles|permission|permissions|isAdmin|hasRole|hasPermission|SecurityContextHolder|Authentication|Principal)\b/u;
+var executableAuthorizationDecisionPattern = /@(?:PreAuthorize|PostAuthorize|Secured|RolesAllowed)\b|\[(?:Authorize)\b[^\]]*(?:Roles|Policy)\s*=|\b(?:hasRole|hasAuthority|hasPermission|isUserInRole|checkPermission|requireRole\w*|RequireRole\w*|require_role|canActivate|authorize|assertAuthorized|PermissionChecker|AccessDecisionManager|SecurityContextHolder\.getContext\(\)\.getAuthentication)\s*\(|\b(?:user|principal|currentUser|account)\.(?:role|roles|permission|permissions|isAdmin)\b\s*(?:[=!]==?|\.includes\s*\(|\.contains\s*\()/u;
 function normalizePath12(value) {
   return value.replace(/\\/g, "/");
 }
@@ -227696,7 +227933,7 @@ function detectAuthorizationFindings(files, contract, astCache) {
     }
   }
   for (const file of files.filter((candidate) => isRepositoryFile(candidate, astCache))) {
-    const roleMatch = repositoryRolePattern.exec(file.content);
+    const roleMatch = executableAuthorizationDecisionPattern.exec(file.content);
     if (!roleMatch) {
       continue;
     }
@@ -230495,8 +230732,9 @@ function extractJavaSignals(file) {
       publishes: []
     });
   }
-  for (const match of file.content.matchAll(/(?:await\s+)?(?:\w+\.)?(?:publishEvent|publish|emit)\s*\(\s*(?:new\s+)?(["']?)([A-Za-z][\w.]*Event?|[a-z][\w.]+)\1/gu)) {
-    const eventName = match[2];
+  for (const match of file.content.matchAll(/(?:await\s+)?(?:\w+\.)?(?:publishEvent|publish|emit)\s*\(\s*(?:(new)\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*\(|(["'])([A-Za-z][\w.]*Event?|[a-z][\w.]+)\3|([A-Z][A-Za-z0-9_]*Event)\b)/gu)) {
+    const constructedType = match[2]?.split(".").at(-1);
+    const eventName = constructedType ?? match[4] ?? match[5];
     if (!eventName) {
       continue;
     }
@@ -234352,7 +234590,7 @@ ${infoLines.join("\n")}
 ## Passed Checks
 ${passedLines.join("\n")}
 
-## Module Dependency Summary
+## Module / Component Contract Dependency Summary
 ${dependencyGraphLines.join("\n")}
 
 ## Disabled Rules
@@ -236588,7 +236826,7 @@ ${appliedFixesSection}
 ## Remaining Violations
 ${remainingViolationsLine}
 
-## Module Dependency Summary
+## Module / Component Contract Dependency Summary
 ${moduleCatalog.length === 0 ? "- Module details are not available in this run." : moduleCatalog.map(
     (entry) => `- ${entry.moduleName} | Role: ${entry.role} | Path: ${entry.path ?? "(not configured)"} | Contract: ${entry.hasContract ? "yes" : "no"} | Declared deps: ${entry.declaredDependencyCount} | Actual deps: ${entry.actualDependencyCount} | Used by: ${entry.inboundDependencyCount}`
   ).join("\n")}
@@ -238840,11 +239078,11 @@ function normalizeAnnotationPath(workspaceRoot, sourceFile) {
   if (!path43.isAbsolute(sourceFile)) {
     return normalized;
   }
-  const relative17 = path43.relative(workspaceRoot, sourceFile).replace(/\\/g, "/");
-  if (relative17.startsWith("..") || path43.isAbsolute(relative17)) {
+  const relative18 = path43.relative(workspaceRoot, sourceFile).replace(/\\/g, "/");
+  if (relative18.startsWith("..") || path43.isAbsolute(relative18)) {
     return void 0;
   }
-  return relative17;
+  return relative18;
 }
 function toAnnotatableFinding(workspaceRoot, finding) {
   if (typeof finding.id !== "string" || !finding.id.startsWith("AP-DEP-")) {
@@ -239028,7 +239266,7 @@ async function emitGithubInlineArchitectureAnnotations(workspaceRoot) {
 var reviewCommentMarker = "<!-- archpilot-pr-review -->";
 var legacyReviewCommentMarker = "<!-- ARCHPILOT_REVIEW_COMMENT -->";
 function requestGithubApi(options) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const payload = options.body !== void 0 ? JSON.stringify(options.body) : void 0;
     const request3 = https2.request(
       {
@@ -239049,7 +239287,7 @@ function requestGithubApi(options) {
           chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
         });
         response.on("end", () => {
-          resolve9({
+          resolve10({
             statusCode: response.statusCode ?? 0,
             body: Buffer.concat(chunks).toString("utf8")
           });
@@ -245326,6 +245564,9 @@ function addEvidence6(evidence, value) {
     evidence.push(value);
   }
 }
+function hasDeclaredMavenReactorEvidence(candidate) {
+  return candidate.evidence.some((entry) => /Declared (?:by )?Maven|nested Maven reactor/iu.test(entry));
+}
 function isIgnoredComponentCandidatePath(componentPath) {
   const normalized = normalizePath25(componentPath).replace(/^\.\//u, "");
   if (normalized === "." || normalized.length === 0) {
@@ -245365,7 +245606,9 @@ function isIgnoredComponentCandidatePath(componentPath) {
     "build",
     "coverage"
   ];
-  return ignoredRootSegments.includes(firstSegment ?? "") || segments.some((segment) => ignoredSupportingSegments.includes(segment.toLowerCase()));
+  const isExampleContainer = firstSegment === "examples" || firstSegment === "example";
+  const isIgnoredRootSegment = ignoredRootSegments.includes(firstSegment ?? "") && (!isExampleContainer || segments.length === 1);
+  return isIgnoredRootSegment || segments.some((segment) => ignoredSupportingSegments.includes(segment.toLowerCase()));
 }
 function pathExists19(pathValue) {
   try {
@@ -245429,6 +245672,9 @@ function readFirstXmlTag(value, tagName) {
   const match = value.match(new RegExp(`<${tagName}(?:\\s[^>]*)?>([\\s\\S]*?)</${tagName}>`, "iu"));
   return match?.[1]?.trim().replace(/\s+/gu, " ");
 }
+function readXmlTagValues(value, tagName) {
+  return [...value.matchAll(new RegExp(`<${tagName}(?:\\s[^>]*)?>([\\s\\S]*?)</${tagName}>`, "giu"))].map((match) => match[1]?.trim().replace(/\s+/gu, " ") ?? "").filter((entry) => entry.length > 0);
+}
 function readMavenMetadata(workspaceRoot, componentPath) {
   if (isUnderJvmResourceRoot4(componentPath)) {
     return void 0;
@@ -245446,7 +245692,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),
@@ -245458,6 +245712,95 @@ function readMavenMetadata(workspaceRoot, componentPath) {
     hasTestResources: pathExists19(path64.join(absoluteRoot, "src", "test", "resources"))
   };
 }
+function workspaceRelativePath(workspaceRoot, absolutePathValue) {
+  const relative18 = path64.relative(workspaceRoot, absolutePathValue);
+  if (relative18.length === 0) {
+    return ".";
+  }
+  if (relative18.startsWith("..") || path64.isAbsolute(relative18)) {
+    return void 0;
+  }
+  return normalizePath25(relative18);
+}
+function canonicalRealPath(filePath) {
+  try {
+    return fs58.realpathSync.native(filePath);
+  } catch {
+    return void 0;
+  }
+}
+function readMavenDeclaredModules(pomPath) {
+  const pomXml = readTextFileSafe(pomPath);
+  if (!pomXml) {
+    return [];
+  }
+  return uniqueSorted4(
+    readXmlTagValues(stripXmlComments(pomXml), "module").filter((modulePath) => !/[${}]/u.test(modulePath))
+  );
+}
+function collectMavenReactorCandidates(workspaceRoot, rootPaths) {
+  const candidates = /* @__PURE__ */ new Map();
+  const visitedPomPaths = /* @__PURE__ */ new Set();
+  const workspaceRealPath = canonicalRealPath(workspaceRoot) ?? path64.resolve(workspaceRoot);
+  const workspaceRealPathForCompare = process.platform === "win32" ? workspaceRealPath.toLowerCase() : workspaceRealPath;
+  const maxVisitedPoms = 500;
+  const addCandidate = (candidatePath, evidence, parentPath) => {
+    const normalized = normalizePath25(candidatePath);
+    const existing = candidates.get(normalized) ?? { path: normalized, evidence: [] };
+    addEvidence6(existing.evidence, evidence);
+    if (parentPath && !existing.parentPath) {
+      existing.parentPath = parentPath;
+    }
+    candidates.set(normalized, existing);
+  };
+  const visitPom = (pomPath, parentPath) => {
+    if (visitedPomPaths.size >= maxVisitedPoms) {
+      return;
+    }
+    const realPomPath = canonicalRealPath(pomPath);
+    if (!realPomPath || visitedPomPaths.has(realPomPath)) {
+      return;
+    }
+    const realPomPathForCompare = process.platform === "win32" ? realPomPath.toLowerCase() : realPomPath;
+    if (realPomPathForCompare !== workspaceRealPathForCompare && !realPomPathForCompare.startsWith(`${workspaceRealPathForCompare}${path64.sep}`)) {
+      return;
+    }
+    visitedPomPaths.add(realPomPath);
+    const pomDirectory = path64.dirname(pomPath);
+    const relativePomDirectory = workspaceRelativePath(workspaceRoot, pomDirectory);
+    if (!relativePomDirectory) {
+      return;
+    }
+    addCandidate(
+      relativePomDirectory,
+      parentPath ? `Declared by Maven reactor parent ${parentPath}` : "Detected Maven reactor root",
+      parentPath
+    );
+    for (const declaredModule of readMavenDeclaredModules(pomPath)) {
+      const childDirectory = path64.resolve(pomDirectory, declaredModule);
+      const childRelativePath = workspaceRelativePath(workspaceRoot, childDirectory);
+      if (!childRelativePath || isUnderJvmResourceRoot4(childRelativePath)) {
+        continue;
+      }
+      const childPom = path64.join(childDirectory, "pom.xml");
+      if (!pathExists19(childPom)) {
+        addCandidate(childRelativePath, `Declared Maven module '${declaredModule}' is missing pom.xml`, relativePomDirectory);
+        continue;
+      }
+      addCandidate(childRelativePath, `Declared Maven module '${declaredModule}' from ${relativePomDirectory}`, relativePomDirectory);
+      visitPom(childPom, relativePomDirectory);
+    }
+  };
+  for (const rootPath of uniqueSorted4(rootPaths)) {
+    const normalizedRoot = normalizePath25(rootPath);
+    const absoluteRoot = normalizedRoot === "." ? workspaceRoot : path64.join(workspaceRoot, ...normalizedRoot.split("/"));
+    const pomPath = path64.join(absoluteRoot, "pom.xml");
+    if (pathExists19(pomPath)) {
+      visitPom(pomPath);
+    }
+  }
+  return [...candidates.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
 function toComponentRoot(modulePath) {
   const normalized = normalizePath25(modulePath);
   const segments = normalized.split("/").filter((segment) => segment.length > 0);
@@ -245492,6 +245835,18 @@ function buildRootCandidates(input2) {
   for (const root of input2.topology.detectedRoots ?? []) {
     addCandidate(root, `Detected project root ${root}`);
   }
+  if (input2.workspaceRoot) {
+    const mavenRoots = [".", ...input2.topology.detectedRoots ?? []];
+    for (const candidate of collectMavenReactorCandidates(input2.workspaceRoot, mavenRoots)) {
+      addCandidate(
+        candidate.path,
+        candidate.parentPath ? `Detected nested Maven reactor module under ${candidate.parentPath}` : "Detected Maven reactor module"
+      );
+      for (const evidence of candidate.evidence) {
+        addCandidate(candidate.path, evidence);
+      }
+    }
+  }
   for (const moduleEntry of input2.modules?.modules ?? []) {
     const componentRoot = toComponentRoot(moduleEntry.path);
     if (componentRoot) {
@@ -245563,6 +245918,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 +246228,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 +246340,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
@@ -245697,6 +246355,9 @@ function classifyGovernanceRole(input2) {
   const hasMavenDistributionPackagingEvidence = Boolean(
     maven?.packaging === "pom" && !hasMavenMainSource && hasAnyToken(pathText, [/(^|\/)(distribution|dist|downloads|assembl(y|ies)|feature-packs?)(\/|$)/u])
   );
+  const hasMavenStarterPackagingEvidence = Boolean(
+    maven && !hasMavenMainJvmSourceEvidence && hasAnyToken(`${pathText} ${mavenMetadataText}`, [/\bstarters?\b|\bspring-boot-starter\b|\bstarter[-\s]/u])
+  );
   if (input2.candidate.architectureRoot?.classification === "backend_app" || input2.candidate.architectureRoot?.classification === "frontend_app") {
     runtimeScore += 3;
     addEvidence6(evidence, `Runtime architecture root signal: ${input2.candidate.architectureRoot.classification}`);
@@ -245725,17 +246386,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 +246439,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");
@@ -245800,6 +246467,10 @@ function classifyGovernanceRole(input2) {
     supportScore += 1;
     addEvidence6(evidence, "Maven POM-only aggregator/packaging module");
   }
+  if (hasMavenStarterPackagingEvidence) {
+    supportScore += 4;
+    addEvidence6(evidence, "Maven starter/resource artifact without JVM runtime source");
+  }
   if (isPlainResourcesSurface) {
     supportScore += 4;
     addEvidence6(evidence, "Resources-only surface without runtime source or manifest evidence");
@@ -245811,6 +246482,13 @@ function classifyGovernanceRole(input2) {
       selectedByDefault: false
     };
   }
+  if (hasMavenStarterPackagingEvidence && !hasMavenMainJvmSourceEvidence) {
+    return {
+      governanceRole: "support",
+      governanceEvidence: uniqueSorted4(evidence),
+      selectedByDefault: false
+    };
+  }
   if (hasMavenDistributionPackagingEvidence && hasAnyToken(mavenMetadataText, [/\b(docs?|documentation|metadata tests?|licenses?|maven plugins?|builds?)\b/u])) {
     supportScore += 3;
     addEvidence6(evidence, "Maven documentation/build/distribution packaging evidence without runtime source");
@@ -245870,7 +246548,7 @@ function detectComponents(input2) {
   const manifestBackedRoots = new Set(
     (input2.topology.detectedRoots ?? []).filter((root) => !isUnderJvmResourceRoot4(root))
   );
-  const rootCandidates = buildRootCandidates(input2).filter((candidate) => !ignoreMatcher.isIgnored(candidate.path)).filter((candidate) => !isIgnoredComponentCandidatePath(candidate.path)).filter((candidate) => !(isUnderJvmResourceRoot4(candidate.path) && !hasRuntimeSourceFiles(input2.workspaceRoot, candidate.path))).filter((candidate) => {
+  const rootCandidates = buildRootCandidates({ ...input2, workspaceRoot: input2.workspaceRoot }).filter((candidate) => !ignoreMatcher.isIgnored(candidate.path) || hasDeclaredMavenReactorEvidence(candidate)).filter((candidate) => !isIgnoredComponentCandidatePath(candidate.path)).filter((candidate) => !(isUnderJvmResourceRoot4(candidate.path) && !hasRuntimeSourceFiles(input2.workspaceRoot, candidate.path))).filter((candidate) => {
     if (input2.topology.topology !== "monorepo" || manifestBackedRoots.size === 0) {
       return true;
     }
@@ -246168,7 +246846,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) || /Maven library main source\/resource surface/iu.test(text) || /Maven Spring Boot auto-configuration\/starter library evidence/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);
@@ -246378,7 +247056,20 @@ function hasAttributableBackendRoot(detection) {
   return getBackendComponents(detection).length > 0;
 }
 function isGenericLibraryStack(stack) {
-  return stack === "node_typescript" || stack === "node_javascript" || stack === "python" || stack === "go" || stack === "kotlin" || stack === "terraform" || stack === "ansible";
+  return stack === "node_typescript" || stack === "node_javascript" || stack === "library_generic" || stack === "java" || stack === "spring" || stack === "python" || stack === "go" || stack === "kotlin" || stack === "kotlin_spring" || stack === "terraform" || stack === "ansible";
+}
+function preferredLibraryStack(stacks) {
+  const uniqueStacks = uniqueInOrder2(stacks);
+  if (uniqueStacks.length <= 1) {
+    return isJvmLibraryStack(uniqueStacks[0]) ? "library_generic" : uniqueStacks[0];
+  }
+  if (uniqueStacks.some(isJvmLibraryStack) && uniqueStacks.every((candidate) => isJvmLibraryStack(candidate) || candidate === "node_typescript" || candidate === "node_javascript")) {
+    return "library_generic";
+  }
+  return void 0;
+}
+function isJvmLibraryStack(stack) {
+  return stack === "java" || stack === "spring";
 }
 function hasProjectKindEvidence(detection, patterns) {
   const evidence = detection.projectKinds?.evidence ?? [];
@@ -246800,7 +247491,7 @@ function resolveStackSelections(detection, projectKinds) {
     const libraryComponentStacks = uniqueInOrder2(
       libraryComponents.map((component) => component.stack).filter((stack) => isGenericLibraryStack(stack))
     );
-    const selectedLibrary = detection.topology.topology === "monorepo" ? libraryComponentStacks.length === 1 ? libraryComponentStacks[0] : void 0 : detection.stacks.selectedAdapterId;
+    const selectedLibrary = detection.topology.topology === "monorepo" ? preferredLibraryStack(libraryComponentStacks) : detection.stacks.selectedAdapterId;
     if (isGenericLibraryStack(selectedLibrary)) {
       selections.library = selectedLibrary;
     }
@@ -246822,7 +247513,7 @@ function resolveProjectProfiles(detection, projectKinds, stackSelections, apiSty
       selectedAdapterId: stackId,
       selectedAdapterCategory: getStackAdapterById(stackId).category,
       projectKinds: [kind],
-      apiStyleHint: kind === "backend" && apiStyle ? apiStyle : resolveRoleApiStyleHint(detection, stackId, component),
+      apiStyleHint: kind === "backend" && apiStyle ? apiStyle : stackId === "library_generic" ? void 0 : resolveRoleApiStyleHint(detection, stackId, component),
       databaseHints: detection.toolingHints?.databaseHints,
       toolingHints: detection.toolingHints?.toolingHints,
       repoTopology: detection.topology.topology === "unknown" ? "single_project" : detection.topology.topology