@lapis-notes/api 0.1.4 → 0.2.0

package/dist/workspace.svelte.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "./storage/path";
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { EventDispatcher } from "./events";
 import { EmptyView, FileView, ItemView, TextFileView, View, } from "./view.svelte";
@@ -7,10 +8,13 @@ import { tick, untrack } from "svelte";
 import { toast } from "svelte-sonner";
 import { SidebarState, } from "@lapis-notes/ui/sidebar-custom";
 import { uniqueId } from "./utils";
+import { attachWorkspaceView } from "./workspace-view-document";
+import { workspaceCloseGuard } from "./workspace-close-guard";
 import { normalizeWorkspaceJson } from "./workspace-layout-normalizer";
 import { promptLoadWorkspaceLayout, promptSaveWorkspaceLayout, } from "./workspace-layout-commands";
 import { NAMED_WORKSPACES_FILE, parseNamedWorkspaceStore, serializeNamedWorkspaceStore, } from "./workspace-layouts";
 import { debounce, isEqual } from "lodash-es";
+import { registerWorkspaceFileSettings } from "./files-configuration";
 import { basename, dirname, joinPath } from "./storage";
 import { HistoryManager } from "./history.svelte";
 import { EditorViewRegistry, } from "./editor-view-registry";
@@ -25,7 +29,7 @@ import { problemsPlugin, PROBLEMS_VIEW_TYPE, } from "@lapismd/design-core/worksp
 import { createAppShellPluginPersistence } from "./app-shell-plugin-persistence";
 import { resolveWorkspaceHostBinding, setWorkspaceHostBinding, } from "./workspace-host-internal";
 import { getWorkspaceHostBinding } from "./workspace-host";
-import { DiagnosticsManager, pathFromDiagnosticResource } from "./diagnostics";
+import { DiagnosticsManager, pathFromDiagnosticResource, } from "./diagnostics";
 import { getApplicationCompatibility, resolveApplication, } from "./application-compatibility";
 const DEFAULT_LAPIS_LOGO_URL = new URL("./assets/lapis-logo.svg", import.meta.url).href;
 const WORKSPACE_HINT_TARGET_SELECTOR = "[data-hint-target]";
@@ -205,8 +209,8 @@ function collectWorkspaceProjectionItem(item, items) {
         item.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
     }
 }
-function beginWorkspaceProjection(workspace) {
-    const items = new Map();
+function beginWorkspaceProjection(workspace, isCurrent) {
+    const items = Object.assign(new Map(), { isCurrent });
     workspace.rootSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
     workspace.leftSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
     workspace.rightSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
@@ -223,8 +227,13 @@ function claimWorkspaceProjectionItem(projectionItems, id, matches, create) {
     }
     return create();
 }
-function finishWorkspaceProjection(projectionItems) {
+function finishWorkspaceProjection(projectionItems, workspace) {
+    const retained = projectionItems.isCurrent?.() === false
+        ? beginWorkspaceProjection(workspace, () => true)
+        : undefined;
     for (const item of projectionItems.values()) {
+        if (retained?.get(item.id) === item)
+            continue;
         if (item instanceof WorkspaceLeaf) {
             item.view.unload();
             if (hasDestroyableEditor(item.view))
@@ -238,6 +247,10 @@ function finishWorkspaceProjection(projectionItems) {
 export const WORKSPACE_ROOT_HOST_ID = "root";
 export const WORKSPACE_POPOUT_UNSUPPORTED_ERROR_MESSAGE = "Workspace popout windows are not supported in the current renderer host.";
 let workspacePopoutHost = null;
+const layoutMutationRevisions = new WeakMap();
+function recordLayoutMutation(workspace) {
+    layoutMutationRevisions.set(workspace, (layoutMutationRevisions.get(workspace) ?? 0) + 1);
+}
 export function setWorkspacePopoutHost(host) {
     workspacePopoutHost = host;
 }
@@ -279,6 +292,8 @@ export class WorkspaceSplit extends WorkspaceParent {
             this.sizes[i] = sizes[i] ?? 50;
         });
         return Promise.all(promises).then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             this.id = layout.id;
             this.type = layout.direction;
         });
@@ -417,6 +432,8 @@ export class WorkspaceSidedock extends WorkspaceSplit {
     }
     loadJson(layout, projectionItems) {
         return super.loadJson(layout, projectionItems).then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             if (/^0(?:px|rem|em|%)?$/.test(layout.width.trim())) {
                 this.open = false;
             }
@@ -520,6 +537,8 @@ export class WorkspaceWindow extends WorkspaceContainer {
             children: layout.children,
         }, projectionItems)
             .then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             this.id = layout.id;
             this.applyInitData({
                 mode: layout.mode,
@@ -574,22 +593,26 @@ function hasDestroyableEditor(view) {
 }
 export class WorkspaceFloating extends WorkspaceParent {
     children = $state([]);
-    loadJson(layouts = [], projectionItems) {
+    loadJson(layouts = [], projectionItems, resolveHandle) {
         const promises = [];
         this.children.slice().forEach((child) => this.removeChild(child, true));
         layouts.forEach((layout) => {
             const child = claimWorkspaceProjectionItem(projectionItems, layout.id, (item) => item instanceof WorkspaceWindow, () => new WorkspaceWindow());
             this.addChild(child);
             promises.push(child.loadWindowJson(layout, projectionItems).then(() => {
+                if (projectionItems?.isCurrent?.() === false)
+                    return;
                 if (child.mode !== "popout") {
                     return;
                 }
-                const handle = openWorkspacePopoutHandle({
-                    x: child.x,
-                    y: child.y,
-                    size: { width: child.width, height: child.height },
-                    mode: "popout",
-                });
+                const handle = resolveHandle
+                    ? resolveHandle(child.id)
+                    : openWorkspacePopoutHandle({
+                        x: child.x,
+                        y: child.y,
+                        size: { width: child.width, height: child.height },
+                        mode: "popout",
+                    });
                 if (!handle) {
                     child.mode = "floating";
                     return;
@@ -741,9 +764,7 @@ export class WorkspaceSidebarGroup extends WorkspaceParent {
         const selected = this.selectedLeafId
             ? this.children.find((leaf) => leaf.id === this.selectedLeafId && !this.isLeafHidden(leaf))
             : undefined;
-        return (selected ??
-            this.children.find((leaf) => !this.isLeafHidden(leaf)) ??
-            null);
+        return (selected ?? this.children.find((leaf) => !this.isLeafHidden(leaf)) ?? null);
     }
     selectLeaf(leaf) {
         if (!this.children.includes(leaf)) {
@@ -812,9 +833,11 @@ export class WorkspaceSidebarGroup extends WorkspaceParent {
         layout.children.forEach((config) => {
             const leaf = claimWorkspaceProjectionItem(projectionItems, config.id, (item) => item instanceof WorkspaceLeaf, () => new WorkspaceLeaf());
             this.addChild(leaf);
-            promises.push(leaf.loadJson(config));
+            promises.push(loadWorkspaceLeafJson(leaf, config, projectionItems?.isCurrent));
         });
         return Promise.all(promises).then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             this.id = layout.id;
             this.name = layout.name;
             this.icon = layout.icon;
@@ -874,10 +897,12 @@ export class WorkspaceTabs extends WorkspaceParent {
             else {
                 const leaf = claimWorkspaceProjectionItem(projectionItems, config.id, (item) => item instanceof WorkspaceLeaf, () => new WorkspaceLeaf());
                 this.addChild(leaf);
-                promises.push(leaf.loadJson(config));
+                promises.push(loadWorkspaceLeafJson(leaf, config, projectionItems?.isCurrent));
             }
         });
         return Promise.all(promises).then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             this.id = layout.id;
             this.stacked = layout.stacked;
             this.selected = layout.currentTab;
@@ -1035,6 +1060,8 @@ export class WorkspaceBottomPanel extends WorkspaceTabs {
     }
     loadJson(layout, projectionItems) {
         return super.loadJson(layout, projectionItems).then(() => {
+            if (projectionItems?.isCurrent?.() === false)
+                return;
             const collapsed = /^0(?:px|rem|em|%)?$/.test(layout.height.trim());
             this.open = !collapsed;
             if (!collapsed)
@@ -1253,6 +1280,9 @@ export class Workspace extends EventDispatcher {
     viewTypes = new Map([
         ["empty", (leaf) => new EmptyView(leaf)],
     ]);
+    fileIconListeners = new Set();
+    iconExtensionSequence = 0;
+    iconExtensions = new Map();
     viewExtensions = new Map();
     editorViews = new EditorViewRegistry();
     sidebarViewPlacements = new Map();
@@ -1281,6 +1311,7 @@ export class Workspace extends EventDispatcher {
     layoutHandlers = [];
     suspendedLayoutPersistence = 0;
     #workspaceHostController = null;
+    #diagnosticOpeners = new Set();
     diagnostics;
     #syncingWorkspaceHost = 0;
     #workspaceHostProjection = Promise.resolve();
@@ -1292,27 +1323,53 @@ export class Workspace extends EventDispatcher {
     #notificationProgressBridgeDisposer = null;
     #commandBridgeDisposer = null;
     workspaceLayoutFile = "workspace.json";
+    #layoutSaveTail = Promise.resolve();
+    #layoutPersistenceDisposed = false;
     statusEl = $state();
     statusCompatEl = $state();
     leftRibbon = new WorkspaceRibbon(this, "left");
     rightRibbon = new WorkspaceRibbon(this, "right");
     containerEl = $state(createDiv("workspace"));
     saveLayoutDebounced = debounce(() => {
-        tick().then(() => {
-            if (!this.layoutReady) {
-                return;
-            }
-            return this.app.vault.create(joinPath("/.obsidian", this.workspaceLayoutFile), JSON.stringify(this.toJson(), null, 2));
+        void this.saveLayoutNow().catch((error) => {
+            console.error("Unable to save workspace layout", error);
         });
     }, 1000);
+    saveLayoutNow() {
+        const write = this.#layoutSaveTail
+            .catch(() => undefined)
+            .then(async () => {
+            await tick();
+            await this.#workspaceHostProjection;
+            if (!this.layoutReady || this.#layoutPersistenceDisposed)
+                return;
+            await this.app.vault.create(joinPath("/", appStatePath(this.workspaceLayoutFile)), JSON.stringify(this.toJson(), null, 2));
+        });
+        this.#layoutSaveTail = write;
+        return write;
+    }
+    /** Await admitted App Shell transitions before the owning host tears down. */
+    async flushPluginChanges() {
+        await this.#workspaceHostController?.plugins.flushChanges();
+    }
+    /** Drain the single layout writer before a host closes, reloads or switches. */
+    async flushLayout() {
+        await tick();
+        await this.#workspaceHostProjection;
+        this.saveLayoutDebounced.cancel();
+        await this.saveLayoutNow();
+    }
     requestSaveLayout(event = { source: "api" }) {
-        if (this.suspendedLayoutPersistence > 0) {
+        if (this.suspendedLayoutPersistence > 0 ||
+            this.#layoutPersistenceDisposed) {
             return;
         }
         untrack(() => this.commitCompatibilityLayoutToHost(event));
         this.emitLayoutChangeAndScheduleSave(event);
     }
     emitLayoutChangeAndScheduleSave(event) {
+        if (this.#layoutPersistenceDisposed)
+            return;
         this.trigger("layout-change", event);
         this.saveLayoutDebounced();
     }
@@ -1730,23 +1787,44 @@ export class Workspace extends EventDispatcher {
             active: this.activeLeaf?.id,
         };
     }
-    async restoreLayoutJson(config) {
-        this.exitFocusMode();
-        const normalized = normalizeWorkspaceJson(config);
+    async restoreLayoutJson(config, live = false, isCurrent = () => true) {
+        if (!live)
+            this.exitFocusMode();
+        const normalized = normalizeWorkspaceJson(config, {
+            preservePopouts: live,
+        });
         await this.activateLayoutPlugins(normalized);
-        const projectionItems = beginWorkspaceProjection(this);
+        if (!isCurrent())
+            return;
+        const projectionItems = beginWorkspaceProjection(this, isCurrent);
         try {
             await Promise.all([
                 this.rootSplit.loadJson(normalized.main, projectionItems),
                 this.leftSplit.loadJson(normalized.left, projectionItems),
                 this.rightSplit.loadJson(normalized.right, projectionItems),
                 this.bottomPanel.loadJson(normalized.bottom, projectionItems),
-                this.floating.loadJson(normalized.floating, projectionItems),
+                this.floating.loadJson(normalized.floating, projectionItems, live
+                    ? (id) => {
+                        const handle = this.#workspaceHostController?.renderer.getPopoutHandle(id);
+                        return handle
+                            ? {
+                                win: handle.window,
+                                doc: handle.document,
+                                focus: () => handle.focus(),
+                                // The controller owns host removal; wrappers only project identity.
+                                close: () => { },
+                                onClose: () => () => { },
+                            }
+                            : null;
+                    }
+                    : undefined),
             ]);
         }
         finally {
-            finishWorkspaceProjection(projectionItems);
+            finishWorkspaceProjection(projectionItems, this);
         }
+        if (!isCurrent())
+            return;
         if (!normalized.active) {
             if (!this.containsLeaf(this.activeLeaf))
                 this.activeLeaf = null;
@@ -1768,7 +1846,7 @@ export class Workspace extends EventDispatcher {
         this.workspaceLayoutFile = file;
         return this.app.telemetry.measureAsync("workspace.load_layout", async (span) => {
             span.setAttribute("workspace.layout_file", file);
-            const workspaceFile = this.app.vault.getFileByPath(joinPath("/.obsidian", file));
+            const workspaceFile = this.app.vault.getFileByPath(joinPath("/", appStatePath(file)));
             this.layoutReady = false;
             if (workspaceFile) {
                 await this.restoreLayoutJson(JSON.parse(await this.app.vault.read(workspaceFile)));
@@ -1814,7 +1892,7 @@ export class Workspace extends EventDispatcher {
             await this.revealLeaf(rightLeaves[0]);
     }
     namedWorkspacesPath() {
-        return joinPath("/.obsidian", NAMED_WORKSPACES_FILE);
+        return joinPath("/", appStatePath(NAMED_WORKSPACES_FILE));
     }
     async readNamedWorkspaceStore() {
         const file = this.app.vault.getFileByPath(this.namedWorkspacesPath());
@@ -1993,12 +2071,30 @@ export class Workspace extends EventDispatcher {
                         values: Object.fromEntries(this.app.configuration.getConfiguration().entries()),
                     }),
                     save: async (snapshot) => {
+                        // Conditional hosts admit changes in bindConfiguration, before debounce.
+                        if (this.app.vault?.supportsConditionalTextWrites)
+                            return;
                         await this.app.configuration.updateConfigurationOptions(snapshot.values);
                     },
                 },
-                plugins: createAppShellPluginPersistence(() => this.app.vault),
+                plugins: createAppShellPluginPersistence(() => this.app.vault, this.app, async (enabled) => {
+                    const plugins = this.#workspaceHostController.plugins;
+                    for (const state of plugins.states) {
+                        if (state.required || typeof enabled[state.id] !== "boolean")
+                            continue;
+                        const success = enabled[state.id]
+                            ? await plugins.enable(state.id)
+                            : await plugins.disable(state.id);
+                        if (!success)
+                            throw new Error(`Could not restore App Shell plugin ${state.id}`);
+                    }
+                }),
             },
         });
+        this.#workspaceHostController.renderer.setCloseGuard(workspaceCloseGuard(this, () => this.#workspaceHostController.renderer.layout.windows.flatMap((win) => {
+            const handle = this.#workspaceHostController.renderer.getPopoutHandle(win.id);
+            return handle ? [handle.document] : [];
+        })));
         setWorkspaceHostBinding(this, {
             controller: this.#workspaceHostController,
         });
@@ -2036,7 +2132,17 @@ export class Workspace extends EventDispatcher {
             });
         });
     }
+    /** Register an owned opener for application-specific diagnostic resources. */
+    registerDiagnosticOpener(opener) {
+        this.#diagnosticOpeners.add(opener);
+        return () => {
+            this.#diagnosticOpeners.delete(opener);
+        };
+    }
     async openDiagnosticLocation(location) {
+        for (const opener of [...this.#diagnosticOpeners])
+            if (await opener(location))
+                return;
         const path = pathFromDiagnosticResource(location.resource);
         if (!path)
             return;
@@ -2070,6 +2176,27 @@ export class Workspace extends EventDispatcher {
         const controller = this.#workspaceHostController;
         if (!controller)
             return;
+        let projecting = false;
+        registerWorkspaceFileSettings(controller.settings);
+        const project = (values) => {
+            projecting = true;
+            try {
+                controller.settings.changeSnapshot({ version: 1, values });
+            }
+            finally {
+                projecting = false;
+            }
+        };
+        const settingsRef = controller.settings.on("change", ({ id }) => {
+            if (projecting || !this.app.vault?.supportsConditionalTextWrites)
+                return;
+            const { values } = controller.settings.getSnapshot();
+            if (id && !Object.hasOwn(values, id))
+                return;
+            const change = this.app.configuration.updateConfigurationOptions(id ? { [id]: values[id] } : values);
+            // The App-owned writer retains failures in the visible conflict registry.
+            void change.catch(() => undefined);
+        });
         const syncAll = () => {
             const snapshot = controller.settings.getSnapshot();
             const apiValues = Object.fromEntries(this.app.configuration.getConfiguration().entries());
@@ -2079,7 +2206,7 @@ export class Workspace extends EventDispatcher {
                     next[key] = apiValues[key];
             }
             if (!isEqual(next, snapshot.values)) {
-                controller.settings.changeSnapshot({ version: 1, values: next });
+                project(next);
             }
         };
         const configurationRef = this.app.configuration.on("updated", ({ key, value }) => {
@@ -2092,13 +2219,14 @@ export class Workspace extends EventDispatcher {
             else
                 next[key] = value;
             if (!isEqual(next, snapshot.values)) {
-                controller.settings.changeSnapshot({ version: 1, values: next });
+                project(next);
             }
         });
         const schemaRef = controller.settings.on("schema-change", syncAll);
         this.#configurationBridgeDisposer = () => {
             this.app.configuration.offref(configurationRef);
             controller.settings.offref(schemaRef);
+            controller.settings.offref(settingsRef);
         };
     }
     /** @internal Connect the API plugin lifecycle to Design Core presentation. */
@@ -2130,11 +2258,13 @@ export class Workspace extends EventDispatcher {
                 const loaded = manager.on("plugins-loaded", listener);
                 const enabled = manager.on("plugin-enabled", listener);
                 const disabled = manager.on("plugin-disabled", listener);
+                const unloaded = manager.on("plugin-unloaded", listener);
                 const error = manager.on("plugin-error", listener);
                 return () => {
                     manager.offref(loaded);
                     manager.offref(enabled);
                     manager.offref(disabled);
+                    manager.offref(unloaded);
                     manager.offref(error);
                 };
             },
@@ -2144,6 +2274,12 @@ export class Workspace extends EventDispatcher {
     }
     /** Dispose the API-owned shell controller and its compatibility bridges. */
     async disposeWorkspaceHost() {
+        await this.#workspaceHostProjection;
+        this.saveLayoutDebounced.cancel();
+        await this.#layoutSaveTail;
+        this.#layoutPersistenceDisposed = true;
+        this.saveLayoutDebounced.cancel();
+        this.app.icons?.dispose();
         this.app.languageServices.unbindDiagnostics();
         this.#configurationBridgeDisposer?.();
         this.#configurationBridgeDisposer = null;
@@ -2160,6 +2296,7 @@ export class Workspace extends EventDispatcher {
         this.#workspaceHostViewDisposers.forEach((dispose) => dispose());
         this.#workspaceHostViewDisposers.clear();
         await this.#workspaceHostController?.dispose();
+        this.#diagnosticOpeners.clear();
     }
     installCommandBridge(controller) {
         const disposers = new Map();
@@ -2208,6 +2345,7 @@ export class Workspace extends EventDispatcher {
     projectStatusBarItem(controller, item, align) {
         controller.status.addItem({
             id: item.id,
+            mount: item.mount,
             align,
             priority: item.priority,
             label: item.text,
@@ -2233,13 +2371,11 @@ export class Workspace extends EventDispatcher {
             for (const id of projectedIds)
                 controller.status.removeItem(id);
             projectedIds.clear();
-            for (const item of this.app.statusBar.getVisibleItems("left", this.app.contextKeys)) {
-                projectedIds.add(item.id);
-                this.projectStatusBarItem(controller, item, "left");
-            }
-            for (const item of this.app.statusBar.getVisibleItems("right", this.app.contextKeys)) {
-                projectedIds.add(item.id);
-                this.projectStatusBarItem(controller, item, "right");
+            for (const align of ["left", "center", "right"]) {
+                for (const item of this.app.statusBar.getVisibleItems(align, this.app.contextKeys)) {
+                    projectedIds.add(item.id);
+                    this.projectStatusBarItem(controller, item, align);
+                }
             }
         };
         const unsubscribeStatus = this.app.statusBar.subscribe(sync);
@@ -2290,9 +2426,19 @@ export class Workspace extends EventDispatcher {
             }
         };
         const changed = notifications.on("changed", sync);
+        const notified = notifications.on("notify", (record) => {
+            controller.notifications.notify({
+                id: record.id,
+                title: record.title,
+                message: record.message,
+                severity: record.severity,
+                source: record.source,
+            });
+        });
         sync();
         this.#notificationProgressBridgeDisposer = () => {
             notifications.offref(changed);
+            notifications.offref(notified);
             for (const handle of projected.values()) {
                 handle.complete();
             }
@@ -2346,7 +2492,10 @@ export class Workspace extends EventDispatcher {
         });
     }
     enqueueWorkspaceHostProjection(layout, event) {
-        const projected = workspaceJsonForCompatibility(normalizeWorkspaceJson(layout));
+        if (this.#layoutPersistenceDisposed)
+            return;
+        const mutationRevision = layoutMutationRevisions.get(this) ?? 0;
+        const projected = workspaceJsonForCompatibility(normalizeWorkspaceJson(layout, { preservePopouts: true }));
         const preserveSidebarWidth = (side, current) => {
             const value = projected[side].width.trim();
             if (/^0(?:px|rem|em|%)?$/.test(value)) {
@@ -2359,13 +2508,26 @@ export class Workspace extends EventDispatcher {
         preserveSidebarWidth("left", this.leftSplit);
         preserveSidebarWidth("right", this.rightSplit);
         const run = this.#workspaceHostProjection.then(async () => {
+            const isCurrent = () => mutationRevision === (layoutMutationRevisions.get(this) ?? 0);
+            if (!isCurrent())
+                return;
             await this.withoutLayoutPersistence(async () => {
-                await this.restoreLayoutJson(projected);
+                await this.restoreLayoutJson(projected, true, isCurrent);
+                if (!isCurrent())
+                    return;
+                this.focusedHostId = this.getCommandHostIdForLeaf(this.activeLeaf);
                 // Sidedock compatibility effects flush after loadJson resolves. Keep
                 // persistence suppressed through that flush so an older queued
                 // projection cannot be committed back over a newer controller layout.
                 await tick();
             });
+            if (!isCurrent()) {
+                this.requestSaveLayout({
+                    source: "api",
+                    operation: "superseded-projection",
+                });
+                return;
+            }
             this.emitLayoutChangeAndScheduleSave(compatibilityLayoutEventFromDesign(event));
         });
         this.#workspaceHostProjection = run.catch((error) => {
@@ -2487,13 +2649,27 @@ export class Workspace extends EventDispatcher {
                 };
             },
             mount: (target, context) => {
-                const leaf = this.getLeafById(context.tab.id);
-                if (!leaf)
-                    return;
-                target.replaceChildren(leaf.containerEl);
+                let active = true;
+                let attached = null;
+                const attach = () => {
+                    if (!active)
+                        return;
+                    const leaf = this.getLeafById(context.tab.id);
+                    if (!leaf || leaf.containerEl.parentElement === target)
+                        return;
+                    attachWorkspaceView(target, leaf);
+                    attached = leaf;
+                };
+                attach();
+                // Controller leaves can render before their compatibility projection.
+                // Reattach the same retained view; do not create another lifecycle owner.
+                void this.#workspaceHostProjection.then(attach).catch((error) => {
+                    console.error("Unable to attach projected workspace view", error);
+                });
                 return () => {
-                    if (leaf.containerEl.parentElement === target) {
-                        leaf.containerEl.remove();
+                    active = false;
+                    if (attached?.containerEl.parentElement === target) {
+                        attached.containerEl.remove();
                     }
                 };
             },
@@ -2565,6 +2741,15 @@ export class Workspace extends EventDispatcher {
      * @public
      */
     async revealLeaf(leaf) {
+        const wasActive = this.activeLeaf === leaf;
+        const revision = layoutMutationRevisions.get(this) ?? 0;
+        await this.#workspaceHostProjection;
+        if (revision !== (layoutMutationRevisions.get(this) ?? 0) ||
+            !this.containsLeaf(leaf))
+            return;
+        recordLayoutMutation(this);
+        if (wasActive)
+            this.activeLeaf = leaf;
         let child = leaf;
         let parent = leaf.parent;
         while (parent) {
@@ -2587,12 +2772,22 @@ export class Workspace extends EventDispatcher {
         if (floatingWindow) {
             this.focusFloatingWindow(floatingWindow);
         }
+        this.requestSaveLayout({ source: "api", operation: "reveal-leaf" });
     }
     registerView(type, viewCreator) {
         this.viewTypes.set(type, viewCreator);
         this.registerWorkspaceHostView(type);
+        for (const listener of this.fileIconListeners)
+            listener();
     }
     registerEditorView(contribution) {
+        const existing = this.editorViews.get(contribution.id);
+        if (existing?.source === "manifest" &&
+            contribution.source === "plugin" &&
+            existing.pluginId &&
+            existing.pluginId === contribution.pluginId) {
+            return this.editorViews.overlay(contribution);
+        }
         return this.editorViews.register(contribution);
     }
     registerSidebarView(type, options = {}) {
@@ -2629,7 +2824,11 @@ export class Workspace extends EventDispatcher {
     unregisterView(type) {
         this.#workspaceHostViewDisposers.get(type)?.();
         this.#workspaceHostViewDisposers.delete(type);
-        return this.viewTypes.delete(type);
+        const removed = this.viewTypes.delete(type);
+        if (removed)
+            for (const listener of this.fileIconListeners)
+                listener();
+        return removed;
     }
     normalizeExtensionKey(extension) {
         const normalized = extension.trim().toLowerCase();
@@ -2642,7 +2841,10 @@ export class Workspace extends EventDispatcher {
         if (!extensionKey) {
             return undefined;
         }
-        return this.viewExtensions.get(extensionKey);
+        return ([...this.iconExtensions.values()]
+            .reverse()
+            .find((entry) => entry.keys.includes(extensionKey))?.viewType ??
+            this.viewExtensions.get(extensionKey));
     }
     resolveViewTypeForPath(path) {
         const normalizedPath = path.trim().toLowerCase();
@@ -2669,13 +2871,14 @@ export class Workspace extends EventDispatcher {
             .replace(/[._-]+/g, " ")
             .replace(/\b\w/gu, (char) => char.toUpperCase());
     }
-    registeredEditorViewForPath(path) {
+    registeredEditorViewForPath(path, metadataOnly = false) {
         return this.editorViews
             .getAll()
             .flatMap((view, viewIndex) => view.filenamePatterns
             .filter((pattern) => matchesEditorAssociationGlob(pattern, path))
             .map((pattern) => ({ view, viewIndex, pattern })))
-            .filter(({ view }) => this.viewTypes.has(view.viewType))
+            .filter(({ view }) => this.viewTypes.has(view.viewType) ||
+            (metadataOnly && view.source === "manifest"))
             .sort((left, right) => {
             const priority = { option: 0, default: 1, exclusive: 2 };
             const priorityDelta = priority[right.view.priority] - priority[left.view.priority];
@@ -2722,7 +2925,55 @@ export class Workspace extends EventDispatcher {
         }
         return this.registeredEditorViewForPath(path)?.viewType;
     }
-    registerExtensions(extensions, viewType) {
+    /** Resolve presentation metadata without activating plugins or creating views. */
+    getFileIconForPath(path) {
+        const association = this.getEditorAssociationForPath(path)?.view;
+        const eligible = association &&
+            (this.viewTypes.has(association.viewType) ||
+                association.source === "manifest");
+        return (eligible ? association : this.registeredEditorViewForPath(path, true))?.fileIcon;
+    }
+    onFileIconsChanged(listener) {
+        this.fileIconListeners.add(listener);
+        const view = this.editorViews.on("changed", listener);
+        const config = this.app.configuration.on("updated", ({ key }) => {
+            if (key === "workspace.editorAssociations")
+                listener();
+        });
+        return () => {
+            this.fileIconListeners.delete(listener);
+            this.editorViews.offref(view);
+            this.app.configuration.offref(config);
+        };
+    }
+    registerExtensions(extensions, viewType, options) {
+        if (options) {
+            const keys = [
+                ...new Set(extensions
+                    .map((ext) => this.normalizeExtensionKey(ext))
+                    .filter(Boolean)),
+            ];
+            if (!keys.length)
+                return () => { };
+            const id = `compat:${viewType}:${++this.iconExtensionSequence}`;
+            const dispose = this.editorViews.register({
+                id,
+                viewType,
+                label: this.humanizeViewType(viewType),
+                filenamePatterns: keys.map((key) => this.extensionKeyToFilenamePattern(key)),
+                priority: "default",
+                source: "compat",
+                fileIcon: options.fileIcon,
+            });
+            const entry = { keys, viewType, dispose };
+            this.iconExtensions.set(id, entry);
+            return () => {
+                if (this.iconExtensions.get(id) !== entry)
+                    return;
+                this.iconExtensions.delete(id);
+                dispose();
+            };
+        }
         const filenamePatterns = [];
         extensions.forEach((ext) => {
             const extensionKey = this.normalizeExtensionKey(ext);
@@ -2733,12 +2984,12 @@ export class Workspace extends EventDispatcher {
             filenamePatterns.push(this.extensionKeyToFilenamePattern(extensionKey));
         });
         if (filenamePatterns.length === 0) {
-            return;
+            return () => { };
         }
         const existing = this.editorViews.getByViewType(viewType)[0];
         if (existing) {
             this.editorViews.update(existing.id, { filenamePatterns });
-            return;
+            return () => this.unregisterExtensions(extensions, viewType);
         }
         this.editorViews.upsert({
             id: viewType,
@@ -2748,8 +2999,19 @@ export class Workspace extends EventDispatcher {
             priority: "default",
             source: "compat",
         });
+        return () => this.unregisterExtensions(extensions, viewType);
     }
     unregisterExtensions(extensions, viewType) {
+        const removed = new Set(extensions.map((ext) => this.normalizeExtensionKey(ext)));
+        for (const [id, entry] of this.iconExtensions) {
+            if (entry.viewType !== viewType)
+                continue;
+            entry.keys = entry.keys.filter((key) => !removed.has(key));
+            if (!entry.keys.length) {
+                this.iconExtensions.delete(id);
+                entry.dispose();
+            }
+        }
         const filenamePatterns = [];
         extensions.forEach((ext) => {
             const extensionKey = this.normalizeExtensionKey(ext);
@@ -2900,6 +3162,11 @@ export class Workspace extends EventDispatcher {
         }
         return this.lastActiveFile;
     }
+    /** Reconcile the remembered file through its workspace owner. */
+    reconcileFileReference(oldPath, file) {
+        if (this.lastActiveFile?.path === oldPath)
+            this.lastActiveFile = file?.copy() ?? null;
+    }
     /**
      * Iterate through all leaves, including main area leaves, floating leaves,
      * and sidebar leaves.
@@ -3023,6 +3290,8 @@ export class Workspace extends EventDispatcher {
         if (!this.containsLeaf(leaf)) {
             return false;
         }
+        if (options.source !== "layout-load")
+            recordLayoutMutation(this);
         const tabs = this.tabsForLeaf(leaf);
         if (leaf.parent instanceof WorkspaceSidebarGroup) {
             leaf.parent.selectLeaf(leaf);
@@ -3676,7 +3945,9 @@ export class Workspace extends EventDispatcher {
             this.app.workspace.activeLeaf = duplicateLeaf;
             this.app.workspace.requestSaveLayout({
                 source: "api",
-                operation: leafType === "split" ? `duplicate-leaf-${direction}` : "duplicate-leaf-tab",
+                operation: leafType === "split"
+                    ? `duplicate-leaf-${direction}`
+                    : "duplicate-leaf-tab",
             });
             return duplicateLeaf;
         });
@@ -3889,7 +4160,7 @@ export class OnDemandPluginInstallView extends FileView {
 function canReuseLeafForFileNavigation(leaf) {
     if (!leaf)
         return false;
-    return (leaf.view.getViewType() === "empty" || leaf.view instanceof FileView);
+    return leaf.view.getViewType() === "empty" || leaf.view instanceof FileView;
 }
 function isPoorerViewState(incoming, live) {
     const next = incoming ?? {};
@@ -3900,6 +4171,25 @@ function isPoorerViewState(incoming, live) {
         return true;
     return liveEntries.some(([key]) => !(key in next));
 }
+function loadWorkspaceLeafJson(leaf, layout, isCurrent = () => true) {
+    if (!isCurrent())
+        return Promise.resolve();
+    leaf.id = layout.id;
+    const liveState = leaf.view.getState();
+    if (leaf.view.getViewType() === layout.state.type &&
+        (isEqual(liveState, layout.state.state) ||
+            isPoorerViewState(layout.state.state, liveState))) {
+        leaf.state = { type: layout.state.type, state: { ...liveState } };
+        return Promise.resolve();
+    }
+    return leaf.setViewState({ type: layout.state.type, state: layout.state.state }, {
+        history: true,
+        layoutProjection: true,
+        projectionIsCurrent: isCurrent,
+        title: layout.state.title,
+        icon: layout.state.icon,
+    });
+}
 function collectLayoutViewTypes(node, target) {
     if (node.type === "split" || node.type === "floating") {
         for (const child of node.children) {
@@ -3914,8 +4204,8 @@ function collectLayoutViewTypes(node, target) {
     }
 }
 /**
- * Compatibility stand-in for a Design Core class view. The host owns the
- * live mount; this view only preserves type and chrome across API commits.
+ * Compatibility stand-in for a Design Core class view. The host owns the live
+ * mount; this view only preserves type and chrome across API commits.
  */
 class HostOwnedWorkspaceView extends View {
     #viewType;
@@ -4170,6 +4460,9 @@ export class WorkspaceLeaf extends WorkspaceItem {
         });
     }
     async setViewState(viewState, eState) {
+        if (!eState?.layoutProjection)
+            recordLayoutMutation(this.app.workspace);
+        const isCurrent = eState?.projectionIsCurrent ?? (() => true);
         return this.app.telemetry.measureAsync("workspace.leaf.set_view_state", async (span) => {
             span.setAttribute("leaf.id", this.id);
             span.setAttribute("view.type", viewState.type);
@@ -4184,13 +4477,19 @@ export class WorkspaceLeaf extends WorkspaceItem {
             if (requestedViewType === ON_DEMAND_PLUGIN_INSTALL_VIEW_TYPE &&
                 file instanceof TFile) {
                 const promptView = await this.app.workspace.createOnDemandPluginInstallView(this, file, { confirm: false });
+                if (!isCurrent())
+                    return;
                 if (promptView) {
-                    this.state = viewState;
-                    this.pinned = !!viewState.pinned;
                     const result = {
                         history: eState?.history === true,
                     };
                     await promptView.setState({ ...(viewState.state || {}) });
+                    if (!isCurrent()) {
+                        promptView.unload();
+                        return;
+                    }
+                    this.state = viewState;
+                    this.pinned = !!viewState.pinned;
                     await this.open(promptView, result, viewState);
                     return;
                 }
@@ -4198,6 +4497,8 @@ export class WorkspaceLeaf extends WorkspaceItem {
             if (eState?.activatePlugins !== false) {
                 await this.app.plugins.activateForViewType(requestedViewType);
             }
+            if (!isCurrent())
+                return;
             let viewCreator = this.app.workspace.viewCreator(requestedViewType);
             let resolvedViewState = viewState;
             if (viewCreator && persistedMissingViewType) {
@@ -4238,11 +4539,17 @@ export class WorkspaceLeaf extends WorkspaceItem {
                     this.app.workspace.viewCreator("empty") ||
                         ((leaf) => new EmptyView(leaf));
             }
-            this.state = resolvedViewState;
-            this.pinned = !!viewState.pinned;
             const view = viewCreator(this);
             const result = { history: eState?.history === true };
             await view.setState({ ...(resolvedViewState.state || {}) });
+            if (!isCurrent()) {
+                view.unload();
+                if (hasDestroyableEditor(view))
+                    view.editor.destroy();
+                return;
+            }
+            this.state = resolvedViewState;
+            this.pinned = !!viewState.pinned;
             await this.open(view, result, resolvedViewState);
         }, {
             attributes: {
@@ -4298,25 +4605,7 @@ export class WorkspaceLeaf extends WorkspaceItem {
         this.parent.removeChild(this);
     }
     loadJson(layout) {
-        this.id = layout.id;
-        const liveState = this.view.getState();
-        if (this.view.getViewType() === layout.state.type &&
-            (isEqual(liveState, layout.state.state) ||
-                isPoorerViewState(layout.state.state, liveState))) {
-            this.state = {
-                type: layout.state.type,
-                state: { ...liveState },
-            };
-            return Promise.resolve();
-        }
-        return this.setViewState({
-            type: layout.state.type,
-            state: layout.state.state,
-        }, {
-            history: true,
-            title: layout.state.title,
-            icon: layout.state.icon,
-        });
+        return loadWorkspaceLeafJson(this, layout);
     }
     reload() {
         this.loadJson(this.toJson());