@emeryld/manager 1.5.0 → 1.5.2

package/dist/ts-trace/report.js

@@ -0,0 +1,718 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { colors } from '../utils/log.js';
+const TRACE_FILE_NAME = 'trace.json';
+const TYPES_FILE_NAME = 'types.json';
+const DEFAULT_FILE_EVENT_NAME = 'checkSourceFile';
+const DEFAULT_SPAN_EVENT_NAMES = new Set([
+    'checkExpression',
+    'checkVariableDeclaration',
+    'checkCallExpression',
+    'checkPropertyAccessExpression',
+]);
+const DEFAULT_RELATION_EVENT_NAMES = new Set([
+    'structuredTypeRelatedTo',
+    'isTypeRelatedTo',
+    'recursiveTypeRelatedTo',
+    'typeRelatedTo',
+]);
+export class TraceReportError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = 'TraceReportError';
+        this.exitCode = exitCode;
+    }
+}
+export async function runTypeScriptTraceReport(options) {
+    const report = await buildTypeScriptTraceReport(options);
+    printTypeScriptTraceReport(report);
+    const shouldPrintJson = options.json || Boolean(options.outPath);
+    if (shouldPrintJson) {
+        const payload = JSON.stringify(report, null, 2);
+        console.log(payload);
+        if (options.outPath) {
+            const outPath = path.isAbsolute(options.outPath)
+                ? options.outPath
+                : path.resolve(process.cwd(), options.outPath);
+            await mkdir(path.dirname(outPath), { recursive: true });
+            await writeFile(outPath, `${payload}\n`, 'utf8');
+            console.log(colors.green(`JSON report written to ${outPath}`));
+        }
+    }
+    return report;
+}
+export async function buildTypeScriptTraceReport(options) {
+    const normalized = normalizeRunOptions(options);
+    const artifactPaths = await resolveTraceArtifacts(normalized.traceDir);
+    const [traceRaw, typesRaw] = await Promise.all([
+        readJsonFile(artifactPaths.traceJsonPath, 'trace.json'),
+        readJsonFile(artifactPaths.typesJsonPath, 'types.json'),
+    ]);
+    const traceEvents = extractTraceEvents(traceRaw);
+    const typesById = extractTypeMetadataMap(typesRaw);
+    const pathResolver = new FilePathResolver(normalized.baseDir, artifactPaths.traceDir);
+    const sourceIndex = new SourcePositionIndex(pathResolver);
+    const filePrimary = new Map();
+    const fileFallback = new Map();
+    const spanBuckets = new Map();
+    const relationBuckets = new Map();
+    const depthLimit = { count: 0, totalMs: 0 };
+    let hasPrimaryFileEvents = false;
+    for (const rawEvent of traceEvents) {
+        const event = normalizeTraceEvent(rawEvent);
+        if (!event)
+            continue;
+        const durationMs = event.dur / 1000;
+        if (durationMs < normalized.minMs)
+            continue;
+        if (normalized.eventFilter && !normalized.eventFilter.has(event.name)) {
+            continue;
+        }
+        const rawEventPath = extractEventPath(event.args);
+        const canonicalPath = rawEventPath
+            ? pathResolver.canonicalize(rawEventPath)
+            : undefined;
+        if (normalized.pathFilter &&
+            !matchesPathFilter(normalized.pathFilter, canonicalPath, pathResolver)) {
+            continue;
+        }
+        if (event.name.includes('DepthLimit')) {
+            depthLimit.count += 1;
+            depthLimit.totalMs += durationMs;
+        }
+        if (canonicalPath) {
+            addAggregate(fileFallback, canonicalPath, durationMs);
+            if (event.name === DEFAULT_FILE_EVENT_NAME) {
+                hasPrimaryFileEvents = true;
+                addAggregate(filePrimary, canonicalPath, durationMs);
+            }
+        }
+        if (canonicalPath && DEFAULT_SPAN_EVENT_NAMES.has(event.name)) {
+            const pos = extractEventPosition(event.args);
+            if (pos !== undefined) {
+                const spanKey = `${canonicalPath}|${event.name}|${pos}`;
+                const bucket = spanBuckets.get(spanKey);
+                if (bucket) {
+                    bucket.totalMs += durationMs;
+                    bucket.count += 1;
+                }
+                else {
+                    spanBuckets.set(spanKey, {
+                        event: event.name,
+                        filePath: canonicalPath,
+                        pos,
+                        totalMs: durationMs,
+                        count: 1,
+                    });
+                }
+            }
+        }
+        if (DEFAULT_RELATION_EVENT_NAMES.has(event.name)) {
+            const relation = extractTypeRelationPair(event.args);
+            if (relation) {
+                const relationKey = `${event.name}|${relation.sourceId}|${relation.targetId}`;
+                const bucket = relationBuckets.get(relationKey);
+                if (bucket) {
+                    bucket.totalMs += durationMs;
+                    bucket.count += 1;
+                }
+                else {
+                    relationBuckets.set(relationKey, {
+                        event: event.name,
+                        sourceId: relation.sourceId,
+                        targetId: relation.targetId,
+                        totalMs: durationMs,
+                        count: 1,
+                    });
+                }
+            }
+        }
+    }
+    const files = buildFileRows(hasPrimaryFileEvents ? filePrimary : fileFallback, normalized.top, pathResolver);
+    const spans = await buildSpanRows(spanBuckets, normalized.top, pathResolver, sourceIndex);
+    const relations = await buildRelationRows(relationBuckets, normalized.top, pathResolver, sourceIndex, typesById);
+    return {
+        meta: {
+            traceDir: artifactPaths.traceDir,
+            top: normalized.top,
+            minMs: normalized.minMs,
+            generatedAt: new Date().toISOString(),
+            baseDir: normalized.baseDir,
+        },
+        files,
+        spans,
+        relations,
+        depthLimit: {
+            count: depthLimit.count,
+            totalMs: roundMs(depthLimit.totalMs),
+        },
+    };
+}
+export function printTypeScriptTraceReport(report) {
+    console.log(colors.bold('TypeScript trace report'));
+    console.log(colors.dim(`traceDir: ${report.meta.traceDir}`));
+    console.log(colors.dim(`top=${report.meta.top} minMs=${report.meta.minMs} baseDir=${report.meta.baseDir}`));
+    console.log('');
+    printTable('A) Top files by checker cost', report.files, [
+        { header: 'rank', align: 'right', value: (_, index) => `${index + 1}` },
+        { header: 'total_ms', align: 'right', value: (row) => formatMs(row.totalMs) },
+        { header: 'count', align: 'right', value: (row) => `${row.count}` },
+        { header: 'avg_ms', align: 'right', value: (row) => formatMs(row.avgMs) },
+        { header: 'file', value: (row) => row.file },
+    ]);
+    printTable('B) Top node spans', report.spans, [
+        { header: 'rank', align: 'right', value: (_, index) => `${index + 1}` },
+        { header: 'total_ms', align: 'right', value: (row) => formatMs(row.totalMs) },
+        { header: 'count', align: 'right', value: (row) => `${row.count}` },
+        { header: 'avg_ms', align: 'right', value: (row) => formatMs(row.avgMs) },
+        { header: 'event', value: (row) => row.event },
+        {
+            header: 'file:line:col',
+            value: (row) => `${row.file}:${row.line || '?'}:${row.col || '?'}`,
+        },
+    ]);
+    printTable('C) Top type relation pairs', report.relations, [
+        { header: 'rank', align: 'right', value: (_, index) => `${index + 1}` },
+        { header: 'total_ms', align: 'right', value: (row) => formatMs(row.totalMs) },
+        { header: 'count', align: 'right', value: (row) => `${row.count}` },
+        { header: 'avg_ms', align: 'right', value: (row) => formatMs(row.avgMs) },
+        { header: 'event', value: (row) => row.event },
+        {
+            header: 'source -> target',
+            value: (row) => `${formatRelationSide(row.sourceId, row.sourceDecl)} -> ${formatRelationSide(row.targetId, row.targetDecl)}`,
+        },
+    ]);
+    console.log(colors.bold('D) Depth limit indicators'));
+    console.log(`count=${report.depthLimit.count} total_ms=${formatMs(report.depthLimit.totalMs)}`);
+    console.log('');
+}
+export function extractTypeMetadataMap(raw) {
+    const typesRoot = isRecord(raw) && 'types' in raw
+        ? raw.types
+        : raw;
+    const result = new Map();
+    if (Array.isArray(typesRoot)) {
+        for (const entry of typesRoot) {
+            const parsed = parseTypeMetadataEntry(entry);
+            if (!parsed)
+                continue;
+            result.set(parsed.typeId, parsed);
+        }
+        return result;
+    }
+    if (!isRecord(typesRoot))
+        return result;
+    for (const [id, entry] of Object.entries(typesRoot)) {
+        const parsed = parseTypeMetadataEntry(entry, id);
+        if (!parsed)
+            continue;
+        result.set(parsed.typeId, parsed);
+    }
+    return result;
+}
+function parseTypeMetadataEntry(raw, fallbackId) {
+    if (!isRecord(raw))
+        return undefined;
+    const typeId = coerceLooseId(raw.id) ?? fallbackId?.trim();
+    if (!typeId)
+        return undefined;
+    return {
+        typeId,
+        kind: pickString(raw, ['kind', 'kindName', 'flags']),
+        name: pickString(raw, ['name', 'symbolName', 'displayName']),
+        firstDeclaration: extractFirstDeclaration(raw),
+    };
+}
+function extractFirstDeclaration(raw) {
+    const firstDeclaration = toRecord(raw.firstDeclaration) ??
+        (Array.isArray(raw.declarations) ? toRecord(raw.declarations[0]) : undefined);
+    if (!firstDeclaration)
+        return undefined;
+    const declarationPath = pickString(firstDeclaration, [
+        'path',
+        'file',
+        'fileName',
+        'sourceFile',
+        'sourceFileName',
+    ]);
+    const start = toNumber(firstDeclaration.start ??
+        firstDeclaration.pos ??
+        firstDeclaration.position);
+    const line = toOneBasedNumber(firstDeclaration.line ?? firstDeclaration.lineNumber);
+    const col = toOneBasedNumber(firstDeclaration.col ??
+        firstDeclaration.column ??
+        firstDeclaration.character);
+    if (!declarationPath && start === undefined && line === undefined && col === undefined) {
+        return undefined;
+    }
+    return { path: declarationPath, start, line, col };
+}
+async function buildRelationRows(buckets, top, pathResolver, sourceIndex, typesById) {
+    const sortedBuckets = [...buckets.values()]
+        .sort(compareAggregateDesc)
+        .slice(0, top);
+    const declarationCache = new Map();
+    const rows = [];
+    for (const bucket of sortedBuckets) {
+        const sourceDecl = await resolveTypeDeclaration(bucket.sourceId, declarationCache, typesById, pathResolver, sourceIndex);
+        const targetDecl = await resolveTypeDeclaration(bucket.targetId, declarationCache, typesById, pathResolver, sourceIndex);
+        rows.push({
+            event: bucket.event,
+            sourceId: bucket.sourceId,
+            targetId: bucket.targetId,
+            sourceDecl,
+            targetDecl,
+            totalMs: roundMs(bucket.totalMs),
+            count: bucket.count,
+            avgMs: roundMs(bucket.totalMs / bucket.count),
+        });
+    }
+    return rows;
+}
+async function resolveTypeDeclaration(typeId, cache, typesById, pathResolver, sourceIndex) {
+    if (cache.has(typeId))
+        return cache.get(typeId);
+    const entry = typesById.get(typeId);
+    const declaration = entry?.firstDeclaration;
+    if (!declaration) {
+        cache.set(typeId, undefined);
+        return undefined;
+    }
+    let resolved;
+    if (declaration.path) {
+        const canonical = pathResolver.canonicalize(declaration.path);
+        const fromStart = declaration.start !== undefined
+            ? await sourceIndex.resolve(canonical, declaration.start)
+            : undefined;
+        if (fromStart) {
+            resolved = fromStart;
+        }
+        else {
+            resolved = {
+                file: pathResolver.toDisplay(canonical),
+                line: declaration.line,
+                col: declaration.col,
+            };
+        }
+    }
+    else if (declaration.line !== undefined || declaration.col !== undefined) {
+        resolved = {
+            file: '(unknown)',
+            line: declaration.line,
+            col: declaration.col,
+        };
+    }
+    cache.set(typeId, resolved);
+    return resolved;
+}
+async function buildSpanRows(buckets, top, pathResolver, sourceIndex) {
+    const sortedBuckets = [...buckets.values()]
+        .sort(compareAggregateDesc)
+        .slice(0, top);
+    const rows = [];
+    for (const bucket of sortedBuckets) {
+        const location = await sourceIndex.resolve(bucket.filePath, bucket.pos);
+        const file = location?.file ?? pathResolver.toDisplay(bucket.filePath);
+        const line = location?.line ?? 0;
+        const col = location?.col ?? 0;
+        rows.push({
+            key: `${file}:${line || '?'}:${col || '?'}:${bucket.event}`,
+            event: bucket.event,
+            file,
+            line,
+            col,
+            totalMs: roundMs(bucket.totalMs),
+            count: bucket.count,
+            avgMs: roundMs(bucket.totalMs / bucket.count),
+        });
+    }
+    return rows;
+}
+function buildFileRows(buckets, top, pathResolver) {
+    return [...buckets.entries()]
+        .sort((a, b) => compareAggregateDesc(a[1], b[1], a[0], b[0]))
+        .slice(0, top)
+        .map(([filePath, bucket]) => ({
+        file: pathResolver.toDisplay(filePath),
+        totalMs: roundMs(bucket.totalMs),
+        count: bucket.count,
+        avgMs: roundMs(bucket.totalMs / bucket.count),
+    }));
+}
+async function resolveTraceArtifacts(traceInput) {
+    const resolvedInput = path.resolve(traceInput);
+    const inputStats = await stat(resolvedInput).catch(() => undefined);
+    if (!inputStats) {
+        throw new TraceReportError(`Trace path not found: ${resolvedInput}`, 2);
+    }
+    const traceDir = inputStats.isDirectory()
+        ? resolvedInput
+        : path.dirname(resolvedInput);
+    const traceJsonPath = path.join(traceDir, TRACE_FILE_NAME);
+    const typesJsonPath = path.join(traceDir, TYPES_FILE_NAME);
+    const [traceStats, typesStats] = await Promise.all([
+        stat(traceJsonPath).catch(() => undefined),
+        stat(typesJsonPath).catch(() => undefined),
+    ]);
+    if (!traceStats?.isFile() || !typesStats?.isFile()) {
+        throw new TraceReportError(`Trace directory is missing ${TRACE_FILE_NAME} or ${TYPES_FILE_NAME}: ${traceDir}`, 2);
+    }
+    return { traceDir, traceJsonPath, typesJsonPath };
+}
+function normalizeRunOptions(options) {
+    const top = Number.isFinite(options.top) && options.top > 0
+        ? Math.floor(options.top)
+        : 20;
+    const minMs = Number.isFinite(options.minMs) && options.minMs >= 0 ? options.minMs : 1;
+    const baseDir = path.resolve(options.baseDir || process.cwd());
+    const eventNames = (options.eventNames ?? [])
+        .map((name) => name.trim())
+        .filter(Boolean);
+    const eventFilter = eventNames.length ? new Set(eventNames) : undefined;
+    const filterRegex = options.filterRegex?.trim();
+    let pathFilter;
+    if (filterRegex) {
+        try {
+            pathFilter = new RegExp(filterRegex);
+        }
+        catch (error) {
+            throw new TraceReportError(`Invalid filter regex "${filterRegex}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        ...options,
+        traceDir: path.resolve(options.traceDir),
+        top,
+        minMs,
+        baseDir,
+        eventFilter,
+        pathFilter,
+    };
+}
+function addAggregate(map, key, durationMs) {
+    const bucket = map.get(key);
+    if (bucket) {
+        bucket.totalMs += durationMs;
+        bucket.count += 1;
+    }
+    else {
+        map.set(key, { totalMs: durationMs, count: 1 });
+    }
+}
+function normalizeTraceEvent(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    if (raw.ph !== 'X')
+        return undefined;
+    const name = typeof raw.name === 'string' ? raw.name : undefined;
+    if (!name)
+        return undefined;
+    const dur = toNumber(raw.dur);
+    if (dur === undefined || dur <= 0)
+        return undefined;
+    return {
+        name,
+        dur,
+        args: toRecord(raw.args) ?? {},
+    };
+}
+function extractEventPath(args) {
+    for (const key of [
+        'path',
+        'file',
+        'fileName',
+        'sourceFile',
+        'sourceFileName',
+        'filePath',
+    ]) {
+        const direct = args[key];
+        if (typeof direct === 'string' && direct.trim()) {
+            return direct.trim();
+        }
+        const record = toRecord(direct);
+        if (!record)
+            continue;
+        for (const nestedKey of ['path', 'fileName', 'file']) {
+            const nested = record[nestedKey];
+            if (typeof nested === 'string' && nested.trim()) {
+                return nested.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function extractEventPosition(args) {
+    for (const key of ['pos', 'start', 'position']) {
+        const value = toNumber(args[key]);
+        if (value !== undefined)
+            return Math.max(0, Math.floor(value));
+    }
+    return undefined;
+}
+function extractTypeRelationPair(args) {
+    const keyPairs = [
+        ['sourceId', 'targetId'],
+        ['sourceTypeId', 'targetTypeId'],
+        ['source', 'target'],
+        ['left', 'right'],
+        ['leftTypeId', 'rightTypeId'],
+        ['from', 'to'],
+    ];
+    for (const [leftKey, rightKey] of keyPairs) {
+        const sourceId = coerceTypeId(args[leftKey]);
+        const targetId = coerceTypeId(args[rightKey]);
+        if (!sourceId || !targetId)
+            continue;
+        return { sourceId, targetId };
+    }
+    return undefined;
+}
+function coerceTypeId(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return `${Math.trunc(value)}`;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (/^-?\d+$/.test(trimmed))
+            return trimmed;
+        return undefined;
+    }
+    const record = toRecord(value);
+    if (!record)
+        return undefined;
+    return coerceTypeId(record.id ?? record.typeId);
+}
+function coerceLooseId(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return `${Math.trunc(value)}`;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    return undefined;
+}
+function matchesPathFilter(filter, canonicalPath, pathResolver) {
+    if (!canonicalPath)
+        return false;
+    const canonicalText = canonicalPath.replace(/\\/g, '/');
+    const displayText = pathResolver.toDisplay(canonicalPath);
+    return testRegex(filter, canonicalText) || testRegex(filter, displayText);
+}
+async function readJsonFile(filePath, label) {
+    let raw;
+    try {
+        raw = await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        throw new TraceReportError(`Failed to read ${label} at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, 1);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new TraceReportError(`Failed to parse ${label} at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, 1);
+    }
+}
+function extractTraceEvents(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (isRecord(raw) && Array.isArray(raw.traceEvents))
+        return raw.traceEvents;
+    throw new TraceReportError(`${TRACE_FILE_NAME} must be an array or an object with a traceEvents array.`, 1);
+}
+function compareAggregateDesc(a, b, leftName = '', rightName = '') {
+    if (b.totalMs !== a.totalMs)
+        return b.totalMs - a.totalMs;
+    if (b.count !== a.count)
+        return b.count - a.count;
+    return leftName.localeCompare(rightName);
+}
+function formatRelationSide(id, declaration) {
+    if (!declaration)
+        return id;
+    if (declaration.line !== undefined) {
+        return `${id}@${declaration.file}:${declaration.line}`;
+    }
+    return `${id}@${declaration.file}`;
+}
+function formatMs(value) {
+    return roundMs(value).toFixed(3);
+}
+function roundMs(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function testRegex(regex, text) {
+    regex.lastIndex = 0;
+    return regex.test(text);
+}
+function pickString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function toOneBasedNumber(value) {
+    const parsed = toNumber(value);
+    if (parsed === undefined)
+        return undefined;
+    if (parsed < 0)
+        return undefined;
+    return Math.floor(parsed) + 1;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function toRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function printTable(title, rows, columns) {
+    console.log(colors.bold(title));
+    if (rows.length === 0) {
+        console.log(colors.dim('No matching events.'));
+        console.log('');
+        return;
+    }
+    const headerRow = columns.map((column) => column.header);
+    const bodyRows = rows.map((row, index) => columns.map((column) => column.value(row, index)));
+    const widths = columns.map((column, columnIndex) => {
+        let width = column.header.length;
+        for (const row of bodyRows) {
+            width = Math.max(width, row[columnIndex].length);
+        }
+        return width;
+    });
+    console.log(headerRow
+        .map((value, index) => padCell(value, widths[index], columns[index].align))
+        .join(' | '));
+    console.log(widths.map((width) => '-'.repeat(width)).join('-+-'));
+    for (const row of bodyRows) {
+        console.log(row
+            .map((value, index) => padCell(value, widths[index], columns[index].align))
+            .join(' | '));
+    }
+    console.log('');
+}
+function padCell(value, width, align = 'left') {
+    if (align === 'right') {
+        return value.padStart(width, ' ');
+    }
+    return value.padEnd(width, ' ');
+}
+class FilePathResolver {
+    baseDir;
+    traceDir;
+    resolutionCache = new Map();
+    constructor(baseDir, traceDir) {
+        this.baseDir = baseDir;
+        this.traceDir = traceDir;
+    }
+    canonicalize(inputPath) {
+        const cached = this.resolutionCache.get(inputPath);
+        if (cached)
+            return cached;
+        const normalizedInput = inputPath.trim();
+        let resolved;
+        if (path.isAbsolute(normalizedInput)) {
+            resolved = path.normalize(normalizedInput);
+        }
+        else {
+            const fromBase = path.resolve(this.baseDir, normalizedInput);
+            const fromTrace = path.resolve(this.traceDir, normalizedInput);
+            const baseExists = existsSync(fromBase);
+            resolved = baseExists ? fromBase : fromTrace;
+        }
+        this.resolutionCache.set(inputPath, resolved);
+        return resolved;
+    }
+    toDisplay(canonicalPath) {
+        const normalizedBase = this.baseDir.replace(/\\/g, '/');
+        const normalizedTarget = canonicalPath.replace(/\\/g, '/');
+        if (process.platform === 'darwin' || process.platform === 'win32') {
+            const baseLower = normalizedBase.toLowerCase();
+            const targetLower = normalizedTarget.toLowerCase();
+            if (targetLower === baseLower)
+                return '.';
+            if (targetLower.startsWith(`${baseLower}/`)) {
+                return normalizedTarget.slice(normalizedBase.length + 1);
+            }
+        }
+        const relative = path.relative(this.baseDir, canonicalPath);
+        return (relative || '.').replace(/\\/g, '/');
+    }
+}
+class SourcePositionIndex {
+    pathResolver;
+    lineIndexCache = new Map();
+    constructor(pathResolver) {
+        this.pathResolver = pathResolver;
+    }
+    async resolve(canonicalPath, pos) {
+        const lineIndex = await this.getLineIndex(canonicalPath);
+        if (!lineIndex)
+            return undefined;
+        const clamped = Math.max(0, Math.min(Math.floor(pos), lineIndex.length));
+        const lineIndexPosition = findLineIndex(lineIndex.starts, clamped);
+        const lineStart = lineIndex.starts[lineIndexPosition];
+        return {
+            file: this.pathResolver.toDisplay(canonicalPath),
+            line: lineIndexPosition + 1,
+            col: clamped - lineStart + 1,
+        };
+    }
+    async getLineIndex(canonicalPath) {
+        if (this.lineIndexCache.has(canonicalPath)) {
+            return this.lineIndexCache.get(canonicalPath);
+        }
+        let text;
+        try {
+            text = await readFile(canonicalPath, 'utf8');
+        }
+        catch {
+            this.lineIndexCache.set(canonicalPath, null);
+            return null;
+        }
+        const starts = [0];
+        for (let i = 0; i < text.length; i++) {
+            if (text.charCodeAt(i) === 10) {
+                starts.push(i + 1);
+            }
+        }
+        const lineIndex = { starts, length: text.length };
+        this.lineIndexCache.set(canonicalPath, lineIndex);
+        return lineIndex;
+    }
+}
+function findLineIndex(starts, position) {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const current = starts[mid];
+        const next = mid + 1 < starts.length ? starts[mid + 1] : Number.MAX_SAFE_INTEGER;
+        if (position >= current && position < next) {
+            return mid;
+        }
+        if (position < current) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return Math.max(0, starts.length - 1);
+}