@konitif/workbench 0.284.1

package/dist/domain/widget/composition.js

@@ -0,0 +1,250 @@
+export function resolveWorkbenchWidgetZone(composition, zoneId) {
+    const zone = composition.zones.find((entry) => entry.id === zoneId);
+    if (!zone) {
+        return null;
+    }
+    const allPlacements = listWorkbenchWidgetZonePlacements(composition, zoneId, { includeHidden: true });
+    const placements = listWorkbenchWidgetZonePlacements(composition, zoneId);
+    const activePlacementId = composition.activePlacementByZoneId?.[zoneId] ?? null;
+    const activePlacement = placements.find((placement) => placement.id === activePlacementId) ??
+        placements.find((placement) => placement.isPinned) ??
+        placements[0] ??
+        null;
+    return {
+        zone,
+        allPlacements,
+        placements,
+        activePlacement
+    };
+}
+export function listWorkbenchWidgetZonePlacements(composition, zoneId, options = {}) {
+    return composition.placements
+        .filter((placement) => placement.zoneId === zoneId && (options.includeHidden || placement.isVisible !== false))
+        .sort(compareWorkbenchWidgetPlacements);
+}
+/**
+ * Returns the placements rendered by a zone without transferring placement
+ * authority to the host component. Tab zones project only the active entity;
+ * stack zones project every visible entity in canonical order.
+ */
+export function listWorkbenchWidgetZoneRenderedPlacements(resolvedZone) {
+    if (!resolvedZone) {
+        return [];
+    }
+    return resolvedZone.zone.presentation === 'stack'
+        ? resolvedZone.placements
+        : resolvedZone.activePlacement
+            ? [resolvedZone.activePlacement]
+            : [];
+}
+export function compareWorkbenchWidgetPlacements(left, right) {
+    const leftOrder = Number.isFinite(left.order) ? Number(left.order) : 0;
+    const rightOrder = Number.isFinite(right.order) ? Number(right.order) : 0;
+    return leftOrder - rightOrder || left.title.localeCompare(right.title) || left.id.localeCompare(right.id);
+}
+export function activateWorkbenchWidgetPlacement(composition, zoneId, placementId) {
+    const placement = listWorkbenchWidgetZonePlacements(composition, zoneId)
+        .find((candidate) => candidate.id === placementId);
+    if (!placement) {
+        return composition;
+    }
+    return {
+        ...composition,
+        activePlacementByZoneId: {
+            ...composition.activePlacementByZoneId,
+            [zoneId]: placement.id
+        }
+    };
+}
+export function moveWorkbenchWidgetPlacement(composition, move) {
+    const movingPlacement = composition.placements.find((placement) => placement.id === move.placementId);
+    const targetZone = composition.zones.find((zone) => zone.id === move.zoneId);
+    if (!movingPlacement || !targetZone) {
+        return composition;
+    }
+    const sourceZoneId = movingPlacement.zoneId;
+    const targetZoneId = targetZone.id;
+    const sourceWasActive = composition.activePlacementByZoneId?.[sourceZoneId] === movingPlacement.id;
+    const targetPlacements = listWorkbenchWidgetZonePlacements(composition, targetZoneId, { includeHidden: true })
+        .filter((placement) => placement.id !== movingPlacement.id);
+    const insertedTargetPlacements = insertWorkbenchWidgetPlacement(targetPlacements, movingPlacement, {
+        beforePlacementId: move.beforePlacementId ?? null,
+        afterPlacementId: move.afterPlacementId ?? null
+    });
+    const nextTargetOrders = createWorkbenchWidgetPlacementOrderMap(insertedTargetPlacements);
+    const nextSourceOrders = createWorkbenchWidgetPlacementOrderMap(listWorkbenchWidgetZonePlacements(composition, sourceZoneId, { includeHidden: true })
+        .filter((placement) => placement.id !== movingPlacement.id));
+    const nextPlacements = composition.placements.map((placement) => {
+        if (placement.id === movingPlacement.id) {
+            return {
+                ...placement,
+                zoneId: targetZoneId,
+                order: nextTargetOrders.get(placement.id) ?? 0,
+                isVisible: true
+            };
+        }
+        if (placement.zoneId === targetZoneId) {
+            return {
+                ...placement,
+                order: nextTargetOrders.get(placement.id) ?? placement.order
+            };
+        }
+        if (placement.zoneId === sourceZoneId) {
+            return {
+                ...placement,
+                order: nextSourceOrders.get(placement.id) ?? placement.order
+            };
+        }
+        return placement;
+    });
+    const nextComposition = {
+        ...composition,
+        placements: nextPlacements,
+        activePlacementByZoneId: {
+            ...composition.activePlacementByZoneId,
+            [targetZoneId]: movingPlacement.id
+        }
+    };
+    if (sourceWasActive && sourceZoneId !== targetZoneId) {
+        nextComposition.activePlacementByZoneId = {
+            ...nextComposition.activePlacementByZoneId,
+            [sourceZoneId]: resolveWorkbenchWidgetZone(nextComposition, sourceZoneId)?.activePlacement?.id ?? null
+        };
+    }
+    return nextComposition;
+}
+export function createWorkbenchWidgetZoneLayoutState(composition, zoneId) {
+    const zonePlacements = composition.placements
+        .filter((placement) => placement.zoneId === zoneId)
+        .sort(compareWorkbenchWidgetPlacements);
+    const zone = composition.zones.find((candidate) => candidate.id === zoneId);
+    const resolvedZone = resolveWorkbenchWidgetZone(composition, zoneId);
+    return {
+        activePlacementId: resolvedZone?.activePlacement?.id ?? null,
+        placementOrder: zonePlacements.map((placement) => placement.id),
+        hiddenPlacementIds: zonePlacements
+            .filter((placement) => placement.isVisible === false)
+            .map((placement) => placement.id),
+        pinnedPlacementIds: zonePlacements
+            .filter((placement) => placement.isPinned === true)
+            .map((placement) => placement.id),
+        presentation: zone?.presentation,
+        axis: zone?.axis
+    };
+}
+export function applyWorkbenchWidgetZoneLayoutState(composition, layoutStateByZoneId) {
+    const nextZones = composition.zones.map((zone) => {
+        const layoutState = layoutStateByZoneId[zone.id];
+        if (!layoutState) {
+            return zone;
+        }
+        return {
+            ...zone,
+            ...(layoutState.presentation ? { presentation: layoutState.presentation } : {}),
+            ...(layoutState.axis ? { axis: layoutState.axis } : {})
+        };
+    });
+    const nextPlacements = composition.placements.map((placement) => {
+        const layoutState = layoutStateByZoneId[placement.zoneId];
+        if (!layoutState) {
+            return placement;
+        }
+        const nextPlacement = { ...placement };
+        const orderIndex = layoutState.placementOrder?.indexOf(placement.id) ?? -1;
+        if (orderIndex >= 0) {
+            nextPlacement.order = orderIndex * 10;
+        }
+        if (layoutState.hiddenPlacementIds) {
+            nextPlacement.isVisible = !layoutState.hiddenPlacementIds.includes(placement.id);
+        }
+        if (layoutState.pinnedPlacementIds) {
+            nextPlacement.isPinned = layoutState.pinnedPlacementIds.includes(placement.id);
+        }
+        return nextPlacement;
+    });
+    let nextComposition = {
+        ...composition,
+        zones: nextZones,
+        placements: nextPlacements,
+        activePlacementByZoneId: {
+            ...composition.activePlacementByZoneId
+        }
+    };
+    for (const [zoneId, layoutState] of Object.entries(layoutStateByZoneId)) {
+        if (!layoutState) {
+            continue;
+        }
+        const activePlacementId = layoutState.activePlacementId ?? null;
+        const activePlacement = activePlacementId
+            ? listWorkbenchWidgetZonePlacements(nextComposition, zoneId).find((placement) => placement.id === activePlacementId)
+            : null;
+        const resolvedZone = resolveWorkbenchWidgetZone({
+            ...nextComposition,
+            activePlacementByZoneId: {
+                ...nextComposition.activePlacementByZoneId,
+                [zoneId]: activePlacement?.id ?? null
+            }
+        }, zoneId);
+        nextComposition = {
+            ...nextComposition,
+            activePlacementByZoneId: {
+                ...nextComposition.activePlacementByZoneId,
+                [zoneId]: activePlacement?.id ?? resolvedZone?.activePlacement?.id ?? null
+            }
+        };
+    }
+    return nextComposition;
+}
+export function createWorkbenchWidgetZoneComposition(input) {
+    const placements = input.placements.map((placement) => ({
+        ...placement,
+        zoneId: input.zone.id,
+        isVisible: placement.isVisible ?? true
+    }));
+    const visiblePlacementIds = new Set(placements.filter((placement) => placement.isVisible !== false).map((placement) => placement.id));
+    const activePlacementId = input.activePlacementId && visiblePlacementIds.has(input.activePlacementId)
+        ? input.activePlacementId
+        : placements.find((placement) => placement.isPinned && placement.isVisible !== false)?.id ??
+            placements.find((placement) => placement.isVisible !== false)?.id ??
+            null;
+    return {
+        zones: [input.zone],
+        placements,
+        activePlacementByZoneId: {
+            [input.zone.id]: activePlacementId
+        }
+    };
+}
+export function createSingleWorkbenchWidgetZoneComposition(input) {
+    return createWorkbenchWidgetZoneComposition({
+        zone: input.zone,
+        placements: [input.placement],
+        activePlacementId: input.placement.id
+    });
+}
+function insertWorkbenchWidgetPlacement(placements, movingPlacement, placement) {
+    const beforeIndex = placement.beforePlacementId
+        ? placements.findIndex((candidate) => candidate.id === placement.beforePlacementId)
+        : -1;
+    if (beforeIndex >= 0) {
+        return [
+            ...placements.slice(0, beforeIndex),
+            movingPlacement,
+            ...placements.slice(beforeIndex)
+        ];
+    }
+    const afterIndex = placement.afterPlacementId
+        ? placements.findIndex((candidate) => candidate.id === placement.afterPlacementId)
+        : -1;
+    if (afterIndex >= 0) {
+        return [
+            ...placements.slice(0, afterIndex + 1),
+            movingPlacement,
+            ...placements.slice(afterIndex + 1)
+        ];
+    }
+    return [...placements, movingPlacement];
+}
+function createWorkbenchWidgetPlacementOrderMap(placements) {
+    return new Map(placements.map((placement, index) => [placement.id, index * 10]));
+}

package/dist/domain/widget/model.d.ts

@@ -0,0 +1,35 @@
+import type { WorkbenchIconInput } from "../icon/model.js";
+import type { WorkbenchReadingLevel, WorkbenchReadingLevelPresentation } from "../presentation/readingLevel.js";
+import type { WorkbenchWidgetPlacement, WorkbenchWidgetZoneDefinition, WorkbenchWidgetZoneSurface } from "./composition.js";
+export type WorkbenchWidgetContext = Record<string, unknown>;
+export interface WorkbenchWidgetDefinition {
+    id: string;
+    title: string;
+    description: string;
+    icon?: WorkbenchIconInput;
+    supportedSurfaces?: WorkbenchWidgetZoneSurface[];
+    presentation?: {
+        readingLevel?: WorkbenchReadingLevelPresentation;
+    };
+}
+export interface WorkbenchWidgetCatalogPort {
+    getDefinition(widgetId: string): WorkbenchWidgetDefinition | undefined;
+    list?(): WorkbenchWidgetDefinition[];
+}
+export interface WorkbenchWidgetRuntimeContext {
+    zone: WorkbenchWidgetZoneDefinition;
+    placement: WorkbenchWidgetPlacement;
+    context: WorkbenchWidgetContext;
+    /** Reading projection resolved by the Widget container, never by its content. */
+    readingLevel: WorkbenchReadingLevel;
+}
+export interface HostedWorkbenchWidgetProps {
+    definition: WorkbenchWidgetDefinition;
+    runtime: WorkbenchWidgetRuntimeContext;
+}
+export declare function createWorkbenchWidgetRuntimeContext(input: {
+    zone: WorkbenchWidgetZoneDefinition;
+    placement: WorkbenchWidgetPlacement;
+    context?: WorkbenchWidgetContext | null;
+    readingLevel?: WorkbenchReadingLevel;
+}): WorkbenchWidgetRuntimeContext;

package/dist/domain/widget/model.js

@@ -0,0 +1,8 @@
+export function createWorkbenchWidgetRuntimeContext(input) {
+    return {
+        zone: input.zone,
+        placement: input.placement,
+        context: input.context ?? {},
+        readingLevel: input.readingLevel ?? 'casual'
+    };
+}

package/dist/domain/widget/toolDock.d.ts

@@ -0,0 +1,30 @@
+import type { ShellRegionId, ShellRegionPresentation } from "../shell/model.js";
+import type { JsonObject } from "../shared/json.js";
+export type WorkbenchToolDockActionSide = 'top' | 'right' | 'bottom' | 'left';
+export interface WorkbenchToolDockVisibilityConfig {
+    dockId: string;
+    legacyVisibleKey?: string | null;
+    defaultVisible?: boolean;
+}
+export interface WorkbenchToolDockRootConfig extends WorkbenchToolDockVisibilityConfig {
+    commandId: string;
+    widgetId: string;
+    defaultRegionId: ShellRegionId;
+}
+export interface WorkbenchToolDockRootLocation {
+    regionId: ShellRegionId;
+    isVisible: boolean;
+    isOpen: boolean;
+    activeWidgetId: string | null;
+    presentation?: ShellRegionPresentation;
+}
+export declare function resolveWorkbenchToolDockSide(regionId: ShellRegionId | null | undefined): WorkbenchToolDockActionSide;
+export declare function readWorkbenchToolDockVisibility(state: unknown, config: WorkbenchToolDockVisibilityConfig): boolean;
+export declare function resolveWorkbenchToolDockEffectiveVisibility(input: {
+    rootLocation: WorkbenchToolDockRootLocation | null;
+    internalVisible: boolean;
+    widgetId: string;
+}): boolean;
+export declare function patchWorkbenchToolDockVisibilityState(state: unknown, input: WorkbenchToolDockVisibilityConfig & {
+    isVisible: boolean;
+}): JsonObject;

package/dist/domain/widget/toolDock.js

@@ -0,0 +1,52 @@
+export function resolveWorkbenchToolDockSide(regionId) {
+    if (regionId === 'left' || regionId === 'right' || regionId === 'bottom') {
+        return regionId;
+    }
+    return 'left';
+}
+export function readWorkbenchToolDockVisibility(state, config) {
+    if (!isRecord(state)) {
+        return config.defaultVisible ?? false;
+    }
+    const dockContainers = state.dockContainers;
+    if (isRecord(dockContainers)) {
+        const dock = dockContainers[config.dockId];
+        if (isRecord(dock) && typeof dock.isVisible === 'boolean') {
+            return dock.isVisible;
+        }
+    }
+    if (config.legacyVisibleKey && typeof state[config.legacyVisibleKey] === 'boolean') {
+        return state[config.legacyVisibleKey] === true;
+    }
+    return config.defaultVisible ?? false;
+}
+export function resolveWorkbenchToolDockEffectiveVisibility(input) {
+    const location = input.rootLocation;
+    if (!location) {
+        return input.internalVisible;
+    }
+    return location.isVisible && location.isOpen && (location.presentation === 'stack' || location.activeWidgetId === input.widgetId);
+}
+export function patchWorkbenchToolDockVisibilityState(state, input) {
+    const currentState = isRecord(state) ? state : {};
+    const dockContainers = isRecord(currentState.dockContainers) ? currentState.dockContainers : {};
+    const currentDock = dockContainers[input.dockId];
+    const currentDockState = isRecord(currentDock) ? currentDock : {};
+    const nextState = {
+        ...currentState,
+        dockContainers: {
+            ...dockContainers,
+            [input.dockId]: {
+                ...currentDockState,
+                isVisible: input.isVisible
+            }
+        }
+    };
+    if (input.legacyVisibleKey) {
+        nextState[input.legacyVisibleKey] = input.isVisible;
+    }
+    return nextState;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/domain/workbench/model.d.ts

@@ -0,0 +1,35 @@
+export interface WorkbenchDefinition {
+    id: string;
+    title: string;
+    summary: string;
+    /**
+     * Ordered list of tools exposed inside this contextualized workbench.
+     * The first entry can be used as a sensible launcher fallback.
+     */
+    toolIds: string[];
+    /**
+     * Optional preferred tool opened when the workbench boots.
+     * Must belong to `toolIds` when provided.
+     */
+    defaultToolId?: string | null;
+    /**
+     * Optional workspace preset reference resolved by the app layer.
+     * Kept as a string on purpose so `core` does not depend on product-specific preset ids yet.
+     */
+    layoutPresetId?: string | null;
+    /**
+     * Optional shell widget subset exposed by this workbench.
+     */
+    shellWidgetIds?: string[];
+    /**
+     * Optional route handle used by the app layer to bind URLs to a contextual workbench.
+     */
+    route?: {
+        page?: string | null;
+        workbench?: string | null;
+    };
+}
+export interface WorkbenchCatalog {
+    getDefinition(workbenchId: string): WorkbenchDefinition | undefined;
+    list(): WorkbenchDefinition[];
+}

package/dist/domain/workbench/model.js

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

package/dist/domain/workbench/routing.d.ts

@@ -0,0 +1,17 @@
+export type WorkbenchRoute = {
+    kind: 'workspace';
+} | {
+    kind: 'docs';
+    tab?: string | null;
+} | {
+    kind: 'lab';
+} | {
+    kind: 'tool';
+    toolId: string;
+} | {
+    kind: 'shell';
+    region: string;
+};
+export declare function parseWorkbenchRoute(href: string): WorkbenchRoute;
+export declare function createWorkbenchRouteHref(currentHref: string, route: WorkbenchRoute): string;
+export declare function createWorkbenchRoutePath(route: WorkbenchRoute): string;

package/dist/domain/workbench/routing.js

@@ -0,0 +1,72 @@
+const ROUTE_SEARCH_PARAMS = ['view', 'docsTab', 'page', 'tool'];
+const WORKBENCH_ROUTE_BASE_SEGMENTS = new Set(['__workbench_dev__']);
+export function parseWorkbenchRoute(href) {
+    const url = new URL(href, 'http://workbench.local');
+    const parts = getWorkbenchRouteParts(url.pathname);
+    if (parts[0] === 'docs') {
+        return { kind: 'docs', tab: parts[1] ?? null };
+    }
+    if (parts[0] === 'shortcuts') {
+        return { kind: 'docs', tab: 'shortcuts' };
+    }
+    if (parts[0] === 'forge' || parts[0] === 'lab') {
+        return { kind: 'lab' };
+    }
+    if (parts[0] === 'tools' && parts[1]) {
+        return { kind: 'tool', toolId: parts[1] };
+    }
+    if (parts[0] === 'shell' && parts[1]) {
+        return { kind: 'shell', region: parts.slice(1).join('/') };
+    }
+    return { kind: 'workspace' };
+}
+export function createWorkbenchRouteHref(currentHref, route) {
+    const url = new URL(currentHref, 'http://workbench.local');
+    url.pathname = joinWorkbenchRoutePath(getWorkbenchRouteBasePath(url.pathname), createWorkbenchRoutePath(route));
+    for (const param of ROUTE_SEARCH_PARAMS) {
+        url.searchParams.delete(param);
+    }
+    return url.toString();
+}
+export function createWorkbenchRoutePath(route) {
+    switch (route.kind) {
+        case 'docs':
+            return route.tab ? `/docs/${encodeURIComponent(route.tab)}` : '/docs';
+        case 'lab':
+            return '/forge';
+        case 'tool':
+            return `/tools/${encodeURIComponent(route.toolId)}`;
+        case 'shell':
+            return `/shell/${route.region.split('/').filter(Boolean).map(encodeURIComponent).join('/')}`;
+        case 'workspace':
+        default:
+            return '/';
+    }
+}
+function normalizeWorkbenchPath(path) {
+    if (!path || path === '/') {
+        return '/';
+    }
+    return path.replace(/\/+$/, '') || '/';
+}
+function getWorkbenchRouteParts(pathname) {
+    const parts = normalizeWorkbenchPath(pathname).split('/').filter(Boolean).map(decodeURIComponent);
+    return WORKBENCH_ROUTE_BASE_SEGMENTS.has(parts[0] ?? '') ? parts.slice(1) : parts;
+}
+function getWorkbenchRouteBasePath(pathname) {
+    const firstPart = normalizeWorkbenchPath(pathname).split('/').filter(Boolean)[0];
+    if (!firstPart) {
+        return '';
+    }
+    const decodedFirstPart = decodeURIComponent(firstPart);
+    return WORKBENCH_ROUTE_BASE_SEGMENTS.has(decodedFirstPart) ? `/${encodeURIComponent(decodedFirstPart)}` : '';
+}
+function joinWorkbenchRoutePath(basePath, routePath) {
+    if (!basePath) {
+        return routePath;
+    }
+    if (routePath === '/') {
+        return `${basePath}/`;
+    }
+    return `${basePath}${routePath}`;
+}

package/dist/domain/workspace/factories.d.ts

@@ -0,0 +1,9 @@
+import type { NonEmptyArray, SplitOrientation, SplitNode, StackNode } from "../layout/model.js";
+import type { PanelNode } from "../panel/model.js";
+import type { Workspace, WorkspaceWindow } from "./model.js";
+import type { LayoutNode } from "../layout/model.js";
+export declare function createPanel(title?: string): PanelNode;
+export declare function createStack(panels?: NonEmptyArray<PanelNode>): StackNode;
+export declare function createSplit(orientation: SplitOrientation, children: readonly [StackNode | SplitNode, StackNode | SplitNode], sizes?: [number, number]): SplitNode;
+export declare function createWorkspaceWindow(root?: LayoutNode, title?: string): WorkspaceWindow;
+export declare function createWorkspaceShell(window?: WorkspaceWindow): Workspace;

package/dist/domain/workspace/factories.js

@@ -0,0 +1,47 @@
+import { createId } from "../shared/id.js";
+import { normalizeSplitSizes } from "../layout/validation.js";
+import { WORKSPACE_SNAPSHOT_VERSION } from "./validation.js";
+export function createPanel(title = 'Untitled panel') {
+    return {
+        id: createId('panel'),
+        title,
+        toolInstanceId: null,
+        showFullscreenToggle: true
+    };
+}
+export function createStack(panels = [createPanel()]) {
+    return {
+        id: createId('stack'),
+        kind: 'stack',
+        activeChildId: panels[0].id,
+        headerVisible: true,
+        children: panels
+    };
+}
+export function createSplit(orientation, children, sizes = [1, 1]) {
+    return {
+        id: createId('split'),
+        kind: 'split',
+        orientation,
+        sizes: normalizeSplitSizes(sizes),
+        children
+    };
+}
+export function createWorkspaceWindow(root = createStack(), title = 'Primary Window') {
+    return {
+        id: createId('window'),
+        title,
+        root
+    };
+}
+export function createWorkspaceShell(window = createWorkspaceWindow()) {
+    return {
+        id: createId('workspace'),
+        version: WORKSPACE_SNAPSHOT_VERSION,
+        activeWindowId: window.id,
+        fullscreenPanelId: null,
+        designSystemThemeSession: null,
+        windows: [window],
+        toolInstances: {}
+    };
+}

package/dist/domain/workspace/model.d.ts

@@ -0,0 +1,23 @@
+import type { LayoutNode } from "../layout/model.js";
+import type { ToolInstance } from "../tool/model.js";
+import type { DesignSystemThemeSession } from "../design-system/themeSession.js";
+export interface WorkspaceWindow {
+    id: string;
+    title: string;
+    root: LayoutNode;
+}
+export interface WorkspacePresetProvenance {
+    id: string;
+    version: string | null;
+    status: 'exact' | 'customized';
+}
+export interface Workspace {
+    id: string;
+    version: number;
+    activeWindowId: string;
+    fullscreenPanelId?: string | null;
+    designSystemThemeSession?: DesignSystemThemeSession | null;
+    presetProvenance?: WorkspacePresetProvenance | null;
+    windows: WorkspaceWindow[];
+    toolInstances: Record<string, ToolInstance>;
+}

package/dist/domain/workspace/model.js

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

package/dist/domain/workspace/persistence.d.ts

@@ -0,0 +1,5 @@
+import type { Workspace } from "./model.js";
+export interface WorkspacePersistencePort {
+    load(): Workspace | null;
+    save(workspace: Workspace): void;
+}

package/dist/domain/workspace/persistence.js

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

package/dist/domain/workspace/selectors.d.ts

@@ -0,0 +1,19 @@
+import type { PanelNode } from "../panel/model.js";
+import type { ToolInstance } from "../tool/model.js";
+import type { Workspace, WorkspaceWindow } from "./model.js";
+export declare function getWindowById(workspace: Workspace, windowId: string): WorkspaceWindow | undefined;
+export declare function getActiveWindow(workspace: Workspace): WorkspaceWindow | undefined;
+export declare function findWindowContainingPanel(workspace: Workspace, panelId: string): WorkspaceWindow | undefined;
+export declare function findPanelInWorkspace(workspace: Workspace, panelId: string): PanelNode | undefined;
+export declare function findStackInWorkspace(workspace: Workspace, stackId: string): import("../../index.js").StackNode | undefined;
+export declare function findStackContainingPanelInWorkspace(workspace: Workspace, panelId: string): import("../../index.js").StackNode | undefined;
+export declare function findSplitInWorkspace(workspace: Workspace, splitId: string): import("../../index.js").SplitNode | undefined;
+export declare function listPanelsInWorkspace(workspace: Workspace): PanelNode[];
+export declare function findToolPlacementByToolId(workspace: Workspace, toolId: string): {
+    panelId: string;
+    toolInstanceId: string;
+    toolInstance: ToolInstance;
+} | undefined;
+export declare function collectReferencedToolInstanceIds(workspace: Workspace): Set<string>;
+export declare function getPreferredFocusedPanelId(workspace: Workspace): string | null;
+export declare function listToolInstances(workspace: Workspace): ToolInstance[];