@myagentroam/node 0.9.94 → 0.9.96

package/dist/service/workspace-code-navigation-service.js

@@ -0,0 +1,1219 @@
+import { spawn } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { constants, createReadStream, createWriteStream } from 'node:fs';
+import { access, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { posix, relative, resolve, sep } from 'node:path';
+import { createInterface } from 'node:readline';
+import { bundledCtagsPath, BUNDLED_CTAGS_VERSION } from '../ctags-binary.js';
+import { nodeLog } from '../operational.js';
+import { normalizeWorkspacePath } from '../workspace.js';
+const INDEX_SCHEMA_VERSION = 1;
+const INDEX_OPTIONS_VERSION = 2;
+const BUILD_TIMEOUT_MS = 120_000;
+const BUILD_QUEUE_LIMIT = 4;
+const BUILD_QUEUE_TIMEOUT_MS = 120_000;
+const MAX_SOURCE_BYTES = 4 * 1024 * 1024;
+const MAX_INDEX_BYTES = 8 * 1024 * 1024 * 1024;
+const MAX_TAGS_BYTES = 512 * 1024 * 1024;
+const MAX_CANDIDATES = 100;
+const MAX_RESULTS = 20;
+const MAX_REFERENCES = 100;
+const MAX_TAG_LINE_BYTES = 16 * 1024;
+const READ_BLOCK_BYTES = 4096;
+const MAX_TARGET_LINE_SCAN_BYTES = MAX_SOURCE_BYTES;
+const MAX_TARGET_PREVIEW_CHARACTERS = 512;
+const NAVIGABLE_EXTENSIONS = new Set([
+    '.c',
+    '.cc',
+    '.cpp',
+    '.cs',
+    '.cxx',
+    '.dart',
+    '.ex',
+    '.exs',
+    '.fs',
+    '.fsx',
+    '.go',
+    '.h',
+    '.hh',
+    '.hpp',
+    '.hrl',
+    '.hs',
+    '.hxx',
+    '.java',
+    '.js',
+    '.jsx',
+    '.kt',
+    '.kts',
+    '.lua',
+    '.m',
+    '.mm',
+    '.php',
+    '.pl',
+    '.pm',
+    '.py',
+    '.pyw',
+    '.r',
+    '.rb',
+    '.rs',
+    '.scala',
+    '.scm',
+    '.sh',
+    '.sql',
+    '.swift',
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.vb'
+]);
+const RELATIVE_SOURCE_SPECIFIER_HANDLERS = [
+    { importExtension: '.js', sourceExtensions: ['.ts', '.tsx'] },
+    { importExtension: '.jsx', sourceExtensions: ['.tsx'] },
+    { importExtension: '.mjs', sourceExtensions: ['.mts'] },
+    { importExtension: '.cjs', sourceExtensions: ['.cts'] }
+];
+const EXTENSIONLESS_RELATIVE_SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.py'];
+const DOTTED_PACKAGE_SPECIFIER_HANDLERS = [
+    { packageSuffixes: ['.java', '.kt', '.kts'] },
+    { packageSuffixes: ['.py', '.pyw', '/__init__.py'] }
+];
+let activeBuilds = 0;
+const buildWaiters = [];
+/**
+ * Builds a demand-driven, standard u-ctags declaration index. It never keeps
+ * a complete symbol table, watcher, or idle child process in memory.
+ */
+export class WorkspaceCodeNavigationService {
+    options;
+    builds = new Map();
+    preparations = new Map();
+    candidateRefreshes = new Map();
+    locations = new Map();
+    failures = new Map();
+    forgotten = new Set();
+    forceFreshCandidates = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async prepare(workspace, input) {
+        if (typeof input.path !== 'string' || input.path.length === 0 || input.path.length > 4096)
+            throw new Error('SYMBOL_DEFINITION_INVALID');
+        if (!isNavigablePath(input.path))
+            return { state: 'READY' };
+        if (!(await this.available()))
+            return { state: 'UNAVAILABLE' };
+        const location = await this.indexLocation(workspace);
+        this.locations.set(workspace.id, location);
+        this.forgotten.delete(location.directory);
+        const manifest = await readManifest(location.manifest);
+        const tags = manifest === undefined
+            ? undefined
+            : await tagsPath(location, manifest).catch(() => undefined);
+        const reusable = manifest !== undefined &&
+            tags !== undefined &&
+            (await tagsAvailable(tags)) &&
+            manifest.sourceFiles !== undefined;
+        const current = reusable &&
+            manifest.schemaVersion === INDEX_SCHEMA_VERSION &&
+            manifest.optionsVersion === INDEX_OPTIONS_VERSION &&
+            manifest.ctagsVersion === BUNDLED_CTAGS_VERSION;
+        const cachedCandidates = this.options.files.index(workspace).peekContentCandidates();
+        const forceRefreshGeneration = this.forceFreshCandidates.get(workspace.id);
+        if (reusable) {
+            if (!current || cachedCandidates === undefined || forceRefreshGeneration !== undefined)
+                this.refreshCandidatesInBackground(workspace, location, manifest, {
+                    requireFresh: forceRefreshGeneration !== undefined,
+                    mustBuild: !current || forceRefreshGeneration !== undefined,
+                    forceRefreshGeneration
+                });
+            return { state: current ? 'READY' : 'STALE' };
+        }
+        const failure = this.failures.get(location.directory);
+        if (failure !== undefined &&
+            !this.builds.has(location.directory) &&
+            !this.preparations.has(location.directory)) {
+            this.failures.delete(location.directory);
+            return { state: 'FAILED', failureCode: failure };
+        }
+        this.startInitialBuild(workspace, location);
+        return { state: 'BUILDING' };
+    }
+    async definition(workspace, input) {
+        const path = input.path;
+        const symbol = input.symbol;
+        const specifier = input.specifier;
+        if (typeof path !== 'string' ||
+            path.length === 0 ||
+            path.length > 4096 ||
+            (typeof symbol === 'string' && typeof specifier === 'string') ||
+            (typeof symbol !== 'string' && typeof specifier !== 'string') ||
+            (typeof symbol === 'string' && !isSymbol(symbol)) ||
+            (typeof specifier === 'string' && !isNavigableSpecifier(specifier)))
+            throw new Error('SYMBOL_DEFINITION_INVALID');
+        if (typeof specifier === 'string')
+            return this.resolvePath(workspace, path, specifier);
+        const requestedSymbol = symbol;
+        if (!(await this.available()))
+            return emptyDefinitionResult({ state: 'UNAVAILABLE' });
+        const location = await this.indexLocation(workspace);
+        this.locations.set(workspace.id, location);
+        this.forgotten.delete(location.directory);
+        const manifest = await readManifest(location.manifest);
+        const tags = manifest === undefined
+            ? undefined
+            : await tagsPath(location, manifest).catch(() => undefined);
+        const tagsReady = tags !== undefined && (await tagsAvailable(tags));
+        const reusable = manifest !== undefined &&
+            tags !== undefined &&
+            tagsReady &&
+            manifest.sourceFiles !== undefined;
+        const current = reusable &&
+            manifest.schemaVersion === INDEX_SCHEMA_VERSION &&
+            manifest.optionsVersion === INDEX_OPTIONS_VERSION &&
+            manifest.ctagsVersion === BUNDLED_CTAGS_VERSION;
+        const fileIndex = this.options.files.index(workspace);
+        const cachedCandidates = fileIndex.peekContentCandidates();
+        const forceRefreshGeneration = this.forceFreshCandidates.get(workspace.id);
+        if (reusable &&
+            (!current || cachedCandidates === undefined || forceRefreshGeneration !== undefined)) {
+            const prepared = await this.manifestInput(workspace, manifest);
+            const targets = await this.findTargets(tags, requestedSymbol, path, prepared);
+            this.refreshCandidatesInBackground(workspace, location, manifest, {
+                requireFresh: forceRefreshGeneration !== undefined,
+                mustBuild: !current || forceRefreshGeneration !== undefined,
+                forceRefreshGeneration
+            });
+            return {
+                state: 'STALE',
+                targets: targets.slice(0, MAX_RESULTS),
+                references: [],
+                referenceTruncated: false,
+                paths: [],
+                truncated: targets.length > MAX_RESULTS || manifest.truncated
+            };
+        }
+        const requireFresh = !current;
+        const prepared = await this.indexInput(workspace, requireFresh);
+        if (!current) {
+            const failure = this.failures.get(location.directory);
+            if (failure !== undefined) {
+                this.failures.delete(location.directory);
+                return emptyDefinitionResult({ state: 'FAILED', failureCode: failure });
+            }
+            this.startBuild(prepared, location);
+            return emptyDefinitionResult({ state: 'BUILDING' });
+        }
+        const fresh = manifest.sourceFingerprint === prepared.sourceFingerprint;
+        const targets = await this.findTargets(tags, requestedSymbol, path, prepared);
+        if (!fresh) {
+            const failure = this.failures.get(location.directory);
+            if (failure !== undefined && targets.length === 0) {
+                this.failures.delete(location.directory);
+                return emptyDefinitionResult({ state: 'FAILED', failureCode: failure });
+            }
+            this.startBuild(prepared, location, manifest);
+            if (targets.length === 0) {
+                return emptyDefinitionResult({
+                    state: 'BUILDING',
+                    truncated: prepared.truncated || manifest.truncated
+                });
+            }
+        }
+        const references = await this.findReferences(workspace, requestedSymbol, targets);
+        return {
+            state: fresh ? 'READY' : 'STALE',
+            targets: targets.slice(0, MAX_RESULTS),
+            references: references.matches,
+            referenceTruncated: references.truncated,
+            paths: [],
+            truncated: targets.length > MAX_RESULTS || prepared.truncated || manifest.truncated
+        };
+    }
+    forget(workspaceId) {
+        const location = this.locations.get(workspaceId);
+        this.locations.delete(workspaceId);
+        this.forceFreshCandidates.delete(workspaceId);
+        if (location !== undefined) {
+            this.failures.delete(location.directory);
+            this.forgotten.add(location.directory);
+            if (!this.builds.has(location.directory))
+                void rm(location.directory, { recursive: true, force: true });
+        }
+    }
+    /** A Node-originated write makes the next background refresh authoritative. */
+    invalidate(workspaceId) {
+        this.forceFreshCandidates.set(workspaceId, (this.forceFreshCandidates.get(workspaceId) ?? 0) + 1);
+    }
+    async available() {
+        try {
+            await access(this.executable(), constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    executable() {
+        return (this.options.ctagsExecutable?.() ??
+            bundledCtagsPath(this.options.platform ?? process.platform, this.options.architecture ?? process.arch));
+    }
+    async indexInput(workspace, requireFresh) {
+        const startedAt = Date.now();
+        const candidates = await this.options.files
+            .index(workspace)
+            .contentCandidates({ requireFresh });
+        return this.indexInputFromCandidates(await realpath(workspace.path), candidates.entries, candidates.truncated, Date.now() - startedAt);
+    }
+    async manifestInput(workspace, manifest) {
+        const entries = Object.entries(manifest.sourceFiles ?? {})
+            .map(([path, fingerprint]) => manifestEntry(path, fingerprint))
+            .filter((entry) => entry !== undefined);
+        return this.indexInputFromCandidates(await realpath(workspace.path), entries, manifest.truncated, 0, manifest.sourceFingerprint, manifest.sourceFiles ?? {}, true);
+    }
+    indexInputFromCandidates(root, candidates, truncated, candidateScanMs, knownFingerprint, knownSourceFiles, revalidateSourceFingerprint = false) {
+        const entries = candidates
+            .filter((entry) => entry.size !== null &&
+            entry.size <= MAX_SOURCE_BYTES &&
+            isNavigablePath(entry.path) &&
+            !entry.path.includes('\n') &&
+            !entry.path.includes('\r'))
+            .sort((left, right) => left.path.localeCompare(right.path));
+        let bytes = 0;
+        const bounded = [];
+        for (const entry of entries) {
+            if (entry.size === null || bytes + entry.size > MAX_INDEX_BYTES)
+                break;
+            bytes += entry.size;
+            bounded.push(entry);
+        }
+        const sourceFiles = knownSourceFiles ??
+            Object.fromEntries(bounded.map((entry) => [entry.path, sourceFileFingerprint(entry.size, entry.modifiedAt)]));
+        return {
+            root,
+            entries: bounded,
+            sourceFingerprint: knownFingerprint ?? sourceFingerprint(bounded),
+            sourceFiles,
+            truncated: truncated || bounded.length !== entries.length,
+            candidateScanMs,
+            revalidateSourceFingerprint
+        };
+    }
+    async indexLocation(workspace) {
+        const path = normalizeWorkspacePath(await realpath(workspace.path));
+        const hash = createHash('sha256').update(path).digest('hex');
+        const nodeId = this.options.nodeId();
+        if (!/^[A-Za-z0-9_-]{1,128}$/u.test(nodeId))
+            throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+        const base = this.options.indexHome?.() ?? resolve(homedir(), '.mar', 'workspace-indexes');
+        const nodeDirectory = resolve(base, nodeId);
+        const directory = resolve(nodeDirectory, hash);
+        if (relative(nodeDirectory, directory)
+            .split(sep)
+            .some((part) => part === '..'))
+            throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+        return {
+            directory,
+            manifest: resolve(directory, 'manifest.json'),
+            generations: resolve(directory, 'generations')
+        };
+    }
+    startBuild(input, location, previous) {
+        void this.ensureBuild(input, location, previous).catch((error) => this.recordBuildFailure(location, error, input));
+    }
+    startInitialBuild(workspace, location) {
+        if (this.builds.has(location.directory) || this.preparations.has(location.directory))
+            return;
+        const preparation = this.indexInput(workspace, true)
+            .then((input) => {
+            if (this.forgotten.has(location.directory))
+                return;
+            return this.ensureBuild(input, location);
+        })
+            .catch((error) => this.recordBuildFailure(location, error))
+            .finally(() => {
+            if (this.preparations.get(location.directory) === preparation)
+                this.preparations.delete(location.directory);
+        });
+        this.preparations.set(location.directory, preparation);
+    }
+    recordBuildFailure(location, error, input) {
+        const failure = buildFailure(error);
+        this.failures.set(location.directory, failure);
+        nodeLog('workspace.code_navigation.index.failed', {
+            nodeId: this.options.nodeId(),
+            failureCode: failure,
+            sourceFiles: input?.entries.length ?? 0,
+            candidateScanMs: input?.candidateScanMs ?? 0
+        });
+    }
+    refreshCandidatesInBackground(workspace, location, manifest, options = {
+        requireFresh: false,
+        mustBuild: false,
+        forceRefreshGeneration: undefined
+    }) {
+        if (this.candidateRefreshes.has(location.directory))
+            return;
+        const startedAt = Date.now();
+        const refresh = this.options.files
+            .index(workspace)
+            .refreshContentCandidates(options.requireFresh)
+            .then(async () => {
+            const prepared = await this.indexInput(workspace, false);
+            const changed = prepared.sourceFingerprint !== manifest.sourceFingerprint;
+            nodeLog('workspace.code_navigation.candidates.refreshed', {
+                nodeId: this.options.nodeId(),
+                sourceFiles: prepared.entries.length,
+                candidateScanMs: prepared.candidateScanMs,
+                elapsedMs: Date.now() - startedAt,
+                changed
+            });
+            if (changed || options.mustBuild)
+                this.startBuild(prepared, location, manifest);
+            if (options.forceRefreshGeneration !== undefined &&
+                this.forceFreshCandidates.get(workspace.id) === options.forceRefreshGeneration)
+                this.forceFreshCandidates.delete(workspace.id);
+        })
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.candidateRefreshes.get(location.directory) === refresh)
+                this.candidateRefreshes.delete(location.directory);
+        });
+        this.candidateRefreshes.set(location.directory, refresh);
+    }
+    ensureBuild(input, location, previous) {
+        const active = this.builds.get(location.directory);
+        if (active !== undefined)
+            return active;
+        const build = this.build(input, location, previous).finally(async () => {
+            if (this.builds.get(location.directory) === build)
+                this.builds.delete(location.directory);
+            if (this.forgotten.delete(location.directory))
+                await rm(location.directory, { recursive: true, force: true });
+        });
+        this.builds.set(location.directory, build);
+        return build;
+    }
+    async build(input, location, previous) {
+        const startedAt = Date.now();
+        const executable = this.executable();
+        await access(executable, constants.X_OK);
+        await ensurePrivateDirectory(location.directory);
+        await ensurePrivateDirectory(location.generations);
+        const generation = randomUUID();
+        const staging = resolve(location.generations, `${generation}.staging`);
+        const committed = resolve(location.generations, generation);
+        try {
+            await ensurePrivateDirectory(staging);
+            const fileList = resolve(staging, 'files.list');
+            const tags = resolve(staging, 'tags');
+            const oldTags = previous?.sourceFiles === undefined
+                ? undefined
+                : await tagsPath(location, previous).catch(() => undefined);
+            const delta = oldTags === undefined || previous?.sourceFiles === undefined
+                ? undefined
+                : sourceDelta(previous.sourceFiles, input.sourceFiles);
+            let ctagsMs;
+            let mode;
+            if (delta === undefined || delta.changed.length + delta.removed.length > 1024) {
+                mode = 'full';
+                await writeFile(fileList, input.entries.map((entry) => entry.path).join('\n'), {
+                    encoding: 'utf8',
+                    mode: 0o600
+                });
+                const release = await acquireBuild();
+                try {
+                    ctagsMs = await runCtags(executable, input.root, fileList, tags);
+                }
+                finally {
+                    release();
+                }
+            }
+            else {
+                mode = 'incremental';
+                ctagsMs = await buildIncrementalTags(executable, input.root, oldTags, delta, staging, tags);
+            }
+            const tagsMetadata = await stat(tags);
+            if (!tagsMetadata.isFile() || tagsMetadata.size > MAX_TAGS_BYTES)
+                throw new Error('SYMBOL_INDEX_LIMIT_EXCEEDED');
+            if (this.forgotten.has(location.directory))
+                return;
+            await rename(staging, committed);
+            const manifest = {
+                schemaVersion: INDEX_SCHEMA_VERSION,
+                optionsVersion: INDEX_OPTIONS_VERSION,
+                ctagsVersion: BUNDLED_CTAGS_VERSION,
+                sourceFingerprint: input.sourceFingerprint,
+                sourceFiles: input.sourceFiles,
+                truncated: input.truncated,
+                generation
+            };
+            const manifestNext = resolve(location.directory, `manifest.${generation}.next.json`);
+            await writeFile(manifestNext, JSON.stringify(manifest), { encoding: 'utf8', mode: 0o600 });
+            await rename(manifestNext, location.manifest);
+            this.failures.delete(location.directory);
+            await removeInactiveGenerations(location.generations, generation);
+            nodeLog('workspace.code_navigation.index.completed', {
+                nodeId: this.options.nodeId(),
+                mode,
+                sourceFiles: input.entries.length,
+                sourceBytes: input.entries.reduce((total, entry) => total + (entry.size ?? 0), 0),
+                candidateScanMs: input.candidateScanMs,
+                ctagsMs,
+                tagsBytes: tagsMetadata.size,
+                elapsedMs: Date.now() - startedAt
+            });
+        }
+        finally {
+            await rm(staging, { recursive: true, force: true });
+        }
+    }
+    async findTargets(tags, symbol, currentPath, input) {
+        const handle = await open(tags, 'r');
+        try {
+            const size = (await handle.stat()).size;
+            const first = await firstTagOffset(handle, size, symbol);
+            const candidates = new Set(input.entries.map((entry) => entry.path));
+            const records = [];
+            let offset = first;
+            while (offset < size && records.length < MAX_CANDIDATES) {
+                const line = await readTagLine(handle, offset, size);
+                if (line === undefined)
+                    break;
+                offset = line.nextOffset;
+                const tag = parseTag(line.text);
+                if (tag === undefined || tag.name !== symbol) {
+                    if (tag !== undefined && compareTagNames(tag.name, symbol) > 0)
+                        break;
+                    continue;
+                }
+                if (!candidates.has(tag.path))
+                    continue;
+                records.push(tag);
+            }
+            const valid = await Promise.all(records.map(async (record) => ({
+                record,
+                preview: await validateTarget(input.root, record, symbol, input.revalidateSourceFingerprint ? input.sourceFiles[record.path] : undefined)
+            })));
+            return valid
+                .flatMap(({ record, preview }) => (preview === undefined ? [] : [{ ...record, preview }]))
+                .sort((left, right) => compareTargets(left, right, currentPath))
+                .map(({ path, line, kind, scope, preview }) => ({ path, line, kind, scope, preview }));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async findReferences(workspace, symbol, definitions) {
+        if (this.options.searchContent === undefined)
+            return { matches: [], truncated: false };
+        try {
+            const search = await this.options.searchContent(workspace, symbol);
+            const definitionLocations = new Set(definitions.map((target) => `${target.path}:${target.line}`));
+            const matches = search.matches
+                .filter((match) => !definitionLocations.has(`${match.path}:${match.line}`) &&
+                containsSymbol(match.preview, symbol))
+                .slice(0, MAX_REFERENCES)
+                .map(({ path, line, column, preview }) => ({ path, line, column, preview }));
+            return {
+                matches,
+                truncated: search.truncated || search.matches.length > MAX_REFERENCES
+            };
+        }
+        catch {
+            return { matches: [], truncated: false };
+        }
+    }
+    async resolvePath(workspace, currentPath, specifier) {
+        const location = await this.indexLocation(workspace);
+        this.locations.set(workspace.id, location);
+        this.forgotten.delete(location.directory);
+        const manifest = await readManifest(location.manifest);
+        const tags = manifest === undefined
+            ? undefined
+            : await tagsPath(location, manifest).catch(() => undefined);
+        const tagsReady = tags !== undefined && (await tagsAvailable(tags));
+        const fileIndex = this.options.files.index(workspace);
+        const cachedCandidates = fileIndex.peekContentCandidates();
+        const forceRefreshGeneration = this.forceFreshCandidates.get(workspace.id);
+        const reusable = manifest !== undefined &&
+            tags !== undefined &&
+            tagsReady &&
+            manifest.sourceFiles !== undefined;
+        const current = reusable &&
+            manifest.schemaVersion === INDEX_SCHEMA_VERSION &&
+            manifest.optionsVersion === INDEX_OPTIONS_VERSION &&
+            manifest.ctagsVersion === BUNDLED_CTAGS_VERSION;
+        const stale = reusable &&
+            (!current || cachedCandidates === undefined || forceRefreshGeneration !== undefined);
+        const input = stale
+            ? await this.manifestInput(workspace, manifest)
+            : await this.indexInput(workspace, false);
+        if (stale)
+            this.refreshCandidatesInBackground(workspace, location, manifest, {
+                requireFresh: forceRefreshGeneration !== undefined,
+                mustBuild: !current || forceRefreshGeneration !== undefined,
+                forceRefreshGeneration
+            });
+        const resolved = await this.resolvePathTargets(input, currentPath, specifier);
+        return {
+            state: stale ? 'STALE' : 'READY',
+            targets: [],
+            references: [],
+            referenceTruncated: false,
+            paths: resolved.targets,
+            truncated: input.truncated || resolved.truncated
+        };
+    }
+    async resolvePathTargets(input, currentPath, specifier) {
+        const targets = input.entries
+            .map((entry) => entry.path)
+            .filter((path) => isNavigablePath(path) && matchesSpecifier(path, currentPath, specifier))
+            .sort((left, right) => pathTargetScore(left, currentPath, specifier) -
+            pathTargetScore(right, currentPath, specifier))
+            .slice(0, MAX_RESULTS);
+        const resolved = await Promise.all(targets.map(async (path) => {
+            const preview = await validatePathTarget(input.root, path, input.revalidateSourceFingerprint ? input.sourceFiles[path] : undefined);
+            return preview === undefined
+                ? undefined
+                : {
+                    path,
+                    line: 1,
+                    kind: 'file',
+                    ...(preview.length === 0 ? {} : { preview: targetPreview(preview) }),
+                    scope: undefined
+                };
+        }));
+        return {
+            targets: resolved.flatMap((target) => (target === undefined ? [] : [target])),
+            truncated: targets.length >= MAX_RESULTS
+        };
+    }
+}
+function emptyDefinitionResult(input) {
+    return {
+        state: input.state,
+        targets: [],
+        references: [],
+        referenceTruncated: false,
+        paths: [],
+        truncated: input.truncated ?? false,
+        ...(input.failureCode === undefined ? {} : { failureCode: input.failureCode })
+    };
+}
+function sourceDelta(previous, current) {
+    const changed = Object.entries(current)
+        .filter(([path, fingerprint]) => previous[path] !== fingerprint)
+        .map(([path]) => path);
+    const removed = Object.keys(previous).filter((path) => current[path] === undefined);
+    return { changed, removed };
+}
+function manifestEntry(path, fingerprint) {
+    const match = /^([0-9]+):(-1|[0-9]+(?:\.[0-9]+)?)$/u.exec(fingerprint);
+    if (match === null)
+        return undefined;
+    const size = Number(match[1]);
+    const modifiedAt = match[2] === '-1' ? null : Number(match[2]);
+    if (!Number.isSafeInteger(size) ||
+        size < 0 ||
+        (modifiedAt !== null && !Number.isFinite(modifiedAt)))
+        return undefined;
+    return {
+        path,
+        name: path.slice(path.lastIndexOf('/') + 1),
+        kind: 'FILE',
+        size,
+        modifiedAt
+    };
+}
+function sourceFileFingerprint(size, modifiedAt) {
+    return `${size}:${modifiedAt ?? -1}`;
+}
+function sourceFingerprint(entries) {
+    const hash = createHash('sha256');
+    for (const entry of entries)
+        hash.update(`${entry.path}\0${sourceFileFingerprint(entry.size ?? -1, entry.modifiedAt)}\0`, 'utf8');
+    return hash.digest('hex');
+}
+async function buildIncrementalTags(executable, root, previousTags, delta, staging, destination) {
+    const changedTags = resolve(staging, 'changed.tags');
+    if (delta.changed.length > 0) {
+        const list = resolve(staging, 'changed.files.list');
+        await writeFile(list, delta.changed.join('\n'), { encoding: 'utf8', mode: 0o600 });
+        const release = await acquireBuild();
+        try {
+            const ctagsMs = await runCtags(executable, root, list, changedTags);
+            await mergeTags(previousTags, changedTags, new Set([...delta.changed, ...delta.removed]), destination);
+            return ctagsMs;
+        }
+        finally {
+            release();
+        }
+    }
+    else
+        await writeFile(changedTags, '', { encoding: 'utf8', mode: 0o600 });
+    await mergeTags(previousTags, changedTags, new Set([...delta.changed, ...delta.removed]), destination);
+    return 0;
+}
+async function mergeTags(previous, changed, replacedPaths, destination) {
+    const output = createWriteStream(destination, { encoding: 'utf8', mode: 0o600 });
+    const oldLines = tagLines(previous)[Symbol.asyncIterator]();
+    const changedLines = tagLines(changed)[Symbol.asyncIterator]();
+    const write = async (line) => {
+        if (!output.write(`${line}\n`))
+            await new Promise((resolvePromise) => output.once('drain', resolvePromise));
+    };
+    let old = await oldLines.next();
+    while (!old.done && old.value.startsWith('!_TAG_')) {
+        await write(old.value);
+        old = await oldLines.next();
+    }
+    let nextChanged = await nextDataTag(changedLines);
+    while (!old.done || nextChanged !== undefined) {
+        while (!old.done && tagPath(old.value) !== undefined && replacedPaths.has(tagPath(old.value)))
+            old = await oldLines.next();
+        if (old.done) {
+            await write(nextChanged);
+            nextChanged = await nextDataTag(changedLines);
+            continue;
+        }
+        if (nextChanged === undefined || compareTagLines(old.value, nextChanged) <= 0) {
+            await write(old.value);
+            old = await oldLines.next();
+        }
+        else {
+            await write(nextChanged);
+            nextChanged = await nextDataTag(changedLines);
+        }
+    }
+    await new Promise((resolvePromise, reject) => {
+        output.once('error', reject);
+        output.end(resolvePromise);
+    });
+}
+async function* tagLines(path) {
+    const input = createInterface({
+        input: createReadStream(path, { encoding: 'utf8' }),
+        crlfDelay: Infinity
+    });
+    for await (const line of input)
+        yield line;
+}
+async function nextDataTag(iterator) {
+    for (;;) {
+        const next = await iterator.next();
+        if (next.done)
+            return undefined;
+        if (!next.value.startsWith('!_TAG_'))
+            return next.value;
+    }
+}
+function tagPath(line) {
+    const second = line.indexOf('\t');
+    if (second < 0)
+        return undefined;
+    const third = line.indexOf('\t', second + 1);
+    return third < 0 ? undefined : line.slice(second + 1, third);
+}
+function compareTagLines(left, right) {
+    const leftName = left.slice(0, left.indexOf('\t'));
+    const rightName = right.slice(0, right.indexOf('\t'));
+    return (compareTagNames(leftName, rightName) || Buffer.compare(Buffer.from(left), Buffer.from(right)));
+}
+async function acquireBuild() {
+    if (activeBuilds >= 1) {
+        if (buildWaiters.length >= BUILD_QUEUE_LIMIT)
+            throw new Error('SYMBOL_INDEX_BUILD_FAILED');
+        await new Promise((resolvePromise, reject) => {
+            const resume = () => {
+                clearTimeout(timer);
+                resolvePromise();
+            };
+            const timer = setTimeout(() => {
+                const index = buildWaiters.indexOf(resume);
+                if (index >= 0)
+                    buildWaiters.splice(index, 1);
+                reject(new Error('SYMBOL_INDEX_BUILD_FAILED'));
+            }, BUILD_QUEUE_TIMEOUT_MS);
+            timer.unref();
+            buildWaiters.push(resume);
+        });
+    }
+    activeBuilds += 1;
+    return () => {
+        activeBuilds -= 1;
+        buildWaiters.shift()?.();
+    };
+}
+async function runCtags(executable, cwd, fileList, destination) {
+    const startedAt = Date.now();
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(executable, [
+            '--options=NONE',
+            '--output-format=u-ctags',
+            '--excmd=number',
+            '--sort=yes',
+            '--tag-relative=no',
+            '--pseudo-tags=-TAG_PROC_CWD',
+            '--fields=+nKS',
+            '--extras=+q',
+            '-L',
+            fileList,
+            '-f',
+            destination
+        ], {
+            cwd,
+            detached: process.platform !== 'win32',
+            windowsHide: true,
+            stdio: ['ignore', 'ignore', 'pipe']
+        });
+        let settled = false;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            callback();
+        };
+        const terminate = () => {
+            if (child.pid !== undefined && process.platform !== 'win32') {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
+                    return;
+                }
+                catch {
+                    // Fall through to the direct process kill.
+                }
+            }
+            child.kill('SIGKILL');
+        };
+        const timer = setTimeout(() => {
+            terminate();
+            settle(() => reject(new Error('SYMBOL_INDEX_BUILD_FAILED')));
+        }, BUILD_TIMEOUT_MS);
+        timer.unref();
+        child.stderr.on('data', () => undefined);
+        child.once('error', () => settle(() => reject(new Error('SYMBOL_INDEX_BUILD_FAILED'))));
+        child.once('exit', (code) => settle(() => (code === 0 ? resolvePromise() : reject(new Error('SYMBOL_INDEX_BUILD_FAILED')))));
+    });
+    return Date.now() - startedAt;
+}
+async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink())
+        throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+}
+async function removeInactiveGenerations(directory, activeGeneration) {
+    const generations = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    await Promise.all(generations
+        .filter((entry) => entry.isDirectory() &&
+        entry.name !== activeGeneration &&
+        /^[0-9a-f-]{36}(?:\.staging)?$/u.test(entry.name))
+        .map((entry) => rm(resolve(directory, entry.name), { recursive: true, force: true })));
+}
+async function readManifest(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        const sourceFiles = validManifestSourceFiles(value.sourceFiles) ? value.sourceFiles : undefined;
+        const schemaVersion = value.schemaVersion;
+        const optionsVersion = value.optionsVersion;
+        return typeof value === 'object' &&
+            value !== null &&
+            typeof schemaVersion === 'number' &&
+            Number.isInteger(schemaVersion) &&
+            schemaVersion >= 0 &&
+            typeof optionsVersion === 'number' &&
+            Number.isInteger(optionsVersion) &&
+            optionsVersion >= 0 &&
+            typeof value.ctagsVersion === 'string' &&
+            typeof value.sourceFingerprint === 'string' &&
+            /^[a-f0-9]{64}$/u.test(value.sourceFingerprint) &&
+            typeof value.truncated === 'boolean' &&
+            typeof value.generation === 'string' &&
+            /^[0-9a-f-]{36}$/u.test(value.generation)
+            ? {
+                schemaVersion,
+                optionsVersion,
+                ctagsVersion: value.ctagsVersion,
+                sourceFingerprint: value.sourceFingerprint,
+                ...(sourceFiles === undefined ? {} : { sourceFiles }),
+                truncated: value.truncated,
+                generation: value.generation
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function validManifestSourceFiles(value) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const entries = Object.entries(value);
+    return (entries.length <= 100_000 &&
+        entries.every(([path, fingerprint]) => path.length > 0 &&
+            path.length <= 4096 &&
+            !path.includes('\0') &&
+            !path.includes('\\') &&
+            !path.startsWith('/') &&
+            !path.split('/').some((part) => part.length === 0 || part === '.' || part === '..') &&
+            typeof fingerprint === 'string' &&
+            /^[0-9]+:(?:-1|[0-9]+(?:\.[0-9]+)?)$/u.test(fingerprint)));
+}
+async function tagsPath(location, manifest) {
+    const path = resolve(location.generations, manifest.generation, 'tags');
+    if (relative(location.generations, path)
+        .split(sep)
+        .some((part) => part === '..'))
+        throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+    return path;
+}
+async function tagsAvailable(path) {
+    try {
+        const metadata = await stat(path);
+        return metadata.isFile() && metadata.size <= MAX_TAGS_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+function isNavigablePath(path) {
+    const dot = path.lastIndexOf('.');
+    return dot >= 0 && NAVIGABLE_EXTENSIONS.has(path.slice(dot).toLowerCase());
+}
+function isSymbol(value) {
+    return value.length > 0 && value.length <= 512 && /^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(value);
+}
+function isNavigableSpecifier(value) {
+    return (value.length > 0 &&
+        value.length <= 1024 &&
+        (/^(?:\.\.?\/)[A-Za-z0-9_./$-]+$/u.test(value) ||
+            /^[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)+$/u.test(value) ||
+            /^(?:@?[A-Za-z0-9_$-]+)(?:\/[A-Za-z0-9_.$-]+)+$/u.test(value)));
+}
+function matchesSpecifier(path, currentPath, specifier) {
+    if (specifier.startsWith('.')) {
+        const resolved = resolveRelativeSpecifier(currentPath, specifier);
+        return (resolved !== undefined &&
+            relativeSpecifierCandidates(resolved).some((candidate) => path === candidate ||
+                path === `${candidate}/index.ts` ||
+                path === `${candidate}/index.tsx` ||
+                path === `${candidate}/index.js` ||
+                path === `${candidate}/index.jsx` ||
+                path === `${candidate}/__init__.py`));
+    }
+    if (specifier.includes('/'))
+        return sourceFileStem(path) === sourceFileStem(specifier);
+    if (specifier.includes('.')) {
+        const packagePath = specifier.replaceAll('.', '/');
+        return DOTTED_PACKAGE_SPECIFIER_HANDLERS.some((handler) => handler.packageSuffixes.some((suffix) => matchesPackagePath(path, `${packagePath}${suffix}`)));
+    }
+    return sourceFileStem(path) === sourceFileStem(specifier);
+}
+function matchesPackagePath(path, packagePath) {
+    return path === packagePath || path.endsWith(`/${packagePath}`);
+}
+function pathTargetScore(path, currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return path.length;
+    const resolved = resolveRelativeSpecifier(currentPath, specifier);
+    if (resolved === undefined)
+        return Number.MAX_SAFE_INTEGER;
+    const candidates = relativeSpecifierCandidates(resolved);
+    const exact = candidates.indexOf(path);
+    if (exact >= 0)
+        return exact;
+    const index = candidates.findIndex((candidate) => path === `${candidate}/index.ts` ||
+        path === `${candidate}/index.tsx` ||
+        path === `${candidate}/index.js` ||
+        path === `${candidate}/index.jsx` ||
+        path === `${candidate}/__init__.py`);
+    return index >= 0 ? candidates.length + index : Number.MAX_SAFE_INTEGER;
+}
+function resolveRelativeSpecifier(currentPath, specifier) {
+    const resolved = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (resolved.startsWith('../') || resolved === '..')
+        return undefined;
+    return resolved.replace(/^\.\//u, '');
+}
+function relativeSpecifierCandidates(path) {
+    const handler = RELATIVE_SOURCE_SPECIFIER_HANDLERS.find(({ importExtension }) => path.toLowerCase().endsWith(importExtension));
+    if (handler !== undefined) {
+        const sourceBase = path.slice(0, -handler.importExtension.length);
+        return [path, ...handler.sourceExtensions.map((extension) => `${sourceBase}${extension}`)];
+    }
+    return path.slice(path.lastIndexOf('/') + 1).includes('.')
+        ? [path]
+        : [path, ...EXTENSIONLESS_RELATIVE_SOURCE_EXTENSIONS.map((extension) => `${path}${extension}`)];
+}
+function sourceFileStem(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return name.replace(/(?:\.d)?\.[^.]+$/u, '');
+}
+async function firstTagOffset(handle, size, symbol) {
+    let low = 0;
+    let high = size;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const start = await findTagLineStart(handle, middle);
+        if (start === undefined) {
+            high = middle;
+            continue;
+        }
+        const line = await readTagLine(handle, start, size);
+        if (line === undefined) {
+            high = middle;
+            continue;
+        }
+        const tag = parseTag(line.text);
+        if (tag === undefined || compareTagNames(tag.name, symbol) < 0)
+            low = line.nextOffset;
+        else
+            high = line.start;
+    }
+    return low;
+}
+async function findTagLineStart(handle, offset) {
+    let cursor = offset;
+    let scanned = 0;
+    while (cursor > 0 && scanned < MAX_TAG_LINE_BYTES) {
+        const start = Math.max(0, cursor - Math.min(READ_BLOCK_BYTES, MAX_TAG_LINE_BYTES - scanned));
+        const chunk = Buffer.alloc(cursor - start);
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, start);
+        if (bytesRead === 0)
+            return undefined;
+        const newline = chunk.subarray(0, bytesRead).lastIndexOf(0x0a);
+        if (newline >= 0)
+            return start + newline + 1;
+        cursor = start;
+        scanned += bytesRead;
+    }
+    return cursor === 0 ? 0 : undefined;
+}
+async function readTagLine(handle, offset, size) {
+    if (offset >= size)
+        return undefined;
+    let start = offset;
+    if (start > 0) {
+        const before = Buffer.alloc(1);
+        await handle.read(before, 0, 1, start - 1);
+        if (before[0] !== 0x0a) {
+            const aligned = await findNewline(handle, start, size, MAX_TAG_LINE_BYTES);
+            if (aligned === undefined)
+                return undefined;
+            start = aligned + 1;
+        }
+    }
+    if (start >= size)
+        return undefined;
+    const bytes = [];
+    let total = 0;
+    let cursor = start;
+    while (cursor < size && total <= MAX_TAG_LINE_BYTES) {
+        const chunk = Buffer.alloc(Math.min(READ_BLOCK_BYTES, size - cursor));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, cursor);
+        if (bytesRead === 0)
+            break;
+        const content = chunk.subarray(0, bytesRead);
+        const newline = content.indexOf(0x0a);
+        const part = newline >= 0 ? content.subarray(0, newline) : content;
+        total += part.length;
+        if (total > MAX_TAG_LINE_BYTES)
+            return undefined;
+        bytes.push(part);
+        if (newline >= 0)
+            return {
+                start,
+                nextOffset: cursor + newline + 1,
+                text: Buffer.concat(bytes, total).toString('utf8')
+            };
+        cursor += bytesRead;
+    }
+    return undefined;
+}
+async function findNewline(handle, offset, size, limit) {
+    let cursor = offset;
+    let remaining = limit;
+    while (cursor < size && remaining > 0) {
+        const chunk = Buffer.alloc(Math.min(READ_BLOCK_BYTES, size - cursor, remaining));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, cursor);
+        if (bytesRead === 0)
+            return undefined;
+        const newline = chunk.subarray(0, bytesRead).indexOf(0x0a);
+        if (newline >= 0)
+            return cursor + newline;
+        cursor += bytesRead;
+        remaining -= bytesRead;
+    }
+    return undefined;
+}
+function parseTag(text) {
+    if (text.length === 0 ||
+        text.startsWith('!_TAG_') ||
+        Buffer.byteLength(text) > MAX_TAG_LINE_BYTES)
+        return undefined;
+    const fields = text.split('\t');
+    if (fields.length < 3)
+        return undefined;
+    const [name, path, excmd, ...extensions] = fields;
+    if (name === undefined ||
+        path === undefined ||
+        excmd === undefined ||
+        name.length === 0 ||
+        path.length === 0 ||
+        path.startsWith('/') ||
+        path.includes('\\') ||
+        path.split('/').some((part) => part === '' || part === '.' || part === '..'))
+        return undefined;
+    const match = /^([1-9][0-9]*);?"?$/u.exec(excmd);
+    if (match === null)
+        return undefined;
+    const line = Number(match[1]);
+    if (!Number.isSafeInteger(line) || line < 1)
+        return undefined;
+    let kind;
+    let scope;
+    for (const extension of extensions) {
+        if (extension.length === 1)
+            kind ??= extension;
+        else if (extension.startsWith('kind:'))
+            kind ??= extension.slice('kind:'.length);
+        else if (extension.startsWith('scope:') ||
+            extension.startsWith('class:') ||
+            extension.startsWith('namespace:'))
+            scope ??= extension.slice(extension.indexOf(':') + 1);
+    }
+    return { name, path, line, kind, scope };
+}
+async function validateTarget(root, target, symbol, expectedFingerprint) {
+    const path = resolve(root, ...target.path.split('/'));
+    const pathMetadata = await lstat(path).catch(() => undefined);
+    if (pathMetadata === undefined ||
+        !pathMetadata.isFile() ||
+        pathMetadata.isSymbolicLink() ||
+        pathMetadata.size > MAX_SOURCE_BYTES)
+        return undefined;
+    const actual = await realpath(path).catch(() => undefined);
+    if (actual === undefined ||
+        relative(root, actual)
+            .split(sep)
+            .some((part) => part === '..'))
+        return undefined;
+    const metadata = await lstat(actual).catch(() => undefined);
+    if (metadata === undefined ||
+        !metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.size > MAX_SOURCE_BYTES)
+        return undefined;
+    if (expectedFingerprint !== undefined &&
+        sourceFileFingerprint(metadata.size, metadata.mtimeMs) !== expectedFingerprint)
+        return undefined;
+    const line = await lineAt(actual, target.line);
+    return line !== undefined && containsSymbol(line, symbol) ? targetPreview(line) : undefined;
+}
+async function validatePathTarget(root, path, expectedFingerprint) {
+    const requested = resolve(root, ...path.split('/'));
+    const requestedMetadata = await lstat(requested).catch(() => undefined);
+    if (requestedMetadata === undefined ||
+        !requestedMetadata.isFile() ||
+        requestedMetadata.isSymbolicLink() ||
+        requestedMetadata.size > MAX_SOURCE_BYTES)
+        return undefined;
+    const actual = await realpath(requested).catch(() => undefined);
+    if (actual === undefined ||
+        relative(root, actual)
+            .split(sep)
+            .some((part) => part === '..'))
+        return undefined;
+    const metadata = await lstat(actual).catch(() => undefined);
+    if (metadata === undefined ||
+        !metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.size > MAX_SOURCE_BYTES ||
+        (expectedFingerprint !== undefined &&
+            sourceFileFingerprint(metadata.size, metadata.mtimeMs) !== expectedFingerprint))
+        return undefined;
+    return lineAt(actual, 1);
+}
+function targetPreview(line) {
+    if (line.length <= MAX_TARGET_PREVIEW_CHARACTERS)
+        return line;
+    const end = line.charCodeAt(MAX_TARGET_PREVIEW_CHARACTERS - 1);
+    const safeEnd = end >= 0xd800 && end <= 0xdbff
+        ? MAX_TARGET_PREVIEW_CHARACTERS - 1
+        : MAX_TARGET_PREVIEW_CHARACTERS;
+    return `${line.slice(0, safeEnd)}…`;
+}
+async function lineAt(path, targetLine) {
+    const handle = await open(path, 'r');
+    try {
+        let offset = 0;
+        let line = 1;
+        let pending = Buffer.alloc(0);
+        while (offset < MAX_TARGET_LINE_SCAN_BYTES) {
+            const chunk = Buffer.alloc(READ_BLOCK_BYTES);
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, offset);
+            if (bytesRead === 0)
+                return line === targetLine ? pending.toString('utf8') : undefined;
+            offset += bytesRead;
+            let content = pending.length === 0
+                ? chunk.subarray(0, bytesRead)
+                : Buffer.concat([pending, chunk.subarray(0, bytesRead)]);
+            let newline;
+            while ((newline = content.indexOf(0x0a)) >= 0) {
+                if (line === targetLine)
+                    return content.subarray(0, newline).toString('utf8');
+                line += 1;
+                content = content.subarray(newline + 1);
+            }
+            pending = content;
+        }
+        return line === targetLine ? pending.toString('utf8') : undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+function containsSymbol(line, symbol) {
+    const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return new RegExp(`(?:^|[^\\p{L}\\p{N}_$])${escaped}(?![\\p{L}\\p{N}_$])`, 'u').test(line);
+}
+function compareTagNames(left, right) {
+    return Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+}
+function compareTargets(left, right, currentPath) {
+    const leftScore = targetScore(left, currentPath);
+    const rightScore = targetScore(right, currentPath);
+    return (rightScore - leftScore ||
+        left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        (left.kind ?? '').localeCompare(right.kind ?? ''));
+}
+function targetScore(target, currentPath) {
+    if (target.path === currentPath)
+        return 100;
+    const currentDirectory = currentPath.includes('/')
+        ? currentPath.slice(0, currentPath.lastIndexOf('/'))
+        : '';
+    const targetDirectory = target.path.includes('/')
+        ? target.path.slice(0, target.path.lastIndexOf('/'))
+        : '';
+    return commonPathSegments(currentDirectory, targetDirectory);
+}
+function commonPathSegments(left, right) {
+    const leftParts = left === '' ? [] : left.split('/');
+    const rightParts = right === '' ? [] : right.split('/');
+    let count = 0;
+    while (count < leftParts.length && leftParts[count] === rightParts[count])
+        count += 1;
+    return count;
+}
+function buildFailure(error) {
+    return error instanceof Error && error.message === 'SYMBOL_INDEX_LIMIT_EXCEEDED'
+        ? 'SYMBOL_INDEX_LIMIT_EXCEEDED'
+        : 'SYMBOL_INDEX_BUILD_FAILED';
+}