@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/alias-advisor/analyze.js

@@ -0,0 +1,982 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeAliasAdvisor = analyzeAliasAdvisor;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const cache_1 = require("../topology/cache");
+const core_1 = require("../topology/core");
+const ts_oracle_host_1 = require("../topology/ts-oracle-host");
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+const lexical_1 = require("./lexical");
+const path_identity_1 = require("./path-identity");
+const ranking_1 = require("./ranking");
+const exact_text_cost_1 = require("./exact-text-cost");
+const token_estimator_1 = require("./token-estimator");
+const SOURCE_EXTENSION_RE = /\.(d\.)?[cm]?[tj]sx?$/i;
+const GENERIC_ROOT_ALIASES = new Set(["@/*", "~/*", "#/*", "/*"]);
+const TOKEN_ESTIMATOR = new token_estimator_1.PathLexicalV1Estimator();
+function analyzeAliasAdvisor(input) {
+    const startedAt = Date.now();
+    const topologyStartedAt = Date.now();
+    const snapshot = input.snapshot === undefined ? (0, cache_1.getProjectTopologySnapshot)(input.cwd) : input.snapshot;
+    const topologyMs = Date.now() - topologyStartedAt;
+    const shortlistSize = Math.max(24, input.request.limit * 3);
+    const shortlisted = selectShortlist(input.lexicalEvidence, input.request.candidate, shortlistSize);
+    const resolutionStartedAt = Date.now();
+    const session = snapshot ? new ResolutionSession(snapshot) : null;
+    const resolutions = session ? resolveShortlist(shortlisted, session) : new Map();
+    const resolutionMs = Date.now() - resolutionStartedAt;
+    const analysisStartedAt = Date.now();
+    const builds = shortlisted.map((evidence) => buildCandidate(evidence, input.request, snapshot, session, resolutions));
+    applyGlobalAliasConflicts(builds);
+    const collapsed = collapseAdoptExistingBuilds(builds, input.request.candidate);
+    const ranked = (0, ranking_1.rankAliasCandidates)(collapsed);
+    const filtered = filterCandidates(ranked, input.request.candidate);
+    const visible = filtered.slice(0, input.request.limit);
+    const analysisMs = Date.now() - analysisStartedAt;
+    return {
+        ok: true,
+        op: "aliasCandidates",
+        mode: "topology-aware-advisor",
+        ranking: {
+            policyVersion: "alias-ranking-v2-text-primary",
+            estimatorProfile: TOKEN_ESTIMATOR.profile,
+            categoryCounts: countCategories(filtered)
+        },
+        decisionPolicy: {
+            version: "alias-decision-evidence-v1",
+            baseline: "keepCurrentAliases",
+            primaryMetric: "exact-text-characters",
+            minImports: ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.minImports,
+            minFiles: ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.minFiles,
+            materialNetCharacters: ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.materialNetCharacters
+        },
+        scope: input.request.displayScope,
+        scopePath: input.request.scope,
+        detail: input.request.detail,
+        ...(input.request.candidate ? { candidate: input.request.candidate } : {}),
+        analyzedFiles: input.analyzedFiles,
+        analyzedSpecifiers: input.analyzedSpecifiers,
+        lexicalEvidenceCount: input.lexicalEvidence.length,
+        shortlistedEvidenceCount: shortlisted.length,
+        hiddenCandidates: Math.max(0, filtered.length - visible.length),
+        evidenceFilter: {
+            minImports: input.request.minImports,
+            minFiles: input.request.minFiles
+        },
+        resultLimit: {
+            limit: input.request.limit,
+        },
+        topology: snapshot ? {
+            available: true,
+            dependencyState: snapshot.dependencySnapshot.state,
+            tsconfigs: snapshot.tsconfigs.length,
+            packages: snapshot.packages.length,
+            diagnostics: snapshot.diagnostics.length
+        } : { available: false },
+        ownerConfigDiagnostics: session?.ownerConfigDiagnostics() ?? [],
+        candidates: visible,
+        timings: {
+            lexicalMs: input.lexicalMs,
+            topologyMs,
+            resolutionMs,
+            analysisMs,
+            totalMs: Date.now() - startedAt + input.lexicalMs
+        }
+    };
+}
+function selectShortlist(evidence, requested, limit) {
+    const selected = evidence.slice(0, limit);
+    for (const item of evidence) {
+        if (requested && (item.prefix === requested || item.suggestedAliases.includes(requested)) && !selected.includes(item)) {
+            selected.push(item);
+        }
+    }
+    const selectedAliases = new Set(selected.flatMap((item) => item.suggestedAliases));
+    for (const item of evidence) {
+        if (!selected.includes(item) && item.suggestedAliases.some((alias) => selectedAliases.has(alias))) {
+            selected.push(item);
+        }
+    }
+    return selected;
+}
+function resolveShortlist(shortlist, session) {
+    const result = new Map();
+    for (const occurrence of uniqueOccurrences(shortlist.flatMap((item) => item.occurrences))) {
+        result.set(occurrenceKey(occurrence), session.resolve(occurrence));
+    }
+    return result;
+}
+function buildCandidate(evidence, request, snapshot, session, resolutionsByKey) {
+    const resolutions = evidence.occurrences.map((occurrence) => resolutionsByKey.get(occurrenceKey(occurrence)) ?? unresolvedWithoutTopology(occurrence));
+    const requestedAlias = request.candidate && evidence.suggestedAliases.includes(request.candidate) ? request.candidate : undefined;
+    const requestedExistingAlias = request.candidate === evidence.prefix ? undefined : request.candidate;
+    const targetRoots = uniqueCanonicalPaths(resolutions
+        .filter((item) => item.status === "resolvedInternal" && item.targetFile)
+        .map((item) => deriveTargetRoot(item, evidence.prefix))
+        .filter((item) => item !== null));
+    const specificExistingAlias = snapshot && session
+        ? findSharedExistingAlias(snapshot, session, resolutions, requestedExistingAlias)
+        : null;
+    const alias = requestedAlias ?? specificExistingAlias?.pattern ?? evidence.suggestedAliases[0] ?? "<alias>";
+    const intent = !snapshot
+        ? "rejectedEvidence"
+        : specificExistingAlias
+            ? "adoptExistingAlias"
+            : "createAlias";
+    const conflicts = [];
+    const coverage = {
+        imports: evidence.importCount,
+        files: evidence.importingFileCount,
+        resolvedInternal: resolutions.filter((item) => item.status === "resolvedInternal").length,
+        resolvedExternal: resolutions.filter((item) => item.status === "resolvedExternal").length,
+        unresolved: resolutions.filter((item) => item.status === "unresolved").length,
+        noOwningTsconfig: resolutions.filter((item) => item.status === "noOwningTsconfig").length
+    };
+    if (!snapshot || coverage.resolvedInternal !== coverage.imports) {
+        conflicts.push({
+            code: "coverage_incomplete",
+            message: !snapshot
+                ? "Topology is unavailable; covered occurrences were not resolved."
+                : `Only ${coverage.resolvedInternal}/${coverage.imports} covered occurrences resolved to internal targets.`,
+            files: unique(resolutions.filter((item) => item.status !== "resolvedInternal").map((item) => item.displayImporter)).slice(0, 8)
+        });
+    }
+    const divergent = resolutions.filter(ownerResolutionsDiverge);
+    if (divergent.length > 0) {
+        conflicts.push({
+            code: "owning_tsconfig_resolution_divergence",
+            message: `${divergent.length} covered occurrence(s) resolve differently across owning tsconfigs.`,
+            files: unique(divergent.map((item) => item.displayImporter)).slice(0, 8)
+        });
+    }
+    if (targetRoots.length === 0) {
+        conflicts.push({
+            code: "target_root_unproven",
+            message: "No single target root could be derived from resolved imports."
+        });
+    }
+    if (targetRoots.length > 1) {
+        conflicts.push({
+            code: "source_prefix_multiple_targets",
+            message: "The same lexical prefix resolves to multiple target roots.",
+            targets: targetRoots.map((item) => toDisplayPath(snapshot?.root ?? request.scope, item))
+        });
+    }
+    if (specificExistingAlias && !specificExistingAlias.compatible) {
+        conflicts.push({
+            code: "incompatible_mapping_across_tsconfigs",
+            message: `${specificExistingAlias.pattern} requires different import specifiers across owning tsconfigs.`
+        });
+    }
+    const targetRoot = targetRoots.length === 1 ? targetRoots[0] : undefined;
+    const applicableTsconfigs = snapshot && session
+        ? buildApplicableTsconfigs(snapshot, session, evidence, resolutions, alias, targetRoot, intent, specificExistingAlias?.specifiersByOccurrence, conflicts)
+        : [];
+    const owningTsconfigs = unique(resolutions.flatMap((resolution) => resolution.owningTsconfigs.map((owner) => owner.tsconfig)));
+    const simulatedTsconfigs = new Set(applicableTsconfigs.map((config) => config.tsconfig));
+    if (owningTsconfigs.some((tsconfig) => !simulatedTsconfigs.has(tsconfig))
+        || applicableTsconfigs.some((config) => config.simulation === "failed" || config.simulation === "notRun")) {
+        conflicts.push({
+            code: "simulation_incomplete",
+            message: "Not every owning tsconfig proved a compatible alias mapping.",
+            targets: owningTsconfigs.filter((tsconfig) => !simulatedTsconfigs.has(tsconfig))
+        });
+    }
+    if (snapshot && targetRoot) {
+        addPackageAndRuntimeConflicts(snapshot, resolutions, alias, intent, conflicts);
+    }
+    const projectedSpecifiers = resolutions.map((resolution, index) => {
+        const occurrence = evidence.occurrences[index];
+        if (intent === "adoptExistingAlias" && snapshot && session && resolution.targetFile) {
+            return specificExistingAlias?.specifiersByOccurrence.get(occurrenceKey(occurrence)) ?? occurrence.specifier;
+        }
+        return (0, lexical_1.rewriteSpecifier)(occurrence.specifier, evidence.prefix, alias);
+    });
+    const boundaryReasons = boundaryRiskReasons(resolutions);
+    const runtimeReasons = runtimeRiskReasons(applicableTsconfigs, alias, intent);
+    const disposition = conflicts.length > 0 ? "rejected" : snapshot ? "eligibleForRanking" : "rawEvidence";
+    const confidence = confidenceFor(disposition, intent, runtimeReasons);
+    const occurrenceIds = evidence.occurrences.map(occurrenceKey);
+    const tokenEstimate = (0, token_estimator_1.estimateAliasTokenCost)({
+        estimator: TOKEN_ESTIMATOR,
+        intent,
+        alias,
+        occurrenceIds,
+        currentSpecifiers: evidence.occurrences.map((occurrence) => occurrence.specifier),
+        projectedSpecifiers,
+        applicableTsconfigs,
+        ...deriveResolverMirrorEstimate(snapshot, resolutions, targetRoot, alias, conflicts)
+    });
+    const exactTextEstimate = (0, exact_text_cost_1.estimateAliasExactTextCost)({
+        intent,
+        alias,
+        occurrenceIds,
+        currentLiterals: evidence.occurrences.map((occurrence) => occurrence.literal),
+        currentSpecifiers: evidence.occurrences.map((occurrence) => occurrence.specifier),
+        projectedSpecifiers,
+        applicableTsconfigs,
+        ...deriveResolverMirrorEstimate(snapshot, resolutions, targetRoot, alias, conflicts)
+    });
+    const targetPattern = intent === "adoptExistingAlias"
+        ? specificExistingAlias?.targets.join(", ")
+        : targetRoot && snapshot
+            ? `${toDisplayPath(snapshot.root, targetRoot)}/*`
+            : undefined;
+    const candidate = {
+        id: candidateId(evidence.prefix, alias, targetPattern ?? "unresolved"),
+        sourcePrefix: evidence.prefix,
+        alias,
+        ...(targetPattern ? { targetPattern } : {}),
+        intent,
+        disposition,
+        coverage,
+        applicableTsconfigs,
+        sourceCost: {
+            metric: "characters",
+            current: exactTextEstimate.cost.sourceLiterals.current,
+            projected: exactTextEstimate.cost.sourceLiterals.projected,
+            delta: exactTextEstimate.cost.sourceLiterals.reduction
+        },
+        decisionEvidence: decisionEvidenceFor({
+            disposition,
+            coverage,
+            exactText: exactTextEstimate.cost,
+            conflicts
+        }),
+        tokenCost: tokenEstimate.cost,
+        ranking: {
+            policyVersion: "alias-ranking-v2-text-primary",
+            category: "rejected",
+            ordinal: 0,
+            score: 0,
+            scoreComponents: {
+                exactNetTextReduction: exactTextEstimate.cost.netReduction.absolute,
+                imports: coverage.imports,
+                files: coverage.files,
+                confidence: confidence.level,
+                estimatorConfidence: tokenEstimate.cost.profile.confidence
+            },
+            reasons: ["ranking pending candidate-set overlap analysis"]
+        },
+        conflicts,
+        boundaryRisk: {
+            level: boundaryReasons.length > 0 ? "high" : "low",
+            reasons: boundaryReasons
+        },
+        runtimeRisk: {
+            level: runtimeReasons.length > 0 ? (conflicts.some((item) => item.code === "runtime_resolver_mismatch") ? "high" : "unknown") : "low",
+            reasons: runtimeReasons
+        },
+        confidence,
+        examples: evidence.occurrences.slice(0, request.detail === "examples" ? 8 : 3).map((occurrence, index) => {
+            const resolution = resolutions[index];
+            return {
+                importer: occurrence.displayImporter,
+                from: occurrence.specifier,
+                ...(projectedSpecifiers[index] && projectedSpecifiers[index] !== occurrence.specifier ? { to: projectedSpecifiers[index] } : {}),
+                ...(resolution?.targetFile && snapshot ? { targetFile: toDisplayPath(snapshot.root, resolution.targetFile) } : {})
+            };
+        }),
+        overlap: {
+            parents: [],
+            children: [],
+            exclusiveImports: 0,
+            exclusiveTextReduction: 0,
+            marginalImports: 0,
+            marginalTextReduction: 0,
+            marginalNetTextReduction: 0,
+            marginalTokenSaving: 0
+        },
+        importNormalizeFollowUp: conflicts.length > 0 ? {
+            status: "blocked",
+            reason: conflicts[0]?.message ?? "Candidate is blocked."
+        } : intent === "adoptExistingAlias" ? {
+            status: "adoptExisting",
+            preferAlias: alias
+        } : {
+            status: "eligibleAfterConfig",
+            preferAlias: alias
+        }
+    };
+    return {
+        candidate,
+        occurrenceSavings: tokenEstimate.occurrenceSavings,
+        exactTextOccurrenceSavings: exactTextEstimate.occurrenceSavings,
+        ...(targetRoot ? { targetRoot } : {})
+    };
+}
+function decisionEvidenceFor(input) {
+    const meetsThreshold = input.coverage.imports >= ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.minImports
+        && input.coverage.files >= ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.minFiles;
+    const eligible = input.disposition === "eligibleForRanking" && input.conflicts.length === 0;
+    const material = input.exactText.netReduction.absolute >= ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.materialNetCharacters;
+    const winsKeepCurrentAliases = eligible && meetsThreshold && material;
+    const outcome = !eligible ? "blocked" : winsKeepCurrentAliases ? "materialImprovement" : "noConfidentImprovement";
+    const reasons = !eligible
+        ? ["M2 technical eligibility did not clear; keep current aliases."]
+        : !meetsThreshold
+            ? ["Candidate is below provisional breadth thresholds; keep current aliases."]
+            : !material
+                ? ["Exact net text reduction is below the provisional material threshold; keep current aliases."]
+                : ["Exact text reduction clears the provisional do-nothing baseline."];
+    return {
+        version: "alias-decision-evidence-v1",
+        baseline: "keepCurrentAliases",
+        primaryMetric: "exact-text-characters",
+        breadth: {
+            occurrences: input.coverage.imports,
+            files: input.coverage.files,
+            meetsThreshold
+        },
+        materialNetCharacters: ranking_1.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS.materialNetCharacters,
+        exactText: input.exactText,
+        winsKeepCurrentAliases,
+        outcome,
+        reasons
+    };
+}
+function buildApplicableTsconfigs(snapshot, session, evidence, resolutions, alias, targetRoot, intent, existingSpecifiersByOccurrence, conflicts) {
+    const byConfig = new Map();
+    resolutions.forEach((resolution, index) => {
+        for (const owner of resolution.owningTsconfigs) {
+            byConfig.set(owner.tsconfig, [...(byConfig.get(owner.tsconfig) ?? []), { index, owner }]);
+        }
+    });
+    const result = [];
+    for (const [tsconfig, entries] of byConfig) {
+        const configSnapshot = snapshot.tsconfigs.find((item) => item.file === tsconfig);
+        const parsed = session.parsedConfig(tsconfig);
+        const files = unique(entries.map(({ index }) => evidence.occurrences[index].displayImporter));
+        if (!configSnapshot || !parsed || !targetRoot) {
+            result.push({ tsconfig, coveredImports: entries.length, coveredFiles: files.length, simulation: "notRun" });
+            continue;
+        }
+        const mappingTarget = mappingTargetFor(snapshot.root, configSnapshot, targetRoot);
+        const exactMapping = configSnapshot.paths.find((mapping) => mapping.pattern === alias);
+        if (exactMapping && intent === "createAlias") {
+            const exactWorks = entries.every(({ index, owner }) => {
+                const occurrence = evidence.occurrences[index];
+                const rewritten = (0, lexical_1.rewriteSpecifier)(occurrence.specifier, evidence.prefix, alias);
+                const simulated = session.resolveSpecifier(parsed, occurrence.importer, rewritten);
+                return owner.targetFile && simulated && (0, path_identity_1.sameCanonicalPath)(simulated, owner.targetFile);
+            });
+            if (!exactWorks) {
+                conflicts.push({
+                    code: "existing_paths_collision",
+                    message: `${alias} already maps to a different target in ${tsconfig}.`,
+                    tsconfig,
+                    targets: exactMapping.targets
+                });
+            }
+            result.push({
+                tsconfig,
+                coveredImports: entries.length,
+                coveredFiles: files.length,
+                mappingTarget,
+                existingAlias: alias,
+                simulation: exactWorks ? "existing" : "failed"
+            });
+            continue;
+        }
+        if (intent === "adoptExistingAlias") {
+            const existingWorks = entries.every(({ index, owner }) => {
+                const occurrence = evidence.occurrences[index];
+                const rewritten = existingSpecifiersByOccurrence?.get(occurrenceKey(occurrence));
+                return owner.targetFile && rewritten
+                    && (0, path_identity_1.sameCanonicalPath)(session.resolveSpecifier(parsed, occurrence.importer, rewritten) ?? "", owner.targetFile);
+            });
+            if (!existingWorks) {
+                conflicts.push({
+                    code: "proposed_mapping_target_mismatch",
+                    message: `${alias} did not resolve to the original targets in ${tsconfig}.`,
+                    tsconfig,
+                    files: files.slice(0, 8)
+                });
+            }
+            result.push({
+                tsconfig,
+                coveredImports: entries.length,
+                coveredFiles: files.length,
+                mappingTarget,
+                existingAlias: alias,
+                simulation: existingWorks ? "existing" : "failed"
+            });
+            continue;
+        }
+        const outcomes = entries.map(({ index, owner }) => {
+            const occurrence = evidence.occurrences[index];
+            const rewritten = (0, lexical_1.rewriteSpecifier)(occurrence.specifier, evidence.prefix, alias);
+            const simulated = session.resolveWithProposedMapping(parsed, configSnapshot, occurrence.importer, rewritten, alias, mappingTarget);
+            return { owner, simulated, occurrence };
+        });
+        const unresolved = outcomes.filter((item) => !item.simulated);
+        const mismatched = outcomes.filter((item) => item.simulated && (!item.owner.targetFile || !(0, path_identity_1.sameCanonicalPath)(item.owner.targetFile, item.simulated)));
+        if (unresolved.length > 0) {
+            conflicts.push({
+                code: "proposed_mapping_unresolved",
+                message: `${alias} did not resolve for ${unresolved.length} covered occurrence(s) in ${tsconfig}.`,
+                tsconfig,
+                files: unique(unresolved.map((item) => item.occurrence.displayImporter)).slice(0, 8)
+            });
+        }
+        if (mismatched.length > 0) {
+            conflicts.push({
+                code: "proposed_mapping_target_mismatch",
+                message: `${alias} resolved to a different target for ${mismatched.length} covered occurrence(s) in ${tsconfig}.`,
+                tsconfig,
+                targets: uniqueCanonicalPaths(mismatched.flatMap((item) => [item.owner.targetFile ?? "", item.simulated ?? ""]).filter(Boolean)).slice(0, 8)
+            });
+        }
+        result.push({
+            tsconfig,
+            coveredImports: entries.length,
+            coveredFiles: files.length,
+            mappingTarget,
+            simulation: unresolved.length === 0 && mismatched.length === 0 ? "resolved" : "failed"
+        });
+    }
+    return result.sort((left, right) => left.tsconfig.localeCompare(right.tsconfig));
+}
+function addPackageAndRuntimeConflicts(snapshot, resolutions, alias, intent, conflicts) {
+    const aliasRoot = alias.replace(/\/\*$/, "");
+    const packageNames = new Set(snapshot.packages.flatMap((pkg) => [pkg.name, ...pkg.dependencies]).filter((item) => Boolean(item)));
+    if (intent === "createAlias" && packageNames.has(aliasRoot)) {
+        conflicts.push({
+            code: "package_name_collision",
+            message: `${aliasRoot} collides with a workspace or dependency package name.`
+        });
+    }
+    const consumerPackages = unique(resolutions.map((item) => item.packageRoot).filter((item) => Boolean(item)))
+        .map((root) => snapshot.packages.find((pkg) => toDisplayPath(snapshot.root, pkg.root) === root))
+        .filter((item) => Boolean(item));
+    if (intent === "createAlias" && consumerPackages.some((pkg) => packageImportsOverlap(pkg, alias))) {
+        conflicts.push({
+            code: "package_imports_collision",
+            message: `${alias} overlaps an existing package.json imports key.`
+        });
+    }
+    const crossPackage = resolutions.some((item) => item.status === "resolvedInternal" && Boolean(item.targetPackageRoot) && item.packageRoot !== item.targetPackageRoot);
+    if (crossPackage && intent === "createAlias") {
+        conflicts.push({
+            code: "private_cross_package_boundary",
+            message: "A new tsconfig alias would bypass a package dependency/exports boundary."
+        });
+    }
+    const nodeStyleConfigs = unique(resolutions.flatMap((item) => item.owningTsconfigs.map((owner) => owner.tsconfig)))
+        .map((file) => snapshot.tsconfigs.find((config) => config.file === file))
+        .filter((item) => Boolean(item))
+        .filter((config) => /node16|nodenext/i.test(`${config.module ?? ""} ${config.moduleResolution ?? ""}`));
+    if (intent === "createAlias" && alias.startsWith("#") && nodeStyleConfigs.length > 0 && !consumerPackages.every((pkg) => packageImportsOverlap(pkg, alias))) {
+        conflicts.push({
+            code: "runtime_resolver_mismatch",
+            message: `${alias} is not mirrored by package.json imports for Node-style resolution.`
+        });
+    }
+}
+function deriveResolverMirrorEstimate(snapshot, resolutions, targetRoot, alias, conflicts) {
+    if (!snapshot || !targetRoot || !alias.startsWith("#") || !conflicts.some((item) => item.code === "runtime_resolver_mismatch")) {
+        return {};
+    }
+    const packageRoots = uniqueCanonicalPaths(resolutions
+        .map((resolution) => resolution.packageRoot)
+        .filter((item) => Boolean(item))
+        .map((item) => path.resolve(snapshot.root, item)));
+    if (packageRoots.length !== 1) {
+        return {};
+    }
+    const relative = path.relative(packageRoots[0], targetRoot).replace(/\\/g, "/");
+    if (relative.startsWith("../") || path.isAbsolute(relative)) {
+        return {};
+    }
+    return { resolverMirror: { target: `./${relative.replace(/^\.\//, "").replace(/\/$/, "")}/*` } };
+}
+function applyGlobalAliasConflicts(builds) {
+    const byAlias = new Map();
+    for (const build of builds.filter((item) => item.candidate.intent === "createAlias")) {
+        byAlias.set(build.candidate.alias, [...(byAlias.get(build.candidate.alias) ?? []), build]);
+    }
+    for (const [alias, group] of byAlias) {
+        const targets = unique(group.map((item) => item.targetRoot).filter((item) => Boolean(item)));
+        if (targets.length <= 1) {
+            continue;
+        }
+        for (const build of group) {
+            build.candidate.conflicts.push({
+                code: "alias_multiple_targets",
+                message: `${alias} is proposed for multiple target roots.`,
+                targets
+            });
+            build.candidate.disposition = "rejected";
+            build.candidate.confidence = { level: "low", reasons: ["hard conflict: alias maps to multiple targets"] };
+            build.candidate.importNormalizeFollowUp = { status: "blocked", reason: `${alias} maps to multiple targets.` };
+        }
+    }
+}
+function collapseAdoptExistingBuilds(builds, requested) {
+    if (requested) {
+        return builds;
+    }
+    const bestByAliasAndTarget = new Map();
+    const result = [];
+    for (const build of builds) {
+        const candidate = build.candidate;
+        if (candidate.intent !== "adoptExistingAlias") {
+            result.push(build);
+            continue;
+        }
+        const key = `${candidate.alias}\0${candidate.targetPattern ?? ""}`;
+        const current = bestByAliasAndTarget.get(key);
+        if (!current || isBroaderEvidence(candidate, current.candidate)) {
+            bestByAliasAndTarget.set(key, build);
+        }
+    }
+    result.push(...bestByAliasAndTarget.values());
+    return result;
+}
+function isBroaderEvidence(candidate, current) {
+    return candidate.coverage.imports > current.coverage.imports
+        || (candidate.coverage.imports === current.coverage.imports && candidate.coverage.files > current.coverage.files)
+        || (candidate.coverage.imports === current.coverage.imports
+            && candidate.coverage.files === current.coverage.files
+            && candidate.sourcePrefix.length < current.sourcePrefix.length);
+}
+function findSharedExistingAlias(snapshot, session, resolutions, requestedAlias) {
+    if (resolutions.length === 0 || resolutions.some((item) => item.status !== "resolvedInternal" || item.owningTsconfigs.length === 0)) {
+        return null;
+    }
+    const patternsPerConfig = new Map();
+    for (const resolution of resolutions) {
+        for (const owner of resolution.owningTsconfigs) {
+            const config = snapshot.tsconfigs.find((item) => item.file === owner.tsconfig);
+            const parsed = session.parsedConfig(owner.tsconfig);
+            if (!config || !parsed || owner.status !== "resolvedInternal" || !owner.targetFile) {
+                return null;
+            }
+            const valid = config.paths
+                .filter((mapping) => !GENERIC_ROOT_ALIASES.has(mapping.pattern) && mapping.pattern.includes("*"))
+                .filter((mapping) => !requestedAlias || mapping.pattern === requestedAlias)
+                .filter((mapping) => {
+                const specifier = specifierForMapping(snapshot.root, mapping, owner.targetFile);
+                const resolved = specifier ? session.resolveSpecifier(parsed, resolution.importer, specifier) : null;
+                return resolved !== null && (0, path_identity_1.sameCanonicalPath)(resolved, owner.targetFile);
+            })
+                .map((mapping) => mapping.pattern);
+            const current = patternsPerConfig.get(config.file);
+            patternsPerConfig.set(config.file, current ? intersect(current, new Set(valid)) : new Set(valid));
+        }
+    }
+    const sets = [...patternsPerConfig.values()];
+    const shared = sets.length > 0 ? sets.slice(1).reduce((result, current) => intersect(result, current), new Set(sets[0])) : new Set();
+    const pattern = [...shared].sort((left, right) => right.replace("*", "").length - left.replace("*", "").length || left.localeCompare(right))[0];
+    if (!pattern) {
+        return null;
+    }
+    const targets = unique(snapshot.tsconfigs.flatMap((config) => config.paths.filter((mapping) => mapping.pattern === pattern).flatMap((mapping) => mapping.targets)));
+    const specifiersByOccurrence = new Map();
+    let compatible = true;
+    for (const resolution of resolutions) {
+        const specifiers = resolution.owningTsconfigs.map((owner) => {
+            const mapping = snapshot.tsconfigs.find((config) => config.file === owner.tsconfig)?.paths.find((item) => item.pattern === pattern);
+            return mapping && owner.targetFile ? specifierForMapping(snapshot.root, mapping, owner.targetFile) : null;
+        });
+        const exactSpecifiers = unique(specifiers.filter((item) => item !== null));
+        if (exactSpecifiers.length !== 1 || specifiers.some((item) => item === null)) {
+            compatible = false;
+            continue;
+        }
+        const exactSpecifier = exactSpecifiers[0];
+        const confirmedByAllOwners = resolution.owningTsconfigs.every((owner) => {
+            const parsed = session.parsedConfig(owner.tsconfig);
+            const resolved = parsed ? session.resolveSpecifier(parsed, resolution.importer, exactSpecifier) : null;
+            return owner.targetFile && resolved && (0, path_identity_1.sameCanonicalPath)(resolved, owner.targetFile);
+        });
+        if (!confirmedByAllOwners) {
+            compatible = false;
+            continue;
+        }
+        specifiersByOccurrence.set(occurrenceKey(resolution), exactSpecifier);
+    }
+    return { pattern, targets, compatible, specifiersByOccurrence };
+}
+function deriveTargetRoot(resolution, prefix) {
+    if (!resolution.targetFile || !resolution.specifier.startsWith(prefix)) {
+        return null;
+    }
+    const suffix = withoutSourceExtension(resolution.specifier.slice(prefix.length)).replace(/^\/+/, "");
+    const target = withoutSourceExtension(resolution.targetFile).replace(/\\/g, "/");
+    if (!suffix || !target.toLowerCase().endsWith(`/${suffix.toLowerCase()}`)) {
+        return null;
+    }
+    return path.resolve(target.slice(0, -(suffix.length + 1)));
+}
+function mappingTargetFor(workspaceRoot, config, targetRoot) {
+    const relative = path.relative(path.resolve(workspaceRoot, config.baseUrl), targetRoot).replace(/\\/g, "/") || ".";
+    return `${relative.replace(/\/$/, "")}/*`;
+}
+function specifierForMapping(workspaceRoot, mapping, targetFile) {
+    if (!mapping.pattern.includes("*")) {
+        return null;
+    }
+    for (const rawTarget of mapping.targets) {
+        const star = rawTarget.indexOf("*");
+        if (star < 0) {
+            continue;
+        }
+        const prefix = path.resolve(workspaceRoot, mapping.baseUrl, rawTarget.slice(0, star));
+        const suffix = withoutSourceExtension(rawTarget.slice(star + 1)).replace(/^[/\\]/, "");
+        const target = withoutSourceExtension(path.resolve(targetFile));
+        const relative = path.relative(prefix, target).replace(/\\/g, "/");
+        if (relative.startsWith("..") || path.isAbsolute(relative) || (suffix && !relative.endsWith(suffix))) {
+            continue;
+        }
+        const wildcard = suffix ? relative.slice(0, -suffix.length).replace(/\/$/, "") : relative;
+        return mapping.pattern.replace("*", wildcard);
+    }
+    return null;
+}
+function boundaryRiskReasons(resolutions) {
+    return unique(resolutions
+        .filter((item) => item.status === "resolvedInternal" && Boolean(item.targetPackageRoot) && item.packageRoot !== item.targetPackageRoot)
+        .map((item) => `${item.packageRoot ?? "workspace"} -> ${item.targetPackageRoot ?? "workspace"}`));
+}
+function runtimeRiskReasons(configs, alias, intent) {
+    if (intent === "adoptExistingAlias") {
+        return [];
+    }
+    const reasons = ["non-TypeScript runtime/bundler resolver support is not proven in M2"];
+    if (alias.startsWith("#")) {
+        reasons.push("# alias may require matching package.json imports");
+    }
+    if (configs.length > 1) {
+        reasons.push("mapping must remain consistent across multiple tsconfigs");
+    }
+    return reasons;
+}
+function confidenceFor(disposition, intent, runtimeReasons) {
+    if (disposition === "rejected" || disposition === "rawEvidence") {
+        return { level: "low", reasons: [disposition === "rejected" ? "hard conflict or incomplete coverage" : "topology evidence unavailable"] };
+    }
+    if (intent === "adoptExistingAlias" && runtimeReasons.length === 0) {
+        return { level: "high", reasons: ["all covered occurrences resolve through an existing TS alias"] };
+    }
+    return { level: "medium", reasons: ["all covered occurrences resolve, but runtime resolver support is pending"] };
+}
+function filterCandidates(candidates, requested) {
+    if (!requested) {
+        return candidates;
+    }
+    return candidates.filter((candidate) => candidate.sourcePrefix === requested || candidate.alias === requested);
+}
+function countCategories(candidates) {
+    const counts = { recommended: 0, review: 0, optional: 0, rejected: 0 };
+    for (const candidate of candidates) {
+        counts[candidate.ranking.category] += 1;
+    }
+    return counts;
+}
+function packageImportsOverlap(pkg, alias) {
+    if (!pkg.imports) {
+        return false;
+    }
+    return Object.keys(pkg.imports).some((key) => pathPatternOverlaps(key, alias));
+}
+function pathPatternOverlaps(left, right) {
+    const leftPrefix = left.replace(/\*.*$/, "");
+    const rightPrefix = right.replace(/\*.*$/, "");
+    return left === right || leftPrefix.startsWith(rightPrefix) || rightPrefix.startsWith(leftPrefix);
+}
+function unresolvedWithoutTopology(occurrence) {
+    return {
+        importer: occurrence.importer,
+        displayImporter: occurrence.displayImporter,
+        specifier: occurrence.specifier,
+        position: occurrence.position,
+        status: "unresolved",
+        owningTsconfigs: [],
+        reason: "topology unavailable"
+    };
+}
+class ResolutionSession {
+    snapshot;
+    parsed = new Map();
+    resolutionCaches = new Map();
+    resolutions = new Map();
+    ownersByFile = null;
+    ownerDiagnostics = [];
+    host;
+    constructor(snapshot) {
+        this.snapshot = snapshot;
+        this.host = (0, ts_oracle_host_1.createWorkspaceModuleResolutionHost)(snapshot.root);
+    }
+    resolve(occurrence) {
+        const key = occurrenceKey(occurrence);
+        const cached = this.resolutions.get(key);
+        if (cached) {
+            return cached;
+        }
+        const ownership = (0, core_1.describeTopologyFile)(this.snapshot, occurrence.importer);
+        const owningTsconfigs = this.owningTsconfigs(occurrence.importer);
+        if (owningTsconfigs.length === 0) {
+            const result = {
+                importer: occurrence.importer,
+                displayImporter: occurrence.displayImporter,
+                specifier: occurrence.specifier,
+                position: occurrence.position,
+                status: "noOwningTsconfig",
+                owningTsconfigs: [],
+                ...(ownership.packageRoot ? { packageRoot: ownership.packageRoot } : {}),
+                ...(ownership.packageName ? { packageName: ownership.packageName } : {}),
+                reason: "no owning tsconfig"
+            };
+            this.resolutions.set(key, result);
+            return result;
+        }
+        const ownerResolutions = owningTsconfigs.map((tsconfig) => this.resolveForOwner(occurrence, tsconfig));
+        const internalTargets = uniqueCanonicalPaths(ownerResolutions
+            .filter((owner) => owner.status === "resolvedInternal" && owner.targetFile)
+            .map((owner) => owner.targetFile));
+        const allInternalSameTarget = ownerResolutions.every((owner) => owner.status === "resolvedInternal") && internalTargets.length === 1;
+        const allExternal = ownerResolutions.every((owner) => owner.status === "resolvedExternal");
+        const status = allInternalSameTarget
+            ? "resolvedInternal"
+            : allExternal
+                ? "resolvedExternal"
+                : "unresolved";
+        const targetFile = allInternalSameTarget ? internalTargets[0] : undefined;
+        const targetOwnership = targetFile ? (0, core_1.describeTopologyFile)(this.snapshot, targetFile) : null;
+        const result = {
+            importer: occurrence.importer,
+            displayImporter: occurrence.displayImporter,
+            specifier: occurrence.specifier,
+            position: occurrence.position,
+            status,
+            owningTsconfigs: ownerResolutions,
+            ...(owningTsconfigs.length === 1 ? { tsconfig: owningTsconfigs[0] } : {}),
+            ...(ownership.packageRoot ? { packageRoot: ownership.packageRoot } : {}),
+            ...(ownership.packageName ? { packageName: ownership.packageName } : {}),
+            ...(targetFile ? { targetFile } : {}),
+            ...(targetOwnership?.packageRoot ? { targetPackageRoot: targetOwnership.packageRoot } : {}),
+            ...(targetOwnership?.packageName ? { targetPackageName: targetOwnership.packageName } : {}),
+            ...(!allInternalSameTarget && !allExternal ? { reason: "owning tsconfigs produced divergent resolution outcomes" } : {})
+        };
+        this.resolutions.set(key, result);
+        return result;
+    }
+    resolveForOwner(occurrence, tsconfig) {
+        const parsed = this.parsedConfig(tsconfig);
+        if (!parsed) {
+            return { tsconfig, status: "unresolved", reason: "owning tsconfig could not be parsed" };
+        }
+        const resolved = this.resolveSpecifier(parsed, occurrence.importer, occurrence.specifier);
+        if (!resolved) {
+            const packageName = packageNameFromSpecifier(occurrence.specifier);
+            const knownExternal = packageName && !this.matchesTsconfigPath(tsconfig, occurrence.specifier) && this.knownPackageName(packageName);
+            return {
+                tsconfig,
+                status: knownExternal ? "resolvedExternal" : "unresolved",
+                reason: knownExternal ? `external package ${packageName}` : "TypeScript module resolution failed"
+            };
+        }
+        return {
+            tsconfig,
+            status: isExternalTarget(this.snapshot.root, resolved) ? "resolvedExternal" : "resolvedInternal",
+            targetFile: resolved
+        };
+    }
+    owningTsconfigs(importer) {
+        this.ensureOwnerIndex();
+        return this.ownersByFile.get((0, path_identity_1.canonicalPathIdentity)(importer)) ?? [];
+    }
+    ownerConfigDiagnostics() {
+        this.ensureOwnerIndex();
+        return [...this.ownerDiagnostics];
+    }
+    ensureOwnerIndex() {
+        if (this.ownersByFile) {
+            return;
+        }
+        this.ownersByFile = new Map();
+        const incomingExtends = new Map();
+        for (const config of this.snapshot.tsconfigs) {
+            if (!config.extends) {
+                continue;
+            }
+            const parent = (0, path_identity_1.canonicalPathIdentity)(path.resolve(this.snapshot.root, config.extends));
+            incomingExtends.set(parent, (incomingExtends.get(parent) ?? 0) + 1);
+        }
+        for (const config of this.snapshot.tsconfigs) {
+            const parsed = this.parsedConfig(config.file);
+            if (!parsed) {
+                continue;
+            }
+            const incoming = incomingExtends.get((0, path_identity_1.canonicalPathIdentity)(parsed.file)) ?? 0;
+            const explicitProjectRoots = hasExplicitProjectRoots(parsed.file);
+            if (incoming > 0 && !explicitProjectRoots) {
+                this.ownerDiagnostics.push({
+                    code: "extends_template_excluded",
+                    tsconfig: config.file,
+                    incomingExtends: incoming,
+                    explicitProjectRoots: false,
+                    fileSetProvenance: "inheritedOrDefault",
+                    message: "Config is extended by project configs and has no explicit files/include/references; its implicit file set is not owner evidence."
+                });
+                continue;
+            }
+            for (const file of parsed.parsed.fileNames) {
+                const identity = (0, path_identity_1.canonicalPathIdentity)(file);
+                this.ownersByFile.set(identity, [...(this.ownersByFile.get(identity) ?? []), config.file]);
+            }
+        }
+    }
+    parsedConfig(tsconfig) {
+        if (this.parsed.has(tsconfig)) {
+            return this.parsed.get(tsconfig) ?? null;
+        }
+        const diagnostics = [];
+        const parsed = (0, tsconfig_loader_1.parseTsConfig)(path.resolve(this.snapshot.root, tsconfig), diagnostics);
+        this.parsed.set(tsconfig, parsed);
+        return parsed;
+    }
+    resolveSpecifier(parsed, importer, specifier) {
+        const cacheKey = parsed.file;
+        const cache = this.resolutionCaches.get(cacheKey) ?? typescript_1.default.createModuleResolutionCache(path.dirname(parsed.file), canonicalFileName, parsed.parsed.options);
+        this.resolutionCaches.set(cacheKey, cache);
+        return normalizeResolvedFile(typescript_1.default.resolveModuleName(specifier, importer, parsed.parsed.options, this.host, cache).resolvedModule?.resolvedFileName);
+    }
+    resolveWithProposedMapping(parsed, config, importer, specifier, alias, mappingTarget) {
+        const options = {
+            ...parsed.parsed.options,
+            baseUrl: path.resolve(this.snapshot.root, config.baseUrl),
+            paths: {
+                ...(parsed.parsed.options.paths ?? {}),
+                [alias]: [mappingTarget]
+            }
+        };
+        const cache = typescript_1.default.createModuleResolutionCache(path.dirname(parsed.file), canonicalFileName, options);
+        return normalizeResolvedFile(typescript_1.default.resolveModuleName(specifier, importer, options, this.host, cache).resolvedModule?.resolvedFileName);
+    }
+    matchesTsconfigPath(tsconfig, specifier) {
+        return this.snapshot.tsconfigs.find((item) => item.file === tsconfig)?.paths.some((mapping) => matchPathPattern(specifier, mapping.pattern)) ?? false;
+    }
+    knownPackageName(packageName) {
+        return this.snapshot.packages.some((pkg) => pkg.name === packageName || pkg.dependencies.includes(packageName));
+    }
+}
+function matchPathPattern(specifier, pattern) {
+    const star = pattern.indexOf("*");
+    if (star < 0) {
+        return specifier === pattern;
+    }
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    return specifier.startsWith(prefix) && specifier.endsWith(suffix);
+}
+function hasExplicitProjectRoots(configFile) {
+    const read = typescript_1.default.readConfigFile(configFile, typescript_1.default.sys.readFile);
+    if (read.error || !read.config || typeof read.config !== "object") {
+        return false;
+    }
+    return ["files", "include", "references"].some((key) => Object.prototype.hasOwnProperty.call(read.config, key));
+}
+function packageNameFromSpecifier(specifier) {
+    if (specifier.startsWith(".") || specifier.startsWith("#") || specifier.startsWith("@/")) {
+        return null;
+    }
+    const parts = specifier.split("/");
+    return specifier.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null : parts[0] || null;
+}
+function isExternalTarget(root, target) {
+    const relative = path.relative(root, target).replace(/\\/g, "/");
+    return relative.startsWith("../") || path.isAbsolute(relative) || relative.split("/").includes("node_modules");
+}
+function normalizeResolvedFile(file) {
+    if (!file) {
+        return null;
+    }
+    return path.resolve(file).replace(/\.d\.ts$/i, ".ts");
+}
+function canonicalFileName(file) {
+    return (0, path_identity_1.canonicalPathIdentity)(file);
+}
+function withoutSourceExtension(file) {
+    return file.replace(SOURCE_EXTENSION_RE, "");
+}
+function occurrenceKey(occurrence) {
+    return `${(0, path_identity_1.canonicalPathIdentity)(occurrence.importer)}\0${occurrence.position}\0${occurrence.specifier}`;
+}
+function uniqueOccurrences(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const key = occurrenceKey(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function candidateId(prefix, alias, target) {
+    return `alias_${(0, node_crypto_1.createHash)("sha256").update(`${prefix}\0${alias}\0${target}`).digest("hex").slice(0, 10)}`;
+}
+function toDisplayPath(root, file) {
+    const relative = path.relative(path.resolve(root), path.resolve(file)).replace(/\\/g, "/");
+    return relative === "" ? "." : relative.startsWith("../") || path.isAbsolute(relative) ? path.resolve(file).replace(/\\/g, "/") : relative;
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function uniqueCanonicalPaths(items) {
+    const byIdentity = new Map();
+    for (const item of items) {
+        byIdentity.set((0, path_identity_1.canonicalPathIdentity)(item), item);
+    }
+    return [...byIdentity.values()];
+}
+function ownerResolutionsDiverge(resolution) {
+    if (resolution.owningTsconfigs.length <= 1) {
+        return false;
+    }
+    const outcomes = new Set(resolution.owningTsconfigs.map((owner) => `${owner.status}:${owner.targetFile ? (0, path_identity_1.canonicalPathIdentity)(owner.targetFile) : owner.reason ?? ""}`));
+    return outcomes.size > 1;
+}
+function intersect(left, right) {
+    return new Set([...left].filter((item) => right.has(item)));
+}