@olenbetong/appframe-ds 1.2.0 → 1.3.0

package/src/mdi/controller.test.ts

@@ -1,382 +1,382 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { MdiController, type MdiControllerOptions } from "./controller.js";
-import { createFakeHost } from "./fakeHost.js";
-import { layoutSpecToLayout } from "./layoutSpec.js";
-import { createLayoutStore, type MdiLayoutStore } from "./layoutStore.js";
-import { createMemorySettingsStore } from "./memorySettingsStore.js";
-import { testSpec, testTypes } from "./testTypes.js";
-import type { MdiConfirmCloseResult, MdiDocumentTypes, MdiLayout, MdiLayoutSpec } from "./types.js";
-
-function setup(
-	options: Partial<MdiControllerOptions> = {},
-	types: MdiDocumentTypes = testTypes,
-	store?: MdiLayoutStore,
-) {
-	let fake = createFakeHost();
-	let confirmClose = vi.fn<(document: unknown) => Promise<MdiConfirmCloseResult>>().mockResolvedValue("discard");
-	let controller = new MdiController(types, store ?? createLayoutStore(createMemorySettingsStore(), "art"));
-
-	controller.setOptions({
-		layoutVersion: 1,
-		defaultLayout: testSpec,
-		persist: false,
-		popoutUrl: "/popout",
-		confirmClose,
-		...options,
-	});
-	controller.attach(fake.host);
-
-	return { controller, fake, confirmClose };
-}
-
-describe("MdiController", () => {
-	beforeEach(() => {
-		vi.spyOn(console, "warn").mockImplementation(() => {});
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	describe("initialize", () => {
-		it("applies the default layout", async () => {
-			let { controller, fake } = setup();
-
-			await controller.initialize();
-
-			expect([...fake.panels.keys()]).toEqual(["explorer", "editor:a", "editor:b", "properties"]);
-			expect(controller.getDocuments().map((document) => document.id)).toEqual([
-				"explorer",
-				"editor:a",
-				"editor:b",
-				"properties",
-			]);
-			expect(controller.getActive()?.id).toBe("explorer");
-			expect(fake.groups.get("mdi-g1")).toMatchObject({ locked: true, headerHidden: true });
-		});
-
-		it("restores no-drop-target groups after dockview reduced the flag to a boolean", async () => {
-			let spec: MdiLayoutSpec = {
-				root: {
-					direction: "horizontal",
-					children: [
-						{ tabs: [{ type: "explorer" }], locked: "no-drop-target" },
-						{ tabs: [{ type: "properties" }], locked: true },
-					],
-				},
-			};
-			let { controller, fake } = setup({ defaultLayout: spec });
-
-			await controller.initialize();
-
-			expect(fake.groups.get("mdi-g1")?.locked).toBe("no-drop-target");
-			expect(fake.groups.get("mdi-g2")?.locked).toBe(true);
-		});
-
-		it("restores a persisted layout and drops documents the resolver rejects", async () => {
-			let restore = vi.fn(async ({ key }: { key?: string }) => (key === "b" ? false : { title: `Restored ${key}` }));
-			let types: MdiDocumentTypes = { ...testTypes, editor: { ...testTypes["editor"]!, restore } };
-			let persisted = layoutSpecToLayout(testSpec, types, 1);
-			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
-			let { controller, fake } = setup({ id: "dock", persist: true }, types, store);
-
-			await controller.initialize();
-
-			expect(restore).toHaveBeenCalledTimes(2);
-			expect([...fake.panels.keys()]).toEqual(["explorer", "editor:a", "properties"]);
-			expect(controller.getDocument("editor:a")?.title).toBe("Restored a");
-			expect(fake.panels.get("editor:a")?.title).toBe("Restored a");
-		});
-
-		it("falls back to the default layout when the version differs", async () => {
-			let persisted = { ...layoutSpecToLayout(testSpec, testTypes, 1), layoutVersion: 0 };
-			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
-			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
-
-			await controller.initialize();
-
-			expect(fake.panels.size).toBe(4);
-		});
-
-		it("re-adds fixed panes that are missing from a saved layout", async () => {
-			let persisted = layoutSpecToLayout(testSpec, testTypes, 1);
-			delete persisted.documents["properties"];
-			delete persisted.dockview.panels["properties"];
-			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
-			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
-
-			await controller.initialize();
-
-			expect(fake.panels.has("properties")).toBe(true);
-			expect(controller.getDocument("properties")).toMatchObject({ closable: false, isActive: false });
-		});
-
-		it("drops documents whose type is no longer registered", async () => {
-			let persisted = layoutSpecToLayout(testSpec, testTypes, 1);
-			let { settings: _settings, ...types } = testTypes;
-			persisted.documents["ghost"] = { type: "ghost", params: {}, closable: true };
-			persisted.dockview.panels["ghost"] = { id: "ghost", contentComponent: "mdi" };
-			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
-			let { controller, fake } = setup({ id: "dock", persist: true }, types, store);
-
-			await controller.initialize();
-
-			expect(fake.panels.has("ghost")).toBe(false);
-			expect(controller.getDocument("ghost")).toBeUndefined();
-		});
-	});
-
-	describe("opening", () => {
-		it("opens a keyed document once and activates it on the second call", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			let opened = vi.fn();
-			controller.subscribe("open", opened);
-
-			let id = controller.openDocument({ type: "editor", key: "c", params: { name: "C" } });
-			fake.activate("explorer");
-			let again = controller.openDocument({ type: "editor", key: "c", params: { name: "C2" } });
-
-			expect(id).toBe("editor:c");
-			expect(again).toBe(id);
-			expect(opened).toHaveBeenCalledTimes(1);
-			expect(fake.panels.size).toBe(5);
-			expect(controller.getDocument(id)?.params).toEqual({ name: "C2" });
-			expect(controller.getActive()?.id).toBe(id);
-		});
-
-		it("ignores the key of singleton types", async () => {
-			let { controller } = setup();
-			await controller.initialize();
-
-			expect(controller.openDocument({ type: "settings", key: "whatever" })).toBe("settings");
-			expect(controller.panelId("settings", "x")).toBe("settings");
-			expect(controller.panelId("editor", "x")).toBe("editor:x");
-		});
-
-		it("adds new documents to the active group by default", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			fake.activate("editor:a");
-
-			controller.openDocument({ type: "editor", key: "d" });
-
-			expect(fake.panels.get("editor:d")?.groupId).toBe(fake.panels.get("editor:a")?.groupId);
-		});
-
-		it("rejects unknown types", async () => {
-			let { controller } = setup();
-			await controller.initialize();
-
-			expect(() => controller.openDocument({ type: "nope" })).toThrow(/unknown document type/);
-		});
-	});
-
-	describe("closing", () => {
-		it("refuses to close unclosable documents unless forced", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-
-			expect(await controller.close("explorer")).toBe(false);
-			expect(fake.panels.has("explorer")).toBe(true);
-			expect(await controller.close("explorer", { force: true })).toBe(true);
-			expect(fake.panels.has("explorer")).toBe(false);
-		});
-
-		it("closes a clean document and reports it", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			let closed = vi.fn();
-			controller.subscribe("close", closed);
-
-			expect(await controller.close("editor:a")).toBe(true);
-			expect(fake.panels.has("editor:a")).toBe(false);
-			expect(controller.getDocument("editor:a")).toBeUndefined();
-			expect(closed).toHaveBeenCalledWith(expect.objectContaining({ id: "editor:a" }));
-		});
-
-		it("lets an onClosing guard veto", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			let unregister = controller.registerGuards("editor:a", { onClosing: () => false });
-
-			expect(await controller.close("editor:a")).toBe(false);
-			expect(fake.panels.has("editor:a")).toBe(true);
-
-			unregister();
-			expect(await controller.close("editor:a")).toBe(true);
-		});
-
-		it("asks before closing a dirty document", async () => {
-			let { controller, fake, confirmClose } = setup();
-			await controller.initialize();
-			let onSave = vi.fn().mockResolvedValue(false);
-			controller.registerGuards("editor:a", { onSave });
-			controller.setDirty("editor:a", true);
-
-			confirmClose.mockResolvedValueOnce("cancel");
-			expect(await controller.close("editor:a")).toBe(false);
-
-			confirmClose.mockResolvedValueOnce("save");
-			expect(await controller.close("editor:a")).toBe(false);
-			expect(onSave).toHaveBeenCalledTimes(1);
-			expect(fake.panels.has("editor:a")).toBe(true);
-
-			onSave.mockResolvedValue(true);
-			confirmClose.mockResolvedValueOnce("save");
-			expect(await controller.close("editor:a")).toBe(true);
-			expect(fake.panels.has("editor:a")).toBe(false);
-
-			controller.setDirty("editor:b", true);
-			confirmClose.mockResolvedValueOnce("discard");
-			expect(await controller.close("editor:b")).toBe(true);
-			expect(confirmClose).toHaveBeenCalledTimes(4);
-		});
-
-		it("closes by key without prompting", async () => {
-			let { controller, fake, confirmClose } = setup();
-			await controller.initialize();
-			controller.setDirty("editor:a", true);
-
-			await controller.closeByKey("a");
-
-			expect(confirmClose).not.toHaveBeenCalled();
-			expect(fake.panels.has("editor:a")).toBe(false);
-		});
-
-		it("closes all closable documents of a type and stops at a veto", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			controller.openDocument({ type: "settings" });
-
-			expect(await controller.closeAll("editor")).toBe(true);
-			expect([...fake.panels.keys()]).toEqual(["explorer", "properties", "settings"]);
-
-			controller.openDocument({ type: "editor", key: "x" });
-			controller.openDocument({ type: "editor", key: "y" });
-			controller.registerGuards("editor:x", { onClosing: () => false });
-
-			expect(await controller.closeAll()).toBe(false);
-			expect(fake.panels.has("editor:x")).toBe(true);
-			expect(fake.panels.has("explorer")).toBe(true);
-		});
-
-		it("treats a panel removed by dockview as closed", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-
-			fake.host.getPanel("editor:b")!.close();
-
-			expect(controller.getDocument("editor:b")).toBeUndefined();
-		});
-	});
-
-	describe("state", () => {
-		it("tracks titles, dirty flags and the active document", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-			let events: string[] = [];
-			controller.subscribe("titleChange", (event) => events.push(`title:${event.id}:${event.title}`));
-			controller.subscribe("dirtyChange", (event) => events.push(`dirty:${event.id}:${event.dirty}`));
-			controller.subscribe("activeChange", (event) => events.push(`active:${event?.id}`));
-
-			controller.setTitle("editor:a", "Renamed");
-			controller.setDirty("editor:a", true);
-			fake.activate("editor:a");
-
-			expect(fake.panels.get("editor:a")?.title).toBe("Renamed");
-			expect(controller.getDocument("editor:a")).toMatchObject({ title: "Renamed", dirty: true, isActive: true });
-			expect(controller.hasDirty()).toBe(true);
-			expect(events).toEqual(["title:editor:a:Renamed", "dirty:editor:a:true", "active:editor:a"]);
-		});
-
-		it("keeps snapshots stable until something changes", async () => {
-			let { controller } = setup();
-			await controller.initialize();
-
-			let first = controller.getDocumentsSnapshot();
-			expect(controller.getDocumentsSnapshot()).toBe(first);
-			expect(controller.getDocument("editor:a")).toBe(controller.getDocument("editor:a"));
-
-			controller.setTitle("editor:a", "x");
-
-			expect(controller.getDocumentsSnapshot()).not.toBe(first);
-		});
-
-		it("pops a document out through the host", async () => {
-			let { controller, fake } = setup();
-			await controller.initialize();
-
-			expect(await controller.popout("editor:a")).toBe(true);
-			expect(fake.popouts).toEqual([{ id: "editor:a", popoutUrl: "/popout" }]);
-			expect(await controller.popout("nope")).toBe(false);
-		});
-	});
-
-	describe("persistence", () => {
-		it("saves layout changes when persistence is on", async () => {
-			vi.useFakeTimers();
-			let settings = createMemorySettingsStore();
-			let store = createLayoutStore(settings, "art");
-			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
-
-			await controller.initialize();
-			expect(settings.data.has("art.dock")).toBe(false);
-
-			controller.openDocument({ type: "editor", key: "z" });
-			fake.fireLayout();
-			await vi.advanceTimersByTimeAsync(300);
-
-			let saved = settings.data.get("art.dock") as MdiLayout;
-			expect(saved.format).toBe(1);
-			expect(Object.keys(saved.documents)).toContain("editor:z");
-			expect(saved.dockview.panels["editor:z"]).toBeDefined();
-			vi.useRealTimers();
-		});
-
-		it("does not touch the store without an id", async () => {
-			let settings = createMemorySettingsStore();
-			let { controller, fake } = setup({ persist: true }, testTypes, createLayoutStore(settings, "art"));
-
-			await controller.initialize();
-			fake.fireLayout();
-			await controller.saveLayout();
-
-			expect(settings.data.size).toBe(0);
-		});
-
-		it("saves, loads and resets on demand without auto-save", async () => {
-			let settings = createMemorySettingsStore();
-			let store = createLayoutStore(settings, "art");
-			let { controller, fake } = setup({ id: "dock", persist: false }, testTypes, store);
-			await controller.initialize();
-
-			controller.openDocument({ type: "settings" });
-			let saved = await controller.saveLayout();
-			expect(settings.data.get("art.dock")).toBe(saved);
-
-			await controller.close("settings", { force: true });
-			expect(fake.panels.has("settings")).toBe(false);
-
-			await controller.loadLayout();
-			expect(fake.panels.has("settings")).toBe(true);
-
-			await controller.resetLayout();
-			expect(fake.panels.has("settings")).toBe(false);
-			expect(settings.data.has("art.dock")).toBe(false);
-			expect(fake.panels.size).toBe(4);
-		});
-	});
-
-	it("stops acting on the host after detach", async () => {
-		let { controller, fake } = setup();
-		await controller.initialize();
-
-		controller.detach();
-		fake.activate("editor:a");
-
-		expect(controller.getActive()?.id).toBe("explorer");
-		expect(() => controller.openDocument({ type: "settings" })).toThrow(/no dock is mounted/);
-	});
-});
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { MdiController, type MdiControllerOptions } from "./controller.js";
+import { createFakeHost } from "./fakeHost.js";
+import { layoutSpecToLayout } from "./layoutSpec.js";
+import { createLayoutStore, type MdiLayoutStore } from "./layoutStore.js";
+import { createMemorySettingsStore } from "./memorySettingsStore.js";
+import { testSpec, testTypes } from "./testTypes.js";
+import type { MdiConfirmCloseResult, MdiDocumentTypes, MdiLayout, MdiLayoutSpec } from "./types.js";
+
+function setup(
+	options: Partial<MdiControllerOptions> = {},
+	types: MdiDocumentTypes = testTypes,
+	store?: MdiLayoutStore,
+) {
+	let fake = createFakeHost();
+	let confirmClose = vi.fn<(document: unknown) => Promise<MdiConfirmCloseResult>>().mockResolvedValue("discard");
+	let controller = new MdiController(types, store ?? createLayoutStore(createMemorySettingsStore(), "art"));
+
+	controller.setOptions({
+		layoutVersion: 1,
+		defaultLayout: testSpec,
+		persist: false,
+		popoutUrl: "/popout",
+		confirmClose,
+		...options,
+	});
+	controller.attach(fake.host);
+
+	return { controller, fake, confirmClose };
+}
+
+describe("MdiController", () => {
+	beforeEach(() => {
+		vi.spyOn(console, "warn").mockImplementation(() => {});
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	describe("initialize", () => {
+		it("applies the default layout", async () => {
+			let { controller, fake } = setup();
+
+			await controller.initialize();
+
+			expect([...fake.panels.keys()]).toEqual(["explorer", "editor:a", "editor:b", "properties"]);
+			expect(controller.getDocuments().map((document) => document.id)).toEqual([
+				"explorer",
+				"editor:a",
+				"editor:b",
+				"properties",
+			]);
+			expect(controller.getActive()?.id).toBe("explorer");
+			expect(fake.groups.get("mdi-g1")).toMatchObject({ locked: true, headerHidden: true });
+		});
+
+		it("restores no-drop-target groups after dockview reduced the flag to a boolean", async () => {
+			let spec: MdiLayoutSpec = {
+				root: {
+					direction: "horizontal",
+					children: [
+						{ tabs: [{ type: "explorer" }], locked: "no-drop-target" },
+						{ tabs: [{ type: "properties" }], locked: true },
+					],
+				},
+			};
+			let { controller, fake } = setup({ defaultLayout: spec });
+
+			await controller.initialize();
+
+			expect(fake.groups.get("mdi-g1")?.locked).toBe("no-drop-target");
+			expect(fake.groups.get("mdi-g2")?.locked).toBe(true);
+		});
+
+		it("restores a persisted layout and drops documents the resolver rejects", async () => {
+			let restore = vi.fn(async ({ key }: { key?: string }) => (key === "b" ? false : { title: `Restored ${key}` }));
+			let types: MdiDocumentTypes = { ...testTypes, editor: { ...testTypes["editor"]!, restore } };
+			let persisted = layoutSpecToLayout(testSpec, types, 1);
+			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
+			let { controller, fake } = setup({ id: "dock", persist: true }, types, store);
+
+			await controller.initialize();
+
+			expect(restore).toHaveBeenCalledTimes(2);
+			expect([...fake.panels.keys()]).toEqual(["explorer", "editor:a", "properties"]);
+			expect(controller.getDocument("editor:a")?.title).toBe("Restored a");
+			expect(fake.panels.get("editor:a")?.title).toBe("Restored a");
+		});
+
+		it("falls back to the default layout when the version differs", async () => {
+			let persisted = { ...layoutSpecToLayout(testSpec, testTypes, 1), layoutVersion: 0 };
+			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
+			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
+
+			await controller.initialize();
+
+			expect(fake.panels.size).toBe(4);
+		});
+
+		it("re-adds fixed panes that are missing from a saved layout", async () => {
+			let persisted = layoutSpecToLayout(testSpec, testTypes, 1);
+			delete persisted.documents["properties"];
+			delete persisted.dockview.panels["properties"];
+			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
+			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
+
+			await controller.initialize();
+
+			expect(fake.panels.has("properties")).toBe(true);
+			expect(controller.getDocument("properties")).toMatchObject({ closable: false, isActive: false });
+		});
+
+		it("drops documents whose type is no longer registered", async () => {
+			let persisted = layoutSpecToLayout(testSpec, testTypes, 1);
+			let { settings: _settings, ...types } = testTypes;
+			persisted.documents["ghost"] = { type: "ghost", params: {}, closable: true };
+			persisted.dockview.panels["ghost"] = { id: "ghost", contentComponent: "mdi" };
+			let store = createLayoutStore(createMemorySettingsStore({ "art.dock": persisted }), "art");
+			let { controller, fake } = setup({ id: "dock", persist: true }, types, store);
+
+			await controller.initialize();
+
+			expect(fake.panels.has("ghost")).toBe(false);
+			expect(controller.getDocument("ghost")).toBeUndefined();
+		});
+	});
+
+	describe("opening", () => {
+		it("opens a keyed document once and activates it on the second call", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			let opened = vi.fn();
+			controller.subscribe("open", opened);
+
+			let id = controller.openDocument({ type: "editor", key: "c", params: { name: "C" } });
+			fake.activate("explorer");
+			let again = controller.openDocument({ type: "editor", key: "c", params: { name: "C2" } });
+
+			expect(id).toBe("editor:c");
+			expect(again).toBe(id);
+			expect(opened).toHaveBeenCalledTimes(1);
+			expect(fake.panels.size).toBe(5);
+			expect(controller.getDocument(id)?.params).toEqual({ name: "C2" });
+			expect(controller.getActive()?.id).toBe(id);
+		});
+
+		it("ignores the key of singleton types", async () => {
+			let { controller } = setup();
+			await controller.initialize();
+
+			expect(controller.openDocument({ type: "settings", key: "whatever" })).toBe("settings");
+			expect(controller.panelId("settings", "x")).toBe("settings");
+			expect(controller.panelId("editor", "x")).toBe("editor:x");
+		});
+
+		it("adds new documents to the active group by default", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			fake.activate("editor:a");
+
+			controller.openDocument({ type: "editor", key: "d" });
+
+			expect(fake.panels.get("editor:d")?.groupId).toBe(fake.panels.get("editor:a")?.groupId);
+		});
+
+		it("rejects unknown types", async () => {
+			let { controller } = setup();
+			await controller.initialize();
+
+			expect(() => controller.openDocument({ type: "nope" })).toThrow(/unknown document type/);
+		});
+	});
+
+	describe("closing", () => {
+		it("refuses to close unclosable documents unless forced", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+
+			expect(await controller.close("explorer")).toBe(false);
+			expect(fake.panels.has("explorer")).toBe(true);
+			expect(await controller.close("explorer", { force: true })).toBe(true);
+			expect(fake.panels.has("explorer")).toBe(false);
+		});
+
+		it("closes a clean document and reports it", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			let closed = vi.fn();
+			controller.subscribe("close", closed);
+
+			expect(await controller.close("editor:a")).toBe(true);
+			expect(fake.panels.has("editor:a")).toBe(false);
+			expect(controller.getDocument("editor:a")).toBeUndefined();
+			expect(closed).toHaveBeenCalledWith(expect.objectContaining({ id: "editor:a" }));
+		});
+
+		it("lets an onClosing guard veto", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			let unregister = controller.registerGuards("editor:a", { onClosing: () => false });
+
+			expect(await controller.close("editor:a")).toBe(false);
+			expect(fake.panels.has("editor:a")).toBe(true);
+
+			unregister();
+			expect(await controller.close("editor:a")).toBe(true);
+		});
+
+		it("asks before closing a dirty document", async () => {
+			let { controller, fake, confirmClose } = setup();
+			await controller.initialize();
+			let onSave = vi.fn().mockResolvedValue(false);
+			controller.registerGuards("editor:a", { onSave });
+			controller.setDirty("editor:a", true);
+
+			confirmClose.mockResolvedValueOnce("cancel");
+			expect(await controller.close("editor:a")).toBe(false);
+
+			confirmClose.mockResolvedValueOnce("save");
+			expect(await controller.close("editor:a")).toBe(false);
+			expect(onSave).toHaveBeenCalledTimes(1);
+			expect(fake.panels.has("editor:a")).toBe(true);
+
+			onSave.mockResolvedValue(true);
+			confirmClose.mockResolvedValueOnce("save");
+			expect(await controller.close("editor:a")).toBe(true);
+			expect(fake.panels.has("editor:a")).toBe(false);
+
+			controller.setDirty("editor:b", true);
+			confirmClose.mockResolvedValueOnce("discard");
+			expect(await controller.close("editor:b")).toBe(true);
+			expect(confirmClose).toHaveBeenCalledTimes(4);
+		});
+
+		it("closes by key without prompting", async () => {
+			let { controller, fake, confirmClose } = setup();
+			await controller.initialize();
+			controller.setDirty("editor:a", true);
+
+			await controller.closeByKey("a");
+
+			expect(confirmClose).not.toHaveBeenCalled();
+			expect(fake.panels.has("editor:a")).toBe(false);
+		});
+
+		it("closes all closable documents of a type and stops at a veto", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			controller.openDocument({ type: "settings" });
+
+			expect(await controller.closeAll("editor")).toBe(true);
+			expect([...fake.panels.keys()]).toEqual(["explorer", "properties", "settings"]);
+
+			controller.openDocument({ type: "editor", key: "x" });
+			controller.openDocument({ type: "editor", key: "y" });
+			controller.registerGuards("editor:x", { onClosing: () => false });
+
+			expect(await controller.closeAll()).toBe(false);
+			expect(fake.panels.has("editor:x")).toBe(true);
+			expect(fake.panels.has("explorer")).toBe(true);
+		});
+
+		it("treats a panel removed by dockview as closed", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+
+			fake.host.getPanel("editor:b")!.close();
+
+			expect(controller.getDocument("editor:b")).toBeUndefined();
+		});
+	});
+
+	describe("state", () => {
+		it("tracks titles, dirty flags and the active document", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+			let events: string[] = [];
+			controller.subscribe("titleChange", (event) => events.push(`title:${event.id}:${event.title}`));
+			controller.subscribe("dirtyChange", (event) => events.push(`dirty:${event.id}:${event.dirty}`));
+			controller.subscribe("activeChange", (event) => events.push(`active:${event?.id}`));
+
+			controller.setTitle("editor:a", "Renamed");
+			controller.setDirty("editor:a", true);
+			fake.activate("editor:a");
+
+			expect(fake.panels.get("editor:a")?.title).toBe("Renamed");
+			expect(controller.getDocument("editor:a")).toMatchObject({ title: "Renamed", dirty: true, isActive: true });
+			expect(controller.hasDirty()).toBe(true);
+			expect(events).toEqual(["title:editor:a:Renamed", "dirty:editor:a:true", "active:editor:a"]);
+		});
+
+		it("keeps snapshots stable until something changes", async () => {
+			let { controller } = setup();
+			await controller.initialize();
+
+			let first = controller.getDocumentsSnapshot();
+			expect(controller.getDocumentsSnapshot()).toBe(first);
+			expect(controller.getDocument("editor:a")).toBe(controller.getDocument("editor:a"));
+
+			controller.setTitle("editor:a", "x");
+
+			expect(controller.getDocumentsSnapshot()).not.toBe(first);
+		});
+
+		it("pops a document out through the host", async () => {
+			let { controller, fake } = setup();
+			await controller.initialize();
+
+			expect(await controller.popout("editor:a")).toBe(true);
+			expect(fake.popouts).toEqual([{ id: "editor:a", popoutUrl: "/popout" }]);
+			expect(await controller.popout("nope")).toBe(false);
+		});
+	});
+
+	describe("persistence", () => {
+		it("saves layout changes when persistence is on", async () => {
+			vi.useFakeTimers();
+			let settings = createMemorySettingsStore();
+			let store = createLayoutStore(settings, "art");
+			let { controller, fake } = setup({ id: "dock", persist: true }, testTypes, store);
+
+			await controller.initialize();
+			expect(settings.data.has("art.dock")).toBe(false);
+
+			controller.openDocument({ type: "editor", key: "z" });
+			fake.fireLayout();
+			await vi.advanceTimersByTimeAsync(300);
+
+			let saved = settings.data.get("art.dock") as MdiLayout;
+			expect(saved.format).toBe(1);
+			expect(Object.keys(saved.documents)).toContain("editor:z");
+			expect(saved.dockview.panels["editor:z"]).toBeDefined();
+			vi.useRealTimers();
+		});
+
+		it("does not touch the store without an id", async () => {
+			let settings = createMemorySettingsStore();
+			let { controller, fake } = setup({ persist: true }, testTypes, createLayoutStore(settings, "art"));
+
+			await controller.initialize();
+			fake.fireLayout();
+			await controller.saveLayout();
+
+			expect(settings.data.size).toBe(0);
+		});
+
+		it("saves, loads and resets on demand without auto-save", async () => {
+			let settings = createMemorySettingsStore();
+			let store = createLayoutStore(settings, "art");
+			let { controller, fake } = setup({ id: "dock", persist: false }, testTypes, store);
+			await controller.initialize();
+
+			controller.openDocument({ type: "settings" });
+			let saved = await controller.saveLayout();
+			expect(settings.data.get("art.dock")).toBe(saved);
+
+			await controller.close("settings", { force: true });
+			expect(fake.panels.has("settings")).toBe(false);
+
+			await controller.loadLayout();
+			expect(fake.panels.has("settings")).toBe(true);
+
+			await controller.resetLayout();
+			expect(fake.panels.has("settings")).toBe(false);
+			expect(settings.data.has("art.dock")).toBe(false);
+			expect(fake.panels.size).toBe(4);
+		});
+	});
+
+	it("stops acting on the host after detach", async () => {
+		let { controller, fake } = setup();
+		await controller.initialize();
+
+		controller.detach();
+		fake.activate("editor:a");
+
+		expect(controller.getActive()?.id).toBe("explorer");
+		expect(() => controller.openDocument({ type: "settings" })).toThrow(/no dock is mounted/);
+	});
+});