lean4monaco 1.1.11 → 1.1.14

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export * from './leanmonaco';
 export { RpcSessionAtPos } from './vscode-lean4/vscode-lean4/src/infoview';
 export { DocumentPosition } from './vscode-lean4/lean4-infoview/src/infoview/util';
 export { LeanClient } from './vscode-lean4/vscode-lean4/src/leanclient';
+export { WithRpcSessions } from './vscode-lean4/lean4-infoview/src/infoview/rpcSessions';
+export { RpcSessions } from './vscode-lean4/lean4-infoview-api/src/rpcSessions';

package/dist/index.js

@@ -3,3 +3,5 @@ export * from './leanmonaco';
 export { RpcSessionAtPos } from './vscode-lean4/vscode-lean4/src/infoview';
 export { DocumentPosition } from './vscode-lean4/lean4-infoview/src/infoview/util';
 export { LeanClient } from './vscode-lean4/vscode-lean4/src/leanclient';
+export { WithRpcSessions } from './vscode-lean4/lean4-infoview/src/infoview/rpcSessions';
+export { RpcSessions } from './vscode-lean4/lean4-infoview-api/src/rpcSessions';

package/dist/vscode-lean4/lean4-infoview/src/infoview/rpcSessions.d.ts

@@ -0,0 +1,21 @@
+import { RpcSessionAtPos } from '@leanprover/infoview-api';
+import * as React from 'react';
+import type { TextDocumentPositionParams } from 'vscode-languageserver-protocol';
+import { DocumentPosition } from './util';
+/**
+ * Provides a {@link RpcSessionsContext} to the children.
+ * The {@link RpcSessions} object stored there manages RPC sessions in the Lean server.
+ */
+export declare function WithRpcSessions({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useRpcSessionAtTdpp(pos: TextDocumentPositionParams): RpcSessionAtPos;
+export declare function useRpcSessionAtPos(pos: DocumentPosition): RpcSessionAtPos;
+/** @deprecated use {@link useRpcSession} instead */
+export declare const RpcContext: React.Context<RpcSessionAtPos>;
+/**
+ * Retrieve an RPC session at {@link EnvPosContext},
+ * if the context is set.
+ * Otherwise return a dummy session that throws on any RPC call.
+ */
+export declare function useRpcSession(): RpcSessionAtPos;

package/dist/vscode-lean4/lean4-infoview/src/infoview/rpcSessions.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RpcSessions } from '@leanprover/infoview-api';
+import * as React from 'react';
+import { EditorContext, EnvPosContext } from './contexts';
+import { DocumentPosition, useClientNotificationEffect, useEvent } from './util';
+const RpcSessionsContext = React.createContext(undefined);
+/**
+ * Provides a {@link RpcSessionsContext} to the children.
+ * The {@link RpcSessions} object stored there manages RPC sessions in the Lean server.
+ */
+export function WithRpcSessions({ children }) {
+    const ec = React.useContext(EditorContext);
+    const [sessions] = React.useState(() => new RpcSessions({
+        createRpcSession: (uri) => ec.api.createRpcSession(uri),
+        closeRpcSession: (uri) => ec.api.closeRpcSession(uri),
+        call: (params) => ec.api.sendClientRequest(params.textDocument.uri, '$/lean/rpc/call', params),
+        release: (params) => void ec.api.sendClientNotification(params.uri, '$/lean/rpc/release', params),
+    }));
+    React.useEffect(() => {
+        // Clean up the sessions on unmount
+        return () => sessions.dispose();
+    }, [sessions]);
+    useClientNotificationEffect('textDocument/didClose', (params) => {
+        sessions.closeSessionForFile(params.textDocument.uri);
+    }, [sessions]);
+    // TODO: only restart files for the server that stopped
+    useEvent(ec.events.serverRestarted, () => sessions.closeAllSessions());
+    return _jsx(RpcSessionsContext.Provider, { value: sessions, children: children });
+}
+const noCtxRpcSession = {
+    call: async () => {
+        throw new Error('no RPC context set');
+    },
+};
+const noPosRpcSession = {
+    call: async () => {
+        throw new Error('no position context set');
+    },
+};
+export function useRpcSessionAtTdpp(pos) {
+    return React.useContext(RpcSessionsContext)?.connect(pos) || noCtxRpcSession;
+}
+export function useRpcSessionAtPos(pos) {
+    return useRpcSessionAtTdpp(DocumentPosition.toTdpp(pos));
+}
+/** @deprecated use {@link useRpcSession} instead */
+/*
+ * NOTE(WN): This context cannot be removed as of 2024-05-27 since existing widgets use it.
+ * For backwards compatibility, it must be set to the correct value by infoview code.
+ * A future major release of @leanprover/infoview could remove this context
+ * after it has been deprecated for a sufficiently long time.
+ */
+export const RpcContext = React.createContext(noCtxRpcSession);
+/**
+ * Retrieve an RPC session at {@link EnvPosContext},
+ * if the context is set.
+ * Otherwise return a dummy session that throws on any RPC call.
+ */
+export function useRpcSession() {
+    const pos = React.useContext(EnvPosContext);
+    const rsc = React.useContext(RpcSessionsContext);
+    if (!pos)
+        return noPosRpcSession;
+    if (!rsc)
+        return noCtxRpcSession;
+    return rsc.connect(DocumentPosition.toTdpp(pos));
+}

package/dist/vscode-lean4/lean4-infoview-api/src/lspTypes.d.ts

@@ -0,0 +1,98 @@
+import type { Diagnostic, DocumentUri, integer, Range, TextDocumentPositionParams, VersionedTextDocumentIdentifier } from 'vscode-languageserver-protocol';
+export declare enum LeanTag {
+    UnsolvedGoals = 1,// introduced in 2025-03-05
+    GoalsAccomplished = 2
+}
+/** Used in place of {@link Diagnostic} within `textDocument/publishDiagnostics`. */
+export interface LeanDiagnostic extends Diagnostic {
+    fullRange?: Range;
+    isSilent?: boolean;
+    leanTags?: LeanTag[];
+}
+export interface LeanPublishDiagnosticsParams {
+    uri: DocumentUri;
+    version?: integer;
+    diagnostics: LeanDiagnostic[];
+}
+export interface PlainGoal {
+    rendered: string;
+    goals: string[];
+}
+export interface PlainTermGoal {
+    goal: string;
+    range: Range;
+}
+export declare enum LeanFileProgressKind {
+    Processing = 1,
+    FatalError = 2
+}
+export interface LeanFileProgressProcessingInfo {
+    /** Range for which the processing info was reported. */
+    range: Range;
+    /** Kind of progress that was reported. */
+    kind?: LeanFileProgressKind;
+}
+export interface LeanFileProgressParams {
+    /** The text document to which this progress notification applies. */
+    textDocument: VersionedTextDocumentIdentifier;
+    /**
+     * Array containing the parts of the file which are still being processed.
+     * The array should be empty if and only if the server is finished processing.
+     */
+    processing: LeanFileProgressProcessingInfo[];
+}
+declare const tag: unique symbol;
+/** An RPC pointer is a reference to an object on the lean server.
+ * An example where you need this is passing the Environment object,
+ * which we need to be able to reference but which would be too large to
+ * send over directly.
+ */
+export type RpcPtr<T> = {
+    readonly [tag]: T;
+    p: string;
+};
+export declare namespace RpcPtr {
+    function copy<T>(p: RpcPtr<T>): RpcPtr<T>;
+    /** Turns a reference into a unique string. Useful for React `key`s. */
+    function toKey(p: RpcPtr<any>): string;
+}
+export interface RpcConnectParams {
+    uri: DocumentUri;
+}
+export interface RpcConnected {
+    sessionId: string;
+}
+export interface RpcKeepAliveParams {
+    uri: DocumentUri;
+    sessionId: string;
+}
+export interface RpcCallParams extends TextDocumentPositionParams {
+    sessionId: string;
+    method: string;
+    params: any;
+}
+export interface RpcReleaseParams {
+    uri: DocumentUri;
+    sessionId: string;
+    refs: RpcPtr<any>[];
+}
+export declare enum RpcErrorCode {
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603,
+    ServerNotInitialized = -32002,
+    UnknownErrorCode = -32001,
+    ContentModified = -32801,
+    RequestCancelled = -32800,
+    RpcNeedsReconnect = -32900,
+    WorkerExited = -32901,
+    WorkerCrashed = -32902
+}
+export interface RpcError {
+    code: RpcErrorCode;
+    message: string;
+}
+export declare function isRpcError(x: any): x is RpcError;
+export {};

package/dist/vscode-lean4/lean4-infoview-api/src/lspTypes.js

@@ -0,0 +1,44 @@
+// Lean 4 extensions to LSP.
+export var LeanTag;
+(function (LeanTag) {
+    LeanTag[LeanTag["UnsolvedGoals"] = 1] = "UnsolvedGoals";
+    LeanTag[LeanTag["GoalsAccomplished"] = 2] = "GoalsAccomplished";
+})(LeanTag || (LeanTag = {}));
+// Seems to be an eslint bug:
+// eslint-disable-next-line no-shadow
+export var LeanFileProgressKind;
+(function (LeanFileProgressKind) {
+    LeanFileProgressKind[LeanFileProgressKind["Processing"] = 1] = "Processing";
+    LeanFileProgressKind[LeanFileProgressKind["FatalError"] = 2] = "FatalError";
+})(LeanFileProgressKind || (LeanFileProgressKind = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var RpcPtr;
+(function (RpcPtr) {
+    function copy(p) {
+        return { p: p.p };
+    }
+    RpcPtr.copy = copy;
+    /** Turns a reference into a unique string. Useful for React `key`s. */
+    function toKey(p) {
+        return p.p;
+    }
+    RpcPtr.toKey = toKey;
+})(RpcPtr || (RpcPtr = {}));
+export var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode[RpcErrorCode["ParseError"] = -32700] = "ParseError";
+    RpcErrorCode[RpcErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    RpcErrorCode[RpcErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    RpcErrorCode[RpcErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    RpcErrorCode[RpcErrorCode["InternalError"] = -32603] = "InternalError";
+    RpcErrorCode[RpcErrorCode["ServerNotInitialized"] = -32002] = "ServerNotInitialized";
+    RpcErrorCode[RpcErrorCode["UnknownErrorCode"] = -32001] = "UnknownErrorCode";
+    RpcErrorCode[RpcErrorCode["ContentModified"] = -32801] = "ContentModified";
+    RpcErrorCode[RpcErrorCode["RequestCancelled"] = -32800] = "RequestCancelled";
+    RpcErrorCode[RpcErrorCode["RpcNeedsReconnect"] = -32900] = "RpcNeedsReconnect";
+    RpcErrorCode[RpcErrorCode["WorkerExited"] = -32901] = "WorkerExited";
+    RpcErrorCode[RpcErrorCode["WorkerCrashed"] = -32902] = "WorkerCrashed";
+})(RpcErrorCode || (RpcErrorCode = {}));
+export function isRpcError(x) {
+    return !!(x?.code && x?.message);
+}

package/dist/vscode-lean4/lean4-infoview-api/src/rpcSessions.d.ts

@@ -0,0 +1,149 @@
+import type { DocumentUri, Position, TextDocumentPositionParams } from 'vscode-languageserver-protocol';
+import { RpcCallParams, RpcPtr, RpcReleaseParams } from './lspTypes';
+/**
+ * Abstraction of the functionality needed
+ * to establish RPC sessions in the Lean server
+ * and to make RPC calls.
+ * See the Lean module `Lean.Server.Rpc.Basic`.
+ *
+ * This interface can be implemented both in the infoview
+ * (relaying LSP messages from the webview to the extension),
+ * as well as in the extension itself
+ * (directly sending LSP messages via the
+ * `vscode-languageserver-node` library (TODO)).
+ */
+export interface RpcServerIface {
+    /**
+     * Creates an RPC session for the given URI and returns the session ID.
+     * The implementation of {@link RpcServerIface} takes care
+     * to send any required keepalive notifications.
+     */
+    createRpcSession(uri: DocumentUri): Promise<string>;
+    /** Closes an RPC session created with {@link createRpcSession}. */
+    closeRpcSession(sessionId: string): void;
+    /** Sends an RPC call to the Lean server. */
+    call(request: RpcCallParams): Promise<any>;
+    /** Sends an RPC reference release notification to the server. */
+    release(request: RpcReleaseParams): void;
+}
+/**
+ * An {@link RpcSessionForFile} with `call` specialized to a specific position `p`.
+ *
+ * Morally, this bundles an RPC session
+ * with the set of RPC methods
+ * available at the position `p`.
+ *
+ * It is okay to mix RPC references
+ * between different {@link RpcSessionAtPos} objects
+ * created from the same {@link RpcSessionForFile}.
+ */
+export interface RpcSessionAtPos {
+    /**
+     * Invoke an RPC method in the Lean server.
+     *
+     * @param method fully qualified name of the method to call.
+     * @param params arguments to the invoked method.
+     * @returns a promise that resolves to the returned value, or an error in case the call fails.
+     */
+    call<T, S>(method: string, params: T): Promise<S>;
+}
+/**
+ * Manages a connection to an RPC session
+ * that has been opened for a given file
+ * (in the Lean server's worker process for that file).
+ *
+ * An RPC session keeps track of a set of RPC references
+ * that are mutually intelligible,
+ * in the sense that any RPC method can be called
+ * with any number of references from this set.
+ * On the other hand,
+ * it is not possible to mix RPC references
+ * between different sessions.
+ */
+declare class RpcSessionForFile {
+    uri: DocumentUri;
+    sessions: RpcSessions;
+    sessionId: Promise<string>;
+    /**
+     * If present, stores a fatal exception
+     * indicating that the RPC session can no longer be used.
+     * For example: the worker crashed
+     */
+    failed?: any;
+    refsToRelease: RpcPtr<any>[];
+    finalizers: FinalizationRegistry<RpcPtr<any>>;
+    /** Essentially a cache for {@link at}. See {@link at} for why we need this. */
+    sessionsAtPos: Map<string, RpcSessionAtPos>;
+    constructor(uri: DocumentUri, sessions: RpcSessions);
+    releaseNow(): Promise<void>;
+    /**
+     * Traverses an object received from the RPC server
+     * and registers all contained references
+     * for future garbage collection.
+     *
+     * The function implements a form of "conservative garbage collection"
+     * where it treats any subobject `{'p': v}` as a potential RPC reference.
+     * Therefore `p` should not be used as a field name on the Lean side
+     * to prevent false positives.
+     *
+     * It is unclear if the false positives will become a big issue.
+     * Earlier versions of the extension
+     * had manually written registration functions for every type,
+     * but those are a lot of boilerplate.
+     * If we change back to that approach,
+     * we should generate them automatically.
+     */
+    registerRefs(o: any): void;
+    private failWithoutClosing;
+    fail(reason: any): void;
+    /**
+     * Invoke an RPC method in the Lean server.
+     *
+     * To compute the set of RPC methods that can be called,
+     * the server finds the environment `e` at the source code location `this.uri:position`.
+     * The callable methods are then all the builtin ones,
+     * and all constants in `e` marked with `@[server_rpc_method]`
+     * (i.e., the `@[server_rpc_method]` declarations made above `this.uri:position`).
+     *
+     * @param position within the file identified by {@link uri}, used to resolve the set of available RPC methods.
+     * @param method fully qualified name of the method to call.
+     * @param params arguments to the invoked method.
+     * @returns a promise that resolves to the returned value, or to an error in case the call fails.
+     */
+    call(position: Position, method: string, params: any): Promise<any>;
+    /**
+     * Returns this session with {@link call} specialized to `position` within the file.
+     * This is guaranteed to return the same (by reference) object
+     * if called multiple times with the same (by deep comparison) position,
+     * on the same {@link RpcSessionForFile}.
+     * It can therefore be used as a React dep.
+     */
+    at(position: Position): RpcSessionAtPos;
+}
+/** Manages RPC sessions for multiple files. */
+export declare class RpcSessions {
+    iface: RpcServerIface;
+    /**
+     * Contains the active {@link RpcSessionForFile} objects.
+     * Once an {@link RpcSessionForFile} is set to failed (e.g. due to a server crash),
+     * it is removed from this map.
+     * The {@link connect} method will then automatically reconnect
+     * the next time it is called.
+     */
+    sessions: Map<DocumentUri, RpcSessionForFile>;
+    constructor(iface: RpcServerIface);
+    private connectCore;
+    /**
+     * Returns an {@link RpcSessionAtPos} for the given document and position.
+     * Calling {@link connect} multiple times will return the same
+     * session (with the same session ID).
+     * A new session is only created if a fatal error occurs (the worker crashes)
+     * or the session is closed manually (the file is closed).
+     */
+    connect(pos: TextDocumentPositionParams): RpcSessionAtPos;
+    /** Closes the session for the given URI. */
+    closeSessionForFile(uri: DocumentUri): void;
+    closeAllSessions(): void;
+    dispose(): void;
+}
+export {};

package/dist/vscode-lean4/lean4-infoview-api/src/rpcSessions.js

@@ -0,0 +1,215 @@
+import { RpcErrorCode, RpcPtr } from './lspTypes';
+/**
+ * Manages a connection to an RPC session
+ * that has been opened for a given file
+ * (in the Lean server's worker process for that file).
+ *
+ * An RPC session keeps track of a set of RPC references
+ * that are mutually intelligible,
+ * in the sense that any RPC method can be called
+ * with any number of references from this set.
+ * On the other hand,
+ * it is not possible to mix RPC references
+ * between different sessions.
+ */
+class RpcSessionForFile {
+    uri;
+    sessions;
+    sessionId;
+    /**
+     * If present, stores a fatal exception
+     * indicating that the RPC session can no longer be used.
+     * For example: the worker crashed
+     */
+    failed;
+    refsToRelease = [];
+    finalizers;
+    /** Essentially a cache for {@link at}. See {@link at} for why we need this. */
+    sessionsAtPos = new Map();
+    constructor(uri, sessions) {
+        this.uri = uri;
+        this.sessions = sessions;
+        this.sessionId = (async () => {
+            try {
+                return await sessions.iface.createRpcSession(uri);
+            }
+            catch (ex) {
+                this.failWithoutClosing(ex);
+                throw ex;
+            }
+        })();
+        this.sessionId.catch(() => { }); // silence uncaught exception warning
+        // Here we hook into the JS GC and send release-reference notifications
+        // whenever the GC finalizes a number of `RpcPtr`s. Requires ES2021.
+        let releaseTimeout;
+        this.finalizers = new FinalizationRegistry(ptr => {
+            if (this.failed)
+                return;
+            this.refsToRelease.push(ptr);
+            // We release eagerly instead of delaying when this many refs become garbage
+            const maxBatchSize = 100;
+            if (this.refsToRelease.length > maxBatchSize) {
+                void this.releaseNow();
+                clearTimeout(releaseTimeout);
+                releaseTimeout = undefined;
+            }
+            else if (releaseTimeout === undefined) {
+                releaseTimeout = window.setTimeout(() => {
+                    void this.releaseNow();
+                    releaseTimeout = undefined;
+                }, 100);
+            }
+        });
+    }
+    async releaseNow() {
+        const sessionId = await this.sessionId;
+        if (this.failed || this.refsToRelease.length === 0)
+            return;
+        this.sessions.iface.release({
+            uri: this.uri,
+            sessionId,
+            refs: this.refsToRelease,
+        });
+        this.refsToRelease = [];
+    }
+    /**
+     * Traverses an object received from the RPC server
+     * and registers all contained references
+     * for future garbage collection.
+     *
+     * The function implements a form of "conservative garbage collection"
+     * where it treats any subobject `{'p': v}` as a potential RPC reference.
+     * Therefore `p` should not be used as a field name on the Lean side
+     * to prevent false positives.
+     *
+     * It is unclear if the false positives will become a big issue.
+     * Earlier versions of the extension
+     * had manually written registration functions for every type,
+     * but those are a lot of boilerplate.
+     * If we change back to that approach,
+     * we should generate them automatically.
+     */
+    registerRefs(o) {
+        if (o instanceof Object) {
+            if (Object.keys(o).length === 1 && 'p' in o && typeof o.p !== 'object') {
+                this.finalizers.register(o, RpcPtr.copy(o));
+            }
+            else {
+                for (const v of Object.values(o))
+                    this.registerRefs(v);
+            }
+        }
+        else if (o instanceof Array) {
+            for (const e of o)
+                this.registerRefs(e);
+        }
+    }
+    failWithoutClosing(reason) {
+        this.failed = reason;
+        // NOTE(WN): the sessions map is keyed by URI rather than ID and by the time this
+        // function executes, a new session for the same file may already have been added.
+        // So we should only delete the stored session if it's still this one.
+        if (this.sessions.sessions.get(this.uri) === this) {
+            this.sessions.sessions.delete(this.uri);
+        }
+    }
+    fail(reason) {
+        this.failWithoutClosing(reason);
+        void this.sessionId.then(id => this.sessions.iface.closeRpcSession(id));
+    }
+    /**
+     * Invoke an RPC method in the Lean server.
+     *
+     * To compute the set of RPC methods that can be called,
+     * the server finds the environment `e` at the source code location `this.uri:position`.
+     * The callable methods are then all the builtin ones,
+     * and all constants in `e` marked with `@[server_rpc_method]`
+     * (i.e., the `@[server_rpc_method]` declarations made above `this.uri:position`).
+     *
+     * @param position within the file identified by {@link uri}, used to resolve the set of available RPC methods.
+     * @param method fully qualified name of the method to call.
+     * @param params arguments to the invoked method.
+     * @returns a promise that resolves to the returned value, or to an error in case the call fails.
+     */
+    async call(position, method, params) {
+        const sessionId = await this.sessionId;
+        if (this.failed)
+            throw this.failed;
+        const tdpp = { position, textDocument: { uri: this.uri } };
+        try {
+            const result = await this.sessions.iface.call({ method, params, sessionId, ...tdpp });
+            this.registerRefs(result);
+            // HACK: most of our types are `T | undefined` so try to return something matching that interface
+            if (result === null)
+                return undefined;
+            return result;
+        }
+        catch (ex) {
+            if (ex?.code === RpcErrorCode.WorkerCrashed ||
+                ex?.code === RpcErrorCode.WorkerExited ||
+                ex?.code === RpcErrorCode.RpcNeedsReconnect) {
+                this.fail(ex);
+            }
+            throw ex;
+        }
+    }
+    /**
+     * Returns this session with {@link call} specialized to `position` within the file.
+     * This is guaranteed to return the same (by reference) object
+     * if called multiple times with the same (by deep comparison) position,
+     * on the same {@link RpcSessionForFile}.
+     * It can therefore be used as a React dep.
+     */
+    at(position) {
+        // As JS tradition dictates, we use stringification for deep comparison of `Position`s in a `Map`.
+        const posStr = `${position.line}:${position.character}`;
+        if (this.sessionsAtPos.has(posStr))
+            return this.sessionsAtPos.get(posStr);
+        const atPos = { call: (method, params) => this.call(position, method, params) };
+        this.sessionsAtPos.set(posStr, atPos);
+        return atPos;
+    }
+}
+/** Manages RPC sessions for multiple files. */
+export class RpcSessions {
+    iface;
+    /**
+     * Contains the active {@link RpcSessionForFile} objects.
+     * Once an {@link RpcSessionForFile} is set to failed (e.g. due to a server crash),
+     * it is removed from this map.
+     * The {@link connect} method will then automatically reconnect
+     * the next time it is called.
+     */
+    sessions = new Map();
+    constructor(iface) {
+        this.iface = iface;
+    }
+    connectCore(uri) {
+        if (this.sessions.has(uri))
+            return this.sessions.get(uri);
+        const sess = new RpcSessionForFile(uri, this);
+        this.sessions.set(uri, sess);
+        return sess;
+    }
+    /**
+     * Returns an {@link RpcSessionAtPos} for the given document and position.
+     * Calling {@link connect} multiple times will return the same
+     * session (with the same session ID).
+     * A new session is only created if a fatal error occurs (the worker crashes)
+     * or the session is closed manually (the file is closed).
+     */
+    connect(pos) {
+        return this.connectCore(pos.textDocument.uri).at(pos.position);
+    }
+    /** Closes the session for the given URI. */
+    closeSessionForFile(uri) {
+        void this.sessions.get(uri)?.fail('file closed');
+    }
+    closeAllSessions() {
+        for (const k of [...this.sessions.keys()])
+            this.closeSessionForFile(k);
+    }
+    dispose() {
+        this.closeAllSessions();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lean4monaco",
-  "version": "1.1.11",
+  "version": "1.1.14",
   "description": "Monaco Editor support for the Lean 4 theorem prover.",
   "keywords": [
     "lean",