@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/lsp/project_service.js

@@ -0,0 +1,4771 @@
+import { dirname, fromFileUrl, join, toFileUrl } from '../platform/path.js';
+import ts from 'typescript';
+import { analyzePreparedProject, analyzePreparedProjectForFile, disposePreparedAnalysisProject, getPreparedAnalysisViewForFile, prepareProjectAnalysis, } from '../checker/analyze_project.js';
+import { collectProjectedUnknownValueExportNames, getLineAndCharacterOfPosition, getPositionOfLineAndCharacter, isProjectedSoundscriptDeclarationFile, isSoundscriptSourceFile, isUnsoundImportedModuleForTypeProjection, mapProgramEnclosingRangeToSource, mapProgramRangeToSource, mapSourcePositionToProgram, toProjectedDeclarationSourceFileName, } from '../frontend/project_frontend.js';
+import { formatSoundscriptText } from '../frontend/format_soundscript.js';
+import { isElaboratedBigIntTypeImportName, isElaboratedF64TypeImportName, } from '../frontend/numeric_prelude.js';
+import { createMacroDebugSnapshot, readMacroDebugStageText, } from '../frontend/macro_debug.js';
+import { createAdvancedMacroContext } from '../frontend/macro_advanced_context.js';
+import { createSyntaxOnlyMacroContext } from '../frontend/macro_context.js';
+import { formatMacroSignatureExamples, tryReadMacroSignature } from '../frontend/macro_api.js';
+import { analysisRegionForMacroDefinition, fragmentsForMacroDefinition, parseMacroSyntaxNodeForDefinition, } from '../frontend/macro_definition_support.js';
+import { createPatchedMacroRegion, mapMaterializedRangeToSource, materializeRegionForAnalysis, materializeRegionForHover, resolveBlockCompletionNodeAtSourcePosition, resolveBlockNodeAtSourcePosition, resolveCompletionNodeAtMaterializedRegion, resolveExpressionCompletionNodeAtSourcePosition, resolveExpressionNodeAtSourcePosition, resolveNodeAtMaterializedRegion, wrapMaterializedRegion, } from '../frontend/macro_operand_semantics.js';
+import { collectResolvedMacroPlaceholders, } from '../frontend/macro_resolver.js';
+import { parseMacroInvocationAt } from '../frontend/macro_parser.js';
+import { scanMacroCandidates } from '../frontend/macro_scanner.js';
+import { fileExistsSync, readTextFileSync } from '../platform/host.js';
+import { logLspTiming, measureLspTiming } from './timing.js';
+const projectContextCacheBySession = new WeakMap();
+const resolvedMacroPlaceholderCache = new WeakMap();
+const importedMacroDefinitionCache = new WeakMap();
+function getProjectContextCache(session) {
+    let cache = projectContextCacheBySession.get(session);
+    if (!cache) {
+        cache = new Map();
+        projectContextCacheBySession.set(session, cache);
+    }
+    return cache;
+}
+function projectContextCacheKey(projectPath, mode) {
+    return `${projectPath}::${mode}`;
+}
+function aggregateMacroCacheStats(preparedProject) {
+    const aggregated = {
+        evaluatedModules: 0,
+        moduleCacheHits: 0,
+        moduleCacheInvalidations: 0,
+        moduleCacheMisses: 0,
+    };
+    for (const view of [preparedProject.tsView, preparedProject.stsView]) {
+        if (!view) {
+            continue;
+        }
+        aggregated.evaluatedModules += view.macroCacheStats.evaluatedModules;
+        aggregated.moduleCacheHits += view.macroCacheStats.moduleCacheHits;
+        aggregated.moduleCacheInvalidations += view.macroCacheStats.moduleCacheInvalidations;
+        aggregated.moduleCacheMisses += view.macroCacheStats.moduleCacheMisses;
+    }
+    return aggregated;
+}
+const SEMANTIC_TOKEN_TYPES = [
+    'namespace',
+    'type',
+    'keyword',
+    'class',
+    'enum',
+    'interface',
+    'typeParameter',
+    'parameter',
+    'variable',
+    'property',
+    'enumMember',
+    'function',
+    'method',
+];
+const SEMANTIC_TOKEN_MODIFIERS = [
+    'declaration',
+    'readonly',
+];
+const SEMANTIC_TOKEN_TYPE_INDICES = new Map(SEMANTIC_TOKEN_TYPES.map((tokenType, index) => [tokenType, index]));
+const SEMANTIC_TOKEN_MODIFIER_INDICES = new Map(SEMANTIC_TOKEN_MODIFIERS.map((modifier, index) => [modifier, index]));
+function findProjectPath(filePath) {
+    let currentDirectory = dirname(filePath);
+    while (true) {
+        for (const fileName of ['tsconfig.soundscript.json', 'tsconfig.json']) {
+            const candidate = join(currentDirectory, fileName);
+            if (fileExistsSync(candidate)) {
+                return candidate;
+            }
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+function toFileOverrideMap(documents) {
+    return new Map(documents.map((document) => [fromFileUrl(document.uri), document.text]));
+}
+function collectAdditionalRootNames(projectPath, documents) {
+    const projectDirectory = dirname(projectPath);
+    return documents
+        .map((document) => fromFileUrl(document.uri))
+        .filter((filePath) => {
+        if (filePath === projectDirectory) {
+            return true;
+        }
+        const withTrailingSlash = projectDirectory.endsWith('/')
+            ? projectDirectory
+            : `${projectDirectory}/`;
+        return filePath.startsWith(withTrailingSlash);
+    })
+        .sort();
+}
+function createProjectDocumentsKey(projectPath, documents) {
+    const projectDirectory = dirname(projectPath);
+    const withTrailingSlash = projectDirectory.endsWith('/')
+        ? projectDirectory
+        : `${projectDirectory}/`;
+    return documents
+        .filter((document) => {
+        const filePath = fromFileUrl(document.uri);
+        return filePath === projectDirectory || filePath.startsWith(withTrailingSlash);
+    })
+        .map((document) => `${document.uri}:${document.version}`)
+        .sort()
+        .join('|');
+}
+function createStsDocumentsKey(projectPath, documents) {
+    const projectDirectory = dirname(projectPath);
+    const withTrailingSlash = projectDirectory.endsWith('/')
+        ? projectDirectory
+        : `${projectDirectory}/`;
+    return documents
+        .filter((document) => {
+        const filePath = fromFileUrl(document.uri);
+        if (!(filePath === projectDirectory || filePath.startsWith(withTrailingSlash))) {
+            return false;
+        }
+        return filePath === projectPath || isSoundscriptSourceFile(filePath);
+    })
+        .map((document) => `${document.uri}:${document.version}`)
+        .sort()
+        .join('|');
+}
+function getProjectContext(filePath, session, requestedMode = 'full') {
+    const projectPath = findProjectPath(filePath);
+    if (!projectPath) {
+        return null;
+    }
+    const documents = session.getAll();
+    const additionalRootNames = collectAdditionalRootNames(projectPath, documents);
+    const documentsKey = createProjectDocumentsKey(projectPath, documents);
+    const stsDocumentsKey = createStsDocumentsKey(projectPath, documents);
+    const projectContextCache = getProjectContextCache(session);
+    const mode = requestedMode === 'sts-local' && isSoundscriptSourceFile(filePath)
+        ? 'sts-local'
+        : 'full';
+    const cached = projectContextCache.get(projectContextCacheKey(projectPath, mode));
+    const alternateCached = projectContextCache.get(projectContextCacheKey(projectPath, mode === 'full' ? 'sts-local' : 'full'));
+    const rootsMatch = cached !== undefined &&
+        cached.additionalRootNames.length === additionalRootNames.length &&
+        cached.additionalRootNames.every((rootName, index) => rootName === additionalRootNames[index]);
+    const alternateRootsMatch = alternateCached !== undefined &&
+        alternateCached.additionalRootNames.length === additionalRootNames.length &&
+        alternateCached.additionalRootNames.every((rootName, index) => rootName === additionalRootNames[index]);
+    const canReuseCachedForFull = cached !== undefined &&
+        rootsMatch &&
+        cached.documentsKey === documentsKey;
+    const canReuseCachedForStsLocal = cached !== undefined &&
+        rootsMatch &&
+        cached.stsDocumentsKey === stsDocumentsKey;
+    const reusableContext = rootsMatch ? cached : alternateRootsMatch ? alternateCached : undefined;
+    const canReusePreparedProject = reusableContext !== undefined;
+    if ((mode === 'full' && canReuseCachedForFull) ||
+        (mode === 'sts-local' && canReuseCachedForStsLocal)) {
+        return { context: cached, projectPath };
+    }
+    const prepareStart = performance.now();
+    const context = {
+        additionalRootNames,
+        analyzedResultByFile: new Map(),
+        documentsKey,
+        mode,
+        stsDocumentsKey,
+        preparedProject: prepareProjectAnalysis({
+            additionalRootNames,
+            projectPath,
+            workingDirectory: dirname(projectPath),
+            fileOverrides: toFileOverrideMap(documents),
+        }, canReusePreparedProject ? reusableContext.preparedProject : undefined, { deferTypescriptView: mode === 'sts-local' }),
+    };
+    const macroCacheStats = aggregateMacroCacheStats(context.preparedProject);
+    logLspTiming('project.prepare', performance.now() - prepareStart, {
+        projectPath,
+        additionalRoots: additionalRootNames.length,
+        openDocuments: documents.length,
+        cache: canReusePreparedProject
+            ? reusableContext === cached ? 'incremental-rebuild' : 'cross-mode-rebuild'
+            : 'rebuild',
+        macroCacheHits: macroCacheStats.moduleCacheHits,
+        macroCacheMisses: macroCacheStats.moduleCacheMisses,
+        macroCacheInvalidations: macroCacheStats.moduleCacheInvalidations,
+        macroModulesEvaluated: macroCacheStats.evaluatedModules,
+    }, { always: true });
+    disposePreparedAnalysisProject(cached?.preparedProject, context.preparedProject);
+    projectContextCache.set(projectContextCacheKey(projectPath, mode), context);
+    return { context, projectPath };
+}
+export function getPreparedProjectForTest(uri, session, mode = 'full') {
+    const filePath = fromFileUrl(uri);
+    return getProjectContext(filePath, session, mode)?.context.preparedProject ?? null;
+}
+function getPreparedProjectContext(filePath, session, mode = isSoundscriptSourceFile(filePath) ? 'sts-local' : 'full') {
+    const entry = getProjectContext(filePath, session, mode);
+    if (!entry) {
+        return null;
+    }
+    return getPreparedAnalysisViewForFile(entry.context.preparedProject, filePath);
+}
+function getPreparedProjectViews(filePath, session) {
+    const entry = getProjectContext(filePath, session, 'full');
+    if (!entry) {
+        return [];
+    }
+    return [
+        entry.context.preparedProject.tsView,
+        entry.context.preparedProject.stsView,
+    ].filter((view) => view !== null);
+}
+function getMacroDebugSnapshotForFile(filePath, session) {
+    const view = getPreparedProjectContext(filePath, session, 'full');
+    if (!view) {
+        return null;
+    }
+    return createMacroDebugSnapshot({
+        diagnosticPreparedFiles: view.diagnosticPreparedFiles,
+        filePath,
+        macroEnvironment: view.macroEnvironment,
+        preparedProgram: view.preparedProgram,
+        program: view.program,
+    });
+}
+function getAnalyzedProjectContext(filePath, session) {
+    var _a;
+    const entry = getProjectContext(filePath, session, 'full');
+    if (!entry) {
+        return null;
+    }
+    (_a = entry.context).analyzedResult ?? (_a.analyzedResult = measureLspTiming('project.analyze', {
+        projectPath: entry.projectPath,
+        rootFiles: (entry.context.preparedProject.tsView?.program.getRootFileNames().length ?? 0) +
+            (entry.context.preparedProject.stsView?.program.getRootFileNames().length ?? 0),
+    }, () => analyzePreparedProject(entry.context.preparedProject), { always: true }));
+    return entry.context.analyzedResult;
+}
+function getFileLocalAnalyzedProjectContext(filePath, session) {
+    if (!isSoundscriptSourceFile(filePath)) {
+        return null;
+    }
+    const entry = getProjectContext(filePath, session, 'sts-local');
+    if (!entry) {
+        return null;
+    }
+    const cached = entry.context.analyzedResultByFile.get(filePath);
+    if (cached) {
+        return cached;
+    }
+    const analyzedResult = measureLspTiming('project.analyzeFile', {
+        filePath,
+        projectPath: entry.projectPath,
+        rootFiles: entry.context.preparedProject.stsView?.program.getRootFileNames().length ?? 0,
+    }, () => analyzePreparedProjectForFile(entry.context.preparedProject, filePath), { always: true });
+    entry.context.analyzedResultByFile.set(filePath, analyzedResult);
+    return analyzedResult;
+}
+function getCollectedResolvedMacroPlaceholders(preparedProject) {
+    const cached = resolvedMacroPlaceholderCache.get(preparedProject.preparedProgram);
+    if (cached) {
+        return cached;
+    }
+    const collected = measureLspTiming('macro.placeholderCollection', {
+        rootFiles: preparedProject.program.getRootFileNames().length,
+    }, () => collectResolvedMacroPlaceholders(preparedProject.preparedProgram), { always: true });
+    resolvedMacroPlaceholderCache.set(preparedProject.preparedProgram, collected);
+    return collected;
+}
+function getImportedMacroDefinitionsForFile(preparedProject, filePath) {
+    let byFile = importedMacroDefinitionCache.get(preparedProject.preparedProgram);
+    if (!byFile) {
+        byFile = new Map();
+        importedMacroDefinitionCache.set(preparedProject.preparedProgram, byFile);
+    }
+    const cached = byFile.get(filePath);
+    if (cached) {
+        return cached;
+    }
+    const sourceFile = preparedProject.preparedProgram.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(filePath));
+    const definitions = sourceFile
+        ? preparedProject.macroEnvironment.definitionsForFile(sourceFile)
+        : new Map();
+    byFile.set(filePath, definitions);
+    return definitions;
+}
+function isAugmentDeclarationMacroInvocation(preparedProject, resolved) {
+    if (!resolved.placeholder.invocation.declarationSpan) {
+        return false;
+    }
+    const definition = getImportedMacroDefinitionsForFile(preparedProject, resolved.placeholder.fileName).get(resolved.placeholder.invocation.nameText);
+    return definition?.expansionMode === 'augment';
+}
+function measureDocumentOperation(operation, uri, fn) {
+    return measureLspTiming(operation, { uri }, fn);
+}
+function createNoProjectDiagnostic(filePath) {
+    return {
+        source: 'cli',
+        code: 'SOUNDSCRIPT_NO_PROJECT',
+        category: 'warning',
+        message: 'No tsconfig.json was found for this file.',
+        hint: "Run 'soundscript init' to create a new project, or add a nearby tsconfig.json or tsconfig.soundscript.json.",
+        filePath,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 1,
+    };
+}
+function createAnalysisFailureDiagnostic(filePath, error) {
+    return {
+        source: 'cli',
+        code: 'SOUNDSCRIPT_ANALYSIS_ERROR',
+        category: 'error',
+        message: 'soundscript could not analyze this file.',
+        notes: [error instanceof Error ? error.message : String(error)],
+        hint: 'Check your project configuration and restart the language server if the problem persists.',
+        filePath,
+        line: 1,
+        column: 1,
+        endLine: 1,
+        endColumn: 1,
+    };
+}
+function findDeepestNodeContainingPosition(node, position) {
+    if (position < node.getFullStart() || position >= node.getEnd()) {
+        return undefined;
+    }
+    const child = ts.forEachChild(node, (currentChild) => findDeepestNodeContainingPosition(currentChild, position));
+    return child ?? node;
+}
+function findCompletionNode(sourceFile, position) {
+    const candidatePositions = [
+        ...new Set([
+            position,
+            Math.max(0, position - 1),
+        ]),
+    ];
+    for (const candidatePosition of candidatePositions) {
+        const node = findDeepestNodeContainingPosition(sourceFile, candidatePosition);
+        if (node && !ts.isSourceFile(node) && node.kind !== ts.SyntaxKind.EndOfFileToken) {
+            return node;
+        }
+    }
+    return undefined;
+}
+function findCallLikeContainingPosition(node, position) {
+    let current = node;
+    while (current) {
+        if ((ts.isCallExpression(current) || ts.isNewExpression(current)) && current.arguments) {
+            const openParen = current.expression.getEnd();
+            const closeParen = current.getEnd() - 1;
+            if (position >= openParen && position <= closeParen) {
+                return current;
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function activeParameterForCallLike(callLike, position) {
+    const argumentsArray = callLike.arguments ?? [];
+    let activeParameter = 0;
+    for (const argument of argumentsArray) {
+        if (position > argument.getEnd()) {
+            activeParameter += 1;
+            continue;
+        }
+        break;
+    }
+    return Math.min(activeParameter, Math.max(argumentsArray.length - 1, 0));
+}
+function parameterLabelForSignature(checker, parameter, callLike) {
+    const declaration = parameter.valueDeclaration ?? parameter.declarations?.[0];
+    const name = parameter.getName();
+    const isRest = declaration !== undefined && ts.isParameter(declaration) &&
+        declaration.dotDotDotToken !== undefined;
+    const isOptional = declaration !== undefined &&
+        ts.isParameter(declaration) &&
+        (declaration.questionToken !== undefined || declaration.initializer !== undefined);
+    const parameterType = checker.getTypeOfSymbolAtLocation(parameter, callLike);
+    return `${isRest ? '...' : ''}${name}${isOptional ? '?' : ''}: ${normalizeSurfaceTypeDisplayText(checker.typeToString(parameterType))}`;
+}
+function signatureHelpForNode(checker, node, position) {
+    const callLike = findCallLikeContainingPosition(node, position);
+    if (!callLike) {
+        return null;
+    }
+    const signature = checker.getResolvedSignature(callLike);
+    if (!signature) {
+        return null;
+    }
+    const parameters = signature.getParameters();
+    const activeParameter = activeParameterForCallLike(callLike, position);
+    const signatureKind = ts.isNewExpression(callLike)
+        ? ts.SignatureKind.Construct
+        : ts.SignatureKind.Call;
+    const calleeLabel = ts.isNewExpression(callLike)
+        ? `new ${callLike.expression.getText(callLike.getSourceFile())}`
+        : callLike.expression.getText(callLike.getSourceFile());
+    return {
+        activeParameter,
+        activeSignature: 0,
+        signatures: [{
+                label: `${calleeLabel}${normalizeSurfaceTypeDisplayText(checker.signatureToString(signature, callLike, ts.TypeFormatFlags.NoTruncation, signatureKind))}`,
+                parameters: parameters.map((parameter) => ({
+                    label: parameterLabelForSignature(checker, parameter, callLike),
+                })),
+            }],
+    };
+}
+function macroSignatureOperandDisplayText(operand) {
+    if (operand.refinement) {
+        return operand.refinement.displayText;
+    }
+    switch (operand.kind) {
+        case 'expr':
+            return `<${operand.name}>`;
+        case 'template':
+            return '`...`';
+        case 'block':
+            return '{ ... }';
+        case 'decl':
+            return '<declaration>';
+    }
+}
+function macroSignatureParameterLabel(operand) {
+    return `${operand.name}${operand.optional ? '?' : ''}: ${macroSignatureOperandDisplayText(operand)}`;
+}
+function macroInvocationParameterSpans(invocation) {
+    const spans = invocation.argumentSpans.map((argument) => argument.span);
+    if (invocation.trailingBlockSpan) {
+        spans.push(invocation.trailingBlockSpan);
+    }
+    if (invocation.declarationSpan) {
+        spans.push(invocation.declarationSpan);
+    }
+    return spans;
+}
+function activeParameterForMacroInvocation(invocation, sourcePosition) {
+    const operandSpans = macroInvocationParameterSpans(invocation);
+    if (operandSpans.length === 0) {
+        return 0;
+    }
+    let activeParameter = 0;
+    for (let index = 0; index < operandSpans.length; index += 1) {
+        const span = operandSpans[index];
+        if (containsPosition(span.start, span.end, sourcePosition)) {
+            return index;
+        }
+        if (sourcePosition >= span.end) {
+            activeParameter = Math.min(index + 1, operandSpans.length - 1);
+        }
+    }
+    return activeParameter;
+}
+function signatureHelpForMacroDefinition(definition, invocation, sourcePosition, context) {
+    const signature = definition.signature;
+    if (!signature) {
+        return null;
+    }
+    const examples = formatMacroSignatureExamples(signature, invocation.nameText);
+    let activeSignature = 0;
+    if (context) {
+        const decoded = tryReadMacroSignature(signature, context);
+        if (decoded) {
+            const decodedIndex = signature.cases.findIndex((signatureCase) => signatureCase === decoded.signatureCase);
+            if (decodedIndex >= 0) {
+                activeSignature = decodedIndex;
+            }
+        }
+    }
+    return {
+        activeParameter: activeParameterForMacroInvocation(invocation, sourcePosition),
+        activeSignature,
+        signatures: signature.cases.map((signatureCase, index) => ({
+            label: examples[index],
+            parameters: signatureCase.operands.map((operand) => ({
+                label: macroSignatureParameterLabel(operand),
+            })),
+        })),
+    };
+}
+function createHoverRange(start, end, originalText) {
+    const startPosition = getLineAndCharacterOfPosition(originalText, start);
+    const endPosition = getLineAndCharacterOfPosition(originalText, end);
+    return {
+        start: { line: startPosition.line, character: startPosition.character },
+        end: { line: endPosition.line, character: endPosition.character },
+    };
+}
+function createLocationKey(location) {
+    return `${location.uri}:${location.range.start.line}:${location.range.start.character}:${location.range.end.line}:${location.range.end.character}`;
+}
+function createRangeFromOffsets(start, end, text) {
+    const safeEnd = Math.max(start, end);
+    return createHoverRange(start, safeEnd, text);
+}
+function rangesEqual(left, right) {
+    return left.start.line === right.start.line &&
+        left.start.character === right.start.character &&
+        left.end.line === right.end.line &&
+        left.end.character === right.end.character;
+}
+function createRangeForNode(preparedProject, sourceFile, node) {
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const preparedFile = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+    if (preparedFile) {
+        const mappedRange = mapProgramEnclosingRangeToSource(preparedFile, node.getStart(sourceFile), node.getEnd());
+        return createRangeFromOffsets(mappedRange.start, mappedRange.end, preparedFile.originalText);
+    }
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+        start: { line: start.line, character: start.character },
+        end: { line: end.line, character: end.character },
+    };
+}
+function createMarkdownCodeBlock(value, language = 'ts') {
+    return `\`\`\`${language}\n${value}\n\`\`\``;
+}
+function createMarkdownHoverContents(code, details = []) {
+    const markdownParts = [createMarkdownCodeBlock(code)];
+    if (details.length > 0) {
+        markdownParts.push(...details);
+    }
+    return {
+        kind: 'markdown',
+        value: markdownParts.join('\n\n'),
+    };
+}
+function createMarkdownTextHoverContents(summary, details = []) {
+    return {
+        kind: 'markdown',
+        value: [summary, ...details].join('\n\n'),
+    };
+}
+function normalizeSurfaceTypeDisplayText(text) {
+    return text.replace(/\b[A-Za-z_$][\w$]*\b/gu, (name) => {
+        if (isElaboratedF64TypeImportName(name)) {
+            return 'number';
+        }
+        if (isElaboratedBigIntTypeImportName(name)) {
+            return 'bigint';
+        }
+        return name;
+    });
+}
+function typeToDisplayString(checker, node) {
+    const type = checker.getTypeAtLocation(node);
+    return normalizeSurfaceTypeDisplayText(checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation));
+}
+function variableKeywordForDeclaration(node) {
+    if ((node.parent.flags & ts.NodeFlags.Const) !== 0) {
+        return 'const';
+    }
+    if ((node.parent.flags & ts.NodeFlags.Let) !== 0) {
+        return 'let';
+    }
+    return 'var';
+}
+function formatSignatureHover(checker, node, symbol, labelPrefix, signatureKind) {
+    const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+    const [signature] = checker.getSignaturesOfType(type, signatureKind);
+    if (!signature) {
+        return undefined;
+    }
+    return `${labelPrefix}${normalizeSurfaceTypeDisplayText(checker.signatureToString(signature, node, ts.TypeFormatFlags.NoTruncation, signatureKind))}`;
+}
+function formatSymbolHoverCode(checker, node) {
+    const symbol = resolveSymbolAtNode(checker, node);
+    if (!symbol) {
+        const typeText = typeToDisplayString(checker, node);
+        return typeText.length > 0 ? typeText : null;
+    }
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    const name = symbol.getName();
+    if (!declaration || !isUserFacingSymbolName(name)) {
+        const typeText = typeToDisplayString(checker, node);
+        return typeText.length > 0 ? typeText : null;
+    }
+    const displayType = typeToDisplayString(checker, node);
+    if (ts.isVariableDeclaration(declaration)) {
+        return `${variableKeywordForDeclaration(declaration)} ${name}: ${displayType}`;
+    }
+    if (ts.isParameter(declaration)) {
+        return `${declaration.dotDotDotToken ? '...' : ''}${name}: ${displayType}`;
+    }
+    if (ts.isPropertyDeclaration(declaration) || ts.isPropertySignature(declaration)) {
+        const readonlyPrefix = isReadonlyDeclaration(declaration) ? 'readonly ' : '';
+        return `${readonlyPrefix}${name}: ${displayType}`;
+    }
+    if (ts.isFunctionDeclaration(declaration)) {
+        return formatSignatureHover(checker, node, symbol, `function ${name}`, ts.SignatureKind.Call) ??
+            `function ${name}: ${displayType}`;
+    }
+    if (ts.isMethodDeclaration(declaration) ||
+        ts.isMethodSignature(declaration) ||
+        ts.isGetAccessorDeclaration(declaration) ||
+        ts.isSetAccessorDeclaration(declaration)) {
+        return formatSignatureHover(checker, node, symbol, name, ts.SignatureKind.Call) ??
+            `${name}: ${displayType}`;
+    }
+    if (ts.isConstructorDeclaration(declaration)) {
+        return formatSignatureHover(checker, node, symbol, 'new ', ts.SignatureKind.Construct) ??
+            `new ${name}`;
+    }
+    if (ts.isClassDeclaration(declaration)) {
+        return `class ${name}`;
+    }
+    if (ts.isInterfaceDeclaration(declaration)) {
+        return `interface ${name}`;
+    }
+    if (ts.isTypeAliasDeclaration(declaration)) {
+        const declaredType = checker.getDeclaredTypeOfSymbol(symbol);
+        return `type ${name} = ${normalizeSurfaceTypeDisplayText(checker.typeToString(declaredType, node, ts.TypeFormatFlags.NoTruncation))}`;
+    }
+    if (ts.isEnumDeclaration(declaration)) {
+        return `enum ${name}`;
+    }
+    if (ts.isEnumMember(declaration)) {
+        return `${name} = ${typeToDisplayString(checker, declaration.name)}`;
+    }
+    if (ts.isModuleDeclaration(declaration)) {
+        return `namespace ${name}`;
+    }
+    const typeText = displayType;
+    return typeText.length > 0 ? typeText : null;
+}
+function createMacroSummaryHover(invocation, originalText, details = []) {
+    return {
+        contents: createMarkdownTextHoverContents(`**macro** \`${invocation.nameText}\``, details),
+        range: createHoverRange(invocation.nameSpan.start, invocation.nameSpan.end, originalText),
+    };
+}
+function createCustomMacroSummaryContents(macroName, body, details = []) {
+    const trimmedBody = body.trim();
+    if (trimmedBody.startsWith('**macro** `')) {
+        const value = details.length > 0 && !body.includes('Accepted forms:')
+            ? `${body}\n\n${details.join('\n\n')}`
+            : body;
+        return {
+            kind: 'markdown',
+            value,
+        };
+    }
+    return createMarkdownTextHoverContents(`**macro** \`${macroName}\``, [
+        body,
+        ...details,
+    ]);
+}
+function createCustomMacroSummaryHover(invocation, originalText, body, details = []) {
+    return {
+        contents: createCustomMacroSummaryContents(invocation.nameText, body, details),
+        range: createHoverRange(invocation.nameSpan.start, invocation.nameSpan.end, originalText),
+    };
+}
+function signatureHoverDetails(definition, macroName) {
+    if (!definition.signature) {
+        return [];
+    }
+    const sections = [
+        [
+            'Accepted forms:',
+            ...formatMacroSignatureExamples(definition.signature, macroName).map((example) => createMarkdownCodeBlock(example)),
+        ].join('\n'),
+    ];
+    const operandDescriptions = new Map();
+    for (const signatureCase of definition.signature.cases) {
+        for (const operand of signatureCase.operands) {
+            if (operand.description && !operandDescriptions.has(operand.name)) {
+                operandDescriptions.set(operand.name, operand.description);
+            }
+        }
+    }
+    if (operandDescriptions.size > 0) {
+        sections.push([
+            'Operands:',
+            ...[...operandDescriptions.entries()].map(([name, description]) => `- \`${name}\`: ${description}`),
+        ].join('\n'));
+    }
+    return sections;
+}
+function getInvocationBlockSpan(invocation) {
+    if (invocation.trailingBlockSpan) {
+        return invocation.trailingBlockSpan;
+    }
+    if (invocation.invocationKind === 'block') {
+        const [firstArgument] = invocation.argumentSpans;
+        if (firstArgument?.kind === 'BlockArg') {
+            return firstArgument.span;
+        }
+    }
+    return undefined;
+}
+function isIdentifierPart(character) {
+    return character !== undefined && /[\p{ID_Continue}_$\u200C\u200D]/u.test(character);
+}
+function createTokenHoverRange(position, originalText) {
+    let start = position;
+    let end = position + 1;
+    while (start > 0 && isIdentifierPart(originalText[start - 1])) {
+        start -= 1;
+    }
+    while (end < originalText.length && isIdentifierPart(originalText[end])) {
+        end += 1;
+    }
+    return createHoverRange(start, end, originalText);
+}
+function containsPosition(start, end, position) {
+    return position >= start && position < end;
+}
+function getIdentifierPrefixAtPosition(text, position) {
+    let start = position;
+    while (start > 0 && isIdentifierPart(text[start - 1])) {
+        start -= 1;
+    }
+    return text.slice(start, position);
+}
+function isUserFacingSymbolName(name) {
+    return !name.startsWith('__@') && !name.startsWith('__sts_');
+}
+function isReadonlyDeclaration(node) {
+    if (ts.isVariableDeclaration(node)) {
+        return (node.parent.flags & ts.NodeFlags.Const) !== 0;
+    }
+    if (ts.isPropertyDeclaration(node) ||
+        ts.isPropertySignature(node) ||
+        ts.isParameter(node)) {
+        return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword) ??
+            false;
+    }
+    return false;
+}
+function getDeclarationNameNode(node) {
+    if (ts.isVariableDeclaration(node)) {
+        return node.name;
+    }
+    if (ts.isParameter(node) || ts.isBindingElement(node)) {
+        return node.name;
+    }
+    if (ts.isFunctionDeclaration(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isPropertyDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isEnumDeclaration(node) ||
+        ts.isEnumMember(node) ||
+        ts.isModuleDeclaration(node) ||
+        ts.isPropertySignature(node) ||
+        ts.isMethodSignature(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node)) {
+        return node.name;
+    }
+    if (ts.isConstructorDeclaration(node)) {
+        return node;
+    }
+    return undefined;
+}
+function getDeclarationNameText(node) {
+    if (ts.isConstructorDeclaration(node)) {
+        return 'constructor';
+    }
+    const nameNode = getDeclarationNameNode(node);
+    if (!nameNode) {
+        return undefined;
+    }
+    if (ts.isIdentifier(nameNode) || ts.isPrivateIdentifier(nameNode)) {
+        return nameNode.text;
+    }
+    if (ts.isStringLiteral(nameNode) || ts.isNumericLiteral(nameNode)) {
+        return nameNode.text;
+    }
+    if (ts.isComputedPropertyName(nameNode)) {
+        return nameNode.getText(nameNode.getSourceFile());
+    }
+    return nameNode.getText(nameNode.getSourceFile());
+}
+function documentSymbolKindForNode(node) {
+    if (ts.isVariableDeclaration(node)) {
+        const declarationList = node.parent;
+        return (declarationList.flags & ts.NodeFlags.Const) !== 0 ? 14 : 13;
+    }
+    if (ts.isFunctionDeclaration(node)) {
+        return 12;
+    }
+    if (ts.isClassDeclaration(node)) {
+        return 5;
+    }
+    if (ts.isMethodDeclaration(node) ||
+        ts.isMethodSignature(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node)) {
+        return 6;
+    }
+    if (ts.isPropertyDeclaration(node)) {
+        return 8;
+    }
+    if (ts.isPropertySignature(node)) {
+        return 7;
+    }
+    if (ts.isConstructorDeclaration(node)) {
+        return 9;
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+        return 11;
+    }
+    if (ts.isEnumDeclaration(node)) {
+        return 10;
+    }
+    if (ts.isEnumMember(node)) {
+        return 22;
+    }
+    if (ts.isModuleDeclaration(node)) {
+        return 2;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+        return 13;
+    }
+    return undefined;
+}
+function semanticTokenTypeForNode(node) {
+    if (ts.isBindingElement(node)) {
+        let current = node.parent;
+        while (current) {
+            if (ts.isParameter(current)) {
+                return 'parameter';
+            }
+            if (ts.isVariableDeclaration(current)) {
+                return 'variable';
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    if (ts.isVariableDeclaration(node)) {
+        return 'variable';
+    }
+    if (ts.isFunctionDeclaration(node)) {
+        return 'function';
+    }
+    if (ts.isClassDeclaration(node)) {
+        return 'class';
+    }
+    if (ts.isMethodDeclaration(node) ||
+        ts.isMethodSignature(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node)) {
+        return 'method';
+    }
+    if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node)) {
+        return 'property';
+    }
+    if (ts.isParameter(node)) {
+        return 'parameter';
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+        return 'interface';
+    }
+    if (ts.isEnumDeclaration(node)) {
+        return 'enum';
+    }
+    if (ts.isEnumMember(node)) {
+        return 'enumMember';
+    }
+    if (ts.isModuleDeclaration(node)) {
+        return 'namespace';
+    }
+    if (ts.isTypeAliasDeclaration(node) || ts.isTypeParameterDeclaration(node)) {
+        return 'type';
+    }
+    return undefined;
+}
+function declarationNodeForSemanticToken(checker, node) {
+    const nameNode = getDeclarationNameNode(node.parent);
+    if (nameNode === node) {
+        return node.parent;
+    }
+    const symbol = resolveSymbolAtNode(checker, node);
+    if (!symbol) {
+        return undefined;
+    }
+    return symbol.valueDeclaration ?? symbol.declarations?.[0];
+}
+function semanticTokenClassification(checker, node) {
+    if (ts.isIdentifier(node)) {
+        const parent = node.parent;
+        if ((ts.isImportSpecifier(parent) && parent.name === node && !parent.isTypeOnly) ||
+            ts.isNamespaceImport(parent) ||
+            (ts.isImportClause(parent) && parent.name === node && !parent.isTypeOnly)) {
+            return {
+                type: 'variable',
+                modifiers: ['declaration', 'readonly'],
+            };
+        }
+    }
+    const declarationNode = declarationNodeForSemanticToken(checker, node);
+    if (!declarationNode) {
+        return null;
+    }
+    const type = semanticTokenTypeForNode(declarationNode);
+    if (!type) {
+        return null;
+    }
+    const modifiers = [];
+    if (getDeclarationNameNode(declarationNode) === node) {
+        modifiers.push('declaration');
+    }
+    if (isReadonlyDeclaration(declarationNode)) {
+        modifiers.push('readonly');
+    }
+    return { type, modifiers };
+}
+function encodeSemanticTokens(tokens) {
+    const sortedTokens = [...tokens].sort((left, right) => left.line - right.line || left.startCharacter - right.startCharacter ||
+        left.length - right.length);
+    const data = [];
+    let previousLine = 0;
+    let previousStartCharacter = 0;
+    for (const token of sortedTokens) {
+        const deltaLine = token.line - previousLine;
+        const deltaStart = deltaLine === 0
+            ? token.startCharacter - previousStartCharacter
+            : token.startCharacter;
+        const tokenTypeIndex = SEMANTIC_TOKEN_TYPE_INDICES.get(token.tokenType);
+        if (tokenTypeIndex === undefined) {
+            continue;
+        }
+        const modifierMask = token.modifiers.reduce((mask, modifier) => {
+            const modifierIndex = SEMANTIC_TOKEN_MODIFIER_INDICES.get(modifier);
+            return modifierIndex === undefined ? mask : mask | (1 << modifierIndex);
+        }, 0);
+        data.push(deltaLine, deltaStart, token.length, tokenTypeIndex, modifierMask);
+        previousLine = token.line;
+        previousStartCharacter = token.startCharacter;
+    }
+    return { data };
+}
+function pushSemanticTokenForRange(tokens, text, start, end, tokenType, modifiers) {
+    if (end <= start) {
+        return;
+    }
+    const startPosition = getLineAndCharacterOfPosition(text, start);
+    const endPosition = getLineAndCharacterOfPosition(text, end);
+    if (startPosition.line !== endPosition.line) {
+        return;
+    }
+    tokens.push({
+        line: startPosition.line,
+        startCharacter: startPosition.character,
+        length: end - start,
+        tokenType,
+        modifiers,
+    });
+}
+function pushMacroSemanticTokens(tokens, originalText, semanticTokens) {
+    for (const semanticToken of semanticTokens) {
+        pushSemanticTokenForRange(tokens, originalText, semanticToken.span.start, semanticToken.span.end, semanticToken.type, [...(semanticToken.modifiers ?? [])]);
+    }
+}
+function collectSemanticTokensFromSourceFile(preparedProject, sourceFile, checker) {
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const preparedFile = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+    if (!preparedFile) {
+        return { data: [] };
+    }
+    const preparedSourceFile = preparedFile;
+    const filePath = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const tokens = [];
+    function visit(node) {
+        if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) {
+            const name = node.text;
+            if (isUserFacingSymbolName(name)) {
+                const classification = semanticTokenClassification(checker, node);
+                if (classification) {
+                    const mappedRange = mapProgramRangeToSource(preparedSourceFile, node.getStart(sourceFile), node.getEnd());
+                    if (!mappedRange.intersectsReplacement && mappedRange.end > mappedRange.start) {
+                        pushSemanticTokenForRange(tokens, preparedSourceFile.originalText, mappedRange.start, mappedRange.end, classification.type, classification.modifiers);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    const scanResult = scanMacroCandidates(sourceFileName, preparedFile.originalText);
+    for (const hash of scanResult.hashes) {
+        if (hash.kind !== 'macro-start') {
+            continue;
+        }
+        const parsed = parseMacroInvocationAt(sourceFileName, preparedFile.originalText, hash.span.start);
+        if ('reason' in parsed) {
+            continue;
+        }
+        pushSemanticTokenForRange(tokens, preparedFile.originalText, parsed.nameSpan.start, parsed.nameSpan.end, 'function', []);
+    }
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject).filter((entry) => entry.sourceFile.fileName === sourceFile.fileName);
+    for (const match of collected) {
+        const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+        if (!artifacts) {
+            continue;
+        }
+        const semanticTokens = [
+            ...artifacts.fragments.flatMap((fragment) => fragment.semanticTokens ?? []),
+            ...(artifacts.definition.semanticTokens && artifacts.node
+                ? artifacts.definition.semanticTokens({ node: artifacts.node })
+                : []),
+        ];
+        if (semanticTokens.length === 0) {
+            continue;
+        }
+        pushMacroSemanticTokens(tokens, preparedFile.originalText, semanticTokens);
+    }
+    return encodeSemanticTokens(tokens);
+}
+function findSourceRootDirectory(filePath) {
+    let currentDirectory = dirname(filePath);
+    while (true) {
+        if (currentDirectory.endsWith('/src') || currentDirectory === 'src') {
+            return currentDirectory;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+function createStarterTsconfigText(filePath) {
+    const sourceRootDirectory = findSourceRootDirectory(filePath);
+    const include = sourceRootDirectory ? ['src/**/*.ts', 'src/**/*.sts'] : ['**/*.ts', '**/*.sts'];
+    return `${JSON.stringify({
+        compilerOptions: {
+            strict: true,
+            noEmit: true,
+            target: 'ES2022',
+            module: 'ESNext',
+        },
+        include,
+    }, null, 2)}\n`;
+}
+function suggestedProjectPathForFile(filePath) {
+    const sourceRootDirectory = findSourceRootDirectory(filePath);
+    const projectDirectory = sourceRootDirectory ? dirname(sourceRootDirectory) : dirname(filePath);
+    return join(projectDirectory, 'tsconfig.json');
+}
+function readCodeActionDocumentText(uri, session) {
+    const openDocument = session.get(uri);
+    if (openDocument) {
+        return openDocument.text;
+    }
+    const filePath = fromFileUrl(uri);
+    try {
+        return readTextFileSync(filePath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function documentLineTexts(text) {
+    return text.split('\n');
+}
+function lineIndentation(lineText) {
+    const match = lineText.match(/^\s*/u);
+    return match?.[0] ?? '';
+}
+function deleteWholeLineEdit(lines, line) {
+    const lineText = lines[line];
+    if (lineText === undefined) {
+        return undefined;
+    }
+    if (line < lines.length - 1) {
+        return {
+            newText: '',
+            range: {
+                start: { line, character: 0 },
+                end: { line: line + 1, character: 0 },
+            },
+        };
+    }
+    return {
+        newText: '',
+        range: {
+            start: { line, character: 0 },
+            end: { line, character: lineText.length },
+        },
+    };
+}
+function isAnnotationCommentLine(lineText) {
+    return /^\s*\/\/\s*#\[/u.test(lineText);
+}
+function annotationNameForLine(lineText) {
+    const match = lineText.match(/^\s*\/\/\s*#\[([A-Za-z_$][\w$.-]*)/u);
+    return match?.[1];
+}
+function diagnosticEvidenceValue(diagnostic, label) {
+    return diagnostic.data?.metadata?.evidence?.find((fact) => fact.label === label)?.value;
+}
+function replaceLineEdit(lines, line, newText) {
+    const lineText = lines[line];
+    if (lineText === undefined) {
+        return undefined;
+    }
+    return {
+        newText,
+        range: {
+            start: { line, character: 0 },
+            end: { line, character: lineText.length },
+        },
+    };
+}
+function annotationLineReplacement(lineText, annotationName) {
+    if (!isAnnotationCommentLine(lineText)) {
+        return undefined;
+    }
+    const indentation = lineIndentation(lineText);
+    return `${indentation}// #[${annotationName}]`;
+}
+function findAttachedAnnotationLine(lines, startLine, annotationName) {
+    for (let line = Math.min(startLine, lines.length - 1); line >= 0; line -= 1) {
+        const lineText = lines[line] ?? '';
+        if (isAnnotationCommentLine(lineText)) {
+            if (!annotationName || annotationNameForLine(lineText) === annotationName) {
+                return line;
+            }
+            continue;
+        }
+        if (line === startLine) {
+            continue;
+        }
+        if (lineText.trim() === '') {
+            continue;
+        }
+        return undefined;
+    }
+    return undefined;
+}
+function createRemoveUnknownAnnotationCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1007') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined || !isAnnotationCommentLine(lineText)) {
+        return undefined;
+    }
+    const edit = deleteWholeLineEdit(lines, line);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: 'Remove unknown annotation comment',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function createRemoveUnsupportedAnnotationArgumentsCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1028') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined) {
+        return undefined;
+    }
+    const annotationName = diagnosticEvidenceValue(diagnostic, 'annotationName') ??
+        annotationNameForLine(lineText);
+    if (!annotationName) {
+        return undefined;
+    }
+    const newText = annotationLineReplacement(lineText, annotationName);
+    if (!newText || newText === lineText) {
+        return undefined;
+    }
+    const edit = replaceLineEdit(lines, line, newText);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: 'Remove unsupported annotation arguments',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function createVarianceContractRewriteCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1031' && diagnostic.code !== 'SOUND1032') {
+        return undefined;
+    }
+    const replacementContract = diagnostic.data?.metadata?.secondarySymbol;
+    if (!replacementContract || !replacementContract.startsWith('// #[variance(')) {
+        return undefined;
+    }
+    const startLine = diagnostic.range?.start.line;
+    if (startLine === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const annotationLine = findAttachedAnnotationLine(lines, startLine, 'variance');
+    if (annotationLine === undefined) {
+        return undefined;
+    }
+    const edit = replaceLineEdit(lines, annotationLine, replacementContract);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: diagnostic.code === 'SOUND1031'
+            ? 'Rewrite checked variance contract'
+            : 'Align checked variance contract',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function collectTopLevelBindingNames(sourceFile) {
+    const names = new Set();
+    const collectBindingName = (name) => {
+        if (ts.isIdentifier(name)) {
+            names.add(name.text);
+            return;
+        }
+        for (const element of name.elements) {
+            if (!ts.isOmittedExpression(element)) {
+                collectBindingName(element.name);
+            }
+        }
+    };
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            if (statement.importClause?.name) {
+                names.add(statement.importClause.name.text);
+            }
+            const namedBindings = statement.importClause?.namedBindings;
+            if (namedBindings) {
+                if (ts.isNamespaceImport(namedBindings)) {
+                    names.add(namedBindings.name.text);
+                }
+                else {
+                    for (const element of namedBindings.elements) {
+                        names.add(element.name.text);
+                    }
+                }
+            }
+            continue;
+        }
+        if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) ||
+            ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) ||
+            ts.isEnumDeclaration(statement)) {
+            if (statement.name) {
+                names.add(statement.name.text);
+            }
+            continue;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                collectBindingName(declaration.name);
+            }
+        }
+    }
+    return names;
+}
+function createUniqueMacroAlias(annotationName, sourceFile) {
+    const baseAlias = `macro${annotationName[0]?.toUpperCase() ?? ''}${annotationName.slice(1)}`;
+    const names = collectTopLevelBindingNames(sourceFile);
+    let alias = baseAlias;
+    let suffix = 2;
+    while (names.has(alias)) {
+        alias = `${baseAlias}${suffix}`;
+        suffix += 1;
+    }
+    return alias;
+}
+function findNamedImportAliasEdit(filePath, text, importSpecifier, importedBinding, alias) {
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement)) {
+            continue;
+        }
+        if (!ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== importSpecifier) {
+            continue;
+        }
+        const namedBindings = statement.importClause?.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+            continue;
+        }
+        for (const element of namedBindings.elements) {
+            if (element.name.text !== importedBinding) {
+                continue;
+            }
+            const importStart = getLineAndCharacterOfPosition(text, element.getStart(sourceFile));
+            const importEnd = getLineAndCharacterOfPosition(text, element.getEnd());
+            const importedName = element.propertyName?.text ?? element.name.text;
+            return {
+                newText: `${importedName} as ${alias}`,
+                range: {
+                    start: { line: importStart.line, character: importStart.character },
+                    end: { line: importEnd.line, character: importEnd.character },
+                },
+            };
+        }
+    }
+    return undefined;
+}
+function createAliasReservedAnnotationMacroCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1033') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const annotationName = diagnosticEvidenceValue(diagnostic, 'annotationName');
+    const importSpecifier = diagnosticEvidenceValue(diagnostic, 'importSpecifier');
+    const importedBinding = diagnosticEvidenceValue(diagnostic, 'importedBinding');
+    if (!annotationName || !importSpecifier || !importedBinding) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined || !isAnnotationCommentLine(lineText)) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const alias = createUniqueMacroAlias(annotationName, sourceFile);
+    const importEdit = findNamedImportAliasEdit(filePath, text, importSpecifier, importedBinding, alias);
+    if (!importEdit) {
+        return undefined;
+    }
+    const annotationReplacement = annotationLineReplacement(lineText, alias);
+    if (!annotationReplacement) {
+        return undefined;
+    }
+    const annotationEdit = replaceLineEdit(lines, line, annotationReplacement);
+    if (!annotationEdit) {
+        return undefined;
+    }
+    return {
+        title: 'Alias imported annotation macro',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [importEdit, annotationEdit],
+            },
+        },
+    };
+}
+function isDynamicImportCallExpression(node) {
+    return !!node &&
+        ts.isCallExpression(node) &&
+        node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]);
+}
+function isRequireCallExpression(node) {
+    return !!node &&
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'require' &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]);
+}
+function unwrapAwaitedImportInitializer(node) {
+    if (!node) {
+        return undefined;
+    }
+    if (ts.isAwaitExpression(node)) {
+        return node.expression;
+    }
+    return ts.isExpression(node) ? node : undefined;
+}
+function variableDeclarationInteropBoundaryLine(declaration, text, sourceFile) {
+    const initializer = unwrapAwaitedImportInitializer(declaration.initializer);
+    if (!isRequireCallExpression(initializer) && !isDynamicImportCallExpression(initializer)) {
+        return undefined;
+    }
+    const statement = declaration.parent?.parent;
+    const startNode = statement && ts.isVariableStatement(statement) ? statement : declaration;
+    return getLineAndCharacterOfPosition(text, startNode.getStart(sourceFile)).line;
+}
+function collectBindingNames(name) {
+    if (ts.isIdentifier(name)) {
+        return [name.text];
+    }
+    const names = [];
+    for (const element of name.elements) {
+        if (!ts.isOmittedExpression(element)) {
+            names.push(...collectBindingNames(element.name));
+        }
+    }
+    return names;
+}
+function collectInteropBoundaryBindings(sourceFile, text) {
+    const bindings = [];
+    const addBinding = (name, startNode) => {
+        const position = startNode.getStart(sourceFile);
+        bindings.push({
+            name,
+            position,
+            line: getLineAndCharacterOfPosition(text, position).line,
+        });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && !node.importClause?.isTypeOnly) {
+            if (node.importClause?.name) {
+                addBinding(node.importClause.name.text, node);
+            }
+            const namedBindings = node.importClause?.namedBindings;
+            if (namedBindings) {
+                if (ts.isNamespaceImport(namedBindings)) {
+                    addBinding(namedBindings.name.text, node);
+                }
+                else {
+                    for (const element of namedBindings.elements) {
+                        if (!element.isTypeOnly) {
+                            addBinding(element.name.text, node);
+                        }
+                    }
+                }
+            }
+        }
+        if (ts.isImportEqualsDeclaration(node)) {
+            addBinding(node.name.text, node);
+        }
+        if (ts.isVariableDeclaration(node)) {
+            const initializer = unwrapAwaitedImportInitializer(node.initializer);
+            if (isRequireCallExpression(initializer) || isDynamicImportCallExpression(initializer)) {
+                const startNode = node.parent?.parent && ts.isVariableStatement(node.parent.parent)
+                    ? node.parent.parent
+                    : node;
+                for (const name of collectBindingNames(node.name)) {
+                    addBinding(name, startNode);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return bindings;
+}
+function bindingInteropBoundaryLine(sourceFile, text, node) {
+    const bindings = collectInteropBoundaryBindings(sourceFile, text);
+    if (bindings.length === 0) {
+        return undefined;
+    }
+    const pickBoundaryLine = (name) => {
+        const position = node.getStart(sourceFile);
+        const candidates = bindings
+            .filter((binding) => binding.name === name && binding.position <= position)
+            .sort((left, right) => right.position - left.position);
+        return candidates[0]?.line;
+    };
+    if (ts.isIdentifier(node)) {
+        const directLine = pickBoundaryLine(node.text);
+        if (directLine !== undefined) {
+            return directLine;
+        }
+        const parent = node.parent;
+        if (ts.isPropertyAccessExpression(parent) &&
+            parent.name === node &&
+            ts.isIdentifier(parent.expression)) {
+            return pickBoundaryLine(parent.expression.text);
+        }
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+        return pickBoundaryLine(node.expression.text);
+    }
+    return undefined;
+}
+function findInteropBoundaryStartLine(filePath, text, diagnostic, _session) {
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const sourcePosition = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, sourcePosition);
+    const bindingLine = current ? bindingInteropBoundaryLine(sourceFile, text, current) : undefined;
+    if (bindingLine !== undefined) {
+        return bindingLine;
+    }
+    while (current) {
+        if (ts.isImportDeclaration(current) ||
+            ts.isImportEqualsDeclaration(current) ||
+            ts.isVariableStatement(current) ||
+            ts.isExpressionStatement(current)) {
+            return getLineAndCharacterOfPosition(text, current.getStart(sourceFile)).line;
+        }
+        current = current.parent;
+    }
+    return start.line;
+}
+function createAddInteropCodeAction(uri, filePath, diagnostic, text, session) {
+    if (diagnostic.code !== 'SOUND1005') {
+        return undefined;
+    }
+    const line = findInteropBoundaryStartLine(filePath, text, diagnostic, session);
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined) {
+        return undefined;
+    }
+    const indentation = lineIndentation(lineText);
+    return {
+        title: 'Add #[interop] boundary',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: `${indentation}// #[interop]\n`,
+                        range: {
+                            start: { line, character: 0 },
+                            end: { line, character: 0 },
+                        },
+                    }],
+            },
+        },
+    };
+}
+function createAddExternCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1029') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined) {
+        return undefined;
+    }
+    const indentation = lineIndentation(lineText);
+    return {
+        title: 'Add #[extern] boundary',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: `${indentation}// #[extern]\n`,
+                        range: {
+                            start: { line, character: 0 },
+                            end: { line, character: 0 },
+                        },
+                    }],
+            },
+        },
+    };
+}
+function createUnsupportedFeatureRewriteCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1022') {
+        return undefined;
+    }
+    const featureId = diagnostic.data?.metadata?.featureId;
+    if (featureId !== 'unsupported.varDeclaration' &&
+        featureId !== 'unsupported.looseEquality' &&
+        featureId !== 'unsupported.voidZero' &&
+        featureId !== 'unsupported.legacyOctalLiteral') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    if (featureId === 'unsupported.varDeclaration') {
+        while (current && !ts.isVariableDeclarationList(current)) {
+            current = current.parent;
+        }
+        if (!current) {
+            return undefined;
+        }
+        const keywordStart = current.getStart(sourceFile);
+        const keywordEnd = keywordStart + 3;
+        if (text.slice(keywordStart, keywordEnd) !== 'var') {
+            return undefined;
+        }
+        return {
+            title: 'Replace `var` with `let`',
+            kind: 'quickfix',
+            edit: {
+                changes: {
+                    [uri]: [{
+                            newText: 'let',
+                            range: createRangeFromOffsets(keywordStart, keywordEnd, text),
+                        }],
+                },
+            },
+        };
+    }
+    if (featureId === 'unsupported.looseEquality') {
+        while (current &&
+            (!ts.isBinaryExpression(current) ||
+                (current.operatorToken.kind !== ts.SyntaxKind.EqualsEqualsToken &&
+                    current.operatorToken.kind !== ts.SyntaxKind.ExclamationEqualsToken))) {
+            current = current.parent;
+        }
+        if (!current || !ts.isBinaryExpression(current)) {
+            return undefined;
+        }
+        const operatorStart = current.operatorToken.getStart(sourceFile);
+        const operatorEnd = current.operatorToken.getEnd();
+        const replacement = current.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken
+            ? '==='
+            : '!==';
+        return {
+            title: `Replace \`${current.operatorToken.getText(sourceFile)}\` with \`${replacement}\``,
+            kind: 'quickfix',
+            edit: {
+                changes: {
+                    [uri]: [{
+                            newText: replacement,
+                            range: createRangeFromOffsets(operatorStart, operatorEnd, text),
+                        }],
+                },
+            },
+        };
+    }
+    if (featureId === 'unsupported.voidZero') {
+        while (current && !ts.isVoidExpression(current)) {
+            current = current.parent;
+        }
+        if (!current || !ts.isVoidExpression(current)) {
+            return undefined;
+        }
+        return {
+            title: 'Replace `void 0` with `undefined`',
+            kind: 'quickfix',
+            edit: {
+                changes: {
+                    [uri]: [{
+                            newText: 'undefined',
+                            range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                        }],
+                },
+            },
+        };
+    }
+    while (current && !ts.isNumericLiteral(current)) {
+        current = current.parent;
+    }
+    if (!current || !ts.isNumericLiteral(current)) {
+        return undefined;
+    }
+    const literalText = current.getText(sourceFile);
+    if (!/^0[0-7]+$/.test(literalText)) {
+        return undefined;
+    }
+    return {
+        title: `Rewrite \`${literalText}\` as \`0o${literalText.slice(1)}\``,
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: `0o${literalText.slice(1)}`,
+                        range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                    }],
+            },
+        },
+    };
+}
+function createProofEscapeHatchRewriteCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1002' && diagnostic.code !== 'SOUND1003') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    if (diagnostic.code === 'SOUND1002') {
+        while (current &&
+            !ts.isAsExpression(current) &&
+            !ts.isTypeAssertionExpression(current)) {
+            current = current.parent;
+        }
+        if (!current ||
+            (!ts.isAsExpression(current) && !ts.isTypeAssertionExpression(current))) {
+            return undefined;
+        }
+        return {
+            title: 'Remove unchecked type assertion',
+            kind: 'quickfix',
+            edit: {
+                changes: {
+                    [uri]: [{
+                            newText: text.slice(current.expression.getStart(sourceFile), current.expression.getEnd()),
+                            range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                        }],
+                },
+            },
+        };
+    }
+    while (current && !ts.isNonNullExpression(current)) {
+        current = current.parent;
+    }
+    if (!current || !ts.isNonNullExpression(current)) {
+        return undefined;
+    }
+    return {
+        title: 'Remove non-null assertion',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: text.slice(current.expression.getStart(sourceFile), current.expression.getEnd()),
+                        range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                    }],
+            },
+        },
+    };
+}
+function createAnyTypeRewriteCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1001') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    while (current && current.kind !== ts.SyntaxKind.AnyKeyword) {
+        current = current.parent;
+    }
+    if (!current || current.kind !== ts.SyntaxKind.AnyKeyword) {
+        return undefined;
+    }
+    return {
+        title: 'Replace `any` with `unknown`',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: 'unknown',
+                        range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                    }],
+            },
+        },
+    };
+}
+function mappedSourceRangeForLookupNode(lookup, node) {
+    return mapProgramEnclosingRangeToSource(lookup.preparedFile, node.getStart(lookup.sourceFile), node.getEnd());
+}
+function findConditionExpressionAtSourcePosition(lookup, sourcePosition) {
+    const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+    if (mappedPosition.insideReplacement) {
+        return null;
+    }
+    let current = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+    while (current && !ts.isExpression(current)) {
+        current = current.parent;
+    }
+    if (!current || !ts.isExpression(current)) {
+        return null;
+    }
+    let expression = current;
+    while (expression.parent &&
+        ts.isExpression(expression.parent) &&
+        expression.parent.getStart(lookup.sourceFile) <= mappedPosition.position &&
+        mappedPosition.position < expression.parent.getEnd()) {
+        expression = expression.parent;
+    }
+    return expression;
+}
+function isNullishType(type) {
+    return (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0;
+}
+function isDefinitelyBooleanTypeForCodeAction(type) {
+    if (type.isUnion()) {
+        return type.types.every((part) => isDefinitelyBooleanTypeForCodeAction(part));
+    }
+    if (type.isIntersection()) {
+        return type.types.every((part) => isDefinitelyBooleanTypeForCodeAction(part));
+    }
+    return (type.flags & ts.TypeFlags.BooleanLike) !== 0;
+}
+function isAlwaysTruthyPresentType(type) {
+    if (type.isIntersection()) {
+        return type.types.every((part) => isAlwaysTruthyPresentType(part));
+    }
+    const flags = type.flags;
+    return (flags & (ts.TypeFlags.Object | ts.TypeFlags.NonPrimitive | ts.TypeFlags.ESSymbolLike)) !==
+        0;
+}
+function explicitNullishComparisonSuffix(type) {
+    const constituents = type.isUnion() ? type.types : [type];
+    let hasNull = false;
+    let hasUndefined = false;
+    let hasPresentConstituent = false;
+    for (const part of constituents) {
+        if (isNullishType(part)) {
+            hasNull || (hasNull = (part.flags & ts.TypeFlags.Null) !== 0);
+            hasUndefined || (hasUndefined = (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0);
+            continue;
+        }
+        hasPresentConstituent = true;
+        if (!isAlwaysTruthyPresentType(part)) {
+            return null;
+        }
+    }
+    if (!hasPresentConstituent || (hasNull === hasUndefined)) {
+        return null;
+    }
+    return hasNull ? ' !== null' : ' !== undefined';
+}
+function explicitNullishComparisonText(lookup, expression, text) {
+    const type = lookup.checker.getTypeAtLocation(expression);
+    const suffix = explicitNullishComparisonSuffix(type);
+    if (!suffix) {
+        return null;
+    }
+    const mappedRange = mappedSourceRangeForLookupNode(lookup, expression);
+    const expressionText = text.slice(mappedRange.start, mappedRange.end);
+    return {
+        expressionText,
+        mappedRange,
+        newText: `${expressionText}${suffix}`,
+    };
+}
+function createExplicitNullishConditionCodeAction(uri, filePath, diagnostic, text, session) {
+    if (diagnostic.code !== 'SOUND1022' ||
+        diagnostic.data?.metadata?.featureId !== 'unsupported.nonBooleanCondition') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const preparedProject = getPreparedProjectContext(filePath, session);
+    if (!preparedProject) {
+        return undefined;
+    }
+    const lookup = createDirectSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return undefined;
+    }
+    const sourcePosition = getPositionOfLineAndCharacter(text, start.line, start.character);
+    const expression = findConditionExpressionAtSourcePosition(lookup, sourcePosition);
+    if (!expression) {
+        return undefined;
+    }
+    const comparison = explicitNullishComparisonText(lookup, expression, text);
+    if (!comparison) {
+        return undefined;
+    }
+    return {
+        title: `Replace truthiness check with \`${comparison.newText}\``,
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: comparison.newText,
+                        range: createRangeFromOffsets(comparison.mappedRange.start, comparison.mappedRange.end, text),
+                    }],
+            },
+        },
+    };
+}
+function createExplicitBooleanLogicalOperatorCodeAction(uri, filePath, diagnostic, text, session) {
+    if (diagnostic.code !== 'SOUND1022' ||
+        diagnostic.data?.metadata?.featureId !== 'unsupported.nonBooleanLogicalOperator') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const preparedProject = getPreparedProjectContext(filePath, session);
+    if (!preparedProject) {
+        return undefined;
+    }
+    const lookup = createDirectSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return undefined;
+    }
+    const sourcePosition = getPositionOfLineAndCharacter(text, start.line, start.character);
+    const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+    if (mappedPosition.insideReplacement) {
+        return undefined;
+    }
+    let current = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+    while (current &&
+        (!ts.isBinaryExpression(current) ||
+            (current.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken &&
+                current.operatorToken.kind !== ts.SyntaxKind.BarBarToken))) {
+        current = current.parent;
+    }
+    if (!current || !ts.isBinaryExpression(current)) {
+        return undefined;
+    }
+    const leftType = lookup.checker.getTypeAtLocation(current.left);
+    const rightType = lookup.checker.getTypeAtLocation(current.right);
+    const leftIsBoolean = isDefinitelyBooleanTypeForCodeAction(leftType);
+    const rightIsBoolean = isDefinitelyBooleanTypeForCodeAction(rightType);
+    const leftComparison = leftIsBoolean
+        ? null
+        : explicitNullishComparisonText(lookup, current.left, text);
+    const rightComparison = rightIsBoolean
+        ? null
+        : explicitNullishComparisonText(lookup, current.right, text);
+    if ((!leftIsBoolean && !leftComparison) || (!rightIsBoolean && !rightComparison)) {
+        return undefined;
+    }
+    const mappedRange = mappedSourceRangeForLookupNode(lookup, current);
+    const leftRange = mappedSourceRangeForLookupNode(lookup, current.left);
+    const rightRange = mappedSourceRangeForLookupNode(lookup, current.right);
+    const operatorText = current.operatorToken.getText(lookup.sourceFile);
+    const leftText = leftComparison?.newText ?? text.slice(leftRange.start, leftRange.end);
+    const rightText = rightComparison?.newText ?? text.slice(rightRange.start, rightRange.end);
+    const newText = `${leftText} ${operatorText} ${rightText}`;
+    return {
+        title: `Make \`${operatorText}\` operands explicitly boolean`,
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText,
+                        range: createRangeFromOffsets(mappedRange.start, mappedRange.end, text),
+                    }],
+            },
+        },
+    };
+}
+function isTypeScriptPragmaCommentLine(lineText) {
+    const trimmed = lineText.trim();
+    return trimmed.startsWith('// @ts-') || trimmed.startsWith('/* @ts-');
+}
+function createRemoveTypeScriptPragmaCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1023') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined || !isTypeScriptPragmaCommentLine(lineText)) {
+        return undefined;
+    }
+    const edit = deleteWholeLineEdit(lines, line);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: 'Remove TypeScript pragma comment',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function createRemoveInvalidAnnotationTargetCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1027') {
+        return undefined;
+    }
+    const startLine = diagnostic.range?.start.line;
+    if (startLine === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const primarySymbol = diagnostic.data?.metadata?.primarySymbol;
+    const annotationName = primarySymbol?.match(/^#\[([A-Za-z_$][\w$.-]*)\]$/u)?.[1];
+    const annotationLine = findAttachedAnnotationLine(lines, startLine, annotationName);
+    const lineText = annotationLine === undefined ? undefined : lines[annotationLine];
+    if (annotationLine === undefined || lineText === undefined || !isAnnotationCommentLine(lineText)) {
+        return undefined;
+    }
+    const edit = deleteWholeLineEdit(lines, annotationLine);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: 'Remove invalid annotation comment',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function createRemoveAmbientExportCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1030') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    while (current) {
+        if (ts.canHaveModifiers(current)) {
+            const modifiers = ts.getModifiers(current);
+            const exportModifier = modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+            if (exportModifier) {
+                let editEnd = exportModifier.getEnd();
+                while (editEnd < text.length && /\s/.test(text[editEnd] ?? '')) {
+                    editEnd++;
+                    break;
+                }
+                return {
+                    title: 'Remove `export` from ambient runtime declaration',
+                    kind: 'quickfix',
+                    edit: {
+                        changes: {
+                            [uri]: [{
+                                    newText: '',
+                                    range: createRangeFromOffsets(exportModifier.getStart(sourceFile), editEnd, text),
+                                }],
+                        },
+                    },
+                };
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function createThrowNonErrorCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1025') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    while (current && !ts.isThrowStatement(current)) {
+        current = current.parent;
+    }
+    if (!current || !ts.isThrowStatement(current) || !current.expression) {
+        return undefined;
+    }
+    const expression = current.expression;
+    return {
+        title: 'Wrap thrown value in `new Error(...)`',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: `new Error(String(${text.slice(expression.getStart(sourceFile), expression.getEnd())}))`,
+                        range: createRangeFromOffsets(expression.getStart(sourceFile), expression.getEnd(), text),
+                    }],
+            },
+        },
+    };
+}
+function createReceiverSensitiveBindCodeAction(uri, filePath, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1035') {
+        return undefined;
+    }
+    const start = diagnostic.range?.start;
+    if (!start) {
+        return undefined;
+    }
+    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const position = getPositionOfLineAndCharacter(text, start.line, start.character);
+    let current = findDeepestNodeContainingPosition(sourceFile, position);
+    while (current &&
+        !ts.isPropertyAccessExpression(current) &&
+        !ts.isElementAccessExpression(current)) {
+        current = current.parent;
+    }
+    if (!current || (!ts.isPropertyAccessExpression(current) && !ts.isElementAccessExpression(current))) {
+        return undefined;
+    }
+    const receiverText = text.slice(current.expression.getStart(sourceFile), current.expression.getEnd());
+    const callableText = text.slice(current.getStart(sourceFile), current.getEnd());
+    return {
+        title: 'Bind the receiver for the extracted method',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [{
+                        newText: `${callableText}.bind(${receiverText})`,
+                        range: createRangeFromOffsets(current.getStart(sourceFile), current.getEnd(), text),
+                    }],
+            },
+        },
+    };
+}
+function createRemoveMalformedAnnotationCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1006') {
+        return undefined;
+    }
+    const line = diagnostic.range?.start.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    const lineText = lines[line];
+    if (lineText === undefined || !isAnnotationCommentLine(lineText)) {
+        return undefined;
+    }
+    const edit = deleteWholeLineEdit(lines, line);
+    if (!edit) {
+        return undefined;
+    }
+    return {
+        title: 'Remove malformed annotation comment',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: [edit],
+            },
+        },
+    };
+}
+function createRemoveDuplicateAnnotationsCodeAction(uri, diagnostic, text) {
+    if (diagnostic.code !== 'SOUND1026') {
+        return undefined;
+    }
+    const startLine = diagnostic.range?.start.line;
+    if (startLine === undefined) {
+        return undefined;
+    }
+    const lines = documentLineTexts(text);
+    if (!isAnnotationCommentLine(lines[startLine] ?? '')) {
+        return undefined;
+    }
+    const edits = [];
+    const seenNames = new Set();
+    for (let line = startLine; line < lines.length; line += 1) {
+        const lineText = lines[line] ?? '';
+        if (!isAnnotationCommentLine(lineText)) {
+            break;
+        }
+        const annotationName = annotationNameForLine(lineText);
+        if (!annotationName) {
+            continue;
+        }
+        if (seenNames.has(annotationName)) {
+            const edit = deleteWholeLineEdit(lines, line);
+            if (edit) {
+                edits.push(edit);
+            }
+            continue;
+        }
+        seenNames.add(annotationName);
+    }
+    if (edits.length === 0) {
+        return undefined;
+    }
+    return {
+        title: 'Remove duplicate annotation entries',
+        kind: 'quickfix',
+        edit: {
+            changes: {
+                [uri]: edits,
+            },
+        },
+    };
+}
+function createDocumentSymbolChildren(preparedProject, sourceFile, nodes) {
+    const symbols = [];
+    for (const node of nodes) {
+        const symbol = createDocumentSymbol(preparedProject, sourceFile, node);
+        if (symbol) {
+            symbols.push(symbol);
+        }
+    }
+    return symbols;
+}
+function childNodesForDocumentSymbol(node) {
+    if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+        return [...node.members];
+    }
+    if (ts.isEnumDeclaration(node)) {
+        return [...node.members];
+    }
+    if (ts.isModuleDeclaration(node) && node.body && ts.isModuleBlock(node.body)) {
+        return [...node.body.statements];
+    }
+    return [];
+}
+function createDocumentSymbol(preparedProject, sourceFile, node) {
+    const kind = documentSymbolKindForNode(node);
+    const name = getDeclarationNameText(node);
+    const nameNode = getDeclarationNameNode(node);
+    if (!kind || !name || !nameNode || !isUserFacingSymbolName(name)) {
+        return null;
+    }
+    const children = createDocumentSymbolChildren(preparedProject, sourceFile, childNodesForDocumentSymbol(node));
+    return {
+        children: children.length > 0 ? children : undefined,
+        kind,
+        name,
+        range: createRangeForNode(preparedProject, sourceFile, node),
+        selectionRange: createRangeForNode(preparedProject, sourceFile, nameNode),
+    };
+}
+function topLevelDocumentSymbols(preparedProject, sourceFile) {
+    const symbols = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const symbol = createDocumentSymbol(preparedProject, sourceFile, declaration);
+                if (symbol) {
+                    symbols.push(symbol);
+                }
+            }
+            continue;
+        }
+        const symbol = createDocumentSymbol(preparedProject, sourceFile, statement);
+        if (symbol) {
+            symbols.push(symbol);
+        }
+    }
+    return symbols;
+}
+function toCompletionItemKind(symbol) {
+    if ((symbol.flags & ts.SymbolFlags.Function) !== 0 || (symbol.flags & ts.SymbolFlags.Method) !== 0) {
+        return 3;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Class) !== 0) {
+        return 7;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Interface) !== 0) {
+        return 8;
+    }
+    if ((symbol.flags & ts.SymbolFlags.TypeAlias) !== 0) {
+        return 25;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Enum) !== 0) {
+        return 13;
+    }
+    if ((symbol.flags & ts.SymbolFlags.EnumMember) !== 0) {
+        return 21;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Module) !== 0 || (symbol.flags & ts.SymbolFlags.Namespace) !== 0) {
+        return 9;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Property) !== 0) {
+        return 10;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Variable) !== 0 ||
+        (symbol.flags & ts.SymbolFlags.BlockScopedVariable) !== 0) {
+        return 6;
+    }
+    if ((symbol.flags & ts.SymbolFlags.TypeParameter) !== 0) {
+        return 25;
+    }
+    return undefined;
+}
+function createCompletionItemsForSymbols(checker, symbols, location, prefix) {
+    const uniqueItems = new Map();
+    for (const symbol of symbols) {
+        if (!isUserFacingSymbolName(symbol.name)) {
+            continue;
+        }
+        if (prefix.length > 0 && !symbol.name.startsWith(prefix)) {
+            continue;
+        }
+        const completionItem = {
+            label: symbol.name,
+            kind: toCompletionItemKind(symbol),
+        };
+        try {
+            const type = checker.getTypeOfSymbolAtLocation(symbol, location);
+            const detail = checker.typeToString(type);
+            if (detail.length > 0 && detail !== 'any') {
+                completionItem.detail = detail;
+            }
+        }
+        catch {
+            // Best-effort detail only.
+        }
+        uniqueItems.set(symbol.name, completionItem);
+    }
+    return [...uniqueItems.values()].sort((left, right) => left.label.localeCompare(right.label));
+}
+function findPropertyAccessCompletionTarget(node) {
+    let current = node;
+    while (current) {
+        if (ts.isPropertyAccessExpression(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function completionItemsForNode(checker, node, originalText, sourcePosition) {
+    const propertyAccess = findPropertyAccessCompletionTarget(node);
+    if (propertyAccess) {
+        const memberPrefix = getIdentifierPrefixAtPosition(originalText, sourcePosition);
+        const apparentType = checker.getApparentType(checker.getTypeAtLocation(propertyAccess.expression));
+        return createCompletionItemsForSymbols(checker, checker.getPropertiesOfType(apparentType), propertyAccess.expression, memberPrefix);
+    }
+    const scopePrefix = getIdentifierPrefixAtPosition(originalText, sourcePosition);
+    const scopeFlags = ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace |
+        ts.SymbolFlags.Alias;
+    return createCompletionItemsForSymbols(checker, checker.getSymbolsInScope(node, scopeFlags), node, scopePrefix);
+}
+function findResolvedMacroContainingPosition(filePath, sourcePosition, collected) {
+    return collected.find((entry) => entry.resolved.placeholder.fileName === filePath &&
+        containsPosition(entry.resolved.placeholder.invocation.span.start, entry.resolved.placeholder.invocation.span.end, sourcePosition));
+}
+function resolveImportedMacroDefinition(preparedProject, filePath, match) {
+    return getImportedMacroDefinitionsForFile(preparedProject, filePath).get(match.resolved.placeholder.invocation.nameText) ?? null;
+}
+function resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, sourcePosition, useCompletion = false) {
+    const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+    if (!artifacts?.node) {
+        return null;
+    }
+    const region = analysisRegionForMacroDefinition(artifacts.definition, {
+        macro: artifacts.context,
+        node: artifacts.node,
+        offset: sourcePosition - artifacts.node.span.start,
+    });
+    if (!region) {
+        return null;
+    }
+    const effectiveSourcePosition = useCompletion && sourcePosition === region.sourceSpan.end
+        ? Math.max(region.sourceSpan.start, sourcePosition - 1)
+        : sourcePosition;
+    const originalText = match.resolved.placeholder.preparedFile.originalText;
+    const materialized = materializeRegionForHover(match.resolved.placeholder.invocation.fileName, originalText, region.sourceSpan, effectiveSourcePosition);
+    if ('kind' in materialized) {
+        return materialized;
+    }
+    const materializedRegion = materialized;
+    const completionMaterialized = useCompletion && sourcePosition === region.sourceSpan.end
+        ? { ...materializedRegion, hoverPosition: materializedRegion.text.length }
+        : materializedRegion;
+    const wrappedRegion = wrapMaterializedRegion(completionMaterialized, region.prefixText, region.suffixText);
+    return useCompletion
+        ? resolveCompletionNodeAtMaterializedRegion(preparedProject.preparedProgram, match.resolved, wrappedRegion)
+        : resolveNodeAtMaterializedRegion(preparedProject.preparedProgram, match.resolved, wrappedRegion);
+}
+function parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match) {
+    const definition = resolveImportedMacroDefinition(preparedProject, filePath, match);
+    if (!definition) {
+        return null;
+    }
+    try {
+        const context = createAdvancedMacroContext(preparedProject.preparedProgram, match.resolved);
+        return {
+            context,
+            definition,
+            fragments: fragmentsForMacroDefinition(definition, context),
+            node: parseMacroSyntaxNodeForDefinition(definition, context),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function findMacroFragmentAtPosition(fragments, sourcePosition) {
+    return fragments.find((fragment) => containsPosition(fragment.span.start, fragment.span.end, sourcePosition)) ?? null;
+}
+function hoverHookForMacroInvocation(preparedProject, filePath, match, sourcePosition, originalText) {
+    const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+    if (!artifacts) {
+        return null;
+    }
+    const fragment = findMacroFragmentAtPosition(artifacts.fragments, sourcePosition);
+    if (fragment?.hover) {
+        const hover = fragment.hover(sourcePosition);
+        if (hover) {
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: hover.contents,
+                },
+                range: createTokenHoverRange(sourcePosition, originalText),
+            };
+        }
+    }
+    if (artifacts.definition.positionHover && artifacts.node) {
+        if (!containsPosition(artifacts.node.span.start, artifacts.node.span.end, sourcePosition)) {
+            return null;
+        }
+        const hover = artifacts.definition.positionHover({
+            macro: artifacts.context,
+            node: artifacts.node,
+            offset: sourcePosition - artifacts.node.span.start,
+        });
+        if (hover) {
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: hover.contents,
+                },
+                range: createTokenHoverRange(sourcePosition, originalText),
+            };
+        }
+    }
+    return null;
+}
+function summaryHoverForMacroInvocation(preparedProject, filePath, match, sourcePosition, originalText) {
+    const definition = resolveImportedMacroDefinition(preparedProject, filePath, match);
+    if (!definition) {
+        return null;
+    }
+    const invocation = match.resolved.placeholder.invocation;
+    if (!containsPosition(invocation.nameSpan.start, invocation.nameSpan.end, sourcePosition)) {
+        return null;
+    }
+    const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+    if (artifacts?.definition.hover && artifacts.node) {
+        if (!containsPosition(artifacts.node.span.start, artifacts.node.span.end, sourcePosition)) {
+            return null;
+        }
+        const hover = artifacts.definition.hover({
+            node: artifacts.node,
+            offset: sourcePosition - artifacts.node.span.start,
+        });
+        if (hover) {
+            const details = signatureHoverDetails(definition, invocation.nameText);
+            return createCustomMacroSummaryHover(invocation, originalText, hover.contents, details);
+        }
+    }
+    const details = signatureHoverDetails(definition, invocation.nameText);
+    if (details.length === 0) {
+        return null;
+    }
+    return createMacroSummaryHover(invocation, originalText, details);
+}
+function importedMacroSummaryHoverForNode(preparedProject, filePath, node, originalText, sourcePosition) {
+    if (!ts.isIdentifier(node)) {
+        return null;
+    }
+    let localMacroName = null;
+    if (ts.isImportSpecifier(node.parent)) {
+        if (node.parent.name === node || node.parent.propertyName === node) {
+            localMacroName = node.parent.name.text;
+        }
+    }
+    if (!localMacroName) {
+        return null;
+    }
+    const definition = getImportedMacroDefinitionsForFile(preparedProject, filePath).get(localMacroName) ?? null;
+    if (!definition) {
+        return null;
+    }
+    const details = signatureHoverDetails(definition, localMacroName);
+    const customBody = genericHoverBodyForImportedMacro(definition, localMacroName);
+    return {
+        contents: customBody
+            ? createCustomMacroSummaryContents(localMacroName, customBody, details)
+            : createMarkdownTextHoverContents(`**macro** \`${localMacroName}\``, details),
+        range: createTokenHoverRange(sourcePosition, originalText),
+    };
+}
+function scanQuotedAnnotationString(text, start) {
+    const quote = text[start];
+    let index = start + 1;
+    while (index < text.length) {
+        const character = text[index];
+        if (character === '\\') {
+            index += 2;
+            continue;
+        }
+        if (character === quote) {
+            return index + 1;
+        }
+        index += 1;
+    }
+    return text.length;
+}
+const BUILTIN_ANNOTATION_HOVER_DETAILS = {
+    extern: {
+        summary: 'Marks a local ambient runtime declaration as an explicit extern boundary.',
+        syntax: '// #[extern]',
+        details: [
+            'Use `#[extern]` only for same-file runtime-provided declarations such as host globals or compiler-injected helpers.',
+            'This attaches to local ambient declarations, not to ordinary imports.',
+        ],
+    },
+    interop: {
+        summary: 'Marks an import-like boundary where unsound foreign values enter soundscript.',
+        syntax: '// #[interop]',
+        details: [
+            'Use `#[interop]` on imports, `require(...)`, or dynamic `import(...)` boundaries that intentionally cross from `.ts`, JavaScript, or declaration-only code into `.sts`.',
+            'Validate the imported value at the boundary before relying on stronger types inside soundscript.',
+        ],
+    },
+    unsafe: {
+        summary: 'Marks a local proof-override site inside soundscript.',
+        syntax: '// #[unsafe]',
+        details: [
+            'Use `#[unsafe]` only when you are intentionally overriding a local proof obligation.',
+            'This is a local escape hatch, not a foreign-boundary marker.',
+        ],
+    },
+    variance: {
+        summary: 'Declares a checked variance contract on a generic interface or type alias.',
+        syntax: '// #[variance(T: out, U: in)]',
+        details: [
+            'Use named arguments such as `T: out`, `U: in`, `R: inout`, or `X: independent`, once per declared type parameter.',
+            'The contract is checked, not trusted: soundscript verifies that the declaration surface actually proves the stated variance.',
+        ],
+    },
+};
+function parseAnnotationHoverItem(rawItemText, absoluteStart, absoluteEnd) {
+    const trimmedText = rawItemText.trim();
+    if (trimmedText.length === 0) {
+        return null;
+    }
+    const leadingWhitespaceLength = rawItemText.length - rawItemText.trimStart().length;
+    const itemStart = absoluteStart + leadingWhitespaceLength;
+    const itemEnd = absoluteEnd - (rawItemText.length - rawItemText.trimEnd().length);
+    const openParenIndex = trimmedText.indexOf('(');
+    if (openParenIndex === -1) {
+        return {
+            end: itemEnd,
+            name: trimmedText,
+            nameEnd: itemStart + trimmedText.length,
+            nameStart: itemStart,
+            start: itemStart,
+            text: trimmedText,
+        };
+    }
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let closeParenIndex = -1;
+    for (let index = openParenIndex; index < trimmedText.length; index += 1) {
+        const character = trimmedText[index];
+        if (character === '"' || character === "'") {
+            index = scanQuotedAnnotationString(trimmedText, index) - 1;
+            continue;
+        }
+        if (character === '(') {
+            parenDepth += 1;
+            continue;
+        }
+        if (character === ')') {
+            parenDepth -= 1;
+            if (parenDepth === 0) {
+                closeParenIndex = index;
+                break;
+            }
+            continue;
+        }
+        if (character === '[') {
+            bracketDepth += 1;
+            continue;
+        }
+        if (character === ']') {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (character === '{') {
+            braceDepth += 1;
+            continue;
+        }
+        if (character === '}') {
+            braceDepth = Math.max(0, braceDepth - 1);
+            continue;
+        }
+    }
+    const name = trimmedText.slice(0, openParenIndex).trim();
+    const rawNamePrefix = rawItemText.slice(0, rawItemText.indexOf(name));
+    const nameStart = absoluteStart + rawNamePrefix.length;
+    return {
+        argumentsText: closeParenIndex === -1
+            ? undefined
+            : trimmedText.slice(openParenIndex + 1, closeParenIndex),
+        end: itemEnd,
+        name,
+        nameEnd: nameStart + name.length,
+        nameStart,
+        start: itemStart,
+        text: trimmedText,
+    };
+}
+function findAnnotationHoverItemAtPosition(originalText, sourcePosition) {
+    const lineStart = originalText.lastIndexOf('\n', Math.max(0, sourcePosition - 1)) + 1;
+    const newlineIndex = originalText.indexOf('\n', sourcePosition);
+    const lineEnd = newlineIndex === -1 ? originalText.length : newlineIndex;
+    const lineText = originalText.slice(lineStart, lineEnd);
+    const openMatch = /\/\/\s*#\[/u.exec(lineText);
+    if (!openMatch) {
+        return null;
+    }
+    const bodyStart = lineStart + openMatch.index + openMatch[0].length;
+    let closingBracketIndex = -1;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    for (let index = bodyStart; index < lineEnd; index += 1) {
+        const character = originalText[index];
+        if (character === '"' || character === "'") {
+            index = scanQuotedAnnotationString(originalText, index) - 1;
+            continue;
+        }
+        if (character === '(') {
+            parenDepth += 1;
+            continue;
+        }
+        if (character === ')') {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (character === '[') {
+            bracketDepth += 1;
+            continue;
+        }
+        if (character === ']') {
+            if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+                closingBracketIndex = index;
+                break;
+            }
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (character === '{') {
+            braceDepth += 1;
+            continue;
+        }
+        if (character === '}') {
+            braceDepth = Math.max(0, braceDepth - 1);
+            continue;
+        }
+    }
+    if (closingBracketIndex === -1 || sourcePosition < bodyStart || sourcePosition > closingBracketIndex) {
+        return null;
+    }
+    let itemStart = bodyStart;
+    parenDepth = 0;
+    bracketDepth = 0;
+    braceDepth = 0;
+    for (let index = bodyStart; index <= closingBracketIndex; index += 1) {
+        const character = index === closingBracketIndex ? ',' : originalText[index];
+        if (index < closingBracketIndex && (character === '"' || character === "'")) {
+            index = scanQuotedAnnotationString(originalText, index) - 1;
+            continue;
+        }
+        if (index < closingBracketIndex && character === '(') {
+            parenDepth += 1;
+            continue;
+        }
+        if (index < closingBracketIndex && character === ')') {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (index < closingBracketIndex && character === '[') {
+            bracketDepth += 1;
+            continue;
+        }
+        if (index < closingBracketIndex && character === ']') {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (index < closingBracketIndex && character === '{') {
+            braceDepth += 1;
+            continue;
+        }
+        if (index < closingBracketIndex && character === '}') {
+            braceDepth = Math.max(0, braceDepth - 1);
+            continue;
+        }
+        if (character === ',' && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+            if (sourcePosition >= itemStart && sourcePosition <= index) {
+                return parseAnnotationHoverItem(originalText.slice(itemStart, index), itemStart, index);
+            }
+            itemStart = index + 1;
+        }
+    }
+    return null;
+}
+function builtinAnnotationHoverContents(annotationName) {
+    const details = BUILTIN_ANNOTATION_HOVER_DETAILS[annotationName];
+    if (!details) {
+        return null;
+    }
+    return createMarkdownTextHoverContents(`**annotation** \`${annotationName}\``, [
+        createMarkdownCodeBlock(details.syntax),
+        details.summary,
+        ...details.details,
+    ]);
+}
+function annotationHover(preparedProject, filePath, sourcePosition, originalText) {
+    const annotation = findAnnotationHoverItemAtPosition(originalText, sourcePosition);
+    if (!annotation || annotation.name.length === 0) {
+        return null;
+    }
+    const importedMacroDefinition = getImportedMacroDefinitionsForFile(preparedProject, filePath).get(annotation.name);
+    if (importedMacroDefinition) {
+        const details = signatureHoverDetails(importedMacroDefinition, annotation.name);
+        const customBody = genericHoverBodyForImportedMacro(importedMacroDefinition, annotation.name);
+        return {
+            contents: customBody
+                ? createCustomMacroSummaryContents(annotation.name, customBody, details)
+                : createMarkdownTextHoverContents(`**macro** \`${annotation.name}\``, details),
+            range: createHoverRange(annotation.nameStart, annotation.nameEnd, originalText),
+        };
+    }
+    const builtinContents = builtinAnnotationHoverContents(annotation.name);
+    if (builtinContents) {
+        return {
+            contents: builtinContents,
+            range: createHoverRange(annotation.nameStart, annotation.nameEnd, originalText),
+        };
+    }
+    const syntax = annotation.argumentsText === undefined
+        ? `// #[${annotation.name}]`
+        : `// #[${annotation.name}(${annotation.argumentsText})]`;
+    return {
+        contents: createMarkdownTextHoverContents(`**annotation** \`${annotation.name}\``, [
+            createMarkdownCodeBlock(syntax),
+            'soundscript parsed this as an annotation comment.',
+        ]),
+        range: createHoverRange(annotation.nameStart, annotation.nameEnd, originalText),
+    };
+}
+function genericHoverBodyForImportedMacro(definition, macroName) {
+    if (!definition.hover) {
+        return null;
+    }
+    try {
+        const syntheticText = buildSyntheticMacroHoverInvocationText(definition.signature, macroName);
+        const parsed = parseMacroInvocationAt('<macro-hover>.sts', syntheticText, 0);
+        if (!('reason' in parsed)) {
+            const syntheticContext = createSyntaxOnlyMacroContext(parsed, syntheticText);
+            const syntheticNode = parseMacroSyntaxNodeForDefinition(definition, syntheticContext) ??
+                syntheticContext.parsedSyntax();
+            if (syntheticNode) {
+                const parsedHover = definition.hover({ node: syntheticNode, offset: 0 })?.contents ?? null;
+                if (parsedHover) {
+                    return parsedHover;
+                }
+            }
+        }
+    }
+    catch {
+        // Fall through to the shallow invocation fallback below.
+    }
+    const syntheticNode = {
+        args: [],
+        block: null,
+        declaration: null,
+        form: 'arglist',
+        hasBlock: false,
+        kind: 'invocation',
+        name: macroName,
+        span: { fileName: '<macro-hover>', start: 0, end: macroName.length },
+        text() {
+            return macroName;
+        },
+    };
+    try {
+        return definition.hover({ node: syntheticNode, offset: 0 })?.contents ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildSyntheticMacroHoverInvocationText(signature, macroName) {
+    if (!signature || signature.cases.length === 0) {
+        return `#${macroName}`;
+    }
+    const [signatureCase] = signature.cases;
+    const exprArgs = signatureCase.operands
+        .filter((operand) => operand.kind === 'expr')
+        .map((operand, index) => syntheticExprOperandText(operand, index));
+    const templateArg = signatureCase.operands.find((operand) => operand.kind === 'template');
+    const blockArg = signatureCase.operands.find((operand) => operand.kind === 'block');
+    const declArg = signatureCase.operands.find((operand) => operand.kind === 'decl');
+    let text = `#${macroName}`;
+    if (templateArg) {
+        text += ` ${syntheticTemplateOperandText()}`;
+    }
+    else if (exprArgs.length === 1) {
+        text += `(${exprArgs[0]})`;
+    }
+    else if (exprArgs.length > 1) {
+        text += `(${exprArgs.join(', ')})`;
+    }
+    if (blockArg) {
+        text += ' { }';
+    }
+    if (declArg) {
+        text += exprArgs.length === 0 && !templateArg && !blockArg
+            ? ' function macroHoverProbe() {}'
+            : ' class MacroHoverProbe {}';
+    }
+    return text;
+}
+function syntheticExprOperandText(operand, index) {
+    switch (operand.refinement?.kind) {
+        case 'array_literal':
+            return '[]';
+        case 'call':
+            return 'probe()';
+        case 'function':
+            return '() => value';
+        case 'identifier':
+            return 'value';
+        default:
+            return index === 0 ? 'value' : `value${index + 1}`;
+    }
+}
+function syntheticTemplateOperandText() {
+    return '`value`';
+}
+function completionHookForMacroInvocation(preparedProject, filePath, match, sourcePosition) {
+    const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+    if (!artifacts) {
+        return null;
+    }
+    const fragment = findMacroFragmentAtPosition(artifacts.fragments, sourcePosition);
+    if (fragment?.completions) {
+        const completions = fragment.completions(sourcePosition);
+        return completions.length > 0 ? [...completions] : null;
+    }
+    if (!artifacts.definition.completions || !artifacts.node) {
+        return null;
+    }
+    if (!containsPosition(artifacts.node.span.start, artifacts.node.span.end, sourcePosition)) {
+        return null;
+    }
+    const completions = artifacts.definition.completions({
+        node: artifacts.node,
+        offset: sourcePosition - artifacts.node.span.start,
+    });
+    return completions.length > 0 ? [...completions] : null;
+}
+function bindingOccurrencesForMacroInvocation(preparedProject, filePath, match) {
+    const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+    if (!artifacts) {
+        return null;
+    }
+    const bindings = [
+        ...artifacts.fragments.flatMap((fragment) => fragment.bindings ?? []),
+    ];
+    if (artifacts.definition.bindings && artifacts.node) {
+        bindings.push(...artifacts.definition.bindings({ node: artifacts.node }));
+    }
+    return bindings.length > 0 ? bindings : null;
+}
+function findMacroBindingOccurrence(preparedProject, filePath, sourcePosition) {
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const match = findResolvedMacroContainingPosition(filePath, sourcePosition, collected);
+    if (!match) {
+        return null;
+    }
+    const occurrences = bindingOccurrencesForMacroInvocation(preparedProject, filePath, match);
+    if (!occurrences) {
+        return null;
+    }
+    const occurrence = occurrences.find((entry) => containsPosition(entry.span.start, entry.span.end, sourcePosition));
+    if (!occurrence) {
+        return null;
+    }
+    return { match, occurrence, occurrences };
+}
+function createSourceSpanLocation(filePath, originalText, span) {
+    return {
+        uri: toFileUrl(filePath).href,
+        range: createRangeFromOffsets(span.start, span.end, originalText),
+    };
+}
+function hoverMacroInvocation(preparedProject, filePath, sourcePosition, originalText) {
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const match = findResolvedMacroContainingPosition(filePath, sourcePosition, collected);
+    if (!match) {
+        return null;
+    }
+    const invocation = match.resolved.placeholder.invocation;
+    const hookHover = hoverHookForMacroInvocation(preparedProject, filePath, match, sourcePosition, originalText);
+    if (hookHover) {
+        return hookHover;
+    }
+    if (!isIdentifierPart(originalText[sourcePosition])) {
+        return null;
+    }
+    const hookAnalysisNode = resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, sourcePosition);
+    if (hookAnalysisNode) {
+        if ('kind' in hookAnalysisNode) {
+            return createMacroSummaryHover(hookAnalysisNode.invocation, originalText);
+        }
+        const value = formatSymbolHoverCode(hookAnalysisNode.checker, hookAnalysisNode.node) ??
+            hookAnalysisNode.semantics.typeOfNode(hookAnalysisNode.node).displayText;
+        return {
+            contents: createMarkdownHoverContents(value),
+            range: createTokenHoverRange(sourcePosition, originalText),
+        };
+    }
+    const expressionNode = resolveExpressionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (expressionNode) {
+        if ('kind' in expressionNode) {
+            return createMacroSummaryHover(expressionNode.invocation, originalText);
+        }
+        const value = formatSymbolHoverCode(expressionNode.checker, expressionNode.node) ??
+            expressionNode.semantics.typeOfNode(expressionNode.node).displayText;
+        return {
+            contents: createMarkdownHoverContents(value),
+            range: createTokenHoverRange(sourcePosition, originalText),
+        };
+    }
+    const blockNode = resolveBlockNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (blockNode) {
+        if ('kind' in blockNode) {
+            return createMacroSummaryHover(blockNode.invocation, originalText);
+        }
+        const value = formatSymbolHoverCode(blockNode.checker, blockNode.node) ??
+            blockNode.semantics.typeOfNode(blockNode.node).displayText;
+        return {
+            contents: createMarkdownHoverContents(value),
+            range: createTokenHoverRange(sourcePosition, originalText),
+        };
+    }
+    const summaryHover = summaryHoverForMacroInvocation(preparedProject, filePath, match, sourcePosition, originalText);
+    if (summaryHover) {
+        return summaryHover;
+    }
+    return createMacroSummaryHover(invocation, originalText);
+}
+function isSuppressedFallbackHoverNode(node) {
+    if (ts.isIdentifier(node) ||
+        ts.isPrivateIdentifier(node) ||
+        ts.isStringLiteralLike(node) ||
+        ts.isNumericLiteral(node) ||
+        ts.isNoSubstitutionTemplateLiteral(node) ||
+        node.kind === ts.SyntaxKind.ThisKeyword ||
+        node.kind === ts.SyntaxKind.SuperKeyword ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        return false;
+    }
+    if (ts.tokenToString(node.kind) !== undefined) {
+        return true;
+    }
+    return ts.isReturnStatement(node);
+}
+function importDeclarationForNode(node) {
+    let current = node;
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isImportDeclaration(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function importBindingHoverKindForDeclaration(declaration) {
+    if (ts.isImportSpecifier(declaration)) {
+        const importClause = declaration.parent.parent;
+        return declaration.isTypeOnly || (ts.isImportClause(importClause) && importClause.isTypeOnly)
+            ? 'type'
+            : 'value';
+    }
+    if (ts.isNamespaceImport(declaration)) {
+        const importClause = declaration.parent.parent;
+        return ts.isImportClause(importClause) && importClause.isTypeOnly ? 'type' : 'value';
+    }
+    if (ts.isImportClause(declaration)) {
+        return declaration.isTypeOnly ? 'type' : 'value';
+    }
+    return null;
+}
+function lookupFilePathForSingleFileProgram(filePath) {
+    return filePath.endsWith('.sts') ? `${filePath}.ts` : filePath;
+}
+function createSingleFileLookupProgram(filePath, originalText) {
+    const lookupFilePath = lookupFilePathForSingleFileProgram(filePath);
+    const options = {
+        allowJs: true,
+        module: ts.ModuleKind.ESNext,
+        noLib: true,
+        noResolve: true,
+        target: ts.ScriptTarget.Latest,
+    };
+    const host = ts.createCompilerHost(options, true);
+    host.getSourceFile = (candidatePath, languageVersion) => {
+        if (candidatePath !== lookupFilePath) {
+            return undefined;
+        }
+        return ts.createSourceFile(candidatePath, originalText, languageVersion, true, ts.ScriptKind.TS);
+    };
+    host.fileExists = (candidatePath) => candidatePath === lookupFilePath;
+    host.readFile = (candidatePath) => candidatePath === lookupFilePath ? originalText : undefined;
+    host.writeFile = () => { };
+    return {
+        lookupFilePath,
+        program: ts.createProgram([lookupFilePath], options, host),
+    };
+}
+function createResolvedSingleFileLookupProgram(filePath, originalText, compilerOptions) {
+    const lookupFilePath = lookupFilePathForSingleFileProgram(filePath);
+    const options = {
+        ...compilerOptions,
+        allowJs: true,
+        noEmit: true,
+    };
+    const host = ts.createCompilerHost(options, true);
+    const baseGetSourceFile = host.getSourceFile.bind(host);
+    const baseFileExists = host.fileExists.bind(host);
+    const baseReadFile = host.readFile.bind(host);
+    host.getSourceFile = (candidatePath, languageVersion, onError, shouldCreateNewSourceFile) => {
+        if (candidatePath === lookupFilePath) {
+            return ts.createSourceFile(candidatePath, originalText, languageVersion, true, ts.ScriptKind.TS);
+        }
+        return baseGetSourceFile(candidatePath, languageVersion, onError, shouldCreateNewSourceFile);
+    };
+    host.fileExists = (candidatePath) => candidatePath === lookupFilePath || baseFileExists(candidatePath);
+    host.readFile = (candidatePath) => candidatePath === lookupFilePath ? originalText : baseReadFile(candidatePath);
+    host.writeFile = () => { };
+    return {
+        lookupFilePath,
+        program: ts.createProgram([lookupFilePath], options, host),
+    };
+}
+function resolvedTypeImportHoverCode(filePath, originalText, sourcePosition, compilerOptions) {
+    const { program, lookupFilePath } = createResolvedSingleFileLookupProgram(filePath, originalText, compilerOptions);
+    const sourceFile = program.getSourceFile(lookupFilePath);
+    if (!sourceFile) {
+        return null;
+    }
+    const node = findDeepestNodeContainingPosition(sourceFile, sourcePosition);
+    if (!node || !ts.isIdentifier(node)) {
+        return null;
+    }
+    const checker = program.getTypeChecker();
+    const symbol = resolveSymbolAtNode(checker, node);
+    if (!symbol) {
+        return null;
+    }
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!declaration) {
+        return null;
+    }
+    return formatSymbolHoverCode(checker, getDefinitionTargetNode(declaration)) ??
+        formatSymbolHoverCode(checker, node) ??
+        null;
+}
+function importBindingDeclarationForSymbol(symbol) {
+    const declarations = symbol.declarations ??
+        (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
+    return declarations.find((declaration) => ts.isImportSpecifier(declaration) ||
+        ts.isNamespaceImport(declaration) ||
+        ts.isImportClause(declaration)) ?? null;
+}
+function projectedForeignImportHover(preparedProject, filePath, sourcePosition, originalText) {
+    const { program, lookupFilePath } = createSingleFileLookupProgram(filePath, originalText);
+    const sourceFile = program.getSourceFile(lookupFilePath);
+    if (!sourceFile) {
+        return null;
+    }
+    const node = findDeepestNodeContainingPosition(sourceFile, sourcePosition);
+    if (!node || !ts.isIdentifier(node)) {
+        return null;
+    }
+    const symbol = program.getTypeChecker().getSymbolAtLocation(node);
+    if (!symbol) {
+        return null;
+    }
+    const bindingDeclaration = importBindingDeclarationForSymbol(symbol);
+    if (!bindingDeclaration) {
+        return null;
+    }
+    const hoverKind = importBindingHoverKindForDeclaration(bindingDeclaration);
+    if (!hoverKind) {
+        return null;
+    }
+    const importDeclaration = importDeclarationForNode(bindingDeclaration);
+    if (!importDeclaration || !ts.isStringLiteral(importDeclaration.moduleSpecifier)) {
+        return null;
+    }
+    if (!isUnsoundImportedModuleForTypeProjection(importDeclaration.moduleSpecifier.text, filePath, preparedProject.preparedProgram.options, ts.sys)) {
+        return null;
+    }
+    if (hoverKind === 'value' &&
+        ts.isImportSpecifier(bindingDeclaration) &&
+        !collectProjectedUnknownValueExportNames(importDeclaration.moduleSpecifier.text, filePath, preparedProject.preparedProgram.options, ts.sys).has((bindingDeclaration.propertyName ?? bindingDeclaration.name).text)) {
+        return null;
+    }
+    const hoverCode = hoverKind === 'type'
+        ? resolvedTypeImportHoverCode(filePath, originalText, sourcePosition, preparedProject.preparedProgram.options)
+        : `const ${node.text}: unknown`;
+    if (!hoverCode) {
+        return null;
+    }
+    return {
+        contents: createMarkdownHoverContents(hoverCode),
+        range: createHoverRange(node.getStart(sourceFile), node.getEnd(), originalText),
+    };
+}
+function resolveSymbolAtNode(checker, node) {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return undefined;
+    }
+    if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+        const aliasedSymbol = checker.getAliasedSymbol(symbol);
+        if (aliasedSymbol) {
+            return aliasedSymbol;
+        }
+    }
+    return symbol;
+}
+function analysisContainerName(node) {
+    if (ts.isClassDeclaration(node) ||
+        ts.isClassExpression(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isMethodSignature(node) ||
+        ts.isModuleDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node)) {
+        return node.name && ts.isIdentifier(node.name) ? node.name.text : null;
+    }
+    return null;
+}
+function namedContainerPath(node) {
+    const path = [];
+    let current = node.parent;
+    while (current && !ts.isSourceFile(current)) {
+        const name = analysisContainerName(current);
+        if (name) {
+            path.push({
+                kind: current.kind,
+                name,
+            });
+        }
+        current = current.parent;
+    }
+    return path.reverse();
+}
+function findNamedDescendantContainer(root, target) {
+    let match = null;
+    function visit(node) {
+        if (match) {
+            return;
+        }
+        if (node.kind === target.kind && analysisContainerName(node) === target.name) {
+            match = node;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(root, visit);
+    return match;
+}
+function resolveAnalysisContainerForSourceNode(sourceNode, analysisSourceFile) {
+    let container = analysisSourceFile;
+    for (const target of namedContainerPath(sourceNode)) {
+        const next = findNamedDescendantContainer(container, target);
+        if (!next) {
+            break;
+        }
+        container = next;
+    }
+    return container;
+}
+function isDeclarationNameNode(node) {
+    const parent = node.parent;
+    return parent?.name === node;
+}
+function countNamedNodeOccurrence(container, target) {
+    if ((!ts.isIdentifier(target) && !ts.isPrivateIdentifier(target)) || !('text' in target)) {
+        return null;
+    }
+    let occurrence = 0;
+    let found = null;
+    const targetText = target.text;
+    const visit = (node) => {
+        if (found !== null) {
+            return;
+        }
+        if ((ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) &&
+            'text' in node &&
+            node.text === targetText) {
+            if (node === target) {
+                found = occurrence;
+                return;
+            }
+            occurrence += 1;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(container);
+    return found;
+}
+function findNamedNodeOccurrence(container, kind, name, occurrenceIndex) {
+    let occurrence = 0;
+    let found = null;
+    const visit = (node) => {
+        if (found !== null) {
+            return;
+        }
+        if (node.kind === kind &&
+            (ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) &&
+            'text' in node &&
+            node.text === name) {
+            if (occurrence === occurrenceIndex) {
+                found = node;
+                return;
+            }
+            occurrence += 1;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(container);
+    return found;
+}
+function symbolDeclaredWithinContainer(symbol, container) {
+    const declarations = symbol.declarations ??
+        (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
+    return declarations.some((declaration) => {
+        let current = declaration;
+        while (current) {
+            if (current === container) {
+                return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    });
+}
+function getAnalysisBackedHoverDetails(preparedProject, filePath, sourceNode) {
+    if (!ts.isIdentifier(sourceNode) && !ts.isPrivateIdentifier(sourceNode)) {
+        return null;
+    }
+    const analysisSourceFile = preparedProject.program.getSourceFile(preparedProject.analysisPreparedProgram.toProgramFileName(filePath));
+    if (!analysisSourceFile) {
+        return null;
+    }
+    const analysisChecker = preparedProject.analysisContext.checker;
+    const sourceContainer = resolveAnalysisContainerForSourceNode(sourceNode, sourceNode.getSourceFile());
+    const analysisContainer = resolveAnalysisContainerForSourceNode(sourceNode, analysisSourceFile);
+    const occurrenceIndex = countNamedNodeOccurrence(sourceContainer, sourceNode);
+    const analysisNode = occurrenceIndex === null || !('text' in sourceNode)
+        ? null
+        : findNamedNodeOccurrence(analysisContainer, sourceNode.kind, sourceNode.text, occurrenceIndex);
+    if (analysisNode &&
+        !ts.isSourceFile(analysisNode) &&
+        (ts.isIdentifier(analysisNode) || ts.isPrivateIdentifier(analysisNode)) &&
+        analysisNode.getText(analysisSourceFile) === sourceNode.getText(sourceNode.getSourceFile())) {
+        const typeText = analysisChecker.typeToString(analysisChecker.getTypeAtLocation(analysisNode), analysisNode, ts.TypeFormatFlags.NoTruncation);
+        return {
+            code: formatSymbolHoverCode(analysisChecker, analysisNode) ?? typeText,
+            typeText,
+        };
+    }
+    const container = resolveAnalysisContainerForSourceNode(sourceNode, analysisSourceFile);
+    const scopeFlags = ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace |
+        ts.SymbolFlags.Alias;
+    const candidates = analysisChecker.getSymbolsInScope(container, scopeFlags).filter((candidate) => candidate.name === sourceNode.text);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const symbol = candidates.find((candidate) => symbolDeclaredWithinContainer(candidate, container)) ??
+        candidates[0];
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!declaration) {
+        return null;
+    }
+    const definitionTarget = getDefinitionTargetNode(declaration);
+    const typeText = analysisChecker.typeToString(analysisChecker.getTypeAtLocation(definitionTarget), definitionTarget, ts.TypeFormatFlags.NoTruncation);
+    return {
+        code: formatSymbolHoverCode(analysisChecker, definitionTarget) ?? typeText,
+        typeText,
+    };
+}
+function getSourceFileModuleSymbol(checker, sourceFile) {
+    return checker.getSymbolAtLocation(sourceFile) ??
+        sourceFile.symbol;
+}
+function canonicalSoundscriptSourceFileName(preparedProject, fileName) {
+    const sourceFileName = toProjectedDeclarationSourceFileName(preparedProject.preparedProgram.toSourceFileName(fileName));
+    return isSoundscriptSourceFile(sourceFileName) ? sourceFileName : null;
+}
+function collectCrossViewDeclarations(preparedProject, symbol, relatedViews) {
+    const declarations = symbol.declarations ??
+        (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
+    if (declarations.length === 0) {
+        return [];
+    }
+    const symbolName = symbol.getName();
+    if (symbolName.length === 0) {
+        return [];
+    }
+    const matches = [];
+    const seen = new Set();
+    for (const declaration of declarations) {
+        const soundscriptSourceFileName = canonicalSoundscriptSourceFileName(preparedProject, declaration.getSourceFile().fileName);
+        if (!soundscriptSourceFileName) {
+            continue;
+        }
+        for (const view of relatedViews) {
+            const candidateFileNames = [
+                view.preparedProgram.toProgramFileName(soundscriptSourceFileName),
+                view.preparedProgram.toProjectedDeclarationFileName(soundscriptSourceFileName),
+            ];
+            for (const candidateFileName of candidateFileNames) {
+                const relatedSourceFile = view.program.getSourceFile(candidateFileName);
+                if (!relatedSourceFile) {
+                    continue;
+                }
+                const moduleSymbol = getSourceFileModuleSymbol(view.analysisContext.checker, relatedSourceFile);
+                if (!moduleSymbol) {
+                    continue;
+                }
+                const exportedSymbol = view.analysisContext.checker.getExportsOfModule(moduleSymbol).find((candidate) => candidate.getName() === symbolName);
+                if (!exportedSymbol) {
+                    continue;
+                }
+                const exportedDeclarations = exportedSymbol.declarations ??
+                    (exportedSymbol.valueDeclaration ? [exportedSymbol.valueDeclaration] : []);
+                for (const exportedDeclaration of exportedDeclarations) {
+                    if (exportedDeclaration.getSourceFile() !== relatedSourceFile) {
+                        continue;
+                    }
+                    const key = `${relatedSourceFile.fileName}:${exportedDeclaration.getStart(relatedSourceFile)}:${exportedDeclaration.getEnd()}`;
+                    if (seen.has(key)) {
+                        continue;
+                    }
+                    seen.add(key);
+                    matches.push({
+                        declaration: exportedDeclaration,
+                        view,
+                    });
+                }
+            }
+        }
+    }
+    return matches;
+}
+function getTargetSymbolKeys(preparedProject, symbol, relatedViews = [], sourceFile, macroSourceMap) {
+    const declarations = symbol.declarations ??
+        (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
+    const keys = new Set();
+    for (const declaration of declarations) {
+        const symbolName = symbol.getName();
+        const sourceBackedLocation = createSourceBackedProjectedDefinitionLocation(preparedProject, declaration, symbolName) ??
+            createSourceBackedDefinitionLocation(preparedProject, declaration, symbolName);
+        if (sourceBackedLocation) {
+            keys.add(createLocationKey(sourceBackedLocation));
+            continue;
+        }
+        const targetNode = getDefinitionTargetNode(declaration);
+        const location = createDefinitionLocation(preparedProject, targetNode, declaration.getSourceFile(), sourceFile && declaration.getSourceFile() === sourceFile ? macroSourceMap : undefined);
+        if (location) {
+            keys.add(createLocationKey(location));
+        }
+    }
+    for (const match of collectCrossViewDeclarations(preparedProject, symbol, relatedViews)) {
+        const symbolName = symbol.getName();
+        const sourceBackedLocation = createSourceBackedProjectedDefinitionLocation(match.view, match.declaration, symbolName) ??
+            createSourceBackedDefinitionLocation(match.view, match.declaration, symbolName);
+        if (sourceBackedLocation) {
+            keys.add(createLocationKey(sourceBackedLocation));
+            continue;
+        }
+        const targetNode = getDefinitionTargetNode(match.declaration);
+        const location = createDefinitionLocation(match.view, targetNode, match.declaration.getSourceFile());
+        if (location) {
+            keys.add(createLocationKey(location));
+        }
+    }
+    return keys;
+}
+function isExportedStatement(statement) {
+    return (ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined)
+        ?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function findTopLevelNamedDeclarationNode(sourceFile, symbolName) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && declaration.name.text === symbolName) {
+                    return declaration.name;
+                }
+            }
+            continue;
+        }
+        if ((ts.isFunctionDeclaration(statement) ||
+            ts.isClassDeclaration(statement) ||
+            ts.isInterfaceDeclaration(statement) ||
+            ts.isTypeAliasDeclaration(statement) ||
+            ts.isEnumDeclaration(statement)) &&
+            statement.name?.text === symbolName) {
+            return statement.name;
+        }
+    }
+    return undefined;
+}
+function createSourceBackedProjectedDefinitionLocation(preparedProject, declaration, symbolName) {
+    const declarationFileName = declaration.getSourceFile().fileName;
+    if (!isProjectedSoundscriptDeclarationFile(declarationFileName)) {
+        return null;
+    }
+    const sourceFileName = toProjectedDeclarationSourceFileName(preparedProject.preparedProgram.toSourceFileName(declarationFileName));
+    const sourceText = ts.sys.readFile(sourceFileName);
+    if (!sourceText) {
+        return null;
+    }
+    const sourceFile = ts.createSourceFile(sourceFileName, sourceText, ts.ScriptTarget.Latest, true);
+    const targetNode = findTopLevelNamedDeclarationNode(sourceFile, symbolName);
+    if (!targetNode) {
+        return null;
+    }
+    return createDefinitionLocationFromOriginalSource(sourceFileName, sourceText, targetNode);
+}
+function createSourceBackedDefinitionLocation(preparedProject, declaration, symbolName) {
+    const declarationFileName = declaration.getSourceFile().fileName;
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(declarationFileName);
+    if (!isSoundscriptSourceFile(sourceFileName)) {
+        return null;
+    }
+    const isTopLevelDeclaration = ts.isVariableDeclaration(declaration)
+        ? ts.isVariableStatement(declaration.parent.parent) &&
+            ts.isSourceFile(declaration.parent.parent.parent)
+        : ts.isClassDeclaration(declaration) ||
+            ts.isFunctionDeclaration(declaration) ||
+            ts.isInterfaceDeclaration(declaration) ||
+            ts.isTypeAliasDeclaration(declaration) ||
+            ts.isEnumDeclaration(declaration)
+            ? ts.isSourceFile(declaration.parent)
+            : false;
+    if (!isTopLevelDeclaration) {
+        return null;
+    }
+    const sourceText = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName)
+        ?.originalText ?? ts.sys.readFile(sourceFileName);
+    if (!sourceText) {
+        return null;
+    }
+    const sourceFile = ts.createSourceFile(sourceFileName, sourceText, ts.ScriptTarget.Latest, true);
+    const sourceBackedNode = findTopLevelNamedDeclarationNode(sourceFile, symbolName);
+    if (!sourceBackedNode) {
+        return null;
+    }
+    return createDefinitionLocationFromOriginalSource(sourceFileName, sourceText, sourceBackedNode);
+}
+function createDefinitionLocationFromOriginalSource(sourceFileName, sourceText, declarationNode) {
+    return {
+        uri: toFileUrl(sourceFileName).href,
+        range: createRangeFromOffsets(declarationNode.getStart(), declarationNode.getEnd(), sourceText),
+    };
+}
+function preparedFileForProgramSourceFile(preparedProject, sourceFile) {
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const directPreparedFile = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+    const diagnosticPreparedFile = preparedProject.diagnosticPreparedFiles.get(sourceFileName);
+    const directProgramSourceFile = preparedProject.preparedProgram.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(sourceFileName));
+    const diagnosticProgramSourceFile = preparedProject.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(sourceFileName));
+    if (sourceFile === directProgramSourceFile) {
+        return directPreparedFile ?? diagnosticPreparedFile;
+    }
+    if (sourceFile === diagnosticProgramSourceFile) {
+        return diagnosticPreparedFile ?? directPreparedFile;
+    }
+    return diagnosticPreparedFile ?? directPreparedFile;
+}
+function symbolMatchesTargetKeys(preparedProject, symbol, targetKeys, sourceFile, macroSourceMap) {
+    for (const key of getTargetSymbolKeys(preparedProject, symbol, [], sourceFile, macroSourceMap)) {
+        if (targetKeys.has(key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getDefinitionTargetNode(declaration) {
+    const namedDeclaration = declaration;
+    return namedDeclaration.name ?? declaration;
+}
+function mapPatchedNodeRangeToSource(node, sourceFile, preparedFile, macroSourceMap) {
+    const nodeStart = node.getStart(sourceFile);
+    const nodeEnd = node.getEnd();
+    const materializedLength = macroSourceMap.materializedRegion.text.length;
+    const replacementLength = macroSourceMap.originalReplacementEnd -
+        macroSourceMap.originalReplacementStart;
+    const materializedEnd = macroSourceMap.rewrittenStart + materializedLength;
+    if (nodeEnd <= macroSourceMap.rewrittenStart) {
+        const mappedRange = mapProgramRangeToSource(preparedFile, nodeStart, nodeEnd);
+        return { start: mappedRange.start, end: mappedRange.end };
+    }
+    if (nodeStart >= materializedEnd) {
+        const delta = replacementLength - materializedLength;
+        const mappedRange = mapProgramRangeToSource(preparedFile, nodeStart + delta, nodeEnd + delta);
+        return { start: mappedRange.start, end: mappedRange.end };
+    }
+    if (nodeStart < macroSourceMap.rewrittenStart || nodeEnd > materializedEnd) {
+        return {
+            start: macroSourceMap.originalReplacementStart,
+            end: macroSourceMap.originalReplacementEnd,
+        };
+    }
+    const materializedRange = mapMaterializedRangeToSource(macroSourceMap.materializedRegion, nodeStart - macroSourceMap.rewrittenStart, nodeEnd - macroSourceMap.rewrittenStart);
+    if (!materializedRange || materializedRange.intersectsUnmapped) {
+        return {
+            start: macroSourceMap.originalReplacementStart,
+            end: macroSourceMap.originalReplacementEnd,
+        };
+    }
+    return {
+        start: materializedRange.start,
+        end: materializedRange.end,
+    };
+}
+function createDefinitionLocation(preparedProject, declarationNode, sourceFile, macroSourceMap) {
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const preparedFile = preparedFileForProgramSourceFile(preparedProject, sourceFile);
+    if (preparedFile) {
+        const mappedRange = macroSourceMap &&
+            sourceFile.fileName === preparedProject.preparedProgram.toProgramFileName(sourceFileName)
+            ? mapPatchedNodeRangeToSource(declarationNode, sourceFile, preparedFile, macroSourceMap)
+            : (() => {
+                const range = mapProgramRangeToSource(preparedFile, declarationNode.getStart(sourceFile), declarationNode.getEnd());
+                return { start: range.start, end: range.end };
+            })();
+        if (!mappedRange) {
+            return null;
+        }
+        return {
+            uri: toFileUrl(sourceFileName).href,
+            range: createRangeFromOffsets(mappedRange.start, mappedRange.end, preparedFile.originalText),
+        };
+    }
+    const start = sourceFile.getLineAndCharacterOfPosition(declarationNode.getStart(sourceFile));
+    const end = sourceFile.getLineAndCharacterOfPosition(declarationNode.getEnd());
+    return {
+        uri: toFileUrl(sourceFileName).href,
+        range: {
+            start: { line: start.line, character: start.character },
+            end: { line: end.line, character: end.character },
+        },
+    };
+}
+function definitionForNode(preparedProject, checker, node, sourceFile, relatedViews = [], macroSourceMap) {
+    const symbol = resolveSymbolAtNode(checker, node);
+    if (!symbol) {
+        return null;
+    }
+    const declarations = symbol.declarations ??
+        (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
+    if (declarations.length === 0) {
+        return null;
+    }
+    const symbolName = symbol.getName();
+    const uniqueLocations = new Map();
+    for (const declaration of declarations) {
+        const sourceBackedLocation = createSourceBackedProjectedDefinitionLocation(preparedProject, declaration, symbolName);
+        if (sourceBackedLocation) {
+            const key = `${sourceBackedLocation.uri}:${sourceBackedLocation.range.start.line}:${sourceBackedLocation.range.start.character}:${sourceBackedLocation.range.end.line}:${sourceBackedLocation.range.end.character}`;
+            uniqueLocations.set(key, sourceBackedLocation);
+            continue;
+        }
+        const sourceBackedDefinitionLocation = createSourceBackedDefinitionLocation(preparedProject, declaration, symbolName);
+        if (sourceBackedDefinitionLocation) {
+            const key = `${sourceBackedDefinitionLocation.uri}:${sourceBackedDefinitionLocation.range.start.line}:${sourceBackedDefinitionLocation.range.start.character}:${sourceBackedDefinitionLocation.range.end.line}:${sourceBackedDefinitionLocation.range.end.character}`;
+            uniqueLocations.set(key, sourceBackedDefinitionLocation);
+            continue;
+        }
+        const targetNode = getDefinitionTargetNode(declaration);
+        const location = createDefinitionLocation(preparedProject, targetNode, declaration.getSourceFile(), declaration.getSourceFile() === sourceFile ? macroSourceMap : undefined);
+        if (!location) {
+            continue;
+        }
+        const key = `${location.uri}:${location.range.start.line}:${location.range.start.character}:${location.range.end.line}:${location.range.end.character}`;
+        uniqueLocations.set(key, location);
+    }
+    for (const match of collectCrossViewDeclarations(preparedProject, symbol, relatedViews)) {
+        const sourceBackedLocation = createSourceBackedProjectedDefinitionLocation(match.view, match.declaration, symbolName) ??
+            createSourceBackedDefinitionLocation(match.view, match.declaration, symbolName);
+        if (sourceBackedLocation) {
+            const key = `${sourceBackedLocation.uri}:${sourceBackedLocation.range.start.line}:${sourceBackedLocation.range.start.character}:${sourceBackedLocation.range.end.line}:${sourceBackedLocation.range.end.character}`;
+            uniqueLocations.set(key, sourceBackedLocation);
+            continue;
+        }
+        const targetNode = getDefinitionTargetNode(match.declaration);
+        const location = createDefinitionLocation(match.view, targetNode, match.declaration.getSourceFile());
+        if (!location) {
+            continue;
+        }
+        const key = `${location.uri}:${location.range.start.line}:${location.range.start.character}:${location.range.end.line}:${location.range.end.character}`;
+        uniqueLocations.set(key, location);
+    }
+    const allLocations = [...uniqueLocations.values()];
+    const sourceLocations = allLocations.filter((location) => isSoundscriptSourceFile(fromFileUrl(location.uri)));
+    if (sourceLocations.length > 0) {
+        return sourceLocations;
+    }
+    const filteredLocations = allLocations.filter((location) => !isProjectedSoundscriptDeclarationFile(fromFileUrl(location.uri)));
+    return uniqueLocations.size > 0
+        ? (filteredLocations.length > 0 ? filteredLocations : allLocations)
+        : null;
+}
+function definitionMacroInvocation(preparedProject, filePath, sourcePosition) {
+    const macroBinding = findMacroBindingOccurrence(preparedProject, filePath, sourcePosition);
+    if (macroBinding) {
+        const declaration = macroBinding.occurrences.find((entry) => entry.bindingId === macroBinding.occurrence.bindingId && entry.kind === 'declaration');
+        if (declaration) {
+            const originalText = macroBinding.match.resolved.placeholder.preparedFile.originalText;
+            return [createSourceSpanLocation(filePath, originalText, declaration.span)];
+        }
+    }
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const match = findResolvedMacroContainingPosition(filePath, sourcePosition, collected);
+    if (!match) {
+        return null;
+    }
+    const hookNode = resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, sourcePosition);
+    if (hookNode && !('kind' in hookNode)) {
+        return definitionForNode(preparedProject, hookNode.checker, hookNode.node, hookNode.sourceFile, [], {
+            materializedRegion: hookNode.materializedRegion,
+            originalReplacementEnd: hookNode.originalReplacementEnd,
+            originalReplacementStart: hookNode.originalReplacementStart,
+            rewrittenStart: hookNode.rewrittenStart,
+        });
+    }
+    const expressionNode = resolveExpressionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (expressionNode && !('kind' in expressionNode)) {
+        return definitionForNode(preparedProject, expressionNode.checker, expressionNode.node, expressionNode.sourceFile, [], {
+            materializedRegion: expressionNode.materializedRegion,
+            originalReplacementEnd: expressionNode.originalReplacementEnd,
+            originalReplacementStart: expressionNode.originalReplacementStart,
+            rewrittenStart: expressionNode.rewrittenStart,
+        });
+    }
+    const blockNode = resolveBlockNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (blockNode && !('kind' in blockNode)) {
+        return definitionForNode(preparedProject, blockNode.checker, blockNode.node, blockNode.sourceFile, [], {
+            materializedRegion: blockNode.materializedRegion,
+            originalReplacementEnd: blockNode.originalReplacementEnd,
+            originalReplacementStart: blockNode.originalReplacementStart,
+            rewrittenStart: blockNode.rewrittenStart,
+        });
+    }
+    return null;
+}
+function resolveMacroNodeAtPosition(preparedProject, filePath, sourcePosition) {
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const match = findResolvedMacroContainingPosition(filePath, sourcePosition, collected);
+    if (!match) {
+        return null;
+    }
+    const hookNode = resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, sourcePosition);
+    if (hookNode && !('kind' in hookNode)) {
+        return {
+            checker: hookNode.checker,
+            materializedRegion: hookNode.materializedRegion,
+            node: hookNode.node,
+            originalReplacementEnd: hookNode.originalReplacementEnd,
+            originalReplacementStart: hookNode.originalReplacementStart,
+            rewrittenStart: hookNode.rewrittenStart,
+            sourceFile: hookNode.sourceFile,
+        };
+    }
+    const declarationNode = resolveDeclarationNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (declarationNode) {
+        return {
+            checker: declarationNode.checker,
+            materializedRegion: declarationNode.materializedRegion,
+            node: declarationNode.node,
+            originalReplacementEnd: declarationNode.originalReplacementEnd,
+            originalReplacementStart: declarationNode.originalReplacementStart,
+            rewrittenStart: declarationNode.rewrittenStart,
+            sourceFile: declarationNode.sourceFile,
+        };
+    }
+    const expressionNode = resolveExpressionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (expressionNode && !('kind' in expressionNode)) {
+        return {
+            checker: expressionNode.checker,
+            materializedRegion: expressionNode.materializedRegion,
+            node: expressionNode.node,
+            originalReplacementEnd: expressionNode.originalReplacementEnd,
+            originalReplacementStart: expressionNode.originalReplacementStart,
+            rewrittenStart: expressionNode.rewrittenStart,
+            sourceFile: expressionNode.sourceFile,
+        };
+    }
+    const blockNode = resolveBlockNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, sourcePosition);
+    if (blockNode && !('kind' in blockNode)) {
+        return {
+            checker: blockNode.checker,
+            materializedRegion: blockNode.materializedRegion,
+            node: blockNode.node,
+            originalReplacementEnd: blockNode.originalReplacementEnd,
+            originalReplacementStart: blockNode.originalReplacementStart,
+            rewrittenStart: blockNode.rewrittenStart,
+            sourceFile: blockNode.sourceFile,
+        };
+    }
+    return null;
+}
+function resolveDeclarationNodeAtSourcePosition(preparedProgram, resolved, sourcePosition) {
+    const declarationSpan = resolved.placeholder.invocation.declarationSpan;
+    if (!declarationSpan ||
+        sourcePosition < declarationSpan.start ||
+        sourcePosition >= declarationSpan.end) {
+        return null;
+    }
+    const originalText = resolved.placeholder.preparedFile.originalText;
+    const materializedRegion = materializeRegionForAnalysis(resolved.placeholder.invocation.fileName, originalText, declarationSpan);
+    return resolveNodeAtMaterializedRegion(preparedProgram, resolved, {
+        ...materializedRegion,
+        hoverPosition: Math.max(0, Math.min(sourcePosition - declarationSpan.start, materializedRegion.text.length)),
+    });
+}
+function resolveRenameTarget(preparedProject, filePath, line, character) {
+    const lookup = createDirectSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return null;
+    }
+    const sourcePosition = getPositionOfLineAndCharacter(lookup.preparedFile.originalText, line, character);
+    const macroNode = resolveMacroNodeAtPosition(preparedProject, filePath, sourcePosition);
+    if (macroNode && ts.isIdentifier(macroNode.node)) {
+        const target = {
+            checker: macroNode.checker,
+            node: macroNode.node,
+            preparedFile: lookup.preparedFile,
+            sourceFile: macroNode.sourceFile,
+            sourcePosition,
+        };
+        if (resolveSymbolAtNode(target.checker, target.node)) {
+            return target;
+        }
+    }
+    const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+    if (!mappedPosition.insideReplacement) {
+        const node = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+        if (node && !ts.isSourceFile(node) && ts.isIdentifier(node)) {
+            const target = {
+                checker: lookup.checker,
+                node,
+                preparedFile: lookup.preparedFile,
+                sourceFile: lookup.sourceFile,
+                sourcePosition,
+            };
+            if (resolveSymbolAtNode(target.checker, target.node)) {
+                return target;
+            }
+        }
+    }
+    return resolveExpandedRenameTarget(preparedProject, filePath, sourcePosition);
+}
+function createDirectSourceLookup(preparedProject, filePath) {
+    const sourceFile = preparedProject.preparedProgram.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(filePath));
+    if (!sourceFile) {
+        return null;
+    }
+    const preparedFile = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(filePath);
+    if (!preparedFile) {
+        return null;
+    }
+    return {
+        checker: preparedProject.preparedProgram.program.getTypeChecker(),
+        preparedFile,
+        sourceFile,
+    };
+}
+function createExpandedSourceLookup(preparedProject, filePath) {
+    const sourceFile = preparedProject.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(filePath));
+    if (!sourceFile) {
+        return null;
+    }
+    const preparedFile = preparedProject.diagnosticPreparedFiles.get(filePath) ??
+        preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(filePath);
+    if (!preparedFile) {
+        return null;
+    }
+    return {
+        checker: preparedProject.program.getTypeChecker(),
+        preparedFile,
+        sourceFile,
+    };
+}
+function findLookupNodeAtSourcePosition(lookup, sourcePosition) {
+    const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+    if (mappedPosition.insideReplacement) {
+        return null;
+    }
+    const node = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+    return !node || ts.isSourceFile(node) ? null : node;
+}
+function resolveExpandedRenameTarget(preparedProject, filePath, sourcePosition) {
+    const lookup = createExpandedSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return null;
+    }
+    const node = findLookupNodeAtSourcePosition(lookup, sourcePosition);
+    if (!node || !ts.isIdentifier(node)) {
+        return null;
+    }
+    return resolveSymbolAtNode(lookup.checker, node)
+        ? {
+            checker: lookup.checker,
+            node,
+            preparedFile: lookup.preparedFile,
+            sourceFile: lookup.sourceFile,
+            sourcePosition,
+        }
+        : null;
+}
+function completionMacroInvocation(preparedProject, filePath, sourcePosition, originalText) {
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const match = findResolvedMacroContainingPosition(filePath, sourcePosition, collected) ??
+        findResolvedMacroContainingPosition(filePath, Math.max(0, sourcePosition - 1), collected);
+    if (!match) {
+        return null;
+    }
+    const candidatePositions = [
+        ...new Set([
+            sourcePosition,
+            Math.max(match.resolved.placeholder.invocation.span.start, sourcePosition - 1),
+        ]),
+    ];
+    for (const candidatePosition of candidatePositions) {
+        const hookCompletion = completionHookForMacroInvocation(preparedProject, filePath, match, candidatePosition);
+        if (hookCompletion) {
+            return hookCompletion;
+        }
+        const hookNode = resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, candidatePosition, true);
+        if (hookNode && !('kind' in hookNode)) {
+            return completionItemsForNode(hookNode.checker, hookNode.node, originalText, sourcePosition);
+        }
+        const expressionNode = resolveExpressionCompletionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, candidatePosition);
+        if (expressionNode && !('kind' in expressionNode)) {
+            return completionItemsForNode(expressionNode.checker, expressionNode.node, originalText, sourcePosition);
+        }
+        const blockNode = resolveBlockCompletionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, candidatePosition);
+        if (blockNode && !('kind' in blockNode)) {
+            return completionItemsForNode(blockNode.checker, blockNode.node, originalText, sourcePosition);
+        }
+    }
+    return null;
+}
+function signatureHelpMacroInvocation(preparedProject, filePath, sourcePosition) {
+    const collected = getCollectedResolvedMacroPlaceholders(preparedProject);
+    const candidatePositions = [
+        ...new Set([
+            sourcePosition,
+            Math.max(0, sourcePosition - 1),
+        ]),
+    ];
+    for (const candidatePosition of candidatePositions) {
+        const match = findResolvedMacroContainingPosition(filePath, candidatePosition, collected);
+        if (!match) {
+            continue;
+        }
+        const hookNode = resolveHookedMacroAnalysisNodeAtPosition(preparedProject, filePath, match, candidatePosition, true);
+        if (hookNode && !('kind' in hookNode)) {
+            return signatureHelpForNode(hookNode.checker, hookNode.node, hookNode.rewrittenStart + hookNode.materializedRegion.hoverPosition);
+        }
+        const expressionNode = resolveExpressionCompletionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, candidatePosition);
+        if (expressionNode && !('kind' in expressionNode)) {
+            return signatureHelpForNode(expressionNode.checker, expressionNode.node, expressionNode.rewrittenStart + expressionNode.materializedRegion.hoverPosition);
+        }
+        const blockNode = resolveBlockCompletionNodeAtSourcePosition(preparedProject.preparedProgram, match.resolved, candidatePosition);
+        if (blockNode && !('kind' in blockNode)) {
+            return signatureHelpForNode(blockNode.checker, blockNode.node, blockNode.rewrittenStart + blockNode.materializedRegion.hoverPosition);
+        }
+        const artifacts = parseResolvedMacroSyntaxArtifacts(preparedProject, filePath, match);
+        if (artifacts?.definition.signature) {
+            return signatureHelpForMacroDefinition(artifacts.definition, match.resolved.placeholder.invocation, candidatePosition, artifacts.context);
+        }
+    }
+    return null;
+}
+function findSourceMacroInvocationContainingPosition(preparedFile, filePath, sourcePosition) {
+    let bestMatch = null;
+    for (const invocation of preparedFile.rewriteResult.macrosById.values()) {
+        if (invocation.fileName !== filePath) {
+            continue;
+        }
+        if (!containsPosition(invocation.span.start, invocation.span.end, sourcePosition) &&
+            sourcePosition !== invocation.span.end) {
+            continue;
+        }
+        if (!bestMatch ||
+            (invocation.span.end - invocation.span.start) < (bestMatch.span.end - bestMatch.span.start)) {
+            bestMatch = invocation;
+        }
+    }
+    return bestMatch;
+}
+function signatureHelpSourceMacroInvocation(preparedProject, preparedFile, filePath, sourcePosition) {
+    const invocation = findSourceMacroInvocationContainingPosition(preparedFile, filePath, sourcePosition);
+    if (!invocation) {
+        return null;
+    }
+    const definition = getImportedMacroDefinitionsForFile(preparedProject, filePath).get(invocation.nameText);
+    if (!definition?.signature) {
+        return null;
+    }
+    return signatureHelpForMacroDefinition(definition, invocation, sourcePosition);
+}
+function findParsedMacroInvocationContainingPosition(fileName, originalText, sourcePosition) {
+    const scanResult = scanMacroCandidates(fileName, originalText);
+    for (const hash of scanResult.hashes) {
+        if (hash.kind !== 'macro-start' || hash.span.start > sourcePosition) {
+            continue;
+        }
+        const parsed = parseMacroInvocationAt(fileName, originalText, hash.span.start);
+        if ('reason' in parsed) {
+            continue;
+        }
+        if (containsPosition(parsed.span.start, parsed.span.end, sourcePosition) ||
+            sourcePosition === parsed.span.end) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function signatureHelpDirectMacroInvocation(preparedProject, filePath, originalText, sourcePosition) {
+    let invocation = findParsedMacroInvocationContainingPosition(filePath, originalText, sourcePosition);
+    if (!invocation) {
+        let probePosition = sourcePosition;
+        while (probePosition > 0) {
+            const precedingChar = originalText[probePosition - 1];
+            if (precedingChar !== ' ' &&
+                precedingChar !== '\t' &&
+                precedingChar !== '\r' &&
+                precedingChar !== '\n' &&
+                precedingChar !== ';') {
+                break;
+            }
+            probePosition -= 1;
+        }
+        if (probePosition !== sourcePosition) {
+            invocation = findParsedMacroInvocationContainingPosition(filePath, originalText, probePosition);
+        }
+    }
+    if (!invocation) {
+        return null;
+    }
+    const definition = getImportedMacroDefinitionsForFile(preparedProject, filePath).get(invocation.nameText) ?? null;
+    if (!definition?.signature) {
+        return null;
+    }
+    return signatureHelpForMacroDefinition(definition, invocation, sourcePosition);
+}
+function collectDirectMacroInvocationsInRegion(fileName, originalText, regionSpan) {
+    const invocations = [];
+    const scanResult = scanMacroCandidates(fileName, originalText);
+    let cursor = regionSpan.start;
+    for (const hash of scanResult.hashes) {
+        if (hash.kind !== 'macro-start') {
+            continue;
+        }
+        if (hash.span.start < cursor || hash.span.start >= regionSpan.end) {
+            continue;
+        }
+        const parsed = parseMacroInvocationAt(fileName, originalText, hash.span.start);
+        if ('reason' in parsed || parsed.span.end > regionSpan.end) {
+            continue;
+        }
+        invocations.push(parsed);
+        cursor = parsed.span.end;
+    }
+    return invocations;
+}
+function collectReferenceLocationForNode(preparedProject, node, sourceFile, uniqueLocations, includeDeclaration, declarationKeys, macroSourceMap) {
+    const sourceFileName = preparedProject.preparedProgram.toSourceFileName(sourceFile.fileName);
+    const preparedFile = preparedFileForProgramSourceFile(preparedProject, sourceFile);
+    if (preparedFile) {
+        const mappedRange = macroSourceMap
+            ? mapPatchedNodeRangeToSource(node, sourceFile, preparedFile, macroSourceMap)
+            : mapProgramRangeToSource(preparedFile, node.getStart(sourceFile), node.getEnd());
+        if (mappedRange &&
+            preparedFile.originalText.slice(mappedRange.start, mappedRange.end) !==
+                node.getText(sourceFile) &&
+            (macroSourceMap ||
+                ('intersectsReplacement' in mappedRange && mappedRange.intersectsReplacement))) {
+            return;
+        }
+    }
+    const location = createDefinitionLocation(preparedProject, node, sourceFile, macroSourceMap);
+    if (!location) {
+        return;
+    }
+    const key = createLocationKey(location);
+    if (!includeDeclaration && declarationKeys.has(key)) {
+        return;
+    }
+    uniqueLocations.set(key, location);
+}
+function collectReferencesInSourceFile(preparedProject, sourceFile, checker, targetKeys, uniqueLocations, includeDeclaration, declarationKeys, macroSourceMap, scanRange) {
+    function visit(node) {
+        if (scanRange && (node.getEnd() <= scanRange.start || node.getStart(sourceFile) >= scanRange.end)) {
+            return;
+        }
+        if (ts.isIdentifier(node)) {
+            const symbol = resolveSymbolAtNode(checker, node);
+            const matches = symbol
+                ? symbolMatchesTargetKeys(preparedProject, symbol, targetKeys, sourceFile, macroSourceMap)
+                : false;
+            if (symbol &&
+                matches) {
+                collectReferenceLocationForNode(preparedProject, node, sourceFile, uniqueLocations, includeDeclaration, declarationKeys, macroSourceMap);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+}
+function collectDirectSymbolReferencesInSourceFile(preparedProject, sourceFile, checker, targetSymbol, uniqueLocations, includeDeclaration, declarationKeys, macroSourceMap) {
+    function visit(node) {
+        if (ts.isIdentifier(node)) {
+            const symbol = resolveSymbolAtNode(checker, node);
+            if (symbol === targetSymbol) {
+                collectReferenceLocationForNode(preparedProject, node, sourceFile, uniqueLocations, includeDeclaration, declarationKeys, macroSourceMap);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+}
+function collectReferencesInMacroRegion(preparedProject, resolved, regionSpan, targetKeys, uniqueLocations, includeDeclaration, declarationKeys) {
+    const preparedFile = resolved.placeholder.preparedFile;
+    const materializedRegion = materializeRegionForAnalysis(resolved.placeholder.fileName, preparedFile.originalText, regionSpan);
+    const patchedRegion = createPatchedMacroRegion(preparedProject.preparedProgram, resolved, materializedRegion);
+    if (patchedRegion) {
+        collectReferencesInSourceFile(preparedProject, patchedRegion.sourceFile, patchedRegion.checker, targetKeys, uniqueLocations, includeDeclaration, declarationKeys, {
+            materializedRegion: patchedRegion.materializedRegion,
+            originalReplacementEnd: patchedRegion.originalReplacementEnd,
+            originalReplacementStart: patchedRegion.originalReplacementStart,
+            rewrittenStart: patchedRegion.rewrittenStart,
+        }, {
+            start: patchedRegion.rewrittenStart,
+            end: patchedRegion.rewrittenStart + patchedRegion.materializedRegion.text.length,
+        });
+    }
+    for (const nestedInvocation of collectDirectMacroInvocationsInRegion(resolved.placeholder.fileName, preparedFile.originalText, regionSpan)) {
+        for (const argument of nestedInvocation.argumentSpans) {
+            if (argument.kind === 'ExprArg') {
+                collectReferencesInMacroRegion(preparedProject, resolved, argument.span, targetKeys, uniqueLocations, includeDeclaration, declarationKeys);
+            }
+        }
+        const nestedBlockSpan = getInvocationBlockSpan(nestedInvocation);
+        if (nestedBlockSpan) {
+            collectReferencesInMacroRegion(preparedProject, resolved, nestedBlockSpan, targetKeys, uniqueLocations, includeDeclaration, declarationKeys);
+        }
+    }
+}
+export function analyzeOpenDocument(uri, session) {
+    return measureDocumentOperation('request.diagnostics', uri, () => {
+        const filePath = fromFileUrl(uri);
+        const analyzedResult = getAnalyzedProjectContext(filePath, session);
+        if (!analyzedResult) {
+            return {
+                diagnostics: [createNoProjectDiagnostic(filePath)],
+                filePath,
+                uri,
+            };
+        }
+        try {
+            const diagnostics = [
+                ...analyzedResult.diagnostics,
+                ...(getFileLocalAnalyzedProjectContext(filePath, session)?.diagnostics ?? []),
+            ].filter((diagnostic) => diagnostic.filePath === filePath);
+            const uniqueDiagnostics = new Map();
+            for (const diagnostic of diagnostics) {
+                const key = [
+                    diagnostic.code,
+                    diagnostic.filePath,
+                    diagnostic.line,
+                    diagnostic.column,
+                    diagnostic.endLine,
+                    diagnostic.endColumn,
+                    diagnostic.message,
+                ].join(':');
+                uniqueDiagnostics.set(key, diagnostic);
+            }
+            return {
+                diagnostics: [...uniqueDiagnostics.values()],
+                filePath,
+                uri,
+            };
+        }
+        catch (error) {
+            return {
+                diagnostics: [createAnalysisFailureDiagnostic(filePath, error)],
+                filePath,
+                uri,
+            };
+        }
+    });
+}
+export function hoverOpenDocument(uri, line, character, session, capabilityMode = 'full') {
+    return measureDocumentOperation('request.hover', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return null;
+            }
+            const originalText = session.get(uri)?.text ?? lookup.preparedFile.originalText;
+            const sourcePosition = getPositionOfLineAndCharacter(originalText, line, character);
+            const annotationCommentHover = annotationHover(preparedProject, filePath, sourcePosition, originalText);
+            if (annotationCommentHover) {
+                return annotationCommentHover;
+            }
+            const macroHover = hoverMacroInvocation(preparedProject, filePath, sourcePosition, originalText);
+            if (macroHover) {
+                return macroHover;
+            }
+            const projectedImportHover = projectedForeignImportHover(preparedProject, filePath, sourcePosition, originalText);
+            if (projectedImportHover) {
+                return projectedImportHover;
+            }
+            const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+            if (mappedPosition.insideReplacement) {
+                return null;
+            }
+            const node = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+            if (!node || ts.isSourceFile(node)) {
+                return null;
+            }
+            if (isSuppressedFallbackHoverNode(node)) {
+                return null;
+            }
+            const importedMacroHover = importedMacroSummaryHoverForNode(preparedProject, filePath, node, lookup.preparedFile.originalText, sourcePosition);
+            if (importedMacroHover) {
+                return importedMacroHover;
+            }
+            const analysisBackedHover = getAnalysisBackedHoverDetails(preparedProject, filePath, node);
+            const type = lookup.checker.getTypeAtLocation(node);
+            const ordinaryTypeText = lookup.checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
+            const fallbackSymbol = resolveSymbolAtNode(lookup.checker, node);
+            const fallbackSymbolDeclaration = fallbackSymbol?.valueDeclaration ??
+                fallbackSymbol?.declarations?.[0];
+            const fallbackValue = (fallbackSymbolDeclaration
+                ? formatSymbolHoverCode(lookup.checker, getDefinitionTargetNode(fallbackSymbolDeclaration))
+                : null) ??
+                formatSymbolHoverCode(lookup.checker, node) ??
+                ordinaryTypeText;
+            const value = analysisBackedHover?.code ??
+                fallbackValue;
+            if (value.length === 0) {
+                return null;
+            }
+            return {
+                contents: createMarkdownHoverContents(value),
+                range: (() => {
+                    const mappedRange = mapProgramRangeToSource(lookup.preparedFile, node.getStart(lookup.sourceFile), node.getEnd());
+                    return createHoverRange(mappedRange.start, mappedRange.end, lookup.preparedFile.originalText);
+                })(),
+            };
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function definitionOpenDocument(uri, line, character, session) {
+    return measureDocumentOperation('request.definition', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const projectViews = getPreparedProjectViews(filePath, session);
+            const primaryResult = definitionInPreparedProject(preparedProject, filePath, line, character, projectViews);
+            if (primaryResult || !isSoundscriptSourceFile(filePath)) {
+                return primaryResult;
+            }
+            const fullPreparedProject = getPreparedProjectContext(filePath, session, 'full');
+            if (!fullPreparedProject || fullPreparedProject === preparedProject) {
+                return primaryResult;
+            }
+            return definitionInPreparedProject(fullPreparedProject, filePath, line, character, projectViews);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+function definitionInPreparedProject(preparedProject, filePath, line, character, relatedViews) {
+    const lookup = createDirectSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return null;
+    }
+    const sourcePosition = getPositionOfLineAndCharacter(lookup.preparedFile.originalText, line, character);
+    const macroDefinition = definitionMacroInvocation(preparedProject, filePath, sourcePosition);
+    if (macroDefinition) {
+        return macroDefinition;
+    }
+    const macroNode = resolveMacroNodeAtPosition(preparedProject, filePath, sourcePosition);
+    if (macroNode) {
+        return definitionForNode(preparedProject, macroNode.checker, macroNode.node, macroNode.sourceFile, relatedViews, {
+            materializedRegion: macroNode.materializedRegion,
+            originalReplacementEnd: macroNode.originalReplacementEnd,
+            originalReplacementStart: macroNode.originalReplacementStart,
+            rewrittenStart: macroNode.rewrittenStart,
+        });
+    }
+    const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+    if (mappedPosition.insideReplacement) {
+        return definitionInExpandedPreparedProject(preparedProject, filePath, sourcePosition, relatedViews);
+    }
+    const node = findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+    if (!node || ts.isSourceFile(node)) {
+        return definitionInExpandedPreparedProject(preparedProject, filePath, sourcePosition, relatedViews);
+    }
+    const directDefinition = definitionForNode(preparedProject, lookup.checker, node, lookup.sourceFile, relatedViews);
+    const selfRange = createTokenHoverRange(sourcePosition, lookup.preparedFile.originalText);
+    const isOnlySelfDefinition = directDefinition?.length === 1 &&
+        directDefinition[0]?.uri === toFileUrl(filePath).href &&
+        rangesEqual(directDefinition[0].range, selfRange);
+    return (!isOnlySelfDefinition ? directDefinition : null) ??
+        definitionInExpandedPreparedProject(preparedProject, filePath, sourcePosition, relatedViews);
+}
+function definitionInExpandedPreparedProject(preparedProject, filePath, sourcePosition, relatedViews) {
+    const lookup = createExpandedSourceLookup(preparedProject, filePath);
+    if (!lookup) {
+        return null;
+    }
+    const node = findLookupNodeAtSourcePosition(lookup, sourcePosition);
+    if (!node) {
+        return null;
+    }
+    return definitionForNode(preparedProject, lookup.checker, node, lookup.sourceFile, relatedViews);
+}
+export function documentSymbolsOpenDocument(uri, session) {
+    return measureDocumentOperation('request.documentSymbols', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return null;
+            }
+            return topLevelDocumentSymbols(preparedProject, lookup.sourceFile);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function semanticTokensLegend() {
+    return {
+        tokenTypes: [...SEMANTIC_TOKEN_TYPES],
+        tokenModifiers: [...SEMANTIC_TOKEN_MODIFIERS],
+    };
+}
+export function semanticTokensOpenDocument(uri, session) {
+    return measureDocumentOperation('request.semanticTokens', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return { data: [] };
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return { data: [] };
+            }
+            return collectSemanticTokensFromSourceFile(preparedProject, lookup.sourceFile, lookup.checker);
+        }
+        catch {
+            return { data: [] };
+        }
+    });
+}
+export function formatOpenDocument(uri, options, session) {
+    const document = session.get(uri);
+    if (!document) {
+        return null;
+    }
+    const filePath = fromFileUrl(uri);
+    if (!isSoundscriptSourceFile(filePath) && document.languageId !== 'soundscript') {
+        return null;
+    }
+    const preparedProject = getPreparedProjectContext(filePath, session);
+    const sourceFile = preparedProject
+        ? preparedProject.preparedProgram.program.getSourceFile(preparedProject.preparedProgram.toProgramFileName(filePath))
+        : undefined;
+    const macroDefinitions = sourceFile
+        ? preparedProject?.macroEnvironment.definitionsForFile(sourceFile)
+        : undefined;
+    const importedMacroSiteKindsBySpecifier = sourceFile
+        ? preparedProject?.macroEnvironment.siteKindsBySpecifierForFile(sourceFile)
+        : undefined;
+    const formattedText = formatSoundscriptText(filePath, document.text, {
+        indentText: options.insertSpaces ? ' '.repeat(Math.max(options.tabSize, 1)) : '\t',
+        importedMacroSiteKindsBySpecifier,
+        macroDefinitions,
+        newLine: document.text.includes('\r\n') ? '\r\n' : '\n',
+    });
+    if (formattedText === document.text) {
+        return [];
+    }
+    const end = getLineAndCharacterOfPosition(document.text, document.text.length);
+    return [{
+            newText: formattedText,
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: end.line, character: end.character },
+            },
+        }];
+}
+export function showExpandedSourceOpenDocument(uri, stage, session) {
+    const filePath = fromFileUrl(uri);
+    const snapshot = getMacroDebugSnapshotForFile(filePath, session);
+    if (!snapshot) {
+        return null;
+    }
+    return {
+        filePath,
+        stage,
+        text: readMacroDebugStageText(snapshot, stage),
+    };
+}
+export function showMacroTraceOpenDocument(uri, session) {
+    const filePath = fromFileUrl(uri);
+    const snapshot = getMacroDebugSnapshotForFile(filePath, session);
+    if (!snapshot) {
+        return null;
+    }
+    return {
+        filePath,
+        traces: snapshot.traces,
+    };
+}
+export function codeActionsOpenDocument(uri, diagnostics = [], session) {
+    const filePath = fromFileUrl(uri);
+    const text = readCodeActionDocumentText(uri, session);
+    const diagnosticCodes = new Set(diagnostics
+        .map((diagnostic) => diagnostic.code)
+        .filter((code) => code !== undefined));
+    const actions = [];
+    if (diagnosticCodes.has('SOUNDSCRIPT_NO_PROJECT')) {
+        const projectPath = suggestedProjectPathForFile(filePath);
+        actions.push({
+            title: 'Create tsconfig.json for soundscript',
+            kind: 'quickfix',
+            edit: {
+                changes: {
+                    [toFileUrl(projectPath).href]: [{
+                            newText: createStarterTsconfigText(filePath),
+                            range: {
+                                start: { line: 0, character: 0 },
+                                end: { line: 0, character: 0 },
+                            },
+                        }],
+                },
+            },
+        });
+    }
+    if (text) {
+        for (const diagnostic of diagnostics) {
+            const interopAction = createAddInteropCodeAction(uri, filePath, diagnostic, text, session);
+            if (interopAction) {
+                actions.push(interopAction);
+            }
+            const externAction = createAddExternCodeAction(uri, diagnostic, text);
+            if (externAction) {
+                actions.push(externAction);
+            }
+            const unsupportedFeatureAction = createUnsupportedFeatureRewriteCodeAction(uri, filePath, diagnostic, text);
+            if (unsupportedFeatureAction) {
+                actions.push(unsupportedFeatureAction);
+            }
+            const explicitNullishConditionAction = createExplicitNullishConditionCodeAction(uri, filePath, diagnostic, text, session);
+            if (explicitNullishConditionAction) {
+                actions.push(explicitNullishConditionAction);
+            }
+            const explicitBooleanLogicalOperatorAction = createExplicitBooleanLogicalOperatorCodeAction(uri, filePath, diagnostic, text, session);
+            if (explicitBooleanLogicalOperatorAction) {
+                actions.push(explicitBooleanLogicalOperatorAction);
+            }
+            const proofEscapeHatchAction = createProofEscapeHatchRewriteCodeAction(uri, filePath, diagnostic, text);
+            if (proofEscapeHatchAction) {
+                actions.push(proofEscapeHatchAction);
+            }
+            const anyTypeAction = createAnyTypeRewriteCodeAction(uri, filePath, diagnostic, text);
+            if (anyTypeAction) {
+                actions.push(anyTypeAction);
+            }
+            const ambientExportAction = createRemoveAmbientExportCodeAction(uri, filePath, diagnostic, text);
+            if (ambientExportAction) {
+                actions.push(ambientExportAction);
+            }
+            const throwNonErrorAction = createThrowNonErrorCodeAction(uri, filePath, diagnostic, text);
+            if (throwNonErrorAction) {
+                actions.push(throwNonErrorAction);
+            }
+            const receiverSensitiveAction = createReceiverSensitiveBindCodeAction(uri, filePath, diagnostic, text);
+            if (receiverSensitiveAction) {
+                actions.push(receiverSensitiveAction);
+            }
+            const invalidAnnotationTargetAction = createRemoveInvalidAnnotationTargetCodeAction(uri, diagnostic, text);
+            if (invalidAnnotationTargetAction) {
+                actions.push(invalidAnnotationTargetAction);
+            }
+            const pragmaAction = createRemoveTypeScriptPragmaCodeAction(uri, diagnostic, text);
+            if (pragmaAction) {
+                actions.push(pragmaAction);
+            }
+            const malformedAction = createRemoveMalformedAnnotationCodeAction(uri, diagnostic, text);
+            if (malformedAction) {
+                actions.push(malformedAction);
+            }
+            const duplicateAction = createRemoveDuplicateAnnotationsCodeAction(uri, diagnostic, text);
+            if (duplicateAction) {
+                actions.push(duplicateAction);
+            }
+            const unknownAnnotationAction = createRemoveUnknownAnnotationCodeAction(uri, diagnostic, text);
+            if (unknownAnnotationAction) {
+                actions.push(unknownAnnotationAction);
+            }
+            const annotationArgumentsAction = createRemoveUnsupportedAnnotationArgumentsCodeAction(uri, diagnostic, text);
+            if (annotationArgumentsAction) {
+                actions.push(annotationArgumentsAction);
+            }
+            const varianceContractAction = createVarianceContractRewriteCodeAction(uri, diagnostic, text);
+            if (varianceContractAction) {
+                actions.push(varianceContractAction);
+            }
+            const aliasAnnotationAction = createAliasReservedAnnotationMacroCodeAction(uri, filePath, diagnostic, text);
+            if (aliasAnnotationAction) {
+                actions.push(aliasAnnotationAction);
+            }
+        }
+    }
+    return actions.length > 0 ? actions : null;
+}
+export function completeOpenDocument(uri, line, character, session) {
+    return measureDocumentOperation('request.completion', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return null;
+            }
+            const sourcePosition = getPositionOfLineAndCharacter(lookup.preparedFile.originalText, line, character);
+            const macroCompletion = completionMacroInvocation(preparedProject, filePath, sourcePosition, lookup.preparedFile.originalText);
+            if (macroCompletion) {
+                return macroCompletion;
+            }
+            const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+            if (mappedPosition.insideReplacement) {
+                return null;
+            }
+            const lookupPosition = Math.max(0, Math.min(mappedPosition.position, Math.max(lookup.sourceFile.end - 1, 0)));
+            const node = findCompletionNode(lookup.sourceFile, lookupPosition);
+            if (!node) {
+                return null;
+            }
+            return completionItemsForNode(lookup.checker, node, lookup.preparedFile.originalText, sourcePosition);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function signatureHelpOpenDocument(uri, line, character, session) {
+    return measureDocumentOperation('request.signatureHelp', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return null;
+            }
+            const sourcePosition = getPositionOfLineAndCharacter(lookup.preparedFile.originalText, line, character);
+            const macroSignatureHelp = signatureHelpMacroInvocation(preparedProject, filePath, sourcePosition);
+            if (macroSignatureHelp) {
+                return macroSignatureHelp;
+            }
+            const directMacroSignatureHelp = signatureHelpDirectMacroInvocation(preparedProject, filePath, lookup.preparedFile.originalText, sourcePosition);
+            if (directMacroSignatureHelp) {
+                return directMacroSignatureHelp;
+            }
+            const sourceMacroSignatureHelp = signatureHelpSourceMacroInvocation(preparedProject, lookup.preparedFile, filePath, sourcePosition);
+            if (sourceMacroSignatureHelp) {
+                return sourceMacroSignatureHelp;
+            }
+            const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+            if (mappedPosition.insideReplacement) {
+                return null;
+            }
+            const lookupPosition = Math.max(0, Math.min(mappedPosition.position, Math.max(lookup.sourceFile.end - 1, 0)));
+            const node = findCompletionNode(lookup.sourceFile, lookupPosition);
+            if (!node) {
+                return null;
+            }
+            return signatureHelpForNode(lookup.checker, node, mappedPosition.position);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function referencesOpenDocument(uri, line, character, session, includeDeclaration) {
+    return measureDocumentOperation('request.references', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session, 'full');
+            if (!preparedProject) {
+                return null;
+            }
+            const lookup = createDirectSourceLookup(preparedProject, filePath);
+            if (!lookup) {
+                return null;
+            }
+            const sourcePosition = getPositionOfLineAndCharacter(lookup.preparedFile.originalText, line, character);
+            const macroBinding = findMacroBindingOccurrence(preparedProject, filePath, sourcePosition);
+            if (macroBinding) {
+                const locations = macroBinding.occurrences
+                    .filter((occurrence) => includeDeclaration || occurrence.kind !== 'declaration')
+                    .filter((occurrence) => occurrence.bindingId === macroBinding.occurrence.bindingId)
+                    .map((occurrence) => createSourceSpanLocation(filePath, lookup.preparedFile.originalText, occurrence.span));
+                return locations.length > 0 ? locations : null;
+            }
+            const macroNode = resolveMacroNodeAtPosition(preparedProject, filePath, sourcePosition);
+            const mappedPosition = mapSourcePositionToProgram(lookup.preparedFile, sourcePosition);
+            const mainNode = mappedPosition.insideReplacement
+                ? undefined
+                : findDeepestNodeContainingPosition(lookup.sourceFile, mappedPosition.position);
+            const primaryResolvedTarget = macroNode
+                ? {
+                    checker: macroNode.checker,
+                    node: macroNode.node,
+                    sourceFile: macroNode.sourceFile,
+                    macroSourceMap: {
+                        materializedRegion: macroNode.materializedRegion,
+                        originalReplacementEnd: macroNode.originalReplacementEnd,
+                        originalReplacementStart: macroNode.originalReplacementStart,
+                        rewrittenStart: macroNode.rewrittenStart,
+                    },
+                }
+                : mainNode && !ts.isSourceFile(mainNode)
+                    ? {
+                        checker: lookup.checker,
+                        node: mainNode,
+                        sourceFile: lookup.sourceFile,
+                        macroSourceMap: undefined,
+                    }
+                    : null;
+            const resolvedTargets = [];
+            if (primaryResolvedTarget) {
+                const symbol = resolveSymbolAtNode(primaryResolvedTarget.checker, primaryResolvedTarget.node);
+                if (symbol) {
+                    resolvedTargets.push({
+                        ...primaryResolvedTarget,
+                        symbol,
+                    });
+                }
+            }
+            if (resolvedTargets.length === 0) {
+                const expandedTarget = resolveExpandedRenameTarget(preparedProject, filePath, sourcePosition);
+                if (expandedTarget) {
+                    const symbol = resolveSymbolAtNode(expandedTarget.checker, expandedTarget.node);
+                    if (symbol) {
+                        resolvedTargets.push({
+                            ...expandedTarget,
+                            macroSourceMap: undefined,
+                            symbol,
+                        });
+                    }
+                }
+            }
+            if (resolvedTargets.length === 0) {
+                return null;
+            }
+            const projectViews = getPreparedProjectViews(filePath, session);
+            const collectReferencesForResolvedTarget = (resolvedTarget) => {
+                const definitionLocations = resolvedTarget.macroSourceMap
+                    ? definitionForNode(preparedProject, resolvedTarget.checker, resolvedTarget.node, resolvedTarget.sourceFile, projectViews, resolvedTarget.macroSourceMap)
+                    : null;
+                const declarationKeys = definitionLocations && definitionLocations.length > 0
+                    ? new Set(definitionLocations.map(createLocationKey))
+                    : getTargetSymbolKeys(preparedProject, resolvedTarget.symbol, projectViews, resolvedTarget.sourceFile, resolvedTarget.macroSourceMap);
+                if (declarationKeys.size === 0) {
+                    return null;
+                }
+                const uniqueLocations = new Map();
+                for (const view of projectViews) {
+                    const programsToScan = [
+                        {
+                            checker: view.preparedProgram.program.getTypeChecker(),
+                            program: view.preparedProgram.program,
+                        },
+                        {
+                            checker: view.analysisContext.checker,
+                            program: view.program,
+                        },
+                    ];
+                    for (const { program, checker } of programsToScan) {
+                        for (const currentSourceFile of program.getSourceFiles()) {
+                            if (currentSourceFile.isDeclarationFile) {
+                                continue;
+                            }
+                            collectReferencesInSourceFile(view, currentSourceFile, checker, declarationKeys, uniqueLocations, includeDeclaration, declarationKeys);
+                        }
+                    }
+                    for (const collected of getCollectedResolvedMacroPlaceholders(view)) {
+                        for (const argument of collected.resolved.placeholder.invocation.argumentSpans) {
+                            if (argument.kind === 'ExprArg') {
+                                collectReferencesInMacroRegion(view, collected.resolved, argument.span, declarationKeys, uniqueLocations, includeDeclaration, declarationKeys);
+                            }
+                        }
+                        const blockSpan = getInvocationBlockSpan(collected.resolved.placeholder.invocation);
+                        if (blockSpan) {
+                            collectReferencesInMacroRegion(view, collected.resolved, blockSpan, declarationKeys, uniqueLocations, includeDeclaration, declarationKeys);
+                        }
+                        const declarationSpan = collected.resolved.placeholder.invocation.declarationSpan;
+                        if (declarationSpan && !isAugmentDeclarationMacroInvocation(view, collected.resolved)) {
+                            collectReferencesInMacroRegion(view, collected.resolved, declarationSpan, declarationKeys, uniqueLocations, includeDeclaration, declarationKeys);
+                        }
+                    }
+                }
+                if (uniqueLocations.size === 0 && resolvedTarget.macroSourceMap) {
+                    collectDirectSymbolReferencesInSourceFile(preparedProject, resolvedTarget.sourceFile, resolvedTarget.checker, resolvedTarget.symbol, uniqueLocations, includeDeclaration, declarationKeys, resolvedTarget.macroSourceMap);
+                }
+                return uniqueLocations.size === 0
+                    ? null
+                    : [...uniqueLocations.values()].sort((left, right) => left.uri.localeCompare(right.uri) ||
+                        left.range.start.line - right.range.start.line ||
+                        left.range.start.character - right.range.start.character ||
+                        left.range.end.line - right.range.end.line ||
+                        left.range.end.character - right.range.end.character);
+            };
+            let bestReferences = null;
+            for (const resolvedTarget of resolvedTargets) {
+                const candidateReferences = collectReferencesForResolvedTarget(resolvedTarget);
+                if (!candidateReferences) {
+                    continue;
+                }
+                if (!bestReferences || candidateReferences.length > bestReferences.length) {
+                    bestReferences = candidateReferences;
+                }
+            }
+            return bestReferences;
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function highlightOpenDocument(uri, line, character, session) {
+    return measureDocumentOperation('request.documentHighlight', uri, () => {
+        const references = referencesOpenDocument(uri, line, character, session, true);
+        if (!references) {
+            return null;
+        }
+        return references
+            .filter((reference) => reference.uri === uri)
+            .map((reference, index) => ({
+            kind: index === 0 ? 3 : 2,
+            range: reference.range,
+        }));
+    });
+}
+export function prepareRenameOpenDocument(uri, line, character, session) {
+    return measureDocumentOperation('request.prepareRename', uri, () => {
+        const filePath = fromFileUrl(uri);
+        try {
+            const preparedProject = getPreparedProjectContext(filePath, session);
+            if (!preparedProject) {
+                return null;
+            }
+            const preparedFile = preparedProject.preparedProgram.preparedHost.getPreparedSourceFile(filePath);
+            if (!preparedFile) {
+                return null;
+            }
+            const sourcePosition = getPositionOfLineAndCharacter(preparedFile.originalText, line, character);
+            const macroBinding = findMacroBindingOccurrence(preparedProject, filePath, sourcePosition);
+            if (macroBinding) {
+                return {
+                    placeholder: macroBinding.occurrence.name,
+                    range: createRangeFromOffsets(macroBinding.occurrence.span.start, macroBinding.occurrence.span.end, preparedFile.originalText),
+                };
+            }
+            const target = resolveRenameTarget(preparedProject, filePath, line, character);
+            if (!target) {
+                return null;
+            }
+            const symbol = resolveSymbolAtNode(target.checker, target.node);
+            if (!symbol) {
+                return null;
+            }
+            const range = createTokenHoverRange(target.sourcePosition, target.preparedFile.originalText);
+            const placeholder = target.preparedFile.originalText.slice(getPositionOfLineAndCharacter(target.preparedFile.originalText, range.start.line, range.start.character), getPositionOfLineAndCharacter(target.preparedFile.originalText, range.end.line, range.end.character));
+            if (placeholder.length === 0) {
+                return null;
+            }
+            return {
+                placeholder,
+                range,
+            };
+        }
+        catch {
+            return null;
+        }
+    });
+}
+export function renameOpenDocument(uri, line, character, newName, session) {
+    return measureDocumentOperation('request.rename', uri, () => {
+        const preparedRename = prepareRenameOpenDocument(uri, line, character, session);
+        if (!preparedRename) {
+            return null;
+        }
+        const references = referencesOpenDocument(uri, line, character, session, true);
+        if (!references) {
+            return null;
+        }
+        const changes = {};
+        for (const reference of references) {
+            const edits = changes[reference.uri] ?? [];
+            edits.push({
+                newText: newName,
+                range: reference.range,
+            });
+            changes[reference.uri] = edits;
+        }
+        return { changes };
+    });
+}