@archpilotlabs/archpilot 0.2.2 → 0.2.4

package/dist/core/src/dependencyValidation.js

@@ -0,0 +1,2557 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyRulesTemplate = exports.DependencyRulesConfigError = void 0;
+exports.isParentChildModuleRelationship = isParentChildModuleRelationship;
+exports.readDependencyRulesConfig = readDependencyRulesConfig;
+exports.buildDependencyGraphSummary = buildDependencyGraphSummary;
+exports.validateDependencyContractBoundaries = validateDependencyContractBoundaries;
+exports.validateDependencyBoundaries = validateDependencyBoundaries;
+exports.buildModuleDependencyGraphSnapshot = buildModuleDependencyGraphSnapshot;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const ts = __importStar(require("typescript"));
+const architectureInit_1 = require("./architectureInit");
+const architectureDependencyContext_1 = require("./architectureDependencyContext");
+const moduleDiscovery_1 = require("./moduleDiscovery");
+const stackAdapters_1 = require("./stackAdapters");
+const sourceScopeClassification_1 = require("./sourceScopeClassification");
+const dependencyRulesConfigFile = '.archpilot/dependency-rules.json';
+class DependencyRulesConfigError extends Error {
+}
+exports.DependencyRulesConfigError = DependencyRulesConfigError;
+exports.dependencyRulesTemplate = `{
+  "modules": {
+    "billing": {
+      "allowedDependencies": ["shared", "identity"],
+      "publicEntrypointsOnly": true
+    },
+    "identity": {
+      "allowedDependencies": ["shared"],
+      "publicEntrypointsOnly": true
+    },
+    "shared": {
+      "allowedDependencies": []
+    }
+  }
+}
+`;
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function toSafeContractModuleFileStem(moduleName) {
+    return normalizePath(moduleName)
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0)
+        .join('.');
+}
+function normalizeAbsolutePath(filePath) {
+    return normalizePath(path.resolve(filePath)).toLowerCase();
+}
+function isPathInsideOrEqual(childPath, parentPath) {
+    const child = normalizeAbsolutePath(childPath);
+    const parent = normalizeAbsolutePath(parentPath);
+    return child === parent || child.startsWith(`${parent}/`);
+}
+function isParentChildModuleRelationship(leftModule, rightModule) {
+    if (leftModule === rightModule) {
+        return false;
+    }
+    return leftModule.startsWith(`${rightModule}/`) || rightModule.startsWith(`${leftModule}/`);
+}
+function isPeerModuleImport(dependencyImport) {
+    return !isParentChildModuleRelationship(dependencyImport.sourceModule, dependencyImport.targetModule);
+}
+function filterPeerModuleImports(imports) {
+    return imports.filter(isPeerModuleImport);
+}
+function getComponentModuleRoots(workspaceRoot, architectureContract) {
+    const components = architectureContract?.components;
+    if (!components) {
+        return new Map();
+    }
+    const rawEntries = Array.isArray(components)
+        ? components.map((entry) => {
+            const typed = entry;
+            return [typed.id, entry];
+        })
+        : Object.entries(components);
+    const componentRoots = new Map();
+    for (const [key, value] of rawEntries) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            continue;
+        }
+        const typed = value;
+        const componentId = typeof typed.id === 'string' && typed.id.trim().length > 0
+            ? typed.id.trim()
+            : typeof key === 'string' && key.trim().length > 0
+                ? key.trim()
+                : undefined;
+        const componentPath = typeof typed.path === 'string' && typed.path.trim().length > 0
+            ? normalizePath(typed.path.trim())
+            : undefined;
+        if (!componentId || !componentPath || componentPath === '.') {
+            continue;
+        }
+        componentRoots.set(componentId, path.join(workspaceRoot, ...componentPath.split('/')));
+    }
+    return new Map([...componentRoots.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function buildModuleHierarchyEdges(moduleIds) {
+    const moduleIdSet = new Set(moduleIds);
+    const edges = [];
+    for (const moduleId of moduleIds) {
+        const parentModule = moduleId
+            .split('/')
+            .slice(0, -1)
+            .map((_, index, segments) => segments.slice(0, segments.length - index).join('/'))
+            .find((candidate) => moduleIdSet.has(candidate));
+        if (!parentModule) {
+            continue;
+        }
+        edges.push({ parentModule, childModule: moduleId });
+    }
+    return edges.sort((left, right) => {
+        const parentCompare = left.parentModule.localeCompare(right.parentModule);
+        if (parentCompare !== 0) {
+            return parentCompare;
+        }
+        return left.childModule.localeCompare(right.childModule);
+    });
+}
+function buildChildModulesByParent(hierarchyEdges) {
+    const byParent = new Map();
+    for (const edge of hierarchyEdges) {
+        const children = byParent.get(edge.parentModule) ?? new Set();
+        children.add(edge.childModule);
+        byParent.set(edge.parentModule, children);
+    }
+    return new Map([...byParent.entries()].map(([parentModule, childModules]) => [
+        parentModule,
+        sortUnique(childModules),
+    ]));
+}
+function isIsolatedContractlessHierarchyModule(input) {
+    return (!input.hasContract &&
+        input.parentModule !== undefined &&
+        input.declaredDependencies.length === 0 &&
+        input.actualDependencies.length === 0 &&
+        input.inboundDeclaredFrom.length === 0 &&
+        input.inboundActualFrom.length === 0 &&
+        input.unusedDeclaredDependencies.length === 0 &&
+        input.undeclaredActualDependencies.length === 0);
+}
+function getModulesRoot(workspaceRoot, modulesRootRelativePath = 'src/modules') {
+    return path.join(workspaceRoot, ...modulesRootRelativePath.split('/'));
+}
+function getScriptKind(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    switch (extension) {
+        case '.tsx':
+            return ts.ScriptKind.TSX;
+        case '.jsx':
+            return ts.ScriptKind.JSX;
+        case '.js':
+            return ts.ScriptKind.JS;
+        case '.ts':
+        default:
+            return ts.ScriptKind.TS;
+    }
+}
+function usesTypeScriptParser(adapter) {
+    return (adapter.dependencyExtractionStrategyHint === 'typescript-imports' ||
+        adapter.dependencyExtractionStrategyHint === 'js-imports' ||
+        adapter.dependencyExtractionStrategyHint === 'generic');
+}
+function usesJavaImportParser(adapter) {
+    return adapter.dependencyExtractionStrategyHint === 'java-imports';
+}
+function usesCSharpImportParser(adapter) {
+    return adapter.dependencyExtractionStrategyHint === 'csharp-imports';
+}
+function usesPhpImportParser(adapter) {
+    return adapter.dependencyExtractionStrategyHint === 'php-imports';
+}
+function usesGoImportParser(adapter) {
+    return adapter.dependencyExtractionStrategyHint === 'go-imports';
+}
+function usesPythonImportParser(adapter) {
+    return adapter.dependencyExtractionStrategyHint === 'python-imports';
+}
+function supportsDependencyImportParsing(adapter) {
+    return (usesTypeScriptParser(adapter) ||
+        usesJavaImportParser(adapter) ||
+        usesCSharpImportParser(adapter) ||
+        usesPhpImportParser(adapter) ||
+        usesGoImportParser(adapter) ||
+        usesPythonImportParser(adapter));
+}
+async function pathExists(targetPath) {
+    try {
+        await node_fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readTextFileIfExists(filePath) {
+    try {
+        return await node_fs_1.promises.readFile(filePath, { encoding: 'utf8' });
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readPackageName(packageJsonPath) {
+    const contents = await readTextFileIfExists(packageJsonPath);
+    if (!contents) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(contents);
+        return typeof parsed.name === 'string' && parsed.name.trim().length > 0
+            ? parsed.name.trim()
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function collectPackageExportSubpaths(exportsValue) {
+    if (typeof exportsValue === 'string') {
+        return ['.'];
+    }
+    if (!exportsValue || typeof exportsValue !== 'object' || Array.isArray(exportsValue)) {
+        return [];
+    }
+    return Object.keys(exportsValue)
+        .filter((key) => key === '.' || key.startsWith('./'))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function readPackagePublicExportSubpaths(moduleRoot) {
+    const contents = await readTextFileIfExists(path.join(moduleRoot, 'package.json'));
+    if (!contents) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(contents);
+        const exportSubpaths = collectPackageExportSubpaths(parsed.exports);
+        if (exportSubpaths.length > 0) {
+            return exportSubpaths;
+        }
+        return typeof parsed.main === 'string' && parsed.main.trim().length > 0 ? ['.'] : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots) {
+    const aliases = [];
+    for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const packageName = await readPackageName(path.join(moduleRoot, 'package.json'));
+        if (!packageName) {
+            continue;
+        }
+        aliases.push({
+            packageName,
+            moduleId,
+            moduleRoot,
+            targetRoot: await resolvePackageAliasSourceRoot(moduleRoot),
+            publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot),
+        });
+    }
+    aliases.push(...(await buildTsConfigPathAliasMap(workspaceRoot, moduleRoots)));
+    return aliases.sort((left, right) => {
+        const lengthCompare = right.packageName.length - left.packageName.length;
+        if (lengthCompare !== 0) {
+            return lengthCompare;
+        }
+        return left.packageName.localeCompare(right.packageName);
+    });
+}
+async function resolvePackageAliasSourceRoot(moduleRoot) {
+    const sourceRoot = path.join(moduleRoot, 'src');
+    try {
+        const stats = await node_fs_1.promises.stat(sourceRoot);
+        if (stats.isDirectory()) {
+            return sourceRoot;
+        }
+    }
+    catch {
+        // Use the package root when no conventional source folder exists.
+    }
+    return moduleRoot;
+}
+async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
+    const contents = await readTextFileIfExists(path.join(workspaceRoot, 'tsconfig.json'));
+    if (!contents) {
+        return [];
+    }
+    let paths;
+    try {
+        const parsed = JSON.parse(contents);
+        paths = parsed.compilerOptions?.paths;
+    }
+    catch {
+        return [];
+    }
+    if (!paths) {
+        return [];
+    }
+    const aliases = [];
+    for (const [aliasPattern, targetPatterns] of Object.entries(paths).sort(([left], [right]) => left.localeCompare(right))) {
+        if (!Array.isArray(targetPatterns)) {
+            continue;
+        }
+        const aliasPrefix = aliasPattern.replace(/\/\*$/u, '');
+        if (aliasPrefix.length === 0) {
+            continue;
+        }
+        for (const targetPattern of targetPatterns) {
+            if (typeof targetPattern !== 'string' || targetPattern.trim().length === 0) {
+                continue;
+            }
+            const isWildcard = /\/\*$/u.test(aliasPattern) && /\/\*$/u.test(targetPattern);
+            const normalizedTarget = normalizePath(targetPattern).replace(/\/\*$/u, '');
+            const absoluteTarget = path.join(workspaceRoot, ...normalizedTarget.split('/'));
+            const moduleEntry = [...moduleRoots.entries()]
+                .filter(([, moduleRoot]) => isPathInsideOrEqual(absoluteTarget, moduleRoot))
+                .sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
+            if (!moduleEntry) {
+                continue;
+            }
+            const [moduleId, moduleRoot] = moduleEntry;
+            if (isWildcard) {
+                aliases.push({
+                    packageName: aliasPrefix,
+                    moduleId,
+                    moduleRoot,
+                    targetRoot: absoluteTarget,
+                    publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot),
+                });
+                continue;
+            }
+            aliases.push({
+                packageName: aliasPrefix,
+                moduleId,
+                moduleRoot,
+                targetFile: absoluteTarget,
+                publicExportSubpaths: await readPackagePublicExportSubpaths(moduleRoot),
+            });
+        }
+    }
+    return aliases;
+}
+function validateDependencyModuleRules(moduleName, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new DependencyRulesConfigError(`Module "${moduleName}" must be an object in ${dependencyRulesConfigFile}.`);
+    }
+    const typedValue = value;
+    const allowedDependenciesRaw = typedValue.allowedDependencies;
+    const publicEntrypointsOnlyRaw = typedValue.publicEntrypointsOnly;
+    if (allowedDependenciesRaw !== undefined &&
+        (!Array.isArray(allowedDependenciesRaw) ||
+            allowedDependenciesRaw.some((item) => typeof item !== 'string'))) {
+        throw new DependencyRulesConfigError(`Module "${moduleName}" has an invalid allowedDependencies array in ${dependencyRulesConfigFile}.`);
+    }
+    if (publicEntrypointsOnlyRaw !== undefined &&
+        typeof publicEntrypointsOnlyRaw !== 'boolean') {
+        throw new DependencyRulesConfigError(`Module "${moduleName}" has an invalid publicEntrypointsOnly flag in ${dependencyRulesConfigFile}.`);
+    }
+    return {
+        ...(allowedDependenciesRaw !== undefined
+            ? {
+                allowedDependencies: [...allowedDependenciesRaw].sort((a, b) => a.localeCompare(b)),
+            }
+            : {}),
+        ...(publicEntrypointsOnlyRaw !== undefined
+            ? { publicEntrypointsOnly: publicEntrypointsOnlyRaw }
+            : {}),
+    };
+}
+async function readDependencyRulesConfig(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, '.archpilot', 'dependency-rules.json');
+    const contents = await readTextFileIfExists(configPath);
+    if (!contents) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        throw new DependencyRulesConfigError('ArchPilot dependency rules config is invalid JSON. Please fix .archpilot/dependency-rules.json. Continuing without dependency boundary validation.');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new DependencyRulesConfigError('ArchPilot dependency rules config must be a JSON object. Please fix .archpilot/dependency-rules.json. Continuing without dependency boundary validation.');
+    }
+    const modulesRaw = parsed.modules;
+    if (!modulesRaw || typeof modulesRaw !== 'object' || Array.isArray(modulesRaw)) {
+        throw new DependencyRulesConfigError('ArchPilot dependency rules config must define a "modules" object. Please fix .archpilot/dependency-rules.json. Continuing without dependency boundary validation.');
+    }
+    const modules = Object.entries(modulesRaw)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .reduce((acc, [moduleName, value]) => {
+        acc[moduleName] = validateDependencyModuleRules(moduleName, value);
+        return acc;
+    }, {});
+    return { modules };
+}
+async function findModuleRoots(workspaceRoot, modulesRootRelativePath = 'src/modules', architectureContract, options) {
+    const discoveredModuleRoots = await (0, moduleDiscovery_1.discoverModuleRoots)(workspaceRoot, modulesRootRelativePath);
+    const moduleRoots = new Map();
+    const registryEntries = architectureContract?.modules
+        ? Object.entries(architectureContract.modules).sort(([left], [right]) => left.localeCompare(right))
+        : [];
+    const contractCache = new Map();
+    const candidatesByRoot = new Map();
+    for (const [moduleName, moduleReference] of registryEntries) {
+        const configuredPath = moduleReference.path;
+        if (!configuredPath || typeof configuredPath !== 'string') {
+            continue;
+        }
+        const normalizedConfiguredPath = normalizePath(configuredPath);
+        if (/\.[a-z0-9]+$/iu.test(normalizedConfiguredPath)) {
+            continue;
+        }
+        const absolutePath = path.join(workspaceRoot, ...normalizedConfiguredPath.split('/'));
+        try {
+            const stats = await node_fs_1.promises.stat(absolutePath);
+            if (stats.isDirectory()) {
+                const normalizedRoot = normalizeAbsolutePath(absolutePath);
+                const existing = candidatesByRoot.get(normalizedRoot) ?? [];
+                existing.push({ moduleName, absolutePath });
+                candidatesByRoot.set(normalizedRoot, existing);
+            }
+        }
+        catch {
+            // Ignore registry paths that are not present in this checkout.
+        }
+    }
+    for (const candidates of candidatesByRoot.values()) {
+        if (options?.canonicalizeOverlappingPaths === true) {
+            const canonical = architectureContract
+                ? await selectCanonicalModuleRootCandidate(workspaceRoot, architectureContract, candidates, contractCache)
+                : candidates[0];
+            if (canonical) {
+                moduleRoots.set(canonical.moduleName, canonical.absolutePath);
+            }
+            continue;
+        }
+        for (const candidate of candidates) {
+            moduleRoots.set(candidate.moduleName, candidate.absolutePath);
+        }
+    }
+    if (registryEntries.length > 0) {
+        return new Map([...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right)));
+    }
+    const componentModuleRoots = getComponentModuleRoots(workspaceRoot, architectureContract);
+    if (componentModuleRoots.size > 0) {
+        for (const [moduleName, moduleRoot] of componentModuleRoots.entries()) {
+            try {
+                const stats = await node_fs_1.promises.stat(moduleRoot);
+                if (stats.isDirectory()) {
+                    moduleRoots.set(moduleName, moduleRoot);
+                }
+            }
+            catch {
+                // Ignore component paths that are not present in this checkout.
+            }
+        }
+        if (moduleRoots.size > 0) {
+            return new Map([...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right)));
+        }
+    }
+    for (const [moduleName, moduleRoot] of discoveredModuleRoots.entries()) {
+        if (!moduleRoots.has(moduleName)) {
+            moduleRoots.set(moduleName, moduleRoot);
+        }
+    }
+    return new Map([...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+async function selectCanonicalModuleRootCandidate(workspaceRoot, architectureContract, candidates, contractCache) {
+    const scoredCandidates = await Promise.all(candidates.map(async (candidate) => {
+        const contract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, candidate.moduleName, contractCache);
+        const contractDetailScore = contract.status === 'ok' && contract.contract
+            ? contract.contract.dependsOn.length * 8 +
+                contract.contract.ownedTables.length * 3 +
+                contract.contract.exposedApis.length * 3 +
+                contract.contract.publicEntrypoints.length
+            : 0;
+        const shallowNameScore = candidate.moduleName.includes('/') ? 0 : 2;
+        return {
+            candidate,
+            score: contractDetailScore + shallowNameScore,
+        };
+    }));
+    return scoredCandidates
+        .sort((left, right) => {
+        const scoreCompare = right.score - left.score;
+        if (scoreCompare !== 0) {
+            return scoreCompare;
+        }
+        const lengthCompare = left.candidate.moduleName.length - right.candidate.moduleName.length;
+        if (lengthCompare !== 0) {
+            return lengthCompare;
+        }
+        return left.candidate.moduleName.localeCompare(right.candidate.moduleName);
+    })[0]?.candidate;
+}
+async function buildExplicitStandaloneModulePathMap(workspaceRoot, architectureContract) {
+    const moduleRegistry = architectureContract?.modules &&
+        typeof architectureContract.modules === 'object' &&
+        !Array.isArray(architectureContract.modules)
+        ? architectureContract.modules
+        : undefined;
+    if (!moduleRegistry || Object.keys(moduleRegistry).length === 0) {
+        return new Map();
+    }
+    const entries = Object.entries(moduleRegistry)
+        .sort(([left], [right]) => left.localeCompare(right));
+    const map = new Map();
+    for (const [moduleName, moduleReference] of entries) {
+        const configuredPath = moduleReference.path;
+        if (!configuredPath || typeof configuredPath !== 'string') {
+            continue;
+        }
+        const normalizedConfiguredPath = normalizePath(configuredPath);
+        if (!/\.[a-z0-9]+$/iu.test(normalizedConfiguredPath)) {
+            continue;
+        }
+        const absolutePath = path.join(workspaceRoot, ...normalizedConfiguredPath.split('/'));
+        try {
+            const stats = await node_fs_1.promises.stat(absolutePath);
+            if (stats.isFile()) {
+                map.set(normalizedConfiguredPath, moduleName);
+            }
+        }
+        catch {
+            // Ignore missing standalone paths.
+        }
+    }
+    return map;
+}
+function isTestSourcePath(relativePath) {
+    return (0, sourceScopeClassification_1.classifyValidationSourceScope)(relativePath).isTestLike;
+}
+async function collectSourceFiles(directoryPath, adapter, scanRootPath = directoryPath, excludedDirectoryRoots = []) {
+    const entries = await node_fs_1.promises.readdir(directoryPath, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            if (excludedDirectoryRoots.some((excludedRoot) => isPathInsideOrEqual(fullPath, excludedRoot))) {
+                continue;
+            }
+            const normalizedRelativeDirectory = normalizePath(path.relative(scanRootPath, fullPath));
+            if (adapter.ignoreDirectoryNames.includes(entry.name) ||
+                adapter.ignoreDirectoryNames.includes(normalizedRelativeDirectory)) {
+                continue;
+            }
+            files.push(...(await collectSourceFiles(fullPath, adapter, scanRootPath, excludedDirectoryRoots)));
+            continue;
+        }
+        if (entry.isFile() &&
+            adapter.dependencyParsingFileExtensions.includes(path.extname(entry.name).toLowerCase()) &&
+            !entry.name.endsWith('.d.ts')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function extractImportSpecifiers(filePath, sourceText) {
+    const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
+    const imports = [];
+    const visit = (node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            const line = sourceFile.getLineAndCharacterOfPosition(node.moduleSpecifier.getStart(sourceFile)).line + 1;
+            imports.push({
+                specifier: node.moduleSpecifier.text,
+                line,
+            });
+        }
+        if (ts.isCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            ((ts.isIdentifier(node.expression) && node.expression.text === 'require') ||
+                node.expression.kind === ts.SyntaxKind.ImportKeyword)) {
+            const firstArg = node.arguments[0];
+            if (firstArg && ts.isStringLiteral(firstArg)) {
+                const line = sourceFile.getLineAndCharacterOfPosition(firstArg.getStart(sourceFile)).line + 1;
+                imports.push({
+                    specifier: firstArg.text,
+                    line,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+function extractJavaImportSpecifiers(sourceText) {
+    const imports = [];
+    const lines = sourceText.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const match = /^\s*import\s+(?:static\s+)?([a-zA-Z_][\w.]*\*?)\s*;\s*$/u.exec(line);
+        if (!match?.[1]) {
+            continue;
+        }
+        imports.push({
+            specifier: match[1],
+            line: index + 1,
+        });
+    }
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+function extractCSharpImportSpecifiers(sourceText) {
+    const imports = [];
+    const lines = sourceText.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]?.replace(/\/\/.*$/u, '').trim() ?? '';
+        if (line.length === 0) {
+            continue;
+        }
+        const usingMatch = /^(?:global\s+)?using\s+([A-Za-z_][\w.]*)\s*;\s*$/u.exec(line);
+        if (usingMatch?.[1]) {
+            imports.push({
+                specifier: usingMatch[1],
+                line: index + 1,
+            });
+        }
+    }
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+function extractPhpImportSpecifiers(sourceText) {
+    const imports = [];
+    const lines = sourceText.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].replace(/\/\/.*$/u, '').replace(/#.*$/u, '').trim();
+        if (line.length === 0) {
+            continue;
+        }
+        const useMatch = /^\s*use\s+(.+?)\s*;\s*$/iu.exec(line);
+        if (!useMatch?.[1]) {
+            continue;
+        }
+        let clause = useMatch[1].trim();
+        clause = clause.replace(/^(function|const)\s+/iu, '').trim();
+        if (clause.length === 0) {
+            continue;
+        }
+        const groupedMatch = /^([a-zA-Z_\\][\w\\]*)\\\{(.+)\}$/u.exec(clause);
+        if (groupedMatch?.[1] && groupedMatch?.[2]) {
+            const baseNamespace = groupedMatch[1].replace(/^\\+/u, '');
+            for (const groupedEntry of groupedMatch[2].split(',')) {
+                const normalizedGroupedEntry = groupedEntry.trim();
+                if (normalizedGroupedEntry.length === 0) {
+                    continue;
+                }
+                const withoutAlias = normalizedGroupedEntry.split(/\s+as\s+/iu)[0]?.trim();
+                if (!withoutAlias) {
+                    continue;
+                }
+                imports.push({
+                    specifier: `${baseNamespace}\\${withoutAlias}`,
+                    line: index + 1,
+                });
+            }
+            continue;
+        }
+        for (const entry of clause.split(',')) {
+            const normalizedEntry = entry.trim();
+            if (normalizedEntry.length === 0) {
+                continue;
+            }
+            const withoutAlias = normalizedEntry.split(/\s+as\s+/iu)[0]?.trim();
+            if (!withoutAlias) {
+                continue;
+            }
+            imports.push({
+                specifier: withoutAlias.replace(/^\\+/u, ''),
+                line: index + 1,
+            });
+        }
+    }
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+function extractGoImportSpecifiers(sourceText) {
+    const imports = [];
+    const lines = sourceText.split(/\r?\n/u);
+    let inImportBlock = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].replace(/\/\/.*$/u, '').trim();
+        if (line.length === 0) {
+            continue;
+        }
+        if (!inImportBlock) {
+            const singleImportMatch = /^\s*import\s+(?:[._a-zA-Z][\w]*\s+)?["`]([^"`]+)["`]\s*$/u.exec(line);
+            if (singleImportMatch?.[1]) {
+                imports.push({
+                    specifier: singleImportMatch[1],
+                    line: index + 1,
+                });
+                continue;
+            }
+            if (/^\s*import\s*\(\s*$/u.test(line)) {
+                inImportBlock = true;
+            }
+            continue;
+        }
+        if (/^\s*\)\s*$/u.test(line)) {
+            inImportBlock = false;
+            continue;
+        }
+        const groupedImportMatch = /^(?:[._a-zA-Z][\w]*\s+)?["`]([^"`]+)["`]\s*$/u.exec(line);
+        if (!groupedImportMatch?.[1]) {
+            continue;
+        }
+        imports.push({
+            specifier: groupedImportMatch[1],
+            line: index + 1,
+        });
+    }
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+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) {
+    const classes = new Map();
+    const packageCandidates = new Map();
+    for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        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 = normalizePath(path.relative(workspaceRoot, sourceFilePath));
+            if (isTestSourcePath(relativePath)) {
+                continue;
+            }
+            const sourceText = await readTextFileIfExists(sourceFilePath);
+            if (!sourceText) {
+                continue;
+            }
+            const packageName = extractJavaPackageName(sourceText);
+            if (!packageName) {
+                continue;
+            }
+            const className = path.basename(sourceFilePath, path.extname(sourceFilePath));
+            const entry = { moduleId, resolvedPath: sourceFilePath };
+            classes.set(`${packageName}.${className}`, entry);
+            const existing = packageCandidates.get(packageName) ?? [];
+            existing.push(entry);
+            packageCandidates.set(packageName, existing);
+        }
+    }
+    const packages = new Map();
+    for (const [packageName, entries] of packageCandidates) {
+        const moduleIds = new Set(entries.map((entry) => entry.moduleId));
+        packages.set(packageName, moduleIds.size === 1 ? entries[0] : 'ambiguous');
+    }
+    return { classes, packages };
+}
+function resolveJavaImportFromIndex(importSpecifier, index, workspaceRoot) {
+    if (!index) {
+        return undefined;
+    }
+    if (importSpecifier.endsWith('.*')) {
+        const packageName = importSpecifier.slice(0, -2);
+        const entry = index.packages.get(packageName);
+        if (!entry || entry === 'ambiguous') {
+            return undefined;
+        }
+        return {
+            targetModule: entry.moduleId,
+            resolvedRelativePath: normalizePath(path.relative(workspaceRoot, entry.resolvedPath)),
+            isPublicImport: false,
+        };
+    }
+    const exactEntry = index.classes.get(importSpecifier);
+    if (exactEntry) {
+        return {
+            targetModule: exactEntry.moduleId,
+            resolvedRelativePath: normalizePath(path.relative(workspaceRoot, exactEntry.resolvedPath)),
+            isPublicImport: false,
+        };
+    }
+    const ownerCandidate = [...index.classes.entries()]
+        .filter(([classImport]) => importSpecifier.startsWith(`${classImport}.`))
+        .sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]))[0];
+    if (!ownerCandidate) {
+        return undefined;
+    }
+    return {
+        targetModule: ownerCandidate[1].moduleId,
+        resolvedRelativePath: normalizePath(path.relative(workspaceRoot, ownerCandidate[1].resolvedPath)),
+        isPublicImport: false,
+    };
+}
+function extractPythonImportSpecifiers(sourceText) {
+    const imports = [];
+    const lines = sourceText.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].replace(/#.*$/u, '').trim();
+        if (line.length === 0) {
+            continue;
+        }
+        const importMatch = /^import\s+(.+)$/u.exec(line);
+        if (importMatch?.[1]) {
+            for (const clause of importMatch[1].split(',')) {
+                const normalized = clause.trim();
+                if (normalized.length === 0) {
+                    continue;
+                }
+                const withoutAlias = normalized.split(/\s+as\s+/u)[0]?.trim();
+                if (!withoutAlias || withoutAlias.startsWith('.')) {
+                    continue;
+                }
+                imports.push({
+                    specifier: withoutAlias,
+                    line: index + 1,
+                });
+            }
+            continue;
+        }
+        const fromMatch = /^from\s+([a-zA-Z_][\w.]*)\s+import\s+(.+)$/u.exec(line);
+        if (!fromMatch?.[1] || !fromMatch?.[2]) {
+            continue;
+        }
+        const importBase = fromMatch[1].trim();
+        if (importBase.startsWith('.')) {
+            continue;
+        }
+        const importedClauses = fromMatch[2].split(',');
+        if (importedClauses.length === 0) {
+            imports.push({
+                specifier: importBase,
+                line: index + 1,
+            });
+            continue;
+        }
+        for (const importedClause of importedClauses) {
+            const normalized = importedClause.trim();
+            if (normalized.length === 0) {
+                continue;
+            }
+            const withoutAlias = normalized.split(/\s+as\s+/u)[0]?.trim();
+            if (!withoutAlias) {
+                continue;
+            }
+            if (withoutAlias === '*') {
+                imports.push({
+                    specifier: importBase,
+                    line: index + 1,
+                });
+                continue;
+            }
+            imports.push({
+                specifier: `${importBase}.${withoutAlias}`,
+                line: index + 1,
+            });
+        }
+    }
+    return imports.sort((left, right) => {
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.specifier.localeCompare(right.specifier);
+    });
+}
+function extractImportSpecifiersForAdapter(adapter, filePath, sourceText) {
+    if (usesJavaImportParser(adapter)) {
+        return extractJavaImportSpecifiers(sourceText);
+    }
+    if (usesCSharpImportParser(adapter)) {
+        return extractCSharpImportSpecifiers(sourceText);
+    }
+    if (usesPhpImportParser(adapter)) {
+        return extractPhpImportSpecifiers(sourceText);
+    }
+    if (usesGoImportParser(adapter)) {
+        return extractGoImportSpecifiers(sourceText);
+    }
+    if (usesPythonImportParser(adapter)) {
+        return extractPythonImportSpecifiers(sourceText);
+    }
+    return extractImportSpecifiers(filePath, sourceText);
+}
+function resolveJavaModuleImport(modulesRootRelativePath, moduleRoots, importSpecifier, adapter) {
+    const segments = importSpecifier.split('.').filter((segment) => segment.length > 0);
+    if (segments.length < 2) {
+        return undefined;
+    }
+    const targetModule = segments.find((segment) => moduleRoots.has(segment));
+    if (!targetModule) {
+        return undefined;
+    }
+    const lastSegment = segments[segments.length - 1];
+    const defaultEntrypointFileName = adapter.scaffoldingDefaults?.moduleIndexFileName ?? 'Application.java';
+    const resolvedFileName = lastSegment === '*'
+        ? defaultEntrypointFileName
+        : lastSegment.endsWith('.java')
+            ? lastSegment
+            : `${lastSegment}.java`;
+    const resolvedRelativePath = normalizePath(`${modulesRootRelativePath}/${targetModule}/${resolvedFileName}`);
+    return {
+        targetModule,
+        resolvedRelativePath,
+        isPublicImport: resolvedFileName === defaultEntrypointFileName || lastSegment === '*',
+    };
+}
+function findCaseInsensitiveModuleId(moduleRoots, segment) {
+    return [...moduleRoots.keys()].find((moduleName) => moduleName.toLowerCase() === segment.toLowerCase());
+}
+function resolveCSharpModuleImportBasePaths(moduleRoots, importSpecifier, adapter) {
+    const segments = importSpecifier.split('.').filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const targetModuleSegment = segments.find((segment) => findCaseInsensitiveModuleId(moduleRoots, segment));
+    if (!targetModuleSegment) {
+        return undefined;
+    }
+    const targetModule = findCaseInsensitiveModuleId(moduleRoots, targetModuleSegment);
+    if (!targetModule) {
+        return undefined;
+    }
+    const targetModuleRoot = moduleRoots.get(targetModule);
+    if (!targetModuleRoot) {
+        return undefined;
+    }
+    return {
+        targetModule,
+        candidateBasePaths: [
+            path.join(targetModuleRoot, ...segments
+                .slice(segments.indexOf(targetModuleSegment) + 1)
+                .filter((segment) => segment.length > 0)),
+            targetModuleRoot,
+        ],
+    };
+}
+function resolvePythonModuleImportBasePaths(moduleRoots, importSpecifier, adapter) {
+    const segments = importSpecifier.split('.').filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const targetModuleSegment = segments.find((segment) => findCaseInsensitiveModuleId(moduleRoots, segment));
+    if (!targetModuleSegment) {
+        return undefined;
+    }
+    const targetModule = findCaseInsensitiveModuleId(moduleRoots, targetModuleSegment);
+    if (!targetModule) {
+        return undefined;
+    }
+    const targetModuleRoot = moduleRoots.get(targetModule);
+    if (!targetModuleRoot) {
+        return undefined;
+    }
+    const remainder = segments.slice(segments.indexOf(targetModuleSegment) + 1).filter((segment) => segment.length > 0);
+    const candidateBasePaths = remainder.length === 0
+        ? [targetModuleRoot]
+        : [
+            path.join(targetModuleRoot, ...remainder),
+            ...(remainder.length > 1 ? [path.join(targetModuleRoot, ...remainder.slice(0, -1))] : []),
+            targetModuleRoot,
+        ];
+    return {
+        targetModule,
+        candidateBasePaths,
+    };
+}
+function resolvePhpModuleImportBasePaths(moduleRoots, importSpecifier, adapter) {
+    const segments = importSpecifier
+        .split('\\')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return undefined;
+    }
+    if (adapter.id === 'laravel' && segments[0] !== 'App') {
+        return undefined;
+    }
+    const targetModuleSegment = segments.find((segment) => findCaseInsensitiveModuleId(moduleRoots, segment));
+    if (!targetModuleSegment) {
+        return undefined;
+    }
+    const targetModule = findCaseInsensitiveModuleId(moduleRoots, targetModuleSegment);
+    if (!targetModule) {
+        return undefined;
+    }
+    const targetModuleRoot = moduleRoots.get(targetModule);
+    if (!targetModuleRoot) {
+        return undefined;
+    }
+    const remainder = segments.slice(segments.indexOf(targetModuleSegment) + 1).filter((segment) => segment.length > 0);
+    return {
+        targetModule,
+        candidateBasePaths: remainder.length === 0
+            ? [targetModuleRoot]
+            : [path.join(targetModuleRoot, ...remainder), targetModuleRoot],
+    };
+}
+function resolveGoModuleImportBasePaths(moduleRoots, importSpecifier, adapter) {
+    const segments = importSpecifier
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const targetModuleSegment = segments.find((segment) => findCaseInsensitiveModuleId(moduleRoots, segment));
+    if (!targetModuleSegment) {
+        return undefined;
+    }
+    const targetModule = findCaseInsensitiveModuleId(moduleRoots, targetModuleSegment);
+    if (!targetModule) {
+        return undefined;
+    }
+    const targetModuleRoot = moduleRoots.get(targetModule);
+    if (!targetModuleRoot) {
+        return undefined;
+    }
+    const remainder = segments.slice(segments.indexOf(targetModuleSegment) + 1).filter((segment) => segment.length > 0);
+    return {
+        targetModule,
+        candidateBasePaths: remainder.length === 0
+            ? [targetModuleRoot]
+            : [path.join(targetModuleRoot, ...remainder), targetModuleRoot],
+    };
+}
+async function resolveImportPath(basePath, adapter) {
+    const relevantExtensions = [...new Set(adapter.dependencyParsingFileExtensions)];
+    const moduleIndexFileName = adapter.scaffoldingDefaults?.moduleIndexFileName;
+    const candidates = [
+        basePath,
+        ...relevantExtensions.map((extension) => `${basePath}${extension}`),
+        ...relevantExtensions.map((extension) => path.join(basePath, `index${extension}`)),
+        ...(moduleIndexFileName ? [path.join(basePath, moduleIndexFileName)] : []),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const stats = await node_fs_1.promises.stat(candidate);
+            if (stats.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Ignore resolution misses and continue to the next candidate.
+        }
+    }
+    return undefined;
+}
+function buildAdapterResolutionKey(adapter) {
+    return [
+        adapter.id,
+        [...new Set(adapter.dependencyParsingFileExtensions)].join(','),
+        adapter.scaffoldingDefaults?.moduleIndexFileName ?? '',
+    ].join('|');
+}
+function buildWorkspacePackageAliasKey(workspacePackageAliases) {
+    return workspacePackageAliases
+        .map((alias) => [
+        alias.packageName,
+        normalizeAbsolutePath(alias.moduleRoot),
+        alias.targetRoot ? normalizeAbsolutePath(alias.targetRoot) : '',
+        alias.targetFile ? normalizeAbsolutePath(alias.targetFile) : '',
+        alias.publicExportSubpaths?.join(',') ?? '',
+        alias.moduleId,
+    ].join(':'))
+        .sort((left, right) => left.localeCompare(right))
+        .join('|');
+}
+function createDependencyGraphResolutionContext() {
+    const resolveImportPathCache = new Map();
+    const workspacePackageCache = new Map();
+    const fileStatCache = new Map();
+    const stats = {
+        resolveImportPathCalls: 0,
+        resolveImportPathCacheHits: 0,
+        resolveImportPathCacheMisses: 0,
+        resolveImportPathCacheEntries: 0,
+        workspacePackageResolutionCalls: 0,
+        workspacePackageResolutionCacheHits: 0,
+        workspacePackageResolutionCacheMisses: 0,
+        workspacePackageResolutionCacheEntries: 0,
+        underlyingStatProbes: 0,
+        statCacheHits: 0,
+        statMisses: 0,
+        negativeResolutionCacheHits: 0,
+        resolveImportPathTimeMs: 0,
+        workspacePackageResolutionTimeMs: 0,
+        statProbeTimeMs: 0,
+    };
+    const isFile = (candidatePath) => {
+        const key = normalizeAbsolutePath(candidatePath);
+        const cached = fileStatCache.get(key);
+        if (cached) {
+            stats.statCacheHits += 1;
+            return cached;
+        }
+        stats.underlyingStatProbes += 1;
+        const started = Date.now();
+        const statPromise = node_fs_1.promises.stat(candidatePath)
+            .then((candidateStats) => candidateStats.isFile())
+            .catch(() => {
+            stats.statMisses += 1;
+            return false;
+        })
+            .finally(() => {
+            stats.statProbeTimeMs += Date.now() - started;
+        });
+        fileStatCache.set(key, statPromise);
+        return statPromise;
+    };
+    const resolvePath = async (basePath, adapter) => {
+        const relevantExtensions = [...new Set(adapter.dependencyParsingFileExtensions)];
+        const moduleIndexFileName = adapter.scaffoldingDefaults?.moduleIndexFileName;
+        const candidates = [
+            basePath,
+            ...relevantExtensions.map((extension) => `${basePath}${extension}`),
+            ...relevantExtensions.map((extension) => path.join(basePath, `index${extension}`)),
+            ...(moduleIndexFileName ? [path.join(basePath, moduleIndexFileName)] : []),
+        ];
+        for (const candidate of candidates) {
+            if (await isFile(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    };
+    const context = {
+        resolveImportPath(basePath, adapter) {
+            stats.resolveImportPathCalls += 1;
+            const started = Date.now();
+            const key = `${normalizeAbsolutePath(basePath)}|${buildAdapterResolutionKey(adapter)}`;
+            const cached = resolveImportPathCache.get(key);
+            if (cached) {
+                stats.resolveImportPathCacheHits += 1;
+                return cached.then((resolvedPath) => {
+                    if (!resolvedPath) {
+                        stats.negativeResolutionCacheHits += 1;
+                    }
+                    stats.resolveImportPathTimeMs += Date.now() - started;
+                    return resolvedPath;
+                });
+            }
+            stats.resolveImportPathCacheMisses += 1;
+            const resolutionPromise = resolvePath(basePath, adapter);
+            resolveImportPathCache.set(key, resolutionPromise);
+            stats.resolveImportPathCacheEntries = resolveImportPathCache.size;
+            return resolutionPromise.finally(() => {
+                stats.resolveImportPathTimeMs += Date.now() - started;
+            });
+        },
+        resolveWorkspacePackageImportTarget(importSpecifier, workspacePackageAliases, adapter) {
+            stats.workspacePackageResolutionCalls += 1;
+            const started = Date.now();
+            const key = [
+                importSpecifier,
+                buildAdapterResolutionKey(adapter),
+                buildWorkspacePackageAliasKey(workspacePackageAliases),
+            ].join('|');
+            const cached = workspacePackageCache.get(key);
+            if (cached) {
+                stats.workspacePackageResolutionCacheHits += 1;
+                return cached.finally(() => {
+                    stats.workspacePackageResolutionTimeMs += Date.now() - started;
+                });
+            }
+            stats.workspacePackageResolutionCacheMisses += 1;
+            const resolutionPromise = resolveWorkspacePackageImportTarget(importSpecifier, workspacePackageAliases, adapter, context);
+            workspacePackageCache.set(key, resolutionPromise);
+            stats.workspacePackageResolutionCacheEntries = workspacePackageCache.size;
+            return resolutionPromise.finally(() => {
+                stats.workspacePackageResolutionTimeMs += Date.now() - started;
+            });
+        },
+        getStats() {
+            return { ...stats };
+        },
+    };
+    return context;
+}
+function resolvePackageAliasRemainder(packageName, importSpecifier) {
+    if (importSpecifier === packageName) {
+        return '';
+    }
+    if (importSpecifier.startsWith(`${packageName}/`)) {
+        return importSpecifier.slice(packageName.length + 1);
+    }
+    return undefined;
+}
+function packageExportPatternMatches(pattern, subpath) {
+    if (!pattern.includes('*')) {
+        return pattern === subpath;
+    }
+    const [prefix, suffix = ''] = pattern.split('*', 2);
+    return subpath.startsWith(prefix) && subpath.endsWith(suffix);
+}
+function isImportSpecifierPackageExport(alias, importSpecifier) {
+    const remainder = resolvePackageAliasRemainder(alias.packageName, importSpecifier);
+    if (remainder === undefined) {
+        return false;
+    }
+    const exportSubpaths = alias.publicExportSubpaths ?? [];
+    if (exportSubpaths.length === 0) {
+        return false;
+    }
+    const importSubpath = remainder.length === 0 ? '.' : `./${remainder}`;
+    return exportSubpaths.some((exportSubpath) => packageExportPatternMatches(exportSubpath, importSubpath));
+}
+async function resolveWorkspacePackageImportTarget(importSpecifier, workspacePackageAliases, adapter, resolutionContext) {
+    const packageAlias = workspacePackageAliases
+        .map((alias) => ({
+        alias,
+        remainder: resolvePackageAliasRemainder(alias.packageName, importSpecifier),
+    }))
+        .sort((left, right) => {
+        const leftCanResolveRemainder = left.remainder !== undefined &&
+            left.remainder.length > 0 &&
+            left.alias.targetRoot !== undefined;
+        const rightCanResolveRemainder = right.remainder !== undefined &&
+            right.remainder.length > 0 &&
+            right.alias.targetRoot !== undefined;
+        if (leftCanResolveRemainder !== rightCanResolveRemainder) {
+            return leftCanResolveRemainder ? -1 : 1;
+        }
+        return 0;
+    })
+        .find((candidate) => candidate.remainder !== undefined);
+    if (!packageAlias) {
+        return undefined;
+    }
+    const { alias, remainder } = packageAlias;
+    if (remainder.length === 0) {
+        const resolvePath = resolutionContext?.resolveImportPath.bind(resolutionContext) ?? resolveImportPath;
+        const resolvedPath = await resolvePath(alias.targetFile ?? alias.moduleRoot, adapter) ??
+            (alias.targetRoot && alias.targetRoot !== alias.moduleRoot
+                ? await resolvePath(alias.targetRoot, adapter)
+                : undefined);
+        return resolvedPath
+            ? {
+                alias,
+                resolvedPath,
+                isPublicPackageImport: isImportSpecifierPackageExport(alias, importSpecifier),
+            }
+            : undefined;
+    }
+    if (alias.targetRoot) {
+        const resolvePath = resolutionContext?.resolveImportPath.bind(resolutionContext) ?? resolveImportPath;
+        const resolvedPath = await resolvePath(path.join(alias.targetRoot, ...remainder.split('/').filter((segment) => segment.length > 0)), adapter);
+        return resolvedPath
+            ? {
+                alias,
+                resolvedPath,
+                isPublicPackageImport: isImportSpecifierPackageExport(alias, importSpecifier),
+            }
+            : undefined;
+    }
+    return undefined;
+}
+async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importSpecifier, adapter, javaImportIndex, resolutionContext) {
+    const candidateBasePaths = [];
+    let packageAliasTargetModule;
+    let packageAliasTargetModuleRoot;
+    let isPublicPackageAliasImport = false;
+    const normalizedModulesRoot = normalizePath(modulesRootRelativePath).replace(/^\/+/, '');
+    if (usesJavaImportParser(adapter) && !importSpecifier.startsWith('.')) {
+        const indexedJava = resolveJavaImportFromIndex(importSpecifier, javaImportIndex, workspaceRoot);
+        if (indexedJava) {
+            return indexedJava;
+        }
+        const resolvedJava = resolveJavaModuleImport(normalizedModulesRoot, moduleRoots, importSpecifier, adapter);
+        if (resolvedJava) {
+            return resolvedJava;
+        }
+    }
+    if (usesCSharpImportParser(adapter) && !importSpecifier.startsWith('.')) {
+        const resolvedCSharp = resolveCSharpModuleImportBasePaths(moduleRoots, importSpecifier, adapter);
+        if (resolvedCSharp) {
+            candidateBasePaths.push(...resolvedCSharp.candidateBasePaths);
+        }
+    }
+    if (usesPhpImportParser(adapter)) {
+        const resolvedPhp = resolvePhpModuleImportBasePaths(moduleRoots, importSpecifier, adapter);
+        if (resolvedPhp) {
+            candidateBasePaths.push(...resolvedPhp.candidateBasePaths);
+        }
+    }
+    if (usesGoImportParser(adapter)) {
+        const resolvedGo = resolveGoModuleImportBasePaths(moduleRoots, importSpecifier, adapter);
+        if (resolvedGo) {
+            candidateBasePaths.push(...resolvedGo.candidateBasePaths);
+        }
+    }
+    if (usesPythonImportParser(adapter) && !importSpecifier.startsWith('.')) {
+        const resolvedPython = resolvePythonModuleImportBasePaths(moduleRoots, importSpecifier, adapter);
+        if (resolvedPython) {
+            candidateBasePaths.push(...resolvedPython.candidateBasePaths);
+        }
+    }
+    if (importSpecifier.startsWith('.')) {
+        candidateBasePaths.push(path.resolve(path.dirname(sourceFilePath), importSpecifier));
+    }
+    else if (importSpecifier.startsWith(`${normalizedModulesRoot}/`)) {
+        candidateBasePaths.push(path.join(workspaceRoot, importSpecifier));
+    }
+    else if (importSpecifier.startsWith(`/${normalizedModulesRoot}/`)) {
+        candidateBasePaths.push(path.join(workspaceRoot, importSpecifier.slice(1)));
+    }
+    else if (normalizedModulesRoot.startsWith('src/') &&
+        importSpecifier.startsWith(`${normalizedModulesRoot.slice('src/'.length)}/`)) {
+        candidateBasePaths.push(path.join(workspaceRoot, 'src', importSpecifier));
+    }
+    else {
+        const resolveWorkspacePackageTarget = resolutionContext?.resolveWorkspacePackageImportTarget.bind(resolutionContext) ??
+            resolveWorkspacePackageImportTarget;
+        const workspacePackageImportTarget = await resolveWorkspacePackageTarget(importSpecifier, workspacePackageAliases, adapter);
+        if (workspacePackageImportTarget) {
+            candidateBasePaths.push(workspacePackageImportTarget.resolvedPath);
+            packageAliasTargetModule = workspacePackageImportTarget.alias.moduleId;
+            packageAliasTargetModuleRoot = workspacePackageImportTarget.alias.moduleRoot;
+            isPublicPackageAliasImport = workspacePackageImportTarget.isPublicPackageImport;
+        }
+        else {
+            const moduleImportTarget = [...moduleRoots.entries()]
+                .filter(([moduleId]) => importSpecifier === moduleId || importSpecifier.startsWith(`${moduleId}/`))
+                .sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]))[0];
+            if (moduleImportTarget) {
+                const [moduleId, moduleRoot] = moduleImportTarget;
+                const remainder = importSpecifier === moduleId ? '' : importSpecifier.slice(moduleId.length + 1);
+                candidateBasePaths.push(path.join(moduleRoot, ...remainder.split('/').filter((segment) => segment.length > 0)));
+            }
+        }
+    }
+    if (candidateBasePaths.length === 0) {
+        return undefined;
+    }
+    let resolvedPath;
+    const resolvePath = resolutionContext?.resolveImportPath.bind(resolutionContext) ?? resolveImportPath;
+    for (const candidateBasePath of candidateBasePaths) {
+        resolvedPath = await resolvePath(candidateBasePath, adapter);
+        if (resolvedPath) {
+            break;
+        }
+    }
+    if (!resolvedPath) {
+        return undefined;
+    }
+    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(normalizePath(path.relative(workspaceRoot, resolvedPath)));
+        if (!standaloneTargetModule) {
+            return undefined;
+        }
+        return {
+            targetModule: standaloneTargetModule,
+            resolvedRelativePath: normalizePath(path.relative(workspaceRoot, resolvedPath)),
+            isPublicImport: true,
+        };
+    }
+    const [targetModule, targetModuleRoot] = targetModuleEntry;
+    const targetSubPath = normalizePath(path.relative(targetModuleRoot, resolvedPath));
+    if (targetSubPath === '' || targetSubPath.startsWith('../') || targetSubPath.startsWith('..\\')) {
+        return undefined;
+    }
+    const indexEntrypointCandidates = adapter.dependencyParsingFileExtensions.map((extension) => `index${extension}`);
+    const adapterModuleEntrypoint = adapter.scaffoldingDefaults?.moduleIndexFileName;
+    const nestedIndexEntrypointCandidates = adapter.dependencyParsingFileExtensions.flatMap((extension) => [`src/index${extension}`, `public/index${extension}`]);
+    const isPublicImport = isPublicPackageAliasImport ||
+        (adapterModuleEntrypoint !== undefined && targetSubPath === adapterModuleEntrypoint) ||
+        indexEntrypointCandidates.includes(targetSubPath) ||
+        nestedIndexEntrypointCandidates.includes(targetSubPath) ||
+        adapter.publicEntrypointDirectoryNames.some((dirName) => targetSubPath.startsWith(`${dirName}/`));
+    return {
+        targetModule,
+        resolvedRelativePath: normalizePath(path.relative(workspaceRoot, resolvedPath)),
+        isPublicImport,
+        ...(isPublicPackageAliasImport ? { isPackagePublicImport: true } : {}),
+    };
+}
+async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter, options) {
+    const imports = [];
+    const includeTestFiles = options?.includeTestFiles === true;
+    if (!supportsDependencyImportParsing(adapter)) {
+        return imports;
+    }
+    const javaImportIndex = usesJavaImportParser(adapter)
+        ? await buildJavaImportIndex(workspaceRoot, moduleRoots, adapter)
+        : undefined;
+    for (const [moduleName, moduleRoot] of [...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const childModuleRoots = [...moduleRoots.entries()]
+            .filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual(childModuleRoot, moduleRoot))
+            .map(([, childModuleRoot]) => childModuleRoot);
+        const sourceFiles = await collectSourceFiles(moduleRoot, adapter, moduleRoot, childModuleRoots);
+        for (const sourceFilePath of sourceFiles) {
+            const sourceFileRelativePath = normalizePath(path.relative(workspaceRoot, sourceFilePath));
+            if (!includeTestFiles && isTestSourcePath(sourceFileRelativePath)) {
+                continue;
+            }
+            const sourceText = await readTextFileIfExists(sourceFilePath);
+            if (!sourceText) {
+                continue;
+            }
+            const importSpecifiers = extractImportSpecifiersForAdapter(adapter, sourceFilePath, sourceText);
+            for (const importReference of importSpecifiers) {
+                const resolved = await resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importReference.specifier, adapter, javaImportIndex, options?.resolutionContext);
+                if (!resolved || resolved.targetModule === moduleName) {
+                    continue;
+                }
+                imports.push({
+                    sourceModule: moduleName,
+                    sourceFileRelativePath,
+                    importSpecifier: importReference.specifier,
+                    line: importReference.line,
+                    targetModule: resolved.targetModule,
+                    isPublicImport: resolved.isPublicImport,
+                    ...(resolved.isPackagePublicImport ? { isPackagePublicImport: true } : {}),
+                    resolvedTargetRelativePath: resolved.resolvedRelativePath,
+                });
+            }
+        }
+    }
+    return imports.sort((left, right) => {
+        const fileCompare = left.sourceFileRelativePath.localeCompare(right.sourceFileRelativePath);
+        if (fileCompare !== 0) {
+            return fileCompare;
+        }
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        const sourceCompare = left.sourceModule.localeCompare(right.sourceModule);
+        if (sourceCompare !== 0) {
+            return sourceCompare;
+        }
+        return left.targetModule.localeCompare(right.targetModule);
+    });
+}
+function canonicalizeCycle(cycle) {
+    const uniqueNodes = cycle.slice(0, -1);
+    const rotations = uniqueNodes.map((_, index) => {
+        const rotated = [...uniqueNodes.slice(index), ...uniqueNodes.slice(0, index)];
+        return `${rotated.join('->')}->${rotated[0]}`;
+    });
+    return rotations.sort((left, right) => left.localeCompare(right))[0];
+}
+function detectCircularDependencies(moduleNames, imports) {
+    const adjacency = new Map();
+    for (const moduleName of moduleNames) {
+        adjacency.set(moduleName, []);
+    }
+    for (const dependencyImport of imports) {
+        const neighbors = adjacency.get(dependencyImport.sourceModule) ?? [];
+        if (!neighbors.includes(dependencyImport.targetModule)) {
+            neighbors.push(dependencyImport.targetModule);
+            neighbors.sort((left, right) => left.localeCompare(right));
+            adjacency.set(dependencyImport.sourceModule, neighbors);
+        }
+    }
+    const cycles = new Set();
+    const visited = new Set();
+    const stack = [];
+    const visit = (moduleName) => {
+        visited.add(moduleName);
+        stack.push(moduleName);
+        for (const neighbor of adjacency.get(moduleName) ?? []) {
+            const stackIndex = stack.indexOf(neighbor);
+            if (stackIndex !== -1) {
+                const cycle = [...stack.slice(stackIndex), neighbor];
+                cycles.add(canonicalizeCycle(cycle));
+                continue;
+            }
+            if (!visited.has(neighbor)) {
+                visit(neighbor);
+            }
+        }
+        stack.pop();
+    };
+    for (const moduleName of [...moduleNames].sort((left, right) => left.localeCompare(right))) {
+        if (!visited.has(moduleName)) {
+            visit(moduleName);
+        }
+    }
+    return [...cycles].sort((left, right) => left.localeCompare(right));
+}
+function makeValidationResult(id, severity, passed, message, scope) {
+    return {
+        id,
+        severity,
+        passed,
+        message,
+        ...(scope ?? {}),
+    };
+}
+function toDependencyContextMetadata(context) {
+    return {
+        dependencyType: context.dependencyType,
+        sourceComponentId: context.source.componentId,
+        sourceComponentName: context.source.componentName,
+        targetComponentId: context.target?.componentId ?? null,
+        targetComponentName: context.target?.componentName ?? null,
+        importSpecifier: context.importSpecifier,
+        resolvedTargetPath: context.resolvedTargetPath ?? null,
+        isExternal: context.isExternal,
+    };
+}
+function resolveImportDependencyContextMetadata(architectureContract, dependencyImport, resolver = (0, architectureDependencyContext_1.createArchitectureDependencyContextResolver)(architectureContract)) {
+    const directContext = resolver.resolve({
+        sourceFile: dependencyImport.sourceFileRelativePath,
+        importSpecifier: dependencyImport.importSpecifier,
+    });
+    if (!directContext.isExternal) {
+        return toDependencyContextMetadata(directContext);
+    }
+    const moduleTargetContext = resolver.resolve({
+        sourceFile: dependencyImport.sourceFileRelativePath,
+        importSpecifier: dependencyImport.targetModule,
+    });
+    if (!moduleTargetContext.isExternal) {
+        return toDependencyContextMetadata({
+            ...moduleTargetContext,
+            importSpecifier: dependencyImport.importSpecifier,
+            resolvedTargetPath: dependencyImport.resolvedTargetRelativePath,
+        });
+    }
+    const resolvedPathContext = resolver.resolve({
+        sourceFile: dependencyImport.sourceFileRelativePath,
+        importSpecifier: dependencyImport.resolvedTargetRelativePath,
+    });
+    return toDependencyContextMetadata(resolvedPathContext.isExternal
+        ? directContext
+        : {
+            ...resolvedPathContext,
+            importSpecifier: dependencyImport.importSpecifier,
+            resolvedTargetPath: dependencyImport.resolvedTargetRelativePath,
+        });
+}
+function buildComponentDependencyPolicyMap(architectureContract) {
+    if (!architectureContract?.components || Object.keys(architectureContract.components).length === 0) {
+        return new Map();
+    }
+    const entries = Array.isArray(architectureContract.components)
+        ? architectureContract.components.map((component, index) => [
+            component.id ?? `component-${index + 1}`,
+            component,
+        ])
+        : Object.entries(architectureContract.components).sort(([left], [right]) => left.localeCompare(right));
+    const policies = new Map();
+    for (const [componentId, component] of entries) {
+        if (component.allowedDependencies === undefined) {
+            continue;
+        }
+        policies.set(componentId, [...component.allowedDependencies].sort((left, right) => left.localeCompare(right)));
+    }
+    return policies;
+}
+function validateComponentDependencyPolicies(architectureContract, imports) {
+    const policies = buildComponentDependencyPolicyMap(architectureContract);
+    if (!architectureContract || policies.size === 0) {
+        return [];
+    }
+    const dependencyContextResolver = (0, architectureDependencyContext_1.createArchitectureDependencyContextResolver)(architectureContract);
+    const findings = [];
+    for (const dependencyImport of imports) {
+        const dependencyMetadata = resolveImportDependencyContextMetadata(architectureContract, dependencyImport, dependencyContextResolver);
+        if (dependencyMetadata.dependencyType !== 'cross-component' ||
+            dependencyMetadata.isExternal ||
+            !dependencyMetadata.sourceComponentId ||
+            !dependencyMetadata.targetComponentId) {
+            continue;
+        }
+        const allowedDependencies = policies.get(dependencyMetadata.sourceComponentId);
+        if (allowedDependencies === undefined) {
+            continue;
+        }
+        if (allowedDependencies.includes(dependencyMetadata.targetComponentId)) {
+            continue;
+        }
+        findings.push({
+            result: makeValidationResult('AP-DEP-011', 'error', false, 'Disallowed cross-component dependency', {
+                findingType: 'module-dependency',
+                module: dependencyImport.sourceModule,
+                target: dependencyImport.targetModule,
+                ...dependencyMetadata,
+            }),
+            filePath: dependencyImport.sourceFileRelativePath,
+            line: dependencyImport.line,
+            importSpecifier: dependencyImport.importSpecifier,
+            findingType: 'module-dependency',
+            module: dependencyImport.sourceModule,
+            target: dependencyImport.targetModule,
+            ...dependencyMetadata,
+        });
+    }
+    return findings;
+}
+function isModuleScopedDependencyImport(architectureContract, dependencyImport, resolver) {
+    if (dependencyImport.sourceModule === dependencyImport.targetModule ||
+        isParentChildModuleRelationship(dependencyImport.sourceModule, dependencyImport.targetModule)) {
+        return false;
+    }
+    if (!architectureContract) {
+        return true;
+    }
+    const dependencyMetadata = resolveImportDependencyContextMetadata(architectureContract, dependencyImport, resolver);
+    // Module and component boundaries are independent axes. A real cross-module
+    // import can also be cross-component, and must still count for module contracts.
+    return !dependencyMetadata.isExternal;
+}
+function buildDependencyConfigSkippedFindings(reason, options) {
+    const findings = [];
+    if (options.checkForbiddenDependencies) {
+        findings.push({
+            result: makeValidationResult('AP-DEP-002', 'info', false, `Forbidden cross-module dependency validation skipped: ${reason}`),
+        });
+    }
+    if (options.checkNonPublicImports) {
+        findings.push({
+            result: makeValidationResult('AP-DEP-003', 'info', false, `Non-public cross-module import validation skipped: ${reason}`),
+        });
+    }
+    return findings;
+}
+function normalizePathList(values) {
+    return values.map((value) => normalizePath(value)).sort((left, right) => left.localeCompare(right));
+}
+function normalizeModuleContract(contractLike) {
+    if (typeof contractLike.module !== 'string') {
+        return undefined;
+    }
+    const dependsOn = Array.isArray(contractLike.dependsOn)
+        ? contractLike.dependsOn.filter((item) => typeof item === 'string')
+        : [];
+    const publicEntrypoints = Array.isArray(contractLike.publicEntrypoints)
+        ? contractLike.publicEntrypoints.filter((item) => typeof item === 'string')
+        : [];
+    const ownedTables = Array.isArray(contractLike.ownedTables)
+        ? contractLike.ownedTables.filter((item) => typeof item === 'string')
+        : [];
+    const exposedApis = Array.isArray(contractLike.exposedApis)
+        ? contractLike.exposedApis.filter((item) => typeof item === 'string')
+        : [];
+    if (dependsOn.length !== (contractLike.dependsOn?.length ?? 0) ||
+        publicEntrypoints.length !== (contractLike.publicEntrypoints?.length ?? 0) ||
+        ownedTables.length !== (contractLike.ownedTables?.length ?? 0) ||
+        exposedApis.length !== (contractLike.exposedApis?.length ?? 0)) {
+        return undefined;
+    }
+    return {
+        module: contractLike.module,
+        dependsOn,
+        publicEntrypoints,
+        ownedTables,
+        exposedApis,
+    };
+}
+async function loadModuleArchitectureContract(workspaceRoot, architectureContract, moduleName, cache) {
+    const cached = cache.get(moduleName);
+    if (cached) {
+        return cached;
+    }
+    const registryEntry = architectureContract.modules[moduleName];
+    const contractPath = registryEntry?.contract ??
+        path.posix.join((0, moduleDiscovery_1.resolveContractsRootFromContract)(architectureContract), `${toSafeContractModuleFileStem(moduleName)}.contract.json`);
+    const fullContractPath = path.join(workspaceRoot, ...contractPath.split('/'));
+    const content = await readTextFileIfExists(fullContractPath);
+    if (!content) {
+        const missingResult = {
+            status: 'missing',
+            contractPath,
+            reason: 'missing_file',
+        };
+        cache.set(moduleName, missingResult);
+        return missingResult;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        const normalized = normalizeModuleContract(parsed);
+        if (!normalized) {
+            const invalidResult = {
+                status: 'invalid',
+                contractPath,
+                reason: 'invalid_shape',
+            };
+            cache.set(moduleName, invalidResult);
+            return invalidResult;
+        }
+        const okResult = {
+            status: 'ok',
+            contract: normalized,
+            contractPath,
+        };
+        cache.set(moduleName, okResult);
+        return okResult;
+    }
+    catch {
+        const invalidResult = {
+            status: 'invalid',
+            contractPath,
+            reason: 'invalid_json',
+        };
+        cache.set(moduleName, invalidResult);
+        return invalidResult;
+    }
+}
+function describeModuleContractStatus(role, moduleName, loadResult) {
+    const contractLocation = loadResult.contractPath ??
+        (loadResult.reason === 'missing_reference'
+            ? 'no contract path is registered in architecture.json'
+            : 'unknown path');
+    if (loadResult.status === 'missing') {
+        return `${role} module contract for '${moduleName}' is missing (${contractLocation})`;
+    }
+    return `${role} module contract for '${moduleName}' is invalid (${contractLocation})`;
+}
+function buildContractSkipMessage(ruleId, sourceModule, targetModule, sourceContract, targetContract) {
+    const ruleLabel = ruleId === 'AP-DEP-004'
+        ? 'Dependency declaration validation'
+        : 'Public surface validation';
+    const sourceUnavailable = sourceContract.status !== 'ok';
+    const targetUnavailable = targetContract.status !== 'ok';
+    if (sourceUnavailable && targetUnavailable) {
+        return `${ruleLabel} skipped for ${ruleId} because ${describeModuleContractStatus('source', sourceModule, sourceContract)} and ${describeModuleContractStatus('target', targetModule, targetContract)}.`;
+    }
+    if (sourceUnavailable) {
+        return `${ruleLabel} skipped for ${ruleId} because ${describeModuleContractStatus('source', sourceModule, sourceContract)}.`;
+    }
+    return `${ruleLabel} skipped for ${ruleId} because ${describeModuleContractStatus('target', targetModule, targetContract)}.`;
+}
+function isImportWithinPublicEntrypoints(resolvedTargetRelativePath, publicEntrypoints) {
+    const normalizedTargetPath = normalizePath(resolvedTargetRelativePath);
+    for (const publicEntrypoint of normalizePathList(publicEntrypoints)) {
+        const isFileEntrypoint = /\.[a-z0-9]+$/iu.test(publicEntrypoint);
+        if (isFileEntrypoint && normalizedTargetPath === publicEntrypoint) {
+            return true;
+        }
+        if (!isFileEntrypoint) {
+            if (normalizedTargetPath === publicEntrypoint ||
+                normalizedTargetPath.startsWith(`${publicEntrypoint}/`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+async function filterExistingPublicEntrypoints(workspaceRoot, publicEntrypoints) {
+    const existingEntrypoints = [];
+    for (const publicEntrypoint of normalizePathList([...publicEntrypoints])) {
+        const absolutePath = path.join(workspaceRoot, ...publicEntrypoint.split('/'));
+        if (await pathExists(absolutePath)) {
+            existingEntrypoints.push(publicEntrypoint);
+        }
+    }
+    return existingEntrypoints;
+}
+async function inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, moduleRoot) {
+    if (!moduleRoot) {
+        return [];
+    }
+    const candidateSubpaths = [
+        'index.ts',
+        'index.tsx',
+        'index.js',
+        'index.jsx',
+        'src/index.ts',
+        'src/index.tsx',
+        'src/index.js',
+        'src/index.jsx',
+        'public/index.ts',
+        'public/index.tsx',
+        'public/index.js',
+        'public/index.jsx',
+    ];
+    const existingEntrypoints = [];
+    for (const candidateSubpath of candidateSubpaths) {
+        const candidatePath = path.join(moduleRoot, ...candidateSubpath.split('/'));
+        if (await pathExists(candidatePath)) {
+            existingEntrypoints.push(normalizePath(path.relative(workspaceRoot, candidatePath)));
+        }
+    }
+    return existingEntrypoints.sort((left, right) => left.localeCompare(right));
+}
+async function resolveModulePublicEntrypoints(workspaceRoot, architectureContract, moduleName, targetContract, moduleRoots) {
+    const registryPublicEntrypoints = architectureContract.modules[moduleName]?.publicEntrypoints ?? [];
+    const explicitPublicEntrypoints = sortUnique([
+        ...registryPublicEntrypoints,
+        ...targetContract.publicEntrypoints,
+    ]);
+    const existingExplicitEntrypoints = await filterExistingPublicEntrypoints(workspaceRoot, explicitPublicEntrypoints);
+    if (existingExplicitEntrypoints.length > 0) {
+        return existingExplicitEntrypoints;
+    }
+    return inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, moduleRoots.get(moduleName));
+}
+async function resolveKnownModulePublicEntrypoints(workspaceRoot, architectureContract, moduleName, targetContract, moduleRoots, adapter) {
+    const registryPublicEntrypoints = architectureContract?.modules[moduleName]?.publicEntrypoints ?? [];
+    const contractPublicEntrypoints = targetContract?.publicEntrypoints ?? [];
+    const explicitPublicEntrypoints = sortUnique([
+        ...registryPublicEntrypoints,
+        ...contractPublicEntrypoints,
+    ]);
+    const existingExplicitEntrypoints = await filterExistingPublicEntrypoints(workspaceRoot, explicitPublicEntrypoints);
+    if (existingExplicitEntrypoints.length > 0) {
+        return existingExplicitEntrypoints;
+    }
+    if (usesJavaImportParser(adapter)) {
+        return [];
+    }
+    return inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, moduleRoots.get(moduleName));
+}
+function labelPublicEntrypoint(publicEntrypoint) {
+    const normalizedEntrypoint = normalizePath(publicEntrypoint);
+    const fileName = normalizedEntrypoint.split('/').at(-1) ?? '';
+    return /^index\.[cm]?[jt]sx?$/iu.test(fileName)
+        ? `${fileName} public entrypoint`
+        : 'public entrypoint';
+}
+function describePublicEntrypointTargets(publicEntrypoints) {
+    if (publicEntrypoints.length <= 1) {
+        return publicEntrypoints[0] ?? 'unknown public entrypoint';
+    }
+    return publicEntrypoints.join(', ');
+}
+async function describeModulePublicImportGuidance(workspaceRoot, moduleName, moduleRoots) {
+    const moduleRoot = moduleRoots.get(moduleName);
+    const inferredEntrypoints = await inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, moduleRoot);
+    if (inferredEntrypoints.length > 0) {
+        return `Use the public entrypoint at ${describePublicEntrypointTargets(inferredEntrypoints)} instead.`;
+    }
+    if (moduleRoot) {
+        return `Use an existing public entrypoint under ${normalizePath(path.relative(workspaceRoot, moduleRoot))} instead.`;
+    }
+    return 'Use an existing target module public entrypoint instead.';
+}
+function buildActualImportedModuleSetBySource(imports, registeredModuleIds) {
+    const bySource = new Map();
+    for (const dependencyImport of imports) {
+        if (!registeredModuleIds.has(dependencyImport.sourceModule)) {
+            continue;
+        }
+        if (!registeredModuleIds.has(dependencyImport.targetModule)) {
+            continue;
+        }
+        const existing = bySource.get(dependencyImport.sourceModule);
+        if (existing) {
+            existing.add(dependencyImport.targetModule);
+            continue;
+        }
+        bySource.set(dependencyImport.sourceModule, new Set([dependencyImport.targetModule]));
+    }
+    return new Map([...bySource.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([sourceModule, targetModules]) => [
+        sourceModule,
+        new Set([...targetModules].sort((left, right) => left.localeCompare(right))),
+    ]));
+}
+function sortUnique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function summarizeValues(values, limit) {
+    const visible = values.slice(0, limit);
+    const remaining = values.length - visible.length;
+    return remaining > 0 ? `${visible.join(', ')} (+${remaining} more)` : visible.join(', ');
+}
+function buildInboundDependencyMap(bySource, moduleIds) {
+    const inbound = new Map();
+    for (const moduleId of moduleIds) {
+        inbound.set(moduleId, new Set());
+    }
+    for (const [source, targets] of bySource.entries()) {
+        for (const target of targets) {
+            const existing = inbound.get(target);
+            if (!existing) {
+                continue;
+            }
+            existing.add(source);
+        }
+    }
+    return new Map(moduleIds.map((moduleId) => [
+        moduleId,
+        sortUnique(inbound.get(moduleId) ?? []),
+    ]));
+}
+async function buildDependencyGraphSummary(workspaceRoot, architectureContract, options) {
+    const modulesRoot = options?.modulesRootRelativePath ??
+        (0, moduleDiscovery_1.resolveModulesRootFromContract)(architectureContract);
+    const adapter = (0, stackAdapters_1.resolvePrimaryAdapterFromContract)(architectureContract);
+    const moduleRoots = await findModuleRoots(workspaceRoot, modulesRoot, architectureContract, { canonicalizeOverlappingPaths: options?.canonicalizeOverlappingModulePaths === true });
+    const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(workspaceRoot, architectureContract);
+    const workspacePackageAliases = await buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots);
+    const moduleIds = sortUnique([...moduleRoots.keys(), ...explicitStandaloneModuleByPath.values()]);
+    const registeredModuleIds = new Set(moduleIds);
+    const resolutionContext = createDependencyGraphResolutionContext();
+    const imports = await collectCrossModuleImports(workspaceRoot, modulesRoot, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter, { resolutionContext });
+    options?.onCollectedImports?.(imports);
+    options?.onResolutionStats?.(resolutionContext.getStats());
+    const peerImports = filterPeerModuleImports(imports);
+    const moduleScopedPeerImports = peerImports.filter((dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport));
+    const actualBySource = buildActualImportedModuleSetBySource(moduleScopedPeerImports, registeredModuleIds);
+    const moduleContractCache = new Map();
+    const declaredBySource = new Map();
+    const hasContractByModule = new Map();
+    for (const moduleId of moduleIds) {
+        const sourceContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, moduleId, moduleContractCache);
+        if (sourceContract.status === 'ok' && sourceContract.contract) {
+            hasContractByModule.set(moduleId, true);
+            declaredBySource.set(moduleId, new Set(sortUnique(sourceContract.contract.dependsOn.filter((dependencyModule) => registeredModuleIds.has(dependencyModule) &&
+                !isParentChildModuleRelationship(moduleId, dependencyModule)))));
+            continue;
+        }
+        hasContractByModule.set(moduleId, false);
+        declaredBySource.set(moduleId, new Set());
+    }
+    const inboundDeclared = buildInboundDependencyMap(declaredBySource, moduleIds);
+    const inboundActual = buildInboundDependencyMap(actualBySource, moduleIds);
+    const hierarchyEdges = buildModuleHierarchyEdges(moduleIds);
+    const parentModuleByChild = new Map(hierarchyEdges.map((edge) => [edge.childModule, edge.parentModule]));
+    const moduleSummaries = moduleIds.map((moduleId) => {
+        const declaredDependencies = sortUnique(declaredBySource.get(moduleId) ?? []);
+        const actualDependencies = sortUnique(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: moduleSummaries.map((moduleSummary) => ({
+            ...moduleSummary,
+            childModules: childModulesByParent.get(moduleSummary.module) ?? [],
+        })),
+        hierarchyEdges: retainedHierarchyEdges,
+    };
+}
+async function validateDependencyContractBoundaries(workspaceRoot, architectureContract, options) {
+    if (!options.checkDeclaredDependencies &&
+        !options.checkPublicSurfaceImports &&
+        !options.checkDeclaredDependenciesUsedByCode) {
+        return [];
+    }
+    const modulesRoot = options.modulesRootRelativePath ??
+        (0, moduleDiscovery_1.resolveModulesRootFromContract)(architectureContract);
+    const adapter = (0, stackAdapters_1.resolvePrimaryAdapterFromContract)(architectureContract);
+    const moduleRoots = await findModuleRoots(workspaceRoot, modulesRoot, architectureContract);
+    const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(workspaceRoot, architectureContract);
+    const workspacePackageAliases = await buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots);
+    const imports = options.precomputedImports
+        ? [...options.precomputedImports]
+        : await collectCrossModuleImports(workspaceRoot, modulesRoot, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter);
+    const dependencyContextResolver = (0, architectureDependencyContext_1.createArchitectureDependencyContextResolver)(architectureContract);
+    const peerImports = filterPeerModuleImports(imports);
+    const moduleScopedPeerImports = peerImports.filter((dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport, dependencyContextResolver));
+    const findings = [];
+    const moduleContractCache = new Map();
+    if (options.checkDeclaredDependencies) {
+        const failuresByDependency = new Map();
+        const skippedFindings = new Map();
+        for (const dependencyImport of moduleScopedPeerImports) {
+            const dependencyMetadata = resolveImportDependencyContextMetadata(architectureContract, dependencyImport, dependencyContextResolver);
+            if (dependencyMetadata.isExternal) {
+                continue;
+            }
+            const sourceContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, dependencyImport.sourceModule, moduleContractCache);
+            const targetContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, dependencyImport.targetModule, moduleContractCache);
+            if (sourceContract.status !== 'ok' || !sourceContract.contract) {
+                const skipKey = [
+                    'AP-DEP-004',
+                    'source',
+                    dependencyImport.sourceModule,
+                    sourceContract.status,
+                    sourceContract.contractPath ?? '',
+                ].join('|');
+                if (!skippedFindings.has(skipKey)) {
+                    skippedFindings.set(skipKey, {
+                        result: makeValidationResult('AP-DEP-004', 'info', false, buildContractSkipMessage('AP-DEP-004', dependencyImport.sourceModule, dependencyImport.targetModule, sourceContract, targetContract), {
+                            findingType: 'module-dependency',
+                            module: dependencyImport.sourceModule,
+                            target: dependencyImport.targetModule,
+                            ...dependencyMetadata,
+                        }),
+                        filePath: dependencyImport.sourceFileRelativePath,
+                        line: dependencyImport.line,
+                        importSpecifier: dependencyImport.importSpecifier,
+                        findingType: 'module-dependency',
+                        module: dependencyImport.sourceModule,
+                        target: dependencyImport.targetModule,
+                        ...dependencyMetadata,
+                    });
+                }
+                continue;
+            }
+            if (!sourceContract.contract.dependsOn.includes(dependencyImport.targetModule)) {
+                const dependencyKey = `${dependencyImport.sourceModule}->${dependencyImport.targetModule}`;
+                const existing = failuresByDependency.get(dependencyKey);
+                if (existing) {
+                    existing.imports.push(dependencyImport);
+                }
+                else {
+                    failuresByDependency.set(dependencyKey, {
+                        dependencyImport,
+                        metadata: dependencyMetadata,
+                        imports: [dependencyImport],
+                    });
+                }
+            }
+        }
+        const failures = [...failuresByDependency.values()]
+            .sort((left, right) => {
+            const sourceCompare = left.dependencyImport.sourceModule.localeCompare(right.dependencyImport.sourceModule);
+            if (sourceCompare !== 0) {
+                return sourceCompare;
+            }
+            return left.dependencyImport.targetModule.localeCompare(right.dependencyImport.targetModule);
+        })
+            .map(({ dependencyImport, imports, metadata }) => {
+            const representativeFiles = sortUnique(imports.map((entry) => entry.sourceFileRelativePath));
+            const representativeImports = sortUnique(imports.map((entry) => entry.importSpecifier));
+            const fileSummary = summarizeValues(representativeFiles, 3);
+            const importSummary = summarizeValues(representativeImports, 3);
+            return {
+                result: makeValidationResult('AP-DEP-004', 'error', false, `Module '${dependencyImport.sourceModule}' imports module '${dependencyImport.targetModule}' but '${dependencyImport.targetModule}' is not declared in ${dependencyImport.sourceModule}.contract.json dependsOn. Import count: ${imports.length}. Representative files: ${fileSummary}. Representative imports: ${importSummary}.`, {
+                    findingType: 'module-dependency',
+                    module: dependencyImport.sourceModule,
+                    target: dependencyImport.targetModule,
+                    ...metadata,
+                }),
+                filePath: dependencyImport.sourceFileRelativePath,
+                line: dependencyImport.line,
+                findingType: 'module-dependency',
+                module: dependencyImport.sourceModule,
+                target: dependencyImport.targetModule,
+                ...metadata,
+            };
+        });
+        if (failures.length > 0) {
+            findings.push(...failures);
+        }
+        else if (moduleScopedPeerImports.length === 0) {
+            findings.push({
+                result: makeValidationResult('AP-DEP-004', 'error', true, 'No cross-module imports detected for contract dependency declaration checks.'),
+            });
+        }
+        else if (skippedFindings.size > 0) {
+            findings.push(...[...skippedFindings.values()]);
+        }
+        else {
+            findings.push({
+                result: makeValidationResult('AP-DEP-004', 'error', true, 'All cross-module imports are declared in source module contract dependsOn lists.'),
+            });
+        }
+    }
+    if (options.checkPublicSurfaceImports) {
+        const failures = [];
+        const skippedFindings = new Map();
+        for (const dependencyImport of moduleScopedPeerImports) {
+            const dependencyMetadata = resolveImportDependencyContextMetadata(architectureContract, dependencyImport, dependencyContextResolver);
+            if (dependencyMetadata.isExternal) {
+                continue;
+            }
+            const sourceContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, dependencyImport.sourceModule, moduleContractCache);
+            const targetContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, dependencyImport.targetModule, moduleContractCache);
+            if (targetContract.status !== 'ok' || !targetContract.contract) {
+                const unavailableRoles = [];
+                if (sourceContract.status !== 'ok') {
+                    unavailableRoles.push({
+                        role: 'source',
+                        moduleName: dependencyImport.sourceModule,
+                        contract: sourceContract,
+                    });
+                }
+                if (targetContract.status !== 'ok') {
+                    unavailableRoles.push({
+                        role: 'target',
+                        moduleName: dependencyImport.targetModule,
+                        contract: targetContract,
+                    });
+                }
+                for (const unavailable of unavailableRoles) {
+                    const skipKey = [
+                        'AP-DEP-005',
+                        unavailable.role,
+                        unavailable.moduleName,
+                        unavailable.contract.status,
+                        unavailable.contract.contractPath ?? '',
+                    ].join('|');
+                    if (skippedFindings.has(skipKey)) {
+                        continue;
+                    }
+                    skippedFindings.set(skipKey, {
+                        result: makeValidationResult('AP-DEP-005', 'info', false, buildContractSkipMessage('AP-DEP-005', dependencyImport.sourceModule, dependencyImport.targetModule, sourceContract, targetContract), {
+                            findingType: 'module-dependency',
+                            module: dependencyImport.sourceModule,
+                            target: dependencyImport.targetModule,
+                            ...dependencyMetadata,
+                        }),
+                        filePath: dependencyImport.sourceFileRelativePath,
+                        line: dependencyImport.line,
+                        importSpecifier: dependencyImport.importSpecifier,
+                        findingType: 'module-dependency',
+                        module: dependencyImport.sourceModule,
+                        target: dependencyImport.targetModule,
+                        ...dependencyMetadata,
+                    });
+                }
+                continue;
+            }
+            const publicEntrypoints = await resolveKnownModulePublicEntrypoints(workspaceRoot, architectureContract, dependencyImport.targetModule, targetContract.contract, moduleRoots, adapter);
+            if (publicEntrypoints.length === 0) {
+                continue;
+            }
+            if (options.suppressPublicSurfaceFailuresForNonPublicImports === true &&
+                !dependencyImport.isPublicImport) {
+                continue;
+            }
+            if (dependencyImport.isPackagePublicImport === true) {
+                continue;
+            }
+            if (!isImportWithinPublicEntrypoints(dependencyImport.resolvedTargetRelativePath, publicEntrypoints)) {
+                const publicEntrypointLabel = labelPublicEntrypoint(publicEntrypoints[0] ?? '');
+                const expectedEntrypoint = describePublicEntrypointTargets(publicEntrypoints);
+                failures.push({
+                    result: makeValidationResult('AP-DEP-005', 'error', false, `Module '${dependencyImport.sourceModule}' must import module '${dependencyImport.targetModule}' via its ${publicEntrypointLabel}: ${expectedEntrypoint}.`, {
+                        findingType: 'module-dependency',
+                        module: dependencyImport.sourceModule,
+                        target: dependencyImport.targetModule,
+                        ...dependencyMetadata,
+                    }),
+                    filePath: dependencyImport.sourceFileRelativePath,
+                    line: dependencyImport.line,
+                    importSpecifier: dependencyImport.importSpecifier,
+                    findingType: 'module-dependency',
+                    module: dependencyImport.sourceModule,
+                    target: dependencyImport.targetModule,
+                    ...dependencyMetadata,
+                });
+            }
+        }
+        if (failures.length > 0) {
+            findings.push(...failures);
+        }
+        else if (moduleScopedPeerImports.length === 0) {
+            findings.push({
+                result: makeValidationResult('AP-DEP-005', 'error', true, 'No cross-module imports detected for public-surface contract checks.'),
+            });
+        }
+        else if (skippedFindings.size > 0) {
+            findings.push(...[...skippedFindings.values()]);
+        }
+        else {
+            findings.push({
+                result: makeValidationResult('AP-DEP-005', 'error', true, 'All cross-module imports resolve through target module contract public entrypoints.'),
+            });
+        }
+    }
+    if (options.checkDeclaredDependenciesUsedByCode) {
+        const failures = [];
+        const canonicalModuleRoots = await findModuleRoots(workspaceRoot, modulesRoot, architectureContract, { canonicalizeOverlappingPaths: true });
+        const canonicalImports = options.precomputedImports
+            ? [...options.precomputedImports]
+            : await collectCrossModuleImports(workspaceRoot, modulesRoot, canonicalModuleRoots, explicitStandaloneModuleByPath, await buildWorkspacePackageAliasMap(workspaceRoot, canonicalModuleRoots), adapter);
+        const canonicalPeerImports = filterPeerModuleImports(canonicalImports).filter((dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport));
+        const registeredModuleIds = new Set([
+            ...canonicalModuleRoots.keys(),
+            ...explicitStandaloneModuleByPath.values(),
+        ]);
+        const importedBySource = buildActualImportedModuleSetBySource(canonicalPeerImports, registeredModuleIds);
+        for (const moduleName of [...registeredModuleIds].sort((left, right) => left.localeCompare(right))) {
+            const sourceContract = await loadModuleArchitectureContract(workspaceRoot, architectureContract, moduleName, moduleContractCache);
+            if (sourceContract.status !== 'ok' || !sourceContract.contract) {
+                continue;
+            }
+            const declaredDependencies = [...sourceContract.contract.dependsOn]
+                .filter((dependencyModule) => registeredModuleIds.has(dependencyModule) &&
+                !isParentChildModuleRelationship(moduleName, dependencyModule))
+                .sort((left, right) => left.localeCompare(right));
+            if (declaredDependencies.length === 0) {
+                continue;
+            }
+            const actualImportedModules = importedBySource.get(moduleName) ?? new Set();
+            for (const declaredDependency of declaredDependencies) {
+                if (actualImportedModules.has(declaredDependency)) {
+                    continue;
+                }
+                failures.push({
+                    result: makeValidationResult('AP-DEP-006', 'warning', false, `Module '${moduleName}' declares dependency on '${declaredDependency}' but no cross-module imports reference it.`, {
+                        findingType: 'module-dependency',
+                        module: moduleName,
+                        target: declaredDependency,
+                    }),
+                    ...(sourceContract.contractPath
+                        ? { filePath: sourceContract.contractPath }
+                        : {}),
+                    findingType: 'module-dependency',
+                    module: moduleName,
+                    target: declaredDependency,
+                });
+            }
+        }
+        if (failures.length > 0) {
+            findings.push(...failures);
+        }
+        else {
+            findings.push({
+                result: makeValidationResult('AP-DEP-006', 'warning', true, 'All declared module dependencies are referenced by cross-module imports.'),
+            });
+        }
+    }
+    return findings;
+}
+async function validateDependencyBoundaries(workspaceRoot, options) {
+    if (!options.checkCircularDependencies &&
+        !options.checkForbiddenDependencies &&
+        !options.checkNonPublicImports &&
+        options.checkComponentDependencyPolicies !== true) {
+        return [];
+    }
+    const parsedArchitectureContract = await (0, architectureInit_1.loadArchitectureContract)(workspaceRoot);
+    const adapter = (0, stackAdapters_1.resolvePrimaryAdapterFromContract)(parsedArchitectureContract);
+    const modulesRootRelativePath = options.modulesRootRelativePath ??
+        (0, moduleDiscovery_1.resolveModulesRootFromContract)(parsedArchitectureContract);
+    const moduleRoots = await findModuleRoots(workspaceRoot, modulesRootRelativePath, parsedArchitectureContract);
+    const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(workspaceRoot, parsedArchitectureContract);
+    const workspacePackageAliases = await buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots);
+    const imports = options.precomputedImports
+        ? [...options.precomputedImports]
+        : await collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter);
+    const dependencyContextResolver = parsedArchitectureContract
+        ? (0, architectureDependencyContext_1.createArchitectureDependencyContextResolver)(parsedArchitectureContract)
+        : undefined;
+    const peerImports = filterPeerModuleImports(imports);
+    const moduleScopedPeerImports = peerImports.filter((dependencyImport) => isModuleScopedDependencyImport(parsedArchitectureContract, dependencyImport, dependencyContextResolver));
+    const findings = [];
+    const moduleContractCache = new Map();
+    let dependencyRules;
+    let dependencyRulesSkipReason;
+    if (options.dependencyRulesConfigOverride) {
+        dependencyRules = options.dependencyRulesConfigOverride;
+    }
+    else {
+        try {
+            dependencyRules = await readDependencyRulesConfig(workspaceRoot);
+            if (!dependencyRules) {
+                dependencyRulesSkipReason =
+                    '.archpilot/dependency-rules.json is missing. Add it to enable config-driven dependency boundary rules.';
+            }
+        }
+        catch (error) {
+            if (error instanceof DependencyRulesConfigError) {
+                dependencyRulesSkipReason = error.message;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    if (options.checkCircularDependencies) {
+        const cycles = detectCircularDependencies([...moduleRoots.keys()], moduleScopedPeerImports);
+        if (cycles.length === 0) {
+            findings.push({
+                result: makeValidationResult('AP-DEP-001', 'error', true, `No circular module dependencies detected across ${modulesRootRelativePath}.`),
+            });
+        }
+        else {
+            for (const cycle of cycles) {
+                findings.push({
+                    result: makeValidationResult('AP-DEP-001', 'error', false, `Circular module dependency detected: ${cycle.replaceAll('->', ' -> ')}.`),
+                });
+            }
+        }
+    }
+    if (options.checkForbiddenDependencies) {
+        if (!dependencyRules) {
+            findings.push(...buildDependencyConfigSkippedFindings(dependencyRulesSkipReason ?? 'dependency rules config is unavailable.', {
+                checkForbiddenDependencies: true,
+                checkNonPublicImports: false,
+            }));
+        }
+        else {
+            const violations = moduleScopedPeerImports.filter((dependencyImport) => {
+                if (parsedArchitectureContract) {
+                    const dependencyMetadata = resolveImportDependencyContextMetadata(parsedArchitectureContract, dependencyImport, dependencyContextResolver);
+                    if (dependencyMetadata.isExternal) {
+                        return false;
+                    }
+                }
+                const moduleRules = dependencyRules.modules[dependencyImport.sourceModule];
+                if (!moduleRules) {
+                    return false;
+                }
+                const allowedDependencies = moduleRules.allowedDependencies ?? [];
+                return !allowedDependencies.includes(dependencyImport.targetModule);
+            });
+            if (violations.length === 0) {
+                findings.push({
+                    result: makeValidationResult('AP-DEP-002', 'error', true, 'No forbidden cross-module dependencies detected.'),
+                });
+            }
+            else {
+                for (const violation of violations) {
+                    const dependencyMetadata = parsedArchitectureContract
+                        ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation, dependencyContextResolver)
+                        : undefined;
+                    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({
+                        result: makeValidationResult('AP-DEP-002', 'error', false, `${violation.sourceFileRelativePath}:${violation.line} imports module "${violation.targetModule}" from "${violation.sourceModule}" via "${violation.importSpecifier}", but "${violation.sourceModule}" ${allowedDescription}.`, {
+                            findingType: 'module-dependency',
+                            module: violation.sourceModule,
+                            target: violation.targetModule,
+                            ...(dependencyMetadata ?? {}),
+                        }),
+                        filePath: violation.sourceFileRelativePath,
+                        line: violation.line,
+                        importSpecifier: violation.importSpecifier,
+                        findingType: 'module-dependency',
+                        module: violation.sourceModule,
+                        target: violation.targetModule,
+                        ...(dependencyMetadata ?? {}),
+                    });
+                }
+            }
+        }
+    }
+    if (options.checkNonPublicImports) {
+        if (!dependencyRules) {
+            findings.push(...buildDependencyConfigSkippedFindings(dependencyRulesSkipReason ?? 'dependency rules config is unavailable.', {
+                checkForbiddenDependencies: false,
+                checkNonPublicImports: true,
+            }));
+        }
+        else {
+            const violations = [];
+            for (const dependencyImport of moduleScopedPeerImports) {
+                if (parsedArchitectureContract) {
+                    const dependencyMetadata = resolveImportDependencyContextMetadata(parsedArchitectureContract, dependencyImport, dependencyContextResolver);
+                    if (dependencyMetadata.isExternal) {
+                        continue;
+                    }
+                }
+                const moduleRules = dependencyRules.modules[dependencyImport.sourceModule];
+                if (moduleRules?.publicEntrypointsOnly !== true || dependencyImport.isPublicImport) {
+                    continue;
+                }
+                if (dependencyImport.isPackagePublicImport === true) {
+                    continue;
+                }
+                const targetContract = parsedArchitectureContract
+                    ? await loadModuleArchitectureContract(workspaceRoot, parsedArchitectureContract, dependencyImport.targetModule, moduleContractCache)
+                    : undefined;
+                const publicEntrypoints = await resolveKnownModulePublicEntrypoints(workspaceRoot, parsedArchitectureContract, dependencyImport.targetModule, targetContract?.contract, moduleRoots, adapter);
+                if (publicEntrypoints.length === 0) {
+                    continue;
+                }
+                if (isImportWithinPublicEntrypoints(dependencyImport.resolvedTargetRelativePath, publicEntrypoints)) {
+                    continue;
+                }
+                violations.push(dependencyImport);
+            }
+            if (violations.length === 0) {
+                findings.push({
+                    result: makeValidationResult('AP-DEP-003', 'error', true, 'No non-public cross-module imports detected.'),
+                });
+            }
+            else {
+                for (const violation of violations) {
+                    const dependencyMetadata = parsedArchitectureContract
+                        ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation, dependencyContextResolver)
+                        : undefined;
+                    const publicImportGuidance = await describeModulePublicImportGuidance(workspaceRoot, violation.targetModule, moduleRoots);
+                    findings.push({
+                        result: makeValidationResult('AP-DEP-003', 'error', false, `${violation.sourceFileRelativePath}:${violation.line} imports non-public path "${violation.importSpecifier}" from module "${violation.targetModule}". ${publicImportGuidance}`, {
+                            findingType: 'module-dependency',
+                            module: violation.sourceModule,
+                            target: violation.targetModule,
+                            ...(dependencyMetadata ?? {}),
+                        }),
+                        filePath: violation.sourceFileRelativePath,
+                        line: violation.line,
+                        importSpecifier: violation.importSpecifier,
+                        findingType: 'module-dependency',
+                        module: violation.sourceModule,
+                        target: violation.targetModule,
+                        ...(dependencyMetadata ?? {}),
+                    });
+                }
+            }
+        }
+    }
+    if (options.checkComponentDependencyPolicies !== false) {
+        findings.push(...validateComponentDependencyPolicies(parsedArchitectureContract, peerImports));
+    }
+    return findings;
+}
+async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
+    const parsedArchitectureContract = await (0, architectureInit_1.loadArchitectureContract)(workspaceRoot);
+    const adapter = (0, stackAdapters_1.resolvePrimaryAdapterFromContract)(parsedArchitectureContract);
+    const modulesRootRelativePath = options?.modulesRootRelativePath ??
+        (0, moduleDiscovery_1.resolveModulesRootFromContract)(parsedArchitectureContract);
+    const moduleRoots = await findModuleRoots(workspaceRoot, modulesRootRelativePath, parsedArchitectureContract);
+    const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(workspaceRoot, parsedArchitectureContract);
+    const workspacePackageAliases = await buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots);
+    const discoveredModules = sortUnique([
+        ...moduleRoots.keys(),
+        ...explicitStandaloneModuleByPath.values(),
+    ]);
+    const moduleFilterSet = options?.moduleFilter
+        ? new Set([...options.moduleFilter].sort((left, right) => left.localeCompare(right)))
+        : undefined;
+    const modules = moduleFilterSet
+        ? discoveredModules.filter((moduleId) => moduleFilterSet.has(moduleId))
+        : discoveredModules;
+    const moduleSet = new Set(modules);
+    const allImports = await collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter);
+    const imports = filterPeerModuleImports(allImports)
+        .filter((dependencyImport) => moduleSet.has(dependencyImport.sourceModule) &&
+        moduleSet.has(dependencyImport.targetModule))
+        .sort((left, right) => {
+        const sourceCompare = left.sourceModule.localeCompare(right.sourceModule);
+        if (sourceCompare !== 0) {
+            return sourceCompare;
+        }
+        const targetCompare = left.targetModule.localeCompare(right.targetModule);
+        if (targetCompare !== 0) {
+            return targetCompare;
+        }
+        const fileCompare = left.sourceFileRelativePath.localeCompare(right.sourceFileRelativePath);
+        if (fileCompare !== 0) {
+            return fileCompare;
+        }
+        const lineCompare = left.line - right.line;
+        if (lineCompare !== 0) {
+            return lineCompare;
+        }
+        return left.importSpecifier.localeCompare(right.importSpecifier);
+    });
+    const edgeAccumulator = new Map();
+    for (const dependencyImport of imports) {
+        const edgeKey = `${dependencyImport.sourceModule}->${dependencyImport.targetModule}`;
+        const existing = edgeAccumulator.get(edgeKey);
+        if (existing) {
+            existing.importCount += 1;
+            if (dependencyImport.isPublicImport) {
+                existing.publicImportCount += 1;
+            }
+            else {
+                existing.nonPublicImportCount += 1;
+            }
+            continue;
+        }
+        edgeAccumulator.set(edgeKey, {
+            sourceModule: dependencyImport.sourceModule,
+            targetModule: dependencyImport.targetModule,
+            importCount: 1,
+            publicImportCount: dependencyImport.isPublicImport ? 1 : 0,
+            nonPublicImportCount: dependencyImport.isPublicImport ? 0 : 1,
+        });
+    }
+    const edges = [...edgeAccumulator.values()].sort((left, right) => {
+        const sourceCompare = left.sourceModule.localeCompare(right.sourceModule);
+        if (sourceCompare !== 0) {
+            return sourceCompare;
+        }
+        return left.targetModule.localeCompare(right.targetModule);
+    });
+    const cycles = detectCircularDependencies(modules, imports);
+    return {
+        modules,
+        edges,
+        hierarchyEdges: buildModuleHierarchyEdges(modules),
+        cycles,
+        imports,
+    };
+}
+//# sourceMappingURL=dependencyValidation.js.map