@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/topology/availability.js

@@ -0,0 +1,663 @@
+"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.buildTopologyAvailabilityView = buildTopologyAvailabilityView;
+exports.buildStructuralTopologyAvailabilityView = buildStructuralTopologyAvailabilityView;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function buildTopologyAvailabilityView(snapshot, candidateSet, oracle) {
+    const startedAt = Date.now();
+    const resultByCandidate = new Map(oracle.results.map((result) => [result.candidateId, result]));
+    const providerMap = new Map();
+    const validProofs = [];
+    let invalidCandidates = 0;
+    for (const candidate of candidateSet.candidates) {
+        const result = resultByCandidate.get(candidate.id);
+        if (!result || result.status !== "valid") {
+            invalidCandidates += 1;
+            continue;
+        }
+        const provider = candidateSet.boundaries.find((boundary) => boundary.path === candidate.providerBoundary) ?? { path: candidate.providerBoundary };
+        const entry = providerMap.get(candidate.providerBoundary) ?? { provider, consumers: [] };
+        const consumer = entry.consumers.find((item) => item.boundary === candidate.consumerBoundary);
+        const displaySpecifier = candidate.aliasPattern;
+        if (consumer) {
+            if (!consumer.specifiers.includes(displaySpecifier)) {
+                consumer.specifiers.push(displaySpecifier);
+            }
+        }
+        else {
+            entry.consumers.push({
+                boundary: candidate.consumerBoundary,
+                specifiers: [displaySpecifier]
+            });
+        }
+        validProofs.push({
+            providerBoundary: candidate.providerBoundary,
+            consumerBoundary: candidate.consumerBoundary,
+            aliasPattern: candidate.aliasPattern,
+            targetPattern: candidate.targetPattern,
+            probeSpecifier: candidate.specifier,
+            targetFile: candidate.targetFile,
+            ...(candidate.targetRoot ? { targetRoot: candidate.targetRoot } : {}),
+            ...(result.resolvedFile ? { resolvedFile: result.resolvedFile } : {}),
+            tsconfig: candidate.consumerTsconfig
+        });
+        providerMap.set(candidate.providerBoundary, entry);
+    }
+    const providers = [...providerMap.values()]
+        .map((provider) => ({
+        ...provider,
+        consumers: provider.consumers
+            .map((consumer) => ({ ...consumer, specifiers: consumer.specifiers.sort(compareSpecifiers) }))
+            .sort((left, right) => boundaryOrder(candidateSet.boundaries, left.boundary) - boundaryOrder(candidateSet.boundaries, right.boundary) || left.boundary.localeCompare(right.boundary))
+    }))
+        .sort((left, right) => right.consumers.length - left.consumers.length ||
+        boundaryOrder(candidateSet.boundaries, left.provider.path) - boundaryOrder(candidateSet.boundaries, right.provider.path) ||
+        left.provider.path.localeCompare(right.provider.path));
+    const exposed = new Set(providers.map((provider) => provider.provider.path));
+    const notExposed = candidateSet.boundaries.filter((boundary) => !exposed.has(boundary.path));
+    const resolutionHealth = buildResolutionHealth(snapshot, candidateSet, oracle, validProofs.length, invalidCandidates);
+    const availabilityMs = Date.now() - startedAt;
+    return {
+        validationMode: "oracle",
+        boundaries: candidateSet.boundaries,
+        aliasScopes: buildAliasScopes(snapshot, candidateSet.boundaries),
+        providers,
+        notExposed,
+        diagnostics: [
+            ...snapshot.diagnostics,
+            ...oracle.diagnostics.map((diagnostic) => ({
+                code: diagnostic.code,
+                message: diagnostic.message,
+                ...(diagnostic.file ? { file: diagnostic.file } : {})
+            }))
+        ],
+        resolutionHealth,
+        timings: {
+            scopeMs: snapshot.timings.scopeMs ?? 0,
+            catalogMs: (snapshot.timings.tsconfigMs ?? 0) + (snapshot.timings.packageMs ?? 0) + (snapshot.timings.dependencyMs ?? 0) + (snapshot.timings.boundaryMs ?? 0),
+            dependencyMs: snapshot.timings.dependencyMs ?? 0,
+            candidateMs: candidateSet.timings.totalMs,
+            oracleMs: oracle.timings.totalMs,
+            availabilityMs,
+            totalMs: (snapshot.timings.totalMs ?? 0) + candidateSet.timings.totalMs + oracle.timings.totalMs + availabilityMs
+        },
+        debug: {
+            candidates: candidateSet.candidates.length,
+            candidateSkipped: candidateSet.skipped,
+            oracleGroups: oracle.groups,
+            invalidCandidates,
+            validProofs: validProofs.sort((left, right) => left.providerBoundary.localeCompare(right.providerBoundary) ||
+                left.consumerBoundary.localeCompare(right.consumerBoundary) ||
+                left.aliasPattern.localeCompare(right.aliasPattern) ||
+                left.probeSpecifier.localeCompare(right.probeSpecifier))
+        }
+    };
+}
+/**
+ * Builds configured package/alias availability without starting TypeScript Programs.
+ * Candidates are already bounded by discovered package manifests, owning configs and
+ * concrete source targets. The heavier oracle remains available through
+ * buildTopologyAvailabilityView when a caller explicitly needs project diagnostics.
+ */
+function buildStructuralTopologyAvailabilityView(snapshot, candidateSet) {
+    const startedAt = Date.now();
+    const providerMap = new Map();
+    const validProofs = [];
+    for (const candidate of candidateSet.candidates) {
+        const provider = candidateSet.boundaries.find((boundary) => boundary.path === candidate.providerBoundary) ?? {
+            path: candidate.providerBoundary
+        };
+        const entry = providerMap.get(candidate.providerBoundary) ?? { provider, consumers: [] };
+        const consumer = entry.consumers.find((item) => item.boundary === candidate.consumerBoundary);
+        if (consumer) {
+            if (!consumer.specifiers.includes(candidate.aliasPattern))
+                consumer.specifiers.push(candidate.aliasPattern);
+        }
+        else {
+            entry.consumers.push({ boundary: candidate.consumerBoundary, specifiers: [candidate.aliasPattern] });
+        }
+        validProofs.push({
+            providerBoundary: candidate.providerBoundary,
+            consumerBoundary: candidate.consumerBoundary,
+            aliasPattern: candidate.aliasPattern,
+            targetPattern: candidate.targetPattern,
+            probeSpecifier: candidate.specifier,
+            targetFile: candidate.targetFile,
+            ...(candidate.targetRoot ? { targetRoot: candidate.targetRoot } : {}),
+            tsconfig: candidate.consumerTsconfig
+        });
+        providerMap.set(candidate.providerBoundary, entry);
+    }
+    const providers = [...providerMap.values()]
+        .map((provider) => ({
+        ...provider,
+        consumers: provider.consumers
+            .map((consumer) => ({ ...consumer, specifiers: consumer.specifiers.sort(compareSpecifiers) }))
+            .sort((left, right) => boundaryOrder(candidateSet.boundaries, left.boundary) - boundaryOrder(candidateSet.boundaries, right.boundary) ||
+            left.boundary.localeCompare(right.boundary))
+    }))
+        .sort((left, right) => right.consumers.length - left.consumers.length ||
+        boundaryOrder(candidateSet.boundaries, left.provider.path) - boundaryOrder(candidateSet.boundaries, right.provider.path) ||
+        left.provider.path.localeCompare(right.provider.path));
+    const exposed = new Set(providers.map((provider) => provider.provider.path));
+    const skipped = candidateSet.skipped.reduce((sum, item) => sum + item.count, 0);
+    const bySource = candidateSet.candidates.reduce((counts, candidate) => {
+        if (candidate.source === "package-dependency")
+            counts.packageDependency += 1;
+        else
+            counts.tsconfigPath += 1;
+        return counts;
+    }, { tsconfigPath: 0, packageDependency: 0 });
+    const availabilityMs = Date.now() - startedAt;
+    return {
+        validationMode: "structural",
+        boundaries: candidateSet.boundaries,
+        aliasScopes: buildAliasScopes(snapshot, candidateSet.boundaries),
+        providers,
+        notExposed: candidateSet.boundaries.filter((boundary) => !exposed.has(boundary.path)),
+        diagnostics: [...snapshot.diagnostics],
+        resolutionHealth: {
+            dependencySnapshot: snapshot.dependencySnapshot,
+            confidence: "complete",
+            candidates: {
+                total: candidateSet.candidates.length,
+                confirmed: candidateSet.candidates.length,
+                invalid: 0,
+                unresolved: 0,
+                targetMismatch: 0,
+                projectInvalid: 0,
+                unknown: 0,
+                resolutionOnly: 0,
+                skipped,
+                bySource
+            },
+            notes: ["Structural availability only; the TypeScript project oracle was not run."],
+            unconfirmedReasons: [],
+            packageEntryIssues: [],
+            targetResolutionIssues: []
+        },
+        timings: {
+            scopeMs: snapshot.timings.scopeMs ?? 0,
+            catalogMs: (snapshot.timings.tsconfigMs ?? 0) + (snapshot.timings.packageMs ?? 0) +
+                (snapshot.timings.dependencyMs ?? 0) + (snapshot.timings.boundaryMs ?? 0),
+            dependencyMs: snapshot.timings.dependencyMs ?? 0,
+            candidateMs: candidateSet.timings.totalMs,
+            oracleMs: 0,
+            availabilityMs,
+            totalMs: (snapshot.timings.totalMs ?? 0) + candidateSet.timings.totalMs + availabilityMs
+        },
+        debug: {
+            candidates: candidateSet.candidates.length,
+            candidateSkipped: candidateSet.skipped,
+            oracleGroups: [],
+            invalidCandidates: 0,
+            validProofs: validProofs.sort((left, right) => left.providerBoundary.localeCompare(right.providerBoundary) ||
+                left.consumerBoundary.localeCompare(right.consumerBoundary) ||
+                left.aliasPattern.localeCompare(right.aliasPattern) ||
+                left.probeSpecifier.localeCompare(right.probeSpecifier))
+        }
+    };
+}
+function buildResolutionHealth(snapshot, candidateSet, oracle, confirmed, invalidCandidates) {
+    let unresolved = 0;
+    let targetMismatch = 0;
+    let projectInvalid = 0;
+    let unknown = 0;
+    for (const result of oracle.results) {
+        if (result.status === "unresolved") {
+            unresolved += 1;
+        }
+        else if (result.status === "target-mismatch") {
+            targetMismatch += 1;
+        }
+        else if (result.status === "resolves-but-project-invalid") {
+            projectInvalid += 1;
+        }
+        else if (result.status === "unknown") {
+            unknown += 1;
+        }
+    }
+    const resolutionOnly = oracle.groups.reduce((sum, group) => sum + group.resolutionOnlyCandidates, 0);
+    const bySource = candidateSet.candidates.reduce((counts, candidate) => {
+        if (candidate.source === "package-dependency") {
+            counts.packageDependency += 1;
+        }
+        else {
+            counts.tsconfigPath += 1;
+        }
+        return counts;
+    }, { tsconfigPath: 0, packageDependency: 0 });
+    const skipped = candidateSet.skipped.reduce((sum, item) => sum + item.count, 0);
+    const unconfirmedReasons = classifyUnconfirmedReasons(snapshot, candidateSet, oracle);
+    const packageEntryIssues = buildPackageEntryIssues(snapshot, candidateSet, oracle);
+    const targetResolutionIssues = buildTargetResolutionIssues(snapshot, candidateSet, oracle);
+    const notes = buildHealthNotes(snapshot, {
+        resolutionOnly,
+        unresolved,
+        packageDependencyCandidates: bySource.packageDependency,
+        skipped
+    });
+    return {
+        dependencySnapshot: snapshot.dependencySnapshot,
+        confidence: inferHealthConfidence(snapshot.dependencySnapshot.state, resolutionOnly, unresolved, unknown),
+        candidates: {
+            total: candidateSet.candidates.length,
+            confirmed,
+            invalid: invalidCandidates,
+            unresolved,
+            targetMismatch,
+            projectInvalid,
+            unknown,
+            resolutionOnly,
+            skipped,
+            bySource
+        },
+        notes,
+        unconfirmedReasons,
+        packageEntryIssues,
+        targetResolutionIssues
+    };
+}
+function classifyUnconfirmedReasons(snapshot, candidateSet, oracle) {
+    const candidateById = new Map(candidateSet.candidates.map((candidate) => [candidate.id, candidate]));
+    const counts = new Map();
+    for (const result of oracle.results) {
+        if (result.status === "valid") {
+            continue;
+        }
+        const candidate = candidateById.get(result.candidateId);
+        const reason = candidate
+            ? classifyUnconfirmedCandidate(snapshot, candidate, result)
+            : "candidate-result-without-candidate";
+        counts.set(reason, (counts.get(reason) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([reason, count]) => ({ reason, count }))
+        .sort((left, right) => right.count - left.count || left.reason.localeCompare(right.reason));
+}
+function classifyUnconfirmedCandidate(snapshot, candidate, result) {
+    const status = result.status;
+    if (status === "target-mismatch") {
+        if (result.resolvedFile && isResolvedOutsideWorkspace(snapshot, result.resolvedFile)) {
+            return candidate.source === "package-dependency"
+                ? "package-dependency-resolved-outside-workspace"
+                : "resolved-outside-workspace";
+        }
+        return "target-mismatch";
+    }
+    if (status === "resolves-but-project-invalid") {
+        return "project-invalid";
+    }
+    if (candidate.source !== "package-dependency") {
+        return status === "unresolved" ? "tsconfig-path-unresolved" : status;
+    }
+    if (status !== "unresolved") {
+        return `package-dependency-${status}`;
+    }
+    const pkg = findProviderPackage(snapshot, candidate);
+    if (!pkg) {
+        return "package-dependency-provider-package-not-found";
+    }
+    if (!hasBarePackageEntry(pkg)) {
+        return "package-dependency-no-root-entry";
+    }
+    const targets = collectPackageEntryTargets(pkg);
+    if (targets.length === 0) {
+        return "package-dependency-no-entry-targets";
+    }
+    const existing = targets.filter((target) => target.exists);
+    const enabledCustomConditions = findConsumerCustomConditions(snapshot, candidate);
+    const disabledSourceConditions = existing
+        .filter((target) => target.isSource && target.condition && !isDefaultExportCondition(target.condition))
+        .map((target) => target.condition)
+        .filter(isString)
+        .filter((condition) => !enabledCustomConditions.includes(condition));
+    if (disabledSourceConditions.length > 0) {
+        return "package-dependency-source-condition-not-enabled";
+    }
+    if (existing.length === 0 && targets.some((target) => target.isBuildOutput)) {
+        return "package-dependency-build-output-missing";
+    }
+    if (existing.length === 0) {
+        return "package-dependency-entry-target-missing";
+    }
+    return "package-dependency-unresolved";
+}
+function buildPackageEntryIssues(snapshot, candidateSet, oracle) {
+    const candidateById = new Map(candidateSet.candidates.map((candidate) => [candidate.id, candidate]));
+    const issueMap = new Map();
+    for (const result of oracle.results) {
+        if (result.status === "valid") {
+            continue;
+        }
+        const candidate = candidateById.get(result.candidateId);
+        if (!candidate || candidate.source !== "package-dependency") {
+            continue;
+        }
+        const pkg = findProviderPackage(snapshot, candidate);
+        if (!pkg) {
+            continue;
+        }
+        const reason = classifyUnconfirmedCandidate(snapshot, candidate, result);
+        if (!isPackageEntryIssueReason(reason)) {
+            continue;
+        }
+        const targets = collectPackageEntryTargets(pkg);
+        const enabledCustomConditions = findConsumerCustomConditions(snapshot, candidate);
+        const key = `${reason}\n${candidate.providerBoundary}\n${candidate.specifier}`;
+        const issue = issueMap.get(key) ?? {
+            reason,
+            providerBoundary: candidate.providerBoundary,
+            ...(pkg.name ? { packageName: pkg.name } : {}),
+            specifier: candidate.specifier,
+            count: 0,
+            consumerBoundaries: new Set(),
+            consumerTsconfigs: new Set(),
+            missingTargets: new Set(),
+            availableSourceConditions: new Set(),
+            enabledCustomConditions: new Set()
+        };
+        issue.count += 1;
+        issue.consumerBoundaries.add(candidate.consumerBoundary);
+        issue.consumerTsconfigs.add(candidate.consumerTsconfig);
+        for (const condition of enabledCustomConditions) {
+            issue.enabledCustomConditions.add(condition);
+        }
+        for (const target of targets) {
+            if (!target.exists) {
+                issue.missingTargets.add(target.target);
+            }
+            if (target.isSource && target.condition && !isDefaultExportCondition(target.condition)) {
+                issue.availableSourceConditions.add(target.condition);
+            }
+        }
+        issueMap.set(key, issue);
+    }
+    return [...issueMap.values()]
+        .map((issue) => ({
+        reason: issue.reason,
+        providerBoundary: issue.providerBoundary,
+        ...(issue.packageName ? { packageName: issue.packageName } : {}),
+        specifier: issue.specifier,
+        count: issue.count,
+        consumerBoundaries: [...issue.consumerBoundaries].sort(),
+        consumerTsconfigs: [...issue.consumerTsconfigs].sort(),
+        missingTargets: [...issue.missingTargets].sort(),
+        availableSourceConditions: [...issue.availableSourceConditions].sort(),
+        enabledCustomConditions: [...issue.enabledCustomConditions].sort()
+    }))
+        .sort((left, right) => right.count - left.count ||
+        left.reason.localeCompare(right.reason) ||
+        left.providerBoundary.localeCompare(right.providerBoundary) ||
+        left.specifier.localeCompare(right.specifier));
+}
+function buildTargetResolutionIssues(snapshot, candidateSet, oracle) {
+    const candidateById = new Map(candidateSet.candidates.map((candidate) => [candidate.id, candidate]));
+    const issueMap = new Map();
+    for (const result of oracle.results) {
+        if (result.status !== "target-mismatch") {
+            continue;
+        }
+        const candidate = candidateById.get(result.candidateId);
+        if (!candidate) {
+            continue;
+        }
+        const reason = classifyUnconfirmedCandidate(snapshot, candidate, result);
+        const pkg = findProviderPackage(snapshot, candidate);
+        const key = `${reason}\n${candidate.providerBoundary}\n${candidate.specifier}\n${candidate.targetFile}`;
+        const issue = issueMap.get(key) ?? {
+            reason,
+            providerBoundary: candidate.providerBoundary,
+            ...(pkg?.name ? { packageName: pkg.name } : {}),
+            specifier: candidate.specifier,
+            count: 0,
+            expectedTargetFile: candidate.targetFile,
+            ...(candidate.targetRoot ? { targetRoot: candidate.targetRoot } : {}),
+            resolvedFiles: new Set(),
+            consumerBoundaries: new Set(),
+            consumerTsconfigs: new Set()
+        };
+        issue.count += 1;
+        if (result.resolvedFile) {
+            issue.resolvedFiles.add(result.resolvedFile);
+        }
+        issue.consumerBoundaries.add(candidate.consumerBoundary);
+        issue.consumerTsconfigs.add(candidate.consumerTsconfig);
+        issueMap.set(key, issue);
+    }
+    return [...issueMap.values()]
+        .map((issue) => ({
+        reason: issue.reason,
+        providerBoundary: issue.providerBoundary,
+        ...(issue.packageName ? { packageName: issue.packageName } : {}),
+        specifier: issue.specifier,
+        count: issue.count,
+        expectedTargetFile: issue.expectedTargetFile,
+        ...(issue.targetRoot ? { targetRoot: issue.targetRoot } : {}),
+        resolvedFiles: [...issue.resolvedFiles].sort(),
+        consumerBoundaries: [...issue.consumerBoundaries].sort(),
+        consumerTsconfigs: [...issue.consumerTsconfigs].sort()
+    }))
+        .sort((left, right) => right.count - left.count ||
+        left.reason.localeCompare(right.reason) ||
+        left.providerBoundary.localeCompare(right.providerBoundary) ||
+        left.specifier.localeCompare(right.specifier));
+}
+function isPackageEntryIssueReason(reason) {
+    return reason === "package-dependency-build-output-missing" ||
+        reason === "package-dependency-source-condition-not-enabled" ||
+        reason === "package-dependency-entry-target-missing" ||
+        reason === "package-dependency-no-entry-targets";
+}
+function hasBarePackageEntry(pkg) {
+    if (pkg.main || pkg.module || pkg.types || pkg.typings) {
+        return true;
+    }
+    if (!pkg.exports) {
+        return false;
+    }
+    return Object.prototype.hasOwnProperty.call(pkg.exports, ".");
+}
+function findProviderPackage(snapshot, candidate) {
+    if (candidate.targetRoot) {
+        const targetRoot = path.resolve(snapshot.root, candidate.targetRoot);
+        return snapshot.packages.find((pkg) => path.resolve(pkg.root) === targetRoot);
+    }
+    return snapshot.packages.find((pkg) => pkg.name === candidate.aliasPattern);
+}
+function findConsumerCustomConditions(snapshot, candidate) {
+    return snapshot.tsconfigs.find((config) => config.file === candidate.consumerTsconfig)?.customConditions ?? [];
+}
+function collectPackageEntryTargets(pkg) {
+    const targets = [
+        ...packageExportTargets(pkg.exports?.["."], []),
+        ...optionalPackageTarget("types", pkg.types),
+        ...optionalPackageTarget("typings", pkg.typings),
+        ...optionalPackageTarget("module", pkg.module),
+        ...optionalPackageTarget("main", pkg.main)
+    ];
+    const seen = new Set();
+    const result = [];
+    for (const item of targets) {
+        if (path.isAbsolute(item.target) || item.target.startsWith("#")) {
+            continue;
+        }
+        if (/\/?package\.json$/i.test(item.target)) {
+            continue;
+        }
+        const key = `${item.condition ?? ""}\n${item.target}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const absolute = path.resolve(pkg.root, item.target);
+        const normalizedTarget = item.target.replace(/\\/g, "/");
+        const isBuildOutput = /(^|\/)(dist|build|lib|cjs|esm|modern|legacy)\//.test(normalizedTarget);
+        result.push({
+            ...(item.condition ? { condition: item.condition } : {}),
+            target: item.target,
+            exists: fs.existsSync(absolute),
+            isSource: !isBuildOutput && (/(^|\/)src\//.test(normalizedTarget) || /\.[cm]?[tj]sx?$/.test(normalizedTarget) && !/\.d\.[cm]?[tj]s$/.test(normalizedTarget)),
+            isBuildOutput
+        });
+    }
+    return result;
+}
+function packageExportTargets(value, conditions) {
+    if (typeof value === "string") {
+        const condition = conditions[conditions.length - 1];
+        return [{ ...(condition ? { condition } : {}), target: value }];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => packageExportTargets(item, conditions));
+    }
+    if (value && typeof value === "object") {
+        return Object.entries(value).flatMap(([key, nested]) => packageExportTargets(nested, key.startsWith(".") ? conditions : [...conditions, key]));
+    }
+    return [];
+}
+function optionalPackageTarget(condition, target) {
+    return typeof target === "string" ? [{ condition, target }] : [];
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function isDefaultExportCondition(condition) {
+    return condition === "default" || condition === "import" || condition === "require" || condition === "types";
+}
+function isResolvedOutsideWorkspace(snapshot, resolvedFile) {
+    if (!path.isAbsolute(resolvedFile)) {
+        return false;
+    }
+    return !isPathInsideOrEqual(path.resolve(resolvedFile), path.resolve(snapshot.root));
+}
+function isPathInsideOrEqual(candidate, parent) {
+    const relative = path.relative(parent, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function inferHealthConfidence(dependencyState, resolutionOnly, unresolved, unknown) {
+    if (dependencyState === "absent" || dependencyState === "partial" || resolutionOnly > 0 || unresolved > 0) {
+        return "incomplete";
+    }
+    if (dependencyState === "unknown" || unknown > 0) {
+        return "unknown";
+    }
+    return "complete";
+}
+function buildHealthNotes(snapshot, stats) {
+    const notes = [];
+    const deps = snapshot.dependencySnapshot;
+    if (deps.state === "absent") {
+        notes.push("dependency install artifacts are absent; package-name availability may be incomplete");
+    }
+    else if (deps.state === "partial") {
+        notes.push("dependency install artifacts look partial; some package-name availability may be incomplete");
+    }
+    else if (deps.state === "unknown") {
+        notes.push("dependency install state is unknown");
+    }
+    if (stats.resolutionOnly > 0) {
+        notes.push(`${stats.resolutionOnly} candidates were not project-validated`);
+    }
+    if (stats.unresolved > 0) {
+        notes.push(`${stats.unresolved} candidates did not resolve`);
+    }
+    if (stats.packageDependencyCandidates > 0 && deps.state !== "present") {
+        notes.push(`${stats.packageDependencyCandidates} package dependency candidates depend on dependency/install state`);
+    }
+    if (stats.skipped > 0) {
+        notes.push(`${stats.skipped} candidate opportunities were skipped before oracle validation`);
+    }
+    return notes;
+}
+function buildAliasScopes(snapshot, boundaries) {
+    const packageConfigs = snapshot.tsconfigs.filter((config) => /^packages\/[^/]+\/tsconfig\.json$/.test(config.file));
+    const signatureCounts = new Map();
+    for (const config of packageConfigs) {
+        for (const entry of config.paths) {
+            const key = aliasKey(entry.pattern, entry.targets);
+            signatureCounts.set(key, (signatureCounts.get(key) ?? 0) + 1);
+        }
+    }
+    const common = new Map();
+    for (const config of packageConfigs) {
+        for (const entry of config.paths) {
+            const key = aliasKey(entry.pattern, entry.targets);
+            if ((signatureCounts.get(key) ?? 0) > 1) {
+                common.set(key, { pattern: entry.pattern, targets: entry.targets });
+            }
+        }
+    }
+    const scopes = [];
+    if (common.size > 0) {
+        scopes.push({ scope: "packages/*", paths: [...common.values()].sort(compareAliasEntries) });
+    }
+    for (const config of packageConfigs) {
+        const boundary = config.file.replace(/\/tsconfig\.json$/, "");
+        const additions = config.paths
+            .filter((entry) => !common.has(aliasKey(entry.pattern, entry.targets)))
+            .map((entry) => ({ pattern: entry.pattern, targets: entry.targets }))
+            .sort(compareAliasEntries);
+        if (additions.length > 0 && boundaries.some((item) => item.path === boundary)) {
+            scopes.push({ scope: `${boundary} adds`, paths: additions });
+        }
+    }
+    const rootConfig = snapshot.tsconfigs.find((config) => config.file === "tsconfig.json");
+    if (rootConfig?.paths.length) {
+        scopes.push({
+            scope: "src",
+            paths: rootConfig.paths.map((entry) => ({ pattern: entry.pattern, targets: entry.targets })).sort(compareAliasEntries)
+        });
+    }
+    return scopes;
+}
+function aliasKey(pattern, targets) {
+    return `${pattern}\n${targets.join("\n")}`;
+}
+function compareAliasEntries(left, right) {
+    return left.pattern.localeCompare(right.pattern);
+}
+function compareSpecifiers(left, right) {
+    return left.length - right.length || left.localeCompare(right);
+}
+function boundaryOrder(boundaries, boundary) {
+    const index = boundaries.findIndex((item) => item.path === boundary);
+    if (index < 0) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return boundary === "src" ? index + 10_000 : index;
+}