@lapis-notes/api 0.1.0

package/dist/workspace.svelte.js

@@ -0,0 +1,4380 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { EventDispatcher } from "./events";
+import { EmptyView, FileView, ItemView, TextFileView, View, } from "./view.svelte";
+import { Menu, isMenuItem } from "./menu.svelte";
+import { TFile } from "./storage/fs";
+import { tick, untrack } from "svelte";
+import { toast } from "svelte-sonner";
+import { SidebarState, } from "@lapis-notes/ui/sidebar-custom";
+import { uniqueId } from "./utils";
+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 { basename, dirname, joinPath } from "./storage";
+import { HistoryManager } from "./history.svelte";
+import { EditorViewRegistry, } from "./editor-view-registry";
+import { compareEditorAssociationPatternSpecificity, matchesEditorAssociationGlob, } from "./glob";
+import { captureLeafViewState, cloneViewState, historyFilePathForViewState, resolveViewForOpenFile, } from "./open-file";
+import { promptConfirm } from "./prompt-confirm";
+import { isAbortError, withPluginInstallProgress, } from "./plugin-install-progress";
+import { AppShellController, WorkspaceMenu as DesignWorkspaceMenu, } from "@lapismd/design-core/workspace/core";
+import { notificationsPlugin } from "@lapismd/design-core/workspace/plugins/notifications";
+import { fModePlugin } from "@lapismd/design-core/workspace/plugins/fmode";
+import { problemsPlugin, PROBLEMS_VIEW_TYPE, } from "@lapismd/design-core/workspace/problems";
+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 { 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]";
+const FILE_EXPLORER_REVEAL_PATH_COMMAND = "lapis-file-explorer:reveal-path";
+const DEFAULT_LEFT_SIDEBAR_VIEW_TYPES = [
+    "file-explorer",
+    "search",
+    "bookmarks",
+];
+const DEFAULT_RIGHT_SIDEBAR_VIEW_TYPES = [
+    "outline",
+    "file-properties",
+    "tag",
+];
+function normalizeHintText(value) {
+    return value?.replace(/\s+/gu, " ").trim() ?? "";
+}
+function filePathBreadcrumbs(app, filePath) {
+    if (!filePath)
+        return [];
+    const parts = dirname(filePath)
+        .split("/")
+        .filter((segment) => segment.length > 0);
+    return parts.map((label, index) => {
+        const path = parts.slice(0, index + 1).join("/");
+        return {
+            id: path,
+            label,
+            onSelect: () => {
+                void app.commands.executeCommand(FILE_EXPLORER_REVEAL_PATH_COMMAND, path);
+            },
+        };
+    });
+}
+function menuItemTitle(title) {
+    return typeof title === "string" ? title : (title.textContent ?? "");
+}
+export function appendLapisMenuToWorkspaceMenu(target, source) {
+    for (const entries of Object.values(source.renderedItems)) {
+        if (entries.length === 0)
+            continue;
+        if (target.entries.length > 0)
+            target.addSeparator();
+        for (const entry of entries) {
+            if (entry === "separator") {
+                target.addSeparator();
+                continue;
+            }
+            if (isMenuItem(entry)) {
+                target.addItem((item) => {
+                    item
+                        .setTitle(menuItemTitle(entry.title))
+                        .setDisabled(entry.disabled)
+                        .setSection(entry.section)
+                        .onClick((event) => entry.click(event));
+                    if (entry.icon)
+                        item.setIcon(entry.icon);
+                    if (entry.checked !== null)
+                        item.setChecked(entry.checked);
+                });
+                continue;
+            }
+            target.addMenu(entry.title, (submenu) => appendLapisMenuToWorkspaceMenu(submenu, entry));
+        }
+    }
+}
+function prependPaneMenu(target, source) {
+    const translated = new DesignWorkspaceMenu();
+    appendLapisMenuToWorkspaceMenu(translated, source);
+    if (translated.entries.length === 0)
+        return;
+    if (target.entries.length > 0)
+        translated.addSeparator();
+    target.entries.unshift(...translated.entries);
+}
+function replaceWorkspaceHostSplitActions(target, workspace, leaf) {
+    for (const entry of target.entries) {
+        if (entry.kind !== "item")
+            continue;
+        const direction = entry.title === "Split right"
+            ? "vertical"
+            : entry.title === "Split down"
+                ? "horizontal"
+                : null;
+        if (!direction)
+            continue;
+        entry.callback = async () => {
+            await workspace.duplicateLeaf(leaf, "split", direction);
+        };
+    }
+}
+function toDesignEditorViewContribution(contribution) {
+    return {
+        id: contribution.id,
+        viewType: contribution.viewType,
+        label: contribution.label,
+        description: contribution.description,
+        filenamePatterns: [...contribution.filenamePatterns],
+        priority: contribution.priority,
+        pluginId: contribution.pluginId,
+        source: contribution.source === "manifest"
+            ? "plugin"
+            : (contribution.source ?? "compat"),
+    };
+}
+function isHintTargetDisabled(element) {
+    if (element.getAttribute("aria-disabled") === "true") {
+        return true;
+    }
+    return "disabled" in element && Boolean(element.disabled);
+}
+function isHintTargetVisible(element) {
+    if (element.getAttribute("aria-hidden") === "true") {
+        return false;
+    }
+    const rect = element.getBoundingClientRect?.();
+    if (rect && rect.width === 0 && rect.height === 0) {
+        return false;
+    }
+    return true;
+}
+export class WorkspaceItem extends EventDispatcher {
+    parent;
+    #workspace = null;
+    id = uniqueId();
+    constructor() {
+        super();
+    }
+    /** Bind a root workspace item to its owning workspace. */
+    bindWorkspace(workspace) {
+        this.#workspace = workspace;
+        this._root = undefined;
+        return this;
+    }
+    /** The workspace that owns this item, when it has been attached. */
+    get workspace() {
+        return this.#workspace ?? this.parent?.workspace;
+    }
+    /** The application that owns this item, when it has been attached. */
+    get application() {
+        return this.workspace?.app;
+    }
+    /** Resolve the owning application before using the compatibility alias. */
+    get app() {
+        return resolveApplication(this.application);
+    }
+    _root = undefined;
+    getRoot() {
+        if (this._root) {
+            return this._root;
+        }
+        let parent = this.parent;
+        while (parent.parent) {
+            parent = parent.parent;
+        }
+        this._root = parent;
+        return parent;
+    }
+}
+export class WorkspaceParent extends WorkspaceItem {
+    constructor() {
+        super();
+    }
+}
+function collectWorkspaceProjectionItem(item, items) {
+    items.set(item.id, item);
+    if (item instanceof WorkspaceSplit) {
+        item.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    }
+    else if (item instanceof WorkspaceTabs) {
+        item.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    }
+    else if (item instanceof WorkspaceSidebarGroup) {
+        item.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    }
+    else if (item instanceof WorkspaceFloating) {
+        item.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    }
+}
+function beginWorkspaceProjection(workspace) {
+    const items = new Map();
+    workspace.rootSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    workspace.leftSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    workspace.rightSplit.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    workspace.bottomPanel.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    workspace.floating.children.forEach((child) => collectWorkspaceProjectionItem(child, items));
+    return items;
+}
+function claimWorkspaceProjectionItem(projectionItems, id, matches, create) {
+    const item = projectionItems?.get(id);
+    if (item && matches(item)) {
+        projectionItems?.delete(id);
+        item._root = undefined;
+        return item;
+    }
+    return create();
+}
+function finishWorkspaceProjection(projectionItems) {
+    for (const item of projectionItems.values()) {
+        if (item instanceof WorkspaceLeaf) {
+            item.view.unload();
+            if (hasDestroyableEditor(item.view))
+                item.view.editor.destroy();
+        }
+        else if (item instanceof WorkspaceWindow) {
+            item.closePopoutWindow();
+        }
+    }
+}
+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;
+export function setWorkspacePopoutHost(host) {
+    workspacePopoutHost = host;
+}
+export function getWorkspacePopoutHost() {
+    return workspacePopoutHost;
+}
+export function supportsWorkspacePopouts() {
+    return workspacePopoutHost?.supportsPopouts() === true;
+}
+function openWorkspacePopoutHandle(data) {
+    if (!supportsWorkspacePopouts()) {
+        return null;
+    }
+    return workspacePopoutHost?.openWindow(data) ?? null;
+}
+export class WorkspaceSplit extends WorkspaceParent {
+    type = $state("vertical");
+    children = $state([]);
+    sizes = $state([]);
+    constructor(type = "vertical") {
+        super();
+        this.type = type;
+    }
+    loadJson(layout, projectionItems) {
+        const promises = [];
+        this.children.slice().forEach((it) => this.removeChild(it, true));
+        const sizes = layout.sizes || [];
+        layout.children.forEach((child, i) => {
+            if (child.type === "tabs") {
+                const tabs = claimWorkspaceProjectionItem(projectionItems, child.id, (item) => item instanceof WorkspaceTabs, () => new WorkspaceTabs({ leaves: [] }));
+                this.addChild(tabs);
+                promises.push(tabs.loadJson(child, projectionItems));
+            }
+            else if (child.type === "split") {
+                const split = claimWorkspaceProjectionItem(projectionItems, child.id, (item) => item instanceof WorkspaceView, () => new WorkspaceView(child.direction));
+                this.addChild(split);
+                promises.push(split.loadJson(child, projectionItems));
+            }
+            this.sizes[i] = sizes[i] ?? 50;
+        });
+        return Promise.all(promises).then(() => {
+            this.id = layout.id;
+            this.type = layout.direction;
+        });
+    }
+    toJson() {
+        return {
+            id: this.id,
+            direction: this.type,
+            sizes: this.sizes.slice(),
+            type: "split",
+            children: this.children.map((it) => it.toJson()),
+        };
+    }
+    addChild(child, index) {
+        if (typeof index === "number" &&
+            index >= 0 &&
+            index <= this.children.length) {
+            this.children.splice(index, 0, child);
+            this.sizes.splice(index, 0, 50);
+        }
+        else {
+            this.children.push(child);
+            this.sizes.push(50);
+        }
+        child.parent = this;
+    }
+    iterateAllSplits(callback) {
+        const response = callback(this);
+        if (response !== undefined && response !== null) {
+            return response;
+        }
+        for (const child of this.children) {
+            if (child instanceof WorkspaceSplit) {
+                const response = child.iterateAllSplits(callback);
+                if (response !== undefined && response !== null) {
+                    return response;
+                }
+            }
+        }
+    }
+    iterateAllTabs(callback) {
+        for (const child of this.children) {
+            if (child instanceof WorkspaceTabs) {
+                const response = callback(child);
+                if (response !== undefined && response !== null) {
+                    return response;
+                }
+            }
+            else {
+                const response = child.iterateAllTabs(callback);
+                if (response !== undefined && response !== null) {
+                    return response;
+                }
+            }
+        }
+    }
+    iterateAllLeaves(callback) {
+        for (const child of this.children) {
+            const response = child.iterateAllLeaves(callback);
+            if (response !== undefined && response !== null) {
+                return response;
+            }
+        }
+    }
+    onEmpty() {
+        tick().then(() => this.addChild(new WorkspaceTabs()));
+    }
+    removeChild(index, softDelete = false) {
+        if (typeof index === "number") {
+            const child = this.children[index];
+            if (child) {
+                this.children.splice(index, 1);
+                this.sizes.splice(index, 1);
+                if (!softDelete &&
+                    !this.children.length &&
+                    this.parent instanceof WorkspaceView) {
+                    this.parent.removeChild(this);
+                }
+            }
+            if (!softDelete && !this.children.length && !this.parent) {
+                this.onEmpty();
+            }
+            return child;
+        }
+        else {
+            return this.removeChild(this.children.findIndex((it) => it === index), softDelete);
+        }
+    }
+    get topLeft() {
+        return this.iterateAllTabs((tab) => tab);
+    }
+    get topRight() {
+        return topRightView(this);
+    }
+}
+function topRightView(view) {
+    if (view instanceof WorkspaceSplit) {
+        if (view.type === "vertical") {
+            return topRightView(view.children[view.children.length - 1]);
+        }
+        else {
+            return topRightView(view.children[0]);
+        }
+    }
+    return view;
+}
+export class WorkspaceView extends WorkspaceSplit {
+}
+/**
+ * Collapsible split container used for the left and right workspace sidebars.
+ *
+ * @public
+ */
+export class WorkspaceSidedock extends WorkspaceSplit {
+    open = $state(true);
+    sidebar;
+    constructor(options = {}) {
+        super();
+        const { initialOpen = true, ...sidebarOptions } = options;
+        this.open = initialOpen;
+        let initialized = false;
+        this.sidebar = new SidebarState({
+            id: this.id,
+            ...sidebarOptions,
+            open: () => this.open,
+            setOpen: (value) => {
+                this.open = value;
+            },
+        });
+        $effect(() => {
+            this.trigger("sidebar-changed", this.sidebar.props.id, this.sidebar.open, this.sidebar.width);
+            if (initialized)
+                this.app.workspace.requestSaveLayout();
+            initialized = true;
+        });
+    }
+    loadJson(layout, projectionItems) {
+        return super.loadJson(layout, projectionItems).then(() => {
+            if (/^0(?:px|rem|em|%)?$/.test(layout.width.trim())) {
+                this.open = false;
+            }
+            else {
+                this.open = true;
+                this.sidebar.width = layout.width;
+            }
+        });
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            width: this.collapsed ? "0" : this.sidebar.width,
+        };
+    }
+    onEmpty() { }
+    get size() {
+        return this.sidebar.size;
+    }
+    get collapsed() {
+        return !this.open;
+    }
+    toggle() {
+        this.open = !this.open;
+    }
+    collapse() {
+        this.open = false;
+    }
+    expand() {
+        this.open = true;
+    }
+}
+export class WorkspaceContainer extends WorkspaceSplit {
+}
+export class WorkspaceRoot extends WorkspaceContainer {
+    win;
+    doc;
+    constructor(win = window, doc = document) {
+        super();
+        this.win = win;
+        this.doc = doc;
+    }
+}
+export class WorkspaceWindow extends WorkspaceContainer {
+    mode = $state("floating");
+    displayState = $state("normal");
+    x = $state(96);
+    y = $state(96);
+    width = $state(480);
+    height = $state(320);
+    win;
+    doc;
+    focusHost = null;
+    closeHost = null;
+    detachHostClose = null;
+    constructor(data = {}, win = window, doc = document) {
+        super();
+        this.win = win;
+        this.doc = doc;
+        this.applyInitData(data);
+    }
+    applyInitData(data = {}) {
+        this.mode = data.mode ?? "floating";
+        this.displayState =
+            data.displayState === "collapsed" || data.displayState === "minimized"
+                ? data.displayState
+                : "normal";
+        this.x = data.x ?? 96;
+        this.y = data.y ?? 96;
+        this.width = data.size?.width ?? 480;
+        this.height = data.size?.height ?? 320;
+    }
+    attachPopoutHandle(handle, onClose) {
+        this.mode = "popout";
+        this.win = handle.win;
+        this.doc = handle.doc;
+        this.focusHost = () => handle.focus();
+        this.closeHost = () => handle.close();
+        this.detachHostClose?.();
+        this.detachHostClose = handle.onClose(onClose);
+    }
+    focusPopoutWindow() {
+        this.focusHost?.();
+    }
+    closePopoutWindow() {
+        const detach = this.detachHostClose;
+        this.detachHostClose = null;
+        detach?.();
+        const close = this.closeHost;
+        this.closeHost = null;
+        this.focusHost = null;
+        close?.();
+    }
+    loadWindowJson(layout, projectionItems) {
+        return super
+            .loadJson({
+            id: layout.id,
+            type: "split",
+            direction: layout.direction,
+            sizes: layout.sizes,
+            children: layout.children,
+        }, projectionItems)
+            .then(() => {
+            this.id = layout.id;
+            this.applyInitData({
+                mode: layout.mode,
+                displayState: layout.displayState,
+                x: layout.x,
+                y: layout.y,
+                size: { width: layout.width, height: layout.height },
+            });
+        });
+    }
+    toWindowJson() {
+        const layout = super.toJson();
+        const displayState = this.displayState === "collapsed" || this.displayState === "minimized"
+            ? this.displayState
+            : undefined;
+        return {
+            ...layout,
+            type: "floating",
+            mode: this.mode,
+            ...(displayState ? { displayState } : {}),
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+        };
+    }
+    setBounds(bounds) {
+        if (typeof bounds.x === "number")
+            this.x = bounds.x;
+        if (typeof bounds.y === "number")
+            this.y = bounds.y;
+        if (typeof bounds.width === "number")
+            this.width = bounds.width;
+        if (typeof bounds.height === "number")
+            this.height = bounds.height;
+    }
+    setDisplayState(displayState) {
+        this.displayState = displayState;
+    }
+    removeChild(index, softDelete = false) {
+        const child = super.removeChild(index, softDelete);
+        if (!softDelete && !this.children.length) {
+            this.closePopoutWindow();
+            this.parent.removeChild(this);
+        }
+        return child;
+    }
+}
+function hasDestroyableEditor(view) {
+    const candidate = view;
+    return typeof candidate.editor?.destroy === "function";
+}
+export class WorkspaceFloating extends WorkspaceParent {
+    children = $state([]);
+    loadJson(layouts = [], projectionItems) {
+        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 (child.mode !== "popout") {
+                    return;
+                }
+                const handle = openWorkspacePopoutHandle({
+                    x: child.x,
+                    y: child.y,
+                    size: { width: child.width, height: child.height },
+                    mode: "popout",
+                });
+                if (!handle) {
+                    child.mode = "floating";
+                    return;
+                }
+                child.attachPopoutHandle(handle, () => {
+                    if (this.app.workspace.floating.children.includes(child)) {
+                        this.app.workspace.closeFloatingWindow(child, {
+                            closeHost: false,
+                            operation: "close-popout-window",
+                        });
+                    }
+                });
+            }));
+        });
+        return Promise.all(promises);
+    }
+    toJson() {
+        return this.children.map((child) => child.toWindowJson());
+    }
+    addChild(child, index) {
+        if (typeof index === "number" &&
+            index >= 0 &&
+            index <= this.children.length) {
+            this.children.splice(index, 0, child);
+        }
+        else {
+            this.children.push(child);
+        }
+        child.parent = this;
+    }
+    bringToFront(child) {
+        const index = this.children.findIndex((candidate) => candidate === child);
+        if (index === -1 || index === this.children.length - 1) {
+            return;
+        }
+        this.children.splice(index, 1);
+        this.children.push(child);
+    }
+    removeChild(index, softDelete = false) {
+        if (index instanceof WorkspaceWindow) {
+            return this.removeChild(this.children.findIndex((child) => child === index), softDelete);
+        }
+        const child = this.children[index];
+        if (child) {
+            this.children.splice(index, 1);
+            if (!softDelete && this.app.workspace.activeLeaf) {
+                const activeLeaf = this.app.workspace.activeLeaf;
+                const stillContained = child.iterateAllLeaves((leaf) => leaf === activeLeaf || undefined);
+                if (stillContained) {
+                    this.app.workspace.activeLeaf = this.app.workspace.activeRootLeaf;
+                }
+            }
+        }
+        return child;
+    }
+    iterateAllLeaves(callback) {
+        for (const child of this.children) {
+            const response = child.iterateAllLeaves(callback);
+            if (response !== undefined && response !== null) {
+                return response;
+            }
+        }
+    }
+}
+export class WorkspaceMobileDrawer extends WorkspaceParent {
+    collapsed = false;
+    expand() {
+        this.collapsed = false;
+    }
+    collapse() {
+        this.collapsed = true;
+    }
+    toggle() {
+        this.collapsed = !this.collapsed;
+    }
+}
+function isSidebarGroupJson(value) {
+    return value.type === "sidebar-group";
+}
+function normalizeSidebarGroupId(group) {
+    return group.trim();
+}
+/**
+ * Sidebar-only container that groups leaves into a named view container.
+ *
+ * @public
+ */
+export class WorkspaceSidebarGroup extends WorkspaceParent {
+    name = $state("");
+    icon = $state(undefined);
+    hiddenLeafIds = $state([]);
+    collapsed = $state({});
+    panelSizes = $state({});
+    selectedLeafId = $state(undefined);
+    children = $state([]);
+    constructor(options = {}) {
+        super();
+        if (options.id) {
+            this.id = options.id;
+        }
+        this.name = options.name ?? options.id ?? "";
+        this.icon = options.icon;
+        this.hiddenLeafIds = [...(options.hiddenLeafIds ?? [])];
+        this.collapsed = { ...(options.collapsed ?? {}) };
+        this.panelSizes = { ...(options.panelSizes ?? {}) };
+    }
+    detach(softDelete = false) {
+        return this.parent.removeChild(this, softDelete);
+    }
+    addChild(child, index) {
+        const oldIndex = this.children.findIndex((it) => it === child);
+        if (child.parent && child.parent !== this) {
+            child.detach();
+        }
+        if (oldIndex !== -1) {
+            this.children.splice(oldIndex, 1);
+        }
+        if (typeof index === "number") {
+            const boundedIndex = Math.max(0, Math.min(index, this.children.length));
+            this.children.splice(boundedIndex, 0, child);
+        }
+        else {
+            this.children.push(child);
+        }
+        child.parent = this;
+    }
+    removeChild(index, softDelete = false) {
+        void softDelete;
+        if (index instanceof WorkspaceLeaf) {
+            return this.removeChild(this.children.findIndex((it) => it === index));
+        }
+        const child = this.children[index];
+        if (!child) {
+            return undefined;
+        }
+        this.children.splice(index, 1);
+        this.hiddenLeafIds = this.hiddenLeafIds.filter((id) => id !== child.id);
+        this.collapsed = Object.fromEntries(Object.entries(this.collapsed).filter(([id]) => id !== child.id));
+        this.panelSizes = Object.fromEntries(Object.entries(this.panelSizes).filter(([id]) => id !== child.id));
+        if (!this.children.length && !softDelete) {
+            this.parent.removeChild(this);
+        }
+        if (this.app.workspace.activeLeaf === child) {
+            this.app.workspace.activeLeaf = this.getSelectedLeaf();
+        }
+        return child;
+    }
+    getSelectedLeaf() {
+        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);
+    }
+    selectLeaf(leaf) {
+        if (!this.children.includes(leaf)) {
+            return;
+        }
+        this.selectedLeafId = leaf.id;
+        if (this.isLeafHidden(leaf)) {
+            this.setLeafHidden(leaf, false);
+        }
+    }
+    iterateAllLeaves(callback) {
+        for (const child of this.children) {
+            const response = callback(child);
+            if (response !== undefined && response !== null) {
+                return response;
+            }
+        }
+    }
+    isLeafHidden(leaf) {
+        const id = typeof leaf === "string" ? leaf : leaf.id;
+        return this.hiddenLeafIds.includes(id);
+    }
+    setLeafHidden(leaf, hidden) {
+        const id = typeof leaf === "string" ? leaf : leaf.id;
+        const ids = new Set(this.hiddenLeafIds);
+        if (hidden) {
+            ids.add(id);
+        }
+        else {
+            ids.delete(id);
+        }
+        this.hiddenLeafIds = [...ids];
+        this.app.workspace.requestSaveLayout();
+    }
+    isLeafCollapsed(leaf) {
+        const id = typeof leaf === "string" ? leaf : leaf.id;
+        return this.collapsed[id] ?? false;
+    }
+    setLeafCollapsed(leaf, collapsed) {
+        const id = typeof leaf === "string" ? leaf : leaf.id;
+        this.collapsed = { ...this.collapsed, [id]: collapsed };
+        this.app.workspace.requestSaveLayout();
+    }
+    getLeafPanelSize(leaf) {
+        const id = typeof leaf === "string" ? leaf : leaf.id;
+        return this.panelSizes[id];
+    }
+    setPanelSizes(leaves, sizes) {
+        const next = { ...this.panelSizes };
+        leaves.forEach((leaf, index) => {
+            const size = sizes[index];
+            if (Number.isFinite(size) && size > 0) {
+                next[leaf.id] = Number(size.toFixed(4));
+            }
+        });
+        this.panelSizes = next;
+        this.app.workspace.requestSaveLayout();
+    }
+    serializedPanelSizes() {
+        const childIds = new Set(this.children.map((leaf) => leaf.id));
+        return Object.fromEntries(Object.entries(this.panelSizes).filter(([id, size]) => childIds.has(id) && Number.isFinite(size) && size > 0));
+    }
+    loadJson(layout, projectionItems) {
+        const promises = [];
+        this.children.slice().forEach((it) => this.removeChild(it, true));
+        layout.children.forEach((config) => {
+            const leaf = claimWorkspaceProjectionItem(projectionItems, config.id, (item) => item instanceof WorkspaceLeaf, () => new WorkspaceLeaf());
+            this.addChild(leaf);
+            promises.push(leaf.loadJson(config));
+        });
+        return Promise.all(promises).then(() => {
+            this.id = layout.id;
+            this.name = layout.name;
+            this.icon = layout.icon;
+            this.hiddenLeafIds = [...(layout.hiddenLeafIds ?? [])];
+            this.collapsed = { ...(layout.collapsed ?? {}) };
+            this.panelSizes = { ...(layout.panelSizes ?? {}) };
+            this.selectedLeafId = this.children.some((leaf) => leaf.id === layout.selectedLeafId)
+                ? layout.selectedLeafId
+                : undefined;
+        });
+    }
+    toJson() {
+        const panelSizes = this.serializedPanelSizes();
+        const selectedLeaf = this.getSelectedLeaf();
+        return {
+            id: this.id,
+            type: "sidebar-group",
+            name: this.name,
+            ...(this.icon ? { icon: this.icon } : {}),
+            ...(this.hiddenLeafIds.length
+                ? { hiddenLeafIds: [...this.hiddenLeafIds] }
+                : {}),
+            ...(Object.keys(this.collapsed).length
+                ? { collapsed: { ...this.collapsed } }
+                : {}),
+            ...(Object.keys(panelSizes).length ? { panelSizes } : {}),
+            ...(selectedLeaf ? { selectedLeafId: selectedLeaf.id } : {}),
+            children: this.children.map((it) => it.toJson()),
+        };
+    }
+}
+/**
+ * Tab strip container for root and sidebar workspace leaves.
+ *
+ * @public
+ */
+export class WorkspaceTabs extends WorkspaceParent {
+    containerEl = $state(null);
+    stacked = $state(false);
+    _selected = $state("0");
+    children = $state([]);
+    constructor(props = {}) {
+        super();
+        const { leaves = [new WorkspaceLeaf()], stacked = false } = props;
+        this.stacked = stacked;
+        leaves.forEach((it) => this.addChild(it));
+    }
+    loadJson(layout, projectionItems) {
+        const promises = [];
+        this.children.slice().forEach((it) => this.removeChild(it, true));
+        layout.children.forEach((config) => {
+            if (isSidebarGroupJson(config)) {
+                const group = claimWorkspaceProjectionItem(projectionItems, config.id, (item) => item instanceof WorkspaceSidebarGroup, () => new WorkspaceSidebarGroup());
+                this.addChild(group);
+                promises.push(group.loadJson(config, projectionItems));
+            }
+            else {
+                const leaf = claimWorkspaceProjectionItem(projectionItems, config.id, (item) => item instanceof WorkspaceLeaf, () => new WorkspaceLeaf());
+                this.addChild(leaf);
+                promises.push(leaf.loadJson(config));
+            }
+        });
+        return Promise.all(promises).then(() => {
+            this.id = layout.id;
+            this.stacked = layout.stacked;
+            this.selected = layout.currentTab;
+        });
+    }
+    toJson() {
+        return {
+            id: this.id,
+            stacked: this.stacked,
+            type: "tabs",
+            children: this.children.map((it) => it.toJson()),
+            currentTab: this.selectedIndex,
+        };
+    }
+    get selected() {
+        return this._selected;
+    }
+    get sideBar() {
+        let parent = this.parent;
+        while (parent) {
+            if (parent instanceof WorkspaceSidedock) {
+                return parent;
+            }
+            parent = parent.parent;
+        }
+    }
+    inSideBar() {
+        return this.sideBar !== undefined;
+    }
+    get selectedIndex() {
+        return +this._selected;
+    }
+    get selectedChild() {
+        return this.children[this.selectedIndex];
+    }
+    get selectedLeaf() {
+        const child = this.selectedChild;
+        if (child instanceof WorkspaceLeaf) {
+            return child;
+        }
+        return child?.getSelectedLeaf() ?? null;
+    }
+    set selected(value) {
+        if (value instanceof WorkspaceLeaf ||
+            value instanceof WorkspaceSidebarGroup) {
+            value = this.children.findIndex((it) => it === value);
+        }
+        this._selected = value?.toString() || "";
+    }
+    detach(softDelete = false) {
+        return this.parent.removeChild(this, softDelete);
+    }
+    addChild(child, index) {
+        const oldIndex = this.children.findIndex((it) => it === child);
+        if (child.parent && child.parent !== this) {
+            child.detach();
+        }
+        if (typeof index === "number") {
+            if (index < 0)
+                index = 0;
+            if (index >= this.children.length)
+                index = this.children.length - 1;
+        }
+        if (typeof index === "number" &&
+            index >= 0 &&
+            index < this.children.length) {
+            if (oldIndex !== -1) {
+                this.children.splice(oldIndex, 1);
+            }
+            this.children.splice(index, 0, child);
+        }
+        else if (oldIndex === -1) {
+            this.children.push(child);
+        }
+        child.parent = this;
+        if (this.selectedIndex === oldIndex) {
+            this.selected = child;
+        }
+    }
+    iterateAllLeaves(callback) {
+        for (const child of this.children) {
+            const response = child instanceof WorkspaceLeaf
+                ? callback(child)
+                : child.iterateAllLeaves(callback);
+            if (response !== undefined && response !== null) {
+                return response;
+            }
+        }
+    }
+    removeChild(index, softDelete = false) {
+        if (index instanceof WorkspaceLeaf ||
+            index instanceof WorkspaceSidebarGroup) {
+            return this.removeChild(this.children.findIndex((it) => it === index), softDelete);
+        }
+        const child = this.children[index];
+        if (child) {
+            if (child instanceof WorkspaceLeaf) {
+                this.app.workspace.clearFocusModeForLeaf(child);
+            }
+            else {
+                child.iterateAllLeaves((leaf) => {
+                    this.app.workspace.clearFocusModeForLeaf(leaf);
+                });
+            }
+            this.children.splice(index, 1);
+            const selectedIndex = +this.selected;
+            if (selectedIndex === index && index > 0) {
+                this.selected = (index - 1).toString();
+            }
+            else if (index < selectedIndex) {
+                this.selected = (selectedIndex - 1).toString();
+            }
+            if (child instanceof WorkspaceLeaf &&
+                this.app.workspace.activeLeaf === child) {
+                this.app.workspace.activeLeaf = this.selectedLeaf;
+            }
+            else if (child instanceof WorkspaceSidebarGroup &&
+                child.children.includes(this.app.workspace.activeLeaf)) {
+                this.app.workspace.activeLeaf = this.selectedLeaf;
+            }
+        }
+        if (!this.children.length) {
+            if (child instanceof WorkspaceLeaf &&
+                this.app.workspace.activeLeaf === child) {
+                this.app.workspace.activeLeaf = null;
+            }
+            if (!softDelete) {
+                this.parent.removeChild(this);
+            }
+        }
+        return child;
+    }
+    closeAll() {
+        this.children.slice().forEach((it) => this.removeChild(it, true));
+        this.parent.removeChild(this);
+    }
+}
+/**
+ * Stable compatibility wrapper for design-core's bottom workspace dock.
+ *
+ * The panel remains a single tabs surface. Its height encodes both the last
+ * expanded size and its persisted open state, matching the workspace JSON
+ * contract used by design-core.
+ *
+ * @public
+ */
+export class WorkspaceBottomPanel extends WorkspaceTabs {
+    ownerWorkspace;
+    open = $state(false);
+    height = $state("240px");
+    constructor(ownerWorkspace) {
+        super({ leaves: [] });
+        this.ownerWorkspace = ownerWorkspace;
+        this.id = "bottom-panel";
+    }
+    loadJson(layout, projectionItems) {
+        return super.loadJson(layout, projectionItems).then(() => {
+            const collapsed = /^0(?:px|rem|em|%)?$/.test(layout.height.trim());
+            this.open = !collapsed;
+            if (!collapsed)
+                this.height = layout.height;
+        });
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            height: this.open ? this.height : "0px",
+        };
+    }
+    get size() {
+        const pixels = workspaceCssLengthToPixels(this.height);
+        const size = Number.parseFloat(pixels);
+        return Number.isFinite(size) ? size : 240;
+    }
+    get collapsed() {
+        return !this.open;
+    }
+    expand() {
+        this.ownerWorkspace.setBottomPanelOpen(true);
+    }
+    collapse() {
+        this.ownerWorkspace.setBottomPanelOpen(false);
+    }
+    toggle() {
+        this.ownerWorkspace.toggleBottomPanel();
+    }
+    detach() {
+        return undefined;
+    }
+    removeChild(index, _softDelete = false) {
+        return super.removeChild(index, true);
+    }
+    closeAll() {
+        this.children.slice().forEach((child) => this.removeChild(child, true));
+    }
+    getRoot() {
+        return this;
+    }
+    /** @internal */
+    _applyOpen(open) {
+        this.open = open;
+    }
+    /** @internal */
+    _applySize(size) {
+        this.height = `${size}px`;
+    }
+}
+export const ON_DEMAND_PLUGIN_INSTALL_VIEW_TYPE = "plugin-install-prompt";
+function registryContributionMatchesPath(entry, path) {
+    const normalizedExtension = extensionFromPath(path);
+    return (entry.contributes?.editorViews?.some((view) => {
+        if (view.extensions?.some((extension) => normalizeRegistryExtension(extension) === normalizedExtension)) {
+            return true;
+        }
+        return view.filenamePatterns?.some((pattern) => matchesEditorAssociationGlob(pattern, path));
+    }) ?? false);
+}
+function extensionFromPath(path) {
+    const basename = path.split("/").pop() ?? path;
+    const dotIndex = basename.lastIndexOf(".");
+    return dotIndex === -1 ? "" : basename.slice(dotIndex + 1).toLowerCase();
+}
+function normalizeRegistryExtension(extension) {
+    return extension.trim().replace(/^\./u, "").toLowerCase();
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export class WorkspaceRibbon {
+    workspace;
+    side;
+    open = $state(true);
+    containerEl = $state(null);
+    ribbonSettingsEl = $state(null);
+    ribbonItemsEl = $state(null);
+    _items = $state({});
+    hostDisposers = new Map();
+    constructor(workspace, side = "left") {
+        this.workspace = workspace;
+        this.side = side;
+    }
+    get items() {
+        return Object.values(this._items);
+    }
+    addItem(item) {
+        if (!this._items[item.id]) {
+            this._items[item.id] = item;
+            if (!item.hidden) {
+                this.hostDisposers.set(item.id, this.workspace.projectCompatibilityRibbonItem(item, this.side));
+            }
+        }
+        else {
+            new Notice(`Ribbon item: ${item.id} already exists`);
+        }
+        return () => {
+            this.removeItem(item.id);
+        };
+    }
+    removeItem(id) {
+        this.hostDisposers.get(id)?.();
+        this.hostDisposers.delete(id);
+        if (this._items[id]) {
+            delete this._items[id];
+        }
+    }
+}
+function workspaceCssLengthToPixels(value) {
+    const normalized = value.trim().toLowerCase();
+    if (/^0(?:px|rem|em|%)?$/.test(normalized))
+        return "0px";
+    const amount = Number.parseFloat(normalized);
+    if (!Number.isFinite(amount) || amount <= 0)
+        return value;
+    if (normalized.endsWith("rem") || normalized.endsWith("em")) {
+        return `${amount * 16}px`;
+    }
+    return normalized.endsWith("px") ? normalized : `${amount}px`;
+}
+function translateWorkspaceSplitDirection(direction) {
+    return direction === "horizontal" ? "vertical" : "horizontal";
+}
+function translateWorkspaceSplitDirections(split) {
+    return {
+        ...split,
+        direction: translateWorkspaceSplitDirection(split.direction),
+        children: split.children.map((child) => child.type === "split" ? translateWorkspaceSplitDirections(child) : child),
+    };
+}
+function translateWorkspaceWindowDirections(win) {
+    return {
+        ...win,
+        direction: translateWorkspaceSplitDirection(win.direction),
+        children: win.children.map((child) => child.type === "split" ? translateWorkspaceSplitDirections(child) : child),
+    };
+}
+function translateWorkspaceJsonSplitDirections(layout) {
+    return {
+        ...layout,
+        main: translateWorkspaceSplitDirections(layout.main),
+        left: translateWorkspaceSplitDirections(layout.left),
+        right: translateWorkspaceSplitDirections(layout.right),
+        floating: layout.floating?.map(translateWorkspaceWindowDirections),
+    };
+}
+function workspaceJsonForDesignCore(layout) {
+    const translated = translateWorkspaceJsonSplitDirections(layout);
+    return {
+        ...translated,
+        left: {
+            ...translated.left,
+            width: workspaceCssLengthToPixels(translated.left.width),
+        },
+        right: {
+            ...translated.right,
+            width: workspaceCssLengthToPixels(translated.right.width),
+        },
+        bottom: {
+            ...translated.bottom,
+            height: workspaceCssLengthToPixels(translated.bottom.height),
+        },
+    };
+}
+function workspaceJsonForCompatibility(layout) {
+    return translateWorkspaceJsonSplitDirections(layout);
+}
+function designLayoutEventFromCompatibility(event) {
+    const source = event.source === "drag-drop"
+        ? "drag-drop"
+        : event.source === "resize"
+            ? "resize"
+            : event.source === "layout-load"
+                ? "layout-restore"
+                : event.source === "bottom-panel"
+                    ? "bottom-panel"
+                    : event.source === "popout"
+                        ? "window-open"
+                        : "layout-replace";
+    return { source, operation: event.operation };
+}
+function compatibilityLayoutEventFromDesign(event) {
+    const source = event.source === "drag-drop"
+        ? "drag-drop"
+        : event.source === "resize"
+            ? "resize"
+            : event.source === "layout-restore"
+                ? "layout-load"
+                : event.source === "bottom-panel"
+                    ? "bottom-panel"
+                    : event.source.startsWith("window-")
+                        ? "popout"
+                        : "api";
+    return { source, operation: event.operation ?? event.source };
+}
+function createWorkspaceLayoutDropEvent(options) {
+    return {
+        ...options,
+        defaultPrevented: false,
+        preventDefault() {
+            this.defaultPrevented = true;
+        },
+    };
+}
+/**
+ * Owns the workspace layout tree, leaf registry, and view-type routing.
+ *
+ * `Workspace` coordinates default file navigation, sidebar placement, layout
+ * persistence, and the active editor/leaf state that plugins interact with.
+ *
+ * @public
+ */
+export class Workspace extends EventDispatcher {
+    app;
+    viewTypes = new Map([
+        ["empty", (leaf) => new EmptyView(leaf)],
+    ]);
+    viewExtensions = new Map();
+    editorViews = new EditorViewRegistry();
+    sidebarViewPlacements = new Map();
+    hoverLinkSources = new Map();
+    rootContainer = new WorkspaceRoot();
+    rootSplit = new WorkspaceView();
+    displayMode = $state("desktop");
+    _activeLeaf = $state(null);
+    lastActiveFile = null;
+    recentFilePaths = [];
+    static RECENT_FILE_LIMIT = 20;
+    focusMode = $state(null);
+    focusedHostId = $state(WORKSPACE_ROOT_HOST_ID);
+    leftSplit = new WorkspaceSidedock({
+        id: "left",
+        initialWidth: "22rem",
+    });
+    rightSplit = new WorkspaceSidedock({
+        id: "right",
+        collapsedSize: "0px",
+        initialOpen: false,
+    });
+    bottomPanel = new WorkspaceBottomPanel(this);
+    floating = new WorkspaceFloating();
+    layoutReady = $state(false);
+    layoutHandlers = [];
+    suspendedLayoutPersistence = 0;
+    #workspaceHostController = null;
+    diagnostics;
+    #syncingWorkspaceHost = 0;
+    #workspaceHostProjection = Promise.resolve();
+    #workspaceHostViewDisposers = new Map();
+    #configurationBridgeDisposer = null;
+    #editorViewBridgeDisposer = null;
+    #pluginSettingsBridgeDisposer = null;
+    #statusBarBridgeDisposer = null;
+    #notificationProgressBridgeDisposer = null;
+    #commandBridgeDisposer = null;
+    workspaceLayoutFile = "workspace.json";
+    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));
+        });
+    }, 1000);
+    requestSaveLayout(event = { source: "api" }) {
+        if (this.suspendedLayoutPersistence > 0) {
+            return;
+        }
+        untrack(() => this.commitCompatibilityLayoutToHost(event));
+        this.emitLayoutChangeAndScheduleSave(event);
+    }
+    emitLayoutChangeAndScheduleSave(event) {
+        this.trigger("layout-change", event);
+        this.saveLayoutDebounced();
+    }
+    commitCompatibilityLayoutToHost(event) {
+        if (!this.#workspaceHostController)
+            return;
+        this.#syncingWorkspaceHost += 1;
+        try {
+            this.#workspaceHostController.workspace.changeLayout(workspaceJsonForDesignCore(this.toJson()), designLayoutEventFromCompatibility(event));
+        }
+        finally {
+            this.#syncingWorkspaceHost -= 1;
+        }
+    }
+    projectCompatibilityRibbonItem(item, side) {
+        const registry = this.#workspaceHostController?.ribbon;
+        if (!registry)
+            return () => { };
+        return registry.addItem({
+            id: item.id,
+            side,
+            section: "top",
+            label: item.title,
+            icon: item.icon,
+            onSelect: (event) => item.callback(event),
+        });
+    }
+    async withoutLayoutPersistence(callback) {
+        this.suspendedLayoutPersistence += 1;
+        try {
+            return await callback();
+        }
+        finally {
+            this.suspendedLayoutPersistence -= 1;
+        }
+    }
+    dispatchLayoutDropEvent(eventName, options) {
+        const event = createWorkspaceLayoutDropEvent(options);
+        this.trigger(eventName, event);
+        return event;
+    }
+    willShowLayoutDropOverlay(options) {
+        return this.dispatchLayoutDropEvent("layout-will-show-overlay", options);
+    }
+    startLayoutDrag(options) {
+        return this.dispatchLayoutDropEvent("layout-drag-start", options);
+    }
+    endLayoutDrag(options) {
+        return this.dispatchLayoutDropEvent("layout-drag-end", options);
+    }
+    moveWorkspaceChildToTabIndex(item, target, index, options) {
+        if (item === target.children[index]) {
+            return false;
+        }
+        const operation = options.operation ?? "tab-reorder";
+        const eventOptions = {
+            source: options.source ?? "api",
+            operation,
+            position: options.position,
+            target,
+            item,
+        };
+        const willDrop = this.dispatchLayoutDropEvent("layout-will-drop", eventOptions);
+        if (willDrop.defaultPrevented) {
+            return false;
+        }
+        const boundedIndex = Math.max(0, Math.min(index, target.children.length));
+        const existingIndex = target.children.findIndex((child) => child === item);
+        if (existingIndex !== -1) {
+            target.removeChild(item, true);
+        }
+        else if (item.parent) {
+            item.detach(true);
+        }
+        const insertionIndex = existingIndex !== -1 && existingIndex < boundedIndex
+            ? boundedIndex - 1
+            : boundedIndex;
+        if (insertionIndex >= target.children.length) {
+            target.children.push(item);
+            item.parent = target;
+        }
+        else {
+            target.addChild(item, insertionIndex);
+        }
+        if (item instanceof WorkspaceLeaf) {
+            target.selected = item;
+            this.activeLeaf = item;
+        }
+        else {
+            target.selected = item;
+            this.activeLeaf = item.getSelectedLeaf();
+        }
+        if (target instanceof WorkspaceBottomPanel) {
+            target._applyOpen(true);
+        }
+        this.requestSaveLayout({ source: "drag-drop", operation });
+        this.dispatchLayoutDropEvent("layout-did-drop", eventOptions);
+        return true;
+    }
+    async dropWorkspaceItemOnTabs(parent, options) {
+        const item = options.item;
+        const file = options.file;
+        if (!item && !file) {
+            return false;
+        }
+        if (parent instanceof WorkspaceBottomPanel &&
+            options.position !== "center") {
+            return false;
+        }
+        const targetTabs = parent instanceof WorkspaceTabs
+            ? parent
+            : new WorkspaceTabs({ leaves: [] });
+        const operation = options.operation ??
+            (options.position === "center" ? "tab-drop" : "split-drop");
+        const eventOptions = {
+            source: options.source ?? "api",
+            operation,
+            position: options.position,
+            target: targetTabs,
+            ...(item ? { item } : {}),
+            ...(file ? { file } : {}),
+        };
+        const willDrop = this.dispatchLayoutDropEvent("layout-will-drop", eventOptions);
+        if (willDrop.defaultPrevented) {
+            return false;
+        }
+        if (options.position === "center") {
+            if (parent instanceof WorkspaceSplit) {
+                parent.addChild(targetTabs);
+            }
+            if (file) {
+                const leaf = new WorkspaceLeaf();
+                targetTabs.addChild(leaf);
+                targetTabs.selected = leaf;
+                await this.withoutLayoutPersistence(() => leaf.openFile(file));
+                this.activeLeaf = leaf;
+            }
+            else if (item) {
+                const movedLeaf = item.detach();
+                if (!(movedLeaf instanceof WorkspaceLeaf)) {
+                    return false;
+                }
+                targetTabs.addChild(movedLeaf);
+                targetTabs.selected = movedLeaf;
+                this.activeLeaf = movedLeaf;
+            }
+            if (targetTabs instanceof WorkspaceBottomPanel) {
+                targetTabs._applyOpen(true);
+            }
+            this.requestSaveLayout({ source: "drag-drop", operation });
+            this.dispatchLayoutDropEvent("layout-did-drop", eventOptions);
+            return true;
+        }
+        if (!(parent instanceof WorkspaceTabs)) {
+            return false;
+        }
+        const leaf = new WorkspaceLeaf();
+        if (file) {
+            await this.withoutLayoutPersistence(() => leaf.openFile(file));
+        }
+        else if (item) {
+            await this.withoutLayoutPersistence(() => leaf.setViewState({ ...item.state }));
+        }
+        const newTabs = new WorkspaceTabs({ leaves: [leaf] });
+        const activeSplit = parent.parent;
+        if (options.position === "top" || options.position === "bottom") {
+            if (parent.parent.type === "horizontal") {
+                parent.parent.addChild(newTabs, options.position === "top" ? 0 : undefined);
+            }
+            else {
+                const tab = activeSplit.removeChild(parent, true);
+                if (!tab) {
+                    return false;
+                }
+                const split = new WorkspaceView("horizontal");
+                if (options.position === "top") {
+                    split.addChild(newTabs);
+                    split.addChild(tab);
+                }
+                else {
+                    split.addChild(tab);
+                    split.addChild(newTabs);
+                }
+                activeSplit.addChild(split);
+            }
+        }
+        else {
+            if (parent.parent.type === "vertical") {
+                parent.parent.addChild(newTabs, options.position === "left" ? 0 : undefined);
+            }
+            else {
+                const tab = activeSplit.removeChild(parent, true);
+                if (!tab) {
+                    return false;
+                }
+                const split = new WorkspaceView("vertical");
+                if (options.position === "left") {
+                    split.addChild(newTabs);
+                    split.addChild(tab);
+                }
+                else {
+                    split.addChild(tab);
+                    split.addChild(newTabs);
+                }
+                activeSplit.addChild(split);
+            }
+        }
+        if (item) {
+            item.detach();
+        }
+        this.activeLeaf = leaf;
+        this.requestSaveLayout({ source: "drag-drop", operation });
+        this.dispatchLayoutDropEvent("layout-did-drop", {
+            ...eventOptions,
+            target: newTabs,
+        });
+        return true;
+    }
+    moveLeafToSidebarGroupIndex(leaf, group, index, options) {
+        const operation = options.operation ?? "sidebar-group-reorder";
+        const eventOptions = {
+            source: options.source ?? "api",
+            operation,
+            position: options.position,
+            target: group,
+            item: leaf,
+        };
+        const willDrop = this.dispatchLayoutDropEvent("layout-will-drop", eventOptions);
+        if (willDrop.defaultPrevented) {
+            return false;
+        }
+        const boundedIndex = Math.max(0, Math.min(index, group.children.length));
+        const existingIndex = group.children.findIndex((child) => child === leaf);
+        if (existingIndex !== -1) {
+            group.removeChild(leaf, true);
+        }
+        else if (leaf.parent) {
+            leaf.detach(true);
+        }
+        const insertionIndex = existingIndex !== -1 && existingIndex < boundedIndex
+            ? boundedIndex - 1
+            : boundedIndex;
+        group.addChild(leaf, insertionIndex);
+        group.hiddenLeafIds = group.hiddenLeafIds.filter((id) => id !== leaf.id);
+        group.parent.selected = group;
+        this.activeLeaf = leaf;
+        this.requestSaveLayout({ source: "drag-drop", operation });
+        this.dispatchLayoutDropEvent("layout-did-drop", eventOptions);
+        return true;
+    }
+    moveLeafToSidebarGroup(leaf, group, options = {}) {
+        const operation = options.operation ?? "sidebar-group-drop";
+        const eventOptions = {
+            source: options.source ?? "api",
+            operation,
+            position: "center",
+            target: group,
+            item: leaf,
+        };
+        const willDrop = this.dispatchLayoutDropEvent("layout-will-drop", eventOptions);
+        if (willDrop.defaultPrevented) {
+            return false;
+        }
+        if (leaf.parent) {
+            leaf.detach(true);
+        }
+        group.addChild(leaf);
+        group.hiddenLeafIds = group.hiddenLeafIds.filter((id) => id !== leaf.id);
+        group.parent.selected = group;
+        this.activeLeaf = leaf;
+        this.requestSaveLayout({ source: "drag-drop", operation });
+        this.dispatchLayoutDropEvent("layout-did-drop", eventOptions);
+        return true;
+    }
+    containsLeaf(target) {
+        if (!target) {
+            return false;
+        }
+        return Boolean(this.iterateAllLeaves((leaf) => leaf === target || undefined));
+    }
+    containsRootLeaf(target) {
+        if (!target) {
+            return false;
+        }
+        return Boolean(this.rootSplit.iterateAllLeaves((leaf) => leaf === target || undefined));
+    }
+    floatingWindowForLeaf(target) {
+        if (!target) {
+            return null;
+        }
+        for (const floatingWindow of this.floating.children) {
+            const containsTarget = floatingWindow.iterateAllLeaves((leaf) => leaf === target || undefined);
+            if (containsTarget) {
+                return floatingWindow;
+            }
+        }
+        return null;
+    }
+    getCommandHostIdForLeaf(target) {
+        return this.floatingWindowForLeaf(target)?.id ?? WORKSPACE_ROOT_HOST_ID;
+    }
+    getCommandHostLeaf(hostId) {
+        if (hostId === WORKSPACE_ROOT_HOST_ID) {
+            return this.activeRootLeaf;
+        }
+        const window = this.floating.children.find((entry) => entry.id === hostId);
+        return window ? this.selectedLeafForWindow(window) : null;
+    }
+    getCommandHostDocument(hostId = this.getFocusedCommandHostId()) {
+        if (hostId === WORKSPACE_ROOT_HOST_ID) {
+            return document;
+        }
+        return (this.floating.children.find((entry) => entry.id === hostId)?.doc ??
+            document);
+    }
+    getFocusedCommandHostId() {
+        if (this.focusedHostId === WORKSPACE_ROOT_HOST_ID) {
+            return WORKSPACE_ROOT_HOST_ID;
+        }
+        return this.floating.children.some((entry) => entry.id === this.focusedHostId)
+            ? this.focusedHostId
+            : WORKSPACE_ROOT_HOST_ID;
+    }
+    focusRootHost() {
+        this.focusedHostId = WORKSPACE_ROOT_HOST_ID;
+    }
+    get activeLeaf() {
+        if (this.containsLeaf(this._activeLeaf)) {
+            return this._activeLeaf;
+        }
+        return (this.rootSplit.iterateAllTabs((tabs) => tabs.selectedLeaf || undefined) ||
+            null);
+    }
+    get activeRootLeaf() {
+        if (this.containsRootLeaf(this._activeLeaf)) {
+            return this._activeLeaf;
+        }
+        return (this.rootSplit.iterateAllTabs((tabs) => tabs.selectedLeaf || undefined) ||
+            null);
+    }
+    set activeLeaf(leaf) {
+        this._activeLeaf = leaf;
+    }
+    get activeEditor() {
+        const view = this.activeLeaf?.view;
+        if (view instanceof TextFileView) {
+            return {
+                app: this.app,
+                get file() {
+                    return view.file;
+                },
+                editor: view.editor,
+            };
+        }
+        return null;
+    }
+    /** @public */
+    get isMobileMode() {
+        return this.displayMode === "mobile";
+    }
+    /** @public */
+    setDisplayMode(mode, reason = "manual") {
+        if (this.displayMode === mode) {
+            return;
+        }
+        const previousMode = this.displayMode;
+        this.displayMode = mode;
+        if (this.#workspaceHostController) {
+            this.#syncingWorkspaceHost += 1;
+            try {
+                this.#workspaceHostController.renderer.setDisplayMode(mode);
+            }
+            finally {
+                this.#syncingWorkspaceHost -= 1;
+            }
+        }
+        this.trigger("display-mode-change", {
+            mode,
+            previousMode,
+            reason,
+        });
+    }
+    enterFocusMode(leaf = this.activeRootLeaf) {
+        if (!leaf || !this.containsRootLeaf(leaf)) {
+            return false;
+        }
+        const tabs = this.tabsForLeaf(leaf);
+        if (tabs.inSideBar()) {
+            return false;
+        }
+        tabs.selected = leaf;
+        this.activeLeaf = leaf;
+        this.focusRootHost();
+        return this.setFocusMode({ leaf, tabs });
+    }
+    exitFocusMode() {
+        return this.setFocusMode(null);
+    }
+    clearFocusModeForLeaf(leaf) {
+        if (this.focusMode?.leaf !== leaf) {
+            return false;
+        }
+        return this.exitFocusMode();
+    }
+    isFocusModeForTabs(tabs) {
+        return this.focusMode?.tabs === tabs;
+    }
+    toJson() {
+        return {
+            main: this.rootSplit.toJson(),
+            left: this.leftSplit.toJson(),
+            right: this.rightSplit.toJson(),
+            bottom: this.bottomPanel.toJson(),
+            floating: this.floating.toJson(),
+            active: this.activeLeaf?.id,
+        };
+    }
+    async restoreLayoutJson(config) {
+        this.exitFocusMode();
+        const normalized = normalizeWorkspaceJson(config);
+        await this.activateLayoutPlugins(normalized);
+        const projectionItems = beginWorkspaceProjection(this);
+        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),
+            ]);
+        }
+        finally {
+            finishWorkspaceProjection(projectionItems);
+        }
+        if (!normalized.active) {
+            if (!this.containsLeaf(this.activeLeaf))
+                this.activeLeaf = null;
+            return;
+        }
+        this.iterateAllLeaves((leaf) => {
+            if (leaf.id === normalized.active) {
+                this.activateLeaf(leaf, {
+                    saveLayout: false,
+                    focusRootHost: false,
+                    source: "layout-load",
+                    operation: "restore-active-leaf",
+                });
+                return false;
+            }
+        });
+    }
+    loadLayout(file = "workspace.json") {
+        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));
+            this.layoutReady = false;
+            if (workspaceFile) {
+                await this.restoreLayoutJson(JSON.parse(await this.app.vault.read(workspaceFile)));
+            }
+            else {
+                await this.withoutLayoutPersistence(() => this.seedDefaultSidebarLayout());
+            }
+            this.commitCompatibilityLayoutToHost({ source: "layout-load" });
+            this.layoutReady = true;
+            this.layoutHandlers.forEach((it) => it());
+            this.trigger("layout-ready");
+        }, {
+            attributes: { "workspace.layout_file": file },
+            slowThresholdMs: 250,
+        });
+    }
+    async seedDefaultSideLeaf(type, side) {
+        if (!this.viewTypes.has(type))
+            return null;
+        const existing = this.getLeavesOfType(type)[0];
+        if (existing)
+            return existing;
+        const leaf = this.ensureSideLeaf(type, side);
+        await leaf.setViewState({ type, state: {} });
+        return leaf;
+    }
+    async seedDefaultSidebarLayout() {
+        const leftLeaves = [];
+        const rightLeaves = [];
+        for (const type of DEFAULT_LEFT_SIDEBAR_VIEW_TYPES) {
+            const leaf = await this.seedDefaultSideLeaf(type, "left");
+            if (leaf)
+                leftLeaves.push(leaf);
+        }
+        for (const type of DEFAULT_RIGHT_SIDEBAR_VIEW_TYPES) {
+            const leaf = await this.seedDefaultSideLeaf(type, "right");
+            if (leaf)
+                rightLeaves.push(leaf);
+        }
+        if (leftLeaves[0])
+            await this.revealLeaf(leftLeaves[0]);
+        if (rightLeaves[0])
+            await this.revealLeaf(rightLeaves[0]);
+    }
+    namedWorkspacesPath() {
+        return joinPath("/.obsidian", NAMED_WORKSPACES_FILE);
+    }
+    async readNamedWorkspaceStore() {
+        const file = this.app.vault.getFileByPath(this.namedWorkspacesPath());
+        if (!file)
+            return { workspaces: {} };
+        return parseNamedWorkspaceStore(await this.app.vault.read(file));
+    }
+    async writeNamedWorkspaceStore(store) {
+        await this.app.vault.create(this.namedWorkspacesPath(), serializeNamedWorkspaceStore(store));
+    }
+    async listNamedLayouts() {
+        const store = await this.readNamedWorkspaceStore();
+        return Object.keys(store.workspaces).sort((left, right) => left.localeCompare(right));
+    }
+    async saveNamedLayout(name) {
+        const normalized = name.trim();
+        if (!normalized) {
+            throw new Error("Workspace layout name must not be empty");
+        }
+        const store = await this.readNamedWorkspaceStore();
+        store.workspaces[normalized] = this.getLayout();
+        store.active = normalized;
+        await this.writeNamedWorkspaceStore(store);
+    }
+    async loadNamedLayout(name) {
+        const store = await this.readNamedWorkspaceStore();
+        const layout = store.workspaces[name];
+        if (!layout) {
+            new Notice(`No saved workspace layout named “${name}”`, undefined, this.app);
+            return;
+        }
+        store.active = name;
+        await this.writeNamedWorkspaceStore(store);
+        await this.changeLayout(layout);
+    }
+    async resetLayoutToDefault() {
+        this.layoutReady = false;
+        try {
+            await this.withoutLayoutPersistence(async () => {
+                await this.restoreLayoutJson({});
+                await this.seedDefaultSidebarLayout();
+            });
+            this.commitCompatibilityLayoutToHost({
+                source: "api",
+                operation: "reset-layout",
+            });
+        }
+        finally {
+            this.layoutReady = true;
+        }
+        this.layoutHandlers.forEach((handler) => handler());
+        this.trigger("layout-ready");
+        this.requestSaveLayout({ source: "api", operation: "reset-layout" });
+    }
+    installWorkspaceLayoutCommands() {
+        this.app.commands.registerCommand({
+            id: "workspace:save-layout",
+            name: "Save workspace layout",
+            title: "Save workspace layout",
+            category: "Workspace",
+            icon: "save",
+            sourcePlugin: "app",
+            callback: () => {
+                void this.listNamedLayouts().then((names) => {
+                    promptSaveWorkspaceLayout(this.app, names, (name) => this.saveNamedLayout(name));
+                });
+            },
+        });
+        this.app.commands.registerCommand({
+            id: "workspace:load-layout",
+            name: "Load workspace layout",
+            title: "Load workspace layout",
+            category: "Workspace",
+            icon: "folder-open",
+            sourcePlugin: "app",
+            callback: () => {
+                void this.listNamedLayouts().then((names) => {
+                    if (names.length === 0) {
+                        new Notice("No saved workspace layouts", undefined, this.app);
+                        return;
+                    }
+                    promptLoadWorkspaceLayout(this.app, names, (name) => this.loadNamedLayout(name));
+                });
+            },
+        });
+        this.app.commands.registerCommand({
+            id: "workspace:reset-layout",
+            name: "Reset workspace layout",
+            title: "Reset workspace layout",
+            category: "Workspace",
+            icon: "rotate-ccw",
+            sourcePlugin: "app",
+            callback: () => {
+                void promptConfirm(this.getCommandHostDocument(), {
+                    title: "Reset workspace layout",
+                    description: "Reset the workspace to File Explorer and Search on the left, and Outline, File Properties, and Tags on the right?",
+                    confirmLabel: "Reset",
+                }).then((confirmed) => {
+                    if (confirmed)
+                        return this.resetLayoutToDefault();
+                });
+            },
+        });
+        this.app.commands.registerCommand({
+            id: "app:go-to-file",
+            name: "Go to file",
+            title: "Go to file",
+            category: "Workspace",
+            icon: "file",
+            sourcePlugin: "app",
+            hotkeys: [{ modifiers: ["Mod"], key: "o" }],
+            callback: () => {
+                getWorkspaceHostBinding(this).controller.commands.openPalette({
+                    tab: "files",
+                });
+            },
+        });
+    }
+    /**
+     * Runs the callback function right away if layout is already ready, or push
+     * it to a queue to be called later when layout is ready.
+     *
+     * @public
+     */
+    onLayoutReady(callback) {
+        if (this.layoutReady) {
+            callback();
+            return;
+        }
+        this.layoutHandlers.push(callback);
+    }
+    constructor(app) {
+        super();
+        this.app = app;
+        this.rootContainer.bindWorkspace(this);
+        this.rootSplit.bindWorkspace(this);
+        this.leftSplit.bindWorkspace(this);
+        this.rightSplit.bindWorkspace(this);
+        this.bottomPanel.bindWorkspace(this);
+        this.floating.bindWorkspace(this);
+        this.rootSplit.addChild(new WorkspaceTabs());
+        const shellOptions = this.app.props?.workspaceShell;
+        const application = shellOptions?.application;
+        this.#workspaceHostController = new AppShellController({
+            layout: workspaceJsonForDesignCore(this.toJson()),
+            application: {
+                name: application?.name ?? "Lapis Notes",
+                version: this.app.version,
+                logoUrl: application?.logoUrl === null
+                    ? undefined
+                    : (application?.logoUrl ?? DEFAULT_LAPIS_LOGO_URL),
+                buildTime: application?.buildTime,
+                commitHash: application?.commitHash,
+                copyright: application?.copyright,
+            },
+            plugins: [
+                ...(shellOptions?.notifications === false
+                    ? []
+                    : [notificationsPlugin()]),
+                fModePlugin({ enabled: false }),
+                problemsPlugin({
+                    navigation: {
+                        open: (location) => this.openDiagnosticLocation(location),
+                    },
+                    clipboard: {
+                        writeText: async (_label, value) => {
+                            await globalThis.navigator?.clipboard?.writeText(value);
+                        },
+                    },
+                }),
+            ],
+            persistence: {
+                configuration: {
+                    load: async () => ({
+                        version: 1,
+                        values: Object.fromEntries(this.app.configuration.getConfiguration().entries()),
+                    }),
+                    save: async (snapshot) => {
+                        await this.app.configuration.updateConfigurationOptions(snapshot.values);
+                    },
+                },
+                plugins: createAppShellPluginPersistence(() => this.app.vault),
+            },
+        });
+        setWorkspaceHostBinding(this, {
+            controller: this.#workspaceHostController,
+        });
+        this.installCommandBridge(this.#workspaceHostController);
+        this.installWorkspaceLayoutCommands();
+        this.on("file-open", (file) => {
+            if (file)
+                this.recordRecentFile(file);
+        });
+        this.installStatusBarBridge(this.#workspaceHostController);
+        this.installNotificationProgressBridge(this.#workspaceHostController);
+        this.diagnostics = new DiagnosticsManager(this.#workspaceHostController.diagnostics, () => new Menu(), appendLapisMenuToWorkspaceMenu);
+        this.installWorkspaceHostEventBridge(this.#workspaceHostController);
+        const editorViewBridgeRef = this.editorViews.on("changed", ({ id }) => {
+            this.syncWorkspaceHostEditorView(id);
+        });
+        this.#editorViewBridgeDisposer = () => this.editorViews.offref(editorViewBridgeRef);
+        $effect(() => {
+            const activeLeaf = this.activeLeaf;
+            if (activeLeaf?.view instanceof FileView && activeLeaf.view.file) {
+                this.lastActiveFile = activeLeaf.view.file;
+            }
+            this.trigger("active-leaf-change", activeLeaf);
+        });
+        $effect(() => {
+            this.trigger("resize", {
+                id: "left",
+                props: { width: this.leftSplit.sidebar.width },
+            });
+        });
+        $effect(() => {
+            this.trigger("resize", {
+                id: "right",
+                props: { width: this.rightSplit.sidebar.width },
+            });
+        });
+    }
+    async openDiagnosticLocation(location) {
+        const path = pathFromDiagnosticResource(location.resource);
+        if (!path)
+            return;
+        const file = this.app.vault.getFileByPath(path);
+        if (!file)
+            return;
+        const existingLeaf = this.iterateAllLeaves((leaf) => leaf.view instanceof FileView && leaf.view.file?.path === file.path
+            ? leaf
+            : undefined);
+        if (existingLeaf) {
+            this.setActiveLeaf(existingLeaf);
+        }
+        else {
+            await this.openLinkText(file.path, "");
+        }
+        const editor = this.activeEditor?.editor;
+        if (!location.range || !editor)
+            return;
+        editor.setSelection({
+            line: location.range.start.line,
+            ch: location.range.start.character,
+        }, {
+            line: location.range.end.line,
+            ch: location.range.end.character,
+        });
+        editor.focus();
+    }
+    /** @internal Complete the configuration bridge after App construction. */
+    bindConfiguration() {
+        this.#configurationBridgeDisposer?.();
+        const controller = this.#workspaceHostController;
+        if (!controller)
+            return;
+        const syncAll = () => {
+            const snapshot = controller.settings.getSnapshot();
+            const apiValues = Object.fromEntries(this.app.configuration.getConfiguration().entries());
+            const next = { ...snapshot.values };
+            for (const key of Object.keys(next)) {
+                if (Object.hasOwn(apiValues, key))
+                    next[key] = apiValues[key];
+            }
+            if (!isEqual(next, snapshot.values)) {
+                controller.settings.changeSnapshot({ version: 1, values: next });
+            }
+        };
+        const configurationRef = this.app.configuration.on("updated", ({ key, value }) => {
+            const snapshot = controller.settings.getSnapshot();
+            if (!Object.hasOwn(snapshot.values, key))
+                return;
+            const next = { ...snapshot.values };
+            if (value === undefined)
+                delete next[key];
+            else
+                next[key] = value;
+            if (!isEqual(next, snapshot.values)) {
+                controller.settings.changeSnapshot({ version: 1, values: next });
+            }
+        });
+        const schemaRef = controller.settings.on("schema-change", syncAll);
+        this.#configurationBridgeDisposer = () => {
+            this.app.configuration.offref(configurationRef);
+            controller.settings.offref(schemaRef);
+        };
+    }
+    /** @internal Connect the API plugin lifecycle to Design Core presentation. */
+    bindPlugins() {
+        this.#pluginSettingsBridgeDisposer?.();
+        const controller = this.#workspaceHostController;
+        if (!controller)
+            return;
+        const manager = this.app.plugins;
+        const source = {
+            id: "lapis",
+            getEntries: () => manager.corePluginEntries.map((entry) => ({
+                id: entry.manifest.id,
+                name: entry.manifest.name,
+                description: entry.manifest.description,
+                required: entry.required,
+                enabled: entry.enabled,
+                status: entry.errorMessage
+                    ? "failed"
+                    : entry.enabled
+                        ? "enabled"
+                        : "disabled",
+                distribution: entry.distribution,
+                error: entry.errorMessage ?? undefined,
+            })),
+            enable: (id) => manager.enablePlugin(id),
+            disable: (id) => manager.disablePlugin(id),
+            subscribe: (listener) => {
+                const loaded = manager.on("plugins-loaded", listener);
+                const enabled = manager.on("plugin-enabled", listener);
+                const disabled = manager.on("plugin-disabled", listener);
+                const error = manager.on("plugin-error", listener);
+                return () => {
+                    manager.offref(loaded);
+                    manager.offref(enabled);
+                    manager.offref(disabled);
+                    manager.offref(error);
+                };
+            },
+        };
+        this.#pluginSettingsBridgeDisposer =
+            controller.managedPlugins.registerSource(source);
+    }
+    /** Dispose the API-owned shell controller and its compatibility bridges. */
+    async disposeWorkspaceHost() {
+        this.app.languageServices.unbindDiagnostics();
+        this.#configurationBridgeDisposer?.();
+        this.#configurationBridgeDisposer = null;
+        this.#pluginSettingsBridgeDisposer?.();
+        this.#pluginSettingsBridgeDisposer = null;
+        this.#statusBarBridgeDisposer?.();
+        this.#statusBarBridgeDisposer = null;
+        this.#notificationProgressBridgeDisposer?.();
+        this.#notificationProgressBridgeDisposer = null;
+        this.#commandBridgeDisposer?.();
+        this.#commandBridgeDisposer = null;
+        this.#editorViewBridgeDisposer?.();
+        this.#editorViewBridgeDisposer = null;
+        this.#workspaceHostViewDisposers.forEach((dispose) => dispose());
+        this.#workspaceHostViewDisposers.clear();
+        await this.#workspaceHostController?.dispose();
+    }
+    installCommandBridge(controller) {
+        const disposers = new Map();
+        const sync = (command) => {
+            disposers.get(command.id)?.();
+            const projected = {
+                id: command.id,
+                title: command.name,
+                category: command.category,
+                icon: command.icon,
+                sourcePlugin: command.sourcePlugin,
+                hotkeys: this.app.commands.getEffectiveHotkeys(command.id),
+                when: () => this.app.commands.isCommandAvailable(command.id),
+                callback: () => this.app.commands.executeCommand(command.id),
+            };
+            disposers.set(command.id, controller.commands.register(projected));
+        };
+        const remove = (command) => {
+            disposers.get(command.id)?.();
+            disposers.delete(command.id);
+        };
+        for (const command of Object.values(this.app.commands.commands)) {
+            sync(command);
+        }
+        const registered = this.app.commands.on("register", sync);
+        const unregistered = this.app.commands.on("unregister", remove);
+        const hotkeysUpdated = this.app.commands.on("hotkeys-updated", (event) => {
+            if (event.commandId) {
+                const command = this.app.commands.getCommand(event.commandId);
+                if (command)
+                    sync(command);
+                return;
+            }
+            for (const command of Object.values(this.app.commands.commands)) {
+                sync(command);
+            }
+        });
+        this.#commandBridgeDisposer = () => {
+            this.app.commands.offref(registered);
+            this.app.commands.offref(unregistered);
+            this.app.commands.offref(hotkeysUpdated);
+            disposers.forEach((dispose) => dispose());
+            disposers.clear();
+        };
+    }
+    projectStatusBarItem(controller, item, align) {
+        controller.status.addItem({
+            id: item.id,
+            align,
+            priority: item.priority,
+            label: item.text,
+            segments: item.segments ?? (item.text ? [item.text] : undefined),
+            tooltip: item.tooltip,
+            icon: item.icon,
+            busy: item.spin,
+            onSelect: item.command
+                ? () => void this.app.commands.executeCommand(item.command)
+                : undefined,
+            buildMenu: item.buildMenu
+                ? (workspaceMenu) => {
+                    const menu = new Menu();
+                    item.buildMenu(menu);
+                    appendLapisMenuToWorkspaceMenu(workspaceMenu, menu);
+                }
+                : undefined,
+        });
+    }
+    installStatusBarBridge(controller) {
+        const projectedIds = new Set();
+        const sync = () => {
+            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");
+            }
+        };
+        const unsubscribeStatus = this.app.statusBar.subscribe(sync);
+        const contextRef = this.app.contextKeys.on("change", sync);
+        this.#statusBarBridgeDisposer = () => {
+            unsubscribeStatus();
+            this.app.contextKeys.offref(contextRef);
+            for (const id of projectedIds)
+                controller.status.removeItem(id);
+            projectedIds.clear();
+        };
+    }
+    installNotificationProgressBridge(controller) {
+        const notifications = this.app.notifications;
+        if (typeof notifications?.on !== "function") {
+            return;
+        }
+        const projected = new Map();
+        const sync = () => {
+            const visible = notifications.activeProgress.filter((entry) => entry.location !== "silent" &&
+                (entry.status === "running" || entry.status === "cancelling"));
+            const visibleIds = new Set(visible.map((entry) => entry.id));
+            for (const [id, handle] of projected) {
+                if (!visibleIds.has(id)) {
+                    handle.complete();
+                    projected.delete(id);
+                }
+            }
+            for (const snapshot of visible) {
+                let handle = projected.get(snapshot.id);
+                if (!handle) {
+                    handle = controller.notifications.createProgress({
+                        id: snapshot.id,
+                        title: snapshot.title,
+                        message: snapshot.message,
+                        source: snapshot.source,
+                        location: snapshot.location,
+                        cancellable: snapshot.cancellable,
+                    });
+                    projected.set(snapshot.id, handle);
+                }
+                handle.report({
+                    message: snapshot.message,
+                    current: snapshot.current,
+                    total: snapshot.total,
+                    indeterminate: snapshot.indeterminate,
+                });
+            }
+        };
+        const changed = notifications.on("changed", sync);
+        sync();
+        this.#notificationProgressBridgeDisposer = () => {
+            notifications.offref(changed);
+            for (const handle of projected.values()) {
+                handle.complete();
+            }
+            projected.clear();
+        };
+    }
+    syncWorkspaceHostEditorView(id) {
+        const registry = this.#workspaceHostController?.editorViews;
+        if (!registry)
+            return;
+        const contribution = this.editorViews.get(id);
+        if (!contribution) {
+            registry.unregister(id);
+            return;
+        }
+        registry.unregister(id);
+        registry.register(toDesignEditorViewContribution(contribution));
+    }
+    installWorkspaceHostEventBridge(controller) {
+        controller.on("layout-change", (event) => {
+            if (this.#syncingWorkspaceHost > 0 || event.source === "display-mode") {
+                return;
+            }
+            this.enqueueWorkspaceHostProjection(controller.getLayout(), event);
+        });
+        controller.on("display-mode-change", (mode) => {
+            if (this.#syncingWorkspaceHost > 0 || this.displayMode === mode)
+                return;
+            const previousMode = this.displayMode;
+            this.displayMode = mode;
+            this.trigger("display-mode-change", {
+                mode,
+                previousMode,
+                reason: "viewport",
+            });
+        });
+        controller.on("layout-will-show-overlay", (event) => {
+            this.forwardWorkspaceHostDropEvent("layout-will-show-overlay", event);
+        });
+        controller.on("layout-will-drop", (event) => {
+            this.forwardWorkspaceHostDropEvent("layout-will-drop", event);
+        });
+        controller.on("layout-did-drop", (event) => {
+            this.forwardWorkspaceHostDropEvent("layout-did-drop", event);
+        });
+        controller.on("layout-drag-start", (event) => {
+            this.forwardWorkspaceHostDragEvent("layout-drag-start", event);
+        });
+        controller.on("layout-drag-end", (event) => {
+            this.forwardWorkspaceHostDragEvent("layout-drag-end", event);
+        });
+    }
+    enqueueWorkspaceHostProjection(layout, event) {
+        const projected = workspaceJsonForCompatibility(normalizeWorkspaceJson(layout));
+        const preserveSidebarWidth = (side, current) => {
+            const value = projected[side].width.trim();
+            if (/^0(?:px|rem|em|%)?$/.test(value)) {
+                projected[side].width = "0";
+            }
+            else if (!(event.source === "resize" && event.id === side)) {
+                projected[side].width = current.sidebar.width;
+            }
+        };
+        preserveSidebarWidth("left", this.leftSplit);
+        preserveSidebarWidth("right", this.rightSplit);
+        const run = this.#workspaceHostProjection.then(async () => {
+            await this.withoutLayoutPersistence(async () => {
+                await this.restoreLayoutJson(projected);
+                // 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();
+            });
+            this.emitLayoutChangeAndScheduleSave(compatibilityLayoutEventFromDesign(event));
+        });
+        this.#workspaceHostProjection = run.catch((error) => {
+            console.error("Unable to project design-core workspace layout", error);
+        });
+    }
+    forwardWorkspaceHostDropEvent(eventName, event) {
+        const item = this.getLeafById(event.tabId) ?? undefined;
+        const target = this.getWorkspaceTabsById(event.targetPaneId) ??
+            item?.parent ??
+            this.rootSplit;
+        const compatibilityEvent = createWorkspaceLayoutDropEvent({
+            source: event.source,
+            operation: event.operation,
+            position: event.position,
+            target,
+            item,
+        });
+        this.trigger(eventName, compatibilityEvent);
+        if (compatibilityEvent.defaultPrevented)
+            event.preventDefault();
+    }
+    forwardWorkspaceHostDragEvent(eventName, event) {
+        const item = this.getLeafById(event.tabId) ?? undefined;
+        this.trigger(eventName, createWorkspaceLayoutDropEvent({
+            source: event.source,
+            operation: "tab-drag",
+            position: "center",
+            target: item?.parent ?? this.rootSplit,
+            item,
+        }));
+    }
+    getWorkspaceTabsById(id) {
+        if (this.bottomPanel.id === id)
+            return this.bottomPanel;
+        const roots = [
+            this.rootSplit,
+            this.leftSplit,
+            this.rightSplit,
+            ...this.floating.children,
+        ];
+        for (const root of roots) {
+            const match = root.iterateAllTabs((tabs) => tabs.id === id ? tabs : undefined);
+            if (match)
+                return match;
+        }
+        return null;
+    }
+    registerWorkspaceHostView(type) {
+        this.#workspaceHostViewDisposers.get(type)?.();
+        this.#workspaceHostViewDisposers.delete(type);
+        if (type === "empty" || !this.#workspaceHostController)
+            return;
+        const dispose = this.#workspaceHostController.renderer.registry.register({
+            kind: "imperative",
+            type,
+            showHeader: true,
+            getChrome: (context) => {
+                const leaf = this.getLeafById(context.tab.id);
+                const view = leaf?.view;
+                const file = view instanceof FileView ? view.file : null;
+                const actions = view instanceof ItemView ? view.actions : [];
+                const breadcrumbPath = view?.getBreadcrumbFilePath() ?? file?.path ?? null;
+                const contributedBreadcrumbs = view?.getBreadcrumbs() ?? [];
+                return {
+                    title: file?.name ??
+                        (breadcrumbPath ? basename(breadcrumbPath) : undefined) ??
+                        leaf?.getDisplayText() ??
+                        context.tab.title,
+                    titleEditable: file != null,
+                    onTitleCommit: async (nextTitle) => {
+                        const currentLeaf = this.getLeafById(context.tab.id);
+                        const currentView = currentLeaf?.view;
+                        const currentFile = currentView instanceof FileView ? currentView.file : null;
+                        if (!currentFile)
+                            return;
+                        const trimmed = nextTitle.trim();
+                        if (!trimmed || trimmed === currentFile.name)
+                            return;
+                        const parent = dirname(currentFile.path);
+                        const nextPath = parent === "/" ? trimmed : joinPath(parent, trimmed);
+                        await this.app.fileManager.renameFile(currentFile, nextPath);
+                        const renamed = this.app.vault.getFileByPath(nextPath);
+                        if (renamed && currentView instanceof FileView) {
+                            await currentView.onRename(renamed);
+                        }
+                    },
+                    breadcrumbs: [
+                        ...contributedBreadcrumbs,
+                        ...filePathBreadcrumbs(this.app, breadcrumbPath),
+                    ],
+                    canGoBack: leaf?.history.hasBackward ?? false,
+                    canGoForward: leaf?.history.hasForward ?? false,
+                    onGoBack: () => {
+                        void leaf?.history.back();
+                    },
+                    onGoForward: () => {
+                        void leaf?.history.forward();
+                    },
+                    actions: actions.map((action, index) => ({
+                        id: `view-action:${index}:${action.icon}`,
+                        label: action.title,
+                        icon: action.icon,
+                        disabled: action.disabled,
+                        onSelect: async (event) => {
+                            await action.callback(event);
+                        },
+                    })),
+                    buildPaneMenu: (menu) => {
+                        const currentLeaf = this.getLeafById(context.tab.id);
+                        const currentView = currentLeaf?.view;
+                        if (!currentView)
+                            return;
+                        replaceWorkspaceHostSplitActions(menu, this, currentLeaf);
+                        const paneMenu = new Menu();
+                        currentView.onPaneMenu(paneMenu, "more-options");
+                        prependPaneMenu(menu, paneMenu);
+                    },
+                };
+            },
+            mount: (target, context) => {
+                const leaf = this.getLeafById(context.tab.id);
+                if (!leaf)
+                    return;
+                target.replaceChildren(leaf.containerEl);
+                return () => {
+                    if (leaf.containerEl.parentElement === target) {
+                        leaf.containerEl.remove();
+                    }
+                };
+            },
+        });
+        this.#workspaceHostViewDisposers.set(type, dispose);
+    }
+    getMostRecentLeaf() {
+        return this.activeLeaf;
+    }
+    getVisibleHintTargets() {
+        const root = this.containerEl;
+        if (!root) {
+            return [];
+        }
+        const elements = Array.from(root.querySelectorAll(WORKSPACE_HINT_TARGET_SELECTOR));
+        const seenIds = new Map();
+        return elements.flatMap((element, index) => {
+            const type = normalizeHintText(element.dataset.hintTarget);
+            if (!type ||
+                isHintTargetDisabled(element) ||
+                !isHintTargetVisible(element)) {
+                return [];
+            }
+            const label = normalizeHintText(element.dataset.hintLabel) ||
+                normalizeHintText(element.getAttribute("aria-label")) ||
+                normalizeHintText(element.textContent) ||
+                type;
+            const baseId = normalizeHintText(element.dataset.hintTargetId) ||
+                `workspace-hint-target:${type}:${index}`;
+            const duplicateCount = seenIds.get(baseId) ?? 0;
+            seenIds.set(baseId, duplicateCount + 1);
+            return [
+                {
+                    id: duplicateCount === 0 ? baseId : `${baseId}:${duplicateCount}`,
+                    type,
+                    label,
+                    action: normalizeHintText(element.dataset.hintAction) || "click",
+                    element,
+                    leafId: normalizeHintText(element.dataset.hintLeafId) || undefined,
+                    commandId: normalizeHintText(element.dataset.hintCommandId) || undefined,
+                    description: normalizeHintText(element.dataset.hintDescription) || undefined,
+                    group: normalizeHintText(element.dataset.hintGroup) || undefined,
+                },
+            ];
+        });
+    }
+    async changeLayout(workspace) {
+        this.layoutReady = false;
+        try {
+            await this.restoreLayoutJson(workspace);
+            this.layoutReady = true;
+            this.layoutHandlers.forEach((it) => it());
+            this.trigger("layout-ready");
+            this.requestSaveLayout();
+        }
+        catch (error) {
+            this.layoutReady = true;
+            throw error;
+        }
+    }
+    getLayout() {
+        return this.toJson();
+    }
+    /**
+     * Bring a given leaf to the foreground. If the leaf is in a sidebar, the
+     * sidebar will be uncollapsed. `await` this function to ensure your view has
+     * been fully loaded and is not deferred.
+     *
+     * @public
+     */
+    async revealLeaf(leaf) {
+        let child = leaf;
+        let parent = leaf.parent;
+        while (parent) {
+            if (parent instanceof WorkspaceTabs) {
+                if (child instanceof WorkspaceLeaf ||
+                    child instanceof WorkspaceSidebarGroup) {
+                    parent.selected = child;
+                }
+                if (parent instanceof WorkspaceBottomPanel) {
+                    parent._applyOpen(true);
+                }
+            }
+            else if (parent instanceof WorkspaceSidedock) {
+                parent.sidebar.setOpen(true);
+            }
+            child = parent;
+            parent = parent.parent;
+        }
+        const floatingWindow = this.floatingWindowForLeaf(leaf);
+        if (floatingWindow) {
+            this.focusFloatingWindow(floatingWindow);
+        }
+    }
+    registerView(type, viewCreator) {
+        this.viewTypes.set(type, viewCreator);
+        this.registerWorkspaceHostView(type);
+    }
+    registerEditorView(contribution) {
+        return this.editorViews.register(contribution);
+    }
+    registerSidebarView(type, options = {}) {
+        this.sidebarViewPlacements.set(type, { ...options });
+    }
+    unregisterSidebarView(type) {
+        this.sidebarViewPlacements.delete(type);
+    }
+    /**
+     * Registers a view with the 'Page preview' core plugin as an emitter of the
+     * 'hover-link' event.
+     *
+     * @public
+     */
+    registerHoverLinkSource(id, info) {
+        this.hoverLinkSources.set(id, { ...info });
+    }
+    unregisterHoverLinkSource(id) {
+        this.hoverLinkSources.delete(id);
+    }
+    updateOptions() {
+        this.app.telemetry.measure("workspace.update_options", (span) => {
+            let editorCount = 0;
+            this.iterateAllLeaves((leaf) => {
+                if (leaf.view instanceof TextFileView) {
+                    editorCount += 1;
+                    const editor = leaf.view.editor;
+                    editor.updateExtensions([], leaf.view.getState());
+                }
+            });
+            span.setAttribute("workspace.updated_editor_count", editorCount);
+        }, { slowThresholdMs: 100 });
+    }
+    unregisterView(type) {
+        this.#workspaceHostViewDisposers.get(type)?.();
+        this.#workspaceHostViewDisposers.delete(type);
+        return this.viewTypes.delete(type);
+    }
+    normalizeExtensionKey(extension) {
+        const normalized = extension.trim().toLowerCase();
+        if (!normalized) {
+            return "";
+        }
+        return normalized.startsWith(".") ? normalized : `.${normalized}`;
+    }
+    resolveViewTypeForExtensionKey(extensionKey) {
+        if (!extensionKey) {
+            return undefined;
+        }
+        return this.viewExtensions.get(extensionKey);
+    }
+    resolveViewTypeForPath(path) {
+        const normalizedPath = path.trim().toLowerCase();
+        if (!normalizedPath) {
+            return undefined;
+        }
+        let matchedViewType;
+        let matchedExtensionLength = -1;
+        for (const [extension, viewType] of this.viewExtensions.entries()) {
+            if (!normalizedPath.endsWith(extension) ||
+                extension.length <= matchedExtensionLength) {
+                continue;
+            }
+            matchedViewType = viewType;
+            matchedExtensionLength = extension.length;
+        }
+        return matchedViewType;
+    }
+    extensionKeyToFilenamePattern(extensionKey) {
+        return `*${extensionKey}`;
+    }
+    humanizeViewType(viewType) {
+        return viewType
+            .replace(/[._-]+/g, " ")
+            .replace(/\b\w/gu, (char) => char.toUpperCase());
+    }
+    registeredEditorViewForPath(path) {
+        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))
+            .sort((left, right) => {
+            const priority = { option: 0, default: 1, exclusive: 2 };
+            const priorityDelta = priority[right.view.priority] - priority[left.view.priority];
+            if (priorityDelta !== 0) {
+                return priorityDelta;
+            }
+            const specificity = compareEditorAssociationPatternSpecificity(right.pattern, left.pattern);
+            if (specificity !== 0) {
+                return specificity;
+            }
+            return left.viewIndex - right.viewIndex;
+        })[0]?.view;
+    }
+    getEditorAssociationForPath(path) {
+        const config = this.app.configuration
+            ?.getConfiguration?.()
+            ?.get("workspace.editorAssociations", {});
+        const associations = config && typeof config === "object" && !Array.isArray(config)
+            ? config
+            : {};
+        return Object.entries(associations)
+            .map(([pattern, editorViewId], index) => ({
+            pattern,
+            editorViewId,
+            index,
+        }))
+            .filter(({ pattern, editorViewId }) => typeof editorViewId === "string" &&
+            editorViewId.trim().length > 0 &&
+            matchesEditorAssociationGlob(pattern, path))
+            .sort((left, right) => {
+            const specificity = compareEditorAssociationPatternSpecificity(right.pattern, left.pattern);
+            return specificity || right.index - left.index;
+        })
+            .map(({ pattern, editorViewId }) => ({
+            pattern,
+            editorViewId,
+            view: this.editorViews.get(editorViewId),
+        }))[0];
+    }
+    resolveEditorAssociationViewType(path) {
+        const association = this.getEditorAssociationForPath(path);
+        if (association?.view && this.viewTypes.has(association.view.viewType)) {
+            return association.view.viewType;
+        }
+        return this.registeredEditorViewForPath(path)?.viewType;
+    }
+    registerExtensions(extensions, viewType) {
+        const filenamePatterns = [];
+        extensions.forEach((ext) => {
+            const extensionKey = this.normalizeExtensionKey(ext);
+            if (!extensionKey) {
+                return;
+            }
+            this.viewExtensions.set(extensionKey, viewType);
+            filenamePatterns.push(this.extensionKeyToFilenamePattern(extensionKey));
+        });
+        if (filenamePatterns.length === 0) {
+            return;
+        }
+        const existing = this.editorViews.getByViewType(viewType)[0];
+        if (existing) {
+            this.editorViews.update(existing.id, { filenamePatterns });
+            return;
+        }
+        this.editorViews.upsert({
+            id: viewType,
+            viewType,
+            label: this.humanizeViewType(viewType),
+            filenamePatterns,
+            priority: "default",
+            source: "compat",
+        });
+    }
+    unregisterExtensions(extensions, viewType) {
+        const filenamePatterns = [];
+        extensions.forEach((ext) => {
+            const extensionKey = this.normalizeExtensionKey(ext);
+            if (this.viewExtensions.get(extensionKey) === viewType) {
+                this.viewExtensions.delete(extensionKey);
+            }
+            if (extensionKey) {
+                filenamePatterns.push(this.extensionKeyToFilenamePattern(extensionKey));
+            }
+        });
+        for (const view of this.editorViews.getByViewType(viewType)) {
+            this.editorViews.removeFilenamePatterns(view.id, filenamePatterns);
+        }
+    }
+    determineViewType(type) {
+        if (this.viewTypes.has(type)) {
+            return type;
+        }
+        return this.resolveViewTypeForExtensionKey(this.normalizeExtensionKey(type));
+    }
+    determineViewTypeForPath(path) {
+        return (this.resolveEditorAssociationViewType(path) ??
+            this.resolveViewTypeForPath(path));
+    }
+    async createOnDemandPluginInstallView(leaf, file, options = {}) {
+        const confirm = options.confirm ?? true;
+        if (confirm && !(await this.confirmOnDemandRegistryLookup(file.path))) {
+            return null;
+        }
+        const entry = await this.findOnDemandPluginForPath(file.path);
+        if (!entry) {
+            return null;
+        }
+        return new OnDemandPluginInstallView(leaf, entry, this.app);
+    }
+    onDemandRegistryLookupConfirmed = new Set();
+    async findOnDemandPluginForPath(path) {
+        const distribution = this.app.pluginDistribution;
+        if (!distribution) {
+            return null;
+        }
+        try {
+            await distribution.refreshCatalog();
+        }
+        catch (error) {
+            new Notice(`Unable to check the official plugin registry: ${formatUnknownError(error)}`, 6000);
+            return null;
+        }
+        return (distribution
+            .search({
+            channel: "official",
+            compatibleOnly: true,
+        })
+            .find((entry) => entry.channel === "official" &&
+            registryContributionMatchesPath(entry, path)) ?? null);
+    }
+    confirmOnDemandRegistryLookup(path) {
+        if (this.onDemandRegistryLookupConfirmed.has(path)) {
+            return Promise.resolve(true);
+        }
+        return promptConfirm(this.getCommandHostDocument(), {
+            title: "No editor available",
+            description: `No installed editor can open ${path}. Check the official plugin registry for a verified plugin?`,
+            confirmLabel: "Check registry",
+            cancelLabel: "Cancel",
+        }).then((confirmed) => {
+            if (confirmed) {
+                this.onDemandRegistryLookupConfirmed.add(path);
+            }
+            return confirmed;
+        });
+    }
+    async activateLayoutPlugins(layout) {
+        const viewTypes = new Set();
+        collectLayoutViewTypes(layout.main, viewTypes);
+        collectLayoutViewTypes(layout.left, viewTypes);
+        collectLayoutViewTypes(layout.right, viewTypes);
+        collectLayoutViewTypes(layout.bottom, viewTypes);
+        for (const window of layout.floating ?? []) {
+            collectLayoutViewTypes(window, viewTypes);
+        }
+        for (const viewType of viewTypes) {
+            await this.app.plugins.activateForViewType(viewType);
+        }
+    }
+    viewCreator(type) {
+        if (typeof type === "string") {
+            const viewType = this.determineViewType(type);
+            if (viewType) {
+                return this.viewTypes.get(viewType);
+            }
+        }
+        else if (type instanceof TFile) {
+            const viewType = this.determineViewTypeForPath(type.path) ??
+                this.determineViewType(type.extension);
+            if (viewType) {
+                return this.viewTypes.get(viewType);
+            }
+        }
+    }
+    setActiveLeaf(leaf, params) {
+        this.activeLeaf = leaf;
+        this.revealLeaf(leaf);
+    }
+    /**
+     * Retrieve a leaf by its id.
+     *
+     * @param id Id of the leaf to retrieve.
+     * @public
+     */
+    getLeafById(id) {
+        return (this.iterateAllLeaves((leaf) => {
+            return leaf.id === id ? leaf : undefined;
+        }) || null);
+    }
+    /**
+     * Get the currently active view of a given type.
+     *
+     * @public
+     */
+    getActiveViewOfType(type) {
+        const leaf = this.activeLeaf;
+        if (leaf && leaf.view instanceof type) {
+            return leaf.view;
+        }
+        return null;
+    }
+    /**
+     * Iterate through all leaves in the main area of the workspace.
+     *
+     * @public
+     */
+    iterateRootLeaves(callback) {
+        this.rootSplit.iterateAllLeaves(callback);
+    }
+    /**
+     * Returns the file for the current view if it's a `FileView`. Otherwise, it
+     * will return the most recently active file.
+     *
+     * @public
+     */
+    getActiveFile() {
+        const leaf = this.activeLeaf;
+        if (leaf && leaf.view instanceof FileView) {
+            if (leaf.view.file)
+                this.lastActiveFile = leaf.view.file;
+            return leaf.view.file ?? this.lastActiveFile;
+        }
+        return this.lastActiveFile;
+    }
+    /**
+     * Iterate through all leaves, including main area leaves, floating leaves,
+     * and sidebar leaves.
+     *
+     * @public
+     */
+    iterateAllLeaves(callback) {
+        for (const child of [
+            this.rootSplit,
+            this.leftSplit,
+            this.rightSplit,
+            this.bottomPanel,
+            this.floating,
+        ]) {
+            const response = child.iterateAllLeaves(callback);
+            if (response !== undefined && response !== null) {
+                return response;
+            }
+        }
+    }
+    /** @public */
+    getOpenLeafEntries(options = {}) {
+        const includeMain = options.includeMain ?? true;
+        const includeLeftSidebar = options.includeLeftSidebar ?? true;
+        const includeRightSidebar = options.includeRightSidebar ?? true;
+        const includeBottomPanel = options.includeBottomPanel ?? true;
+        const includeFloating = options.includeFloating ?? true;
+        const includePopout = options.includePopout ?? true;
+        const entries = [];
+        const pushLeaf = (leaf, region, parentWindow) => {
+            const tabs = this.tabsForLeaf(leaf);
+            const group = leaf.parent instanceof WorkspaceSidebarGroup ? leaf.parent : undefined;
+            const view = leaf.view;
+            const isSelectedInParent = group
+                ? tabs.selectedChild === group && !group.isLeafHidden(leaf)
+                : tabs.selectedLeaf === leaf;
+            entries.push({
+                id: leaf.id,
+                leaf,
+                title: view.getDisplayText(),
+                icon: view.getIcon(),
+                viewType: view.getViewType(),
+                ...(view instanceof FileView && view.file?.path
+                    ? { filePath: view.file.path }
+                    : {}),
+                region,
+                active: this.activeLeaf === leaf,
+                selectedInParent: isSelectedInParent,
+                parentTabsId: tabs.id,
+                ...(group
+                    ? {
+                        parentGroupId: group.id,
+                        parentGroupName: group.name,
+                    }
+                    : {}),
+                ...(parentWindow
+                    ? {
+                        parentWindowId: parentWindow.id,
+                        parentWindowMode: parentWindow.mode,
+                    }
+                    : {}),
+            });
+        };
+        if (includeMain) {
+            this.rootSplit.iterateAllLeaves((leaf) => {
+                pushLeaf(leaf, "main");
+            });
+        }
+        if (includeLeftSidebar) {
+            this.leftSplit.iterateAllLeaves((leaf) => {
+                pushLeaf(leaf, "left");
+            });
+        }
+        if (includeRightSidebar) {
+            this.rightSplit.iterateAllLeaves((leaf) => {
+                pushLeaf(leaf, "right");
+            });
+        }
+        if (includeBottomPanel) {
+            this.bottomPanel.iterateAllLeaves((leaf) => {
+                pushLeaf(leaf, "bottom");
+            });
+        }
+        if (includeFloating || includePopout) {
+            this.floating.children.forEach((window) => {
+                const region = window.mode === "popout"
+                    ? "popout"
+                    : "floating";
+                if ((region === "floating" && !includeFloating) ||
+                    (region === "popout" && !includePopout)) {
+                    return;
+                }
+                window.iterateAllLeaves((leaf) => {
+                    pushLeaf(leaf, region, window);
+                });
+            });
+        }
+        return entries;
+    }
+    /**
+     * Remove all leaves of the given type.
+     *
+     * @public
+     */
+    detachLeavesOfType(viewType) {
+        this.getLeavesOfType(viewType).forEach((leaf) => {
+            leaf.close();
+        });
+    }
+    getLeavesOfType(viewType) {
+        const leaves = [];
+        this.iterateAllLeaves((leaf) => {
+            if (leaf.view.getViewType() === viewType) {
+                leaves.push(leaf);
+            }
+        });
+        return leaves;
+    }
+    /** @public */
+    activateLeaf(leaf, options = {}) {
+        if (!this.containsLeaf(leaf)) {
+            return false;
+        }
+        const tabs = this.tabsForLeaf(leaf);
+        if (leaf.parent instanceof WorkspaceSidebarGroup) {
+            leaf.parent.selectLeaf(leaf);
+            tabs.selected = leaf.parent;
+        }
+        else {
+            tabs.selected = leaf;
+        }
+        if (tabs instanceof WorkspaceBottomPanel) {
+            tabs._applyOpen(true);
+        }
+        const floatingWindow = this.floatingWindowForLeaf(leaf);
+        if (floatingWindow) {
+            this.floating.bringToFront(floatingWindow);
+            if (this.isMobileMode) {
+                if (options.focusRootHost ?? true) {
+                    this.focusRootHost();
+                }
+            }
+            else {
+                this.focusedHostId = floatingWindow.id;
+                if (floatingWindow.mode === "popout") {
+                    floatingWindow.focusPopoutWindow();
+                }
+            }
+        }
+        else if (options.focusRootHost ?? true) {
+            this.focusRootHost();
+        }
+        this.activeLeaf = leaf;
+        if (options.saveLayout ?? true) {
+            this.requestSaveLayout({
+                source: options.source ?? "api",
+                operation: options.operation ?? "activate-leaf",
+            });
+        }
+        return true;
+    }
+    /** @public */
+    closeLeafAndSelectFallback(leaf, options = {}) {
+        if (!this.containsLeaf(leaf)) {
+            return this.activeLeaf;
+        }
+        const wasActive = this.activeLeaf === leaf;
+        leaf.close();
+        let next = this.activeLeaf;
+        if (!this.containsLeaf(next) || next === leaf) {
+            next = null;
+        }
+        if (!next && (options.preferRoot ?? true)) {
+            next = this.activeRootLeaf;
+        }
+        if (!next) {
+            next = this.getOpenLeafEntries()[0]?.leaf ?? null;
+        }
+        if (wasActive && next) {
+            this.activateLeaf(next, {
+                saveLayout: false,
+                source: "api",
+                operation: "close-leaf-select-fallback",
+            });
+        }
+        if (options.saveLayout ?? true) {
+            this.requestSaveLayout({
+                source: "api",
+                operation: "close-leaf-mobile",
+            });
+        }
+        return next;
+    }
+    createLeafInParent(parent, index) {
+        const leaf = new WorkspaceLeaf();
+        parent.addChild(new WorkspaceTabs({ leaves: [leaf] }), index);
+        return leaf;
+    }
+    createLeafBySplit(leaf, direction = "vertical", before = false) {
+        const sibling = new WorkspaceLeaf();
+        const tab = this.tabsForLeaf(leaf);
+        if (tab instanceof WorkspaceBottomPanel) {
+            throw new Error("Bottom panel does not support split panes");
+        }
+        const split = tab.parent;
+        const index = split.children.findIndex((it) => it === tab);
+        const newTab = new WorkspaceTabs({ leaves: [sibling] });
+        if (split.type === direction) {
+            split.addChild(newTab, before ? index : index + 1);
+        }
+        else {
+            const oldTab = split.removeChild(tab, true);
+            const nested = new WorkspaceView(direction);
+            if (before) {
+                nested.addChild(newTab);
+                oldTab && nested.addChild(oldTab);
+            }
+            else {
+                oldTab && nested.addChild(oldTab);
+                nested.addChild(newTab);
+            }
+            split.addChild(nested, index);
+        }
+        return sibling;
+    }
+    splitActiveLeaf(direction) {
+        return this.getLeaf("split", direction);
+    }
+    getUnpinnedLeaf() {
+        return this.getLeaf(false);
+    }
+    getGroupLeaves(group) {
+        const leaves = [];
+        this.iterateAllLeaves((leaf) => {
+            if (leaf.group === group) {
+                leaves.push(leaf);
+            }
+        });
+        return leaves;
+    }
+    sideDock(side) {
+        return side === "left" ? this.leftSplit : this.rightSplit;
+    }
+    tabsForLeaf(leaf) {
+        return leaf.parent instanceof WorkspaceSidebarGroup
+            ? leaf.parent.parent
+            : leaf.parent;
+    }
+    setFocusMode(state) {
+        if (this.focusMode?.leaf === state?.leaf &&
+            this.focusMode?.tabs === state?.tabs) {
+            return false;
+        }
+        this.focusMode = state;
+        this.trigger("focus-mode-change", state);
+        return true;
+    }
+    selectedLeafForWindow(window) {
+        return (window.iterateAllTabs((tabs) => tabs.selectedLeaf || undefined) ?? null);
+    }
+    getSidebarGroups(side) {
+        const groups = [];
+        const sections = side
+            ? [this.sideDock(side)]
+            : [this.leftSplit, this.rightSplit];
+        sections.forEach((section) => {
+            section.iterateAllTabs((tabs) => {
+                tabs.children.forEach((child) => {
+                    if (child instanceof WorkspaceSidebarGroup) {
+                        groups.push(child);
+                    }
+                });
+            });
+        });
+        return groups;
+    }
+    getSidebarGroup(side, group) {
+        const id = normalizeSidebarGroupId(group);
+        return (this.getSidebarGroups(side).find((candidate) => candidate.id === id || candidate.name === group) ?? null);
+    }
+    getOrCreateSidebarGroup(side, group, options = {}) {
+        const id = normalizeSidebarGroupId(options.id ?? group);
+        const existing = this.getSidebarGroup(side, id);
+        if (existing) {
+            if (options.name !== undefined)
+                existing.name = options.name;
+            if (options.icon !== undefined)
+                existing.icon = options.icon;
+            return existing;
+        }
+        const sidebarGroup = new WorkspaceSidebarGroup({
+            id,
+            name: options.name ?? group,
+            icon: options.icon,
+            hiddenLeafIds: options.hiddenLeafIds,
+            collapsed: options.collapsed,
+        });
+        this.findOrCreateTab(this.sideDock(side)).addChild(sidebarGroup);
+        this.requestSaveLayout();
+        return sidebarGroup;
+    }
+    getSidebarGroupLeaves(side, group) {
+        return this.getSidebarGroup(side, group)?.children ?? [];
+    }
+    convertSidebarLeavesToGroup(side, leaves, options = {}) {
+        if (!leaves.length) {
+            throw new Error("Cannot create a sidebar group without leaves");
+        }
+        const groupId = options.id ?? options.group ?? leaves[0].view.getViewType();
+        const group = new WorkspaceSidebarGroup({
+            id: normalizeSidebarGroupId(groupId),
+            name: options.name ?? groupId,
+            icon: options.icon,
+            hiddenLeafIds: options.hiddenLeafIds,
+            collapsed: options.collapsed,
+        });
+        const tabs = this.tabsForLeaf(leaves[0]);
+        const insertIndex = Math.max(0, Math.min(...leaves.map((leaf) => tabs.children.findIndex((it) => it === leaf))));
+        leaves.forEach((leaf) => {
+            if (this.tabsForLeaf(leaf) !== tabs) {
+                throw new Error("Sidebar group conversion requires leaves in one tab set");
+            }
+            tabs.removeChild(leaf, true);
+            leaf.parent = undefined;
+            group.addChild(leaf);
+        });
+        tabs.addChild(group, insertIndex);
+        tabs.selected = group;
+        if (side !== "left" && side !== "right") {
+            throw new Error(`Unsupported sidebar side: ${side}`);
+        }
+        this.requestSaveLayout();
+        return group;
+    }
+    convertSidebarGroupToLeaves(group) {
+        const tabs = group.parent;
+        const index = tabs.children.findIndex((it) => it === group);
+        const leaves = [...group.children];
+        tabs.removeChild(group, true);
+        group.children = [];
+        group.hiddenLeafIds = [];
+        group.collapsed = {};
+        leaves.forEach((leaf, offset) => {
+            tabs.addChild(leaf, index + offset);
+        });
+        tabs.selected = leaves[0] ?? "0";
+        this.requestSaveLayout();
+        return leaves;
+    }
+    getLastOpenFiles() {
+        if (this.recentFilePaths.length > 0)
+            return [...this.recentFilePaths];
+        const files = [];
+        this.iterateAllLeaves((leaf) => {
+            if (leaf.view instanceof FileView && leaf.view.file) {
+                files.push(leaf.view.file.path);
+            }
+        });
+        return [...new Set(files)];
+    }
+    getRecentFiles() {
+        return this.getLastOpenFiles()
+            .map((path) => this.app.vault.getFileByPath(path))
+            .filter((file) => file instanceof TFile);
+    }
+    recordRecentFile(file) {
+        this.recentFilePaths = [
+            file.path,
+            ...this.recentFilePaths.filter((path) => path !== file.path),
+        ].slice(0, Workspace.RECENT_FILE_LIMIT);
+    }
+    async openLinkText(linktext, sourcePath, newLeaf, openState) {
+        const linkpath = linktext.split(/[|#]/, 1)[0];
+        const candidates = [linkpath, `${linkpath}.md`, `${linkpath}.markdown`];
+        const file = candidates
+            .map((path) => this.app.vault.getFileByPath(path))
+            .find((file) => file instanceof TFile);
+        if (!file) {
+            new Notice(`Unable to find file: ${linktext}`);
+            return;
+        }
+        const leaf = this.getLeaf(newLeaf);
+        const state = openState?.state
+            ? { type: leaf.view.getViewType(), state: openState.state }
+            : undefined;
+        if (openState?.active !== false) {
+            this.activeLeaf = leaf;
+        }
+        await leaf.openFile(file, { state });
+    }
+    ensureSideLeaf(type, sideOrOptions = "right", options = {}) {
+        const registeredOptions = this.sidebarViewPlacements.get(type) ?? {};
+        const requestedOptions = arguments.length < 2
+            ? {}
+            : typeof sideOrOptions === "string"
+                ? { ...options, side: sideOrOptions }
+                : sideOrOptions;
+        const placement = { ...registeredOptions, ...requestedOptions };
+        const side = placement.side ?? "right";
+        if (placement.group) {
+            const group = this.getOrCreateSidebarGroup(side, placement.group, {
+                id: placement.group,
+                name: placement.groupTitle ?? placement.title ?? placement.group,
+                icon: placement.groupIcon ?? placement.icon,
+            });
+            const existing = group.children.find((leaf) => leaf.view.getViewType() === type);
+            if (existing)
+                return existing;
+            const leaf = new WorkspaceLeaf();
+            group.addChild(leaf);
+            if (placement.hidden) {
+                group.setLeafHidden(leaf, true);
+            }
+            this.requestSaveLayout();
+            return leaf;
+        }
+        const existing = this.getLeavesOfType(type)[0];
+        if (existing)
+            return existing;
+        const leaf = side === "left" ? this.getLeftLeaf(false) : this.getRightLeaf(false);
+        if (!leaf) {
+            throw new Error(`Unable to create ${side} leaf`);
+        }
+        return leaf;
+    }
+    handleLinkContextMenu(menu, linktext, sourcePath, event) {
+        menu.addItem((item) => item.setTitle("Open link").onClick(() => {
+            this.openLinkText(linktext, sourcePath);
+        }));
+    }
+    moveLeafToPopout(leaf, data) {
+        return this.moveWorkspaceChildToWindow(leaf, data, {
+            mode: "popout",
+            source: "api",
+            operation: "move-leaf-to-popout",
+        });
+    }
+    moveWorkspaceChildToPopout(item, data) {
+        return this.moveWorkspaceChildToWindow(item, data, {
+            mode: "popout",
+            source: "api",
+            operation: "move-workspace-child-to-popout",
+        });
+    }
+    openPopoutLeaf(data) {
+        const window = this.createWorkspaceWindow({ ...data, mode: "popout" });
+        const tabs = new WorkspaceTabs({ leaves: [] });
+        const leaf = new WorkspaceLeaf();
+        tabs.addChild(leaf);
+        tabs.selected = leaf;
+        window.addChild(tabs);
+        this.floating.addChild(window);
+        this.floating.bringToFront(window);
+        this.activeLeaf = leaf;
+        this.requestSaveLayout({
+            source: "popout",
+            operation: "open-popout-window",
+        });
+        return leaf;
+    }
+    openFloatingLeaf(data) {
+        const window = this.createWorkspaceWindow({ ...data, mode: "floating" });
+        const tabs = new WorkspaceTabs({ leaves: [] });
+        const leaf = new WorkspaceLeaf();
+        tabs.addChild(leaf);
+        tabs.selected = leaf;
+        window.addChild(tabs);
+        this.floating.addChild(window);
+        this.floating.bringToFront(window);
+        this.activeLeaf = leaf;
+        this.requestSaveLayout({
+            source: "api",
+            operation: "open-floating-window",
+        });
+        return leaf;
+    }
+    moveWorkspaceChildToFloating(item, data, options = {}) {
+        return this.moveWorkspaceChildToWindow(item, data, {
+            ...options,
+            mode: "floating",
+        });
+    }
+    supportsPopoutWindows() {
+        return supportsWorkspacePopouts();
+    }
+    createWorkspaceWindow(data = {}) {
+        if (data.mode !== "popout") {
+            return new WorkspaceWindow({ ...data, mode: "floating" });
+        }
+        const handle = openWorkspacePopoutHandle(data);
+        if (!handle) {
+            throw new Error(WORKSPACE_POPOUT_UNSUPPORTED_ERROR_MESSAGE);
+        }
+        const window = new WorkspaceWindow({ ...data, mode: "popout" }, handle.win, handle.doc);
+        window.attachPopoutHandle(handle, () => {
+            if (this.floating.children.includes(window)) {
+                this.closeFloatingWindow(window, {
+                    closeHost: false,
+                    operation: "close-popout-window",
+                });
+            }
+        });
+        return window;
+    }
+    moveWorkspaceChildToWindow(item, data, options) {
+        const window = this.createWorkspaceWindow({ ...data, mode: options.mode });
+        const operation = options.operation ?? "float-pane";
+        const eventOptions = {
+            source: options.source ?? "api",
+            operation,
+            position: "center",
+            target: window,
+            item,
+        };
+        const willDrop = this.dispatchLayoutDropEvent("layout-will-drop", eventOptions);
+        if (willDrop.defaultPrevented) {
+            window.closePopoutWindow();
+            return window;
+        }
+        // Build and commit the destination tree before detaching the item from its
+        // source.  This ensures the item always has a reachable parent: if anything
+        // between the detach and the addChild were to throw, the window is already
+        // registered in this.floating and the item is still in its original tree.
+        const tabs = new WorkspaceTabs({ leaves: [] });
+        window.addChild(tabs);
+        this.floating.addChild(window);
+        if (item.parent) {
+            item.detach(true);
+        }
+        tabs.addChild(item);
+        tabs.selected = item;
+        this.floating.bringToFront(window);
+        this.activeLeaf =
+            item instanceof WorkspaceLeaf ? item : item.getSelectedLeaf();
+        this.requestSaveLayout({
+            source: options.mode === "popout"
+                ? "popout"
+                : options.source === "api"
+                    ? "api"
+                    : "drag-drop",
+            operation,
+        });
+        this.dispatchLayoutDropEvent("layout-did-drop", eventOptions);
+        return window;
+    }
+    focusFloatingWindow(window) {
+        const alreadyTopmost = this.floating.children.at(-1) === window;
+        this.focusedHostId = window.id;
+        this.floating.bringToFront(window);
+        window.focusPopoutWindow();
+        const selectedLeaf = this.selectedLeafForWindow(window);
+        if (selectedLeaf) {
+            this.activeLeaf = selectedLeaf;
+        }
+        if (!alreadyTopmost) {
+            this.requestSaveLayout({
+                source: "api",
+                operation: "focus-floating-pane",
+            });
+        }
+    }
+    setFloatingWindowDisplayState(window, displayState, operation = `set-floating-pane-${displayState}`) {
+        window.setDisplayState(displayState);
+        this.floating.bringToFront(window);
+        const selectedLeaf = this.selectedLeafForWindow(window);
+        if (selectedLeaf && displayState !== "minimized") {
+            this.activeLeaf = selectedLeaf;
+        }
+        this.requestSaveLayout({ source: "api", operation });
+    }
+    collapseFloatingWindow(window) {
+        this.setFloatingWindowDisplayState(window, "collapsed", "collapse-floating-pane");
+    }
+    minimizeFloatingWindow(window) {
+        this.setFloatingWindowDisplayState(window, "minimized", "minimize-floating-pane");
+    }
+    maximizeFloatingWindow(window) {
+        this.setFloatingWindowDisplayState(window, "maximized", "maximize-floating-pane");
+    }
+    restoreFloatingWindow(window) {
+        this.setFloatingWindowDisplayState(window, "normal", "restore-floating-pane");
+    }
+    setFloatingWindowBounds(window, bounds) {
+        window.setBounds(bounds);
+    }
+    commitFloatingWindowBounds(window, bounds, operation = "resize-floating-pane") {
+        window.setBounds(bounds);
+        this.requestSaveLayout({ source: "resize", operation });
+    }
+    closeFloatingWindow(window, options = {}) {
+        if (this.focusedHostId === window.id) {
+            this.focusedHostId = WORKSPACE_ROOT_HOST_ID;
+        }
+        if (options.closeHost !== false) {
+            window.closePopoutWindow();
+        }
+        const leaves = [];
+        window.iterateAllLeaves((leaf) => {
+            leaves.push(leaf);
+        });
+        leaves.forEach((leaf) => leaf.close());
+        if (this.floating.children.includes(window)) {
+            this.floating.removeChild(window);
+        }
+        this.activeLeaf = this.activeRootLeaf;
+        this.requestSaveLayout({
+            source: window.mode === "popout" ? "popout" : "api",
+            operation: options.operation ??
+                (window.mode === "popout"
+                    ? "close-popout-window"
+                    : "close-floating-pane"),
+        });
+    }
+    createSideLeaf(section) {
+        const leaf = new WorkspaceLeaf();
+        const currentTab = this.findOrCreateTab(section);
+        const layout = currentTab.parent;
+        const index = layout.children.findIndex((child) => child === currentTab);
+        const tab = layout.removeChild(currentTab, true);
+        if (!tab || index === -1) {
+            return null;
+        }
+        const nested = new WorkspaceView("horizontal");
+        nested.addChild(tab);
+        nested.addChild(new WorkspaceTabs({ leaves: [leaf] }));
+        layout.addChild(nested, index);
+        return leaf;
+    }
+    findOrCreateTab(section) {
+        const rootLeaf = section.iterateAllLeaves((leaf) => leaf);
+        let currentTab;
+        if (rootLeaf) {
+            currentTab = this.tabsForLeaf(rootLeaf);
+        }
+        else {
+            const tab = section.iterateAllTabs((tab) => tab);
+            if (tab) {
+                currentTab = tab;
+            }
+            else {
+                let split = section.iterateAllSplits((split) => split);
+                currentTab = new WorkspaceTabs({ leaves: [] });
+                if (split) {
+                    split.addChild(currentTab);
+                }
+                else {
+                    const view = new WorkspaceView();
+                    view.addChild(currentTab);
+                    section.addChild(view);
+                }
+            }
+        }
+        return currentTab;
+    }
+    /**
+     * Create a new leaf inside the right sidebar.
+     *
+     * @param split Should the existing split be split up?
+     * @public
+     */
+    getRightLeaf(split) {
+        if (split) {
+            return this.createSideLeaf(this.rightSplit);
+        }
+        const leaf = new WorkspaceLeaf();
+        this.findOrCreateTab(this.rightSplit).addChild(leaf);
+        return leaf;
+    }
+    /**
+     * Create a new leaf inside the left sidebar.
+     *
+     * @param split Should the existing split be split up?
+     * @public
+     */
+    getLeftLeaf(split) {
+        if (split) {
+            return this.createSideLeaf(this.leftSplit);
+        }
+        const leaf = new WorkspaceLeaf();
+        this.findOrCreateTab(this.leftSplit).addChild(leaf);
+        return leaf;
+    }
+    /** Create and activate a new leaf in the bottom panel. @public */
+    getBottomLeaf() {
+        const leaf = new WorkspaceLeaf();
+        this.bottomPanel.addChild(leaf);
+        this.bottomPanel.selected = leaf;
+        this.bottomPanel._applyOpen(true);
+        this.activeLeaf = leaf;
+        this.focusRootHost();
+        this.requestSaveLayout({
+            source: "bottom-panel",
+            operation: "open-leaf",
+        });
+        return leaf;
+    }
+    /** Open or close the bottom panel without changing its last size. @public */
+    setBottomPanelOpen(open) {
+        if (this.bottomPanel.collapsed === !open)
+            return;
+        this.bottomPanel._applyOpen(open);
+        this.requestSaveLayout({
+            source: "bottom-panel",
+            operation: open ? "expand" : "collapse",
+        });
+    }
+    /** Resize the bottom panel using design-core's supported range. @public */
+    setBottomPanelSize(size) {
+        if (!Number.isFinite(size))
+            return;
+        const nextSize = Math.min(640, Math.max(120, size));
+        if (this.bottomPanel.size === nextSize)
+            return;
+        this.bottomPanel._applySize(nextSize);
+        this.requestSaveLayout({
+            source: "bottom-panel",
+            operation: "resize",
+        });
+    }
+    /** Toggle the bottom panel while retaining its last expanded size. @public */
+    toggleBottomPanel() {
+        this.setBottomPanelOpen(this.bottomPanel.collapsed);
+    }
+    /** Configured desktop span of the bottom panel. @public */
+    get bottomPanelAlignment() {
+        return (this.#workspaceHostController?.workspace.bottomPanelAlignment ?? "center");
+    }
+    /** Update the live design-core shell setting without writing workspace JSON. */
+    setBottomPanelAlignment(alignment) {
+        return (this.#workspaceHostController?.workspace.setBottomPanelAlignment(alignment) ?? false);
+    }
+    duplicateLeaf(leaf, leafType, direction = "vertical") {
+        if (leafType === "split" &&
+            this.tabsForLeaf(leaf) instanceof WorkspaceBottomPanel) {
+            return Promise.reject(new Error("Bottom panel does not support split panes"));
+        }
+        if (leafType === "window") {
+            const popoutLeaf = this.openPopoutLeaf();
+            return popoutLeaf.setViewState({ ...leaf.state }).then(() => {
+                this.app.workspace.activeLeaf = popoutLeaf;
+                this.app.workspace.requestSaveLayout({
+                    source: "popout",
+                    operation: "duplicate-leaf-window",
+                });
+                return popoutLeaf;
+            });
+        }
+        const duplicateLeaf = new WorkspaceLeaf();
+        return duplicateLeaf.setViewState({ ...leaf.state }).then(() => {
+            const leafTabs = this.tabsForLeaf(leaf);
+            const split = leafTabs.parent;
+            switch (leafType) {
+                case true:
+                case "tab":
+                    leafTabs.addChild(duplicateLeaf);
+                    leafTabs.selected = (leafTabs.children.length - 1).toString();
+                    break;
+                case "split":
+                    direction ||= "vertical";
+                    if (split.type === direction) {
+                        split.addChild(new WorkspaceTabs({ leaves: [duplicateLeaf] }));
+                    }
+                    else {
+                        const index = split.children.findIndex((it) => it === leafTabs);
+                        const tab = split.removeChild(leafTabs, true);
+                        if (tab) {
+                            const layout = new WorkspaceView(direction);
+                            layout.addChild(tab);
+                            layout.addChild(new WorkspaceTabs({ leaves: [duplicateLeaf] }));
+                            split.addChild(layout, index);
+                        }
+                    }
+            }
+            this.app.workspace.activeLeaf = duplicateLeaf;
+            this.app.workspace.requestSaveLayout({
+                source: "api",
+                operation: leafType === "split" ? `duplicate-leaf-${direction}` : "duplicate-leaf-tab",
+            });
+            return duplicateLeaf;
+        });
+    }
+    /**
+     * If newLeaf is false (or not set) then an existing leaf which can be
+     * navigated is returned, or a new leaf will be created if there was no leaf
+     * available.
+     *
+     * If newLeaf is `'tab'` or `true` then a new leaf will be created in the
+     * preferred location within the root split and returned.
+     *
+     * If newLeaf is `'split'` then a new leaf will be created adjacent to the
+     * currently active leaf.
+     *
+     * If newLeaf is `'window'` then a popout window will be created with a new
+     * leaf inside.
+     *
+     * @public
+     */
+    getLeaf(newLeaf, direction) {
+        if (!newLeaf) {
+            const focusedHostId = this.getFocusedCommandHostId();
+            if (focusedHostId !== WORKSPACE_ROOT_HOST_ID) {
+                const focusedHostLeaf = this.getCommandHostLeaf(focusedHostId);
+                if (canReuseLeafForFileNavigation(focusedHostLeaf)) {
+                    return focusedHostLeaf;
+                }
+            }
+            const activeFloatingWindow = this.floatingWindowForLeaf(this._activeLeaf);
+            if (activeFloatingWindow &&
+                canReuseLeafForFileNavigation(this._activeLeaf)) {
+                return this._activeLeaf;
+            }
+            if (canReuseLeafForFileNavigation(this.activeRootLeaf)) {
+                return this.activeRootLeaf;
+            }
+            const tab = this.findOrCreateTab(this.rootSplit);
+            const reusable = tab.children.find((child) => child instanceof WorkspaceLeaf &&
+                canReuseLeafForFileNavigation(child));
+            if (reusable) {
+                return reusable;
+            }
+            if (canReuseLeafForFileNavigation(tab.selectedLeaf)) {
+                return tab.selectedLeaf;
+            }
+            const leaf = new WorkspaceLeaf();
+            tab.addChild(leaf);
+            return leaf;
+        }
+        if (newLeaf === "tab" || newLeaf === true) {
+            const tab = this.findOrCreateTab(this.rootSplit);
+            const leaf = new WorkspaceLeaf();
+            tab.addChild(leaf);
+            return leaf;
+        }
+        if (newLeaf === "split") {
+            const activeTab = (this.activeLeaf &&
+                this.containsRootLeaf(this.activeLeaf) &&
+                this.tabsForLeaf(this.activeLeaf)) ||
+                this.findOrCreateTab(this.rootSplit);
+            const leaf = new WorkspaceLeaf();
+            const view = activeTab.parent;
+            const dir = direction ?? "vertical";
+            if (view.type === dir) {
+                view.addChild(new WorkspaceTabs({ leaves: [leaf] }));
+            }
+            else {
+                const tab = view.removeChild(activeTab);
+                if (tab) {
+                    const split = new WorkspaceView(dir);
+                    split.addChild(tab);
+                    split.addChild(new WorkspaceTabs({ leaves: [leaf] }));
+                    view.addChild(split);
+                }
+            }
+            return leaf;
+        }
+        if (newLeaf === "window") {
+            return this.openPopoutLeaf();
+        }
+        throw new Error(`Unsupported pane: ${newLeaf}`);
+    }
+}
+export class OnDemandPluginInstallView extends FileView {
+    plugin;
+    status = $state("idle");
+    errorMessage = $state(null);
+    constructor(leaf, plugin, application) {
+        super(leaf);
+        this.plugin = plugin;
+        this.application = resolveApplication(application ?? leaf.application);
+    }
+    application;
+    getViewType() {
+        return ON_DEMAND_PLUGIN_INSTALL_VIEW_TYPE;
+    }
+    getDisplayText() {
+        return this.file?.name ?? "Install plugin";
+    }
+    getIcon() {
+        return "download";
+    }
+    canAcceptExtension() {
+        return true;
+    }
+    async onLoadFile(file) {
+        this.file = file;
+        this.render();
+    }
+    async onUnloadFile() {
+        this.file = null;
+    }
+    async onRename(file) {
+        this.file = file;
+        this.render();
+    }
+    getErrorMessage() {
+        return this.errorMessage;
+    }
+    async installAndOpen() {
+        if (!this.file || this.status === "installing") {
+            return false;
+        }
+        this.status = "installing";
+        this.errorMessage = null;
+        this.render();
+        try {
+            await withPluginInstallProgress(this.application, {
+                pluginId: this.plugin.id,
+                title: `Installing ${this.plugin.name}`,
+                source: "Plugin install",
+            }, (signal) => this.application.pluginDistribution.install(this.plugin.id, {
+                requireOfficial: true,
+                enable: true,
+                signal,
+            }));
+            const file = this.file;
+            const viewCreator = this.application.workspace.viewCreator(file);
+            if (!viewCreator) {
+                throw new Error(`Plugin ${this.plugin.name} installed, but it did not register a handler for ${file.path}.`);
+            }
+            await this.leaf.openFile(file, { result: { history: false } });
+            return true;
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                this.status = "idle";
+                this.errorMessage = null;
+                this.render();
+                return false;
+            }
+            this.status = "failed";
+            this.errorMessage =
+                error instanceof Error ? error.message : String(error);
+            this.render();
+            return false;
+        }
+    }
+    load() {
+        this.render();
+    }
+    unload() {
+        this.leaf?.contentEl?.replaceChildren();
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    render() {
+        const fileName = this.file?.name ?? "this file";
+        const root = document.createElement("section");
+        root.className = "plugin-install-prompt";
+        const panel = document.createElement("div");
+        panel.className = "plugin-install-prompt__panel";
+        root.appendChild(panel);
+        const title = document.createElement("h2");
+        title.className = "plugin-install-prompt__title";
+        title.textContent = `${this.plugin.name} is required`;
+        panel.appendChild(title);
+        const body = document.createElement("p");
+        body.className = "plugin-install-prompt__body";
+        body.textContent = `${fileName} can be opened by the verified official ${this.plugin.name} plugin.`;
+        panel.appendChild(body);
+        if (this.errorMessage) {
+            const error = document.createElement("pre");
+            error.className = "plugin-install-prompt__error";
+            error.textContent = this.errorMessage;
+            panel.appendChild(error);
+        }
+        const button = document.createElement("button");
+        button.type = "button";
+        button.className = "plugin-install-prompt__button";
+        button.disabled = this.status === "installing";
+        button.textContent =
+            this.status === "installing"
+                ? "Installing..."
+                : this.status === "failed"
+                    ? "Retry install"
+                    : "Install and open";
+        button.addEventListener("click", () => {
+            void this.installAndOpen();
+        });
+        panel.appendChild(button);
+        this.leaf?.contentEl?.replaceChildren(root);
+    }
+}
+function canReuseLeafForFileNavigation(leaf) {
+    if (!leaf)
+        return false;
+    return (leaf.view.getViewType() === "empty" || leaf.view instanceof FileView);
+}
+function isPoorerViewState(incoming, live) {
+    const next = incoming ?? {};
+    const liveEntries = Object.entries(live).filter(([, value]) => value !== undefined);
+    if (liveEntries.length === 0)
+        return false;
+    if (Object.keys(next).length === 0)
+        return true;
+    return liveEntries.some(([key]) => !(key in next));
+}
+function collectLayoutViewTypes(node, target) {
+    if (node.type === "split" || node.type === "floating") {
+        for (const child of node.children) {
+            collectLayoutViewTypes(child, target);
+        }
+        return;
+    }
+    for (const child of node.children) {
+        if (child.type === "leaf" && typeof child.state?.type === "string") {
+            target.add(child.state.type);
+        }
+    }
+}
+/**
+ * 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;
+    #title;
+    constructor(leaf, viewType, title, icon) {
+        super(leaf);
+        this.#viewType = viewType;
+        this.#title = title;
+        this.icon = icon;
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    getViewType() {
+        return this.#viewType;
+    }
+    getDisplayText() {
+        return this.#title;
+    }
+}
+function isHostOwnedViewType(workspace, type) {
+    if (!type || type === "empty" || workspace.viewCreator(type)) {
+        return false;
+    }
+    if (type === PROBLEMS_VIEW_TYPE) {
+        return true;
+    }
+    return (resolveWorkspaceHostBinding(workspace)?.controller.renderer.registry.resolve(type) != null);
+}
+function hostOwnedViewChrome(type, definition, chrome) {
+    const title = typeof chrome?.title === "string" &&
+        chrome.title.length > 0 &&
+        chrome.title !== type
+        ? chrome.title
+        : type === PROBLEMS_VIEW_TYPE
+            ? "Problems"
+            : type;
+    const icon = typeof chrome?.icon === "string" && chrome.icon.length > 0
+        ? chrome.icon
+        : (definition?.icon ??
+            (type === PROBLEMS_VIEW_TYPE ? "circle-alert" : "file"));
+    return { title, icon };
+}
+/**
+ * Single navigable pane in the workspace that hosts one {@link View} at a time.
+ *
+ * @public
+ */
+export class WorkspaceLeaf extends WorkspaceItem {
+    _view = $state();
+    hoverPopover = null;
+    pinned = $state(false);
+    group = $state(null);
+    ephemeralState = {};
+    contentEl = $state();
+    containerEl = $state();
+    history;
+    currentState = Object.freeze({
+        type: "empty",
+        state: Object.freeze({}),
+    });
+    detach(softDelete = false) {
+        return this.parent.removeChild(this, softDelete);
+    }
+    get state() {
+        const value = { ...this.currentState };
+        value.state ||= {};
+        Object.freeze(value.state);
+        return Object.freeze(value);
+    }
+    set state(value) {
+        value = { ...value };
+        value.state ||= {};
+        Object.freeze(value.state);
+        this.currentState = Object.freeze(value);
+    }
+    constructor(view) {
+        super();
+        if (view) {
+            view.leaf = this;
+            this.view = view;
+        }
+        else {
+            this.view = new EmptyView(this);
+        }
+        this.containerEl = createDiv("h-full");
+        // Imperative views own this compatibility root, so its sizing cannot rely
+        // on a host-wide utility stylesheet being present.
+        this.containerEl.style.height = "100%";
+        this.contentEl = this.containerEl.createDiv();
+        this.history = new HistoryManager(this.updateHistory.bind(this));
+    }
+    updateHistory(state) {
+        const nextState = cloneViewState(state);
+        this.state = nextState;
+        this.pinned = !!nextState.pinned;
+        const filePath = historyFilePathForViewState(nextState);
+        const file = filePath ? this.app.vault.getFileByPath(filePath) : null;
+        if (file instanceof TFile) {
+            this.ensureContentEl();
+            return this.openFile(file, {
+                state: nextState,
+                result: { history: false },
+            });
+        }
+        this.ensureContentEl();
+        return this.setViewState(nextState, { history: false });
+    }
+    captureCurrentViewState() {
+        return captureLeafViewState(this);
+    }
+    snapshotHistoryBeforeNavigation(result, capturedState) {
+        if (result?.history === false) {
+            return;
+        }
+        const currentState = capturedState
+            ? cloneViewState(capturedState)
+            : this.captureCurrentViewState();
+        this.state = currentState;
+        if (this.history.history.length === 0) {
+            this.history.pushState(cloneViewState(currentState));
+        }
+        else {
+            this.history.replaceState(cloneViewState(currentState));
+        }
+    }
+    pushHistoryAfterNavigation(result) {
+        if (result?.history === false) {
+            return;
+        }
+        const nextState = cloneViewState(this.state);
+        if (isEqual(this.history.history.state, nextState)) {
+            return;
+        }
+        this.history.pushState(nextState);
+    }
+    get view() {
+        return this._view;
+    }
+    set view(view) {
+        if (this._view === view) {
+            return;
+        }
+        if (this._view) {
+            const previousView = this._view;
+            previousView.unload();
+            if (hasDestroyableEditor(previousView)) {
+                previousView.editor.destroy();
+            }
+        }
+        view.leaf = this;
+        if (hasDestroyableEditor(view) && this.application) {
+            view.editor.bindApplication?.(this.application);
+        }
+        this._view = view;
+    }
+    open(view, result = { history: true }, state) {
+        view.leaf = this;
+        const filePath = (state || this.state)?.state?.["file"]?.toString();
+        const file = filePath ? this.app.vault.getFileByPath(filePath) : null;
+        this.view = view;
+        if (view instanceof FileView && file instanceof TFile) {
+            return this.openFile(file, { view, result, state }).then(() => view);
+        }
+        else if (view instanceof FileView && filePath) {
+            new Notice(`Unable to load file: ${filePath}`, undefined, this.app);
+        }
+        this.prepareContainerForView(view);
+        if (result?.history !== false) {
+            this.snapshotHistoryBeforeNavigation(result);
+        }
+        this.view.load();
+        if (result?.history !== false) {
+            this.pushHistoryAfterNavigation(result);
+        }
+        this.app.workspace.requestSaveLayout();
+        return Promise.resolve(this.view);
+    }
+    ensureContentEl() {
+        if (this.contentEl.parentElement === this.containerEl) {
+            return;
+        }
+        this.containerEl.empty();
+        this.containerEl.appendChild(this.contentEl);
+    }
+    prepareContainerForView(view) {
+        if (view instanceof ItemView) {
+            this.ensureContentEl();
+            return;
+        }
+        this.containerEl.empty();
+    }
+    openFile(file, { view, result, state, } = {}) {
+        const historyStateBeforeNavigation = result?.history === false ? undefined : this.captureCurrentViewState();
+        return this.app.telemetry
+            .measureAsync("workspace.leaf.prepare_open_file", async () => {
+            await this.app.plugins.activateForPath(file.path);
+            const languageIds = this.app.plugins.findLanguageIdsForPath(file.path);
+            for (const languageId of languageIds) {
+                await this.app.plugins.activateForLanguage(languageId);
+            }
+            const association = this.app.workspace.getEditorAssociationForPath(file.path);
+            if (association?.view) {
+                await this.app.plugins.activateForViewType(association.view.viewType);
+            }
+        }, { slowThresholdMs: 100 })
+            .then(async () => {
+            view =
+                view ??
+                    resolveViewForOpenFile(this, file) ??
+                    (await this.app.workspace.createOnDemandPluginInstallView(this, file)) ??
+                    undefined;
+            return this.app.telemetry.measureAsync("workspace.leaf.open_file", async (span) => {
+                span.setAttribute("leaf.id", this.id);
+                span.setAttribute("file.extension", file.extension);
+                span.setAttribute("view.type", view?.getViewType?.() ?? "unknown");
+                if (view instanceof FileView) {
+                    if (result?.history !== false) {
+                        this.snapshotHistoryBeforeNavigation(result, historyStateBeforeNavigation);
+                    }
+                    this.ensureContentEl();
+                    const mergedState = {
+                        ...view.getState(),
+                        ...(state?.state ?? {}),
+                        file: file.path,
+                    };
+                    await view.setState(mergedState);
+                    this.state = {
+                        type: view.getViewType(),
+                        state: mergedState,
+                    };
+                    this.view = view;
+                    await view.onLoadFile(file);
+                    this.app.workspace.trigger("file-open", file);
+                    if (result?.history !== false) {
+                        this.pushHistoryAfterNavigation(result);
+                    }
+                    this.view.load();
+                    this.app.workspace.requestSaveLayout();
+                    return;
+                }
+            }, {
+                attributes: {
+                    "leaf.id": this.id,
+                    "file.extension": file.extension,
+                },
+                slowThresholdMs: 250,
+            });
+        });
+    }
+    async setViewState(viewState, eState) {
+        return this.app.telemetry.measureAsync("workspace.leaf.set_view_state", async (span) => {
+            span.setAttribute("leaf.id", this.id);
+            span.setAttribute("view.type", viewState.type);
+            const persistedMissingViewType = viewState.type === "empty" &&
+                typeof viewState.state?.["__missingViewType"] === "string" &&
+                viewState.state["__missingViewType"].length > 0
+                ? viewState.state["__missingViewType"]
+                : null;
+            const requestedViewType = persistedMissingViewType ?? viewState.type;
+            const filePath = viewState.state?.["file"]?.toString();
+            const file = filePath ? this.app.vault.getFileByPath(filePath) : null;
+            if (requestedViewType === ON_DEMAND_PLUGIN_INSTALL_VIEW_TYPE &&
+                file instanceof TFile) {
+                const promptView = await this.app.workspace.createOnDemandPluginInstallView(this, file, { confirm: false });
+                if (promptView) {
+                    this.state = viewState;
+                    this.pinned = !!viewState.pinned;
+                    const result = {
+                        history: eState?.history === true,
+                    };
+                    await promptView.setState({ ...(viewState.state || {}) });
+                    await this.open(promptView, result, viewState);
+                    return;
+                }
+            }
+            if (eState?.activatePlugins !== false) {
+                await this.app.plugins.activateForViewType(requestedViewType);
+            }
+            let viewCreator = this.app.workspace.viewCreator(requestedViewType);
+            let resolvedViewState = viewState;
+            if (viewCreator && persistedMissingViewType) {
+                const restoredState = { ...(viewState.state ?? {}) };
+                delete restoredState["__missingViewType"];
+                resolvedViewState = {
+                    ...viewState,
+                    type: requestedViewType,
+                    state: restoredState,
+                };
+            }
+            else if (!viewCreator &&
+                isHostOwnedViewType(this.app.workspace, requestedViewType)) {
+                const restoredState = { ...(viewState.state ?? {}) };
+                delete restoredState["__missingViewType"];
+                resolvedViewState = {
+                    ...viewState,
+                    type: requestedViewType,
+                    state: restoredState,
+                };
+                const definition = resolveWorkspaceHostBinding(this.app.workspace)?.controller.renderer.registry.resolve(requestedViewType);
+                const chrome = hostOwnedViewChrome(requestedViewType, definition, persistedMissingViewType
+                    ? undefined
+                    : { title: eState?.title, icon: eState?.icon });
+                viewCreator = (leaf) => new HostOwnedWorkspaceView(leaf, requestedViewType, chrome.title, chrome.icon);
+            }
+            else if (!viewCreator) {
+                new Notice(`Unknown view type: ${requestedViewType}`, undefined, this.app);
+                resolvedViewState = {
+                    ...viewState,
+                    type: "empty",
+                    state: {
+                        ...(viewState.state ?? {}),
+                        __missingViewType: requestedViewType,
+                    },
+                };
+                viewCreator =
+                    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 || {}) });
+            await this.open(view, result, resolvedViewState);
+        }, {
+            attributes: {
+                "leaf.id": this.id,
+                "view.type": viewState.type,
+            },
+            slowThresholdMs: 150,
+        });
+    }
+    getViewState() {
+        return this.state;
+    }
+    get isDeferred() {
+        return false;
+    }
+    loadIfDeferred() {
+        return Promise.resolve();
+    }
+    getEphemeralState() {
+        return this.ephemeralState;
+    }
+    setEphemeralState(state) {
+        this.ephemeralState = state;
+    }
+    togglePinned() {
+        this.setPinned(!this.pinned);
+    }
+    setPinned(pinned) {
+        this.pinned = pinned;
+        this.state = { ...this.state, pinned };
+        this.trigger("pinned-change", pinned);
+    }
+    setGroupMember(other) {
+        if (other.group) {
+            this.setGroup(other.group);
+        }
+    }
+    setGroup(group) {
+        this.group = group;
+        this.trigger("group-change", !!group);
+    }
+    getIcon() {
+        return this.view.getIcon();
+    }
+    getDisplayText() {
+        return this.view.getDisplayText();
+    }
+    getContainer() {
+        return this.app.workspace.rootContainer;
+    }
+    onResize() { }
+    close() {
+        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,
+        });
+    }
+    reload() {
+        this.loadJson(this.toJson());
+    }
+    toJson() {
+        return {
+            id: this.id,
+            type: "leaf",
+            state: {
+                type: this.view.getViewType(),
+                state: this.view.getState(),
+                icon: this.view.getIcon(),
+                title: this.view.getDisplayText(),
+            },
+        };
+    }
+}
+export class Notice {
+    id;
+    noticeEl = createDiv();
+    containerEl = this.noticeEl;
+    messageEl = this.noticeEl.createDiv();
+    application;
+    constructor(message, duration, application) {
+        this.application = application ?? getApplicationCompatibility();
+        this.messageEl.setText(message);
+        if (this.application?.notifications) {
+            const record = this.application.notifications.notify({
+                message,
+                id: createNoticeId(),
+            });
+            this.id = record.id;
+            return;
+        }
+        this.id = toast(message, { duration });
+    }
+    setMessage(message) {
+        this.messageEl.setText(message);
+        const id = this.id;
+        if (this.application?.notifications) {
+            this.application.notifications.notify({
+                message,
+                id: String(id),
+            });
+            return;
+        }
+        this.id = toast(message, { id });
+    }
+    hide() {
+        toast.dismiss(this.id);
+        this.noticeEl.detach();
+    }
+}
+function createNoticeId() {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return `notice-${crypto.randomUUID()}`;
+    }
+    return `notice-${Date.now().toString(36)}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
+}