@konitif/workbench 0.284.1

package/dist/application/workspace/collapseSplitBoundary.js

@@ -0,0 +1,106 @@
+import { listPanels } from "../../domain/layout/selectors.js";
+import { createSplit } from "../../domain/workspace/factories.js";
+import { normalizeSplitSizes } from "../../domain/layout/validation.js";
+import { pruneUnusedToolInstances, updateCanonicalizedActiveWindowRoot } from "./finalizeWorkspace.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+export function collapseSplitBoundary(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.rootSplitId, (selected) => collapseSplitBoundaryInActiveWindow(selected, input));
+}
+function collapseSplitBoundaryInActiveWindow(workspace, input) {
+    let removedNode = null;
+    let didCollapse = false;
+    const nextWorkspace = updateCanonicalizedActiveWindowRoot(workspace, (root) => {
+        const nextRoot = collapseSplitBoundaryInNode(root, input, (node) => {
+            removedNode = node;
+            didCollapse = true;
+        });
+        return didCollapse ? nextRoot : root;
+    });
+    if (!didCollapse || !removedNode) {
+        return workspace;
+    }
+    const removedToolInstanceIds = new Set(listPanels(removedNode)
+        .map((panel) => panel.toolInstanceId)
+        .filter((toolInstanceId) => !!toolInstanceId));
+    if (removedToolInstanceIds.size === 0) {
+        return nextWorkspace;
+    }
+    return pruneUnusedToolInstances(nextWorkspace, removedToolInstanceIds);
+}
+function collapseSplitBoundaryInNode(node, input, onCollapse) {
+    if (node.kind !== 'split') {
+        return node;
+    }
+    if (node.id === input.rootSplitId) {
+        const segments = collectCanonicalSegments(node, node.orientation, 1);
+        const removeIndex = input.removeSide === 'start' ? input.boundaryIndex : input.boundaryIndex + 1;
+        if (removeIndex < 0 || removeIndex >= segments.length) {
+            return node;
+        }
+        const removedSegment = segments[removeIndex];
+        if (!removedSegment) {
+            return node;
+        }
+        onCollapse(removedSegment.node);
+        const remainingSegments = segments.filter((_, index) => index !== removeIndex);
+        return buildCanonicalSplitChain(node.orientation, remainingSegments, node.id);
+    }
+    return {
+        ...node,
+        children: [
+            collapseSplitBoundaryInNode(node.children[0], input, onCollapse),
+            collapseSplitBoundaryInNode(node.children[1], input, onCollapse)
+        ]
+    };
+}
+function collectCanonicalSegments(node, orientation, size) {
+    if (node.kind !== 'split' || node.orientation !== orientation) {
+        return [{ node, size }];
+    }
+    return [
+        ...collectCanonicalSegments(node.children[0], orientation, size * node.sizes[0]),
+        ...collectCanonicalSegments(node.children[1], orientation, size * node.sizes[1])
+    ];
+}
+function buildCanonicalSplitChain(orientation, segments, rootSplitId) {
+    if (segments.length === 1) {
+        return segments[0].node;
+    }
+    if (segments.length === 2) {
+        const nextSizes = normalizeSplitSizes([segments[0].size, segments[1].size]);
+        if (rootSplitId) {
+            return {
+                id: rootSplitId,
+                kind: 'split',
+                orientation,
+                children: [segments[0].node, segments[1].node],
+                sizes: nextSizes
+            };
+        }
+        return createSplit(orientation, [segments[0].node, segments[1].node], nextSizes);
+    }
+    const splitIndex = resolveBalancedSplitIndex(segments);
+    const leftSegments = segments.slice(0, splitIndex);
+    const rightSegments = segments.slice(splitIndex);
+    const leftTotal = leftSegments.reduce((sum, segment) => sum + segment.size, 0);
+    const rightTotal = rightSegments.reduce((sum, segment) => sum + segment.size, 0);
+    const nextSizes = normalizeSplitSizes([leftTotal, rightTotal]);
+    const leftNode = buildCanonicalSplitChain(orientation, leftSegments);
+    const rightNode = buildCanonicalSplitChain(orientation, rightSegments);
+    if (rootSplitId) {
+        return {
+            id: rootSplitId,
+            kind: 'split',
+            orientation,
+            children: [leftNode, rightNode],
+            sizes: nextSizes
+        };
+    }
+    return createSplit(orientation, [leftNode, rightNode], nextSizes);
+}
+function resolveBalancedSplitIndex(segments) {
+    if (segments.length <= 2) {
+        return 1;
+    }
+    return Math.max(1, Math.min(segments.length - 1, Math.floor(segments.length / 2)));
+}

package/dist/application/workspace/commands.d.ts

@@ -0,0 +1,71 @@
+import type { LayoutDockSide, LayoutEdge } from "../../domain/layout/interaction.js";
+import type { WorkbenchReadingLevel } from "../../domain/presentation/readingLevel.js";
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import { type WorkspaceSessionState } from "./session.js";
+export type WorkspaceCommand = {
+    type: 'open-tool';
+    toolId: string;
+} | {
+    type: 'open-tool-in-panel';
+    panelId: string;
+    toolId: string;
+} | {
+    type: 'open-tool-in-new-tab';
+    panelId: string;
+    toolId: string;
+} | {
+    type: 'split-panel-horizontal';
+} | {
+    type: 'split-panel-vertical';
+} | {
+    type: 'split-panel-to-side';
+    orientation: 'horizontal' | 'vertical';
+    side: LayoutDockSide;
+    panelId?: string;
+} | {
+    type: 'join-panel-area';
+    panelId: string;
+    edge: LayoutEdge;
+} | {
+    type: 'swap-panel-area';
+    panelId: string;
+    edge: LayoutEdge;
+} | {
+    type: 'close-active-panel';
+} | {
+    type: 'close-panel';
+    panelId: string;
+} | {
+    type: 'detach-panel-to-window';
+    panelId: string;
+} | {
+    type: 'focus-panel';
+    panelId: string;
+} | {
+    type: 'activate-tab';
+    stackId: string;
+    panelId: string;
+} | {
+    type: 'set-stack-header-visibility';
+    stackId: string;
+    visible: boolean;
+} | {
+    type: 'set-panel-fullscreen-toggle-visibility';
+    panelId: string;
+    visible: boolean;
+} | {
+    type: 'run-tool-shell-command';
+    panelId: string;
+    toolInstanceId: string;
+    commandId: string;
+    /** Current shell default used only to resolve an inherited Tool reading level. */
+    inheritedReadingLevel?: WorkbenchReadingLevel;
+};
+interface WorkspaceCommandContext {
+    toolCatalog: ToolCatalogPort;
+}
+/**
+ * Command handling owns focus transitions so Svelte components only emit user intent.
+ */
+export declare function dispatchWorkspaceCommand(state: WorkspaceSessionState, command: WorkspaceCommand, context: WorkspaceCommandContext): WorkspaceSessionState;
+export {};

package/dist/application/workspace/commands.js

@@ -0,0 +1,216 @@
+import { listPanelsInWorkspace, findPanelInWorkspace, findStackContainingPanelInWorkspace, findStackInWorkspace, findWindowContainingPanel, findToolPlacementByToolId, getPreferredFocusedPanelId } from "../../domain/workspace/selectors.js";
+import { closePanel } from "./closePanel.js";
+import { detachPanelToWindow } from "./detachPanelToWindow.js";
+import { joinPanelArea } from "./joinPanelArea.js";
+import { openTool } from "./openTool.js";
+import { runToolShellCommand } from "./runToolShellCommand.js";
+import { setPanelFullscreenToggleVisibility } from "./setPanelFullscreenToggleVisibility.js";
+import { setStackHeaderVisibility } from "./setStackHeaderVisibility.js";
+import { setActiveStackChild } from "./setActiveStackChild.js";
+import { focusPanel } from "./focusPanel.js";
+import { selectWorkspaceTargetWindow } from "./targetWindow.js";
+import { splitPanel } from "./splitPanel.js";
+import { swapPanelArea } from "./swapPanelArea.js";
+import { createPanel } from "../../domain/workspace/factories.js";
+import { updateActiveWindowRoot, updateStackById } from "./layoutTree.js";
+import { createWorkspaceSessionState, getFocusedPanel } from "./session.js";
+/**
+ * Command handling owns focus transitions so Svelte components only emit user intent.
+ */
+export function dispatchWorkspaceCommand(state, command, context) {
+    const targetId = command.type === 'set-stack-header-visibility' ? command.stackId :
+        command.type === 'set-panel-fullscreen-toggle-visibility' ||
+            command.type === 'close-panel' || command.type === 'join-panel-area' ||
+            command.type === 'swap-panel-area' ? command.panelId :
+            command.type === 'split-panel-to-side' ? command.panelId ?? state.focus.activePanelId :
+                command.type === 'split-panel-horizontal' || command.type === 'split-panel-vertical' ||
+                    command.type === 'close-active-panel' || command.type === 'open-tool' ? state.focus.activePanelId : null;
+    const normalizedState = createWorkspaceSessionState(selectWorkspaceTargetWindow(state.workspace, targetId), state.focus);
+    switch (command.type) {
+        case 'focus-panel':
+            return focusPanel(normalizedState, command.panelId);
+        case 'activate-tab':
+            return activateTab(normalizedState, command.stackId, command.panelId);
+        case 'set-stack-header-visibility':
+            return setStackHeaderVisibilityFromCommand(normalizedState, command.stackId, command.visible);
+        case 'set-panel-fullscreen-toggle-visibility':
+            return setPanelFullscreenToggleVisibilityFromCommand(normalizedState, command.panelId, command.visible);
+        case 'open-tool':
+            return openToolFromFocus(normalizedState, command.toolId, context.toolCatalog);
+        case 'open-tool-in-panel':
+            return openToolInPanel(normalizedState, command.panelId, command.toolId, context.toolCatalog);
+        case 'open-tool-in-new-tab':
+            return openToolInNewTab(normalizedState, command.panelId, command.toolId, context.toolCatalog);
+        case 'run-tool-shell-command':
+            return runFocusedToolShellCommand(normalizedState, command, context.toolCatalog);
+        case 'split-panel-horizontal':
+            return splitFocusedPanel(normalizedState, 'horizontal');
+        case 'split-panel-vertical':
+            return splitFocusedPanel(normalizedState, 'vertical');
+        case 'split-panel-to-side':
+            return splitPanelToSide(normalizedState, command.orientation, command.side, command.panelId ?? null);
+        case 'join-panel-area':
+            return joinPanelAreaFromCommand(normalizedState, command.panelId, command.edge);
+        case 'swap-panel-area':
+            return swapPanelAreaFromCommand(normalizedState, command.panelId, command.edge);
+        case 'close-active-panel':
+            return closeFocusedPanel(normalizedState);
+        case 'close-panel':
+            return closePanelById(normalizedState, command.panelId);
+        case 'detach-panel-to-window':
+            return detachPanelFromCommand(normalizedState, command.panelId);
+    }
+}
+function runFocusedToolShellCommand(state, command, toolCatalog) {
+    const nextWorkspace = runToolShellCommand(state.workspace, {
+        panelId: command.panelId,
+        toolInstanceId: command.toolInstanceId,
+        commandId: command.commandId,
+        inheritedReadingLevel: command.inheritedReadingLevel
+    }, toolCatalog);
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: command.panelId });
+}
+function activateTab(state, stackId, panelId) {
+    const stack = findStackInWorkspace(state.workspace, stackId);
+    if (!stack || !stack.children.some((panel) => panel.id === panelId)) {
+        return state;
+    }
+    // A tab belongs to its containing window, not necessarily the window last
+    // activated by a synchronized client. Reuse the canonical focus transition.
+    return focusPanel(state, panelId);
+}
+function setStackHeaderVisibilityFromCommand(state, stackId, visible) {
+    const stack = findStackInWorkspace(state.workspace, stackId);
+    if (!stack) {
+        return state;
+    }
+    const nextWorkspace = setStackHeaderVisibility(state.workspace, { stackId, visible });
+    return createWorkspaceSessionState(nextWorkspace, state.focus);
+}
+function setPanelFullscreenToggleVisibilityFromCommand(state, panelId, visible) {
+    const panel = findPanelInWorkspace(state.workspace, panelId);
+    if (!panel) {
+        return state;
+    }
+    const nextWorkspace = setPanelFullscreenToggleVisibility(state.workspace, { panelId, visible });
+    return createWorkspaceSessionState(nextWorkspace, state.focus);
+}
+function openToolFromFocus(state, toolId, toolCatalog) {
+    const focusedPanel = getFocusedPanel(state);
+    if (!focusedPanel) {
+        return state;
+    }
+    const focusedWorkspace = ensurePanelVisible(state.workspace, focusedPanel.id);
+    const openToolResult = openTool(focusedWorkspace, { panelId: focusedPanel.id, toolId }, toolCatalog);
+    return createWorkspaceSessionState(openToolResult.workspace, {
+        activePanelId: openToolResult.panelId ?? focusedPanel.id
+    });
+}
+function openToolInPanel(state, panelId, toolId, toolCatalog) {
+    const targetPanel = findPanelInWorkspace(state.workspace, panelId);
+    if (!targetPanel) {
+        return state;
+    }
+    const visibleState = focusPanel(state, panelId);
+    const visibleWorkspace = ensurePanelVisible(visibleState.workspace, panelId);
+    const openToolResult = openTool(visibleWorkspace, { panelId, toolId, singletonPlacement: 'move-to-panel' }, toolCatalog);
+    return createWorkspaceSessionState(openToolResult.workspace, {
+        activePanelId: openToolResult.panelId ?? panelId
+    });
+}
+function openToolInNewTab(state, panelId, toolId, toolCatalog) {
+    const targetPanel = findPanelInWorkspace(state.workspace, panelId);
+    const toolDefinition = toolCatalog.getDefinition(toolId);
+    if (!targetPanel || !toolDefinition) {
+        return state;
+    }
+    const existingPlacement = findToolPlacementByToolId(state.workspace, toolId);
+    if (toolDefinition.openingPolicy.mode === 'singleton-global' && existingPlacement &&
+        findWindowContainingPanel(state.workspace, existingPlacement.panelId)?.id ===
+            findWindowContainingPanel(state.workspace, panelId)?.id) {
+        return focusPanel(state, existingPlacement.panelId);
+    }
+    const visibleState = focusPanel(state, panelId);
+    const containingStack = findStackContainingPanelInWorkspace(visibleState.workspace, panelId);
+    if (!containingStack) {
+        return state;
+    }
+    const panel = createPanel('New panel');
+    const nextWorkspace = updateActiveWindowRoot(visibleState.workspace, (root) => updateStackById(root, containingStack.id, (stack) => ({
+        ...stack,
+        activeChildId: panel.id,
+        children: [...stack.children, panel]
+    })));
+    // Explicit addition targets this window. Reuse a remote singleton rather
+    // than focusing a logical window whose browser tab may no longer exist.
+    const openToolResult = openTool(nextWorkspace, { panelId: panel.id, toolId, singletonPlacement: 'move-to-panel' }, toolCatalog);
+    return createWorkspaceSessionState(openToolResult.workspace, {
+        activePanelId: openToolResult.panelId ?? panel.id
+    });
+}
+function splitFocusedPanel(state, orientation) {
+    return splitPanelToSide(state, orientation, orientation === 'horizontal' ? 'right' : 'bottom');
+}
+function splitPanelToSide(state, orientation, side, panelId = null) {
+    const focusedPanel = getFocusedPanel(state);
+    const targetPanelId = panelId ?? focusedPanel?.id ?? null;
+    if (!targetPanelId) {
+        return state;
+    }
+    const baseWorkspace = ensurePanelVisible(state.workspace, targetPanelId);
+    const previousPanelIds = new Set(listPanelsInWorkspace(baseWorkspace).map((panel) => panel.id));
+    const nextWorkspace = splitPanel(baseWorkspace, { panelId: targetPanelId, orientation, side });
+    const newPanel = listPanelsInWorkspace(nextWorkspace).find((panel) => !previousPanelIds.has(panel.id));
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: newPanel?.id ?? targetPanelId });
+}
+function closeFocusedPanel(state) {
+    const focusedPanel = getFocusedPanel(state);
+    if (!focusedPanel) {
+        return state;
+    }
+    return closePanelById(state, focusedPanel.id);
+}
+function closePanelById(state, panelId) {
+    const sourceStack = findStackContainingPanelInWorkspace(state.workspace, panelId);
+    if (!sourceStack) {
+        return state;
+    }
+    const nextWorkspace = closePanel(state.workspace, { panelId });
+    const survivingStack = findStackInWorkspace(nextWorkspace, sourceStack.id);
+    const nextFocusedPanelId = state.focus.activePanelId === panelId
+        ? (survivingStack?.activeChildId ?? getPreferredFocusedPanelId(nextWorkspace))
+        : state.focus.activePanelId;
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null });
+}
+function detachPanelFromCommand(state, panelId) {
+    const result = detachPanelToWindow(state.workspace, { panelId });
+    if (!result) {
+        return state;
+    }
+    const nextFocusedPanelId = state.focus.activePanelId === panelId
+        ? getPreferredFocusedPanelId(result.workspace)
+        : state.focus.activePanelId;
+    return createWorkspaceSessionState(result.workspace, { activePanelId: nextFocusedPanelId ?? null });
+}
+function joinPanelAreaFromCommand(state, panelId, edge) {
+    const side = edge;
+    const nextWorkspace = joinPanelArea(state.workspace, { panelId, edge, side });
+    const nextFocusedPanelId = findPanelInWorkspace(nextWorkspace, panelId)?.id ??
+        getPreferredFocusedPanelId(nextWorkspace) ??
+        state.focus.activePanelId;
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null });
+}
+function swapPanelAreaFromCommand(state, panelId, edge) {
+    const nextWorkspace = swapPanelArea(state.workspace, { panelId, edge });
+    const nextFocusedPanelId = findPanelInWorkspace(nextWorkspace, panelId)?.id ??
+        getPreferredFocusedPanelId(nextWorkspace) ??
+        state.focus.activePanelId;
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null });
+}
+function ensurePanelVisible(workspace, panelId) {
+    const containingStack = findStackContainingPanelInWorkspace(workspace, panelId);
+    if (!containingStack || containingStack.activeChildId === panelId) {
+        return workspace;
+    }
+    return setActiveStackChild(workspace, { stackId: containingStack.id, panelId });
+}

package/dist/application/workspace/createPeripheralBands.d.ts

@@ -0,0 +1,14 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface CreatePeripheralBandsInput {
+    windowId?: string;
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+export interface CreatePeripheralBandsResult {
+    workspace: Workspace;
+    createdPanelIds: string[];
+}
+export declare function createPeripheralBands(workspace: Workspace, input: CreatePeripheralBandsInput): CreatePeripheralBandsResult;
+export {};

package/dist/application/workspace/createPeripheralBands.js

@@ -0,0 +1,62 @@
+import { createPanel, createSplit, createStack } from "../../domain/workspace/factories.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { updateActiveWindowRoot } from "./layoutTree.js";
+const MIN_BAND_RATIO = 0.14;
+const MAX_BAND_RATIO = 0.42;
+function clampBandRatio(value) {
+    return Math.max(MIN_BAND_RATIO, Math.min(MAX_BAND_RATIO, Number(value.toFixed(4))));
+}
+export function createPeripheralBands(workspace, input) {
+    const createdPanelIds = [];
+    const orderedBands = resolveOrderedBands(input);
+    const targetWindowId = input.windowId ?? workspace.activeWindowId;
+    if (orderedBands.length === 0 || !workspace.windows.some((window) => window.id === targetWindowId)) {
+        return {
+            workspace,
+            createdPanelIds
+        };
+    }
+    const targetWorkspace = targetWindowId === workspace.activeWindowId
+        ? workspace : { ...workspace, activeWindowId: targetWindowId };
+    const nextWorkspace = updateActiveWindowRoot(targetWorkspace, (root) => {
+        let nextRoot = root;
+        for (const band of orderedBands) {
+            const panel = createPanel('New panel');
+            createdPanelIds.push(panel.id);
+            nextRoot = wrapRootWithPeripheralBand(nextRoot, band.edge, band.ratio, createStack([panel]));
+        }
+        return canonicalizeLayout(nextRoot);
+    });
+    return {
+        workspace: nextWorkspace,
+        createdPanelIds
+    };
+}
+function resolveOrderedBands(input) {
+    const bands = [];
+    if (typeof input.left === 'number') {
+        bands.push({ edge: 'left', ratio: clampBandRatio(input.left) });
+    }
+    if (typeof input.right === 'number') {
+        bands.push({ edge: 'right', ratio: clampBandRatio(input.right) });
+    }
+    if (typeof input.top === 'number') {
+        bands.push({ edge: 'top', ratio: clampBandRatio(input.top) });
+    }
+    if (typeof input.bottom === 'number') {
+        bands.push({ edge: 'bottom', ratio: clampBandRatio(input.bottom) });
+    }
+    // Columns first, then rows, so corner pulls yield a top/bottom band spanning
+    // the full width while left/right bands occupy the remaining height.
+    return bands.sort((leftBand, rightBand) => getBandPriority(leftBand.edge) - getBandPriority(rightBand.edge));
+}
+function getBandPriority(edge) {
+    return edge === 'left' || edge === 'right' ? 0 : 1;
+}
+function wrapRootWithPeripheralBand(root, edge, ratio, bandStack) {
+    const orientation = edge === 'left' || edge === 'right' ? 'horizontal' : 'vertical';
+    if (edge === 'left' || edge === 'top') {
+        return createSplit(orientation, [bandStack, root], [ratio, 1 - ratio]);
+    }
+    return createSplit(orientation, [root, bandStack], [1 - ratio, ratio]);
+}

package/dist/application/workspace/createWorkspace.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface CreateWorkspaceOptions {
+    initialToolId?: string;
+}
+export declare function createWorkspace(toolCatalog?: ToolCatalogPort, options?: CreateWorkspaceOptions): Workspace;
+export {};

package/dist/application/workspace/createWorkspace.js

@@ -0,0 +1,12 @@
+import { createPanel, createStack, createWorkspaceShell, createWorkspaceWindow } from "../../domain/workspace/factories.js";
+import { openTool } from "./openTool.js";
+export function createWorkspace(toolCatalog, options = {}) {
+    const initialPanel = createPanel('Welcome');
+    const initialStack = createStack([initialPanel]);
+    const initialWindow = createWorkspaceWindow(initialStack);
+    const workspace = createWorkspaceShell(initialWindow);
+    if (!options.initialToolId || !toolCatalog) {
+        return workspace;
+    }
+    return openTool(workspace, { panelId: initialPanel.id, toolId: options.initialToolId }, toolCatalog).workspace;
+}

package/dist/application/workspace/detachPanelToWindow.d.ts

@@ -0,0 +1,12 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+export interface DetachPanelToWindowInput {
+    panelId: string;
+}
+export interface DetachPanelToWindowResult {
+    workspace: Workspace;
+    panelId: string;
+    sourceWindowId: string;
+    sourceStackId: string;
+    windowId: string;
+}
+export declare function detachPanelToWindow(workspace: Workspace, input: DetachPanelToWindowInput): DetachPanelToWindowResult | null;

package/dist/application/workspace/detachPanelToWindow.js

@@ -0,0 +1,57 @@
+import { createStack, createWorkspaceWindow } from "../../domain/workspace/factories.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { findPanelPathById, replaceNodeAtPathAllowingRemoval } from "./layoutTree.js";
+export function detachPanelToWindow(workspace, input) {
+    for (const sourceWindow of workspace.windows) {
+        const panelPath = findPanelPathById(sourceWindow.root, input.panelId);
+        if (!panelPath) {
+            continue;
+        }
+        const nextSourceRoot = replaceNodeAtPathAllowingRemoval(sourceWindow.root, panelPath.trail, removePanelFromStack(panelPath.stack, input.panelId)) ?? createStack();
+        const detachedWindow = createWorkspaceWindow(createStack([panelPath.panel]), panelPath.panel.title);
+        const nextWorkspace = {
+            ...workspace,
+            activeWindowId: sourceWindow.id,
+            fullscreenPanelId: workspace.fullscreenPanelId === input.panelId ? null : workspace.fullscreenPanelId ?? null,
+            windows: [
+                ...workspace.windows.map((window) => window.id === sourceWindow.id
+                    ? {
+                        ...window,
+                        root: canonicalizeLayout(nextSourceRoot)
+                    }
+                    : window),
+                detachedWindow
+            ]
+        };
+        return {
+            workspace: nextWorkspace,
+            panelId: panelPath.panel.id,
+            sourceWindowId: sourceWindow.id,
+            sourceStackId: panelPath.stack.id,
+            windowId: detachedWindow.id
+        };
+    }
+    return null;
+}
+function removePanelFromStack(stack, panelId) {
+    const removedPanelIndex = stack.children.findIndex((panel) => panel.id === panelId);
+    if (removedPanelIndex === -1) {
+        return stack;
+    }
+    const nextChildren = stack.children.filter((panel) => panel.id !== panelId);
+    if (nextChildren.length === 0) {
+        return null;
+    }
+    const normalizedChildren = nextChildren;
+    return {
+        ...stack,
+        children: normalizedChildren,
+        activeChildId: selectActivePanelAfterDetach(stack, panelId, removedPanelIndex, normalizedChildren)
+    };
+}
+function selectActivePanelAfterDetach(stack, panelId, removedPanelIndex, nextChildren) {
+    if (stack.activeChildId !== panelId) {
+        return stack.activeChildId;
+    }
+    return stack.children[removedPanelIndex - 1]?.id ?? nextChildren[0].id;
+}

package/dist/application/workspace/dockPanel.d.ts

@@ -0,0 +1,10 @@
+import type { LayoutDockPlacement, LayoutDockSide, LayoutDockTarget } from "../../domain/layout/interaction.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export interface DockPanelInput {
+    panelId: string;
+    target: LayoutDockTarget;
+}
+export declare function dockPanel(workspace: Workspace, input: DockPanelInput): Workspace;
+export declare function createStackDockTarget(stackId: string, placement: LayoutDockPlacement, tabIndex?: number | null): LayoutDockTarget;
+export declare function createWorkspaceEdgeDockTarget(side: LayoutDockSide): LayoutDockTarget;
+export declare function isEdgeDockPlacement(placement: LayoutDockPlacement): placement is LayoutDockSide;