@konitif/workbench-runtime 0.284.1

package/dist/workbench/createWorkbenchStoreRuntime.js

@@ -0,0 +1,242 @@
+import { derived, get, writable } from 'svelte/store';
+import { createWorkbenchShellActions } from "./workbenchShellActions.js";
+import { createWorkbenchToolRuntimeActions } from "./workbenchToolRuntimeActions.js";
+import { createWorkbenchLayoutActions } from "./workbenchLayoutActions.js";
+import { createWorkbenchHistoryActions } from "./workbenchHistoryActions.js";
+import { createWorkbenchWorkspaceActions } from "./workbenchWorkspaceActions.js";
+import { createWorkbenchWindowRuntime } from "./workbenchWindowRuntime.js";
+import { createWorkbenchToolRuntimeUiStore } from "./workbenchToolRuntimeUiStore.js";
+import { createWorkbenchPersistenceRuntime } from "./workbenchPersistenceRuntime.js";
+import { createWorkbenchStateFactory } from "./workbenchStateFactory.js";
+import { createWorkbenchHistoryRuntime } from "./workbenchHistoryRuntime.js";
+import { createWorkspaceSessionState, dismissLayoutInteraction } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchStoreRuntime(options) {
+    for (const key of ['workspacePersistence', 'shellPersistence', 'focusPersistence', 'workspaceSync', 'hostEvents', 'detachedWindows']) {
+        if (options[key] === undefined || (key !== 'hostEvents' && key !== 'detachedWindows' && options[key] === null)) {
+            throw new TypeError(`Missing required Workbench port: ${key}`);
+        }
+    }
+    let disposed = false;
+    const persistence = options.workspacePersistence;
+    const shellPersistenceKey = options.shellPersistenceKey ?? `${options.persistenceKey}.shell`;
+    const focusPersistenceKey = options.focusPersistenceKey ?? `${options.persistenceKey}.focus`;
+    const persistenceDebounceMs = Math.max(0, options.persistenceDebounceMs ?? 120);
+    function isPersistenceEnabled() {
+        return options.persistenceEnabled?.() ?? true;
+    }
+    const shellPersistence = options.shellPersistence;
+    const workspaceSync = options.workspaceSync;
+    const focusPersistence = options.focusPersistence;
+    const stateFactory = createWorkbenchStateFactory({
+        initialToolId: options.initialToolId,
+        toolCatalog: options.toolCatalog,
+        shellWidgetCatalog: options.shellWidgetCatalog,
+        initialWorkspaceMode: options.initialWorkspaceMode,
+        initialStackHeaderVisible: options.initialStackHeaderVisible,
+        defaultOpenShellRegions: options.defaultOpenShellRegions
+    });
+    const { createInitialWorkspace, createShellFallback, createWorkbenchState } = stateFactory;
+    const initialWorkspace = isPersistenceEnabled()
+        ? (persistence.load() ?? createWorkbenchState().workspace)
+        : createWorkbenchState().workspace;
+    const initialShell = shellPersistence.load(createShellFallback());
+    const fallbackSession = createWorkspaceSessionState(initialWorkspace);
+    const initialFocus = focusPersistence.load(initialWorkspace, fallbackSession.focus);
+    const internalWorkspaceStore = writable(createWorkbenchState(createWorkspaceSessionState(initialWorkspace, initialFocus), initialShell));
+    const toolRuntimeUi = createWorkbenchToolRuntimeUiStore(() => get(internalWorkspaceStore).workspace);
+    const historyRuntime = createWorkbenchHistoryRuntime();
+    const persistenceCoordinator = createWorkbenchPersistenceRuntime({
+        persistenceKey: options.persistenceKey,
+        shellPersistenceKey,
+        focusPersistenceKey,
+        persistenceDebounceMs,
+        shellWidgetCatalog: options.shellWidgetCatalog,
+        defaultOpenShellRegions: options.defaultOpenShellRegions,
+        initialWorkspace,
+        initialShell,
+        initialFocus,
+        workspacePersistence: persistence,
+        shellPersistence,
+        focusPersistence,
+        workspaceSync,
+        hostEvents: options.hostEvents,
+        isPersistenceEnabled,
+        getWorkbenchState: () => get(internalWorkspaceStore),
+        createWorkbenchState,
+        setWorkbenchState
+    });
+    function flushWorkspacePersistence() {
+        persistenceCoordinator.flush();
+    }
+    function updateWorkbenchState(updater, historyScope = 'both') {
+        if (disposed)
+            return;
+        internalWorkspaceStore.update((state) => {
+            const updatedState = updater(state);
+            const provenance = state.workspace.presetProvenance;
+            const presetContentChanged = provenance?.status === 'exact' &&
+                (updatedState.workspace !== state.workspace || updatedState.shell !== state.shell);
+            const nextState = presetContentChanged
+                ? {
+                    ...updatedState,
+                    workspace: {
+                        ...updatedState.workspace,
+                        presetProvenance: {
+                            ...provenance,
+                            status: 'customized'
+                        }
+                    }
+                }
+                : updatedState;
+            historyRuntime.recordTransition(state, nextState, historyScope);
+            return nextState;
+        });
+    }
+    function setWorkbenchState(nextState, historyScope = 'both') {
+        if (disposed)
+            return;
+        internalWorkspaceStore.update((state) => {
+            historyRuntime.recordTransition(state, nextState, historyScope);
+            return nextState;
+        });
+    }
+    function restoreHistorySnapshot(snapshot) {
+        return createWorkbenchState(createWorkspaceSessionState(snapshot.workspace, snapshot.focus), snapshot.shell, dismissLayoutInteraction());
+    }
+    function resolveWorkspaceCommandHistoryScope(command) {
+        switch (command.type) {
+            case 'open-tool':
+            case 'open-tool-in-panel':
+            case 'open-tool-in-new-tab':
+            case 'split-panel-horizontal':
+            case 'split-panel-vertical':
+            case 'split-panel-to-side':
+            case 'join-panel-area':
+            case 'swap-panel-area':
+            case 'close-active-panel':
+            case 'close-panel':
+            case 'detach-panel-to-window':
+            case 'focus-panel':
+            case 'activate-tab':
+            case 'set-stack-header-visibility':
+            case 'set-panel-fullscreen-toggle-visibility':
+            case 'run-tool-shell-command':
+                return 'app';
+        }
+    }
+    const toolRuntimeActions = createWorkbenchToolRuntimeActions({
+        toolCatalog: options.toolCatalog,
+        workspaceHistory: historyRuntime.controller,
+        getWorkbenchState: () => get(internalWorkspaceStore),
+        createHistorySnapshot: historyRuntime.createSnapshot,
+        restoreHistorySnapshot,
+        createWorkbenchState,
+        updateWorkbenchState,
+        setWorkbenchState,
+        syncHistoryStatus: historyRuntime.syncStatus,
+        setToolPanelLoadingState(toolInstanceId, nextLoading) {
+            if (disposed)
+                return false;
+            return toolRuntimeUi.setToolPanelLoadingState(toolInstanceId, nextLoading);
+        },
+        setToolResourceLoadingState(toolInstanceId, nextLoading) {
+            if (disposed)
+                return false;
+            return toolRuntimeUi.setToolResourceLoadingState(toolInstanceId, nextLoading);
+        },
+        setToolShellStatusState(toolInstanceId, nextStatus) {
+            if (disposed)
+                return false;
+            return toolRuntimeUi.setToolShellStatus(toolInstanceId, nextStatus);
+        }
+    });
+    const shellActions = createWorkbenchShellActions({
+        updateWorkbenchState,
+        flushPersistence: flushWorkspacePersistence
+    });
+    const layoutActions = createWorkbenchLayoutActions({
+        toolCatalog: options.toolCatalog,
+        getWorkbenchState: () => get(internalWorkspaceStore),
+        createWorkbenchState,
+        updateWorkbenchState
+    });
+    const genericWorkspaceActions = createWorkbenchWorkspaceActions({
+        toolCatalog: options.toolCatalog,
+        initialWorkspaceMode: options.initialWorkspaceMode,
+        createInitialWorkspace,
+        getWorkbenchState: () => get(internalWorkspaceStore),
+        createWorkbenchState,
+        updateWorkbenchState,
+        setWorkbenchState,
+        resolveWorkspaceCommandHistoryScope
+    });
+    const historyActions = createWorkbenchHistoryActions({
+        workspaceHistory: historyRuntime.controller,
+        getWorkbenchState: () => get(internalWorkspaceStore),
+        createHistorySnapshot: historyRuntime.createSnapshot,
+        restoreHistorySnapshot,
+        setWorkbenchState,
+        syncHistoryStatus: historyRuntime.syncStatus
+    });
+    const windowActions = createWorkbenchWindowRuntime({
+        detachedWindows: options.detachedWindows,
+        createWorkbenchState,
+        updateWorkbenchState,
+        flushWorkspacePersistence
+    });
+    const unsubscribeState = internalWorkspaceStore.subscribe((state) => {
+        persistenceCoordinator.handleStateChange(state);
+        toolRuntimeUi.prune(state.workspace.toolInstances);
+    });
+    const workspaceStore = {
+        subscribe: derived([internalWorkspaceStore, toolRuntimeUi.store], ([$state, $toolRuntimeUi]) => ({
+            ...$state,
+            toolRuntimeUi: $toolRuntimeUi
+        })).subscribe
+    };
+    const workspaceHistoryStore = {
+        subscribe: historyRuntime.statusStore.subscribe
+    };
+    const workspaceActions = {
+        ...genericWorkspaceActions,
+        ...layoutActions,
+        ...windowActions,
+        ...shellActions,
+        ...historyActions,
+        dispatchCommand(command) {
+            genericWorkspaceActions.dispatchCommand(command);
+            // The active tab is user-visible shell state. Persist it at the interaction boundary so a
+            // reload cannot reopen the default tab while the ordinary debounce is still pending.
+            if (command.type === 'activate-tab' || command.type === 'focus-panel')
+                flushWorkspacePersistence();
+        },
+        toolRuntime: toolRuntimeActions
+    };
+    function resetForTests() {
+        if (disposed)
+            return;
+        windowActions.disposeDetachedWindowTracking();
+        historyRuntime.reset();
+        internalWorkspaceStore.set(createWorkbenchState());
+        toolRuntimeUi.reset();
+        flushWorkspacePersistence();
+        historyRuntime.syncStatus();
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        unsubscribeState();
+        windowActions.disposeDetachedWindowTracking();
+        // Providers belong to the caller; release only this runtime's subscriptions.
+        persistenceCoordinator.dispose();
+    }
+    return {
+        dispose,
+        flushPersistence: flushWorkspacePersistence,
+        workspaceStore,
+        workspaceHistoryStore,
+        workspaceActions,
+        __resetWorkspaceStoreForTests: resetForTests
+    };
+}

package/dist/workbench/createWorkspaceModeController.d.ts

@@ -0,0 +1,36 @@
+import { type Readable } from 'svelte/store';
+import type { WorkspaceCommand } from '@konitif/workbench';
+import type { createWorkbenchStore } from "./createWorkbenchStore.js";
+type WorkbenchStore = ReturnType<typeof createWorkbenchStore>;
+type WorkspaceActions = WorkbenchStore['workspaceActions'];
+type WorkspaceState = Parameters<WorkbenchStore['workspaceStore']['subscribe']>[0] extends (value: infer State) => void ? State : never;
+type WorkspaceHistoryState = Parameters<WorkbenchStore['workspaceHistoryStore']['subscribe']>[0] extends (value: infer State) => void ? State : never;
+type WorkspaceActionName = keyof WorkspaceActions;
+export interface WorkspaceModeControllerOptions<Mode extends string> {
+    initialMode: Mode;
+    modes?: readonly Mode[];
+    stores?: Record<Mode, WorkbenchStore>;
+    getStore?: (mode: Mode) => WorkbenchStore;
+    isWorkspaceCommandBlocked?: (mode: Mode, command: WorkspaceCommand) => boolean;
+    isWorkspaceActionBlocked?: (mode: Mode, action: WorkspaceActionName) => boolean;
+    resolveBlockedWorkspaceAction?: (context: {
+        mode: Mode;
+        action: WorkspaceActionName;
+        store: WorkbenchStore;
+    }) => ((...args: unknown[]) => unknown) | null | undefined;
+    onModeActivated?: (mode: Mode, store: WorkbenchStore) => void;
+    onWorkspaceReset?: (mode: Mode, store: WorkbenchStore) => void;
+}
+export interface WorkspaceModeController<Mode extends string> {
+    activeMode: Readable<Mode>;
+    workspaceStore: Readable<WorkspaceState>;
+    workspaceHistoryStore: Readable<WorkspaceHistoryState>;
+    workspaceActions: WorkspaceActions;
+    setActiveMode: (mode: Mode) => void;
+    suspendMode: (mode: Mode) => void;
+    resumeMode: (mode: Mode) => void;
+    getWorkspaceActionsForMode: (mode: Mode) => WorkspaceActions;
+    getWorkspaceStateForMode: (mode: Mode) => WorkspaceState;
+}
+export declare function createWorkspaceModeController<Mode extends string>(options: WorkspaceModeControllerOptions<Mode>): WorkspaceModeController<Mode>;
+export {};

package/dist/workbench/createWorkspaceModeController.js

@@ -0,0 +1,168 @@
+import { get, writable } from 'svelte/store';
+export function createWorkspaceModeController(options) {
+    const activeModeStore = writable(options.initialMode);
+    const suspendedModes = new Set();
+    const refreshReaders = new Set();
+    function getStoreForMode(mode) {
+        if (suspendedModes.has(mode))
+            throw new Error(`Workbench mode "${mode}" is suspended.`);
+        const store = options.getStore?.(mode) ?? options.stores?.[mode];
+        if (!store) {
+            throw new Error(`No workbench store registered for mode "${mode}".`);
+        }
+        return store;
+    }
+    function createActiveReadable(selectStore) {
+        return {
+            subscribe(run, invalidate) {
+                if (suspendedModes.has(get(activeModeStore))) {
+                    throw new Error(`Workbench mode "${get(activeModeStore)}" is suspended.`);
+                }
+                let activeUnsubscribe = null;
+                const refresh = () => {
+                    activeUnsubscribe?.();
+                    activeUnsubscribe = null;
+                    const mode = get(activeModeStore);
+                    if (suspendedModes.has(mode))
+                        return;
+                    activeUnsubscribe = selectStore(getStoreForMode(mode)).subscribe(run, invalidate);
+                };
+                refreshReaders.add(refresh);
+                const modeUnsubscribe = activeModeStore.subscribe(refresh);
+                return () => {
+                    activeUnsubscribe?.();
+                    modeUnsubscribe();
+                    refreshReaders.delete(refresh);
+                };
+            }
+        };
+    }
+    function createActionProxy(resolveTarget) {
+        return new Proxy({}, {
+            ownKeys() {
+                return Reflect.ownKeys(resolveTarget());
+            },
+            getOwnPropertyDescriptor(_target, property) {
+                const descriptor = Reflect.getOwnPropertyDescriptor(resolveTarget(), property);
+                return descriptor
+                    ? {
+                        ...descriptor,
+                        configurable: true,
+                        enumerable: true
+                    }
+                    : undefined;
+            },
+            has(_target, property) {
+                return property in resolveTarget();
+            },
+            get(_target, property) {
+                const value = Reflect.get(resolveTarget(), property);
+                if (typeof value === 'function') {
+                    return (...args) => Reflect.get(resolveTarget(), property)(...args);
+                }
+                return value;
+            }
+        });
+    }
+    function createWorkspaceActionsForMode(mode) {
+        const toolRuntimeActions = createActionProxy(() => getStoreForMode(mode).workspaceActions.toolRuntime);
+        return new Proxy({ toolRuntime: toolRuntimeActions }, {
+            get(target, property) {
+                const store = getStoreForMode(mode);
+                if (property === 'toolRuntime') {
+                    return target.toolRuntime;
+                }
+                if (property === 'dispatchCommand') {
+                    return (command) => {
+                        if (options.isWorkspaceCommandBlocked?.(mode, command)) {
+                            return;
+                        }
+                        getStoreForMode(mode).workspaceActions.dispatchCommand(command);
+                    };
+                }
+                if (property === 'resetWorkspace') {
+                    return () => {
+                        const current = getStoreForMode(mode);
+                        current.workspaceActions.resetWorkspace();
+                        options.onWorkspaceReset?.(mode, current);
+                    };
+                }
+                if (options.isWorkspaceActionBlocked?.(mode, property)) {
+                    const blockedAction = options.resolveBlockedWorkspaceAction?.({
+                        mode,
+                        action: property,
+                        store
+                    });
+                    return blockedAction ?? (() => undefined);
+                }
+                const value = Reflect.get(store.workspaceActions, property);
+                if (typeof value === 'function') {
+                    return (...args) => Reflect.get(getStoreForMode(mode).workspaceActions, property)(...args);
+                }
+                return value;
+            }
+        });
+    }
+    const workspaceActionsByMode = Object.fromEntries(resolveWorkspaceModes().map((mode) => [
+        mode,
+        createWorkspaceActionsForMode(mode)
+    ]));
+    const activeToolRuntimeActions = createActionProxy(() => workspaceActionsByMode[get(activeModeStore)].toolRuntime);
+    const activeWorkspaceActions = new Proxy({ toolRuntime: activeToolRuntimeActions }, {
+        get(target, property) {
+            if (property === 'toolRuntime') {
+                return target.toolRuntime;
+            }
+            const value = Reflect.get(workspaceActionsByMode[get(activeModeStore)], property);
+            if (typeof value === 'function') {
+                return (...args) => Reflect.get(workspaceActionsByMode[get(activeModeStore)], property)(...args);
+            }
+            return value;
+        }
+    });
+    return {
+        activeMode: {
+            subscribe: activeModeStore.subscribe
+        },
+        workspaceStore: createActiveReadable((store) => store.workspaceStore),
+        workspaceHistoryStore: createActiveReadable((store) => store.workspaceHistoryStore),
+        workspaceActions: activeWorkspaceActions,
+        suspendMode(mode) {
+            if (suspendedModes.has(mode))
+                return;
+            suspendedModes.add(mode);
+            if (get(activeModeStore) === mode)
+                for (const refresh of [...refreshReaders])
+                    refresh();
+        },
+        resumeMode(mode) {
+            if (!suspendedModes.delete(mode))
+                return;
+            if (get(activeModeStore) === mode)
+                for (const refresh of [...refreshReaders])
+                    refresh();
+        },
+        setActiveMode(mode) {
+            const store = getStoreForMode(mode);
+            if (get(activeModeStore) !== mode) {
+                activeModeStore.set(mode);
+            }
+            options.onModeActivated?.(mode, store);
+        },
+        getWorkspaceActionsForMode(mode) {
+            return workspaceActionsByMode[mode];
+        },
+        getWorkspaceStateForMode(mode) {
+            return get(getStoreForMode(mode).workspaceStore);
+        }
+    };
+    function resolveWorkspaceModes() {
+        if (options.modes) {
+            return options.modes;
+        }
+        if (options.stores) {
+            return Object.keys(options.stores);
+        }
+        return [options.initialMode];
+    }
+}

package/dist/workbench/workbenchDetachedWindowHost.d.ts

@@ -0,0 +1,16 @@
+/** Native handles, URLs and polling belong to the host, not to workspace state. */
+export type WorkbenchDetachedWindowOpening = {
+    status: 'blocked';
+}
+/** Logical detachment without a native window or closure observation. */
+ | {
+    status: 'unmanaged';
+} | {
+    status: 'opened';
+    /** May notify synchronously. Unsubscribe never closes the native window. */
+    observeClosed(onClosed: () => void): () => void;
+};
+export interface WorkbenchDetachedWindowHost {
+    /** A thrown error means opening failed without retaining a native window. */
+    open(windowId: string): WorkbenchDetachedWindowOpening;
+}

package/dist/workbench/workbenchDetachedWindowHost.js

@@ -0,0 +1 @@
+export {};

package/dist/workbench/workbenchFocusPersistence.d.ts

@@ -0,0 +1,15 @@
+import { type Workspace, type WorkspaceFocus } from '@konitif/workbench';
+export interface WorkbenchFocusPersistencePort {
+    load(workspace: Workspace, fallback: WorkspaceFocus): WorkspaceFocus;
+    save(focus: WorkspaceFocus): void;
+    serialize(focus: WorkspaceFocus): string;
+    normalize(input: unknown, workspace: Workspace, fallback: WorkspaceFocus): WorkspaceFocus;
+}
+interface LocalWorkbenchFocusPersistenceOptions {
+    storageKey: string;
+    isEnabled?: () => boolean;
+}
+export declare function createLocalWorkbenchFocusPersistence(options: LocalWorkbenchFocusPersistenceOptions): WorkbenchFocusPersistencePort;
+export declare function serializeWorkspaceFocus(focus: WorkspaceFocus): string;
+export declare function normalizePersistedWorkspaceFocus(input: unknown, workspace: Workspace, fallback: WorkspaceFocus): WorkspaceFocus;
+export {};

package/dist/workbench/workbenchFocusPersistence.js

@@ -0,0 +1,44 @@
+import { findPanelInWorkspace, normalizeWorkspaceFocus } from '@konitif/workbench';
+export function createLocalWorkbenchFocusPersistence(options) {
+    return {
+        load(workspace, fallback) {
+            if (!isEnabled(options) || typeof localStorage === 'undefined') {
+                return fallback;
+            }
+            try {
+                const rawFocus = localStorage.getItem(options.storageKey);
+                return rawFocus ? normalizePersistedWorkspaceFocus(JSON.parse(rawFocus), workspace, fallback) : fallback;
+            }
+            catch {
+                return fallback;
+            }
+        },
+        save(focus) {
+            if (!isEnabled(options) || typeof localStorage === 'undefined') {
+                return;
+            }
+            localStorage.setItem(options.storageKey, serializeWorkspaceFocus(focus));
+        },
+        serialize: serializeWorkspaceFocus,
+        normalize: normalizePersistedWorkspaceFocus
+    };
+}
+export function serializeWorkspaceFocus(focus) {
+    return JSON.stringify(focus);
+}
+export function normalizePersistedWorkspaceFocus(input, workspace, fallback) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return normalizeWorkspaceFocus(workspace, fallback);
+    }
+    const activePanelId = input.activePanelId;
+    const requestedPanelId = typeof activePanelId === 'string' ? activePanelId : fallback.activePanelId;
+    const validPanelId = requestedPanelId && findPanelInWorkspace(workspace, requestedPanelId)
+        ? requestedPanelId
+        : fallback.activePanelId;
+    return normalizeWorkspaceFocus(workspace, {
+        activePanelId: validPanelId
+    });
+}
+function isEnabled(options) {
+    return options.isEnabled?.() ?? true;
+}

package/dist/workbench/workbenchHistoryActions.d.ts

@@ -0,0 +1,21 @@
+import type { WorkspaceHistoryController } from "./workspaceHistoryController.js";
+export interface CreateWorkbenchHistoryActionsInput<TState, TSnapshot> {
+    workspaceHistory: WorkspaceHistoryController<TSnapshot>;
+    getWorkbenchState(): TState;
+    createHistorySnapshot(state: TState): TSnapshot;
+    restoreHistorySnapshot(snapshot: TSnapshot): TState;
+    setWorkbenchState(nextState: TState, historyScope?: 'none'): void;
+    syncHistoryStatus(): void;
+}
+export declare function createWorkbenchHistoryActions<TState, TSnapshot>(input: CreateWorkbenchHistoryActionsInput<TState, TSnapshot>): {
+    beginAppHistoryTransaction: () => void;
+    commitAppHistoryTransaction: () => void;
+    cancelAppHistoryTransaction: () => void;
+    beginCoreHistoryTransaction: () => void;
+    commitCoreHistoryTransaction: () => void;
+    cancelCoreHistoryTransaction: () => void;
+    undoAppHistory: () => void;
+    redoAppHistory: () => void;
+    undoCoreHistory: () => void;
+    redoCoreHistory: () => void;
+};

package/dist/workbench/workbenchHistoryActions.js

@@ -0,0 +1,45 @@
+export function createWorkbenchHistoryActions(input) {
+    function beginTransaction(channel) {
+        input.workspaceHistory.beginTransaction(channel, input.createHistorySnapshot(input.getWorkbenchState()));
+    }
+    function commitTransaction(channel) {
+        input.workspaceHistory.commitTransaction(channel, input.createHistorySnapshot(input.getWorkbenchState()));
+        input.syncHistoryStatus();
+    }
+    function cancelTransaction(channel) {
+        const snapshot = input.workspaceHistory.cancelTransaction(channel);
+        if (!snapshot) {
+            return;
+        }
+        input.setWorkbenchState(input.restoreHistorySnapshot(snapshot), 'none');
+        input.syncHistoryStatus();
+    }
+    function undoHistory(channel) {
+        const snapshot = input.workspaceHistory.undo(channel, input.createHistorySnapshot(input.getWorkbenchState()));
+        if (!snapshot) {
+            return;
+        }
+        input.setWorkbenchState(input.restoreHistorySnapshot(snapshot), 'none');
+        input.syncHistoryStatus();
+    }
+    function redoHistory(channel) {
+        const snapshot = input.workspaceHistory.redo(channel, input.createHistorySnapshot(input.getWorkbenchState()));
+        if (!snapshot) {
+            return;
+        }
+        input.setWorkbenchState(input.restoreHistorySnapshot(snapshot), 'none');
+        input.syncHistoryStatus();
+    }
+    return {
+        beginAppHistoryTransaction: () => beginTransaction('app'),
+        commitAppHistoryTransaction: () => commitTransaction('app'),
+        cancelAppHistoryTransaction: () => cancelTransaction('app'),
+        beginCoreHistoryTransaction: () => beginTransaction('core'),
+        commitCoreHistoryTransaction: () => commitTransaction('core'),
+        cancelCoreHistoryTransaction: () => cancelTransaction('core'),
+        undoAppHistory: () => undoHistory('app'),
+        redoAppHistory: () => redoHistory('app'),
+        undoCoreHistory: () => undoHistory('core'),
+        redoCoreHistory: () => redoHistory('core')
+    };
+}

package/dist/workbench/workbenchHistoryRuntime.d.ts

@@ -0,0 +1,16 @@
+import type { ShellState, Workspace, WorkspaceFocus } from '@konitif/workbench/workspace-contracts';
+import { type WorkbenchHistoryScope, type WorkbenchHistoryStatus } from "./workspaceHistoryController.js";
+export interface WorkbenchHistoryState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+}
+export type WorkbenchSnapshot<TState extends WorkbenchHistoryState> = Pick<TState, 'workspace' | 'focus' | 'shell'>;
+export declare function createWorkbenchHistoryRuntime<TState extends WorkbenchHistoryState>(): {
+    controller: import("./workspaceHistoryController.js").WorkspaceHistoryController<WorkbenchSnapshot<TState>>;
+    statusStore: import("svelte/store").Writable<WorkbenchHistoryStatus>;
+    createSnapshot: (state: TState) => WorkbenchSnapshot<TState>;
+    recordTransition: (previousState: TState, nextState: TState, historyScope: WorkbenchHistoryScope) => void;
+    reset: () => void;
+    syncStatus: () => void;
+};

package/dist/workbench/workbenchHistoryRuntime.js

@@ -0,0 +1,42 @@
+import { writable } from 'svelte/store';
+import { createWorkspaceHistoryController } from "./workspaceHistoryController.js";
+export function createWorkbenchHistoryRuntime() {
+    const statusStore = writable({
+        app: { canUndo: false, canRedo: false },
+        core: { canUndo: false, canRedo: false }
+    });
+    const controller = createWorkspaceHistoryController({
+        isChanged(left, right) {
+            return left.workspace !== right.workspace || left.focus !== right.focus || left.shell !== right.shell;
+        }
+    });
+    function createSnapshot(state) {
+        return {
+            workspace: state.workspace,
+            focus: state.focus,
+            shell: state.shell
+        };
+    }
+    function syncStatus() {
+        statusStore.set(controller.getStatus());
+    }
+    function recordTransition(previousState, nextState, historyScope) {
+        if (previousState === nextState || historyScope === 'none') {
+            return;
+        }
+        controller.recordTransition(createSnapshot(previousState), createSnapshot(nextState), historyScope);
+        syncStatus();
+    }
+    function reset() {
+        controller.reset();
+        syncStatus();
+    }
+    return {
+        controller,
+        statusStore,
+        createSnapshot,
+        recordTransition,
+        reset,
+        syncStatus
+    };
+}

package/dist/workbench/workbenchHostEvents.d.ts

@@ -0,0 +1,13 @@
+/** Notifications only; the persistence coordinator owns admission and effects. */
+export interface WorkbenchHostStorageChange {
+    key: string | null;
+    newValue: string | null;
+}
+export interface WorkbenchHostEventHandlers {
+    onPersistenceBoundary(): void;
+    onStorageChange(event: WorkbenchHostStorageChange): void;
+}
+export interface WorkbenchHostEvents {
+    /** Own only this subscription. Return an idempotent unsubscribe function. */
+    subscribe(handlers: WorkbenchHostEventHandlers): () => void;
+}

package/dist/workbench/workbenchHostEvents.js

@@ -0,0 +1 @@
+export {};