@konitif/workbench-runtime 0.284.1

package/dist/workbench/workbenchLayoutActions.d.ts

@@ -0,0 +1,84 @@
+import { createWorkspaceSessionState, type LayoutDockSide, type LayoutDockTarget, type LayoutEdge, type LayoutInteractionState, type LayoutMenuActionId, type LayoutMenuActionSelection, type LayoutMenuTarget, type ShellState, type SplitOrientation, type ToolCatalog, type Workspace, type WorkspaceFocus } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchHistoryScope } from "./workspaceHistoryController.js";
+export interface WorkbenchLayoutActionState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface CreateWorkbenchLayoutActionsInput<TState extends WorkbenchLayoutActionState> {
+    toolCatalog: ToolCatalog;
+    getWorkbenchState(): TState;
+    createWorkbenchState(workspaceSession: ReturnType<typeof createWorkspaceSessionState>, shell: ShellState, layoutInteraction: LayoutInteractionState): TState;
+    updateWorkbenchState(updater: (state: TState) => TState, historyScope?: WorkbenchHistoryScope): void;
+}
+export declare function createWorkbenchLayoutActions<TState extends WorkbenchLayoutActionState>(input: CreateWorkbenchLayoutActionsInput<TState>): {
+    resizeSplit(splitId: string, sizes: [number, number]): void;
+    resizeSplitBoundary(rootSplitId: string, boundaryIndex: number, deltaRatio: number, mode?: "local" | "proportional"): void;
+    collapseSplit(splitId: string, removeChildIndex: 0 | 1): void;
+    collapseSplitBoundary(rootSplitId: string, boundaryIndex: number, removeSide: "start" | "end"): void;
+    openLayoutSplitMenu(panelId: string | null, edge: LayoutEdge, anchor: {
+        x: number;
+        y: number;
+    }, targets?: LayoutMenuTarget[], options?: {
+        source?: "workspace-edge" | "split-boundary" | "panel-menu";
+        initialActionId?: LayoutMenuActionId | null;
+    }): void;
+    selectLayoutSplitOrientation(orientation: SplitOrientation): void;
+    selectLayoutMenuAction(selection: LayoutMenuActionSelection | null): void;
+    hoverLayoutSplitSide(side: LayoutDockSide | null): void;
+    confirmLayoutSplitSide(side: LayoutDockSide): void;
+    updateLayoutSplitPreview(panelId: string | null, pointerRatio: number): void;
+    adjustLayoutSplitPreviewCuts(delta: number): void;
+    startLayoutSplitPreview(panelId: string, edge: LayoutEdge, orientation: SplitOrientation, cuts: number, pointerRatio: number): void;
+    startBoundaryPull(params: {
+        windowId?: string;
+        anchor: {
+            x: number;
+            y: number;
+        };
+        horizontalEdge?: "left" | "right" | null;
+        verticalEdge?: "top" | "bottom" | null;
+        source?: "edge" | "corner";
+        neutralThreshold?: number;
+        creationThreshold?: number;
+    }): void;
+    updateBoundaryPull(pointer: {
+        x: number;
+        y: number;
+    }, viewport: {
+        width: number;
+        height: number;
+    }): void;
+    commitBoundaryPull(): void;
+    startIntersectionResize(params: {
+        anchor: {
+            x: number;
+            y: number;
+        };
+        columnSplitId: string;
+        rowSplitId: string;
+        columnBaseSizes: [number, number];
+        rowBaseSizes: [number, number];
+    }): void;
+    updateIntersectionResize(pointer: {
+        x: number;
+        y: number;
+    }, dimensions: {
+        width: number;
+        height: number;
+    }): void;
+    commitIntersectionResize(): void;
+    startPanelDrag(panelId: string, sourceStackId: string, anchor: {
+        x: number;
+        y: number;
+    }): void;
+    updatePanelDrag(pointer: {
+        x: number;
+        y: number;
+    }, hoveredTarget: LayoutDockTarget | null): void;
+    commitPanelDock(): void;
+    commitLayoutSubdivideSelection(panelId: string, edge: LayoutEdge, orientation: SplitOrientation, cuts: number, pointerRatio: number): void;
+    commitLayoutSplitPreview(): void;
+    cancelLayoutInteraction(): void;
+};

package/dist/workbench/workbenchLayoutActions.js

@@ -0,0 +1,191 @@
+import { adjustLayoutSplitPreviewCuts, commitBoundaryPull, commitIntersectionResize, commitLayoutSplitPreview, commitLayoutSubdivideSelection, commitPanelDock, collapseSplit, collapseSplitBoundary, confirmLayoutSplitSide, createPeripheralBands, createWorkspaceSessionState, dismissLayoutInteraction, dispatchWorkspaceCommand, dockPanel, findPanelInWorkspace, getPreferredFocusedPanelId, joinPanelArea, openLayoutSplitMenu, previewLayoutSplitSide, resizeSplit, resizeSplitBoundary, selectLayoutMenuAction, selectLayoutSplitOrientation, startBoundaryPull, startIntersectionResize, startLayoutSplitPreview, startPanelDrag, subdividePanel, swapPanelArea, updateBoundaryPull, updateIntersectionResize, updateLayoutSplitPreview, updatePanelDrag } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchLayoutActions(input) {
+    function resolveLayoutMenuHistoryScope(state) {
+        if (state.layoutInteraction.mode === 'split-menu') {
+            return state.layoutInteraction.source === 'panel-menu' ? 'app' : 'core';
+        }
+        if (state.layoutInteraction.mode === 'split-side-pick' || state.layoutInteraction.mode === 'split-preview') {
+            return state.layoutInteraction.panelId ? 'app' : 'core';
+        }
+        return 'core';
+    }
+    function applyLayoutInteractionResolution(state, resolution) {
+        if (resolution.kind === 'state') {
+            return {
+                ...state,
+                layoutInteraction: resolution.state
+            };
+        }
+        if (resolution.kind === 'commit-subdivide') {
+            const result = subdividePanel(state.workspace, resolution.subdivide);
+            const nextFocusedPanelId = resolution.subdivide.edge === 'left' || resolution.subdivide.edge === 'top'
+                ? result.createdPanelIds[0] ?? state.focus.activePanelId
+                : result.createdPanelIds[result.createdPanelIds.length - 1] ?? state.focus.activePanelId;
+            return input.createWorkbenchState(createWorkspaceSessionState(result.workspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, resolution.state);
+        }
+        if (resolution.kind === 'commit-boundary-pull') {
+            const result = createPeripheralBands(state.workspace, resolution.boundaryPull);
+            const nextFocusedPanelId = result.createdPanelIds[result.createdPanelIds.length - 1] ?? state.focus.activePanelId;
+            return input.createWorkbenchState(createWorkspaceSessionState(result.workspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, resolution.state);
+        }
+        if (resolution.kind === 'commit-intersection-resize') {
+            const nextWorkspace = resizeSplit(resizeSplit(state.workspace, {
+                splitId: resolution.intersectionResize.columnSplitId,
+                sizes: resolution.intersectionResize.columnSizes
+            }), {
+                splitId: resolution.intersectionResize.rowSplitId,
+                sizes: resolution.intersectionResize.rowSizes
+            });
+            return input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, state.focus), state.shell, resolution.state);
+        }
+        if (resolution.kind === 'commit-swap') {
+            return input.createWorkbenchState(createWorkspaceSessionState(swapPanelArea(state.workspace, resolution.swap), state.focus), state.shell, resolution.state);
+        }
+        if (resolution.kind === 'commit-join') {
+            const nextWorkspace = joinPanelArea(state.workspace, resolution.join);
+            const nextFocusedPanelId = resolution.join.siblingAreaPanelIds.find((panelId) => findPanelInWorkspace(nextWorkspace, panelId)) ??
+                (findPanelInWorkspace(nextWorkspace, state.focus.activePanelId ?? '')
+                    ? state.focus.activePanelId
+                    : getPreferredFocusedPanelId(nextWorkspace));
+            return input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, resolution.state);
+        }
+        if (resolution.kind === 'commit-dock') {
+            const nextWorkspace = dockPanel(state.workspace, resolution.dock);
+            return input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, { activePanelId: resolution.dock.panelId }), state.shell, resolution.state);
+        }
+        return input.createWorkbenchState(dispatchWorkspaceCommand(state, {
+            type: 'split-panel-to-side',
+            orientation: resolution.split.orientation,
+            side: resolution.split.side,
+            panelId: resolution.split.panelId ?? undefined
+        }, { toolCatalog: input.toolCatalog }), state.shell, resolution.state);
+    }
+    return {
+        resizeSplit(splitId, sizes) {
+            input.updateWorkbenchState((state) => input.createWorkbenchState(createWorkspaceSessionState(resizeSplit(state.workspace, { splitId, sizes }), state.focus), state.shell, state.layoutInteraction), 'core');
+        },
+        resizeSplitBoundary(rootSplitId, boundaryIndex, deltaRatio, mode = 'local') {
+            input.updateWorkbenchState((state) => input.createWorkbenchState(createWorkspaceSessionState(resizeSplitBoundary(state.workspace, { rootSplitId, boundaryIndex, deltaRatio, mode }), state.focus), state.shell, state.layoutInteraction), 'core');
+        },
+        collapseSplit(splitId, removeChildIndex) {
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = collapseSplit(state.workspace, { splitId, removeChildIndex });
+                const nextFocusedPanelId = findPanelInWorkspace(nextWorkspace, state.focus.activePanelId ?? '')
+                    ? state.focus.activePanelId
+                    : getPreferredFocusedPanelId(nextWorkspace);
+                return input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, state.layoutInteraction);
+            }, 'core');
+        },
+        collapseSplitBoundary(rootSplitId, boundaryIndex, removeSide) {
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = collapseSplitBoundary(state.workspace, { rootSplitId, boundaryIndex, removeSide });
+                const nextFocusedPanelId = findPanelInWorkspace(nextWorkspace, state.focus.activePanelId ?? '')
+                    ? state.focus.activePanelId
+                    : getPreferredFocusedPanelId(nextWorkspace);
+                return input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, state.layoutInteraction);
+            }, 'core');
+        },
+        openLayoutSplitMenu(panelId, edge, anchor, targets = [], options = {}) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: openLayoutSplitMenu(panelId, edge, anchor, targets, options)
+            }));
+        },
+        selectLayoutSplitOrientation(orientation) {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, selectLayoutSplitOrientation(state.layoutInteraction, orientation)), resolveLayoutMenuHistoryScope(input.getWorkbenchState()));
+        },
+        selectLayoutMenuAction(selection) {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, selectLayoutMenuAction(state.layoutInteraction, selection)), resolveLayoutMenuHistoryScope(input.getWorkbenchState()));
+        },
+        hoverLayoutSplitSide(side) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: previewLayoutSplitSide(state.layoutInteraction, side)
+            }));
+        },
+        confirmLayoutSplitSide(side) {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, confirmLayoutSplitSide(state.layoutInteraction, side)), resolveLayoutMenuHistoryScope(input.getWorkbenchState()));
+        },
+        updateLayoutSplitPreview(panelId, pointerRatio) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: updateLayoutSplitPreview(state.layoutInteraction, panelId, pointerRatio)
+            }));
+        },
+        adjustLayoutSplitPreviewCuts(delta) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: adjustLayoutSplitPreviewCuts(state.layoutInteraction, delta)
+            }));
+        },
+        startLayoutSplitPreview(panelId, edge, orientation, cuts, pointerRatio) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: startLayoutSplitPreview({
+                    panelId,
+                    edge,
+                    orientation,
+                    cuts,
+                    pointerRatio
+                })
+            }));
+        },
+        startBoundaryPull(params) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: startBoundaryPull({ ...params, windowId: params.windowId ?? state.workspace.activeWindowId })
+            }));
+        },
+        updateBoundaryPull(pointer, viewport) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: updateBoundaryPull(state.layoutInteraction, pointer, viewport)
+            }));
+        },
+        commitBoundaryPull() {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, commitBoundaryPull(state.layoutInteraction)), 'core');
+        },
+        startIntersectionResize(params) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: startIntersectionResize(params)
+            }));
+        },
+        updateIntersectionResize(pointer, dimensions) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: updateIntersectionResize(state.layoutInteraction, pointer, dimensions)
+            }));
+        },
+        commitIntersectionResize() {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, commitIntersectionResize(state.layoutInteraction)), 'core');
+        },
+        startPanelDrag(panelId, sourceStackId, anchor) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: startPanelDrag(panelId, sourceStackId, anchor)
+            }));
+        },
+        updatePanelDrag(pointer, hoveredTarget) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: updatePanelDrag(state.layoutInteraction, pointer, hoveredTarget)
+            }));
+        },
+        commitPanelDock() {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, commitPanelDock(state.layoutInteraction)), 'app');
+        },
+        commitLayoutSubdivideSelection(panelId, edge, orientation, cuts, pointerRatio) {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, commitLayoutSubdivideSelection({ panelId, edge, orientation, cuts, pointerRatio })), panelId ? 'app' : 'core');
+        },
+        commitLayoutSplitPreview() {
+            input.updateWorkbenchState((state) => applyLayoutInteractionResolution(state, commitLayoutSplitPreview(state.layoutInteraction)), resolveLayoutMenuHistoryScope(input.getWorkbenchState()));
+        },
+        cancelLayoutInteraction() {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                layoutInteraction: dismissLayoutInteraction()
+            }));
+        }
+    };
+}

package/dist/workbench/workbenchPersistenceRuntime.d.ts

@@ -0,0 +1,39 @@
+import { createWorkspaceSessionState, type ShellRegionId, type ShellState, type ShellWidgetCatalog, type Workspace, type WorkspaceFocus, type WorkspacePersistencePort } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchShellPersistencePort } from "./workbenchShellPersistence.js";
+import type { WorkbenchFocusPersistencePort } from "./workbenchFocusPersistence.js";
+import type { WorkbenchHistoryScope } from "./workspaceHistoryController.js";
+import type { WorkspaceSyncController } from "./workspaceSyncController.js";
+import type { WorkbenchHostEvents } from "./workbenchHostEvents.js";
+export interface WorkbenchPersistenceState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+}
+export interface CreateWorkbenchPersistenceRuntimeInput<TState extends WorkbenchPersistenceState> {
+    persistenceKey: string;
+    shellPersistenceKey: string;
+    focusPersistenceKey: string;
+    persistenceDebounceMs: number;
+    shellWidgetCatalog: ShellWidgetCatalog;
+    defaultOpenShellRegions?: ShellRegionId[];
+    initialWorkspace: Workspace;
+    initialShell: ShellState;
+    initialFocus: WorkspaceFocus;
+    workspacePersistence: WorkspacePersistencePort;
+    shellPersistence: WorkbenchShellPersistencePort;
+    focusPersistence: WorkbenchFocusPersistencePort;
+    workspaceSync: WorkspaceSyncController;
+    /** The caller selects its host; null explicitly disables notifications. */
+    hostEvents: WorkbenchHostEvents | null;
+    isPersistenceEnabled(): boolean;
+    getWorkbenchState(): TState;
+    createWorkbenchState(workspaceSession: ReturnType<typeof createWorkspaceSessionState>, shellState: ShellState): TState;
+    setWorkbenchState(nextState: TState, historyScope?: WorkbenchHistoryScope): void;
+}
+export interface WorkbenchPersistenceCoordinator<TState extends WorkbenchPersistenceState> {
+    handleStateChange(state: TState): void;
+    flush(): void;
+    /** Cancel pending work; call flush explicitly beforehand if desired. */
+    dispose(): void;
+}
+export declare function createWorkbenchPersistenceRuntime<TState extends WorkbenchPersistenceState>(input: CreateWorkbenchPersistenceRuntimeInput<TState>): WorkbenchPersistenceCoordinator<TState>;

package/dist/workbench/workbenchPersistenceRuntime.js

@@ -0,0 +1,168 @@
+import { createShellState, createWorkspaceSessionState, validateWorkspace } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchPersistenceRuntime(input) {
+    if (input.hostEvents === undefined) {
+        throw new TypeError('hostEvents must be supplied explicitly (use null to disable notifications).');
+    }
+    let pendingPersistenceTimer = null;
+    let lastPersistedWorkspace = input.initialWorkspace;
+    let lastPersistedShellSignature = input.shellPersistence.serialize(input.initialShell);
+    let lastPersistedFocusSignature = input.focusPersistence.serialize(input.initialFocus);
+    let isApplyingRemoteWorkspace = false;
+    let disposed = false;
+    function createShellFallback() {
+        return createShellState(input.shellWidgetCatalog, { openRegionIds: input.defaultOpenShellRegions });
+    }
+    function handleStateChange(state) {
+        if (disposed)
+            return;
+        scheduleWorkspacePersistence(state.workspace, state.shell, state.focus);
+        publishWorkspaceSync(state.workspace, state.shell, state.focus);
+    }
+    function scheduleWorkspacePersistence(workspace, shell, focus) {
+        const shellSignature = input.shellPersistence.serialize(shell);
+        const focusSignature = input.focusPersistence.serialize(focus);
+        if (!input.isPersistenceEnabled()) {
+            clearPendingPersistence();
+            return;
+        }
+        if (workspace === lastPersistedWorkspace &&
+            shellSignature === lastPersistedShellSignature &&
+            focusSignature === lastPersistedFocusSignature) {
+            return;
+        }
+        clearPendingPersistence();
+        const persist = () => {
+            pendingPersistenceTimer = null;
+            if (disposed)
+                return;
+            persistWorkspaceShellAndFocus(workspace, shell, shellSignature, focus, focusSignature);
+        };
+        if (input.persistenceDebounceMs === 0) {
+            persist();
+            return;
+        }
+        pendingPersistenceTimer = setTimeout(persist, input.persistenceDebounceMs);
+    }
+    function flush() {
+        if (disposed)
+            return;
+        clearPendingPersistence();
+        if (!input.isPersistenceEnabled()) {
+            return;
+        }
+        const currentState = input.getWorkbenchState();
+        persistWorkspaceShellAndFocus(currentState.workspace, currentState.shell, input.shellPersistence.serialize(currentState.shell), currentState.focus, input.focusPersistence.serialize(currentState.focus));
+    }
+    function persistWorkspaceShellAndFocus(workspace, shell, shellSignature, focus, focusSignature) {
+        if (validateWorkspace(workspace).length === 0) {
+            try {
+                input.workspacePersistence.save(workspace);
+                lastPersistedWorkspace = workspace;
+            }
+            catch {
+                // Persistence is best-effort: invalid storage state should not break runtime flows.
+            }
+        }
+        try {
+            input.shellPersistence.save(shell);
+            lastPersistedShellSignature = shellSignature;
+        }
+        catch {
+            // Persistence is best-effort: invalid storage state should not break runtime flows.
+        }
+        try {
+            input.focusPersistence.save(focus);
+            lastPersistedFocusSignature = focusSignature;
+        }
+        catch {
+            // Persistence is best-effort: invalid storage state should not break runtime flows.
+        }
+    }
+    function publishWorkspaceSync(workspace, shell, focus) {
+        if (!input.isPersistenceEnabled() || isApplyingRemoteWorkspace || validateWorkspace(workspace).length > 0) {
+            return;
+        }
+        input.workspaceSync.publish({
+            workspace,
+            shell,
+            focus
+        });
+    }
+    function applyRemoteWorkspace(workspace, shell = null, focus = null) {
+        if (disposed || !input.isPersistenceEnabled() || validateWorkspace(workspace).length > 0) {
+            return;
+        }
+        const currentState = input.getWorkbenchState();
+        const nextShell = shell
+            ? input.shellPersistence.normalize(shell, createShellFallback())
+            : currentState.shell;
+        const nextShellSignature = input.shellPersistence.serialize(nextShell);
+        const nextFocus = input.focusPersistence.normalize(focus, workspace, currentState.focus);
+        const nextFocusSignature = input.focusPersistence.serialize(nextFocus);
+        if (JSON.stringify(currentState.workspace) === JSON.stringify(workspace) &&
+            input.shellPersistence.serialize(currentState.shell) === nextShellSignature &&
+            input.focusPersistence.serialize(currentState.focus) === nextFocusSignature) {
+            return;
+        }
+        // The admitted remote snapshot supersedes the local snapshot captured by
+        // the debounce callback. Do not let that stale callback overwrite storage.
+        clearPendingPersistence();
+        isApplyingRemoteWorkspace = true;
+        lastPersistedWorkspace = workspace;
+        lastPersistedShellSignature = nextShellSignature;
+        lastPersistedFocusSignature = nextFocusSignature;
+        input.setWorkbenchState(input.createWorkbenchState(createWorkspaceSessionState(workspace, nextFocus), nextShell), 'none');
+        isApplyingRemoteWorkspace = false;
+    }
+    function clearPendingPersistence() {
+        if (pendingPersistenceTimer !== null) {
+            clearTimeout(pendingPersistenceTimer);
+            pendingPersistenceTimer = null;
+        }
+    }
+    function handlePersistenceBoundary() {
+        flush();
+    }
+    function handleStorage(event) {
+        if (disposed || !input.isPersistenceEnabled()) {
+            return;
+        }
+        if (![input.persistenceKey, input.shellPersistenceKey, input.focusPersistenceKey].includes(event.key ?? '') ||
+            !event.newValue) {
+            return;
+        }
+        const loadedWorkspace = event.key === input.persistenceKey
+            ? input.workspacePersistence.load()
+            : input.getWorkbenchState().workspace;
+        if (!loadedWorkspace) {
+            return;
+        }
+        applyRemoteWorkspace(loadedWorkspace, input.shellPersistence.load(createShellFallback()), input.focusPersistence.load(loadedWorkspace, input.getWorkbenchState().focus));
+    }
+    const unsubscribeHost = input.hostEvents?.subscribe({
+        onPersistenceBoundary: handlePersistenceBoundary,
+        onStorageChange: handleStorage
+    });
+    const unsubscribe = input.workspaceSync.subscribe((snapshot) => {
+        applyRemoteWorkspace(snapshot.workspace, snapshot.shell ?? null, snapshot.focus ?? null);
+    });
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        clearPendingPersistence();
+        try {
+            unsubscribeHost?.();
+        }
+        finally {
+            if (typeof unsubscribe === 'function')
+                unsubscribe();
+        }
+        // workspaceSync is injected: its owner, not this subscriber, closes it.
+    }
+    return {
+        handleStateChange,
+        flush,
+        dispose
+    };
+}

package/dist/workbench/workbenchShellActions.d.ts

@@ -0,0 +1,24 @@
+import { type LayoutInteractionState, type ShellRegionId, type ShellRegionAxis, type ShellRegionPresentation, type ShellState, type ShellWidgetPlacement, type Workspace, type WorkspaceFocus } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchHistoryScope } from "./workspaceHistoryController.js";
+export interface WorkbenchShellActionState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface WorkbenchShellActions {
+    addShellWidgetToRegion(regionId: ShellRegionId, widgetId: string, placement?: ShellWidgetPlacement): void;
+    activateShellWidget(regionId: ShellRegionId, widgetId: string): void;
+    moveShellWidgetToRegion(regionId: ShellRegionId, widgetId: string, placement?: ShellWidgetPlacement): void;
+    removeShellWidgetFromRegion(regionId: ShellRegionId, widgetId: string): void;
+    setShellRegionArrangement(regionId: ShellRegionId, presentation: ShellRegionPresentation, axis?: ShellRegionAxis): void;
+    setShellRegionOpen(regionId: ShellRegionId, isOpen: boolean): void;
+    setShellRegionVisible(regionId: ShellRegionId, isVisible: boolean): void;
+    setShellRegionWidgetVisible(regionId: ShellRegionId, widgetId: string, isVisible: boolean): void;
+    setShellRegionSize(regionId: ShellRegionId, size: number): void;
+}
+export interface CreateWorkbenchShellActionsInput<TState extends WorkbenchShellActionState> {
+    updateWorkbenchState(updater: (state: TState) => TState, historyScope?: WorkbenchHistoryScope): void;
+    flushPersistence?(): void;
+}
+export declare function createWorkbenchShellActions<TState extends WorkbenchShellActionState>(input: CreateWorkbenchShellActionsInput<TState>): WorkbenchShellActions;

package/dist/workbench/workbenchShellActions.js

@@ -0,0 +1,63 @@
+import { addShellWidgetToRegion, activateShellWidget, moveShellWidgetToRegion, removeShellWidgetFromRegion, setShellRegionArrangement, setShellRegionOpen, setShellRegionSize, setShellRegionWidgetVisible, setShellRegionVisible } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchShellActions(input) {
+    function commitShellInteraction(updater) {
+        input.updateWorkbenchState(updater, 'core');
+        input.flushPersistence?.();
+    }
+    return {
+        addShellWidgetToRegion(regionId, widgetId, placement = {}) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: addShellWidgetToRegion(state.shell, regionId, widgetId, placement)
+            }));
+        },
+        activateShellWidget(regionId, widgetId) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: activateShellWidget(state.shell, regionId, widgetId)
+            }));
+        },
+        moveShellWidgetToRegion(regionId, widgetId, placement = {}) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: moveShellWidgetToRegion(state.shell, regionId, widgetId, placement)
+            }));
+        },
+        removeShellWidgetFromRegion(regionId, widgetId) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: removeShellWidgetFromRegion(state.shell, regionId, widgetId)
+            }));
+        },
+        setShellRegionArrangement(regionId, presentation, axis) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: setShellRegionArrangement(state.shell, regionId, presentation, axis)
+            }));
+        },
+        setShellRegionOpen(regionId, isOpen) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: setShellRegionOpen(state.shell, regionId, isOpen)
+            }));
+        },
+        setShellRegionVisible(regionId, isVisible) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: setShellRegionVisible(state.shell, regionId, isVisible)
+            }));
+        },
+        setShellRegionWidgetVisible(regionId, widgetId, isVisible) {
+            commitShellInteraction((state) => ({
+                ...state,
+                shell: setShellRegionWidgetVisible(state.shell, regionId, widgetId, isVisible)
+            }));
+        },
+        setShellRegionSize(regionId, size) {
+            input.updateWorkbenchState((state) => ({
+                ...state,
+                shell: setShellRegionSize(state.shell, regionId, size)
+            }), 'core');
+        }
+    };
+}

package/dist/workbench/workbenchShellPersistence.d.ts

@@ -0,0 +1,18 @@
+import type { ShellState, ShellWidgetCatalog } from '@konitif/workbench';
+export interface WorkbenchShellPersistencePort {
+    load(fallback: ShellState): ShellState;
+    save(shell: ShellState): void;
+    serialize(shell: ShellState): string;
+    normalize(input: unknown, fallback: ShellState): ShellState;
+}
+interface LocalWorkbenchShellPersistenceOptions {
+    storageKey: string;
+    isEnabled?: () => boolean;
+    shellWidgetCatalog?: ShellWidgetCatalog;
+}
+export declare function createLocalWorkbenchShellPersistence(options: LocalWorkbenchShellPersistenceOptions): WorkbenchShellPersistencePort;
+export declare function serializeShellState(shell: ShellState): string;
+export declare function normalizePersistedShellState(input: unknown, fallback: ShellState, options?: {
+    shellWidgetCatalog?: ShellWidgetCatalog;
+}): ShellState;
+export {};