zidane-ui 9.0.4 → 9.1.3

package/dist/extensions/testing/contract.js

@@ -0,0 +1,407 @@
+import { ExtensionsHostError } from "../headless/host.js";
+import { EXTENSION_TOKENS } from "../headless/wire.js";
+import { afterEach, describe, expect, it, vi } from "vitest";
+//#region src/extensions/testing/contract.ts
+/**
+* What every `ExtensionsHost` implementation does alike, as a vitest suite: the in-memory fixture
+* (`createFixtureExtensionsHost`), the desktop app's over IPC, `adapters/`' over zidane-server.
+*
+* An implementation's test calls {@link describeExtensionsHostContract} with a harness factory. The
+* contract hands it an {@link ExtensionsHostContractBackend}: the items there at the start and what
+* the extensions behind the host answer. The harness builds the host over a backend that does that
+* (a fixture, a fake server, a mocked IPC bridge) and returns an {@link ExtensionsHostContractControl}
+* that drives the backend from outside: items coming and going, dialogs and `ctx.ui` calls routed
+* to this client, another client writing a store. The capabilities list says which optional members
+* the host offers: the suite checks the others are undefined and skips what needs them.
+*
+*   describeExtensionsHostContract('createServerExtensionsHost', (backend) => ({ host, control }), [
+*     'invoke', 'dialogs', 'rpc',
+*   ]);
+*/
+const MEMBERS = [
+	"invoke",
+	"dialogs",
+	"effects",
+	"rpc",
+	"storage",
+	"settings",
+	"integrations",
+	"commands"
+];
+/** The store the storage tests read and write. */
+const CONTRACT_STORE = {
+	extensionId: "demo",
+	name: "counter",
+	scope: "user"
+};
+/** The API key the backend's integrations accept. */
+const CONTRACT_GOOD_KEY = "good-key";
+const GITHUB_WORK = {
+	methodId: "oauth",
+	account: "work",
+	label: "Work",
+	isDefault: true,
+	connectedAt: 1
+};
+const STATUS = {
+	key: "slot:demo:1",
+	token: "slot",
+	extension: "demo",
+	item: {
+		at: "app.statusbar",
+		text: "Synced",
+		order: 100
+	}
+};
+const PANEL = {
+	key: "panel:demo:2",
+	token: "panel",
+	extension: "demo",
+	item: {
+		id: "demo/board",
+		label: "Board",
+		surfaces: ["side"],
+		live: false,
+		actions: true
+	}
+};
+const SETTINGS = {
+	schema: {
+		categories: [],
+		items: [{
+			key: "enabled",
+			label: "Enabled",
+			type: "boolean",
+			default: true,
+			category: "demo",
+			extension: "demo"
+		}, {
+			key: "token",
+			label: "Token",
+			type: "string",
+			default: "",
+			category: "demo",
+			extension: "demo"
+		}]
+	},
+	actions: [],
+	values: { demo: { enabled: false } },
+	locked: ["demo:token"]
+};
+function backend() {
+	return {
+		items: [STATUS, PANEL],
+		callbacks: {
+			"panel.load": ({ panelId }) => ({ sections: [{ items: [{
+				kind: "markdown",
+				text: `hello from ${panelId}`
+			}] }] }),
+			"panel.action": () => {
+				throw new Error("the board is read-only");
+			}
+		},
+		rpc: { "demo.counter": {
+			add: (input) => input.n + 1,
+			fail: () => {
+				throw {
+					type: "demo.too-big",
+					message: "too big",
+					data: { max: 3 }
+				};
+			}
+		} },
+		storeValue: { count: 1 },
+		settings: SETTINGS,
+		integrations: [{
+			id: "linear",
+			name: "Linear",
+			extensionId: "demo",
+			methods: [{
+				type: "apiKey",
+				id: "key",
+				label: "API key"
+			}]
+		}, {
+			id: "github",
+			name: "GitHub",
+			extensionId: "demo",
+			methods: [{
+				type: "oauth",
+				id: "oauth",
+				label: "Sign in"
+			}],
+			connection: GITHUB_WORK,
+			connections: [GITHUB_WORK, {
+				methodId: "oauth",
+				account: "home",
+				connectedAt: 2
+			}]
+		}],
+		commands: [{
+			id: "demo.sync",
+			title: "Sync now",
+			extensionId: "demo"
+		}]
+	};
+}
+async function rejection(promise) {
+	try {
+		await promise;
+	} catch (err) {
+		expect(err).toBeInstanceOf(ExtensionsHostError);
+		return err;
+	}
+	throw new Error("expected a rejection");
+}
+/**
+* Declares the shared `ExtensionsHost` suite for one implementation.
+*
+* @param name - The implementation's name, shown in the suite title.
+* @param makeHarness - Builds a fresh host over a backend that does what it is given, once per test.
+* @param capabilities - The optional members the host offers. Every other optional member must be undefined.
+*/
+function describeExtensionsHostContract(name, makeHarness, capabilities) {
+	const has = (c) => capabilities.includes(c);
+	describe(`ExtensionsHost contract: ${name}`, () => {
+		const cleanup = [];
+		afterEach(() => {
+			for (const done of cleanup.splice(0).reverse()) done();
+		});
+		const setup = async () => {
+			const harness = await makeHarness(backend());
+			cleanup.push(() => harness.dispose?.());
+			return harness;
+		};
+		it("offers exactly its capabilities; the members it leaves out are undefined", async () => {
+			const { host } = await setup();
+			for (const token of EXTENSION_TOKENS) expect(typeof host.items[token].get, token).toBe("function");
+			for (const member of MEMBERS) expect(host[member] === void 0, member).toBe(!has(member));
+			if (host.settings) expect(typeof host.settings.set).toBe(has("settings.set") ? "function" : "undefined");
+		});
+		it("lists the items per token, and follows them as they come, change and go", async () => {
+			const { host, control } = await setup();
+			expect(host.items.slot.get()).toEqual([STATUS]);
+			expect(host.items.panel.get()).toEqual([PANEL]);
+			const heard = vi.fn();
+			cleanup.push(host.items.slot.subscribe(heard));
+			const changed = {
+				...STATUS,
+				item: {
+					...STATUS.item,
+					text: "Syncing",
+					loader: true
+				}
+			};
+			control.upsert(changed);
+			await vi.waitFor(() => expect(host.items.slot.get()).toEqual([changed]));
+			expect(heard).toHaveBeenCalled();
+			control.remove(STATUS.key);
+			await vi.waitFor(() => expect(host.items.slot.get()).toEqual([]));
+			expect(host.items.panel.get()).toEqual([PANEL]);
+		});
+		it.skipIf(!has("invoke"))("invokes callbacks, and words a failing one as failed", async () => {
+			const { host } = await setup();
+			const content = await host.invoke("panel.load", {
+				panelId: "demo/board",
+				cwd: "/repo"
+			});
+			expect(JSON.stringify(content)).toContain("hello from demo/board");
+			const err = await rejection(host.invoke("panel.action", {
+				panelId: "demo/board",
+				actionId: "x",
+				cwd: "/repo"
+			}));
+			expect(err.error).toEqual({
+				code: "failed",
+				message: "the board is read-only"
+			});
+		});
+		it.skipIf(!has("dialogs"))("shows a routed dialog until answered, and toasts beside it", async () => {
+			const { host, control } = await setup();
+			expect(host.dialogs.current.get()).toBeNull();
+			const answer = control.dialog({
+				kind: "confirm",
+				title: "Delete it?"
+			}, {
+				extensionId: "demo",
+				sessionId: "s1"
+			});
+			await vi.waitFor(() => expect(host.dialogs.current.get()?.request).toEqual({
+				kind: "confirm",
+				title: "Delete it?"
+			}));
+			const toast = control.dialog({
+				kind: "toast",
+				text: "Saved",
+				tone: "success"
+			}, { extensionId: "demo" });
+			await vi.waitFor(() => expect(host.dialogs.toasts.get().map((d) => d.request)).toEqual([{
+				kind: "toast",
+				text: "Saved",
+				tone: "success"
+			}]));
+			const dialog = host.dialogs.current.get();
+			expect(dialog.extensionId).toBe("demo");
+			await host.dialogs.answer(dialog.id, true);
+			await expect(answer).resolves.toBe(true);
+			await vi.waitFor(() => expect(host.dialogs.current.get()).toBeNull());
+			await host.dialogs.answer(host.dialogs.toasts.get()[0].id, void 0);
+			await expect(toast).resolves.toBeUndefined();
+		});
+		it.skipIf(!has("dialogs"))("drops a dialog the extension withdraws", async () => {
+			const { host, control } = await setup();
+			const abort = new AbortController();
+			const answer = control.dialog({
+				kind: "prompt",
+				title: "Name?"
+			}, {
+				extensionId: "demo",
+				signal: abort.signal
+			});
+			await vi.waitFor(() => expect(host.dialogs.current.get()).not.toBeNull());
+			abort.abort(/* @__PURE__ */ new Error("timed out"));
+			await expect(answer).rejects.toThrow();
+			await vi.waitFor(() => expect(host.dialogs.current.get()).toBeNull());
+		});
+		it.skipIf(!has("effects"))("hands ctx.ui calls to the app and answers with what it settled", async () => {
+			const { host, control } = await setup();
+			const seen = [];
+			cleanup.push(host.effects.subscribe((request) => {
+				seen.push(request);
+				host.effects.settle(request.id, request.effect.kind === "panel-state" ? ["demo/board"] : true);
+			}));
+			await expect(control.effect({
+				kind: "panel",
+				action: "open",
+				panelId: "demo/board"
+			})).resolves.toBe(true);
+			await expect(control.effect({ kind: "panel-state" })).resolves.toEqual(["demo/board"]);
+			await expect(control.effect({
+				kind: "composer",
+				op: {
+					op: "insert",
+					text: "hi"
+				}
+			})).resolves.toBe(true);
+			expect(seen.map((r) => r.effect.kind)).toEqual([
+				"panel",
+				"panel-state",
+				"composer"
+			]);
+		});
+		it.skipIf(!has("rpc"))("calls RPC methods and rejects with their typed error", async () => {
+			const { host } = await setup();
+			await expect(host.rpc("demo.counter", "add", { n: 1 }, { extensionId: "demo" })).resolves.toBe(2);
+			const err = await rejection(host.rpc("demo.counter", "fail", {}, { extensionId: "demo" }));
+			expect(err.error).toEqual({
+				code: "rpc",
+				type: "demo.too-big",
+				message: "too big",
+				data: { max: 3 }
+			});
+		});
+		it.skipIf(!has("storage"))("reads, writes and follows a store", async () => {
+			const { host, control } = await setup();
+			const store = host.storage.store(CONTRACT_STORE);
+			await vi.waitFor(() => expect(store.get()).toEqual({ count: 1 }));
+			await host.storage.set(CONTRACT_STORE, { count: 2 });
+			await vi.waitFor(() => expect(control.readStore()).toEqual({ count: 2 }));
+			await vi.waitFor(() => expect(store.get()).toEqual({ count: 2 }));
+			const heard = vi.fn();
+			cleanup.push(store.subscribe(heard));
+			control.writeStore({ count: 5 });
+			await vi.waitFor(() => expect(store.get()).toEqual({ count: 5 }));
+			expect(heard).toHaveBeenCalled();
+		});
+		it.skipIf(!has("settings"))("lists the settings with their locked keys", async () => {
+			const { host } = await setup();
+			await vi.waitFor(() => expect(host.settings.wire.get().schema.items.map((i) => i.key)).toEqual(["enabled", "token"]));
+			expect(host.settings.wire.get().locked).toEqual(["demo:token"]);
+			expect(host.settings.wire.get().values.demo?.enabled).toBe(false);
+		});
+		it.skipIf(!has("settings.set"))("writes a setting, and refuses a locked one", async () => {
+			const { host } = await setup();
+			await host.settings.set("demo", "enabled", true);
+			await vi.waitFor(() => expect(host.settings.wire.get().values.demo?.enabled).toBe(true));
+			const err = await rejection(host.settings.set("demo", "token", "x"));
+			expect(err.error).toMatchObject({
+				code: "refused",
+				reason: "locked"
+			});
+		});
+		it.skipIf(!has("integrations"))("connects and disconnects an integration", async () => {
+			const { host } = await setup();
+			const linear = () => host.integrations.list.get().find((i) => i.id === "linear");
+			await vi.waitFor(() => expect(linear()).toBeDefined());
+			expect(linear().connection).toBeUndefined();
+			const err = await rejection(host.integrations.connect("linear", {
+				methodId: "key",
+				key: "nope"
+			}));
+			expect(err.error).toMatchObject({
+				code: "refused",
+				reason: "invalid"
+			});
+			await host.integrations.connect("linear", {
+				methodId: "key",
+				key: CONTRACT_GOOD_KEY
+			});
+			await vi.waitFor(() => expect(linear().connection).toMatchObject({
+				methodId: "key",
+				account: "demo"
+			}));
+			expect(linear().connections).toEqual([expect.objectContaining({
+				account: "demo",
+				isDefault: true
+			})]);
+			await host.integrations.disconnect("linear");
+			await vi.waitFor(() => expect(linear().connection).toBeUndefined());
+			expect(linear().connections ?? []).toEqual([]);
+		});
+		const accounts = (i) => (i?.connections ?? []).map((c) => [c.account, c.isDefault === true]);
+		it.skipIf(!has("integrations"))("lists an integration's connections, the default first", async () => {
+			const { host } = await setup();
+			const github = () => host.integrations.list.get().find((i) => i.id === "github");
+			await vi.waitFor(() => expect(github()).toBeDefined());
+			expect(accounts(github())).toEqual([["work", true], ["home", false]]);
+			expect(github().connection).toMatchObject({
+				account: "work",
+				label: "Work",
+				isDefault: true
+			});
+		});
+		it.skipIf(!has("integrations"))("disconnects one account, then the rest", async () => {
+			const { host } = await setup();
+			const github = () => host.integrations.list.get().find((i) => i.id === "github");
+			await vi.waitFor(() => expect(github()).toBeDefined());
+			await host.integrations.disconnect("github", { account: "home" });
+			await vi.waitFor(() => expect(accounts(github())).toEqual([["work", true]]));
+			await host.integrations.disconnect("github");
+			await vi.waitFor(() => expect(github().connection).toBeUndefined());
+			expect(accounts(github())).toEqual([]);
+		});
+		it.skipIf(!has("integrations"))("makes another account the default", async () => {
+			const { host } = await setup();
+			const github = () => host.integrations.list.get().find((i) => i.id === "github");
+			await vi.waitFor(() => expect(github()).toBeDefined());
+			await host.integrations.setDefault("github", "home");
+			await vi.waitFor(() => expect(accounts(github())).toEqual([["home", true], ["work", false]]));
+			expect(github().connection).toMatchObject({
+				account: "home",
+				isDefault: true
+			});
+		});
+		it.skipIf(!has("commands"))("lists and runs commands", async () => {
+			const { host, control } = await setup();
+			await vi.waitFor(() => expect(host.commands.list.get().map((c) => c.id)).toEqual(["demo.sync"]));
+			await expect(host.commands.run("demo.sync", { sessionId: "s1" })).resolves.toBe(true);
+			expect(control.ran()).toEqual([{
+				id: "demo.sync",
+				sessionId: "s1"
+			}]);
+			await expect(host.commands.run("demo.nope")).resolves.toBe(false);
+		});
+	});
+}
+//#endregion
+export { CONTRACT_GOOD_KEY, CONTRACT_STORE, describeExtensionsHostContract };

package/dist/extensions/testing/index.d.ts

@@ -0,0 +1,2 @@
+import { FixtureCallback, FixtureExtensionsCapability, FixtureExtensionsControl, FixtureExtensionsHost, FixtureExtensionsOptions, FixtureRpcError, FixtureRpcMethod, createFixtureExtensionsHost, fixtureItem, storeKey } from "../headless/fixture-host.js";
+export { FixtureCallback, FixtureExtensionsCapability, FixtureExtensionsControl, FixtureExtensionsHost, FixtureExtensionsOptions, FixtureRpcError, FixtureRpcMethod, createFixtureExtensionsHost, fixtureItem, storeKey };

package/dist/extensions/testing/index.js

@@ -0,0 +1 @@
+export { createFixtureExtensionsHost, fixtureItem, storeKey } from "../headless/fixture-host.js";

package/dist/extensions/useExtensionsLabels.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionsLabels } from "./headless/labels.js";
+//#region src/extensions/useExtensionsLabels.d.ts
+/** Returns the extensions components' strings: the defaults merged with any overrides. */
+declare function useExtensionsLabels(): ExtensionsLabels;
+//#endregion
+export { useExtensionsLabels };

package/dist/extensions/useExtensionsLabels.js

@@ -0,0 +1,18 @@
+import { useLabels } from "../labels.js";
+import { DEFAULT_EXTENSIONS_LABELS } from "./headless/labels.js";
+import { useMemo } from "react";
+//#region src/extensions/useExtensionsLabels.ts
+/**
+* The extensions components' labels: the defaults, overridable through
+* `<LabelsProvider>` or `ExtensionsProvider`'s `labels`.
+*/
+/** Returns the extensions components' strings: the defaults merged with any overrides. */
+function useExtensionsLabels() {
+	const overrides = useLabels();
+	return useMemo(() => ({
+		...DEFAULT_EXTENSIONS_LABELS,
+		...overrides
+	}), [overrides]);
+}
+//#endregion
+export { useExtensionsLabels };

package/dist/files/DiffsTab.js

@@ -11,7 +11,6 @@ import { useFind } from "../code/editor/find/useFind.js";
 import { FilesChatContext, useNoEdits, useNoKeyScope } from "./tab-hooks.js";
 import { useFilesLabels } from "./useFilesLabels.js";
 import { DiffScroller, DiffView } from "../code/editor/DiffView.js";
-import { parseFilePatch } from "../code/editor/patch-parse.js";
 import { ReviewableDiff } from "./ReviewableDiff.js";
 import { FileIcon, TreeChevron } from "../code/editor/FileIcon.js";
 import { DiffFileTree } from "../session/DiffFileTree.js";
@@ -22,6 +21,7 @@ import { matchRanges } from "./headless/search.js";
 import { nameMatches } from "./headless/name-match.js";
 import { filesRootOf, steppedIndex } from "./headless/view.js";
 import { MediaDiff, isMediaDiff } from "./MediaDiff.js";
+import { parseSessionPatch } from "./session-patch.js";
 import { SearchPanel } from "./SearchPanel.js";
 import { useFilesDiagnostics } from "./useFilesDiagnostics.js";
 import { useWorkingTreeDiff } from "./working-tree-diff.js";
@@ -47,6 +47,11 @@ import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
 /** Search in changes stops here (as search in files does in main). */
 const MAX_SEARCH_LINES = 2e3;
 const renderFileIcon = (path) => /* @__PURE__ */ jsx(FileIcon, { path });
+/**
+* Each file header's icon centered on the tree's icon column above it (the list's 8px, a row's 8px,
+* the 14px icon against the header's 16px), its name within half a pixel of the tree's names.
+*/
+const DIFF_HEADER_INSET = { "--zg-diff-header-inset": "15px" };
 const renderChevron = (open) => /* @__PURE__ */ jsx(TreeChevron, {
 	open,
 	className: "text-[var(--zg-text-muted)]"
@@ -392,6 +397,7 @@ function DiffsTab({ scope, useEdits = useNoEdits, useKeyScope = useNoKeyScope, c
 				})
 			}), /* @__PURE__ */ jsxs("div", {
 				className: "relative flex-1 min-h-0 flex flex-col",
+				style: DIFF_HEADER_INSET,
 				ref: (el) => {
 					scroller.current = el?.firstElementChild ?? null;
 				},
@@ -449,23 +455,5 @@ const SessionDiff = memo(function SessionDiff({ id, patch, diffStyle, wrap }) {
 		wrap
 	});
 });
-/** Parsed once per edit: the diff column and find both read it. */
-const parsedPatches = /* @__PURE__ */ new Map();
-function parseSessionPatch(id, patch) {
-	const hit = parsedPatches.get(id);
-	if (hit && hit.patch === patch) return hit.diff;
-	let diff = null;
-	try {
-		diff = parseFilePatch(patch, `${id}:`) ?? null;
-	} catch {
-		diff = null;
-	}
-	if (parsedPatches.size > 2e3) parsedPatches.clear();
-	parsedPatches.set(id, {
-		patch,
-		diff
-	});
-	return diff;
-}
 //#endregion
 export { DiffsTab };

package/dist/files/EditorColumn.js

@@ -1,8 +1,8 @@
 import { Breadcrumb } from "../components/Breadcrumb.js";
 import { IconToggle } from "../components/IconToggle.js";
 import { PanelEmpty, PanelLoading } from "../components/PanelEmpty.js";
-import { mediaSiblings, mediaTypeOfPath } from "./headless/media.js";
 import { useFilesHost } from "./FilesProvider.js";
+import { mediaSiblings, mediaTypeOfPath } from "./headless/media.js";
 import { absolutePath } from "./file-actions.js";
 import { useFilesLabels } from "./useFilesLabels.js";
 import { useLsp } from "./useLsp.js";

package/dist/files/EditorEnvironmentRoot.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+//#region src/files/EditorEnvironmentRoot.d.ts
+/** Props for {@link EditorEnvironmentRoot}. */
+interface EditorEnvironmentRootProps {
+  /** The editor surfaces. */
+  children: ReactNode;
+}
+/**
+ * Provides the editor surfaces' environment from the app's appearance and Editor settings.
+ *
+ * @param props - The `children`.
+ */
+declare function EditorEnvironmentRoot({ children }: EditorEnvironmentRootProps): import("react").JSX.Element;
+//#endregion
+export { EditorEnvironmentRoot, EditorEnvironmentRootProps };

package/dist/files/EditorEnvironmentRoot.js

@@ -0,0 +1,55 @@
+import { EditorEnvironmentProvider } from "../code/editor/environment.js";
+import { useAppearanceReducedMotion, usePalette, useShikiTheme } from "../appearance/AppearanceProvider.js";
+import { useEditorPrefs } from "./FilesProvider.js";
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+//#region src/files/EditorEnvironmentRoot.tsx
+/**
+* The kit's editor surfaces' environment in the app's theme and Editor
+* settings, at an app's root (the desktop app's and the web app's): `EditorEnvironmentProvider` comes from the
+* design system (`zidane-ui`), so providing it loads no editor. pierre's
+* highlight worker pool is `EditorWorkers`, around the views that load the
+* editor.
+*/
+/**
+* Provides the editor surfaces' environment from the app's appearance and Editor settings.
+*
+* @param props - The `children`.
+*/
+function EditorEnvironmentRoot({ children }) {
+	const shikiTheme = useShikiTheme();
+	const { appearance } = usePalette();
+	const ed = useEditorPrefs();
+	const reducedMotion = useAppearanceReducedMotion();
+	const value = useMemo(() => ({
+		shikiTheme,
+		appearance,
+		reducedMotion,
+		settings: {
+			editing: ed.editing,
+			saveOn: ed.saveOn,
+			tabSize: ed.tabSize,
+			wordWrap: ed.wordWrap,
+			matchBrackets: ed.matchBrackets,
+			roundedSelection: ed.roundedSelection,
+			autoSurround: ed.autoSurround
+		}
+	}), [
+		shikiTheme,
+		appearance,
+		reducedMotion,
+		ed.editing,
+		ed.saveOn,
+		ed.tabSize,
+		ed.wordWrap,
+		ed.matchBrackets,
+		ed.roundedSelection,
+		ed.autoSurround
+	]);
+	return /* @__PURE__ */ jsx(EditorEnvironmentProvider, {
+		value,
+		children
+	});
+}
+//#endregion
+export { EditorEnvironmentRoot };

package/dist/files/MediaDiff.js

@@ -1,5 +1,5 @@
-import { mediaTypeOfPath } from "./headless/media.js";
 import { useFilesHost } from "./FilesProvider.js";
+import { mediaTypeOfPath } from "./headless/media.js";
 import { useFilesLabels } from "./useFilesLabels.js";
 import { MediaView } from "./MediaView.js";
 import { jsx, jsxs } from "react/jsx-runtime";

package/dist/files/drafts-store.d.ts

@@ -9,6 +9,8 @@ declare class DraftStore {
   has(path: string): boolean;
   /** `null` drops the draft. No-op (and no notification) when the text does not change. */
   set(path: string, contents: string | null, base?: WorkspaceFile): void;
+  /** No draft, no subscriber. */
+  get idle(): boolean;
   subscribe(path: string, fn: () => void): () => void;
 }
 /** The draft for `path` (null when clean or no path); re-renders on every flush for that path. */
@@ -35,6 +37,14 @@ declare class FolderBuffers {
    * (nothing would reattach to it).
    */
   release(path: string, held: EditSlot): void;
+  /** Nothing unsaved and no view on any of its files. */
+  get idle(): boolean;
+  /**
+   * Drops the retained sessions of this root's paths that were reset at least
+   * once (it is being forgotten). A never-reset path's first session is not
+   * tracked here: it stays until the editor's own session cap lets it go.
+   */
+  forgetSessions(): void;
   /** Views currently holding `path`. */
   holders(path: string): number;
   key(path: string, held: EditSlot): string;

package/dist/files/drafts-store.js

@@ -51,6 +51,10 @@ var DraftStore = class {
 		}
 		for (const fn of this.listeners.get(path) ?? []) fn();
 	}
+	/** No draft, no subscriber. */
+	get idle() {
+		return this.drafts.size === 0 && this.listeners.size === 0;
+	}
 	subscribe(path, fn) {
 		let set = this.listeners.get(path);
 		if (!set) this.listeners.set(path, set = /* @__PURE__ */ new Set());
@@ -105,6 +109,18 @@ var FolderBuffers = class {
 		if (taken?.size === 0) this.slots.delete(path);
 		if (held.slot !== 0) forgetEditSession(this.key(path, held));
 	}
+	/** Nothing unsaved and no view on any of its files. */
+	get idle() {
+		return this.drafts.idle && this.slots.size === 0;
+	}
+	/**
+	* Drops the retained sessions of this root's paths that were reset at least
+	* once (it is being forgotten). A never-reset path's first session is not
+	* tracked here: it stays until the editor's own session cap lets it go.
+	*/
+	forgetSessions() {
+		for (const [path, generation] of this.generations) for (let g = 0; g <= generation; g++) forgetEditSession(editSessionKey(this.root, path, g));
+	}
 	/** Views currently holding `path`. */
 	holders(path) {
 		return this.slots.get(path)?.size ?? 0;
@@ -129,10 +145,23 @@ var FolderBuffers = class {
 	}
 };
 const folders = /* @__PURE__ */ new Map();
+/** Roots held before idle ones go, least recently used first. One with a draft or a view always stays. */
+const MAX_FOLDERS = 32;
 /** The shared buffers of a files root (`filesRootOf(scope)`), created on first use. */
 function folderBuffers(root) {
 	let buffers = folders.get(root);
-	if (!buffers) folders.set(root, buffers = new FolderBuffers(root));
+	if (buffers) {
+		folders.delete(root);
+		folders.set(root, buffers);
+		return buffers;
+	}
+	folders.set(root, buffers = new FolderBuffers(root));
+	for (const [oldRoot, old] of folders) {
+		if (folders.size <= MAX_FOLDERS) break;
+		if (old === buffers || !old.idle) continue;
+		folders.delete(oldRoot);
+		old.forgetSessions();
+	}
 	return buffers;
 }
 function __resetFolderBuffersForTests() {

package/dist/files/headless/lsp-edits.d.ts

@@ -8,6 +8,9 @@ declare function resetEdits(cwd: string, path: string): void;
  * full text (no complete history for this document).
  */
 declare function takeEdits(cwd: string, path: string): LspTextChange[] | undefined;
+/** The server closed the document: its next open starts from the full text. */
+declare function forgetEdits(cwd: string, path: string): void;
 declare function __resetLspEditsForTests(): void;
+declare function __lspEditBuffersForTests(): number;
 //#endregion
-export { __resetLspEditsForTests, recordEdits, resetEdits, takeEdits };
+export { __lspEditBuffersForTests, __resetLspEditsForTests, forgetEdits, recordEdits, resetEdits, takeEdits };