@withtruing/companion 0.0.0-stage → 0.13.0

package/dist/import-resolver.js

@@ -0,0 +1,644 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { lstat, readFile } from 'node:fs/promises';
+import { extname, posix, relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
+import { builtinModules } from 'node:module';
+import ts from 'typescript';
+import { hasLinkedPathComponent, isTrackedRegularFileMode, safeSelectedPath } from './investigation-reader.js';
+const execFileAsync = promisify(execFile);
+const SCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+const JS_TO_TS = {
+    '.js': ['.ts'],
+    '.jsx': ['.tsx'],
+    '.mjs': ['.mts'],
+    '.cjs': ['.cts'],
+};
+const BLOCKING_V1 = new Set([
+    'unresolved_internal',
+    'unresolved_dynamic',
+    'declaration_only',
+    'parse_failed',
+    'unsupported_resolution',
+    'unsupported_exports',
+    'unsupported_workspace_config',
+    'unsafe_path',
+    'named_path_unverifiable',
+    'limit_depth',
+    'limit_files',
+    'limit_bytes',
+]);
+/** Under @2, `limit_bytes` is a deliberate trim (nearest files kept), not a block. */
+const BLOCKING_V2 = new Set([...BLOCKING_V1].filter((code) => code !== 'limit_bytes'));
+/** Every mapper version this companion can produce; advertised as capabilities. */
+export const SUPPORTED_MAPPER_VERSIONS = [
+    'auto-surface-mapper@1',
+    'auto-surface-mapper@2',
+];
+export function isSupportedMapperVersion(value) {
+    return SUPPORTED_MAPPER_VERSIONS.includes(value);
+}
+export class MappingFailure extends Error {
+    kind;
+    code;
+    constructor(kind, code, detail) {
+        super(detail);
+        this.kind = kind;
+        this.code = code;
+    }
+}
+class WorkspaceInputError extends Error {
+    code;
+    constructor(code, detail) {
+        super(detail);
+        this.code = code;
+    }
+}
+export const DEFAULT_MAPPER_SETTINGS = {
+    maxDepth: 8,
+    maxFiles: 120,
+    maxSourceBytes: 1_048_576,
+    conditions: ['import', 'require', 'node', 'default'],
+    extensionOrder: [
+        'exact', '.js->.ts', '.jsx->.tsx', '.mjs->.mts', '.cjs->.cts',
+        '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json',
+        '/index.ts', '/index.tsx', '/index.js',
+    ],
+};
+const hash = (bytes) => `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+const compareDiagnostic = (a, b) => a.code.localeCompare(b.code) || a.path.localeCompare(b.path) || a.detail.localeCompare(b.detail);
+const repoPath = (value) => value.replaceAll('\\', '/').replace(/^\.\//, '');
+function isSafeRepoPath(value) {
+    if (!value || value.startsWith('/') || value.includes('\\') || /^[A-Za-z]:/.test(value))
+        return false;
+    const segments = value.split('/');
+    return !segments.some((segment) => !segment || segment === '..' || segment === '.');
+}
+export async function enumerateTrackedFiles(sandboxPath, commit) {
+    let stdout;
+    try {
+        ({ stdout } = await execFileAsync('git', ['ls-tree', '-r', '-z', '--full-tree', commit], { cwd: sandboxPath, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, windowsHide: true }));
+    }
+    catch (error) {
+        throw new MappingFailure('transient', 'enumeration_failed', error instanceof Error ? error.message : String(error));
+    }
+    const entries = new Map();
+    for (const record of stdout.split('\0').filter(Boolean)) {
+        const tab = record.indexOf('\t');
+        if (tab < 0)
+            throw new MappingFailure('transient', 'enumeration_failed', 'Malformed git ls-tree output');
+        const [mode, type, object] = record.slice(0, tab).split(' ');
+        const path = record.slice(tab + 1);
+        entries.set(path, { path, mode, type, object });
+    }
+    return { entries, complete: true };
+}
+function regular(tree, path) {
+    const entry = tree.entries.get(path);
+    return !!entry && isTrackedRegularFileMode(entry.mode, entry.type);
+}
+async function safeRead(root, tree, path) {
+    if (!isSafeRepoPath(path) || !regular(tree, path))
+        throw new Error(`not a tracked regular file: ${path}`);
+    const absolute = safeSelectedPath(root, path);
+    if (await hasLinkedPathComponent(root, path))
+        throw new Error(`symlinked path component: ${path}`);
+    const stat = await lstat(absolute);
+    if (!stat.isFile())
+        throw new Error(`not an ordinary file: ${path}`);
+    return readFile(absolute);
+}
+function parseWorkspaceGlobs(text) {
+    const globs = [];
+    const unsupported = [];
+    let inPackages = false;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/\s+#.*$/, '');
+        if (/^packages\s*:\s*$/.test(line.trim())) {
+            inPackages = true;
+            continue;
+        }
+        if (/^packages\s*:/.test(line.trim())) {
+            unsupported.push(line.trim());
+            inPackages = false;
+            continue;
+        }
+        if (inPackages && /^\S/.test(line) && !/^\s*-/.test(line))
+            break;
+        if (!inPackages)
+            continue;
+        const match = line.match(/^\s*-\s*['"]?([^'"\s]+)['"]?\s*$/);
+        if (!match) {
+            if (/^\s*-/.test(line))
+                unsupported.push(line.trim());
+            continue;
+        }
+        if (/^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*(?:\/\*)?$/.test(match[1]))
+            globs.push(match[1]);
+        else
+            unsupported.push(match[1]);
+    }
+    return { globs, unsupported };
+}
+function workspaceDirsForGlob(glob, tree) {
+    if (!glob.endsWith('/*'))
+        return [glob];
+    const parent = glob.slice(0, -2);
+    const dirs = new Set();
+    for (const path of tree.entries.keys()) {
+        if (!path.startsWith(`${parent}/`))
+            continue;
+        const rest = path.slice(parent.length + 1);
+        const first = rest.split('/')[0];
+        if (first)
+            dirs.add(`${parent}/${first}`);
+    }
+    return [...dirs].sort();
+}
+async function readJsonInput(root, tree, path) {
+    if (!tree.entries.has(path))
+        return null;
+    if (!regular(tree, path))
+        throw new WorkspaceInputError('unsafe_path', 'not a tracked regular file');
+    let bytes;
+    try {
+        bytes = await safeRead(root, tree, path);
+    }
+    catch (error) {
+        throw new WorkspaceInputError('unsafe_path', error instanceof Error ? error.message : String(error));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bytes.toString('utf8'));
+    }
+    catch (error) {
+        throw new WorkspaceInputError('unsupported_workspace_config', error instanceof Error ? error.message : String(error));
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new WorkspaceInputError('unsupported_workspace_config', 'expected a JSON object');
+    }
+    return { json: parsed, sha256: hash(bytes) };
+}
+async function checkedJsonInput(root, tree, path, diagnostics) {
+    try {
+        return await readJsonInput(root, tree, path);
+    }
+    catch (error) {
+        const checked = error instanceof WorkspaceInputError
+            ? error
+            : new WorkspaceInputError('unsafe_path', error instanceof Error ? error.message : String(error));
+        diagnostics.push({ code: checked.code, path, detail: checked.message });
+        return null;
+    }
+}
+async function discoverWorkspace(root, tree) {
+    const diagnostics = [];
+    const resolutionInputs = [];
+    const globs = [];
+    const rootRead = await checkedJsonInput(root, tree, 'package.json', diagnostics);
+    const rootPackage = rootRead
+        ? { dir: '', path: 'package.json', json: rootRead.json, name: typeof rootRead.json.name === 'string' ? rootRead.json.name : undefined }
+        : null;
+    if (rootRead) {
+        resolutionInputs.push({ path: 'package.json', sha256: rootRead.sha256 });
+        const workspaces = rootRead.json.workspaces;
+        if (Array.isArray(workspaces)) {
+            for (const value of workspaces) {
+                if (typeof value === 'string' && /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*(?:\/\*)?$/.test(value))
+                    globs.push(value);
+                else
+                    diagnostics.push({ code: 'unsupported_workspace_config', path: 'package.json', detail: String(value) });
+            }
+        }
+        else if (workspaces !== undefined) {
+            diagnostics.push({ code: 'unsupported_workspace_config', path: 'package.json', detail: 'workspaces must be an array' });
+        }
+    }
+    if (tree.entries.has('pnpm-workspace.yaml')) {
+        if (!regular(tree, 'pnpm-workspace.yaml')) {
+            diagnostics.push({ code: 'unsafe_path', path: 'pnpm-workspace.yaml', detail: 'not a tracked regular file' });
+        }
+        else {
+            try {
+                const bytes = await safeRead(root, tree, 'pnpm-workspace.yaml');
+                resolutionInputs.push({ path: 'pnpm-workspace.yaml', sha256: hash(bytes) });
+                const parsed = parseWorkspaceGlobs(bytes.toString('utf8'));
+                globs.push(...parsed.globs);
+                for (const unsupported of parsed.unsupported) {
+                    diagnostics.push({ code: 'unsupported_workspace_config', path: 'pnpm-workspace.yaml', detail: unsupported });
+                }
+            }
+            catch (error) {
+                diagnostics.push({
+                    code: 'unsafe_path',
+                    path: 'pnpm-workspace.yaml',
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    const packageDirs = new Set(globs.flatMap((glob) => workspaceDirsForGlob(glob, tree)));
+    const packages = new Map();
+    const packageByDir = [];
+    for (const dir of [...packageDirs].sort()) {
+        const path = `${dir}/package.json`;
+        const read = await checkedJsonInput(root, tree, path, diagnostics);
+        if (!read)
+            continue;
+        resolutionInputs.push({ path, sha256: read.sha256 });
+        const info = {
+            dir,
+            path,
+            json: read.json,
+            name: typeof read.json.name === 'string' ? read.json.name : undefined,
+        };
+        packageByDir.push(info);
+        if (info.name)
+            packages.set(info.name, info);
+    }
+    packageByDir.sort((a, b) => b.dir.length - a.dir.length || a.dir.localeCompare(b.dir));
+    const packageScopes = new Set([...packages.keys()]
+        .filter((name) => name.startsWith('@'))
+        .map((name) => name.split('/')[0]));
+    return {
+        packages,
+        packageScopes,
+        packageByDir,
+        rootPackage,
+        workspaceDirs: [...packageDirs].sort((a, b) => b.length - a.length || a.localeCompare(b)),
+        resolutionInputs: resolutionInputs.sort((a, b) => a.path.localeCompare(b.path)),
+        diagnostics,
+    };
+}
+function scriptKind(path) {
+    const extension = extname(path);
+    if (extension === '.tsx')
+        return ts.ScriptKind.TSX;
+    if (extension === '.jsx')
+        return ts.ScriptKind.JSX;
+    if (extension === '.js' || extension === '.mjs' || extension === '.cjs')
+        return ts.ScriptKind.JS;
+    if (extension === '.json')
+        return ts.ScriptKind.JSON;
+    return ts.ScriptKind.TS;
+}
+export function parseImportEdges(path, source) {
+    const file = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, scriptKind(path));
+    const parseFailed = (file.parseDiagnostics?.length ?? 0) > 0;
+    const edges = [];
+    const literal = (node) => ts.isStringLiteralLike(node) ? node.text : null;
+    const add = (node, specifier, edge, detail) => {
+        edges.push({ position: node.getStart(file), specifier, edge, ...(detail ? { detail } : {}) });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            add(node, literal(node.moduleSpecifier), node.importClause ? 'import' : 'side_effect');
+        }
+        else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+            add(node, literal(node.moduleSpecifier), 'reexport');
+        }
+        else if (ts.isImportEqualsDeclaration(node)
+            && ts.isExternalModuleReference(node.moduleReference)
+            && node.moduleReference.expression) {
+            add(node, literal(node.moduleReference.expression), 'require');
+        }
+        else if (ts.isCallExpression(node)) {
+            const dynamic = node.expression.kind === ts.SyntaxKind.ImportKeyword;
+            const required = ts.isIdentifier(node.expression) && node.expression.text === 'require';
+            if (dynamic || required) {
+                const specifier = node.arguments.length === 1 ? literal(node.arguments[0]) : null;
+                add(node, specifier, dynamic ? 'dynamic' : 'require', specifier === null ? node.getText(file).slice(0, 160) : undefined);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return {
+        parseFailed,
+        edges: edges.sort((a, b) => a.position - b.position || (a.specifier ?? '').localeCompare(b.specifier ?? '')),
+    };
+}
+function relativeCandidates(importer, specifier) {
+    const base = repoPath(posix.normalize(posix.join(posix.dirname(importer), specifier)));
+    const extension = extname(base);
+    const candidates = [];
+    if (JS_TO_TS[extension]) {
+        const stem = base.slice(0, -extension.length);
+        candidates.push(...JS_TO_TS[extension].map((candidate) => `${stem}${candidate}`), base);
+    }
+    else if (extension) {
+        candidates.push(base);
+    }
+    candidates.push(`${base}.ts`, `${base}.tsx`, `${base}.mts`, `${base}.cts`, `${base}.js`, `${base}.jsx`, `${base}.mjs`, `${base}.cjs`, `${base}.json`, `${base}/index.ts`, `${base}/index.tsx`, `${base}/index.js`);
+    return [...new Set(candidates)].filter(isSafeRepoPath);
+}
+function firstResolution(tree, candidates) {
+    for (const path of candidates) {
+        const entry = tree.entries.get(path);
+        if (entry && !isTrackedRegularFileMode(entry.mode, entry.type))
+            return { unsafe: path };
+        if (entry && !path.endsWith('.d.ts'))
+            return { path };
+    }
+    const declaration = candidates.map((candidate) => candidate.endsWith('.d.ts') ? candidate : `${candidate.replace(/\.[^.\/]+$/, '')}.d.ts`)
+        .find((candidate) => regular(tree, candidate));
+    return declaration ? { declarationOnly: declaration } : {};
+}
+function packageNameAndSubpath(specifier) {
+    const parts = specifier.split('/');
+    const name = specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+    return { name, subpath: parts.slice(specifier.startsWith('@') ? 2 : 1).join('/') };
+}
+function chooseConditional(value, conditions) {
+    if (typeof value === 'string')
+        return { target: value };
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return { unsupported: true };
+    const record = value;
+    for (const condition of conditions) {
+        if (condition in record)
+            return chooseConditional(record[condition], conditions);
+    }
+    if ('types' in record)
+        return { typesOnly: true };
+    return { unsupported: true };
+}
+function exportTarget(exportsValue, subpath, conditions) {
+    if (typeof exportsValue === 'string')
+        return subpath ? { unsupported: true } : { target: exportsValue };
+    if (!exportsValue || typeof exportsValue !== 'object' || Array.isArray(exportsValue))
+        return { unsupported: true };
+    const record = exportsValue;
+    const keys = Object.keys(record);
+    if (!keys.some((key) => key.startsWith('.')))
+        return subpath ? { unsupported: true } : chooseConditional(record, conditions);
+    const requested = subpath ? `./${subpath}` : '.';
+    if (requested in record)
+        return chooseConditional(record[requested], conditions);
+    for (const key of keys.sort()) {
+        const stars = [...key.matchAll(/\*/g)].length;
+        if (stars > 1 || (key.includes('*') && stars !== 1))
+            return { unsupported: true };
+        if (stars !== 1)
+            continue;
+        const [prefix, suffix] = key.split('*');
+        if (!requested.startsWith(prefix) || !requested.endsWith(suffix))
+            continue;
+        const capture = requested.slice(prefix.length, requested.length - suffix.length);
+        const selected = chooseConditional(record[key], conditions);
+        if (selected.target) {
+            if ([...selected.target.matchAll(/\*/g)].length !== 1)
+                return { unsupported: true };
+            selected.target = selected.target.replace('*', capture);
+        }
+        return selected;
+    }
+    return { unsupported: true };
+}
+function declaredDependencies(info) {
+    const names = new Set();
+    if (!info)
+        return names;
+    for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+        const value = info.json[field];
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            for (const name of Object.keys(value))
+                names.add(name);
+        }
+    }
+    return names;
+}
+function nearestPackage(importer, workspace) {
+    return workspace.packageByDir.find((candidate) => importer.startsWith(`${candidate.dir}/`))
+        ?? workspace.rootPackage;
+}
+function packageTargetCandidates(dir, target) {
+    const cleaned = target.replace(/^\.\//, '');
+    return relativeCandidates(`${dir}/__package__.ts`, `./${cleaned}`);
+}
+function sourceFallbackCandidates(pkg, target) {
+    const normalized = repoPath(posix.normalize(posix.join(pkg.dir, target.replace(/^\.\//, ''))));
+    const prefixes = [`${pkg.dir}/dist/`, `${pkg.dir}/build/`];
+    const prefix = prefixes.find((candidate) => normalized.startsWith(candidate));
+    if (!prefix)
+        return [];
+    const relativeStem = normalized.slice(prefix.length).replace(/\.[^.\/]+$/, '');
+    return relativeCandidates(`${pkg.dir}/src/__fallback__.ts`, `./${relativeStem}`);
+}
+function resolveSpecifier(tree, workspace, importer, specifier, settings) {
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        const found = firstResolution(tree, relativeCandidates(importer, specifier));
+        if (found.path)
+            return { path: found.path };
+        if (found.unsafe)
+            return { diagnostic: { code: 'unsafe_path', path: found.unsafe, detail: `${importer}: ${specifier}` } };
+        if (found.declarationOnly)
+            return { diagnostic: { code: 'declaration_only', path: importer, detail: `${specifier} -> ${found.declarationOnly}` } };
+        return { diagnostic: { code: 'unresolved_internal', path: importer, detail: specifier } };
+    }
+    if (specifier.startsWith('#')) {
+        return { diagnostic: { code: 'unsupported_resolution', path: importer, detail: specifier } };
+    }
+    const { name, subpath } = packageNameAndSubpath(specifier);
+    const pkg = workspace.packages.get(name);
+    if (pkg) {
+        let target;
+        if (pkg.json.exports !== undefined) {
+            const selected = exportTarget(pkg.json.exports, subpath, settings.conditions);
+            if (selected.typesOnly)
+                return { diagnostic: { code: 'declaration_only', path: importer, detail: specifier } };
+            if (selected.unsupported || !selected.target)
+                return { diagnostic: { code: 'unsupported_exports', path: pkg.path, detail: specifier } };
+            target = selected.target;
+        }
+        else if (!subpath) {
+            target = typeof pkg.json.main === 'string'
+                ? pkg.json.main
+                : typeof pkg.json.module === 'string'
+                    ? pkg.json.module
+                    : undefined;
+        }
+        else {
+            target = subpath;
+        }
+        const candidates = target
+            ? packageTargetCandidates(pkg.dir, target)
+            : [`${pkg.dir}/src/index.ts`, `${pkg.dir}/src/index.tsx`, `${pkg.dir}/index.ts`, `${pkg.dir}/index.js`];
+        const found = firstResolution(tree, candidates);
+        if (found.path)
+            return { path: found.path };
+        if (found.unsafe)
+            return { diagnostic: { code: 'unsafe_path', path: found.unsafe, detail: `${importer}: ${specifier}` } };
+        if (found.declarationOnly)
+            return { diagnostic: { code: 'declaration_only', path: importer, detail: `${specifier} -> ${found.declarationOnly}` } };
+        if (target) {
+            const fallback = firstResolution(tree, sourceFallbackCandidates(pkg, target));
+            if (fallback.path) {
+                return {
+                    path: fallback.path,
+                    informational: { code: 'source_fallback', path: fallback.path, detail: specifier },
+                };
+            }
+            if (fallback.unsafe)
+                return { diagnostic: { code: 'unsafe_path', path: fallback.unsafe, detail: specifier } };
+        }
+        return { diagnostic: { code: 'unresolved_internal', path: importer, detail: specifier } };
+    }
+    if (builtinModules.includes(specifier) || specifier.startsWith('node:'))
+        return { external: true };
+    const dependencyNames = new Set([
+        ...declaredDependencies(nearestPackage(importer, workspace)),
+        ...declaredDependencies(workspace.rootPackage),
+    ]);
+    if (dependencyNames.has(name))
+        return { external: true };
+    if (name.startsWith('@') && workspace.packageScopes.has(name.split('/')[0])) {
+        return { diagnostic: { code: 'unresolved_internal', path: importer, detail: specifier } };
+    }
+    return { diagnostic: { code: 'unsupported_resolution', path: importer, detail: specifier } };
+}
+function seedRoots(seeds, workspace) {
+    return seeds.map((seed) => {
+        const matched = workspace.workspaceDirs.find((dir) => seed.path.startsWith(`${dir}/`));
+        if (matched)
+            return matched;
+        const segments = seed.path.split('/');
+        if ((segments[0] === 'apps' || segments[0] === 'packages') && segments.length > 2) {
+            return `${segments[0]}/${segments[1]}`;
+        }
+        return '';
+    });
+}
+export async function expandImports(input) {
+    const settings = input.settings ?? DEFAULT_MAPPER_SETTINGS;
+    const mapperVersion = input.mapperVersion ?? 'auto-surface-mapper@1';
+    const blocking = mapperVersion === 'auto-surface-mapper@2' ? BLOCKING_V2 : BLOCKING_V1;
+    const workspace = await discoverWorkspace(input.sandboxPath, input.tree);
+    const diagnostics = [...workspace.diagnostics];
+    const externals = [];
+    const roots = seedRoots(input.seeds, workspace);
+    const viaByPath = new Map();
+    const depthByPath = new Map();
+    const queue = [];
+    for (const seed of [...input.seeds].sort((a, b) => a.path.localeCompare(b.path))) {
+        if (!depthByPath.has(seed.path)) {
+            depthByPath.set(seed.path, 0);
+            queue.push(seed.path);
+        }
+        const via = viaByPath.get(seed.path) ?? [];
+        via.push({ from: '', specifier: seed.path, edge: 'seed' });
+        viaByPath.set(seed.path, via);
+    }
+    const files = [];
+    let includedBytes = 0;
+    let byteLimitHit = false;
+    while (queue.length > 0) {
+        const path = queue.shift();
+        const depth = depthByPath.get(path);
+        if (byteLimitHit) {
+            diagnostics.push({ code: 'limit_bytes', path, detail: `maxSourceBytes=${settings.maxSourceBytes}` });
+            continue;
+        }
+        if (files.length >= settings.maxFiles) {
+            diagnostics.push({ code: 'limit_files', path, detail: `maxFiles=${settings.maxFiles}` });
+            for (const omitted of queue)
+                diagnostics.push({ code: 'limit_files', path: omitted, detail: `maxFiles=${settings.maxFiles}` });
+            break;
+        }
+        let bytes;
+        try {
+            bytes = await safeRead(input.sandboxPath, input.tree, path);
+        }
+        catch (error) {
+            diagnostics.push({ code: 'unsafe_path', path, detail: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        if (includedBytes + bytes.byteLength > settings.maxSourceBytes) {
+            diagnostics.push({ code: 'limit_bytes', path, detail: `maxSourceBytes=${settings.maxSourceBytes}` });
+            byteLimitHit = true;
+            continue;
+        }
+        includedBytes += bytes.byteLength;
+        const extension = extname(path);
+        const parsed = SCRIPT_EXTENSIONS.has(extension);
+        files.push({
+            path,
+            sha256: hash(bytes),
+            bytes: bytes.byteLength,
+            depth,
+            shared: roots.every((root) => root !== '' && path !== root && !path.startsWith(`${root}/`)),
+            kind: parsed ? 'parsed' : 'opaque',
+            via: (viaByPath.get(path) ?? []).sort((a, b) => a.from.localeCompare(b.from) || a.specifier.localeCompare(b.specifier) || a.edge.localeCompare(b.edge)),
+        });
+        if (!parsed)
+            continue;
+        const parsedFile = parseImportEdges(path, bytes.toString('utf8'));
+        if (parsedFile.parseFailed) {
+            diagnostics.push({ code: 'parse_failed', path, detail: 'TypeScript syntax parse failed' });
+            continue;
+        }
+        for (const edge of parsedFile.edges) {
+            if (edge.specifier === null) {
+                diagnostics.push({ code: 'unresolved_dynamic', path, detail: edge.detail ?? edge.edge });
+                continue;
+            }
+            const resolved = resolveSpecifier(input.tree, workspace, path, edge.specifier, settings);
+            if (resolved.external) {
+                externals.push({ from: path, specifier: edge.specifier });
+                diagnostics.push({ code: 'external', path, detail: edge.specifier });
+                continue;
+            }
+            if (resolved.diagnostic)
+                diagnostics.push(resolved.diagnostic);
+            if (resolved.informational)
+                diagnostics.push(resolved.informational);
+            if (!resolved.path)
+                continue;
+            const target = resolved.path;
+            const targetDepth = depth + 1;
+            const via = viaByPath.get(target) ?? [];
+            via.push({ from: path, specifier: edge.specifier, edge: edge.edge });
+            viaByPath.set(target, via);
+            const knownDepth = depthByPath.get(target);
+            if (knownDepth !== undefined && knownDepth <= targetDepth)
+                continue;
+            depthByPath.set(target, targetDepth);
+            if (targetDepth > settings.maxDepth) {
+                diagnostics.push({ code: 'limit_depth', path: target, detail: `maxDepth=${settings.maxDepth}` });
+            }
+            else {
+                queue.push(target);
+            }
+        }
+    }
+    for (const file of files) {
+        file.via = (viaByPath.get(file.path) ?? []).sort((a, b) => a.from.localeCompare(b.from) || a.specifier.localeCompare(b.specifier) || a.edge.localeCompare(b.edge));
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    const uniqueDiagnostics = [...new Map(diagnostics.map((entry) => [`${entry.code}\0${entry.path}\0${entry.detail}`, entry])).values()].sort(compareDiagnostic);
+    const uniqueExternals = [...new Map(externals.map((entry) => [`${entry.from}\0${entry.specifier}`, entry])).values()].sort((a, b) => a.from.localeCompare(b.from) || a.specifier.localeCompare(b.specifier));
+    return {
+        mapper: { version: mapperVersion, settings },
+        resolutionInputs: workspace.resolutionInputs,
+        files,
+        externals: uniqueExternals,
+        status: uniqueDiagnostics.some((diagnostic) => blocking.has(diagnostic.code)) ? 'incomplete' : 'complete',
+        diagnostics: uniqueDiagnostics,
+    };
+}
+export function trackedNamedPathStatus(tree, path) {
+    if (!isSafeRepoPath(path))
+        return 'unverifiable';
+    const entry = tree.entries.get(path);
+    if (!entry)
+        return 'missing';
+    return isTrackedRegularFileMode(entry.mode, entry.type) ? 'present' : 'unverifiable';
+}
+export function absoluteIsContained(root, path) {
+    const absoluteRoot = resolve(root);
+    const absolute = resolve(root, path);
+    return absolute === absoluteRoot || absolute.startsWith(`${absoluteRoot}${sep}`);
+}
+export function relativeRepoPath(root, path) {
+    return repoPath(relative(root, path));
+}