@konitif/workbench 0.284.1

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

@@ -0,0 +1,34 @@
+import type { LayoutNode, SplitNode, StackNode } from "../../domain/layout/model.js";
+import type { PanelNode } from "../../domain/panel/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export interface LayoutNodePathEntry {
+    split: SplitNode;
+    childIndex: 0 | 1;
+}
+export interface StackPanelPath {
+    stack: StackNode;
+    trail: LayoutNodePathEntry[];
+}
+export interface LayoutNodePath {
+    node: LayoutNode;
+    trail: LayoutNodePathEntry[];
+}
+export interface PanelPath {
+    panel: PanelNode;
+    stack: StackNode;
+    panelIndex: number;
+    trail: LayoutNodePathEntry[];
+}
+export declare function updateActiveWindowRoot(workspace: Workspace, updater: (root: LayoutNode) => LayoutNode): Workspace;
+export declare function containsPanel(node: LayoutNode, panelId: string): boolean;
+export declare function updateStackById(node: LayoutNode, stackId: string, updater: (stack: StackNode) => StackNode): LayoutNode;
+export declare function updateSplitById(node: LayoutNode, splitId: string, updater: (split: SplitNode) => SplitNode): LayoutNode;
+export declare function updatePanelById(node: LayoutNode, panelId: string, updater: (panel: PanelNode) => PanelNode): LayoutNode;
+export declare function replaceStackContainingPanel(node: LayoutNode, panelId: string, updater: (stack: StackNode) => LayoutNode): LayoutNode;
+export declare function findStackPathContainingPanel(node: LayoutNode, panelId: string, trail?: LayoutNodePathEntry[]): StackPanelPath | null;
+export declare function findLayoutNodePathById(node: LayoutNode, nodeId: string, trail?: LayoutNodePathEntry[]): LayoutNodePath | null;
+export declare function findStackPathById(node: LayoutNode, stackId: string): LayoutNodePath | null;
+export declare function findSplitPathById(node: LayoutNode, splitId: string): LayoutNodePath | null;
+export declare function findPanelPathById(node: LayoutNode, panelId: string, trail?: LayoutNodePathEntry[]): PanelPath | null;
+export declare function replaceNodeAtPath(root: LayoutNode, trail: LayoutNodePathEntry[], replacement: LayoutNode): LayoutNode;
+export declare function replaceNodeAtPathAllowingRemoval(root: LayoutNode, trail: LayoutNodePathEntry[], replacement: LayoutNode | null): LayoutNode | null;

package/dist/application/workspace/layoutTree.js

@@ -0,0 +1,135 @@
+import { containsPanel as layoutContainsPanel } from "../../domain/layout/selectors.js";
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+export function updateActiveWindowRoot(workspace, updater) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow) {
+        return workspace;
+    }
+    return {
+        ...workspace,
+        windows: workspace.windows.map((window) => window.id === activeWindow.id ? { ...window, root: updater(window.root) } : window)
+    };
+}
+export function containsPanel(node, panelId) {
+    return layoutContainsPanel(node, panelId);
+}
+export function updateStackById(node, stackId, updater) {
+    const stackPath = findStackPathById(node, stackId);
+    if (!stackPath || stackPath.node.kind !== 'stack') {
+        return node;
+    }
+    return replaceNodeAtPath(node, stackPath.trail, updater(stackPath.node));
+}
+export function updateSplitById(node, splitId, updater) {
+    const splitPath = findSplitPathById(node, splitId);
+    if (!splitPath || splitPath.node.kind !== 'split') {
+        return node;
+    }
+    return replaceNodeAtPath(node, splitPath.trail, updater(splitPath.node));
+}
+export function updatePanelById(node, panelId, updater) {
+    const panelPath = findPanelPathById(node, panelId);
+    if (!panelPath) {
+        return node;
+    }
+    const nextChildren = [...panelPath.stack.children];
+    nextChildren[panelPath.panelIndex] = updater(panelPath.panel);
+    return replaceNodeAtPath(node, panelPath.trail, {
+        ...panelPath.stack,
+        children: nextChildren
+    });
+}
+export function replaceStackContainingPanel(node, panelId, updater) {
+    const stackPath = findStackPathContainingPanel(node, panelId);
+    if (!stackPath) {
+        return node;
+    }
+    return replaceNodeAtPath(node, stackPath.trail, updater(stackPath.stack));
+}
+export function findStackPathContainingPanel(node, panelId, trail = []) {
+    if (node.kind === 'stack') {
+        return node.children.some((panel) => panel.id === panelId)
+            ? {
+                stack: node,
+                trail
+            }
+            : null;
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        const path = findStackPathContainingPanel(child, panelId, [...trail, { split: node, childIndex }]);
+        if (path) {
+            return path;
+        }
+    }
+    return null;
+}
+export function findLayoutNodePathById(node, nodeId, trail = []) {
+    if (node.id === nodeId) {
+        return {
+            node,
+            trail
+        };
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        const path = findLayoutNodePathById(child, nodeId, [...trail, { split: node, childIndex }]);
+        if (path) {
+            return path;
+        }
+    }
+    return null;
+}
+export function findStackPathById(node, stackId) {
+    const path = findLayoutNodePathById(node, stackId);
+    return path?.node.kind === 'stack' ? path : null;
+}
+export function findSplitPathById(node, splitId) {
+    const path = findLayoutNodePathById(node, splitId);
+    return path?.node.kind === 'split' ? path : null;
+}
+export function findPanelPathById(node, panelId, trail = []) {
+    if (node.kind === 'stack') {
+        const panelIndex = node.children.findIndex((panel) => panel.id === panelId);
+        return panelIndex === -1
+            ? null
+            : {
+                panel: node.children[panelIndex],
+                stack: node,
+                panelIndex,
+                trail
+            };
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        const path = findPanelPathById(child, panelId, [...trail, { split: node, childIndex }]);
+        if (path) {
+            return path;
+        }
+    }
+    return null;
+}
+export function replaceNodeAtPath(root, trail, replacement) {
+    return replaceNodeAtPathAllowingRemoval(root, trail, replacement) ?? root;
+}
+export function replaceNodeAtPathAllowingRemoval(root, trail, replacement) {
+    let nextNode = replacement;
+    for (let index = trail.length - 1; index >= 0; index -= 1) {
+        const { split, childIndex } = trail[index];
+        const siblingIndex = childIndex === 0 ? 1 : 0;
+        const sibling = split.children[siblingIndex];
+        if (!nextNode) {
+            nextNode = sibling;
+            continue;
+        }
+        const nextChildren = childIndex === 0 ? [nextNode, sibling] : [sibling, nextNode];
+        nextNode = {
+            ...split,
+            children: nextChildren
+        };
+    }
+    return nextNode;
+}

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

@@ -0,0 +1,15 @@
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface OpenToolInput {
+    panelId: string;
+    toolId: string;
+    singletonPlacement?: 'focus-existing' | 'move-to-panel';
+}
+export interface OpenToolResult {
+    workspace: Workspace;
+    panelId: string | null;
+    toolInstanceId: string | null;
+    reusedExisting: boolean;
+}
+export declare function openTool(workspace: Workspace, input: OpenToolInput, toolCatalog: ToolCatalogPort): OpenToolResult;
+export {};

package/dist/application/workspace/openTool.js

@@ -0,0 +1,89 @@
+import { createInitialToolShellState, resolvePanelTitle } from "../../domain/tool/shell.js";
+import { createId } from "../../domain/shared/id.js";
+import { cloneJsonObject } from "../../domain/shared/json.js";
+import { containsPanel } from "../../domain/layout/selectors.js";
+import { findToolPlacementByToolId, getActiveWindow } from "../../domain/workspace/selectors.js";
+import { pruneUnusedToolInstances } from "./finalizeWorkspace.js";
+import { updateActiveWindowRoot, updatePanelById } from "./layoutTree.js";
+export function openTool(workspace, input, toolCatalog) {
+    const toolDefinition = toolCatalog.getDefinition(input.toolId);
+    const activeWindow = getActiveWindow(workspace);
+    if (!toolDefinition || !activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return {
+            workspace,
+            panelId: null,
+            toolInstanceId: null,
+            reusedExisting: false
+        };
+    }
+    const existingPlacement = findToolPlacementByToolId(workspace, input.toolId);
+    if (toolDefinition.openingPolicy.mode === 'singleton-global' &&
+        existingPlacement &&
+        input.singletonPlacement !== 'move-to-panel') {
+        return {
+            workspace,
+            panelId: existingPlacement.panelId,
+            toolInstanceId: existingPlacement.toolInstanceId,
+            reusedExisting: true
+        };
+    }
+    if (toolDefinition.openingPolicy.mode === 'singleton-global' &&
+        existingPlacement &&
+        input.singletonPlacement === 'move-to-panel') {
+        const nextWorkspace = moveExistingToolInstanceToPanel(workspace, {
+            sourcePanelId: existingPlacement.panelId,
+            targetPanelId: input.panelId,
+            toolInstanceId: existingPlacement.toolInstanceId,
+            panelTitle: resolvePanelTitle(toolDefinition, existingPlacement.toolInstance)
+        });
+        return {
+            workspace: pruneUnusedToolInstances(nextWorkspace),
+            panelId: input.panelId,
+            toolInstanceId: existingPlacement.toolInstanceId,
+            reusedExisting: true
+        };
+    }
+    const toolInstance = {
+        id: createId('tool-instance'),
+        toolId: toolDefinition.id,
+        state: cloneJsonObject(toolDefinition.initialState),
+        panelTitleOverride: null,
+        shellState: createInitialToolShellState(toolDefinition)
+    };
+    const nextWorkspace = updateActiveWindowRoot({
+        ...workspace,
+        toolInstances: {
+            ...workspace.toolInstances,
+            [toolInstance.id]: toolInstance
+        }
+    }, (root) => updatePanelById(root, input.panelId, (panel) => ({
+        ...panel,
+        title: resolvePanelTitle(toolDefinition, toolInstance),
+        toolInstanceId: toolInstance.id
+    })));
+    return {
+        workspace: pruneUnusedToolInstances(nextWorkspace),
+        panelId: input.panelId,
+        toolInstanceId: toolInstance.id,
+        reusedExisting: false
+    };
+}
+function moveExistingToolInstanceToPanel(workspace, input) {
+    return {
+        ...workspace,
+        windows: workspace.windows.map((window) => ({
+            ...window,
+            root: updatePanelById(updatePanelById(window.root, input.sourcePanelId, (panel) => panel.id === input.targetPanelId
+                ? panel
+                : {
+                    ...panel,
+                    title: 'New panel',
+                    toolInstanceId: null
+                }), input.targetPanelId, (panel) => ({
+                ...panel,
+                title: input.panelTitle,
+                toolInstanceId: input.toolInstanceId
+            }))
+        }))
+    };
+}

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

@@ -0,0 +1,60 @@
+import type { ShellState } from "../../domain/shell/model.js";
+import type { WorkspaceSessionState } from "../../domain/workspace/session.js";
+export declare const WORKSPACE_PRESET_ARTIFACT_SCHEMA: "konitif.workspace-preset";
+export declare const WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION: 1;
+export interface WorkspacePresetCompatibility {
+    fixtureSchemaVersions: string[];
+    projectSchemaVersions: string[];
+}
+export interface WorkspacePresetCatalogMetadata {
+    label: string;
+    description: string;
+    icon: string;
+}
+export interface WorkspacePresetArtifact {
+    schema: typeof WORKSPACE_PRESET_ARTIFACT_SCHEMA;
+    schemaVersion: typeof WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION;
+    id: string;
+    name: string;
+    version: string;
+    catalog: WorkspacePresetCatalogMetadata;
+    compatibility: WorkspacePresetCompatibility;
+    workspaceSession: WorkspaceSessionState;
+    shellState: ShellState;
+}
+export type WorkspacePresetDiagnosticCode = 'workspace-preset.invalid-json' | 'workspace-preset.invalid-schema' | 'workspace-preset.invalid-id' | 'workspace-preset.invalid-name' | 'workspace-preset.invalid-version' | 'workspace-preset.invalid-catalog' | 'workspace-preset.invalid-compatibility' | 'workspace-preset.invalid-workspace' | 'workspace-preset.invalid-focus' | 'workspace-preset.invalid-shell' | 'workspace-preset.fixture-schema-incompatible' | 'workspace-preset.project-schema-incompatible';
+export interface WorkspacePresetDiagnostic {
+    code: WorkspacePresetDiagnosticCode;
+    path: string;
+    message: string;
+}
+export interface AuthorWorkspacePresetInput {
+    id: string;
+    name: string;
+    version: string;
+    catalog?: Partial<WorkspacePresetCatalogMetadata>;
+    compatibility: WorkspacePresetCompatibility;
+    workspaceSession: WorkspaceSessionState;
+    shellState: ShellState;
+}
+export type WorkspacePresetResult = {
+    ok: true;
+    artifact: WorkspacePresetArtifact;
+    diagnostics: [];
+} | {
+    ok: false;
+    artifact?: undefined;
+    diagnostics: WorkspacePresetDiagnostic[];
+};
+export interface WorkspacePresetCompatibilityRequest {
+    fixtureSchemaVersion?: string | null;
+    projectSchemaVersion?: string | null;
+}
+export declare function authorWorkspacePreset(input: AuthorWorkspacePresetInput): WorkspacePresetResult;
+export declare function serializeWorkspacePresetArtifact(artifact: WorkspacePresetArtifact): string;
+export declare function importWorkspacePresetArtifact(source: string, compatibilityRequest?: WorkspacePresetCompatibilityRequest): WorkspacePresetResult;
+export declare function evaluateWorkspacePresetCompatibility(artifact: WorkspacePresetArtifact, request: WorkspacePresetCompatibilityRequest): WorkspacePresetDiagnostic[];
+export declare function validateWorkspacePresetArtifact(value: unknown): WorkspacePresetDiagnostic[];
+export declare function projectWorkspacePresetCatalogMetadata(artifact: WorkspacePresetArtifact): WorkspacePresetCatalogMetadata & {
+    id: string;
+};

package/dist/application/workspace/presetArtifacts.js

@@ -0,0 +1,231 @@
+import { validateWorkspaceSnapshot } from "../../domain/workspace/validation.js";
+import { createWorkspaceSessionState } from "./session.js";
+export const WORKSPACE_PRESET_ARTIFACT_SCHEMA = 'konitif.workspace-preset';
+export const WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION = 1;
+const PRESET_ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+const PRESET_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const SHELL_REGION_IDS = ['left', 'right', 'bottom'];
+export function authorWorkspacePreset(input) {
+    const artifact = {
+        schema: WORKSPACE_PRESET_ARTIFACT_SCHEMA,
+        schemaVersion: WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION,
+        id: input.id.trim(),
+        name: input.name.trim(),
+        version: input.version.trim(),
+        catalog: normalizeCatalogMetadata(input.name, input.catalog),
+        compatibility: normalizeCompatibility(input.compatibility),
+        workspaceSession: createWorkspaceSessionState(input.workspaceSession.workspace, input.workspaceSession.focus),
+        shellState: input.shellState
+    };
+    const diagnostics = validateWorkspacePresetArtifact(artifact);
+    return diagnostics.length > 0
+        ? { ok: false, diagnostics }
+        : { ok: true, artifact: cloneCanonicalValue(artifact), diagnostics: [] };
+}
+export function serializeWorkspacePresetArtifact(artifact) {
+    const diagnostics = validateWorkspacePresetArtifact(artifact);
+    if (diagnostics.length > 0) {
+        throw new Error(diagnostics[0]?.message ?? 'Workspace preset artifact is invalid.');
+    }
+    return `${JSON.stringify(sortCanonicalValue(artifact), null, 2)}\n`;
+}
+export function importWorkspacePresetArtifact(source, compatibilityRequest = {}) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        return {
+            ok: false,
+            diagnostics: [diagnostic('workspace-preset.invalid-json', '$', 'Workspace preset must be valid JSON.')]
+        };
+    }
+    const migrated = migrateWorkspacePresetArtifact(parsed);
+    const diagnostics = validateWorkspacePresetArtifact(migrated);
+    if (diagnostics.length > 0) {
+        return { ok: false, diagnostics };
+    }
+    const artifact = cloneCanonicalValue(migrated);
+    const compatibilityDiagnostics = evaluateWorkspacePresetCompatibility(artifact, compatibilityRequest);
+    return compatibilityDiagnostics.length > 0
+        ? { ok: false, diagnostics: compatibilityDiagnostics }
+        : { ok: true, artifact, diagnostics: [] };
+}
+export function evaluateWorkspacePresetCompatibility(artifact, request) {
+    const diagnostics = [];
+    const fixtureSchemaVersion = request.fixtureSchemaVersion?.trim();
+    const projectSchemaVersion = request.projectSchemaVersion?.trim();
+    if (fixtureSchemaVersion && !artifact.compatibility.fixtureSchemaVersions.includes(fixtureSchemaVersion)) {
+        diagnostics.push(diagnostic('workspace-preset.fixture-schema-incompatible', '$.compatibility.fixtureSchemaVersions', `Preset ${artifact.id}@${artifact.version} does not support fixture schema ${fixtureSchemaVersion}. Supported versions: ${formatSupportedVersions(artifact.compatibility.fixtureSchemaVersions)}.`));
+    }
+    if (projectSchemaVersion && !artifact.compatibility.projectSchemaVersions.includes(projectSchemaVersion)) {
+        diagnostics.push(diagnostic('workspace-preset.project-schema-incompatible', '$.compatibility.projectSchemaVersions', `Preset ${artifact.id}@${artifact.version} does not support project schema ${projectSchemaVersion}. Supported versions: ${formatSupportedVersions(artifact.compatibility.projectSchemaVersions)}.`));
+    }
+    return diagnostics;
+}
+export function validateWorkspacePresetArtifact(value) {
+    if (!isRecord(value)) {
+        return [diagnostic('workspace-preset.invalid-schema', '$', 'Workspace preset must be an object.')];
+    }
+    const diagnostics = [];
+    if (value.schema !== WORKSPACE_PRESET_ARTIFACT_SCHEMA ||
+        value.schemaVersion !== WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION) {
+        diagnostics.push(diagnostic('workspace-preset.invalid-schema', '$.schema', `Workspace preset must use ${WORKSPACE_PRESET_ARTIFACT_SCHEMA} schema version ${WORKSPACE_PRESET_ARTIFACT_SCHEMA_VERSION}.`));
+    }
+    if (typeof value.id !== 'string' || !PRESET_ID_PATTERN.test(value.id)) {
+        diagnostics.push(diagnostic('workspace-preset.invalid-id', '$.id', 'Workspace preset id must be a lowercase dot-or-dash identifier.'));
+    }
+    if (typeof value.name !== 'string' || value.name.trim().length < 2 || value.name.trim().length > 80) {
+        diagnostics.push(diagnostic('workspace-preset.invalid-name', '$.name', 'Workspace preset name must contain 2 to 80 characters.'));
+    }
+    if (typeof value.version !== 'string' || !PRESET_VERSION_PATTERN.test(value.version)) {
+        diagnostics.push(diagnostic('workspace-preset.invalid-version', '$.version', 'Workspace preset version must use semantic versioning.'));
+    }
+    diagnostics.push(...validateCatalogMetadata(value.catalog));
+    diagnostics.push(...validateCompatibility(value.compatibility));
+    diagnostics.push(...validateWorkspaceSession(value.workspaceSession));
+    diagnostics.push(...validateShellState(value.shellState));
+    return diagnostics;
+}
+export function projectWorkspacePresetCatalogMetadata(artifact) {
+    return {
+        id: artifact.id,
+        ...cloneCanonicalValue(artifact.catalog)
+    };
+}
+function validateCatalogMetadata(value) {
+    if (!isRecord(value) ||
+        typeof value.label !== 'string' ||
+        value.label.trim().length < 2 ||
+        value.label.trim().length > 80 ||
+        typeof value.description !== 'string' ||
+        value.description.trim().length < 2 ||
+        value.description.trim().length > 240 ||
+        typeof value.icon !== 'string' ||
+        value.icon.trim().length < 2 ||
+        value.icon.trim().length > 80) {
+        return [
+            diagnostic('workspace-preset.invalid-catalog', '$.catalog', 'Workspace preset catalog metadata must provide a label, description, and icon.')
+        ];
+    }
+    return [];
+}
+function normalizeCatalogMetadata(name, value) {
+    const normalizedName = name.trim();
+    return {
+        label: value?.label?.trim() || normalizedName,
+        description: value?.description?.trim() || `${normalizedName} workspace preset.`,
+        icon: value?.icon?.trim() || 'layout.workspace'
+    };
+}
+function migrateWorkspacePresetArtifact(value) {
+    if (!isRecord(value) || value.catalog !== undefined) {
+        return value;
+    }
+    const name = typeof value.name === 'string' ? value.name : '';
+    return {
+        ...value,
+        catalog: normalizeCatalogMetadata(name, undefined)
+    };
+}
+function validateCompatibility(value) {
+    if (!isRecord(value)) {
+        return [
+            diagnostic('workspace-preset.invalid-compatibility', '$.compatibility', 'Workspace preset compatibility must be an object.')
+        ];
+    }
+    const fixtureVersions = validateVersionList(value.fixtureSchemaVersions);
+    const projectVersions = validateVersionList(value.projectSchemaVersions);
+    return fixtureVersions && projectVersions
+        ? []
+        : [
+            diagnostic('workspace-preset.invalid-compatibility', '$.compatibility', 'Workspace preset compatibility must declare non-empty unique fixture and project schema version lists.')
+        ];
+}
+function validateWorkspaceSession(value) {
+    if (!isRecord(value) || !isRecord(value.focus)) {
+        return [
+            diagnostic('workspace-preset.invalid-workspace', '$.workspaceSession', 'Workspace preset must contain a workspace session and focus state.')
+        ];
+    }
+    const workspaceIssues = validateWorkspaceSnapshot(value.workspace);
+    if (workspaceIssues.length > 0) {
+        return workspaceIssues.map((issue) => diagnostic('workspace-preset.invalid-workspace', `$.workspaceSession.${issue.path}`, issue.message));
+    }
+    const normalized = createWorkspaceSessionState(value.workspace, value.focus);
+    if (value.focus.activePanelId !== normalized.focus.activePanelId ||
+        value.focus.activeToolInstanceId !== normalized.focus.activeToolInstanceId) {
+        return [
+            diagnostic('workspace-preset.invalid-focus', '$.workspaceSession.focus', 'Workspace preset focus must reference the focused panel and its tool instance.')
+        ];
+    }
+    return [];
+}
+function validateShellState(value) {
+    if (!isRecord(value) || !isRecord(value.regions)) {
+        return [
+            diagnostic('workspace-preset.invalid-shell', '$.shellState', 'Workspace preset must contain shell regions.')
+        ];
+    }
+    for (const regionId of SHELL_REGION_IDS) {
+        const region = value.regions[regionId];
+        if (!isRecord(region) ||
+            region.id !== regionId ||
+            typeof region.isVisible !== 'boolean' ||
+            typeof region.isOpen !== 'boolean' ||
+            typeof region.size !== 'number' ||
+            !Number.isFinite(region.size) ||
+            !Array.isArray(region.widgetIds) ||
+            !region.widgetIds.every((widgetId) => typeof widgetId === 'string') ||
+            (region.activeWidgetId !== null && typeof region.activeWidgetId !== 'string')) {
+            return [
+                diagnostic('workspace-preset.invalid-shell', `$.shellState.regions.${regionId}`, `Workspace preset shell region ${regionId} is incomplete or invalid.`)
+            ];
+        }
+        if (region.activeWidgetId && !region.widgetIds.includes(region.activeWidgetId)) {
+            return [
+                diagnostic('workspace-preset.invalid-shell', `$.shellState.regions.${regionId}.activeWidgetId`, `Workspace preset shell region ${regionId} must activate one of its declared widgets.`)
+            ];
+        }
+    }
+    return [];
+}
+function validateVersionList(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((entry) => typeof entry === 'string' && entry.trim().length > 0) &&
+        new Set(value).size === value.length);
+}
+function normalizeCompatibility(value) {
+    return {
+        fixtureSchemaVersions: normalizeVersionList(value.fixtureSchemaVersions),
+        projectSchemaVersions: normalizeVersionList(value.projectSchemaVersions)
+    };
+}
+function normalizeVersionList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right, 'en'));
+}
+function formatSupportedVersions(values) {
+    return values.length > 0 ? values.join(', ') : 'none';
+}
+function diagnostic(code, path, message) {
+    return { code, path, message };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneCanonicalValue(value) {
+    return JSON.parse(JSON.stringify(sortCanonicalValue(value)));
+}
+function sortCanonicalValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortCanonicalValue);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(value)
+        .sort((left, right) => left.localeCompare(right, 'en'))
+        .filter((key) => value[key] !== undefined)
+        .map((key) => [key, sortCanonicalValue(value[key])]));
+}

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

@@ -0,0 +1,5 @@
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import { type WorkspaceSessionState } from "./session.js";
+export type WorkspacePresetId = 'default';
+export declare function createWorkspaceFromPreset(toolCatalog: ToolCatalogPort, presetId?: WorkspacePresetId): import("../../index.js").Workspace;
+export declare function createWorkspaceSessionFromPreset(toolCatalog: ToolCatalogPort, presetId?: WorkspacePresetId): WorkspaceSessionState;

package/dist/application/workspace/presets.js

@@ -0,0 +1,12 @@
+import { createWorkspaceSessionState } from "./session.js";
+import { createWorkspace } from "./createWorkspace.js";
+const DEFAULT_WORKSPACE_INITIAL_TOOL_ID = 'example.welcome';
+export function createWorkspaceFromPreset(toolCatalog, presetId = 'default') {
+    switch (presetId) {
+        case 'default':
+            return createWorkspace(toolCatalog, { initialToolId: DEFAULT_WORKSPACE_INITIAL_TOOL_ID });
+    }
+}
+export function createWorkspaceSessionFromPreset(toolCatalog, presetId = 'default') {
+    return createWorkspaceSessionState(createWorkspaceFromPreset(toolCatalog, presetId));
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+/** Recover the current detached layout, never a snapshot captured before detaching. */
+export declare function reattachWorkspaceWindow(workspace: Workspace, input: {
+    windowId: string;
+    sourceWindowId: string;
+    sourceStackId: string;
+}): Workspace;

package/dist/application/workspace/reattachWorkspaceWindow.js

@@ -0,0 +1,24 @@
+import { createSplit } from "../../domain/workspace/factories.js";
+import { findStackPathById, updateStackById } from "./layoutTree.js";
+/** Recover the current detached layout, never a snapshot captured before detaching. */
+export function reattachWorkspaceWindow(workspace, input) {
+    const detached = workspace.windows.find((entry) => entry.id === input.windowId);
+    const source = workspace.windows.find((entry) => entry.id === input.sourceWindowId);
+    if (!detached || !source || detached.id === source.id)
+        return workspace;
+    const detachedRoot = detached.root;
+    const stackExists = findStackPathById(source.root, input.sourceStackId);
+    const root = detachedRoot.kind === 'stack' && stackExists
+        ? updateStackById(source.root, input.sourceStackId, (stack) => ({
+            ...stack,
+            children: [...stack.children, ...detachedRoot.children],
+            activeChildId: detachedRoot.activeChildId
+        }))
+        : createSplit('horizontal', [source.root, detachedRoot]);
+    return {
+        ...workspace,
+        activeWindowId: source.id,
+        windows: workspace.windows.filter((entry) => entry.id !== detached.id)
+            .map((entry) => entry.id === source.id ? { ...entry, root } : entry)
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface ResizeSplitInput {
+    splitId: string;
+    sizes: [number, number];
+}
+export declare function resizeSplit(workspace: Workspace, input: ResizeSplitInput): Workspace;
+export {};

package/dist/application/workspace/resizeSplit.js

@@ -0,0 +1,12 @@
+import { normalizeSplitSizes } from "../../domain/layout/validation.js";
+import { updateActiveWindowRoot, updateSplitById } from "./layoutTree.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+export function resizeSplit(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.splitId, (selected) => resizeSplitInActiveWindow(selected, input));
+}
+function resizeSplitInActiveWindow(workspace, input) {
+    return updateActiveWindowRoot(workspace, (root) => updateSplitById(root, input.splitId, (split) => ({
+        ...split,
+        sizes: normalizeSplitSizes(input.sizes)
+    })));
+}

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

@@ -0,0 +1,10 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+export type ResizeSplitBoundaryMode = 'local' | 'proportional';
+interface ResizeSplitBoundaryInput {
+    rootSplitId: string;
+    boundaryIndex: number;
+    deltaRatio: number;
+    mode?: ResizeSplitBoundaryMode;
+}
+export declare function resizeSplitBoundary(workspace: Workspace, input: ResizeSplitBoundaryInput): Workspace;
+export {};