@termaxjs/web-core 0.1.1

package/dist/layout/tabsActions.js

@@ -0,0 +1,975 @@
+export let layoutAdapter = { disposeSession: () => { } };
+export const setLayoutAdapter = (a) => layoutAdapter = a;
+import { findLeafCwd, hasLeaf, leafIds, moveLeaf, nextLeafId, removeLeaf, setLeafCwd as setLeafCwdInTree, siblingLeafOf, splitLeaf, swapLeaves, } from "./paneTree.js";
+import { MAX_PANES_PER_TAB, nextActiveInSpace } from "./useTabs.js";
+import { useTabsStore } from "./tabsStore.js";
+function basename(path) {
+    const parts = path.split(/[\\/]/).filter(Boolean);
+    return parts.length ? parts[parts.length - 1] : path;
+}
+function titleFromUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.host || url;
+    }
+    catch {
+        return url || "preview";
+    }
+}
+export function splitActivePane(tabId, dir) {
+    let newLeafId = null;
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal" || t.blocks)
+            return t;
+        if (leafIds(t.paneTree).length >= MAX_PANES_PER_TAB)
+            return t;
+        const splitId = useTabsStore.getState().allocId();
+        const leafId = useTabsStore.getState().allocId();
+        newLeafId = leafId;
+        const paneTree = splitLeaf(t.paneTree, t.activeLeafId, splitId, leafId, dir, t.cwd);
+        return { ...t, paneTree, activeLeafId: leafId };
+    }));
+    return newLeafId;
+}
+export function splitPaneDirectly(tabId, targetLeafId, dir, edge) {
+    let newLeafId = null;
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal" || t.blocks)
+            return t;
+        if (leafIds(t.paneTree).length >= MAX_PANES_PER_TAB)
+            return t;
+        const splitId = useTabsStore.getState().allocId();
+        const leafId = useTabsStore.getState().allocId();
+        newLeafId = leafId;
+        const paneTree = splitLeaf(t.paneTree, targetLeafId, splitId, leafId, dir, t.cwd, undefined, edge);
+        return { ...t, paneTree, activeLeafId: leafId };
+    }));
+    return newLeafId;
+}
+export function splitPaneWithEditor(tabId, leafIdToSplit, path, dir, edge = "after") {
+    let newLeafId = null;
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal" || t.blocks)
+            return t;
+        if (leafIds(t.paneTree).length >= MAX_PANES_PER_TAB)
+            return t;
+        const splitId = useTabsStore.getState().allocId();
+        const leafId = useTabsStore.getState().allocId();
+        newLeafId = leafId;
+        const paneTree = splitLeaf(t.paneTree, leafIdToSplit, splitId, leafId, dir, t.cwd, path, edge);
+        return { ...t, paneTree, activeLeafId: leafId };
+    }));
+    return newLeafId;
+}
+export function swapPanes(tabId, leafA, leafB) {
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal")
+            return t;
+        const paneTree = swapLeaves(t.paneTree, leafA, leafB);
+        return { ...t, paneTree };
+    }));
+}
+export function movePane(tabId, sourceId, targetId, dir, edge) {
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal")
+            return t;
+        const newSplitId = useTabsStore.getState().allocId();
+        const paneTree = moveLeaf(t.paneTree, sourceId, targetId, newSplitId, dir, edge);
+        return { ...t, paneTree };
+    }));
+}
+export function closePaneByLeaf(leafId) {
+    let didRemove = false;
+    useTabsStore.getState().setTabs((curr) => {
+        const tab = curr.find((t) => t.kind === "terminal" && hasLeaf(t.paneTree, leafId));
+        if (tab?.kind !== "terminal")
+            return curr;
+        const newTree = removeLeaf(tab.paneTree, leafId);
+        if (newTree === null) {
+            const fallback = nextActiveInSpace(curr, tab.id);
+            const next = curr.filter((x) => x.id !== tab.id);
+            const newActive = fallback !== null ? fallback : -1;
+            useTabsStore
+                .getState()
+                .setActiveId(useTabsStore.getState().activeId === tab.id
+                ? newActive
+                : useTabsStore.getState().activeId);
+            didRemove = true;
+            return next;
+        }
+        const remaining = leafIds(newTree);
+        let newActive = tab.activeLeafId;
+        if (tab.activeLeafId === leafId) {
+            const sib = siblingLeafOf(tab.paneTree, leafId);
+            newActive = sib && remaining.includes(sib) ? sib : remaining[0];
+        }
+        didRemove = true;
+        return curr.map((x) => x.id === tab.id
+            ? { ...x, paneTree: newTree, activeLeafId: newActive }
+            : x);
+    });
+    if (didRemove) {
+        layoutAdapter.disposeSession(leafId);
+        window.dispatchEvent(new Event("resize"));
+    }
+}
+export function closeActivePane(tabId) {
+    let closedTab = false;
+    let removedLeaf = null;
+    useTabsStore.getState().setTabs((curr) => {
+        const t = curr.find((x) => x.id === tabId);
+        if (t?.kind !== "terminal")
+            return curr;
+        const target = t.activeLeafId;
+        const newTree = removeLeaf(t.paneTree, target);
+        if (newTree === null) {
+            const fallback = nextActiveInSpace(curr, tabId);
+            const next = curr.filter((x) => x.id !== tabId);
+            const newActive = fallback !== null ? fallback : -1;
+            useTabsStore
+                .getState()
+                .setActiveId(useTabsStore.getState().activeId === tabId
+                ? newActive
+                : useTabsStore.getState().activeId);
+            closedTab = true;
+            removedLeaf = target;
+            return next;
+        }
+        const remaining = leafIds(newTree);
+        const sib = siblingLeafOf(t.paneTree, target);
+        const newActive = sib && remaining.includes(sib) ? sib : remaining[0];
+        removedLeaf = target;
+        return curr.map((x) => x.id === tabId ? { ...x, paneTree: newTree, activeLeafId: newActive } : x);
+    });
+    if (removedLeaf !== null) {
+        layoutAdapter.disposeSession(removedLeaf);
+        window.dispatchEvent(new Event("resize"));
+    }
+    return closedTab;
+}
+export function mergeTabIntoPane(sourceTabId, activeTabId, targetPaneId, dir, edge) {
+    useTabsStore.getState().setTabs((curr) => {
+        const sourceTab = curr.find((t) => t.id === sourceTabId);
+        const activeTab = curr.find((t) => t.id === activeTabId);
+        if (!sourceTab || !activeTab || activeTab.kind !== "terminal")
+            return curr;
+        if (sourceTabId === activeTabId)
+            return curr;
+        const newSplitId = useTabsStore.getState().allocId();
+        let sourceNode;
+        if (sourceTab.kind === "terminal") {
+            const leaves = leafIds(sourceTab.paneTree);
+            if (leaves.length !== 1)
+                return curr;
+            let foundLeaf = null;
+            const findLeaf = (n) => {
+                if (n.kind === "leaf" && n.id === leaves[0])
+                    foundLeaf = n;
+                else if (n.kind === "split")
+                    n.children.forEach(findLeaf);
+            };
+            findLeaf(sourceTab.paneTree);
+            if (!foundLeaf)
+                return curr;
+            sourceNode = foundLeaf;
+        }
+        else if (sourceTab.kind === "editor" || sourceTab.kind === "markdown") {
+            sourceNode = {
+                kind: "leaf",
+                id: useTabsStore.getState().allocId(),
+                editorPath: sourceTab.path,
+            };
+        }
+        else {
+            return curr;
+        }
+        function insertNode(n) {
+            if (n.kind === "split" && n.dir === dir) {
+                const leafIdx = n.children.findIndex((c) => c.kind === "leaf" && c.id === targetPaneId);
+                if (leafIdx >= 0) {
+                    const newChildren = [...n.children];
+                    newChildren.splice(edge === "before" ? leafIdx : leafIdx + 1, 0, sourceNode);
+                    return { ...n, children: newChildren };
+                }
+            }
+            if (n.kind === "leaf") {
+                if (n.id !== targetPaneId)
+                    return n;
+                return {
+                    kind: "split",
+                    id: newSplitId,
+                    dir,
+                    children: edge === "before" ? [sourceNode, n] : [n, sourceNode],
+                };
+            }
+            let changed = false;
+            const newChildren = n.children.map((c) => {
+                const inserted = insertNode(c);
+                if (inserted !== c)
+                    changed = true;
+                return inserted;
+            });
+            return changed ? { ...n, children: newChildren } : n;
+        }
+        const newActiveTree = insertNode(activeTab.paneTree);
+        return curr
+            .filter((t) => t.id !== sourceTabId)
+            .map((t) => t.id === activeTabId ? { ...t, paneTree: newActiveTree, activeLeafId: sourceNode.id } : t);
+    });
+}
+export function setActiveSpaceForNewTabs(spaceId) {
+    useTabsStore.getState().activeSpaceId = spaceId;
+}
+export function replaceTabs(next, nextActiveId) {
+    if (next.length === 0)
+        return;
+    useTabsStore.getState().setTabs(next);
+    useTabsStore.getState().setActiveId(nextActiveId);
+}
+export function newTabInSpace(spaceId, cwd) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((curr) => [
+        ...curr,
+        {
+            id: tabId,
+            kind: "terminal",
+            spaceId,
+            cold: true,
+            title: cwd ? basename(cwd) : "shell",
+            cwd,
+            paneTree: { kind: "leaf", id: leafId, cwd },
+            activeLeafId: leafId,
+        },
+    ]);
+    // Focus the new tab when it lands in the active space (e.g. opened from the
+    // empty-space landing) so the surface actually switches to it. Skip when
+    // seeding a background space — pointing the global activeId at a hidden
+    // space would blank the visible one.
+    if (useTabsStore.getState().activeSpaceId === spaceId) {
+        useTabsStore.getState().setActiveId(tabId);
+    }
+    return tabId;
+}
+export function moveTabToSpace(tabId, targetSpaceId) {
+    const curr = useTabsStore.getState().tabs;
+    const tab = curr.find((t) => t.id === tabId);
+    if (!tab || tab.spaceId === targetSpaceId)
+        return false;
+    useTabsStore
+        .getState()
+        .setTabs((prev) => prev.map((t) => t.id === tabId ? { ...t, spaceId: targetSpaceId } : t));
+    if (useTabsStore.getState().activeId !== tabId)
+        return false;
+    const fallback = nextActiveInSpace(curr, tabId);
+    if (fallback !== null) {
+        useTabsStore.getState().setActiveId(fallback);
+        return false;
+    }
+    return true;
+}
+export function copyTabToSpace(tabId, targetSpaceId) {
+    const curr = useTabsStore.getState().tabs;
+    const tab = curr.find((t) => t.id === tabId);
+    if (!tab)
+        return null;
+    const newTabId = useTabsStore.getState().allocId();
+    const newLeafId = useTabsStore.getState().allocId();
+    let cloned;
+    if (tab.kind === "terminal") {
+        cloned = {
+            ...tab,
+            id: newTabId,
+            spaceId: targetSpaceId,
+            cold: true,
+            paneTree: {
+                kind: "leaf",
+                id: newLeafId,
+                ...(tab.cwd && { cwd: tab.cwd }),
+            },
+            activeLeafId: newLeafId,
+        };
+    }
+    else {
+        cloned = {
+            ...tab,
+            id: newTabId,
+            spaceId: targetSpaceId,
+            cold: true,
+        };
+    }
+    useTabsStore.getState().setTabs((prev) => [...prev, cloned]);
+    return newTabId;
+}
+export function reorderTab(tabId, targetTabId, edge) {
+    if (tabId === targetTabId)
+        return false;
+    const curr = useTabsStore.getState().tabs;
+    const moved = curr.find((t) => t.id === tabId);
+    const target = curr.find((t) => t.id === targetTabId);
+    if (!moved || !target)
+        return false;
+    const crossSpace = moved.spaceId !== target.spaceId;
+    useTabsStore.getState().setTabs((prev) => {
+        const without = prev.filter((t) => t.id !== tabId);
+        let idx = without.findIndex((t) => t.id === targetTabId);
+        if (idx < 0)
+            return prev;
+        if (edge === "bottom")
+            idx += 1;
+        const next = crossSpace
+            ? { ...moved, spaceId: target.spaceId }
+            : moved;
+        without.splice(idx, 0, next);
+        return without;
+    });
+    if (!crossSpace || useTabsStore.getState().activeId !== tabId)
+        return false;
+    const fallback = nextActiveInSpace(curr, tabId);
+    if (fallback !== null) {
+        useTabsStore.getState().setActiveId(fallback);
+        return false;
+    }
+    return true;
+}
+export function removeTabsForSpace(spaceId) {
+    let toDispose = [];
+    useTabsStore.getState().setTabs((curr) => {
+        const next = curr.filter((t) => t.spaceId !== spaceId);
+        if (next.length === curr.length)
+            return curr;
+        toDispose = curr
+            .filter((t) => t.spaceId === spaceId && t.kind === "terminal")
+            .flatMap((t) => leafIds(t.paneTree));
+        const activeTab = curr.find((t) => t.id === useTabsStore.getState().activeId);
+        if (activeTab?.spaceId === spaceId) {
+            useTabsStore.getState().setActiveId(next.length > 0 ? next[0].id : -1);
+        }
+        return next;
+    });
+    for (const lid of toDispose)
+        layoutAdapter.disposeSession(lid);
+}
+export function newTab(cwd, command, title) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((t) => [
+        ...t,
+        {
+            id: tabId,
+            kind: "terminal",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title: title || "shell",
+            cwd,
+            paneTree: { kind: "leaf", id: leafId, cwd, command },
+            activeLeafId: leafId,
+        },
+    ]);
+    useTabsStore.getState().setActiveId(tabId);
+    return tabId;
+}
+export function newBlockTab(cwd) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((t) => [
+        ...t,
+        {
+            id: tabId,
+            kind: "terminal",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title: "blocks",
+            cwd,
+            paneTree: { kind: "leaf", id: leafId, cwd },
+            activeLeafId: leafId,
+            blocks: true,
+        },
+    ]);
+    useTabsStore.getState().setActiveId(tabId);
+    return tabId;
+}
+export function newAgentTab(cwd, title) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((t) => [
+        ...t,
+        {
+            id: tabId,
+            kind: "terminal",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title,
+            cwd,
+            paneTree: { kind: "leaf", id: leafId, cwd },
+            activeLeafId: leafId,
+        },
+    ]);
+    useTabsStore.getState().setActiveId(tabId);
+    return { tabId, leafId };
+}
+export function newPrivateTab(cwd) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((t) => [
+        ...t,
+        {
+            id: tabId,
+            kind: "terminal",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title: "private",
+            cwd,
+            paneTree: { kind: "leaf", id: leafId, cwd },
+            activeLeafId: leafId,
+            private: true,
+        },
+    ]);
+    useTabsStore.getState().setActiveId(tabId);
+    return tabId;
+}
+export function openFileTab(path, pin = true, gotoLine) {
+    let targetId = null;
+    useTabsStore.getState().setTabs((curr) => {
+        if (pin) {
+            // Persistent open: find any existing editor tab, pin it if needed.
+            const existing = curr.find((t) => t.kind === "editor" && t.path === path);
+            if (existing) {
+                targetId = existing.id;
+                let needsUpdate = false;
+                if (gotoLine !== undefined &&
+                    existing.gotoLine !== gotoLine) {
+                    needsUpdate = true;
+                }
+                if (existing.preview) {
+                    needsUpdate = true;
+                }
+                if (needsUpdate) {
+                    return curr.map((t) => t.id === existing.id
+                        ? {
+                            ...t,
+                            preview: false,
+                            ...(gotoLine !== undefined ? { gotoLine } : {}),
+                        }
+                        : t);
+                }
+                return curr;
+            }
+            const id = useTabsStore.getState().allocId();
+            targetId = id;
+            return [
+                ...curr,
+                {
+                    id,
+                    kind: "editor",
+                    spaceId: useTabsStore.getState().activeSpaceId,
+                    title: basename(path),
+                    path,
+                    dirty: false,
+                    preview: false,
+                },
+            ];
+        }
+        else {
+            // Preview open: persistent tab for this path takes priority.
+            const persistent = curr.find((t) => t.kind === "editor" && t.path === path && !t.preview);
+            if (persistent) {
+                targetId = persistent.id;
+                return curr;
+            }
+            // Reuse the slot if it already shows the same path.
+            const existingPreview = curr.find((t) => t.kind === "editor" && t.path === path && t.preview);
+            if (existingPreview) {
+                targetId = existingPreview.id;
+                return curr;
+            }
+            // Replace the current preview slot, or append a new one.
+            const previewIdx = curr.findIndex((t) => t.kind === "editor" && t.preview);
+            const id = useTabsStore.getState().allocId();
+            targetId = id;
+            const tab = {
+                id,
+                kind: "editor",
+                spaceId: useTabsStore.getState().activeSpaceId,
+                title: basename(path),
+                path,
+                dirty: false,
+                preview: true,
+            };
+            if (previewIdx === -1)
+                return [...curr, tab];
+            const next = [...curr];
+            next[previewIdx] = tab;
+            return next;
+        }
+    });
+    if (targetId !== null)
+        useTabsStore.getState().setActiveId(targetId);
+    return targetId;
+}
+export function openFileTabInSpace(spaceId, path, pin = false) {
+    let targetId = null;
+    useTabsStore.getState().setTabs((curr) => {
+        const existing = curr.find((t) => t.kind === "editor" && t.path === path && t.spaceId === spaceId);
+        if (existing) {
+            targetId = existing.id;
+            if (pin && existing.preview) {
+                return curr.map((t) => t.id === existing.id ? { ...t, preview: false } : t);
+            }
+            return curr;
+        }
+        const id = useTabsStore.getState().allocId();
+        targetId = id;
+        const tab = {
+            id,
+            kind: "editor",
+            spaceId,
+            title: basename(path) || "untitled",
+            path,
+            dirty: false,
+            preview: !pin,
+        };
+        return [...curr, tab];
+    });
+    if (targetId !== null)
+        useTabsStore.getState().setActiveId(targetId);
+    return targetId;
+}
+export function pinTab(id) {
+    useTabsStore
+        .getState()
+        .setTabs((curr) => curr.map((t) => t.id === id && t.kind === "editor" ? { ...t, preview: false } : t));
+}
+export function openAiDiffTab(input) {
+    let targetId = null;
+    useTabsStore.getState().setTabs((curr) => {
+        const existing = curr.find((t) => t.kind === "ai-diff" && t.approvalId === input.approvalId);
+        if (existing) {
+            targetId = existing.id;
+            return curr;
+        }
+        const id = useTabsStore.getState().allocId();
+        targetId = id;
+        const title = `${basename(input.path)} (AI diff)`;
+        return [
+            ...curr,
+            {
+                id,
+                kind: "ai-diff",
+                spaceId: useTabsStore.getState().activeSpaceId,
+                title,
+                path: input.path,
+                originalContent: input.originalContent,
+                proposedContent: input.proposedContent,
+                approvalId: input.approvalId,
+                status: "pending",
+                isNewFile: input.isNewFile,
+            },
+        ];
+    });
+    if (targetId !== null)
+        useTabsStore.getState().setActiveId(targetId);
+    return targetId;
+}
+export function setAiDiffStatus(approvalId, status) {
+    useTabsStore
+        .getState()
+        .setTabs((curr) => curr.map((t) => t.kind === "ai-diff" && t.approvalId === approvalId
+        ? { ...t, status }
+        : t));
+}
+export function closeAiDiffTab(approvalId) {
+    useTabsStore.getState().setTabs((curr) => {
+        const target = curr.find((t) => t.kind === "ai-diff" && t.approvalId === approvalId);
+        if (!target)
+            return curr;
+        const fallback = nextActiveInSpace(curr, target.id);
+        const next = curr.filter((t) => t.id !== target.id);
+        const newActiveId = fallback !== null ? fallback : -1;
+        useTabsStore
+            .getState()
+            .setActiveId((active) => (target.id === active ? newActiveId : active));
+        return next;
+    });
+}
+export function newPreviewTab(url) {
+    const id = useTabsStore.getState().allocId();
+    useTabsStore.getState().setTabs((t) => [
+        ...t,
+        {
+            id,
+            kind: "preview",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title: titleFromUrl(url),
+            url,
+        },
+    ]);
+    useTabsStore.getState().setActiveId(id);
+    return id;
+}
+export function newMarkdownTab(path) {
+    let targetId = null;
+    useTabsStore.getState().setTabs((curr) => {
+        const existing = curr.find((t) => t.kind === "markdown" && t.path === path);
+        if (existing) {
+            targetId = existing.id;
+            return curr;
+        }
+        const id = useTabsStore.getState().allocId();
+        targetId = id;
+        return [
+            ...curr,
+            {
+                id,
+                kind: "markdown",
+                spaceId: useTabsStore.getState().activeSpaceId,
+                title: basename(path),
+                path,
+            },
+        ];
+    });
+    if (targetId !== null)
+        useTabsStore.getState().setActiveId(targetId);
+    return targetId;
+}
+export function openGitDiffTab(input) {
+    const curr = useTabsStore.getState().tabs;
+    const existing = curr.find((t) => t.kind === "git-diff" &&
+        t.repoRoot === input.repoRoot &&
+        t.path === input.path &&
+        t.mode === input.mode);
+    const computedTitle = input.title ?? `${basename(input.path)} (${input.mode})`;
+    const originalPath = input.originalPath ?? null;
+    if (existing) {
+        const nextTabs = curr.map((t) => t.id === existing.id ? { ...t, title: computedTitle, originalPath } : t);
+        useTabsStore.getState().tabs = nextTabs;
+        useTabsStore.getState().setTabs(nextTabs);
+        useTabsStore.getState().setActiveId(existing.id);
+        return existing.id;
+    }
+    const id = useTabsStore.getState().allocId();
+    const nextTabs = [
+        ...curr,
+        {
+            id,
+            kind: "git-diff",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title: computedTitle,
+            path: input.path,
+            repoRoot: input.repoRoot,
+            mode: input.mode,
+            originalPath,
+        },
+    ];
+    useTabsStore.getState().tabs = nextTabs;
+    useTabsStore.getState().setTabs(nextTabs);
+    useTabsStore.getState().setActiveId(id);
+    return id;
+}
+export function openCommitHistoryTab(input) {
+    const curr = useTabsStore.getState().tabs;
+    const existing = curr.find((t) => t.kind === "git-history" && t.repoRoot === input.repoRoot);
+    const title = input.branch ? `History · ${input.branch}` : "Git History";
+    if (existing) {
+        const nextTabs = curr.map((t) => t.id === existing.id ? { ...t, title } : t);
+        useTabsStore.getState().tabs = nextTabs;
+        useTabsStore.getState().setTabs(nextTabs);
+        useTabsStore.getState().setActiveId(existing.id);
+        return existing.id;
+    }
+    const id = useTabsStore.getState().allocId();
+    const nextTabs = [
+        ...curr,
+        {
+            id,
+            kind: "git-history",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title,
+            repoRoot: input.repoRoot,
+        },
+    ];
+    useTabsStore.getState().tabs = nextTabs;
+    useTabsStore.getState().setTabs(nextTabs);
+    useTabsStore.getState().setActiveId(id);
+    return id;
+}
+export function openCommitFileDiffTab(input) {
+    const curr = useTabsStore.getState().tabs;
+    const existing = curr.find((t) => t.kind === "git-commit-file" &&
+        t.repoRoot === input.repoRoot &&
+        t.sha === input.sha &&
+        t.path === input.path);
+    const title = `${basename(input.path)} @ ${input.shortSha}`;
+    if (existing) {
+        const nextTabs = curr.map((t) => t.id === existing.id
+            ? {
+                ...t,
+                title,
+                subject: input.subject,
+                originalPath: input.originalPath,
+            }
+            : t);
+        useTabsStore.getState().tabs = nextTabs;
+        useTabsStore.getState().setTabs(nextTabs);
+        useTabsStore.getState().setActiveId(existing.id);
+        return existing.id;
+    }
+    const id = useTabsStore.getState().allocId();
+    const nextTabs = [
+        ...curr,
+        {
+            id,
+            kind: "git-commit-file",
+            spaceId: useTabsStore.getState().activeSpaceId,
+            title,
+            repoRoot: input.repoRoot,
+            sha: input.sha,
+            shortSha: input.shortSha,
+            subject: input.subject,
+            path: input.path,
+            originalPath: input.originalPath,
+        },
+    ];
+    useTabsStore.getState().tabs = nextTabs;
+    useTabsStore.getState().setTabs(nextTabs);
+    useTabsStore.getState().setActiveId(id);
+    return id;
+}
+export function closeTab(id) {
+    let toDispose = [];
+    useTabsStore.getState().setTabs((curr) => {
+        const target = curr.find((t) => t.id === id);
+        if (!target)
+            return curr;
+        if (target.kind === "terminal") {
+            toDispose = leafIds(target.paneTree);
+        }
+        const fallback = nextActiveInSpace(curr, id);
+        const next = curr.filter((t) => t.id !== id);
+        const newActiveId = fallback !== null ? fallback : -1;
+        useTabsStore
+            .getState()
+            .setActiveId((active) => (id === active ? newActiveId : active));
+        return next;
+    });
+    for (const lid of toDispose)
+        layoutAdapter.disposeSession(lid);
+}
+export function updateTab(id, patch) {
+    useTabsStore.getState().setTabs((t) => t.map((x) => {
+        if (x.id !== id)
+            return x;
+        if (x.kind === "terminal") {
+            return {
+                ...x,
+                ...(patch.title !== undefined && { title: patch.title }),
+                ...(patch.dynamicTitle !== undefined && {
+                    dynamicTitle: patch.dynamicTitle,
+                }),
+                ...(patch.alert !== undefined && { alert: patch.alert }),
+                ...(patch.interaction !== undefined && {
+                    interaction: patch.interaction,
+                }),
+                ...(patch.cwd !== undefined && { cwd: patch.cwd }),
+                ...(patch.customTitle !== undefined && {
+                    customTitle: patch.customTitle === "" ? undefined : patch.customTitle,
+                }),
+            };
+        }
+        if (x.kind === "preview") {
+            return {
+                ...x,
+                ...(patch.title !== undefined && { title: patch.title }),
+                ...(patch.url !== undefined && {
+                    url: patch.url,
+                    title: patch.title ?? titleFromUrl(patch.url),
+                }),
+            };
+        }
+        if (x.kind === "markdown") {
+            return {
+                ...x,
+                ...(patch.title !== undefined && { title: patch.title }),
+            };
+        }
+        // editor tab: auto-promote from preview the moment the file becomes dirty.
+        const autoPin = patch.dirty === true && x.preview
+            ? { preview: false }
+            : {};
+        return {
+            ...x,
+            ...autoPin,
+            ...(patch.title !== undefined && { title: patch.title }),
+            ...(patch.dirty !== undefined && { dirty: patch.dirty }),
+            ...(patch.path !== undefined && { path: patch.path }),
+        };
+    }));
+}
+export function selectByIndex(idx) {
+    const t = useTabsStore.getState().tabs[idx];
+    if (t)
+        useTabsStore.getState().setActiveId(t.id);
+}
+export function setLeafCwd(leafId, cwd) {
+    useTabsStore.getState().setTabs((curr) => {
+        let changed = false;
+        const next = curr.map((t) => {
+            if (t.kind !== "terminal" || !hasLeaf(t.paneTree, leafId))
+                return t;
+            const paneTree = setLeafCwdInTree(t.paneTree, leafId, cwd);
+            const isActive = t.activeLeafId === leafId;
+            const cwdChanged = isActive && t.cwd !== cwd;
+            if (paneTree === t.paneTree && !cwdChanged)
+                return t;
+            changed = true;
+            return {
+                ...t,
+                paneTree,
+                ...(cwdChanged && { cwd, title: cwd ? basename(cwd) : "shell" }),
+            };
+        });
+        return changed ? next : curr;
+    });
+}
+export function focusPane(tabId, leafId) {
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal")
+            return t;
+        if (!hasLeaf(t.paneTree, leafId))
+            return t;
+        if (t.activeLeafId === leafId)
+            return t;
+        const cwd = findLeafCwd(t.paneTree, leafId);
+        return {
+            ...t,
+            activeLeafId: leafId,
+            ...(cwd !== undefined && { cwd }),
+        };
+    }));
+}
+export function focusNextPaneInTab(tabId, delta) {
+    useTabsStore.getState().setTabs((curr) => curr.map((t) => {
+        if (t.id !== tabId || t.kind !== "terminal")
+            return t;
+        const next = nextLeafId(t.paneTree, t.activeLeafId, delta);
+        if (next === t.activeLeafId)
+            return t;
+        const cwd = findLeafCwd(t.paneTree, next);
+        return { ...t, activeLeafId: next, ...(cwd !== undefined && { cwd }) };
+    }));
+}
+export function resetWorkspace(cwd) {
+    const tabId = useTabsStore.getState().allocId();
+    const leafId = useTabsStore.getState().allocId();
+    let toDispose = [];
+    useTabsStore.getState().setTabs((curr) => {
+        toDispose = curr.flatMap((t) => t.kind === "terminal" ? leafIds(t.paneTree) : []);
+        return [
+            {
+                id: tabId,
+                kind: "terminal",
+                spaceId: useTabsStore.getState().activeSpaceId,
+                title: "shell",
+                cwd,
+                paneTree: { kind: "leaf", id: leafId, cwd },
+                activeLeafId: leafId,
+            },
+        ];
+    });
+    useTabsStore.getState().setActiveId(tabId);
+    for (const lid of toDispose)
+        layoutAdapter.disposeSession(lid);
+}
+export function extractPaneToTab(tabId, leafId) {
+    let newTabId = null;
+    useTabsStore.getState().setTabs((curr) => {
+        const tab = curr.find((t) => t.id === tabId && t.kind === "terminal");
+        if (!tab || tab.kind !== "terminal")
+            return curr;
+        if (!hasLeaf(tab.paneTree, leafId))
+            return curr;
+        const leaves = leafIds(tab.paneTree);
+        if (leaves.length <= 1)
+            return curr;
+        const newTree = removeLeaf(tab.paneTree, leafId);
+        if (!newTree)
+            return curr;
+        const remaining = leafIds(newTree);
+        const newActive = tab.activeLeafId === leafId ? remaining[0] : tab.activeLeafId;
+        newTabId = useTabsStore.getState().allocId();
+        const createdTab = {
+            kind: "terminal",
+            id: newTabId,
+            spaceId: tab.spaceId,
+            paneTree: { kind: "leaf", id: leafId },
+            activeLeafId: leafId,
+            cwd: tab.cwd,
+            title: tab.title,
+        };
+        return curr
+            .map((x) => (x.id === tabId ? { ...x, paneTree: newTree, activeLeafId: newActive } : x))
+            .concat(createdTab);
+    });
+    if (newTabId !== null) {
+        useTabsStore.getState().setActiveId(newTabId);
+        if (typeof window !== "undefined")
+            window.dispatchEvent(new Event("resize"));
+    }
+    return newTabId;
+}
+export function unsplitAllPanesToTabs(tabId) {
+    let createdTabIds = [];
+    useTabsStore.getState().setTabs((curr) => {
+        const tab = curr.find((t) => t.id === tabId && t.kind === "terminal");
+        if (!tab || tab.kind !== "terminal")
+            return curr;
+        const leaves = leafIds(tab.paneTree);
+        if (leaves.length <= 1)
+            return curr;
+        const firstLeaf = leaves[0];
+        const firstTab = {
+            ...tab,
+            paneTree: { kind: "leaf", id: firstLeaf },
+            activeLeafId: firstLeaf,
+        };
+        const extraTabs = leaves.slice(1).map((leafId) => {
+            const newId = useTabsStore.getState().allocId();
+            createdTabIds.push(newId);
+            return {
+                kind: "terminal",
+                id: newId,
+                spaceId: tab.spaceId,
+                paneTree: { kind: "leaf", id: leafId },
+                activeLeafId: leafId,
+                cwd: tab.cwd,
+                title: tab.title,
+            };
+        });
+        return curr.map((x) => (x.id === tabId ? firstTab : x)).concat(extraTabs);
+    });
+    if (typeof window !== "undefined")
+        window.dispatchEvent(new Event("resize"));
+    return createdTabIds;
+}
+export function closeOtherPanes(tabId, keepLeafId) {
+    const leavesToDispose = [];
+    useTabsStore.getState().setTabs((curr) => {
+        const tab = curr.find((t) => t.id === tabId && t.kind === "terminal");
+        if (!tab || tab.kind !== "terminal")
+            return curr;
+        const leaves = leafIds(tab.paneTree);
+        for (const l of leaves) {
+            if (l !== keepLeafId)
+                leavesToDispose.push(l);
+        }
+        return curr.map((x) => x.id === tabId
+            ? {
+                ...x,
+                paneTree: { kind: "leaf", id: keepLeafId },
+                activeLeafId: keepLeafId,
+            }
+            : x);
+    });
+    for (const l of leavesToDispose) {
+        layoutAdapter.disposeSession(l);
+    }
+    if (typeof window !== "undefined")
+        window.dispatchEvent(new Event("resize"));
+}
+//# sourceMappingURL=tabsActions.js.map