@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/topology/core.js

@@ -0,0 +1,903 @@
+"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.buildProjectTopologySnapshot = buildProjectTopologySnapshot;
+exports.describeTopologyFile = describeTopologyFile;
+exports.resolveTopologyReachability = resolveTopologyReachability;
+exports.buildBoundaryRelations = buildBoundaryRelations;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_discovery_1 = require("../config/tsconfig-discovery");
+const errors_1 = require("../shared/errors");
+const dependency_snapshot_1 = require("./dependency-snapshot");
+const scope_1 = require("./scope");
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+const EXCLUDED_DIRS = new Set(["node_modules", ".git", ".tmp", ".next", "dist", "out", "coverage"]);
+function buildProjectTopologySnapshot(root, options = {}) {
+    const startedAt = Date.now();
+    const workspaceRoot = path.resolve(root);
+    const diagnostics = [];
+    const scope = (0, scope_1.createTopologyScope)(workspaceRoot, options.scope);
+    const tsconfigStartedAt = Date.now();
+    const tsconfigResult = readTsConfigSnapshots(workspaceRoot, diagnostics, scope);
+    const tsconfigs = tsconfigResult.configs;
+    const tsconfigMs = Date.now() - tsconfigStartedAt;
+    const packageStartedAt = Date.now();
+    const packages = readPackageSnapshots(workspaceRoot, diagnostics, scope);
+    const packageMs = Date.now() - packageStartedAt;
+    const dependencyStartedAt = Date.now();
+    const dependencySnapshot = (0, dependency_snapshot_1.buildTopologyDependencySnapshot)(workspaceRoot, packages);
+    const dependencyMs = Date.now() - dependencyStartedAt;
+    const totalMs = Date.now() - startedAt;
+    return {
+        operation: "inspect.topology",
+        version: 1,
+        root: workspaceRoot,
+        mode: "lazy",
+        builtAt: new Date().toISOString(),
+        buildMs: totalMs,
+        timings: {
+            scopeMs: scope.timings.totalMs,
+            tsconfigDiscoveryMs: tsconfigResult.discoveryMs,
+            tsconfigMs,
+            packageMs,
+            dependencyMs,
+            totalMs
+        },
+        scope: {
+            mode: scope.mode,
+            defaultExcludes: scope.defaultExcludes,
+            configExcludes: scope.configExcludes
+        },
+        dependencySnapshot,
+        tsconfigs,
+        packages,
+        diagnostics
+    };
+}
+function describeTopologyFile(snapshot, filePath) {
+    return describeFileOwnership(snapshot, resolveInsideRoot(snapshot.root, filePath));
+}
+function resolveTopologyReachability(snapshot, fromFile, toFile) {
+    const from = resolveInsideRoot(snapshot.root, fromFile);
+    const to = resolveInsideRoot(snapshot.root, toFile);
+    const diagnostics = [];
+    if (!fs.existsSync(from)) {
+        diagnostics.push({ code: "TOPOLOGY_FROM_NOT_FOUND", message: "Importer file does not exist.", file: toDisplayPath(snapshot.root, from) });
+    }
+    if (!fs.existsSync(to)) {
+        diagnostics.push({ code: "TOPOLOGY_TO_NOT_FOUND", message: "Target file does not exist.", file: toDisplayPath(snapshot.root, to) });
+    }
+    const owner = {
+        from: describeFileOwnership(snapshot, from),
+        to: describeFileOwnership(snapshot, to)
+    };
+    const candidates = buildImportSpecifierCandidates(snapshot, from, to, owner);
+    return {
+        from: toDisplayPath(snapshot.root, from),
+        to: toDisplayPath(snapshot.root, to),
+        reachable: candidates.some((candidate) => candidate.valid),
+        owner,
+        candidates,
+        diagnostics: [...diagnostics, ...owner.from.diagnostics, ...owner.to.diagnostics]
+    };
+}
+function buildBoundaryRelations(snapshot, boundaryPath) {
+    const target = resolveInsideRoot(snapshot.root, boundaryPath);
+    const targetPackage = findOwningPackage(snapshot, target);
+    const targetRoot = targetPackage?.root ?? target;
+    const diagnostics = [];
+    if (!targetPackage) {
+        diagnostics.push({
+            code: "TOPOLOGY_BOUNDARY_PACKAGE_NOT_FOUND",
+            message: "Boundary path is not inside a discovered package.",
+            file: toDisplayPath(snapshot.root, target)
+        });
+    }
+    const canImport = [];
+    const canBeImportedBy = [];
+    for (const pkg of snapshot.packages) {
+        if (pkg.root === targetRoot) {
+            continue;
+        }
+        canImport.push(packageRelation(snapshot.root, targetPackage ?? undefined, pkg));
+        canBeImportedBy.push(packageRelation(snapshot.root, pkg, targetPackage ?? undefined));
+    }
+    return {
+        boundary: toDisplayPath(snapshot.root, targetRoot),
+        ...(targetPackage?.root ? { packageRoot: toDisplayPath(snapshot.root, targetPackage.root) } : {}),
+        ...(targetPackage?.name ? { packageName: targetPackage.name } : {}),
+        canImport: canImport.sort(compareBoundaryRelations),
+        canBeImportedBy: canBeImportedBy.sort(compareBoundaryRelations),
+        diagnostics
+    };
+}
+function readTsConfigSnapshots(root, diagnostics, scope) {
+    const discovery = (0, tsconfig_discovery_1.discoverTsconfigFiles)(root, {
+        includeDefaultExcluded: true,
+        includeConfigExcluded: true
+    });
+    const cache = new Map();
+    const configs = discovery.visible
+        .filter((file) => scope.isPathInScope(file))
+        .map((file) => readEffectiveTsConfig(file, cache, diagnostics))
+        .filter((config) => config !== null)
+        .map((config) => ({
+        file: toDisplayPath(root, config.file),
+        baseUrl: toDisplayPath(root, config.baseUrl),
+        paths: config.paths.map((mapping) => ({
+            ...mapping,
+            baseUrl: toDisplayPath(root, mapping.baseUrl)
+        })),
+        ...(config.extends ? { extends: toDisplayPath(root, config.extends) } : {}),
+        ...(config.files ? { files: config.files } : {}),
+        ...(config.include ? { include: config.include } : {}),
+        ...(config.exclude ? { exclude: config.exclude } : {}),
+        ...(config.references ? { references: config.references.map((reference) => toDisplayPath(root, reference)) } : {}),
+        ...(typeof config.composite === "boolean" ? { composite: config.composite } : {}),
+        ...(config.module ? { module: config.module } : {}),
+        ...(config.moduleResolution ? { moduleResolution: config.moduleResolution } : {}),
+        ...(config.customConditions ? { customConditions: config.customConditions } : {}),
+        ...(config.rootDir ? { rootDir: toDisplayPath(root, config.rootDir) } : {}),
+        ...(config.rootDirs ? { rootDirs: config.rootDirs.map((entry) => toDisplayPath(root, entry)) } : {})
+    }))
+        .sort((left, right) => left.file.localeCompare(right.file));
+    return { configs, discoveryMs: discovery.durationMs };
+}
+function readPackageSnapshots(root, diagnostics, scope) {
+    const packages = [];
+    const workspaceFilter = readWorkspacePackageFilter(root, diagnostics);
+    for (const packageJson of walkPackageJson(root)) {
+        if (!scope.isPathInScope(packageJson)) {
+            continue;
+        }
+        if (workspaceFilter && !workspaceFilter(packageJson)) {
+            continue;
+        }
+        try {
+            const raw = parseJsoncObject(fs.readFileSync(packageJson, "utf8"));
+            const dependencies = dependencyNames(raw);
+            const name = typeof raw.name === "string" && raw.name.trim() !== "" ? raw.name.trim() : undefined;
+            const exportsValue = normalizePackageMapValue(raw.exports);
+            const importsValue = normalizePackageMapValue(raw.imports);
+            packages.push({
+                root: path.dirname(packageJson),
+                packageJson,
+                ...(name ? { name } : {}),
+                ...(typeof raw.main === "string" ? { main: raw.main } : {}),
+                ...(typeof raw.module === "string" ? { module: raw.module } : {}),
+                ...(typeof raw.types === "string" ? { types: raw.types } : {}),
+                ...(typeof raw.typings === "string" ? { typings: raw.typings } : {}),
+                dependencies,
+                ...(exportsValue ? { exports: exportsValue } : {}),
+                ...(importsValue ? { imports: importsValue } : {}),
+                ...(typeof raw.private === "boolean" ? { private: raw.private } : {})
+            });
+        }
+        catch (error) {
+            diagnostics.push({
+                code: "TOPOLOGY_PACKAGE_JSON_UNREADABLE",
+                message: error instanceof Error ? error.message : "Could not read package.json.",
+                file: toDisplayPath(root, packageJson)
+            });
+        }
+    }
+    return packages.sort((left, right) => toDisplayPath(root, left.root).localeCompare(toDisplayPath(root, right.root)));
+}
+function buildImportSpecifierCandidates(snapshot, fromFile, toFile, owner) {
+    const candidates = [];
+    const fromPackageRoot = owner.from.packageRoot;
+    const toPackageRoot = owner.to.packageRoot;
+    const samePackage = Boolean(fromPackageRoot && toPackageRoot && fromPackageRoot === toPackageRoot);
+    candidates.push({
+        specifier: relativeSpecifier(fromFile, toFile),
+        kind: "relative",
+        valid: fs.existsSync(toFile),
+        reason: samePackage ? "relative path inside same package" : "relative path can reach target; cross-package relative is discouraged",
+        policy: samePackage ? "allowed" : "discouraged"
+    });
+    const fromTsConfig = owner.from.tsconfig
+        ? snapshot.tsconfigs.find((config) => config.file === owner.from.tsconfig)
+        : undefined;
+    if (fromTsConfig) {
+        for (const candidate of aliasCandidates(snapshot.root, fromTsConfig, toFile)) {
+            candidates.push(candidate);
+        }
+    }
+    const targetPackage = owner.to.packageRoot
+        ? snapshot.packages.find((pkg) => toDisplayPath(snapshot.root, pkg.root) === owner.to.packageRoot)
+        : undefined;
+    const fromPackage = owner.from.packageRoot
+        ? snapshot.packages.find((pkg) => toDisplayPath(snapshot.root, pkg.root) === owner.from.packageRoot)
+        : undefined;
+    if (targetPackage?.name) {
+        const dependencyAllowsPackage = fromPackage?.root === targetPackage.root ||
+            Boolean(fromPackage?.dependencies.includes(targetPackage.name));
+        const subpath = packageSubpath(targetPackage.root, toFile);
+        const exportAllowsSubpath = subpath === "" || packageExportsSubpath(targetPackage, subpath);
+        const valid = Boolean(dependencyAllowsPackage && exportAllowsSubpath);
+        candidates.push({
+            specifier: subpath ? `${targetPackage.name}/${subpath}` : targetPackage.name,
+            kind: "package",
+            valid,
+            packageName: targetPackage.name,
+            reason: !dependencyAllowsPackage
+                ? "importing package does not declare target package dependency"
+                : exportAllowsSubpath
+                    ? "package dependency/self import is present and subpath is public"
+                    : "package dependency exists, but target subpath is not proven public by package exports"
+        });
+    }
+    if (fromPackage?.root === targetPackage?.root && fromPackage?.imports) {
+        const importCandidate = packageImportCandidate(fromPackage, toFile);
+        if (importCandidate) {
+            candidates.push(importCandidate);
+        }
+    }
+    return uniqueCandidates(candidates);
+}
+function aliasCandidates(root, config, toFile) {
+    const targetNoExt = withoutSourceExtension(toFile);
+    const candidates = [];
+    for (const mapping of config.paths) {
+        for (const rawTarget of mapping.targets) {
+            const specifier = aliasCandidate(targetNoExt, {
+                ...mapping,
+                baseUrl: path.resolve(root, mapping.baseUrl)
+            }, rawTarget);
+            if (specifier) {
+                candidates.push({
+                    specifier,
+                    kind: "tsconfig-path",
+                    valid: true,
+                    reason: `matched tsconfig paths pattern ${mapping.pattern}`,
+                    tsconfig: config.file
+                });
+            }
+        }
+    }
+    return candidates.sort((left, right) => left.specifier.length - right.specifier.length || left.specifier.localeCompare(right.specifier));
+}
+function describeFileOwnership(snapshot, file) {
+    const tsconfig = findOwningTsConfig(snapshot, file);
+    const pkg = findOwningPackage(snapshot, file);
+    const diagnostics = [];
+    if (!tsconfig) {
+        diagnostics.push({
+            code: "TOPOLOGY_TSCONFIG_NOT_FOUND",
+            message: "No discovered tsconfig owns this file.",
+            file: toDisplayPath(snapshot.root, file)
+        });
+    }
+    if (!pkg) {
+        diagnostics.push({
+            code: "TOPOLOGY_PACKAGE_NOT_FOUND",
+            message: "No discovered package.json owns this file.",
+            file: toDisplayPath(snapshot.root, file)
+        });
+    }
+    return {
+        file: toDisplayPath(snapshot.root, file),
+        ...(tsconfig ? { tsconfig: tsconfig.file } : {}),
+        ...(pkg ? { packageRoot: toDisplayPath(snapshot.root, pkg.root) } : {}),
+        ...(pkg?.name ? { packageName: pkg.name } : {}),
+        diagnostics
+    };
+}
+function findOwningTsConfig(snapshot, file) {
+    const absolute = path.resolve(file);
+    return snapshot.tsconfigs
+        .map((config) => ({ config, dir: path.dirname(path.resolve(snapshot.root, config.file)) }))
+        .filter((item) => isPathInsideOrEqual(absolute, item.dir) && fileMatchesTsConfig(snapshot.root, absolute, item.config))
+        .sort((left, right) => right.dir.length - left.dir.length ||
+        tsconfigOwnerRank(left.config.file) - tsconfigOwnerRank(right.config.file) ||
+        left.config.file.localeCompare(right.config.file))[0]?.config ?? null;
+}
+function findOwningPackage(snapshot, file) {
+    const absolute = path.resolve(file);
+    return snapshot.packages
+        .filter((pkg) => isPathInsideOrEqual(absolute, pkg.root))
+        .sort((left, right) => right.root.length - left.root.length)[0] ?? null;
+}
+function readEffectiveTsConfig(configPath, cache, diagnostics) {
+    const normalized = path.resolve(configPath);
+    if (cache.has(normalized)) {
+        return cache.get(normalized) ?? null;
+    }
+    cache.set(normalized, null);
+    const raw = readRawTsConfig(normalized, diagnostics);
+    if (!raw) {
+        return null;
+    }
+    const parentPath = raw.extends ? resolveExtendsTsConfig(normalized, raw.extends) : null;
+    const parent = parentPath ? readEffectiveTsConfig(parentPath, cache, diagnostics) : null;
+    const configDir = path.dirname(normalized);
+    const baseUrl = raw.compilerOptions?.baseUrl
+        ? path.resolve(configDir, raw.compilerOptions.baseUrl)
+        : parent?.baseUrl ?? configDir;
+    const localPaths = raw.compilerOptions?.paths;
+    const paths = localPaths
+        ? Object.entries(localPaths)
+            .flatMap(([pattern, targets]) => createPathMappings(pattern, targets, baseUrl))
+            .sort(compareMappings)
+        : parent?.paths ?? [];
+    const result = {
+        file: normalized,
+        baseUrl,
+        paths,
+        ...(raw.files ? { files: raw.files } : {}),
+        ...(raw.include ? { include: raw.include } : {}),
+        ...(raw.exclude ? { exclude: raw.exclude } : {}),
+        ...(raw.references ? { references: raw.references.map((reference) => path.resolve(configDir, reference)) } : {}),
+        ...(typeof raw.compilerOptions?.composite === "boolean" ? { composite: raw.compilerOptions.composite } : typeof parent?.composite === "boolean" ? { composite: parent.composite } : {}),
+        ...(raw.compilerOptions?.module ? { module: raw.compilerOptions.module } : parent?.module ? { module: parent.module } : {}),
+        ...(raw.compilerOptions?.moduleResolution ? { moduleResolution: raw.compilerOptions.moduleResolution } : parent?.moduleResolution ? { moduleResolution: parent.moduleResolution } : {}),
+        ...(raw.compilerOptions?.customConditions ? { customConditions: raw.compilerOptions.customConditions } : parent?.customConditions ? { customConditions: parent.customConditions } : {}),
+        ...(raw.compilerOptions?.rootDir ? { rootDir: path.resolve(configDir, raw.compilerOptions.rootDir) } : parent?.rootDir ? { rootDir: parent.rootDir } : {}),
+        ...(raw.compilerOptions?.rootDirs ? { rootDirs: raw.compilerOptions.rootDirs.map((entry) => path.resolve(configDir, entry)) } : parent?.rootDirs ? { rootDirs: parent.rootDirs } : {}),
+        ...(parentPath ? { extends: parentPath } : {})
+    };
+    cache.set(normalized, result);
+    return result;
+}
+function readRawTsConfig(file, diagnostics) {
+    try {
+        const parsed = typescript_1.default.parseConfigFileTextToJson(file, fs.readFileSync(file, "utf8"));
+        if (parsed.error) {
+            diagnostics.push({
+                code: "TOPOLOGY_TSCONFIG_PARSE_FAILED",
+                message: typescript_1.default.flattenDiagnosticMessageText(parsed.error.messageText, "\n"),
+                file
+            });
+            return null;
+        }
+        const raw = isRecord(parsed.config) ? parsed.config : {};
+        const compilerOptions = isRecord(raw.compilerOptions) ? raw.compilerOptions : {};
+        const paths = isRecord(compilerOptions.paths) ? readPathsObject(compilerOptions.paths) : undefined;
+        return {
+            file,
+            ...(typeof raw.extends === "string" ? { extends: raw.extends } : {}),
+            ...(Array.isArray(raw.files) ? { files: readStringArray(raw.files) } : {}),
+            ...(Array.isArray(raw.include) ? { include: readStringArray(raw.include) } : {}),
+            ...(Array.isArray(raw.exclude) ? { exclude: readStringArray(raw.exclude) } : {}),
+            ...(Array.isArray(raw.references) ? { references: readTsConfigReferencePaths(raw.references) } : {}),
+            compilerOptions: {
+                ...(typeof compilerOptions.baseUrl === "string" ? { baseUrl: compilerOptions.baseUrl } : {}),
+                ...(paths ? { paths } : {}),
+                ...(typeof compilerOptions.composite === "boolean" ? { composite: compilerOptions.composite } : {}),
+                ...(typeof compilerOptions.module === "string" ? { module: compilerOptions.module } : {}),
+                ...(typeof compilerOptions.moduleResolution === "string" ? { moduleResolution: compilerOptions.moduleResolution } : {}),
+                ...(Array.isArray(compilerOptions.customConditions) ? { customConditions: readStringArray(compilerOptions.customConditions) } : {}),
+                ...(typeof compilerOptions.rootDir === "string" ? { rootDir: compilerOptions.rootDir } : {}),
+                ...(Array.isArray(compilerOptions.rootDirs) ? { rootDirs: readStringArray(compilerOptions.rootDirs) } : {})
+            }
+        };
+    }
+    catch (error) {
+        diagnostics.push({
+            code: "TOPOLOGY_TSCONFIG_UNREADABLE",
+            message: error instanceof Error ? error.message : "Could not read tsconfig.",
+            file
+        });
+        return null;
+    }
+}
+function createPathMappings(pattern, targets, baseUrl) {
+    return [{
+            pattern,
+            targets,
+            baseUrl,
+            specificity: pattern.replace("*", "").length
+        }];
+}
+function aliasCandidate(targetNoExt, mapping, rawTarget) {
+    const starIndex = rawTarget.indexOf("*");
+    if (starIndex < 0) {
+        const absoluteTarget = withoutSourceExtension(path.resolve(mapping.baseUrl, rawTarget));
+        return absoluteTarget === targetNoExt && !mapping.pattern.includes("*") ? mapping.pattern : null;
+    }
+    const targetPrefix = withoutSourceExtension(path.resolve(mapping.baseUrl, rawTarget.slice(0, starIndex)));
+    const targetSuffix = withoutSourceExtension(rawTarget.slice(starIndex + 1));
+    if (!targetNoExt.startsWith(targetPrefix) || (targetSuffix && !targetNoExt.endsWith(targetSuffix))) {
+        return null;
+    }
+    const wildcard = targetNoExt.slice(targetPrefix.length, targetSuffix ? -targetSuffix.length : undefined).replace(/^[/\\]/, "");
+    return mapping.pattern.replace("*", wildcard.replace(/\\/g, "/"));
+}
+function packageRelation(root, from, to) {
+    const fromLabel = from ? toDisplayPath(root, from.root) : "<unknown>";
+    const toLabel = to ? toDisplayPath(root, to.root) : "<unknown>";
+    if (!from || !to) {
+        return {
+            from: fromLabel,
+            to: toLabel,
+            reachable: false,
+            reasons: ["package boundary is unknown"]
+        };
+    }
+    if (from.root === to.root) {
+        return {
+            from: fromLabel,
+            to: toLabel,
+            reachable: true,
+            reasons: ["same package"]
+        };
+    }
+    if (to.name && from.dependencies.includes(to.name)) {
+        return {
+            from: fromLabel,
+            to: toLabel,
+            reachable: true,
+            reasons: [`${from.name ?? fromLabel} declares dependency ${to.name}`]
+        };
+    }
+    const referenceReason = tsconfigReferenceReason(root, from, to);
+    if (referenceReason) {
+        return {
+            from: fromLabel,
+            to: toLabel,
+            reachable: true,
+            reasons: [referenceReason]
+        };
+    }
+    return {
+        from: fromLabel,
+        to: toLabel,
+        reachable: false,
+        reasons: to.name ? [`missing dependency ${to.name}`] : ["target package has no name"]
+    };
+}
+function walkPackageJson(root) {
+    const results = [];
+    visit(root);
+    return results;
+    function visit(dir) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRS.has(entry.name)) {
+                    visit(full);
+                }
+                continue;
+            }
+            if (entry.isFile() && entry.name === "package.json") {
+                results.push(full);
+            }
+        }
+    }
+}
+function readWorkspacePackageFilter(root, diagnostics) {
+    const rootPackageJson = path.join(root, "package.json");
+    const patterns = [
+        ...readPackageJsonWorkspacePatterns(rootPackageJson, diagnostics),
+        ...readPnpmWorkspacePatterns(path.join(root, "pnpm-workspace.yaml"), diagnostics)
+    ];
+    const positives = uniqueStrings(patterns.filter((pattern) => !pattern.startsWith("!")));
+    const negatives = uniqueStrings(patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1)));
+    if (positives.length === 0) {
+        return null;
+    }
+    return (packageJson) => {
+        if (path.resolve(packageJson) === path.resolve(rootPackageJson)) {
+            return true;
+        }
+        const packageDir = toDisplayPath(root, path.dirname(packageJson));
+        return positives.some((pattern) => workspacePatternMatches(packageDir, pattern)) &&
+            !negatives.some((pattern) => workspacePatternMatches(packageDir, pattern));
+    };
+}
+function workspacePatternMatches(packageDir, pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/\/$/, "");
+    if (!containsGlob(normalizedPattern)) {
+        return packageDir === normalizedPattern;
+    }
+    return globToRegExp(normalizedPattern).test(packageDir);
+}
+function readPackageJsonWorkspacePatterns(file, diagnostics) {
+    if (!fs.existsSync(file)) {
+        return [];
+    }
+    try {
+        const raw = parseJsoncObject(fs.readFileSync(file, "utf8"));
+        const workspaces = raw.workspaces;
+        if (Array.isArray(workspaces)) {
+            return readStringArray(workspaces);
+        }
+        if (isRecord(workspaces) && Array.isArray(workspaces.packages)) {
+            return readStringArray(workspaces.packages);
+        }
+    }
+    catch (error) {
+        diagnostics.push({
+            code: "TOPOLOGY_WORKSPACE_PACKAGE_JSON_UNREADABLE",
+            message: error instanceof Error ? error.message : "Could not read package workspaces.",
+            file: toDisplayPath(path.dirname(file), file)
+        });
+    }
+    return [];
+}
+function readPnpmWorkspacePatterns(file, diagnostics) {
+    if (!fs.existsSync(file)) {
+        return [];
+    }
+    try {
+        const patterns = [];
+        const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+        let inPackages = false;
+        for (const line of lines) {
+            if (/^\s*packages\s*:\s*$/.test(line)) {
+                inPackages = true;
+                continue;
+            }
+            if (inPackages && /^\S/.test(line) && !/^\s*-/.test(line)) {
+                break;
+            }
+            if (!inPackages) {
+                continue;
+            }
+            const match = line.match(/^\s*-\s*['"]?([^'"]+?)['"]?\s*(?:#.*)?$/);
+            if (match?.[1]) {
+                patterns.push(match[1].trim());
+            }
+        }
+        return patterns;
+    }
+    catch (error) {
+        diagnostics.push({
+            code: "TOPOLOGY_PNPM_WORKSPACE_UNREADABLE",
+            message: error instanceof Error ? error.message : "Could not read pnpm workspace.",
+            file: toDisplayPath(path.dirname(file), file)
+        });
+        return [];
+    }
+}
+function dependencyNames(raw) {
+    return uniqueStrings([
+        ...objectKeys(raw.dependencies),
+        ...objectKeys(raw.devDependencies),
+        ...objectKeys(raw.peerDependencies),
+        ...objectKeys(raw.optionalDependencies)
+    ]);
+}
+function normalizePackageMapValue(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value === "string" || Array.isArray(value)) {
+        return { ".": value };
+    }
+    return undefined;
+}
+function objectKeys(value) {
+    return isRecord(value) ? Object.keys(value).sort() : [];
+}
+function readPathsObject(value) {
+    const paths = {};
+    for (const [key, rawTargets] of Object.entries(value)) {
+        if (!Array.isArray(rawTargets)) {
+            continue;
+        }
+        const targets = rawTargets.filter((target) => typeof target === "string" && target.trim() !== "");
+        if (targets.length > 0) {
+            paths[key] = targets;
+        }
+    }
+    return Object.keys(paths).length > 0 ? paths : undefined;
+}
+function resolveExtendsTsConfig(configPath, rawExtends) {
+    const configDir = path.dirname(configPath);
+    const base = rawExtends.startsWith(".") || path.isAbsolute(rawExtends)
+        ? path.resolve(configDir, rawExtends)
+        : path.resolve(configDir, "node_modules", rawExtends);
+    const candidates = path.extname(base)
+        ? [base]
+        : [`${base}.json`, path.join(base, "tsconfig.json")];
+    return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile()) ?? null;
+}
+function resolveInsideRoot(root, value) {
+    const resolved = path.resolve(root, value);
+    if (!isPathInsideOrEqual(resolved, root)) {
+        throw new errors_1.CliError("TOPOLOGY_PATH_OUTSIDE_WORKSPACE", "Topology paths must stay inside the workspace.", {
+            root,
+            path: value
+        });
+    }
+    return resolved;
+}
+function relativeSpecifier(fromFile, toFile) {
+    let specifier = withoutSourceExtension(path.relative(path.dirname(fromFile), toFile)).replace(/\\/g, "/");
+    if (!specifier.startsWith(".")) {
+        specifier = `./${specifier}`;
+    }
+    return specifier;
+}
+function packageSubpath(packageRoot, toFile) {
+    const relative = withoutSourceExtension(path.relative(packageRoot, toFile)).replace(/\\/g, "/");
+    const withoutSrc = relative.replace(/^src\//, "");
+    return withoutSrc === "index" ? "" : withoutSrc;
+}
+function packageExportsSubpath(pkg, subpath) {
+    if (!pkg.exports) {
+        return false;
+    }
+    const key = `./${subpath}`;
+    return packageMapAllowsSubpath(pkg.exports, key);
+}
+function packageMapAllowsSubpath(map, key) {
+    if (Object.prototype.hasOwnProperty.call(map, key) ||
+        Object.prototype.hasOwnProperty.call(map, `${key}.js`) ||
+        Object.prototype.hasOwnProperty.call(map, `${key}.ts`)) {
+        return true;
+    }
+    for (const pattern of Object.keys(map)) {
+        if (!pattern.includes("*")) {
+            continue;
+        }
+        const [prefix = "", suffix = ""] = pattern.split("*");
+        if (key.startsWith(prefix) && key.endsWith(suffix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function packageImportCandidate(pkg, toFile) {
+    if (!pkg.imports) {
+        return null;
+    }
+    const relative = withoutSourceExtension(path.relative(pkg.root, toFile)).replace(/\\/g, "/");
+    for (const [pattern, rawTarget] of Object.entries(pkg.imports)) {
+        if (!pattern.startsWith("#")) {
+            continue;
+        }
+        const specifier = packageImportSpecifierForTarget(pattern, rawTarget, relative);
+        if (specifier) {
+            return {
+                specifier,
+                kind: "package-import",
+                valid: true,
+                ...(pkg.name ? { packageName: pkg.name } : {}),
+                reason: `matched package imports pattern ${pattern}`
+            };
+        }
+    }
+    return null;
+}
+function packageImportSpecifierForTarget(pattern, rawTarget, relativeTargetNoExt) {
+    const targets = flattenPackageTargetStrings(rawTarget);
+    for (const target of targets) {
+        const normalized = withoutSourceExtension(target.replace(/^\.\//, "")).replace(/\\/g, "/");
+        const starIndex = normalized.indexOf("*");
+        if (starIndex < 0) {
+            if (normalized === relativeTargetNoExt && !pattern.includes("*")) {
+                return pattern;
+            }
+            continue;
+        }
+        const prefix = normalized.slice(0, starIndex);
+        const suffix = normalized.slice(starIndex + 1);
+        if (!relativeTargetNoExt.startsWith(prefix) || (suffix && !relativeTargetNoExt.endsWith(suffix))) {
+            continue;
+        }
+        const wildcard = relativeTargetNoExt.slice(prefix.length, suffix ? -suffix.length : undefined).replace(/^[/\\]/, "");
+        return pattern.replace("*", wildcard);
+    }
+    return null;
+}
+function flattenPackageTargetStrings(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(flattenPackageTargetStrings);
+    }
+    if (isRecord(value)) {
+        return Object.values(value).flatMap(flattenPackageTargetStrings);
+    }
+    return [];
+}
+function withoutSourceExtension(file) {
+    const ext = path.extname(file);
+    return SOURCE_EXTENSIONS.includes(ext) ? file.slice(0, -ext.length) : file;
+}
+function compareMappings(left, right) {
+    return right.specificity - left.specificity || left.pattern.localeCompare(right.pattern);
+}
+function compareBoundaryRelations(left, right) {
+    return Number(right.reachable) - Number(left.reachable) || left.from.localeCompare(right.from) || left.to.localeCompare(right.to);
+}
+function tsconfigOwnerRank(file) {
+    return path.basename(file).toLowerCase() === "tsconfig.json" ? 0 : 1;
+}
+function tsconfigReferenceReason(root, from, to) {
+    if (!from || !to) {
+        return null;
+    }
+    const fromConfig = path.join(from.root, "tsconfig.json");
+    if (!fs.existsSync(fromConfig)) {
+        return null;
+    }
+    const raw = readRawTsConfig(fromConfig, []);
+    if (!raw?.references) {
+        return null;
+    }
+    const targetConfig = path.join(to.root, "tsconfig.json");
+    const referenced = raw.references.some((reference) => {
+        const resolved = path.resolve(path.dirname(fromConfig), reference);
+        return path.resolve(resolved) === path.resolve(to.root) ||
+            path.resolve(resolved, "tsconfig.json") === path.resolve(targetConfig) ||
+            path.resolve(resolved) === path.resolve(targetConfig);
+    });
+    return referenced ? `${toDisplayPath(root, fromConfig)} references ${toDisplayPath(root, targetConfig)}` : null;
+}
+function fileMatchesTsConfig(root, file, config) {
+    const configPath = path.resolve(root, config.file);
+    const configDir = path.dirname(configPath);
+    const relative = path.relative(configDir, file).replace(/\\/g, "/");
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return false;
+    }
+    if (config.files && config.files.length > 0) {
+        return config.files.some((entry) => path.resolve(configDir, entry) === file);
+    }
+    const include = config.include && config.include.length > 0 ? config.include : ["**/*"];
+    const exclude = config.exclude ?? ["node_modules", "bower_components", "jspm_packages"];
+    return include.some((pattern) => globMatches(relative, pattern)) &&
+        !exclude.some((pattern) => globMatches(relative, pattern) || relative === pattern || relative.startsWith(`${pattern.replace(/\/$/, "")}/`));
+}
+function globMatches(relativePath, pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/\/$/, "");
+    if (normalizedPattern === relativePath) {
+        return true;
+    }
+    if (!containsGlob(normalizedPattern)) {
+        return relativePath === normalizedPattern || relativePath.startsWith(`${normalizedPattern}/`);
+    }
+    return globToRegExp(normalizedPattern).test(relativePath);
+}
+function containsGlob(value) {
+    return value.includes("*") || value.includes("?");
+}
+function globToRegExp(pattern) {
+    let source = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        const next = pattern[index + 1];
+        const nextNext = pattern[index + 2];
+        if (char === "*" && next === "*" && nextNext === "/") {
+            source += "(?:.*/)?";
+            index += 2;
+            continue;
+        }
+        if (char === "*" && next === "*") {
+            source += ".*";
+            index += 1;
+            continue;
+        }
+        if (char === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (char === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegExp(char ?? "");
+    }
+    source += "$";
+    return new RegExp(source);
+}
+function readStringArray(value) {
+    return value.filter((item) => typeof item === "string" && item.trim() !== "");
+}
+function readTsConfigReferencePaths(value) {
+    return value.flatMap((item) => isRecord(item) && typeof item.path === "string" ? [item.path] : []);
+}
+function uniqueCandidates(candidates) {
+    const byKey = new Map();
+    for (const candidate of candidates) {
+        byKey.set(`${candidate.kind}\n${candidate.specifier}`, candidate);
+    }
+    return Array.from(byKey.values()).sort((left, right) => left.kind.localeCompare(right.kind) ||
+        left.specifier.length - right.specifier.length ||
+        left.specifier.localeCompare(right.specifier));
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value !== ""))).sort();
+}
+function isPathInsideOrEqual(candidate, parent) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function toDisplayPath(root, file) {
+    const relative = path.relative(root, file).replace(/\\/g, "/");
+    return relative === "" ? "." : relative;
+}
+function parseJsoncObject(text) {
+    return JSON.parse(stripJsonComments(text));
+}
+function stripJsonComments(text) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index] ?? "";
+        const next = text[index + 1] ?? "";
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            while (index < text.length && text[index] !== "\n") {
+                index += 1;
+            }
+            result += "\n";
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            index += 2;
+            while (index < text.length && !(text[index] === "*" && text[index + 1] === "/")) {
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function escapeRegExp(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}