@konitif/workbench 0.284.1

package/dist/application/runtime/WorkbenchRuntimeSanitizers.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeInspectableStatus } from "../../domain/runtime/model.js";
+import type { JsonValue } from "../../domain/shared/json.js";
+export declare function normalizeRuntimeObjectSnapshot(value: unknown): Record<string, unknown>;
+export declare function normalizeRuntimeInspectableStatus(value: unknown): RuntimeInspectableStatus | null;
+export declare function normalizeRuntimeStringArray(value: unknown): string[] | null;
+export declare function normalizeRuntimeNullableString(value: unknown): string | null;
+export declare function sanitizeRuntimeJson(value: unknown, depth?: number): JsonValue;
+export declare function sanitizeRuntimeText(value: string, maxLength?: number): string;
+export declare function isJsonValue(value: unknown): value is JsonValue;

package/dist/application/runtime/WorkbenchRuntimeSanitizers.js

@@ -0,0 +1,62 @@
+export function normalizeRuntimeObjectSnapshot(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function normalizeRuntimeInspectableStatus(value) {
+    return value === 'active' || value === 'idle' || value === 'degraded' || value === 'error' || value === 'unknown'
+        ? value
+        : null;
+}
+export function normalizeRuntimeStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string').map((entry) => sanitizeRuntimeText(entry, 120))
+        : null;
+}
+export function normalizeRuntimeNullableString(value) {
+    return typeof value === 'string' ? sanitizeRuntimeText(value, 500) : null;
+}
+export function sanitizeRuntimeJson(value, depth = 0) {
+    if (value === null || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return sanitizeRuntimeText(value);
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 4) {
+            return `[Array(${value.length})]`;
+        }
+        return value.slice(0, 50).map((entry) => sanitizeRuntimeJson(entry, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+        if (depth >= 4) {
+            return '[Object]';
+        }
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 50)
+            .map(([key, entry]) => [sanitizeRuntimeText(key, 120), sanitizeRuntimeJson(entry, depth + 1)]));
+    }
+    return null;
+}
+export function sanitizeRuntimeText(value, maxLength = 2000) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}…`;
+}
+export function isJsonValue(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}

package/dist/application/shell/state.d.ts

@@ -0,0 +1,22 @@
+import type { ShellState, ShellRegionId, ShellRegionState, ShellRegionAxis, ShellRegionPresentation, ShellWidgetCatalogPort, ShellWidgetPlacement } from "../../domain/shell/model.js";
+export declare const DEFAULT_SHELL_REGION_SIZES: Record<ShellRegionId, number>;
+export declare const MIN_SHELL_REGION_SIZES: Record<ShellRegionId, number>;
+export declare const SHELL_REGION_RESIZE_CLOSE_OFFSET_PX = 32;
+export declare function resolveShellRegionPresentation(region: ShellRegionState): ShellRegionPresentation;
+export declare function resolveShellRegionAxis(region: ShellRegionState): ShellRegionAxis;
+export declare function isShellRegionWidgetVisible(region: ShellRegionState, widgetId: string): boolean;
+export declare function listVisibleShellRegionWidgetIds(region: ShellRegionState): string[];
+export declare function setShellRegionArrangement(shellState: ShellState, regionId: ShellRegionId, presentation: ShellRegionPresentation, axis?: ShellRegionAxis): ShellState;
+export declare function createShellState(widgetCatalog: ShellWidgetCatalogPort, options?: {
+    openRegionIds?: ShellRegionId[];
+}): ShellState;
+export declare function setShellRegionVisible(shellState: ShellState, regionId: ShellRegionId, isVisible: boolean): ShellState;
+export declare function setShellRegionOpen(shellState: ShellState, regionId: ShellRegionId, isOpen: boolean): ShellState;
+export declare function toggleShellRegionOpen(shellState: ShellState, regionId: ShellRegionId): ShellState;
+export declare function setShellRegionSize(shellState: ShellState, regionId: ShellRegionId, size: number): ShellState;
+export declare function shouldCloseShellRegionFromResize(regionId: ShellRegionId, requestedSize: number): boolean;
+export declare function activateShellWidget(shellState: ShellState, regionId: ShellRegionId, widgetId: string): ShellState;
+export declare function setShellRegionWidgetVisible(shellState: ShellState, regionId: ShellRegionId, widgetId: string, isVisible: boolean): ShellState;
+export declare function addShellWidgetToRegion(shellState: ShellState, regionId: ShellRegionId, widgetId: string, placement?: ShellWidgetPlacement): ShellState;
+export declare function moveShellWidgetToRegion(shellState: ShellState, targetRegionId: ShellRegionId, widgetId: string, placement?: ShellWidgetPlacement): ShellState;
+export declare function removeShellWidgetFromRegion(shellState: ShellState, regionId: ShellRegionId, widgetId: string): ShellState;

package/dist/application/shell/state.js

@@ -0,0 +1,308 @@
+import { hasDockPlacement, insertDockableEntityId } from "../../domain/composition/docking.js";
+export const DEFAULT_SHELL_REGION_SIZES = {
+    left: 240,
+    right: 320,
+    bottom: 220
+};
+export const MIN_SHELL_REGION_SIZES = {
+    left: 180,
+    right: 180,
+    bottom: 124
+};
+export const SHELL_REGION_RESIZE_CLOSE_OFFSET_PX = 32;
+export function resolveShellRegionPresentation(region) {
+    return region.presentation ?? 'tabs';
+}
+export function resolveShellRegionAxis(region) {
+    return region.axis ?? (region.id === 'bottom' ? 'horizontal' : 'vertical');
+}
+export function isShellRegionWidgetVisible(region, widgetId) {
+    return region.widgetIds.includes(widgetId) && !(region.hiddenWidgetIds ?? []).includes(widgetId);
+}
+export function listVisibleShellRegionWidgetIds(region) {
+    const hiddenWidgetIds = new Set(region.hiddenWidgetIds ?? []);
+    return region.widgetIds.filter((widgetId) => !hiddenWidgetIds.has(widgetId));
+}
+export function setShellRegionArrangement(shellState, regionId, presentation, axis) {
+    const region = shellState.regions[regionId];
+    if (!region) {
+        return shellState;
+    }
+    const nextAxis = axis ?? resolveShellRegionAxis(region);
+    if (resolveShellRegionPresentation(region) === presentation && resolveShellRegionAxis(region) === nextAxis) {
+        return shellState;
+    }
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        presentation,
+        axis: nextAxis
+    });
+}
+export function createShellState(widgetCatalog, options = {}) {
+    return {
+        regions: {
+            left: createShellRegionState('left', widgetCatalog, options),
+            right: createShellRegionState('right', widgetCatalog, options),
+            bottom: createShellRegionState('bottom', widgetCatalog, options)
+        }
+    };
+}
+export function setShellRegionVisible(shellState, regionId, isVisible) {
+    const region = shellState.regions[regionId];
+    if (!region || region.isVisible === isVisible) {
+        return shellState;
+    }
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        isVisible
+    });
+}
+export function setShellRegionOpen(shellState, regionId, isOpen) {
+    const region = shellState.regions[regionId];
+    if (!region || region.isOpen === isOpen) {
+        return shellState;
+    }
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        isOpen
+    });
+}
+export function toggleShellRegionOpen(shellState, regionId) {
+    const region = shellState.regions[regionId];
+    return region ? setShellRegionOpen(shellState, regionId, !region.isOpen) : shellState;
+}
+export function setShellRegionSize(shellState, regionId, size) {
+    const region = shellState.regions[regionId];
+    if (!region || !Number.isFinite(size)) {
+        return shellState;
+    }
+    const normalizedSize = Math.max(MIN_SHELL_REGION_SIZES[regionId], Math.round(size));
+    if (region.size === normalizedSize) {
+        return shellState;
+    }
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        size: normalizedSize
+    });
+}
+export function shouldCloseShellRegionFromResize(regionId, requestedSize) {
+    if (!Number.isFinite(requestedSize)) {
+        return false;
+    }
+    return Math.round(requestedSize) <= MIN_SHELL_REGION_SIZES[regionId] - SHELL_REGION_RESIZE_CLOSE_OFFSET_PX;
+}
+export function activateShellWidget(shellState, regionId, widgetId) {
+    const region = shellState.regions[regionId];
+    if (!region || !region.widgetIds.includes(widgetId)) {
+        return shellState;
+    }
+    if (region.activeWidgetId === widgetId &&
+        region.isVisible &&
+        region.isOpen &&
+        isShellRegionWidgetVisible(region, widgetId)) {
+        return shellState;
+    }
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        isVisible: true,
+        isOpen: true,
+        activeWidgetId: widgetId,
+        hiddenWidgetIds: (region.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== widgetId)
+    });
+}
+export function setShellRegionWidgetVisible(shellState, regionId, widgetId, isVisible) {
+    const region = shellState.regions[regionId];
+    if (!region || !region.widgetIds.includes(widgetId)) {
+        return shellState;
+    }
+    const currentlyVisible = isShellRegionWidgetVisible(region, widgetId);
+    if (currentlyVisible === isVisible) {
+        return isVisible && (!region.isVisible || !region.isOpen || region.activeWidgetId !== widgetId)
+            ? activateShellWidget(shellState, regionId, widgetId)
+            : shellState;
+    }
+    const hiddenWidgetIds = isVisible
+        ? (region.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== widgetId)
+        : [...new Set([...(region.hiddenWidgetIds ?? []), widgetId])];
+    const visibleWidgetIds = region.widgetIds.filter((candidateId) => !hiddenWidgetIds.includes(candidateId));
+    const activeWidgetId = visibleWidgetIds.includes(region.activeWidgetId ?? '')
+        ? region.activeWidgetId
+        : visibleWidgetIds[0] ?? null;
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        isVisible: visibleWidgetIds.length > 0 ? (isVisible ? true : region.isVisible) : false,
+        isOpen: visibleWidgetIds.length > 0 ? (isVisible ? true : region.isOpen) : false,
+        activeWidgetId: isVisible ? widgetId : activeWidgetId,
+        hiddenWidgetIds
+    });
+}
+export function addShellWidgetToRegion(shellState, regionId, widgetId, placement = {}) {
+    const region = shellState.regions[regionId];
+    const normalizedWidgetId = widgetId.trim();
+    if (!region || !normalizedWidgetId) {
+        return shellState;
+    }
+    if (region.widgetIds.includes(normalizedWidgetId) && !hasShellWidgetPlacement(placement)) {
+        return activateShellWidget(shellState, regionId, normalizedWidgetId);
+    }
+    let nextShellState = shellState;
+    const regionIds = ['left', 'right', 'bottom'];
+    for (const currentRegionId of regionIds) {
+        const currentRegion = nextShellState.regions[currentRegionId];
+        if (currentRegionId === regionId || !currentRegion?.widgetIds.includes(normalizedWidgetId)) {
+            continue;
+        }
+        const widgetIds = currentRegion.widgetIds.filter((currentWidgetId) => currentWidgetId !== normalizedWidgetId);
+        const hiddenWidgetIds = (currentRegion.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId);
+        const visibleWidgetIds = widgetIds.filter((widgetId) => !hiddenWidgetIds.includes(widgetId));
+        nextShellState = updateShellRegion(nextShellState, currentRegionId, {
+            ...currentRegion,
+            isVisible: visibleWidgetIds.length > 0 ? currentRegion.isVisible : false,
+            isOpen: visibleWidgetIds.length > 0 ? currentRegion.isOpen : false,
+            activeWidgetId: visibleWidgetIds.includes(currentRegion.activeWidgetId ?? '')
+                ? currentRegion.activeWidgetId
+                : visibleWidgetIds[0] ?? null,
+            widgetIds,
+            hiddenWidgetIds
+        });
+    }
+    const nextRegion = nextShellState.regions[regionId];
+    const widgetIds = insertShellWidgetId(nextRegion.widgetIds, normalizedWidgetId, placement);
+    return updateShellRegion(nextShellState, regionId, {
+        ...nextRegion,
+        isVisible: true,
+        isOpen: true,
+        activeWidgetId: normalizedWidgetId,
+        widgetIds,
+        hiddenWidgetIds: (nextRegion.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId)
+    });
+}
+export function moveShellWidgetToRegion(shellState, targetRegionId, widgetId, placement = {}) {
+    const normalizedWidgetId = widgetId.trim();
+    const targetRegion = shellState.regions[targetRegionId];
+    if (!targetRegion || !normalizedWidgetId) {
+        return shellState;
+    }
+    let sourceRegionId = null;
+    let nextShellState = shellState;
+    const regionIds = ['left', 'right', 'bottom'];
+    for (const regionId of regionIds) {
+        const region = nextShellState.regions[regionId];
+        if (!region?.widgetIds.includes(normalizedWidgetId)) {
+            continue;
+        }
+        sourceRegionId = regionId;
+        if (regionId === targetRegionId) {
+            const widgetIds = insertShellWidgetId(region.widgetIds, normalizedWidgetId, placement);
+            return updateShellRegion(shellState, targetRegionId, {
+                ...region,
+                isVisible: true,
+                isOpen: true,
+                activeWidgetId: normalizedWidgetId,
+                widgetIds,
+                hiddenWidgetIds: (region.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId)
+            });
+        }
+        const widgetIds = region.widgetIds.filter((currentWidgetId) => currentWidgetId !== normalizedWidgetId);
+        const hiddenWidgetIds = (region.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId);
+        const visibleWidgetIds = widgetIds.filter((widgetId) => !hiddenWidgetIds.includes(widgetId));
+        nextShellState = updateShellRegion(nextShellState, regionId, {
+            ...region,
+            isVisible: visibleWidgetIds.length > 0 ? region.isVisible : false,
+            isOpen: visibleWidgetIds.length > 0 ? region.isOpen : false,
+            activeWidgetId: visibleWidgetIds.includes(region.activeWidgetId ?? '')
+                ? region.activeWidgetId
+                : visibleWidgetIds[0] ?? null,
+            widgetIds,
+            hiddenWidgetIds
+        });
+    }
+    if (!sourceRegionId) {
+        return addShellWidgetToRegion(shellState, targetRegionId, normalizedWidgetId, placement);
+    }
+    const nextTargetRegion = nextShellState.regions[targetRegionId];
+    const widgetIds = insertShellWidgetId(nextTargetRegion.widgetIds, normalizedWidgetId, placement);
+    return updateShellRegion(nextShellState, targetRegionId, {
+        ...nextTargetRegion,
+        isVisible: true,
+        isOpen: true,
+        activeWidgetId: normalizedWidgetId,
+        widgetIds,
+        hiddenWidgetIds: (nextTargetRegion.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId)
+    });
+}
+export function removeShellWidgetFromRegion(shellState, regionId, widgetId) {
+    const region = shellState.regions[regionId];
+    const normalizedWidgetId = widgetId.trim();
+    if (!region || !normalizedWidgetId || !region.widgetIds.includes(normalizedWidgetId)) {
+        return shellState;
+    }
+    const widgetIds = region.widgetIds.filter((currentWidgetId) => currentWidgetId !== normalizedWidgetId);
+    const hiddenWidgetIds = (region.hiddenWidgetIds ?? []).filter((hiddenWidgetId) => hiddenWidgetId !== normalizedWidgetId);
+    const visibleWidgetIds = widgetIds.filter((candidateId) => !hiddenWidgetIds.includes(candidateId));
+    const activeWidgetId = visibleWidgetIds.includes(region.activeWidgetId ?? '')
+        ? region.activeWidgetId
+        : visibleWidgetIds[0] ?? null;
+    return updateShellRegion(shellState, regionId, {
+        ...region,
+        isVisible: visibleWidgetIds.length > 0 ? region.isVisible : false,
+        isOpen: visibleWidgetIds.length > 0 ? region.isOpen : false,
+        activeWidgetId,
+        widgetIds,
+        hiddenWidgetIds
+    });
+}
+function createShellRegionState(regionId, widgetCatalog, options = {}) {
+    const widgetIds = listShellWidgetsForRegion(widgetCatalog, regionId);
+    const shouldOpen = widgetIds.length > 0 && Boolean(options.openRegionIds?.includes(regionId));
+    return {
+        id: regionId,
+        isVisible: shouldOpen,
+        isOpen: shouldOpen,
+        size: DEFAULT_SHELL_REGION_SIZES[regionId],
+        activeWidgetId: widgetIds[0] ?? null,
+        widgetIds,
+        hiddenWidgetIds: [],
+        presentation: 'tabs',
+        axis: regionId === 'bottom' ? 'horizontal' : 'vertical'
+    };
+}
+function listShellWidgetsForRegion(widgetCatalog, regionId) {
+    const widgetIds = [];
+    if (!('list' in widgetCatalog) || typeof widgetCatalog.list !== 'function') {
+        return widgetIds;
+    }
+    for (const widget of widgetCatalog.list()) {
+        if (widget.defaultRegion === regionId && widget.initiallyConnected !== false) {
+            widgetIds.push(widget.id);
+        }
+    }
+    return widgetIds;
+}
+function isPlaceholderShellWidgetId(widgetId) {
+    return widgetId.endsWith('.empty');
+}
+function hasShellWidgetPlacement(placement) {
+    return hasDockPlacement(toDockPlacement(placement));
+}
+function insertShellWidgetId(widgetIds, widgetId, placement = {}) {
+    const baseWidgetIds = widgetIds
+        .filter((currentWidgetId) => !isPlaceholderShellWidgetId(currentWidgetId))
+        .filter((currentWidgetId) => currentWidgetId !== widgetId);
+    return insertDockableEntityId(baseWidgetIds, widgetId, toDockPlacement(placement));
+}
+function toDockPlacement(placement = {}) {
+    return {
+        beforeEntityId: placement.beforeWidgetId,
+        afterEntityId: placement.afterWidgetId
+    };
+}
+function updateShellRegion(shellState, regionId, nextRegion) {
+    return {
+        ...shellState,
+        regions: {
+            ...shellState.regions,
+            [regionId]: nextRegion
+        }
+    };
+}

package/dist/application/widgets/createWorkbenchWidgetAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { WorkbenchWidgetDefinition } from "../../domain/widget/model.js";
+import type { RegisteredWorkbenchWidget, RegisteredWorkbenchWidgetComponentLoader } from "../../infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.js";
+import { type WidgetDefinitionCatalog } from '@konitif/widgets';
+export type WorkbenchWidgetHosting = Pick<WorkbenchWidgetDefinition, 'icon' | 'supportedSurfaces' | 'presentation'>;
+/** Candidate bridge; neither registers nor loads, and owns no placement state. */
+export declare function createWorkbenchWidgetAdapter(catalog: WidgetDefinitionCatalog, widgetId: string, load: RegisteredWorkbenchWidgetComponentLoader): Readonly<{
+    source: import("@konitif/widgets").WidgetDefinition;
+    project(host?: WorkbenchWidgetHosting): RegisteredWorkbenchWidget;
+}>;

package/dist/application/widgets/createWorkbenchWidgetAdapter.js

@@ -0,0 +1,30 @@
+import { bindWidgetImplementation } from '@konitif/widgets';
+/** Candidate bridge; neither registers nor loads, and owns no placement state. */
+export function createWorkbenchWidgetAdapter(catalog, widgetId, load) {
+    const binding = bindWidgetImplementation(catalog, widgetId, load);
+    return Object.freeze({
+        source: binding.definition,
+        project(host = {}) {
+            for (const key of ['id', 'title', 'description']) {
+                if (key in host)
+                    throw new Error(`Host override of widget ${key} refused`);
+            }
+            const readingLevel = host.presentation?.readingLevel;
+            // This record is a disposable compatibility snapshot, not a second catalog.
+            const definition = {
+                id: binding.definition.id,
+                title: binding.definition.title,
+                description: binding.definition.description,
+                ...(host.icon === undefined ? {} : { icon: typeof host.icon === 'string' ? host.icon : { ...host.icon } }),
+                ...(host.supportedSurfaces === undefined ? {} : { supportedSurfaces: [...host.supportedSurfaces] }),
+                ...(host.presentation === undefined ? {} : { presentation: {
+                        ...(readingLevel === undefined ? {} : { readingLevel: {
+                                ...readingLevel,
+                                ...(readingLevel.availableLevels === undefined ? {} : { availableLevels: [...readingLevel.availableLevels] })
+                            } })
+                    } })
+            };
+            return { definition, loadComponent: binding.load };
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { LayoutNode } from "../../domain/layout/model.js";
+export declare function canonicalizeLayout(node: LayoutNode): LayoutNode;

package/dist/application/workspace/canonicalizeLayout.js

@@ -0,0 +1,91 @@
+import { createSplit } from "../../domain/workspace/factories.js";
+import { normalizeSplitSizes } from "../../domain/layout/validation.js";
+export function canonicalizeLayout(node) {
+    if (node.kind === 'stack') {
+        return node;
+    }
+    const leftChild = canonicalizeLayout(node.children[0]);
+    const rightChild = canonicalizeLayout(node.children[1]);
+    const segments = [
+        ...collectCanonicalSegments(leftChild, node.orientation, node.sizes[0]),
+        ...collectCanonicalSegments(rightChild, node.orientation, node.sizes[1])
+    ];
+    if (segments.length === 2 && segments[0].node === leftChild && segments[1].node === rightChild) {
+        if (leftChild === node.children[0] && rightChild === node.children[1]) {
+            return node;
+        }
+        return {
+            ...node,
+            children: [leftChild, rightChild],
+            sizes: normalizeSplitSizes(node.sizes)
+        };
+    }
+    const splitIds = collectCanonicalSplitIds(node, node.orientation).slice(0, Math.max(0, segments.length - 1));
+    return buildCanonicalSplitChain(node.orientation, segments, splitIds);
+}
+function collectCanonicalSegments(node, orientation, size) {
+    if (node.kind !== 'split' || node.orientation !== orientation) {
+        return [{ node, size }];
+    }
+    return [
+        ...collectCanonicalSegments(node.children[0], orientation, size * node.sizes[0]),
+        ...collectCanonicalSegments(node.children[1], orientation, size * node.sizes[1])
+    ];
+}
+function buildCanonicalSplitChain(orientation, segments, splitIds) {
+    if (segments.length === 1) {
+        return segments[0].node;
+    }
+    if (segments.length === 2) {
+        const nextSizes = normalizeSplitSizes([segments[0].size, segments[1].size]);
+        const splitId = splitIds[0];
+        if (splitId) {
+            return {
+                id: splitId,
+                kind: 'split',
+                orientation,
+                children: [segments[0].node, segments[1].node],
+                sizes: nextSizes
+            };
+        }
+        return createSplit(orientation, [segments[0].node, segments[1].node], nextSizes);
+    }
+    const splitIndex = resolveBalancedSplitIndex(segments);
+    const leftSegments = segments.slice(0, splitIndex);
+    const rightSegments = segments.slice(splitIndex);
+    const leftTotal = leftSegments.reduce((sum, segment) => sum + segment.size, 0);
+    const rightTotal = rightSegments.reduce((sum, segment) => sum + segment.size, 0);
+    const nextSizes = normalizeSplitSizes([leftTotal, rightTotal]);
+    const currentSplitId = splitIds[0];
+    const leftSplitCount = Math.max(0, leftSegments.length - 1);
+    const leftSplitIds = splitIds.slice(1, 1 + leftSplitCount);
+    const rightSplitIds = splitIds.slice(1 + leftSplitCount);
+    const leftNode = buildCanonicalSplitChain(orientation, leftSegments, leftSplitIds);
+    const rightNode = buildCanonicalSplitChain(orientation, rightSegments, rightSplitIds);
+    if (currentSplitId) {
+        return {
+            id: currentSplitId,
+            kind: 'split',
+            orientation,
+            children: [leftNode, rightNode],
+            sizes: nextSizes
+        };
+    }
+    return createSplit(orientation, [leftNode, rightNode], nextSizes);
+}
+function collectCanonicalSplitIds(node, orientation) {
+    if (node.kind !== 'split' || node.orientation !== orientation) {
+        return [];
+    }
+    return [
+        node.id,
+        ...collectCanonicalSplitIds(node.children[0], orientation),
+        ...collectCanonicalSplitIds(node.children[1], orientation)
+    ];
+}
+function resolveBalancedSplitIndex(segments) {
+    if (segments.length <= 2) {
+        return 1;
+    }
+    return Math.max(1, Math.min(segments.length - 1, Math.floor(segments.length / 2)));
+}

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

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

package/dist/application/workspace/closePanel.js

@@ -0,0 +1,43 @@
+import { createStack } from "../../domain/workspace/factories.js";
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { pruneUnusedToolInstances, updateCanonicalizedActiveWindowRoot } from "./finalizeWorkspace.js";
+import { findStackPathContainingPanel, replaceNodeAtPathAllowingRemoval } from "./layoutTree.js";
+export function closePanel(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow) {
+        return workspace;
+    }
+    const stackPath = findStackPathContainingPanel(activeWindow.root, input.panelId);
+    if (!stackPath) {
+        return workspace;
+    }
+    const nextWorkspace = updateCanonicalizedActiveWindowRoot(workspace, () => replaceNodeAtPathAllowingRemoval(activeWindow.root, stackPath.trail, closePanelFromStack(stackPath.stack, input.panelId)) ?? createStack());
+    return pruneUnusedToolInstances(nextWorkspace);
+}
+function closePanelFromStack(stack, panelId) {
+    const closedPanelIndex = stack.children.findIndex((panel) => panel.id === panelId);
+    if (closedPanelIndex === -1) {
+        return stack;
+    }
+    const nextChildren = stack.children.filter((panel) => panel.id !== panelId);
+    if (nextChildren.length === 0) {
+        return null;
+    }
+    const normalizedChildren = nextChildren;
+    const nextActiveChildId = selectActiveChildIdAfterClose(stack, panelId, closedPanelIndex, normalizedChildren);
+    return {
+        ...stack,
+        children: normalizedChildren,
+        activeChildId: nextActiveChildId
+    };
+}
+function selectActiveChildIdAfterClose(stack, panelId, closedPanelIndex, nextChildren) {
+    if (stack.activeChildId !== panelId) {
+        return stack.activeChildId;
+    }
+    const previousPanel = stack.children[closedPanelIndex - 1];
+    if (previousPanel) {
+        return previousPanel.id;
+    }
+    return nextChildren[0].id;
+}

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

@@ -0,0 +1,7 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface CollapseSplitInput {
+    splitId: string;
+    removeChildIndex: 0 | 1;
+}
+export declare function collapseSplit(workspace: Workspace, input: CollapseSplitInput): Workspace;
+export {};

package/dist/application/workspace/collapseSplit.js

@@ -0,0 +1,45 @@
+import { listPanels } from "../../domain/layout/selectors.js";
+import { pruneUnusedToolInstances, updateCanonicalizedActiveWindowRoot } from "./finalizeWorkspace.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+export function collapseSplit(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.splitId, (selected) => collapseSplitInActiveWindow(selected, input));
+}
+function collapseSplitInActiveWindow(workspace, input) {
+    let removedNode = null;
+    let didCollapse = false;
+    const nextWorkspace = updateCanonicalizedActiveWindowRoot(workspace, (root) => {
+        const nextRoot = collapseSplitNode(root, input.splitId, input.removeChildIndex, (node) => {
+            removedNode = node;
+            didCollapse = true;
+        });
+        return didCollapse ? nextRoot : root;
+    });
+    if (!didCollapse || !removedNode) {
+        return workspace;
+    }
+    const removedToolInstanceIds = new Set(listPanels(removedNode)
+        .map((panel) => panel.toolInstanceId)
+        .filter((toolInstanceId) => !!toolInstanceId));
+    if (removedToolInstanceIds.size === 0) {
+        return nextWorkspace;
+    }
+    return pruneUnusedToolInstances(nextWorkspace, removedToolInstanceIds);
+}
+function collapseSplitNode(node, splitId, removeChildIndex, onCollapse) {
+    if (node.kind === 'stack') {
+        return node;
+    }
+    if (node.id === splitId) {
+        const removedNode = node.children[removeChildIndex];
+        const survivor = node.children[removeChildIndex === 0 ? 1 : 0];
+        onCollapse(removedNode);
+        return survivor;
+    }
+    return {
+        ...node,
+        children: [
+            collapseSplitNode(node.children[0], splitId, removeChildIndex, onCollapse),
+            collapseSplitNode(node.children[1], splitId, removeChildIndex, onCollapse)
+        ]
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+interface CollapseSplitBoundaryInput {
+    rootSplitId: string;
+    boundaryIndex: number;
+    removeSide: 'start' | 'end';
+}
+export declare function collapseSplitBoundary(workspace: Workspace, input: CollapseSplitBoundaryInput): Workspace;
+export {};