@konitif/workbench 0.284.1

package/dist/application/workspace/resizeSplitBoundary.js

@@ -0,0 +1,115 @@
+import { LAYOUT_MIN_SPLIT_SIZE, normalizeSplitSizes } from "../../domain/layout/validation.js";
+import { updateActiveWindowRoot } from "./layoutTree.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+const MIN_CHAIN_SEGMENT_SIZE = LAYOUT_MIN_SPLIT_SIZE;
+export function resizeSplitBoundary(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.rootSplitId, (selected) => resizeSplitBoundaryInActiveWindow(selected, input));
+}
+function resizeSplitBoundaryInActiveWindow(workspace, input) {
+    if (!Number.isFinite(input.deltaRatio) || Math.abs(input.deltaRatio) < Number.EPSILON) {
+        return workspace;
+    }
+    return updateActiveWindowRoot(workspace, (root) => resizeSplitBoundaryInNode(root, input.rootSplitId, input.boundaryIndex, input.deltaRatio, input.mode ?? 'local'));
+}
+function resizeSplitBoundaryInNode(node, rootSplitId, boundaryIndex, deltaRatio, mode) {
+    if (node.kind !== 'split') {
+        return node;
+    }
+    if (node.id === rootSplitId) {
+        const chain = flattenSameOrientationChain(node, node.orientation, 1);
+        if (boundaryIndex < 0 || boundaryIndex >= chain.sizes.length - 1) {
+            return node;
+        }
+        const nextSizes = mode === 'proportional'
+            ? resizeBoundaryProportionally(chain.sizes, boundaryIndex, deltaRatio)
+            : resizeBoundaryLocally(chain.sizes, boundaryIndex, deltaRatio);
+        if (!nextSizes) {
+            return node;
+        }
+        const [nextNode] = applyFlattenedChainSizes(node, node.orientation, nextSizes, 0);
+        return nextNode;
+    }
+    return {
+        ...node,
+        children: [
+            resizeSplitBoundaryInNode(node.children[0], rootSplitId, boundaryIndex, deltaRatio, mode),
+            resizeSplitBoundaryInNode(node.children[1], rootSplitId, boundaryIndex, deltaRatio, mode)
+        ]
+    };
+}
+function flattenSameOrientationChain(node, orientation, size) {
+    if (node.kind !== 'split' || node.orientation !== orientation) {
+        return {
+            orientation,
+            sizes: [size]
+        };
+    }
+    const left = flattenSameOrientationChain(node.children[0], orientation, size * node.sizes[0]);
+    const right = flattenSameOrientationChain(node.children[1], orientation, size * node.sizes[1]);
+    return {
+        orientation,
+        sizes: [...left.sizes, ...right.sizes]
+    };
+}
+function applyFlattenedChainSizes(node, orientation, sizes, offset) {
+    if (node.kind !== 'split' || node.orientation !== orientation) {
+        return [node, offset + 1, sizes[offset] ?? 0];
+    }
+    const [leftChild, leftOffset, leftSize] = applyFlattenedChainSizes(node.children[0], orientation, sizes, offset);
+    const [rightChild, rightOffset, rightSize] = applyFlattenedChainSizes(node.children[1], orientation, sizes, leftOffset);
+    return [
+        {
+            ...node,
+            children: [leftChild, rightChild],
+            sizes: normalizeSplitSizes([leftSize, rightSize])
+        },
+        rightOffset,
+        leftSize + rightSize
+    ];
+}
+function resizeBoundaryLocally(sizes, boundaryIndex, deltaRatio) {
+    const nextSizes = [...sizes];
+    const leftIndex = boundaryIndex;
+    const rightIndex = boundaryIndex + 1;
+    const clampedDelta = clamp(deltaRatio, -(nextSizes[leftIndex] - MIN_CHAIN_SEGMENT_SIZE), nextSizes[rightIndex] - MIN_CHAIN_SEGMENT_SIZE);
+    if (!Number.isFinite(clampedDelta) || Math.abs(clampedDelta) < Number.EPSILON) {
+        return null;
+    }
+    nextSizes[leftIndex] += clampedDelta;
+    nextSizes[rightIndex] -= clampedDelta;
+    return nextSizes;
+}
+function resizeBoundaryProportionally(sizes, boundaryIndex, deltaRatio) {
+    const leftSizes = sizes.slice(0, boundaryIndex + 1);
+    const rightSizes = sizes.slice(boundaryIndex + 1);
+    const leftTotal = sum(leftSizes);
+    const minLeftTotal = leftSizes.length * MIN_CHAIN_SEGMENT_SIZE;
+    const minRightTotal = rightSizes.length * MIN_CHAIN_SEGMENT_SIZE;
+    const nextLeftTotal = clamp(deltaRatio + leftTotal, minLeftTotal, 1 - minRightTotal);
+    const nextRightTotal = 1 - nextLeftTotal;
+    if (!Number.isFinite(nextLeftTotal) ||
+        !Number.isFinite(nextRightTotal) ||
+        Math.abs(nextLeftTotal - leftTotal) < Number.EPSILON) {
+        return null;
+    }
+    return [
+        ...scaleSegmentGroup(leftSizes, nextLeftTotal),
+        ...scaleSegmentGroup(rightSizes, nextRightTotal)
+    ];
+}
+function scaleSegmentGroup(sizes, nextTotal) {
+    const currentTotal = sum(sizes);
+    if (currentTotal <= 0) {
+        return sizes.map(() => nextTotal / Math.max(sizes.length, 1));
+    }
+    const scaled = sizes.map((size) => size / currentTotal * nextTotal);
+    const clamped = scaled.map((size) => Math.max(MIN_CHAIN_SEGMENT_SIZE, size));
+    const clampedTotal = sum(clamped);
+    return clamped.map((size) => size / clampedTotal * nextTotal);
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

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

@@ -0,0 +1,11 @@
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import { type WorkbenchReadingLevel } from "../../domain/presentation/readingLevel.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface RunToolShellCommandInput {
+    panelId: string;
+    toolInstanceId: string;
+    commandId: string;
+    inheritedReadingLevel?: WorkbenchReadingLevel;
+}
+export declare function runToolShellCommand(workspace: Workspace, input: RunToolShellCommandInput, toolCatalog: ToolCatalogPort): Workspace;
+export {};

package/dist/application/workspace/runToolShellCommand.js

@@ -0,0 +1,133 @@
+import { cloneJsonObject, isJsonObject } from "../../domain/shared/json.js";
+import { CYCLE_TOOL_READING_LEVEL_COMMAND_ID, INHERIT_TOOL_READING_LEVEL_COMMAND_ID, normalizePanelTitleOverride, normalizeToolShellStatus, resolvePanelTitle, resolveToolReadingLevel, SET_TOOL_READING_LEVEL_ADVANCED_COMMAND_ID, SET_TOOL_READING_LEVEL_CASUAL_COMMAND_ID, SET_TOOL_READING_LEVEL_EXPERT_COMMAND_ID } from "../../domain/tool/shell.js";
+import { normalizeWorkbenchReadingLevels } from "../../domain/presentation/readingLevel.js";
+import { findPanelInWorkspace } from "../../domain/workspace/selectors.js";
+import { updatePanelById } from "./layoutTree.js";
+export function runToolShellCommand(workspace, input, toolCatalog) {
+    const panel = findPanelInWorkspace(workspace, input.panelId);
+    const toolInstance = workspace.toolInstances[input.toolInstanceId];
+    if (!panel || panel.toolInstanceId !== input.toolInstanceId || !toolInstance) {
+        return workspace;
+    }
+    const toolDefinition = toolCatalog.getDefinition(toolInstance.toolId);
+    if (toolDefinition) {
+        const nextReadingLevel = resolveReadingLevelCommand(toolDefinition, toolInstance, input.commandId, input.inheritedReadingLevel);
+        if (nextReadingLevel) {
+            const inheritedShellState = { ...(toolInstance.shellState ?? {
+                    status: null
+                }) };
+            delete inheritedShellState.readingLevel;
+            return {
+                ...workspace,
+                toolInstances: {
+                    ...workspace.toolInstances,
+                    [input.toolInstanceId]: {
+                        ...toolInstance,
+                        shellState: {
+                            ...inheritedShellState,
+                            status: toolInstance.shellState?.status ?? null,
+                            ...(nextReadingLevel === 'inherit' ? {} : { readingLevel: nextReadingLevel })
+                        }
+                    }
+                }
+            };
+        }
+    }
+    const shell = toolDefinition?.shell;
+    const command = shell?.commands?.find((entry) => entry.id === input.commandId);
+    if (!toolDefinition || !shell || !command || !shell.executeCommand) {
+        return workspace;
+    }
+    const result = shell.executeCommand({
+        commandId: input.commandId,
+        definition: toolDefinition,
+        instance: toolInstance
+    });
+    if (!result) {
+        return workspace;
+    }
+    if ('nextState' in result && result.nextState !== undefined && !isJsonObject(result.nextState)) {
+        return workspace;
+    }
+    let nextToolInstance = toolInstance;
+    let shouldUpdateToolInstance = false;
+    let shouldUpdatePanelTitle = false;
+    if ('nextState' in result && result.nextState !== undefined) {
+        nextToolInstance = {
+            ...nextToolInstance,
+            state: cloneJsonObject(result.nextState)
+        };
+        shouldUpdateToolInstance = true;
+    }
+    if ('nextStatus' in result) {
+        const nextStatus = normalizeToolShellStatus(result.nextStatus);
+        if (result.nextStatus !== null && nextStatus === null) {
+            return workspace;
+        }
+        nextToolInstance = {
+            ...nextToolInstance,
+            shellState: {
+                ...nextToolInstance.shellState,
+                status: nextStatus
+            }
+        };
+        shouldUpdateToolInstance = true;
+    }
+    if ('nextPanelTitleOverride' in result) {
+        nextToolInstance = {
+            ...nextToolInstance,
+            panelTitleOverride: normalizePanelTitleOverride(result.nextPanelTitleOverride ?? null)
+        };
+        shouldUpdateToolInstance = true;
+        shouldUpdatePanelTitle = true;
+    }
+    if (!shouldUpdateToolInstance) {
+        return workspace;
+    }
+    const nextWorkspace = {
+        ...workspace,
+        toolInstances: {
+            ...workspace.toolInstances,
+            [input.toolInstanceId]: nextToolInstance
+        }
+    };
+    if (!shouldUpdatePanelTitle) {
+        return nextWorkspace;
+    }
+    return {
+        ...nextWorkspace,
+        windows: nextWorkspace.windows.map((window) => ({
+            ...window,
+            root: updatePanelById(window.root, input.panelId, (currentPanel) => ({
+                ...currentPanel,
+                title: resolvePanelTitle(toolDefinition, nextToolInstance)
+            }))
+        }))
+    };
+}
+function resolveReadingLevelCommand(definition, instance, commandId, inheritedReadingLevel) {
+    const presentation = definition.panelPresentation?.readingLevel;
+    if (!presentation)
+        return null;
+    const availableLevels = normalizeWorkbenchReadingLevels(presentation);
+    if (availableLevels.length <= 1)
+        return null;
+    if (commandId === INHERIT_TOOL_READING_LEVEL_COMMAND_ID) {
+        return 'inherit';
+    }
+    const requestedLevelByCommand = {
+        [SET_TOOL_READING_LEVEL_CASUAL_COMMAND_ID]: 'casual',
+        [SET_TOOL_READING_LEVEL_ADVANCED_COMMAND_ID]: 'advanced',
+        [SET_TOOL_READING_LEVEL_EXPERT_COMMAND_ID]: 'expert'
+    };
+    const requestedLevel = requestedLevelByCommand[commandId];
+    if (requestedLevel) {
+        return availableLevels.includes(requestedLevel) ? requestedLevel : null;
+    }
+    if (commandId !== CYCLE_TOOL_READING_LEVEL_COMMAND_ID && commandId !== 'workbench.tool.reading-level') {
+        return null;
+    }
+    const currentLevel = resolveToolReadingLevel(definition, instance, inheritedReadingLevel);
+    const currentIndex = Math.max(0, availableLevels.indexOf(currentLevel));
+    return availableLevels[(currentIndex + 1) % availableLevels.length] ?? presentation.defaultLevel;
+}

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

@@ -0,0 +1,9 @@
+import type { PanelNode } from "../../domain/panel/model.js";
+import type { ToolInstance } from "../../domain/tool/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+import type { WorkspaceFocus, WorkspaceSessionState } from "../../domain/workspace/session.js";
+export type { WorkspaceFocus, WorkspaceSessionState } from "../../domain/workspace/session.js";
+export declare function createWorkspaceSessionState(workspace: Workspace, focus?: Partial<WorkspaceFocus>): WorkspaceSessionState;
+export declare function normalizeWorkspaceFocus(workspace: Workspace, focus?: Partial<WorkspaceFocus>): WorkspaceFocus;
+export declare function getFocusedPanel(state: WorkspaceSessionState): PanelNode | undefined;
+export declare function getFocusedToolInstance(state: WorkspaceSessionState): ToolInstance | undefined;

package/dist/application/workspace/session.js

@@ -0,0 +1,36 @@
+import { getPreferredFocusedPanelId, findPanelInWorkspace } from "../../domain/workspace/selectors.js";
+export function createWorkspaceSessionState(workspace, focus = {}) {
+    return {
+        workspace,
+        focus: normalizeWorkspaceFocus(workspace, focus)
+    };
+}
+export function normalizeWorkspaceFocus(workspace, focus = {}) {
+    const requestedPanelId = focus.activePanelId ?? getPreferredFullscreenPanelId(workspace) ?? getPreferredFocusedPanelId(workspace);
+    const requestedPanel = requestedPanelId ? findPanelInWorkspace(workspace, requestedPanelId) : undefined;
+    const panel = requestedPanel ?? getFallbackFocusedPanel(workspace);
+    return {
+        activePanelId: panel?.id ?? null,
+        activeToolInstanceId: panel?.toolInstanceId ?? null
+    };
+}
+export function getFocusedPanel(state) {
+    return state.focus.activePanelId ? findPanelInWorkspace(state.workspace, state.focus.activePanelId) : undefined;
+}
+export function getFocusedToolInstance(state) {
+    if (!state.focus.activeToolInstanceId) {
+        return undefined;
+    }
+    return state.workspace.toolInstances[state.focus.activeToolInstanceId];
+}
+function getFallbackFocusedPanel(workspace) {
+    const fallbackPanelId = getPreferredFullscreenPanelId(workspace) ?? getPreferredFocusedPanelId(workspace);
+    return fallbackPanelId ? findPanelInWorkspace(workspace, fallbackPanelId) : undefined;
+}
+function getPreferredFullscreenPanelId(workspace) {
+    const fullscreenPanelId = workspace.fullscreenPanelId ?? null;
+    if (!fullscreenPanelId) {
+        return null;
+    }
+    return findPanelInWorkspace(workspace, fullscreenPanelId)?.id ?? null;
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SetActiveStackChildInput {
+    stackId: string;
+    panelId: string;
+}
+export declare function setActiveStackChild(workspace: Workspace, input: SetActiveStackChildInput): Workspace;
+export {};

package/dist/application/workspace/setActiveStackChild.js

@@ -0,0 +1,12 @@
+import { updateActiveWindowRoot, updateStackById } from "./layoutTree.js";
+export function setActiveStackChild(workspace, input) {
+    return updateActiveWindowRoot(workspace, (root) => updateStackById(root, input.stackId, (stack) => {
+        if (!stack.children.some((panel) => panel.id === input.panelId)) {
+            return stack;
+        }
+        return {
+            ...stack,
+            activeChildId: input.panelId
+        };
+    }));
+}

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

@@ -0,0 +1,3 @@
+import type { DesignSystemThemeSession } from "../../domain/design-system/themeSession.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export declare function setDesignSystemThemeSession(workspace: Workspace, nextSession: DesignSystemThemeSession | null): Workspace;

package/dist/application/workspace/setDesignSystemThemeSession.js

@@ -0,0 +1,12 @@
+import { normalizeDesignSystemThemeSession } from "../../domain/design-system/themeSession.js";
+export function setDesignSystemThemeSession(workspace, nextSession) {
+    const normalizedSession = nextSession ? normalizeDesignSystemThemeSession(nextSession) : null;
+    const currentSession = workspace.designSystemThemeSession ?? null;
+    if (JSON.stringify(currentSession) === JSON.stringify(normalizedSession)) {
+        return workspace;
+    }
+    return {
+        ...workspace,
+        designSystemThemeSession: normalizedSession
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SetPanelFullscreenToggleVisibilityInput {
+    panelId: string;
+    visible: boolean;
+}
+export declare function setPanelFullscreenToggleVisibility(workspace: Workspace, input: SetPanelFullscreenToggleVisibilityInput): Workspace;
+export {};

package/dist/application/workspace/setPanelFullscreenToggleVisibility.js

@@ -0,0 +1,7 @@
+import { updateActiveWindowRoot, updatePanelById } from "./layoutTree.js";
+export function setPanelFullscreenToggleVisibility(workspace, input) {
+    return updateActiveWindowRoot(workspace, (root) => updatePanelById(root, input.panelId, (panel) => ({
+        ...panel,
+        showFullscreenToggle: input.visible
+    })));
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SetStackHeaderVisibilityInput {
+    stackId: string;
+    visible: boolean;
+}
+export declare function setStackHeaderVisibility(workspace: Workspace, input: SetStackHeaderVisibilityInput): Workspace;
+export {};

package/dist/application/workspace/setStackHeaderVisibility.js

@@ -0,0 +1,7 @@
+import { updateActiveWindowRoot, updateStackById } from "./layoutTree.js";
+export function setStackHeaderVisibility(workspace, input) {
+    return updateActiveWindowRoot(workspace, (root) => updateStackById(root, input.stackId, (stack) => ({
+        ...stack,
+        headerVisible: input.visible
+    })));
+}

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

@@ -0,0 +1,9 @@
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SetToolPanelTitleOverrideInput {
+    panelId: string;
+    toolInstanceId: string;
+    panelTitleOverride: string | null;
+}
+export declare function setToolPanelTitleOverride(workspace: Workspace, input: SetToolPanelTitleOverrideInput, toolCatalog: ToolCatalogPort): Workspace;
+export {};

package/dist/application/workspace/setToolPanelTitleOverride.js

@@ -0,0 +1,33 @@
+import { updatePanelById } from "./layoutTree.js";
+import { normalizePanelTitleOverride, resolvePanelTitle } from "../../domain/tool/shell.js";
+import { findPanelInWorkspace } from "../../domain/workspace/selectors.js";
+export function setToolPanelTitleOverride(workspace, input, toolCatalog) {
+    const panel = findPanelInWorkspace(workspace, input.panelId);
+    const toolInstance = workspace.toolInstances[input.toolInstanceId];
+    if (!panel || panel.toolInstanceId !== input.toolInstanceId || !toolInstance) {
+        return workspace;
+    }
+    const toolDefinition = toolCatalog.getDefinition(toolInstance.toolId);
+    if (!toolDefinition) {
+        return workspace;
+    }
+    const normalizedOverride = normalizePanelTitleOverride(input.panelTitleOverride);
+    const nextToolInstance = {
+        ...toolInstance,
+        panelTitleOverride: normalizedOverride
+    };
+    return {
+        ...workspace,
+        toolInstances: {
+            ...workspace.toolInstances,
+            [input.toolInstanceId]: nextToolInstance
+        },
+        windows: workspace.windows.map((window) => ({
+            ...window,
+            root: updatePanelById(window.root, input.panelId, (currentPanel) => ({
+                ...currentPanel,
+                title: resolvePanelTitle(toolDefinition, nextToolInstance)
+            }))
+        }))
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+import type { ToolShellStatus } from "../../domain/tool/model.js";
+interface SetToolShellStatusInput {
+    toolInstanceId: string;
+    nextStatus: ToolShellStatus | null;
+}
+export declare function setToolShellStatus(workspace: Workspace, input: SetToolShellStatusInput): Workspace;
+export {};

package/dist/application/workspace/setToolShellStatus.js

@@ -0,0 +1,32 @@
+import { normalizeToolShellStatus } from "../../domain/tool/shell.js";
+export function setToolShellStatus(workspace, input) {
+    const toolInstance = workspace.toolInstances[input.toolInstanceId];
+    if (!toolInstance) {
+        return workspace;
+    }
+    const nextStatus = normalizeToolShellStatus(input.nextStatus);
+    if (input.nextStatus !== null && nextStatus === null) {
+        return workspace;
+    }
+    const currentStatusValue = toolInstance.shellState?.status ?? null;
+    const currentStatus = normalizeToolShellStatus(currentStatusValue);
+    const currentStatusIsWellFormed = currentStatusValue === null || currentStatus !== null;
+    if (currentStatusIsWellFormed &&
+        currentStatus?.label === nextStatus?.label &&
+        currentStatus?.tone === nextStatus?.tone) {
+        return workspace;
+    }
+    return {
+        ...workspace,
+        toolInstances: {
+            ...workspace.toolInstances,
+            [input.toolInstanceId]: {
+                ...toolInstance,
+                shellState: {
+                    ...toolInstance.shellState,
+                    status: nextStatus
+                }
+            }
+        }
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+export declare function normalizeWorkspaceFullscreenPanel(workspace: Workspace): Workspace;
+export declare function setWorkspaceFullscreenPanel(workspace: Workspace, panelId: string | null): Workspace;

package/dist/application/workspace/setWorkspaceFullscreenPanel.js

@@ -0,0 +1,26 @@
+import { findPanelInWorkspace } from "../../domain/workspace/selectors.js";
+export function normalizeWorkspaceFullscreenPanel(workspace) {
+    const fullscreenPanelId = workspace.fullscreenPanelId ?? null;
+    if (fullscreenPanelId === null) {
+        return workspace.fullscreenPanelId === null ? workspace : { ...workspace, fullscreenPanelId: null };
+    }
+    return findPanelInWorkspace(workspace, fullscreenPanelId)
+        ? workspace
+        : {
+            ...workspace,
+            fullscreenPanelId: null
+        };
+}
+export function setWorkspaceFullscreenPanel(workspace, panelId) {
+    const nextFullscreenPanelId = panelId ?? null;
+    if (nextFullscreenPanelId !== null && !findPanelInWorkspace(workspace, nextFullscreenPanelId)) {
+        return normalizeWorkspaceFullscreenPanel(workspace);
+    }
+    if ((workspace.fullscreenPanelId ?? null) === nextFullscreenPanelId) {
+        return normalizeWorkspaceFullscreenPanel(workspace);
+    }
+    return {
+        ...workspace,
+        fullscreenPanelId: nextFullscreenPanelId
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { WorkspaceValidationIssue } from "../../domain/workspace/validation.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export interface WorkspaceSnapshotImportResult {
+    ok: boolean;
+    workspace?: Workspace;
+    error?: string;
+    issues?: WorkspaceValidationIssue[];
+}
+export declare function exportWorkspaceSnapshot(workspace: Workspace): string;
+export declare function importWorkspaceSnapshot(source: string): WorkspaceSnapshotImportResult;

package/dist/application/workspace/snapshots.js

@@ -0,0 +1,34 @@
+import { parseWorkspaceSnapshot, validateWorkspaceSnapshot } from "../../domain/workspace/validation.js";
+export function exportWorkspaceSnapshot(workspace) {
+    return JSON.stringify(workspace, null, 2);
+}
+export function importWorkspaceSnapshot(source) {
+    try {
+        const parsedValue = JSON.parse(source);
+        const issues = validateWorkspaceSnapshot(parsedValue);
+        if (issues.length > 0) {
+            return {
+                ok: false,
+                error: issues[0].message,
+                issues
+            };
+        }
+        const workspace = parseWorkspaceSnapshot(parsedValue);
+        if (!workspace) {
+            return {
+                ok: false,
+                error: 'Workspace snapshot could not be normalized.'
+            };
+        }
+        return {
+            ok: true,
+            workspace
+        };
+    }
+    catch {
+        return {
+            ok: false,
+            error: 'Workspace snapshot must be valid JSON.'
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { LayoutDockSide } from "../../domain/layout/interaction.js";
+import type { SplitOrientation } from "../../domain/layout/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SplitPanelInput {
+    panelId: string;
+    orientation: SplitOrientation;
+    side?: LayoutDockSide;
+}
+export declare function splitPanel(workspace: Workspace, input: SplitPanelInput): Workspace;
+export {};

package/dist/application/workspace/splitPanel.js

@@ -0,0 +1,21 @@
+import { containsPanel } from "../../domain/layout/selectors.js";
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { createPanel, createSplit, createStack } from "../../domain/workspace/factories.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { replaceStackContainingPanel, updateActiveWindowRoot } from "./layoutTree.js";
+export function splitPanel(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return workspace;
+    }
+    const nextRoot = replaceStackContainingPanel(activeWindow.root, input.panelId, (stack) => {
+        const newStack = createStack([createPanel('New panel')]);
+        const nextChildren = input.orientation === 'horizontal' && input.side === 'left'
+            ? [newStack, stack]
+            : input.orientation === 'vertical' && input.side === 'top'
+                ? [newStack, stack]
+                : [stack, newStack];
+        return createSplit(input.orientation, nextChildren);
+    });
+    return updateActiveWindowRoot(workspace, () => canonicalizeLayout(nextRoot));
+}

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

@@ -0,0 +1,39 @@
+import type { LayoutEdge } from "../../domain/layout/interaction.js";
+import type { SplitOrientation } from "../../domain/layout/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export type PanelSubdivisionAxis = 'columns' | 'rows';
+export interface PanelSubdivisionPreview {
+    axis: PanelSubdivisionAxis;
+    cutCount: number;
+    pointerRatio: number;
+    linePositions: number[];
+    preservedSegmentIndex: number;
+    segmentRanges: Array<{
+        index: number;
+        start: number;
+        end: number;
+        center: number;
+    }>;
+}
+export interface SubdividePanelInput {
+    panelId: string;
+    orientation: SplitOrientation;
+    edge: LayoutEdge;
+    cuts: number;
+    pointerRatio: number;
+}
+export interface SubdividePanelResult {
+    workspace: Workspace;
+    createdPanelIds: string[];
+    originalPanelId: string;
+}
+export declare function clampSubdivisionCuts(cuts: number): number;
+export declare function clampSubdivisionPointerRatio(pointerRatio: number): number;
+export declare function resolveSubdivisionAxis(orientation: SplitOrientation): PanelSubdivisionAxis;
+export declare function resolveLayoutOrientationForSubdivision(orientation: SplitOrientation): SplitOrientation;
+export declare function getSubdivisionSegmentSizes(edge: LayoutEdge, cuts: number, pointerRatio: number): number[];
+export declare function getSubdivisionPreview(orientation: SplitOrientation, edge: LayoutEdge, cuts: number, pointerRatio: number): PanelSubdivisionPreview;
+export declare function resolveDefaultSubdivisionPreservedSegmentIndex(edge: LayoutEdge, cuts: number): number;
+export declare function resolveSubdivisionPreservedSegmentIndex(edge: LayoutEdge, cuts: number, pointerRatio: number): number;
+export declare function resolveSubdivisionSegmentPointerRatio(edge: LayoutEdge, cuts: number, segmentIndex: number): number;
+export declare function subdividePanel(workspace: Workspace, input: SubdividePanelInput): SubdividePanelResult;