@stateward/language-server 1.0.1 → 1.1.0

package/dist/adoption.d.ts

@@ -47,6 +47,11 @@ export type NextAnswer = {
  | {
     kind: "blocked";
     message: string;
+}
+/** Every rule left could not run here (a library's types are missing): nothing was turned on. */
+ | {
+    kind: "not-checked";
+    message: string;
 } | {
     kind: "rollout-off";
     message: string;

package/dist/adoption.js

@@ -1,4 +1,4 @@
-import { RolloutError, advance, buildPlan, describeTurnOn, readRollout, ruleIsOn, writeRollout, } from "@stateward/core/internal";
+import { RolloutError, advance, buildPlan, describeNotChecked, describeTurnOn, readRollout, ruleIsOn, writeRollout, } from "@stateward/core/internal";
 import { countFindings } from "./report.js";
 export const STATUS_NOTIFICATION = "stateward/status";
 export const PLAN_REQUEST = "stateward/plan";
@@ -70,7 +70,7 @@ export function parseNextParams(params) {
 export function rolloutOffAnswer(configFileName) {
     return {
         kind: "rollout-off",
-        message: `Turn on \`rollout: true\` in ${configFileName} first: without it every rule runs, and there is no next rule to turn on.`,
+        message: `Set \`rollout: true\` in ${configFileName} first: without it every rule runs, and there is no next rule to turn on.`,
     };
 }
 /**
@@ -87,6 +87,8 @@ export function applyNext(config, result, anyway) {
         const enabled = readRollout(config);
         const step = advance(buildPlan(config, result), enabled, anyway);
         switch (step.kind) {
+            case "not-checked":
+                return { kind: "not-checked", message: describeNotChecked(step.rows) };
             case "all-on":
                 return {
                     kind: "all-on",

package/dist/fix-all.d.ts

@@ -38,7 +38,7 @@ export declare function kindWanted(only: readonly string[] | undefined, kind: st
  * edit whose version is not the document's current one, so a fix computed before an edit can
  * never be applied to the text after it.
  */
-export declare function versionedEdit(changes: Readonly<Record<string, readonly TextEdit[]>>, versionOf: (uri: string) => number | null): WorkspaceEdit;
+export declare function versionedEdit(changes: Readonly<Record<string, readonly TextEdit[]>>, versionOf: (uri: string) => number | null, exists?: (uri: string) => boolean): WorkspaceEdit;
 /** `action` with its `changes` edit turned into versioned `documentChanges`; unchanged when it has none. */
 export declare function versionedAction(action: CodeAction, versionOf: (uri: string) => number | null): CodeAction;
 //# sourceMappingURL=fix-all.d.ts.map

package/dist/fix-all.js

@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 function compare(a, b) {
     return a.line - b.line || a.character - b.character;
 }
@@ -74,14 +76,21 @@ export function kindWanted(only, kind) {
  * edit whose version is not the document's current one, so a fix computed before an edit can
  * never be applied to the text after it.
  */
-export function versionedEdit(changes, versionOf) {
+export function versionedEdit(changes, versionOf, exists = fileExists) {
     return {
-        documentChanges: Object.entries(changes).map(([uri, edits]) => ({
-            textDocument: { uri, version: versionOf(uri) },
-            edits: [...edits],
-        })),
+        documentChanges: Object.entries(changes).flatMap(([uri, edits]) => {
+            const version = versionOf(uri);
+            const edit = { textDocument: { uri, version }, edits: [...edits] };
+            // A fix may write a file once (a guarantees file): it is created first, then filled.
+            if (version !== null || exists(uri))
+                return [edit];
+            return [{ kind: "create", uri, options: { ignoreIfExists: true } }, edit];
+        }),
     };
 }
+function fileExists(uri) {
+    return !uri.startsWith("file:") || existsSync(fileURLToPath(uri));
+}
 /** `action` with its `changes` edit turned into versioned `documentChanges`; unchanged when it has none. */
 export function versionedAction(action, versionOf) {
     const changes = action.edit?.changes;

package/dist/guarantees.d.ts

@@ -0,0 +1,46 @@
+import { type CodeAction, type CodeLens, type Range } from "vscode-languageserver/node";
+import type { GuaranteeProof } from "@stateward/core/internal";
+/**
+ * The editor's view of the stated guarantees: a hover and a code lens on each marked
+ * declaration, and "Show proof path" on each error about one. Everything here answers from the
+ * last full pass (its proofs and the texts it read), so nothing is type checked on a request.
+ */
+/** Opens the places a guarantee covers (its errors first, then its readers) in a list to jump through. */
+export declare const SHOW_COVERS_COMMAND = "stateward.showGuaranteeCovers";
+/** Walks an error about a guarantee: where it fails, then each step of its path, then the declaration. */
+export declare const SHOW_PROOF_PATH_COMMAND = "stateward.showProofPath";
+/** One place to jump to, as the client's commands take it. */
+export type Place = {
+    uri: string;
+    range: Range;
+    label: string;
+};
+/** The argument of both commands: a title and the places, in order. */
+export type PlaceList = {
+    title: string;
+    places: Place[];
+};
+/**
+ * The proofs of the last full pass, with the text of every file they point into as that pass read
+ * it: offsets are turned into lines with that text, and a file whose text has changed since gets
+ * no hover or lens until the next pass.
+ */
+export type ProofView = {
+    readonly proofs: readonly GuaranteeProof[];
+    /** By TypeScript path. */
+    readonly texts: ReadonlyMap<string, string>;
+    /** The project folder, for paths in a hover. */
+    readonly cwd: string;
+};
+export declare const NO_PROOFS: ProofView;
+export declare function proofView(proofs: readonly GuaranteeProof[], textOf: (file: string) => string | undefined, cwd: string): ProofView;
+/**
+ * The hover on a marked declaration: "Guaranteed: <what>; proven for N readers", or the first
+ * error and its path when it is not proven. Undefined when `offset` is on no declaration.
+ */
+export declare function guaranteeHover(view: ProofView, file: string, text: string, offset: number): string | undefined;
+/** A code lens above each marked declaration of `file`: what it covers, and a command that lists it. */
+export declare function guaranteeLenses(view: ProofView, file: string, text: string): CodeLens[];
+/** "Show proof path" for each error about a guarantee whose place in `file` meets `range`. */
+export declare function proofPathActions(view: ProofView, file: string, text: string, range: Range): CodeAction[];
+//# sourceMappingURL=guarantees.d.ts.map

package/dist/guarantees.js

@@ -0,0 +1,180 @@
+import { pathToFileURL } from "node:url";
+import { CodeActionKind, } from "vscode-languageserver/node";
+import { describeStatus, displayPath } from "@stateward/core/internal";
+import { buildLineIndex, toRange } from "./mapping.js";
+/**
+ * The editor's view of the stated guarantees: a hover and a code lens on each marked
+ * declaration, and "Show proof path" on each error about one. Everything here answers from the
+ * last full pass (its proofs and the texts it read), so nothing is type checked on a request.
+ */
+/** Opens the places a guarantee covers (its errors first, then its readers) in a list to jump through. */
+export const SHOW_COVERS_COMMAND = "stateward.showGuaranteeCovers";
+/** Walks an error about a guarantee: where it fails, then each step of its path, then the declaration. */
+export const SHOW_PROOF_PATH_COMMAND = "stateward.showProofPath";
+/** At most this many steps of a path are shown in a hover; the command shows them all. */
+const HOVER_STEPS = 4;
+export const NO_PROOFS = { proofs: [], texts: new Map(), cwd: "" };
+/** Every file a proof points into. */
+function filesOf(proofs) {
+    const files = new Set();
+    for (const { stated, status } of proofs) {
+        files.add(stated.location.file);
+        for (const place of stated.covered)
+            files.add(place.location.file);
+        if (status.kind !== "unproven")
+            continue;
+        for (const error of status.errors) {
+            files.add(error.location.file);
+            for (const note of error.related)
+                files.add(note.location.file);
+        }
+    }
+    return files;
+}
+export function proofView(proofs, textOf, cwd) {
+    const texts = new Map();
+    for (const file of filesOf(proofs)) {
+        const text = textOf(file);
+        if (text !== undefined)
+            texts.set(file, text);
+    }
+    return { proofs, texts, cwd };
+}
+function indexer(view) {
+    const indexes = new Map();
+    return (file) => {
+        const known = indexes.get(file);
+        if (known !== undefined)
+            return known;
+        const index = buildLineIndex(view.texts.get(file) ?? "");
+        indexes.set(file, index);
+        return index;
+    };
+}
+/** The proofs declared in `file`, when the editor's text is still the one the pass read. */
+function declaredIn(view, file, text) {
+    if (view.texts.get(file) !== text)
+        return [];
+    return view.proofs.filter((proof) => proof.stated.location.file === file);
+}
+function place(index, location, label) {
+    return {
+        uri: pathToFileURL(location.file).href,
+        range: toRange(index(location.file), location),
+        label,
+    };
+}
+function lineOf(view, index, location) {
+    const line = toRange(index(location.file), location).start.line + 1;
+    return `${displayPath(view.cwd, location.file)}:${String(line)}`;
+}
+/** An error's path as places: where it fails, each note (the declaration's last). */
+function pathOf(view, index, error) {
+    return [
+        place(index, error.location, error.message),
+        ...error.related.map((note) => place(index, note.location, note.message)),
+    ];
+}
+function errorsOf(proof) {
+    return proof.status.kind === "unproven" ? proof.status.errors : [];
+}
+/**
+ * The hover on a marked declaration: "Guaranteed: <what>; proven for N readers", or the first
+ * error and its path when it is not proven. Undefined when `offset` is on no declaration.
+ */
+export function guaranteeHover(view, file, text, offset) {
+    const proof = declaredIn(view, file, text).find(({ stated }) => offset >= stated.location.start && offset <= stated.location.end);
+    if (proof === undefined)
+        return undefined;
+    const { stated } = proof;
+    const head = `**Guaranteed:** ${stated.promise} (\`${stated.marker}\`); ${describeStatus(proof)}`;
+    const first = errorsOf(proof)[0];
+    if (first === undefined)
+        return head;
+    const index = indexer(view);
+    // The declaration's own note says what the hover already says.
+    const steps = first.related.filter((note) => note.location.file !== stated.location.file || note.location.start !== stated.location.start);
+    const shown = steps
+        .slice(0, HOVER_STEPS)
+        .map((note) => `- ${lineOf(view, index, note.location)}: ${note.message}`);
+    const more = steps.length > shown.length
+        ? [`- … ${String(steps.length - shown.length)} more: "Show proof path" on the error`]
+        : [];
+    return [
+        head,
+        `First: ${first.message} (${lineOf(view, index, first.location)})`,
+        [...shown, ...more].join("\n"),
+    ]
+        .filter((part) => part !== "")
+        .join("\n\n");
+}
+function lensTitle(proof) {
+    const { stated, status } = proof;
+    const count = stated.covered.length;
+    const covers = count === 1 ? stated.covers.replace(/s$/, "") : stated.covers;
+    switch (status.kind) {
+        case "proven":
+            return `${String(count)} ${covers} proven · show`;
+        case "unproven":
+            return `${String(status.errors.length)} not proven · ${String(count)} ${covers} · show`;
+        case "unused":
+        case "off":
+            return describeStatus(proof);
+        default: {
+            const unreachable = status;
+            return unreachable;
+        }
+    }
+}
+/** A code lens above each marked declaration of `file`: what it covers, and a command that lists it. */
+export function guaranteeLenses(view, file, text) {
+    const index = indexer(view);
+    return declaredIn(view, file, text).map((proof) => {
+        const { stated } = proof;
+        const places = [
+            ...errorsOf(proof).map((error) => place(index, error.location, `not proven: ${error.message}`)),
+            ...stated.covered.map((covered) => place(index, covered.location, covered.name)),
+        ];
+        const argument = { title: `${stated.name}: ${describeStatus(proof)}`, places };
+        const range = toRange(index(file), stated.location);
+        return {
+            range: { start: range.start, end: range.start },
+            command: {
+                title: lensTitle(proof),
+                // A lens with nothing to list is a label: no command runs when it is clicked.
+                command: places.length === 0 ? "" : SHOW_COVERS_COMMAND,
+                arguments: places.length === 0 ? [] : [argument],
+            },
+        };
+    });
+}
+/** "Show proof path" for each error about a guarantee whose place in `file` meets `range`. */
+export function proofPathActions(view, file, text, range) {
+    if (view.texts.get(file) !== text)
+        return [];
+    const index = indexer(view);
+    return view.proofs.flatMap((proof) => errorsOf(proof).flatMap((error) => {
+        if (error.location.file !== file)
+            return [];
+        const at = toRange(index(file), error.location);
+        const meets = !(isBefore(at.end, range.start) || isBefore(range.end, at.start));
+        if (!meets)
+            return [];
+        const argument = {
+            title: `Proof path: ${error.message}`,
+            places: pathOf(view, index, error),
+        };
+        const title = `Show the proof path of ${proof.stated.name}`;
+        return [
+            {
+                title,
+                kind: CodeActionKind.QuickFix,
+                command: { title, command: SHOW_PROOF_PATH_COMMAND, arguments: [argument] },
+            },
+        ];
+    }));
+}
+function isBefore(a, b) {
+    return a.line < b.line || (a.line === b.line && a.character < b.character);
+}
+//# sourceMappingURL=guarantees.js.map

package/dist/server.d.ts

@@ -23,12 +23,16 @@ export declare const DISK_SAVE_MS: number;
  * Wires the stateward language server to `connection`. The caller starts listening. The returned
  * function stops the server's timers (also done on shutdown); call it before disposing the connection.
  */
-export declare function startServer(connection: Connection, { idleMs, cacheDir, saveMs, }?: {
+export declare function startServer(connection: Connection, { idleMs, cacheDir, saveMs, fastMs, fullMs, }?: {
     /** How long a nested config's engine waits, with none of its files open, before it stops. */
     idleMs?: number;
     /** The results cache folder of a project, as the CLI finds it; undefined for none. */
     cacheDir?: (project: string) => string | undefined;
     /** The least time between two writes of a config's results cache. */
     saveMs?: number;
+    /** How long after an edit its fast pass waits (tests: long, to see the state before it). */
+    fastMs?: number;
+    /** How long after an edit the full pass waits. */
+    fullMs?: number;
 }): () => void;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,18 +1,19 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { CodeActionKind, DidChangeConfigurationNotification, DidChangeWatchedFilesNotification, MarkupKind, ErrorCodes, MessageType, ResponseError, ShowMessageNotification, TextDocumentSyncKind, TextDocuments, } from "vscode-languageserver/node";
+import { CodeActionKind, CodeLensRefreshRequest, DidChangeConfigurationNotification, DidChangeWatchedFilesNotification, MarkupKind, ErrorCodes, MessageType, ResponseError, ShowMessageNotification, TextDocumentSyncKind, TextDocuments, } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { BaselineError, NothingToCheckError, activeRuleIds, TsconfigError, TypeScriptLibMissingError, check, computeImplementationId, configLocalImports, createChecker, defaultCacheDir, displayPath, loadConfigFile, openDiskCache, reloadsLocalImports, resultsCacheLimit, toTypeScriptPath, } from "@stateward/core/internal";
+import { BaselineError, NothingToCheckError, activeRuleIds, TsconfigError, TypeScriptLibMissingError, check, computeImplementationId, configLocalImports, createChecker, defaultCacheDir, displayPath, loadConfigFile, proveGuarantees, openDiskCache, reloadsLocalImports, resultsCacheLimit, toTypeScriptPath, } from "@stateward/core/internal";
 import { InvalidNextParamsError, NEXT_REQUEST, PLAN_REQUEST, RECHECK_REQUEST, STATUS_NOTIFICATION, applyNext, parseNextParams, planAnswer, rolloutOffAnswer, statusReport, } from "./adoption.js";
 import { layBaseline } from "./baseline.js";
 import { DEFAULT_HINT_SETTINGS, hintEnabled, readHintSettings, toInlayHints, } from "./inlay-hints.js";
 import { InvalidExplainParamsError, answerExplain } from "./explain.js";
 import { fixAllEdits, kindWanted, versionedAction, versionedEdit, } from "./fix-all.js";
+import { NO_PROOFS, guaranteeHover, guaranteeLenses, proofPathActions, proofView, } from "./guarantees.js";
 import { mergeFastPass } from "./merge.js";
 import { SILENT_PROGRESS, withProgress } from "./progress.js";
 import { fastPassLine, fullPassLine, longestStepLine } from "./report.js";
-import { TOKEN_TYPES, buildLineIndex, encodeTokens, offsetAt, rangesIntersect, toRange, toCodeActions, toLspChanges, toDiagnostic, toHiddenDiagnostic, toIgnoreAction, } from "./mapping.js";
+import { TOKEN_TYPES, buildLineIndex, encodeTokens, offsetAt, rangesIntersect, toCodeActions, toLspChanges, toDiagnostic, toHiddenDiagnostic, toIgnoreAction, } from "./mapping.js";
 import { SCRIPT_GLOB, classifyChange, createErrorGate, isImportableJson } from "./watch.js";
 import { createConfigLocator, folderOf } from "./configs.js";
 /** The wait after a config load, a watched-file change or a closed document, before a full pass. */
@@ -89,7 +90,7 @@ function describe(error) {
  * Wires the stateward language server to `connection`. The caller starts listening. The returned
  * function stops the server's timers (also done on shutdown); call it before disposing the connection.
  */
-export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (project) => defaultCacheDir(project, process.env), saveMs = DISK_SAVE_MS, } = {}) {
+export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (project) => defaultCacheDir(project, process.env), saveMs = DISK_SAVE_MS, fastMs = FAST_MS, fullMs = FULL_MS, } = {}) {
     const documents = new TextDocuments(TextDocument);
     /** The workspace folders; undefined until the client has initialized. */
     let folders = [];
@@ -97,6 +98,8 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
     let watchScripts = false;
     /** The client can be told to ask for inline hints again (after a check, a settings change). */
     let refreshHints = false;
+    /** The client can be told to ask for code lenses again (after a full pass). */
+    let refreshLenses = false;
     /** The client answers `workspace/configuration`. */
     let canPullSettings = false;
     /** The client lets the server ask to be told when settings change. */
@@ -114,6 +117,20 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         .all()
         .filter((document) => isTypeScriptFile(document.uri))
         .map((document) => [toTypeScriptPath(fileURLToPath(document.uri)), document.version]));
+    /**
+     * The version each open file document had when it was opened, by path (`toTypeScriptPath`): one
+     * still at that version holds the text it was opened with, so its fast pass may take its results
+     * from the cache.
+     */
+    const versionsAtOpen = new Map();
+    /** The files of `files` whose document is unedited since it was opened. */
+    const uneditedSinceOpen = (files) => {
+        const now = openVersions();
+        return files.filter((file) => {
+            const version = now.get(toTypeScriptPath(file));
+            return version !== undefined && version === versionsAtOpen.get(toTypeScriptPath(file));
+        });
+    };
     /** The engine of the config `file` belongs to, if it runs. */
     const engineOf = (file) => {
         const configFile = locator.configOf(file);
@@ -134,16 +151,18 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         const folder = folderOf(engine.configFile, folders) ?? engine.cwd;
         return ` (${displayPath(folder, engine.configFile)})`;
     };
+    /** A file's text on disk; empty for a file a fix creates (it does not exist yet). */
+    const textOnDisk = (file) => (existsSync(file) ? readFileSync(file, "utf8") : "");
     const fileMapper = (open) => {
         const indexes = new Map();
         return {
             uriOf: (file) => pathToFileURL(file).href,
-            textOf: (file) => open.get(file) ?? readFileSync(file, "utf8"),
+            textOf: (file) => open.get(file) ?? textOnDisk(file),
             indexOf: (file) => {
                 const cached = indexes.get(file);
                 if (cached !== undefined)
                     return cached;
-                const index = buildLineIndex(open.get(file) ?? readFileSync(file, "utf8"));
+                const index = buildLineIndex(open.get(file) ?? textOnDisk(file));
                 indexes.set(file, index);
                 return index;
             },
@@ -230,7 +249,10 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
                 return;
             }
             const raw = outcome.result;
-            const pass = layBaseline(state.config, raw, activeRuleIds(state.config, { kind: "configured" }), open);
+            const active = activeRuleIds(state.config, { kind: "configured" });
+            const pass = layBaseline(state.config, raw, active, open);
+            // Before the baseline: an accepted error still leaves its guarantee unproven.
+            engine.proofs = proofView(proveGuarantees(state.checker.guarantees(), raw.findings, active), (file) => state.checker.analysedText(file), engine.cwd);
             const result = pass.fresh;
             const { byUri, sites } = render(pass.findings.filter((finding) => shows(engine, finding.location.file)), pass.hidden.filter((entry) => shows(engine, entry.file)), open, pass.baselined);
             for (const uri of engine.published) {
@@ -248,9 +270,11 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
                 ...statusReport(state.config, result, pass.baselined.size),
                 configFile: engine.configFile,
             });
-            // The hints come from this pass's summaries.
+            // The hints and lenses come from this pass's summaries.
             if (refreshHints)
                 connection.languages.inlayHint.refresh().catch(logUnexpected);
+            if (refreshLenses)
+                connection.sendRequest(CodeLensRefreshRequest.type).catch(logUnexpected);
             saveSoon(engine);
         }
         catch (error) {
@@ -353,7 +377,9 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         if (targets.length === 0)
             return;
         try {
-            const result = editor.checkFiles(targets, open);
+            // A document just opened usually holds the text the saved results were computed on: its
+            // findings then come from the cache, with no type checking (a large app's first findings).
+            const result = editor.checkFiles(targets, open, uneditedSinceOpen(targets));
             for (const file of targets) {
                 const merged = mergeFastPass({ file, fast: result });
                 // Only the file rules ran: the project rules' entries are not matched here.
@@ -414,8 +440,8 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         clearTimeout(engine.fastTimer);
         engine.fastTimer = setTimeout(() => {
             fastPass(engine);
-        }, FAST_MS);
-        scheduleFull(engine, FULL_MS);
+        }, fastMs);
+        scheduleFull(engine, fullMs);
     };
     const clearDiagnostics = (engine) => {
         for (const uri of engine.published)
@@ -524,6 +550,7 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
             disk: undefined,
             saveTimer: undefined,
             savedAt: undefined,
+            proofs: NO_PROOFS,
         };
         engines.set(configFile, engine);
         void loadEngine(engine).catch(logUnexpected);
@@ -590,6 +617,7 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         watchScripts =
             params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
         refreshHints = params.capabilities.workspace?.inlayHint?.refreshSupport === true;
+        refreshLenses = params.capabilities.workspace?.codeLens?.refreshSupport === true;
         canPullSettings = params.capabilities.workspace?.configuration === true;
         watchSettings =
             params.capabilities.workspace?.didChangeConfiguration?.dynamicRegistration === true;
@@ -600,6 +628,7 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
                 textDocumentSync: TextDocumentSyncKind.Incremental,
                 hoverProvider: true,
                 inlayHintProvider: true,
+                codeLensProvider: { resolveProvider: false },
                 codeActionProvider: {
                     codeActionKinds: [CodeActionKind.QuickFix, CodeActionKind.RefactorRewrite, FIX_ALL_KIND],
                 },
@@ -677,6 +706,9 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         }
     });
     documents.onDidOpen((event) => {
+        if (event.document.uri.startsWith("file:")) {
+            versionsAtOpen.set(toTypeScriptPath(fileURLToPath(event.document.uri)), event.document.version);
+        }
         engineForDocument(event.document.uri);
     });
     documents.onDidChangeContent((event) => {
@@ -688,7 +720,7 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
             // An imported JSON file: no findings of its own, but the files that import it change, and
             // only the full pass checks those.
             cancelFull(engine);
-            scheduleFull(engine, FULL_MS);
+            scheduleFull(engine, fullMs);
             return;
         }
         // Fixes hold offsets of the text before this edit: offer none until the fast pass recomputes them.
@@ -703,6 +735,9 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         void runFull(engine).catch(logUnexpected);
     });
     documents.onDidClose((event) => {
+        if (event.document.uri.startsWith("file:")) {
+            versionsAtOpen.delete(toTypeScriptPath(fileURLToPath(event.document.uri)));
+        }
         if (!isSyncedFile(event.document.uri))
             return;
         const engine = engineOf(fileURLToPath(event.document.uri));
@@ -866,10 +901,15 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
             actions.push(...sites
                 .filter((site) => rangesIntersect(site.range, params.range))
                 .flatMap((site) => [...site.actions, ...(site.extra ?? [])])
-                .map((action) => versionedAction(action, versionOf)), ...explainActions(params.context.diagnostics));
+                .map((action) => versionedAction(action, versionOf)), ...explainActions(params.context.diagnostics), ...(guarded(() => {
+                const document = documents.get(params.textDocument.uri);
+                if (engine === undefined || key === undefined || document === undefined)
+                    return [];
+                return proofPathActions(engine.proofs, key, document.getText(), params.range);
+            }) ?? []));
             if (all.count >= 2) {
                 actions.push({
-                    title: "Fix all stateward problems in this file",
+                    title: "Fix all stateward problems in the file",
                     kind: CodeActionKind.QuickFix,
                     ...fixAll,
                 });
@@ -877,7 +917,7 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         }
         if (all.count >= 1 && kindWanted(only, FIX_ALL_KIND)) {
             actions.push({
-                title: "Fix all stateward problems in this file",
+                title: "Fix all stateward problems in the file",
                 kind: FIX_ALL_KIND,
                 ...fixAll,
             });
@@ -903,17 +943,12 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
             return [];
         const index = buildLineIndex(text);
         const found = editor.refactors(file, offsetAt(index, range.start), offsetAt(index, range.end));
+        // The edits may reach other files (a helper file the refactoring writes once).
+        const files = fileMapper(new Map([[file, text]]));
         return found.map((action) => versionedAction({
             title: action.title,
             kind: CodeActionKind.RefactorRewrite,
-            edit: {
-                changes: {
-                    [uri]: action.edits.map((edit) => ({
-                        range: toRange(index, edit.location),
-                        newText: edit.newText,
-                    })),
-                },
-            },
+            edit: { changes: toLspChanges(action.edits, files) },
         }, versionOf));
     }) ?? [];
     /** The checker of the config `uri`'s file belongs to, when it is ready. */
@@ -926,11 +961,34 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         const editor = checkerOf(params.textDocument.uri);
         if (document === undefined || editor === undefined)
             return null;
-        const markdown = guarded(() => editor.hover(fileURLToPath(document.uri), offsetAt(buildLineIndex(document.getText()), params.position)));
+        const markdown = guarded(() => {
+            const file = fileURLToPath(document.uri);
+            const text = document.getText();
+            const offset = offsetAt(buildLineIndex(text), params.position);
+            // From the last full pass's proofs: no type checking for it.
+            const engine = engineOf(file);
+            const guarantee = engine === undefined
+                ? undefined
+                : guaranteeHover(engine.proofs, toTypeScriptPath(file), text, offset);
+            return [...(guarantee === undefined ? [] : [guarantee]), ...editor.hover(file, offset)];
+        });
         if (markdown === undefined || markdown.length === 0)
             return null;
         return { contents: { kind: MarkupKind.Markdown, value: markdown.join("\n\n---\n\n") } };
     });
+    connection.onCodeLens((params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (document === undefined)
+            return [];
+        const lenses = guarded(() => {
+            const file = fileURLToPath(document.uri);
+            const engine = engineOf(file);
+            if (engine === undefined)
+                return [];
+            return guaranteeLenses(engine.proofs, toTypeScriptPath(file), document.getText());
+        });
+        return lenses ?? [];
+    });
     /** Which inline hints the editor's settings turn on (`stateward.inlayHints.*`). */
     let hintSettings = DEFAULT_HINT_SETTINGS;
     connection.languages.inlayHint.on((params) => {
@@ -938,6 +996,11 @@ export function startServer(connection, { idleMs = ENGINE_IDLE_MS, cacheDir = (p
         const editor = checkerOf(params.textDocument.uri);
         if (document === undefined || editor === undefined)
             return [];
+        // Hints come from a full pass's summaries, and the client is asked again after each one: before
+        // the first, answering would build and bind the programs ahead of the open file's findings.
+        const engine = guarded(() => engineOf(fileURLToPath(document.uri)));
+        if (refreshHints && engine?.firstFullDone !== true)
+            return [];
         const hints = guarded(() => {
             const index = buildLineIndex(document.getText());
             const found = editor.inlayHints(fileURLToPath(document.uri), (kind) => hintEnabled(hintSettings, kind));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stateward/language-server",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "The stateward language server: exclusive states and predictable code paths in any editor that speaks LSP, with findings, quick fixes and hints.",
   "license": "MIT",
   "repository": {
@@ -41,12 +41,13 @@
   "dependencies": {
     "vscode-languageserver": "^11.0.0",
     "vscode-languageserver-textdocument": "^1.0.16",
-    "@stateward/core": "1.0.1"
+    "@stateward/core": "1.1.0"
   },
   "devDependencies": {
     "@types/react": "^19.3.0",
     "react": "^19.3.1",
     "vscode-jsonrpc": "10.0.0",
-    "@stateward/plugin-react-context": "1.0.1"
+    "@stateward/plugin-ownership": "1.1.0",
+    "@stateward/plugin-react-context": "1.1.0"
   }
 }