@velarscript/cli 0.12.1 → 0.14.0

package/dist/language-server.js

@@ -1,16 +1,16 @@
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { isAbsolute, relative, resolve } from "node:path";
-import { compile, CORE_CONTEXTUAL_KEYWORD_WORDS, CORE_PRELUDE_NAMES, formatSource, isSourceIdentifierPart, keywordKinds, PERMANENT_NAMESPACE_NAMES, permanentNamespaceCoveringModule, } from "@velarscript/compiler";
+import { compile, CORE_CONTEXTUAL_KEYWORD_WORDS, CORE_PRELUDE_NAMES, isSourceIdentifierPart, keywordKinds, PERMANENT_NAMESPACE_NAMES, permanentNamespaceCoveringModule, } from "@velarscript/compiler";
 import { standardModuleInterfaces } from "./standard-modules.js";
 import { VelarProjectSessions } from "./project-session.js";
 import { VELAR_VERSION } from "./version.js";
 import { hostErrorMessage } from "./host-error.js";
+import { formatSourceChecked } from "./format-guard.js";
 import { canonicalizePotentialPath, canonicalPathWithinCanonicalRoot } from "./canonical-path.js";
-import { createScriptLanguageDocument, scriptLanguageFor, } from "./script-language-service.js";
 import { buildOwnershipGraph, ownershipGraphRevision } from "./ownership-graph.js";
 import { projectDefinitionAt, projectCompletionsAt, projectCompletionContextAt, projectDocumentSymbols, projectExpressionAt, projectMemberSymbolAt, projectPrepareRenameAt, projectReferencesAt, projectRenameAt, projectSemanticTokens, projectSignatureAt, projectSymbolAt, projectWorkspaceSymbols, } from "./project-semantic.js";
 import { MAX_WORKSPACE_SEARCH_RESULTS, MAX_WORKSPACE_TEXT_FILES, MAX_WORKSPACE_CHANGE_PATHS, MAX_WORKSPACE_CHANGE_PATH_CODE_UNITS, MAX_WORKSPACE_CHANGE_TEXT_CODE_UNITS, WORKSPACE_TEXT_EXTENSIONS, WorkspaceIndexCancelledError, WorkspaceTextIndex, } from "./workspace-index.js";
-export const VELAR_LANGUAGE_SERVER_PROTOCOL_VERSION = 4;
+export const VELAR_LANGUAGE_SERVER_PROTOCOL_VERSION = 5;
 let activePositionEncoding = "utf-16";
 let confinedWorkspaceRoot = null;
 let confinedCanonicalRoot = null;
@@ -25,6 +25,21 @@ const semanticTokenTypes = [
     "interface", "comment", "string", "keyword", "number", "regexp", "operator",
 ];
 const semanticTokenModifiers = ["declaration", "readonly", "static"];
+const nonVelarDocumentResults = new Map([
+    ["textDocument/completion", { isIncomplete: false, items: [] }],
+    ["textDocument/hover", null],
+    ["textDocument/definition", null],
+    ["textDocument/references", []],
+    ["textDocument/documentHighlight", []],
+    ["textDocument/prepareRename", null],
+    ["textDocument/rename", null],
+    ["textDocument/documentSymbol", []],
+    ["textDocument/signatureHelp", null],
+    ["textDocument/inlayHint", []],
+    ["textDocument/semanticTokens/full", { data: [] }],
+    ["textDocument/codeAction", []],
+    ["textDocument/formatting", []],
+]);
 const keywordDocumentation = new Map([
     ["assert", "Requires a boolean or optional invariant and narrows stable values in following statements."],
     ["not", "Negates a checked condition; use `not in` for negative membership and `is not` for a negative runtime type test."],
@@ -134,7 +149,6 @@ export async function runLanguageServer() {
     const configuredCanonical = configuredCanonicalRoot() ?? confinedWorkspaceRoot;
     confinedCanonicalRoot = configuredCanonical ? await canonicalizePotentialPath(configuredCanonical) : null;
     const documents = new Map();
-    const scriptDocuments = new Map();
     const sessions = new VelarProjectSessions();
     const workspaceIndex = new WorkspaceTextIndex();
     const pendingRequests = new Set();
@@ -166,13 +180,13 @@ export async function runLanguageServer() {
         process.stdout.write(`Content-Length: ${Buffer.byteLength(fallbackJson, "utf8")}\r\n\r\n${fallbackJson}`);
     };
     const overrides = () => new Map([...documents.values()].flatMap((item) => {
-        if (scriptDocuments.has(item.uri))
+        if (!isVelarDocument(item))
             return [];
         const itemPath = pathOf(item.uri);
         return itemPath ? [[itemPath, item.text]] : [];
     }));
     const projectFor = async (document) => {
-        if (scriptDocuments.has(document.uri))
+        if (!isVelarDocument(document))
             return null;
         const path = pathOf(document.uri);
         if (!path)
@@ -204,20 +218,16 @@ export async function runLanguageServer() {
         const current = documents.get(document.uri);
         if (!current || current.version !== document.version)
             return;
-        const script = scriptDocuments.get(document.uri);
-        if (script) {
+        if (!isVelarDocument(document)) {
             send({
                 jsonrpc: "2.0",
                 method: "textDocument/publishDiagnostics",
-                params: {
-                    uri: document.uri,
-                    version: document.version,
-                    diagnostics: boundedScriptDiagnostics(document.text, script.analysis()),
-                },
+                params: { uri: document.uri, version: document.version, diagnostics: [] },
             });
             return;
         }
         let diagnostics = [];
+        let advisories = [];
         let notices = [];
         let source;
         try {
@@ -232,24 +242,28 @@ export async function runLanguageServer() {
                             .filter((failure) => failure.path === path)
                             .map((failure) => ({ code: "VEL9001", message: failure.message, span: { start: 0, end: 1 } })),
                     ];
+                    advisories = module.result.advisories;
                     notices = (project?.notices ?? []).filter((notice) => notice.path === path).map((notice) => notice.message);
                     source = module.result.source;
                 }
                 else {
                     const result = compile(document.text, { path });
                     diagnostics = result.diagnostics;
+                    advisories = result.advisories;
                     source = result.source;
                 }
             }
             else {
                 const result = compile(document.text, { path: document.uri });
                 diagnostics = result.diagnostics;
+                advisories = result.advisories;
                 source = result.source;
             }
         }
         catch (error) {
             const result = compile(document.text, { path: document.uri });
             diagnostics = [{ code: "VEL9001", message: hostErrorMessage(error), span: { start: 0, end: 1 } }];
+            advisories = [];
             source = result.source;
         }
         if (documents.get(document.uri)?.version !== document.version)
@@ -260,7 +274,7 @@ export async function runLanguageServer() {
             params: {
                 uri: document.uri,
                 version: document.version,
-                diagnostics: boundedDiagnostics(source, diagnostics, notices),
+                diagnostics: boundedDiagnostics(source, diagnostics, notices, advisories),
             },
         });
     };
@@ -290,7 +304,7 @@ export async function runLanguageServer() {
         const currentOverrides = overrides();
         const roots = new Map();
         for (const document of documents.values()) {
-            if (scriptDocuments.has(document.uri))
+            if (!isVelarDocument(document))
                 continue;
             const documentPath = pathOf(document.uri);
             if (!documentPath)
@@ -338,6 +352,14 @@ export async function runLanguageServer() {
             return;
         }
         const params = message.params;
+        if (message.id !== undefined && message.method && nonVelarDocumentResults.has(message.method)) {
+            const descriptor = params?.textDocument;
+            const document = descriptor?.uri ? documents.get(descriptor.uri) : undefined;
+            if (document && !isVelarDocument(document)) {
+                respond(message.id, nonVelarDocumentResults.get(message.method));
+                return;
+            }
+        }
         switch (message.method) {
             case "initialize":
                 activePositionEncoding = requestedPositionEncoding(params);
@@ -375,9 +397,6 @@ export async function runLanguageServer() {
                                 watchedFiles: true,
                                 workspaceRescan: true,
                                 cancellation: true,
-                                scriptLanguages: ["javascript", "typescript"],
-                                scriptImplementation: "velarscript",
-                                incrementalScriptLexing: true,
                                 workspaceSearch: true,
                                 workspaceTextExtensions: WORKSPACE_TEXT_EXTENSIONS,
                                 workspaceTextFileLimit: MAX_WORKSPACE_TEXT_FILES,
@@ -422,11 +441,7 @@ export async function runLanguageServer() {
                 documents.set(value.uri, value);
                 if (path)
                     workspaceIndex.openDocument(path, value.text);
-                const scriptLanguage = scriptLanguageFor(path ?? value.uri, value.languageId);
-                const script = scriptLanguage ? createScriptLanguageDocument(scriptLanguage, value.text) : null;
-                if (script)
-                    scriptDocuments.set(value.uri, script);
-                if (path && !script) {
+                if (path && isVelarDocument(value)) {
                     try {
                         await sessions.snapshot(path, overrides());
                     }
@@ -448,10 +463,6 @@ export async function runLanguageServer() {
                 const nextPath = pathOf(next.uri);
                 if (nextPath)
                     workspaceIndex.changeDocument(nextPath, next.text);
-                const script = scriptDocuments.get(next.uri);
-                const edit = script ? scriptTextEdit(current.text, next.text) : null;
-                if (script && edit)
-                    script.apply([edit]);
                 schedulePublish(next.uri);
                 break;
             }
@@ -464,14 +475,13 @@ export async function runLanguageServer() {
             }
             case "textDocument/didClose": {
                 const descriptor = params?.textDocument;
+                const current = documents.get(descriptor.uri);
                 documents.delete(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                scriptDocuments.delete(descriptor.uri);
                 diagnosticUris.delete(descriptor.uri);
                 const path = pathOf(descriptor.uri);
                 if (path)
                     await queueWorkspaceIndex(() => workspaceIndex.closeDocument(path));
-                if (path && !script)
+                if (path && current && isVelarDocument(current))
                     await sessions.update(path, new Set([path]), overrides());
                 send({ jsonrpc: "2.0", method: "textDocument/publishDiagnostics", params: { uri: descriptor.uri, diagnostics: [] } });
                 break;
@@ -597,7 +607,7 @@ export async function runLanguageServer() {
                     break;
                 }
                 const document = documents.get(descriptor.uri);
-                if (!document || scriptDocuments.has(descriptor.uri)) {
+                if (!document || !isVelarDocument(document)) {
                     respondError(message.id, "velar/ownershipGraph requires an open VelarScript document", -32602);
                     break;
                 }
@@ -661,7 +671,7 @@ export async function runLanguageServer() {
                     break;
                 }
                 const document = documents.get(descriptor.uri);
-                if (!document || scriptDocuments.has(descriptor.uri)) {
+                if (!document || !isVelarDocument(document)) {
                     respondError(message.id, "velar/emittedJavaScript requires an open VelarScript document", -32602);
                     break;
                 }
@@ -690,7 +700,7 @@ export async function runLanguageServer() {
                     generatedChars: code?.length ?? 0,
                     sourceMapChars: sourceMap?.length ?? 0,
                     limitReached: (code?.length ?? 0) > limit || (sourceMap?.length ?? 0) > limit,
-                    diagnostics: boundedDiagnostics(module.result.source, module.result.diagnostics, []),
+                    diagnostics: boundedDiagnostics(module.result.source, module.result.diagnostics, [], module.result.advisories),
                 });
                 break;
             }
@@ -707,7 +717,7 @@ export async function runLanguageServer() {
                 await waitForWorkspaceIndex(message.id);
                 const projects = new Map();
                 for (const document of documents.values()) {
-                    if (scriptDocuments.has(document.uri))
+                    if (!isVelarDocument(document))
                         continue;
                     const path = pathOf(document.uri);
                     if (!path)
@@ -758,16 +768,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const items = script.completionsAt(scriptOffsetAt(document.text, position)).slice(0, MAX_LSP_RESULT_ITEMS).map((item) => ({
-                        label: clipLspText(item.label),
-                        kind: lspCompletionKind(item.kind),
-                        detail: clipLspText(item.detail),
-                    }));
-                    respond(message.id, { isIncomplete: false, items });
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const offset = document ? offsetAt(document.text, position) : 0;
@@ -790,15 +790,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const result = script.hoverAt(scriptOffsetAt(document.text, position));
-                    respond(message.id, result ? {
-                        contents: { kind: "markdown", value: `\`\`${clipLspText(result.contents)}\`\`` },
-                        range: scriptRange(document.text, result),
-                    } : null);
-                    break;
-                }
                 respond(message.id, document ? await hover(document, position, await projectFor(document)) : null);
                 break;
             }
@@ -806,12 +797,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const location = script.definitionAt(scriptOffsetAt(document.text, position));
-                    respond(message.id, location ? { uri: descriptor.uri, range: scriptRange(document.text, location) } : null);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const location = document && path && project ? projectDefinitionAt(project, path, offsetAt(document.text, position)) : null;
@@ -823,14 +808,6 @@ export async function runLanguageServer() {
                 const position = params?.position;
                 const context = params?.context;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const locations = script.referencesAt(scriptOffsetAt(document.text, position), context?.includeDeclaration ?? false)
-                        .slice(0, MAX_LSP_RESULT_ITEMS)
-                        .map((span) => ({ uri: descriptor.uri, range: scriptRange(document.text, span) }));
-                    respond(message.id, locations);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const locations = document && path && project
@@ -844,14 +821,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const locations = script.referencesAt(scriptOffsetAt(document.text, position), true)
-                        .slice(0, MAX_LSP_RESULT_ITEMS)
-                        .map((span) => ({ range: scriptRange(document.text, span), kind: 1 }));
-                    respond(message.id, locations);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const locations = document && path && project
@@ -869,12 +838,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const symbol = script.symbolAt(scriptOffsetAt(document.text, position));
-                    respond(message.id, symbol ? { range: scriptRange(document.text, symbol), placeholder: symbol.name } : null);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const prepared = document && path && project ? projectPrepareRenameAt(project, path, offsetAt(document.text, position)) : null;
@@ -887,19 +850,6 @@ export async function runLanguageServer() {
                 const position = params?.position;
                 const newName = params?.newName;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    const renamed = script.renameAt(scriptOffsetAt(document.text, position), newName);
-                    if (renamed.error)
-                        respondError(message.id, renamed.error);
-                    else if (renamed.edits.length > MAX_LSP_RESULT_ITEMS)
-                        respondError(message.id, `Rename affects more than ${MAX_LSP_RESULT_ITEMS} locations`);
-                    else
-                        respond(message.id, {
-                            changes: { [descriptor.uri]: renamed.edits.map((edit) => ({ range: scriptRange(document.text, edit), newText: edit.replacement })) },
-                        });
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const renamed = document && path && project ? projectRenameAt(project, path, offsetAt(document.text, position), newName) : "No renameable VelarScript symbol at this position";
@@ -914,17 +864,6 @@ export async function runLanguageServer() {
             case "textDocument/documentSymbol": {
                 const descriptor = params?.textDocument;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    respond(message.id, script.analysis().symbols.slice(0, MAX_LSP_RESULT_ITEMS).map((symbol) => ({
-                        name: clipLspText(symbol.name),
-                        detail: clipLspText(symbol.type),
-                        kind: lspSymbolKind(symbol.kind),
-                        range: scriptRange(document.text, symbol),
-                        selectionRange: scriptRange(document.text, symbol),
-                    })));
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 respond(message.id, path && project ? projectDocumentSymbols(project, path).slice(0, MAX_LSP_RESULT_ITEMS).map((symbol) => ({
@@ -940,10 +879,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const position = params?.position;
                 const document = documents.get(descriptor.uri);
-                if (scriptDocuments.has(descriptor.uri)) {
-                    respond(message.id, null);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const signature = document && path && project ? projectSignatureAt(project, path, offsetAt(document.text, position)) : null;
@@ -958,10 +893,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const range = params?.range;
                 const document = documents.get(descriptor.uri);
-                if (scriptDocuments.has(descriptor.uri)) {
-                    respond(message.id, []);
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 respond(message.id, document && path && project ? projectInlayHints(project, path, document.text, range) : []);
@@ -970,11 +901,6 @@ export async function runLanguageServer() {
             case "textDocument/semanticTokens/full": {
                 const descriptor = params?.textDocument;
                 const document = documents.get(descriptor.uri);
-                const script = scriptDocuments.get(descriptor.uri);
-                if (document && script) {
-                    respond(message.id, { data: scriptSemanticTokenData(document.text, script.analysis()) });
-                    break;
-                }
                 const path = pathOf(descriptor.uri);
                 const project = document ? await projectFor(document) : null;
                 const tokens = path && project ? projectSemanticTokens(project, path).slice(0, MAX_LSP_RESULT_ITEMS) : [];
@@ -985,10 +911,6 @@ export async function runLanguageServer() {
                 const descriptor = params?.textDocument;
                 const context = params?.context;
                 const document = documents.get(descriptor.uri);
-                if (scriptDocuments.has(descriptor.uri)) {
-                    respond(message.id, []);
-                    break;
-                }
                 const acceptsQuickFix = !context?.only || context.only.some((kind) => kind === "quickfix" || kind.startsWith("quickfix."));
                 const fixPath = pathOf(descriptor.uri);
                 const fixProject = document && acceptsQuickFix ? await projectFor(document) : null;
@@ -1004,13 +926,13 @@ export async function runLanguageServer() {
                     respond(message.id, []);
                     break;
                 }
-                if (scriptDocuments.has(descriptor.uri)) {
-                    respond(message.id, []);
-                    break;
-                }
                 const project = await projectFor(document);
-                const formatted = formatSource(document.text, { extensions: project?.compilerExtensions ?? [] });
-                respond(message.id, formatted === document.text ? [] : [{ range: fullRange(document.text), newText: formatted }]);
+                const { text: formatted, stable } = formatSourceChecked(document.text, { extensions: project?.compilerExtensions ?? [] });
+                // Formatting is idempotent by contract, so a result the formatter would
+                // change again is a formatter defect. Offering it as an edit hands
+                // format-on-save a module the next save corrupts, and an editor cannot
+                // undo what it never saw as a change; no edits is the honest answer.
+                respond(message.id, !stable || formatted === document.text ? [] : [{ range: fullRange(document.text), newText: formatted }]);
                 break;
             }
             default:
@@ -1096,49 +1018,33 @@ function isRpcMessage(value) {
 function clipLspText(value) {
     return value.length <= MAX_LSP_TEXT_CHARS ? value : `${value.slice(0, MAX_LSP_TEXT_CHARS - 1)}…`;
 }
-function boundedDiagnostics(source, diagnostics, notices) {
+function boundedDiagnostics(source, diagnostics, notices, advisories) {
     const output = [];
     for (const diagnostic of diagnostics) {
         if (output.length >= MAX_LSP_RESULT_ITEMS)
             break;
         output.push(lspDiagnostic(source, diagnostic));
     }
+    // D89: advisories are published on the same channel the protocol gives an
+    // editor, one severity below an error, so the squiggle a reader sees says
+    // "this spelling means something else" without claiming the file failed.
+    for (const item of advisories) {
+        if (output.length >= MAX_LSP_RESULT_ITEMS)
+            break;
+        output.push(lspAdvisory(source, item));
+    }
     for (const notice of notices) {
         if (output.length >= MAX_LSP_RESULT_ITEMS)
             break;
         output.push(lspNotice(source, notice));
     }
-    if (diagnostics.length + notices.length > MAX_LSP_RESULT_ITEMS) {
+    if (diagnostics.length + advisories.length + notices.length > MAX_LSP_RESULT_ITEMS) {
         if (output.length >= MAX_LSP_RESULT_ITEMS)
             output.pop();
         output.push(lspNotice(source, `Diagnostics were truncated to ${MAX_LSP_RESULT_ITEMS} items`));
     }
     return output;
 }
-function boundedScriptDiagnostics(text, analysis) {
-    const diagnostics = analysis.diagnostics.slice(0, MAX_LSP_RESULT_ITEMS);
-    const ends = diagnostics.map((diagnostic) => Math.max(diagnostic.start + 1, diagnostic.end));
-    const positions = scriptPositionsAt(text, diagnostics.flatMap((diagnostic, index) => [diagnostic.start, ends[index]]));
-    const output = diagnostics.map((diagnostic, index) => ({
-        range: scriptRangeFromPositions(positions, diagnostic.start, ends[index]),
-        severity: diagnostic.severity === "error" ? 1 : 2,
-        code: diagnostic.code,
-        source: "velar-script",
-        message: clipLspText(diagnostic.message),
-    }));
-    if (analysis.diagnostics.length > MAX_LSP_RESULT_ITEMS) {
-        if (output.length >= MAX_LSP_RESULT_ITEMS)
-            output.pop();
-        output.push({
-            range: scriptRange(text, { start: 0, end: Math.min(1, codePointCount(text, 0, text.length)) }),
-            severity: 2,
-            code: "SCRIPT9001",
-            source: "velar-script",
-            message: `Script diagnostics were truncated to ${MAX_LSP_RESULT_ITEMS} items`,
-        });
-    }
-    return output;
-}
 function oversizedDiagnosticsFallback(params) {
     const input = params && typeof params === "object" && !Array.isArray(params)
         ? params
@@ -1173,6 +1079,21 @@ function lspDiagnostic(source, item) {
         message: clipLspText(item.message),
     };
 }
+/** D89: severity 2 is Warning — an advisory is reported, never a failure. */
+function lspAdvisory(source, item) {
+    const start = lspSourcePosition(source, item.span.start);
+    const end = lspSourcePosition(source, Math.max(item.span.start + 1, item.span.end));
+    return {
+        range: {
+            start,
+            end,
+        },
+        severity: 2,
+        code: item.code,
+        source: "velar",
+        message: clipLspText(item.message),
+    };
+}
 function lspNotice(source, message) {
     const start = lspSourcePosition(source, 0);
     const end = lspSourcePosition(source, Math.min(1, source.text.length));
@@ -1267,74 +1188,20 @@ function semanticTokenData(source, tokens) {
     }
     return data;
 }
-function scriptSemanticTokenData(text, analysis) {
-    const tokens = analysis.tokens.slice(0, MAX_LSP_RESULT_ITEMS);
-    const positions = scriptPositionsAt(text, tokens.flatMap((token) => [token.start, token.end]));
-    const declarations = new Map(analysis.symbols.map((symbol) => [`${symbol.start}:${symbol.end}`, symbol]));
-    const references = new Map(analysis.references.map((reference) => [`${reference.start}:${reference.end}`, reference]));
-    const symbols = new Map(analysis.symbols.map((symbol) => [symbol.id, symbol]));
-    const data = [];
-    let previousLine = 0;
-    let previousCharacter = 0;
-    for (const token of tokens) {
-        const key = `${token.start}:${token.end}`;
-        const declaration = declarations.get(key);
-        const reference = references.get(key);
-        const symbol = declaration ?? (reference ? symbols.get(reference.symbolId) : undefined);
-        const type = symbol ? scriptSemanticSymbolType(symbol.kind) : scriptLexicalTokenType(token.kind);
-        if (!type)
-            continue;
-        const range = scriptRangeFromPositions(positions, token.start, token.end);
-        if (range.start.line !== range.end.line || range.end.character <= range.start.character)
-            continue;
-        const deltaLine = range.start.line - previousLine;
-        const deltaCharacter = deltaLine === 0 ? range.start.character - previousCharacter : range.start.character;
-        const tokenType = semanticTokenTypes.indexOf(type);
-        if (tokenType < 0 || deltaLine < 0 || deltaCharacter < 0)
-            continue;
-        const modifiers = (declaration ? 1 << semanticTokenModifiers.indexOf("declaration") : 0)
-            | (symbol && (symbol.kind === "constant" || symbol.kind === "import") ? 1 << semanticTokenModifiers.indexOf("readonly") : 0);
-        data.push(deltaLine, deltaCharacter, range.end.character - range.start.character, tokenType, modifiers);
-        previousLine = range.start.line;
-        previousCharacter = range.start.character;
-    }
-    return data;
-}
-function scriptSemanticSymbolType(kind) {
-    switch (kind) {
-        case "class": return "class";
-        case "interface": return "interface";
-        case "type": return "type";
-        case "enum": return "enum";
-        case "function": return "function";
-        case "parameter": return "parameter";
-        default: return "variable";
-    }
-}
-function scriptLexicalTokenType(kind) {
-    switch (kind) {
-        case "comment": return "comment";
-        case "string":
-        case "template": return "string";
-        case "keyword": return "keyword";
-        case "number": return "number";
-        case "regexp": return "regexp";
-        case "operator": return "operator";
-        case "identifier": return "variable";
-        default: return null;
-    }
-}
 /**
  * D38 §48: an editor quick fix is the same mechanical rewrite `velar fix`
  * applies, read from the diagnostic that named it. The compiler registers the
  * rewrite where it reports the diagnostic, so the editor never re-derives one
- * from message text and the two surfaces can never drift apart.
+ * from message text and the two surfaces can never drift apart. D89: an
+ * advisory that names one rewrite registers it the same way, so the editor
+ * offers A2's swap as an ordinary quick fix; `velar fix` still reads
+ * diagnostics only, because which name binds which value is a judgment.
  */
 function quickFixes(document, module, diagnostics) {
     if (!module)
         return [];
     const source = module.result.source;
-    const registered = module.result.diagnostics
+    const registered = [...module.result.diagnostics, ...module.result.advisories]
         .filter((item) => item.fix && item.fix.edits.length > 0)
         .map((item) => ({ code: item.code, range: lspRange(source, boundedDiagnosticSpan(source, item.span)), fix: item.fix }));
     if (registered.length === 0)
@@ -1461,6 +1328,13 @@ function rawPathOf(uri) {
         return null;
     }
 }
+function isVelarDocument(document) {
+    const language = document.languageId.trim().toLowerCase();
+    if (language === "velar" || language === "velarscript")
+        return true;
+    const path = rawPathOf(document.uri);
+    return path !== null && path.toLowerCase().endsWith(".vel");
+}
 async function authorizedPathOf(uri) {
     const path = pathOf(uri);
     if (!path || !confinedCanonicalRoot)
@@ -1485,24 +1359,6 @@ function applyContentChanges(text, changes) {
     }
     return result;
 }
-function scriptTextEdit(previous, next) {
-    if (previous === next)
-        return null;
-    const before = Array.from(previous);
-    const after = Array.from(next);
-    const limit = Math.min(before.length, after.length);
-    let prefix = 0;
-    while (prefix < limit && before[prefix] === after[prefix])
-        prefix += 1;
-    let suffix = 0;
-    while (suffix < limit - prefix && before[before.length - suffix - 1] === after[after.length - suffix - 1])
-        suffix += 1;
-    return {
-        start: prefix,
-        end: before.length - suffix,
-        replacement: after.slice(prefix, after.length - suffix).join(""),
-    };
-}
 function offsetAt(text, position) {
     const requestedLine = Number.isSafeInteger(position?.line) && position.line >= 0
         ? position.line
@@ -1520,68 +1376,6 @@ function offsetAt(text, position) {
         ? Math.min(end, offset + requestedCharacter)
         : codeUnitOffsetAt(text, offset, end, requestedCharacter);
 }
-function scriptOffsetAt(text, position) {
-    return codePointCount(text, 0, offsetAt(text, position));
-}
-function scriptRange(text, span) {
-    const positions = scriptPositionsAt(text, [span.start, span.end]);
-    return scriptRangeFromPositions(positions, span.start, span.end);
-}
-function scriptRangeFromPositions(positions, start, end) {
-    const startPosition = positions.get(start);
-    const endPosition = positions.get(end);
-    if (!startPosition || !endPosition)
-        throw new Error("Script coordinate map is incomplete");
-    return { start: startPosition, end: endPosition };
-}
-function scriptPositionsAt(text, offsets) {
-    const requested = [...new Set(offsets.map((offset) => Math.max(0, offset)))].sort((left, right) => left - right);
-    const output = new Map();
-    let codeUnit = 0;
-    let codePoint = 0;
-    let line = 0;
-    let lineCodeUnit = 0;
-    let lineCodePoint = 0;
-    let pendingCarriageReturn = false;
-    for (const requestedOffset of requested) {
-        while (codePoint < requestedOffset && codeUnit < text.length) {
-            const value = text.codePointAt(codeUnit);
-            const width = value > 0xffff ? 2 : 1;
-            const character = text[codeUnit];
-            codeUnit += width;
-            codePoint += 1;
-            if (pendingCarriageReturn) {
-                pendingCarriageReturn = false;
-                if (character === "\n") {
-                    line += 1;
-                    lineCodeUnit = codeUnit;
-                    lineCodePoint = codePoint;
-                    continue;
-                }
-            }
-            if (character === "\r") {
-                if (text[codeUnit] === "\n")
-                    pendingCarriageReturn = true;
-                else {
-                    line += 1;
-                    lineCodeUnit = codeUnit;
-                    lineCodePoint = codePoint;
-                }
-            }
-            else if (character === "\n") {
-                line += 1;
-                lineCodeUnit = codeUnit;
-                lineCodePoint = codePoint;
-            }
-        }
-        const boundedOffset = Math.min(requestedOffset, codePoint);
-        output.set(requestedOffset, {
-            line,
-            character: activePositionEncoding === "utf-16" ? codeUnit - lineCodeUnit : boundedOffset - lineCodePoint,
-        });
-    }
-    return output;
-}
 function positionAt(text, requestedOffset) {
     const offset = Math.max(0, Math.min(text.length, requestedOffset));
     let line = 0;