@konitif/workbench 0.284.1

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

@@ -0,0 +1,207 @@
+import type { JsonObject } from "../shared/json.js";
+import type { KonitifToolCapabilities } from '@konitif/core';
+import type { WorkbenchIconInput } from "../icon/model.js";
+import type { ShellRegionId } from "../shell/model.js";
+import type { WorkbenchReadingLevel, WorkbenchReadingLevelPresentation } from "../presentation/readingLevel.js";
+export type ToolOpeningPolicy = {
+    mode: 'singleton-global';
+    onOpen: 'focus-existing';
+} | {
+    mode: 'multi-instance';
+};
+export type ToolPanelSplitPolicy = {
+    mode: 'fresh-instance';
+} | {
+    mode: 'clone-serializable-state';
+} | {
+    mode: 'share-instance';
+} | {
+    mode: 'custom';
+};
+export type ToolShellStatusTone = 'neutral' | 'attention' | 'success';
+export interface ToolShellStatus {
+    label: string;
+    tone?: ToolShellStatusTone;
+}
+export interface ToolPanelLoadingState {
+    label: string;
+    detail?: string;
+}
+export interface ToolResourceLoadingState {
+    label: string;
+    detail?: string;
+    /**
+     * Normalized progress ratio in the [0, 1] range.
+     * `null` or `undefined` means indeterminate.
+     */
+    progress?: number | null;
+}
+export interface ToolShellState {
+    status: ToolShellStatus | null;
+    /** Optional user override persisted for this Tool instance only. */
+    readingLevel?: WorkbenchReadingLevel;
+}
+export interface ToolShellCommand {
+    id: string;
+    title: string;
+    description: string;
+    keywords?: string[];
+}
+export interface ToolShellHeaderActionLabelContext {
+    command: ToolShellCommand;
+    definition: ToolDefinition;
+    instance: ToolInstance;
+}
+export interface ToolShellHeaderAction {
+    commandId: string;
+    label: string;
+    icon?: WorkbenchIconInput;
+    group?: 'tool' | 'dock';
+    frequency?: 'common' | 'advanced' | 'debug';
+    headerButton?: boolean;
+    labelTranslationKey?: string;
+    resolveLabel?(context: ToolShellHeaderActionLabelContext): string;
+    resolveLabelTranslationKey?(context: ToolShellHeaderActionLabelContext): string | null;
+    resolveActive?(context: ToolShellHeaderActionLabelContext): boolean;
+    children?: ToolShellHeaderAction[];
+}
+export interface ToolShellWidgetDock {
+    commandId: string;
+    dockId: string;
+    title: string;
+    icon?: WorkbenchIconInput;
+    defaultRegionId: ShellRegionId;
+    defaultVisible?: boolean;
+    legacyVisibleKey?: string | null;
+    rootWidgetId?: string | null;
+    showLabel?: string;
+    hideLabel?: string;
+    showTranslationKey?: string;
+    hideTranslationKey?: string;
+}
+export interface ToolShellCommandContext {
+    commandId: string;
+    definition: ToolDefinition;
+    instance: ToolInstance;
+}
+export interface ToolShellCommandResult {
+    nextState?: JsonObject;
+    nextPanelTitleOverride?: string | null;
+    nextStatus?: ToolShellStatus | null;
+}
+export interface ToolShellContributionDefinition {
+    initialStatus?: ToolShellStatus | null;
+    /**
+     * Selects the single surface responsible for rendering the Tool status.
+     * The panel chrome remains the compatibility default; Tools that already
+     * expose the status in their own header must opt into `tool-header` to avoid
+     * projecting the same information twice.
+     */
+    statusPlacement?: 'panel-chrome' | 'tool-header';
+    commands?: ToolShellCommand[];
+    headerActions?: ToolShellHeaderAction[];
+    widgetDocks?: ToolShellWidgetDock[];
+    executeCommand?(context: ToolShellCommandContext): ToolShellCommandResult | null;
+}
+export type ToolFullscreenCompanionPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export interface ToolFullscreenCompanionSize {
+    width: number;
+    height: number;
+}
+export interface ToolFullscreenCompanionChromePolicy {
+    header?: boolean;
+    menu?: boolean;
+    fullscreen?: boolean;
+    dockButtons?: boolean;
+}
+export interface ToolFullscreenCompanionBehaviorPolicy {
+    pinned?: boolean;
+    draggable?: boolean;
+    collapsible?: boolean;
+    passthroughWhenCollapsed?: boolean;
+}
+export interface ToolFullscreenCompanionActivationPolicy {
+    sourceStateKey: string;
+    defaultEnabled?: boolean;
+}
+export interface ToolFullscreenCompanionDefinition {
+    id: string;
+    toolId: string;
+    mode: string;
+    sourceStateKeys?: string[];
+    placement: ToolFullscreenCompanionPlacement;
+    size: ToolFullscreenCompanionSize;
+    chrome?: ToolFullscreenCompanionChromePolicy;
+    behavior?: ToolFullscreenCompanionBehaviorPolicy;
+    activation?: ToolFullscreenCompanionActivationPolicy;
+}
+export interface ToolDefinition {
+    id: string;
+    title: string;
+    icon?: WorkbenchIconInput;
+    /**
+     * Default panel title applied when a tool is opened into a panel.
+     */
+    panelTitle: string;
+    description: string;
+    keywords?: string[];
+    openingPolicy: ToolOpeningPolicy;
+    /**
+     * Versioned capabilities supplied and consumed by the Tool.
+     * The Workbench resolves these declarations against its registered catalog and
+     * projects availability to the hosted Tool without exposing neighboring state.
+     */
+    capabilities?: KonitifToolCapabilities;
+    /**
+     * Future-facing split semantics:
+     * - `fresh-instance`: create a brand new tool instance in the new panel
+     * - `clone-serializable-state`: duplicate from current serializable state into a new instance
+     * - `share-instance`: point both panels at the same tool instance
+     * - `custom`: reserved for tool-specific logic later
+     *
+     * Current workbench behavior still preserves the existing panel/tool instance during layout reorganizations,
+     * and does not yet automatically duplicate tools on split.
+     */
+    panelSplitPolicy?: ToolPanelSplitPolicy;
+    /** Generic shell presentation preferences declared by the hosted tool. */
+    panelPresentation?: {
+        immersiveWhenTabsHidden?: boolean;
+        /** Optional shared Casual / Advanced / Expert projection contract. */
+        readingLevel?: WorkbenchReadingLevelPresentation;
+    };
+    /**
+     * Serializable default instance state used when creating a new tool instance.
+     */
+    initialState: JsonObject;
+    /**
+     * Optional shell-facing contribution surface resolved by the workbench.
+     */
+    shell?: ToolShellContributionDefinition;
+    /**
+     * Optional companion tools rendered by the shell when this tool owns a fullscreen panel.
+     * The fullscreen tool declares the companion relationship; the companion tool provides a
+     * mode-specific projection through its normal component surface.
+     */
+    fullscreenCompanions?: ToolFullscreenCompanionDefinition[];
+}
+export interface ToolInstance {
+    id: string;
+    toolId: string;
+    /**
+     * Serializable instance state owned by the workspace snapshot.
+     */
+    state: JsonObject;
+    /**
+     * Optional serializable title override requested by the hosted tool runtime.
+     * `null` means "use the ToolDefinition.panelTitle default".
+     */
+    panelTitleOverride: string | null;
+    /**
+     * Optional serializable shell-facing state controlled through the tool runtime.
+     */
+    shellState?: ToolShellState;
+}
+export interface ToolCatalogPort {
+    getDefinition(toolId: string): ToolDefinition | undefined;
+}
+export type ToolCatalog = ToolCatalogPort;

package/dist/domain/tool/model.js

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

package/dist/domain/tool/runtime.d.ts

@@ -0,0 +1,122 @@
+import type { JsonObject } from "../shared/json.js";
+import type { KonitifToolConsumedCapability } from '@konitif/core';
+import type { WorkbenchRuntimeProjectionSessionPatch } from "../runtime/model.js";
+import type { WorkbenchReadingLevel } from "../presentation/readingLevel.js";
+import type { ToolDefinition, ToolInstance, ToolPanelLoadingState, ToolResourceLoadingState, ToolShellStatus } from "./model.js";
+export * from "./shell.js";
+export interface ToolRuntimeSessionInfo {
+    activePanelId: string | null;
+    activeToolInstanceId: string | null;
+    isActivePanel: boolean;
+    isActiveToolInstance: boolean;
+    layoutEditingEnabled: boolean;
+}
+export type ToolRuntimeCapabilityAvailability = 'missing' | 'incompatible' | 'available' | 'mounted' | 'active';
+export interface ToolRuntimeCapabilityProvider {
+    toolId: string;
+    capabilityVersion: string;
+    toolVersion: string | null;
+    availability: 'available' | 'mounted' | 'active';
+    panelIds: readonly string[];
+    toolInstanceIds: readonly string[];
+}
+export interface ToolRuntimeCapabilityProjection {
+    requirement: Readonly<KonitifToolConsumedCapability>;
+    availability: ToolRuntimeCapabilityAvailability;
+    providers: readonly ToolRuntimeCapabilityProvider[];
+}
+export interface ToolRuntimeCapabilitySnapshot {
+    list(): readonly ToolRuntimeCapabilityProjection[];
+    get(capabilityId: string): ToolRuntimeCapabilityProjection | null;
+}
+export interface ToolRuntimeCapabilityAccess extends ToolRuntimeCapabilitySnapshot {
+    /** Ask the shell to focus an existing compatible provider or open one. */
+    request(capabilityId: string): boolean;
+}
+export interface ToolRuntimeContext {
+    /**
+     * Stable identity for the currently hosted tool instance.
+     */
+    toolInstanceId: string;
+    /**
+     * Stable identity for the panel currently hosting the tool.
+     */
+    panelId: string;
+    /** Shell-owned reading projection for the hosted Tool. */
+    readingLevel: WorkbenchReadingLevel;
+    /**
+     * Readonly session/focus snapshot for the current render.
+     */
+    session: Readonly<ToolRuntimeSessionInfo>;
+    /** Shell-owned, readonly projection of the capabilities declared by this Tool. */
+    capabilities: ToolRuntimeCapabilityAccess;
+    /**
+     * Replace the tool's serializable state snapshot.
+     * Returns `false` when the payload is rejected.
+     */
+    setState(nextState: JsonObject): boolean;
+    /**
+     * Override the displayed panel title. Pass `null` to restore the definition default.
+     * Returns `false` when the target panel or instance can no longer be resolved.
+     */
+    setPanelTitleOverride(nextTitle: string | null): boolean;
+    /**
+     * Update the tool's serializable shell status contribution. Pass `null` to clear it.
+     * Returns `false` when the target instance can no longer be resolved.
+     */
+    setShellStatus(nextStatus: ToolShellStatus | null): boolean;
+    /**
+     * Update the panel-scoped loading overlay controlled by the hosted tool.
+     * Returns `false` when the target instance can no longer be resolved.
+     */
+    setPanelLoading(nextLoading: ToolPanelLoadingState | null): boolean;
+    /**
+     * Update the top docked resource loading indicator controlled by the hosted tool.
+     * Returns `false` when the target instance can no longer be resolved.
+     */
+    setResourceLoading(nextLoading: ToolResourceLoadingState | null): boolean;
+    /**
+     * Publish session-level projection metadata such as selected/focused entities.
+     * Returns `false` when the host does not expose a projection session bridge.
+     */
+    publishRuntimeProjectionSession(patch: WorkbenchRuntimeProjectionSessionPatch): boolean;
+    /**
+     * Execute a registered shell command against the current tool instance.
+     * Returns `false` when the command cannot be resolved or does not change state.
+     */
+    runCommand(commandId: string): boolean;
+    /**
+     * Ask the workspace host to open or focus a registered tool.
+     * Returns `false` when the tool cannot be resolved or workspace state is unchanged.
+     */
+    openTool(toolId: string): boolean;
+    /**
+     * Returns whether the global app history currently exposes an undo step.
+     */
+    canUndoHistory(): boolean;
+    /**
+     * Returns whether the global app history currently exposes a redo step.
+     */
+    canRedoHistory(): boolean;
+    /**
+     * Undo the last app-scoped workspace mutation.
+     * Returns `false` when no history step is available.
+     */
+    undoHistory(): boolean;
+    /**
+     * Redo the last reverted app-scoped workspace mutation.
+     * Returns `false` when no history step is available.
+     */
+    redoHistory(): boolean;
+}
+/**
+ * Lifecycle boundaries for hosted tools:
+ * - mount: the tool component is instantiated by ToolHost for a resolved panel/tool pair
+ * - restore: serialized ToolInstance.state is provided as normal props on mount; there is no separate hydrate hook
+ * - unmount: the component is removed when the host panel closes, changes tool instance, or leaves the tree
+ */
+export interface HostedToolProps {
+    definition: ToolDefinition;
+    instance: ToolInstance;
+    runtime: ToolRuntimeContext;
+}

package/dist/domain/tool/runtime.js

@@ -0,0 +1,2 @@
+// Compatibility facade: shell helpers have one implementation, independent of runtime services.
+export * from "./shell.js";

package/dist/domain/tool/shell.d.ts

@@ -0,0 +1,38 @@
+import { type WorkbenchReadingLevel } from "../presentation/readingLevel.js";
+import type { WorkbenchIconInput } from "../icon/model.js";
+import type { ToolDefinition, ToolInstance, ToolPanelLoadingState, ToolResourceLoadingState, ToolShellCommand, ToolShellWidgetDock, ToolShellState, ToolShellStatus } from "./model.js";
+export declare function normalizePanelTitleOverride(value: string | null): string | null;
+export declare function normalizeToolShellStatus(value: unknown): ToolShellStatus | null;
+export declare function normalizeToolPanelLoadingState(value: ToolPanelLoadingState | null | undefined): ToolPanelLoadingState | null;
+export declare function normalizeToolResourceLoadingState(value: ToolResourceLoadingState | null | undefined): ToolResourceLoadingState | null;
+export declare function createInitialToolShellState(definition: ToolDefinition): ToolShellState;
+export declare const TOOL_READING_LEVEL_MENU_COMMAND_ID = "workbench.tool.reading-level";
+export declare const CYCLE_TOOL_READING_LEVEL_COMMAND_ID = "workbench.tool.reading-level.cycle";
+export declare const INHERIT_TOOL_READING_LEVEL_COMMAND_ID = "workbench.tool.reading-level.inherit";
+export declare const SET_TOOL_READING_LEVEL_CASUAL_COMMAND_ID = "workbench.tool.reading-level.casual";
+export declare const SET_TOOL_READING_LEVEL_ADVANCED_COMMAND_ID = "workbench.tool.reading-level.advanced";
+export declare const SET_TOOL_READING_LEVEL_EXPERT_COMMAND_ID = "workbench.tool.reading-level.expert";
+export declare function resolveToolReadingLevel(definition: ToolDefinition, instance: ToolInstance, inheritedDefault?: WorkbenchReadingLevel): WorkbenchReadingLevel;
+export declare function resolvePanelTitle(definition: ToolDefinition, instance: ToolInstance): string;
+export interface ResolvedToolShellHeaderAction {
+    commandId: string;
+    label: string;
+    icon?: WorkbenchIconInput;
+    group: 'tool' | 'dock';
+    frequency?: 'common' | 'advanced' | 'debug';
+    headerButton?: boolean;
+    active?: boolean;
+    labelTranslationKey?: string;
+    title: string;
+    description: string;
+    keywords?: string[];
+    children?: ResolvedToolShellHeaderAction[];
+}
+export interface ResolvedToolShellContribution {
+    status: ToolShellStatus | null;
+    statusPlacement: 'panel-chrome' | 'tool-header';
+    commands: ToolShellCommand[];
+    headerActions: ResolvedToolShellHeaderAction[];
+    widgetDocks: ToolShellWidgetDock[];
+}
+export declare function resolveToolShellContribution(definition: ToolDefinition, instance: ToolInstance, inheritedReadingLevel?: WorkbenchReadingLevel): ResolvedToolShellContribution;

package/dist/domain/tool/shell.js

@@ -0,0 +1,175 @@
+import { normalizeWorkbenchReadingLevels, resolveWorkbenchReadingLevel } from "../presentation/readingLevel.js";
+export function normalizePanelTitleOverride(value) {
+    if (value === null) {
+        return null;
+    }
+    const normalizedValue = value.trim();
+    return normalizedValue.length > 0 ? normalizedValue : null;
+}
+export function normalizeToolShellStatus(value) {
+    if (value === null || typeof value !== 'object') {
+        return null;
+    }
+    const candidate = value;
+    if (typeof candidate.label !== 'string') {
+        return null;
+    }
+    const label = candidate.label.trim();
+    if (label.length === 0) {
+        return null;
+    }
+    const tone = candidate.tone ?? 'neutral';
+    return {
+        label,
+        tone: tone === 'attention' || tone === 'success' ? tone : 'neutral'
+    };
+}
+export function normalizeToolPanelLoadingState(value) {
+    if (!value) {
+        return null;
+    }
+    const label = value.label.trim();
+    if (label.length === 0) {
+        return null;
+    }
+    const detail = value.detail?.trim();
+    return detail
+        ? {
+            label,
+            detail
+        }
+        : {
+            label
+        };
+}
+export function normalizeToolResourceLoadingState(value) {
+    if (!value) {
+        return null;
+    }
+    const label = value.label.trim();
+    if (label.length === 0) {
+        return null;
+    }
+    const detail = value.detail?.trim();
+    const rawProgress = value.progress;
+    const progress = typeof rawProgress === 'number' && Number.isFinite(rawProgress)
+        ? Math.max(0, Math.min(rawProgress, 1))
+        : null;
+    return {
+        label,
+        ...(detail ? { detail } : {}),
+        ...(progress === null ? {} : { progress })
+    };
+}
+export function createInitialToolShellState(definition) {
+    return {
+        status: normalizeToolShellStatus(definition.shell?.initialStatus)
+    };
+}
+export const TOOL_READING_LEVEL_MENU_COMMAND_ID = 'workbench.tool.reading-level';
+export const CYCLE_TOOL_READING_LEVEL_COMMAND_ID = 'workbench.tool.reading-level.cycle';
+export const INHERIT_TOOL_READING_LEVEL_COMMAND_ID = 'workbench.tool.reading-level.inherit';
+export const SET_TOOL_READING_LEVEL_CASUAL_COMMAND_ID = 'workbench.tool.reading-level.casual';
+export const SET_TOOL_READING_LEVEL_ADVANCED_COMMAND_ID = 'workbench.tool.reading-level.advanced';
+export const SET_TOOL_READING_LEVEL_EXPERT_COMMAND_ID = 'workbench.tool.reading-level.expert';
+export function resolveToolReadingLevel(definition, instance, inheritedDefault) {
+    return resolveWorkbenchReadingLevel(instance.shellState?.readingLevel, definition.panelPresentation?.readingLevel, inheritedDefault);
+}
+export function resolvePanelTitle(definition, instance) {
+    return normalizePanelTitleOverride(instance.panelTitleOverride) ?? definition.panelTitle;
+}
+export function resolveToolShellContribution(definition, instance, inheritedReadingLevel) {
+    const readingLevelPresentation = definition.panelPresentation?.readingLevel;
+    const availableReadingLevels = normalizeWorkbenchReadingLevels(readingLevelPresentation);
+    const readingLevel = resolveToolReadingLevel(definition, instance, inheritedReadingLevel);
+    const exposesReadingLevelChoice = availableReadingLevels.length > 1;
+    const readingCommands = exposesReadingLevelChoice
+        ? [
+            {
+                id: TOOL_READING_LEVEL_MENU_COMMAND_ID,
+                title: 'Reading level',
+                description: 'Cycle the Tool projection through its available reading levels.'
+            },
+            {
+                id: INHERIT_TOOL_READING_LEVEL_COMMAND_ID,
+                title: 'Use default reading level',
+                description: 'Remove the local override and use the Tool or shell default.'
+            },
+            ...availableReadingLevels.map((level) => ({
+                id: `workbench.tool.reading-level.${level}`,
+                title: `${level[0]?.toUpperCase()}${level.slice(1)} reading level`,
+                description: `Project this Tool at the ${level} reading level.`
+            }))
+        ]
+        : [];
+    const commands = [...(definition.shell?.commands ?? []), ...readingCommands];
+    const commandsById = new Map(commands.map((command) => [command.id, command]));
+    const resolveHeaderAction = (action) => {
+        const command = commandsById.get(action.commandId);
+        if (!command) {
+            return null;
+        }
+        const children = (action.children ?? []).flatMap((child) => {
+            const resolvedChild = resolveHeaderAction(child);
+            return resolvedChild ? [resolvedChild] : [];
+        });
+        const active = action.resolveActive?.({ command, definition, instance }) ?? false;
+        return {
+            commandId: action.commandId,
+            label: action.resolveLabel?.({ command, definition, instance }) || action.label,
+            icon: action.icon,
+            group: action.group ?? 'tool',
+            frequency: action.frequency,
+            ...(action.headerButton ? { headerButton: true } : {}),
+            ...(active ? { active } : {}),
+            labelTranslationKey: action.resolveLabelTranslationKey?.({ command, definition, instance }) ?? action.labelTranslationKey,
+            title: command.title,
+            description: command.description,
+            keywords: command.keywords,
+            ...(children.length > 0 ? { children } : {})
+        };
+    };
+    const readingLevelAction = exposesReadingLevelChoice
+        ? [
+            {
+                commandId: TOOL_READING_LEVEL_MENU_COMMAND_ID,
+                label: 'Reading level',
+                labelTranslationKey: 'ui.shell.tool.readingLevel.label',
+                icon: 'action.settings',
+                group: 'tool',
+                frequency: 'advanced',
+                children: [
+                    {
+                        commandId: INHERIT_TOOL_READING_LEVEL_COMMAND_ID,
+                        label: 'Use default',
+                        labelTranslationKey: 'ui.shell.readingLevel.inherit',
+                        group: 'tool',
+                        frequency: 'advanced',
+                        resolveActive: () => instance.shellState?.readingLevel === undefined
+                    },
+                    ...availableReadingLevels.map((level) => ({
+                        commandId: `workbench.tool.reading-level.${level}`,
+                        label: `${level[0]?.toUpperCase()}${level.slice(1)}`,
+                        labelTranslationKey: `ui.shell.readingLevel.${level}`,
+                        group: 'tool',
+                        frequency: 'advanced',
+                        resolveActive: () => instance.shellState?.readingLevel !== undefined && readingLevel === level
+                    }))
+                ]
+            }
+        ]
+        : [];
+    const headerActions = [...(definition.shell?.headerActions ?? []), ...readingLevelAction].flatMap((action) => {
+        const resolvedAction = resolveHeaderAction(action);
+        return resolvedAction ? [resolvedAction] : [];
+    });
+    return {
+        status: instance.shellState
+            ? normalizeToolShellStatus(instance.shellState.status)
+            : normalizeToolShellStatus(definition.shell?.initialStatus),
+        statusPlacement: definition.shell?.statusPlacement ?? 'panel-chrome',
+        commands,
+        headerActions,
+        widgetDocks: (definition.shell?.widgetDocks ?? []).map((dock) => ({ ...dock }))
+    };
+}

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

@@ -0,0 +1,79 @@
+import type { WorkbenchIconInput } from "../icon/model.js";
+import type { JsonObject } from "../shared/json.js";
+export type WorkbenchWidgetZoneSurface = 'shell' | 'panel' | 'panel-header' | 'panel-footer' | 'side' | 'tool' | 'tool-dock';
+export type WorkbenchWidgetZoneChrome = 'none' | 'header' | 'tabs';
+export type WorkbenchWidgetZonePresentation = 'tabs' | 'stack';
+export type WorkbenchWidgetZoneAxis = 'horizontal' | 'vertical';
+export interface WorkbenchWidgetZoneDefinition {
+    id: string;
+    title: string;
+    surface: WorkbenchWidgetZoneSurface;
+    chrome?: WorkbenchWidgetZoneChrome;
+    /** How multiple placements are projected inside the zone. Defaults to tabs. */
+    presentation?: WorkbenchWidgetZonePresentation;
+    /** Ordering axis used by stacked zones and their drag/drop projection. */
+    axis?: WorkbenchWidgetZoneAxis;
+    icon?: WorkbenchIconInput;
+    description?: string;
+}
+export interface WorkbenchWidgetPlacement {
+    id: string;
+    widgetId: string;
+    zoneId: string;
+    title: string;
+    order?: number;
+    icon?: WorkbenchIconInput;
+    isVisible?: boolean;
+    isPinned?: boolean;
+    state?: JsonObject;
+}
+export interface WorkbenchWidgetZoneComposition {
+    zones: WorkbenchWidgetZoneDefinition[];
+    placements: WorkbenchWidgetPlacement[];
+    activePlacementByZoneId?: Record<string, string | null | undefined>;
+}
+export interface WorkbenchWidgetZoneLayoutState {
+    activePlacementId?: string | null;
+    placementOrder?: string[];
+    hiddenPlacementIds?: string[];
+    pinnedPlacementIds?: string[];
+    presentation?: WorkbenchWidgetZonePresentation;
+    axis?: WorkbenchWidgetZoneAxis;
+}
+export type WorkbenchWidgetZoneLayoutStateByZoneId = Record<string, WorkbenchWidgetZoneLayoutState | undefined>;
+export interface WorkbenchWidgetPlacementMove {
+    placementId: string;
+    zoneId: string;
+    beforePlacementId?: string | null;
+    afterPlacementId?: string | null;
+}
+export interface ResolvedWorkbenchWidgetZone {
+    zone: WorkbenchWidgetZoneDefinition;
+    allPlacements: WorkbenchWidgetPlacement[];
+    placements: WorkbenchWidgetPlacement[];
+    activePlacement: WorkbenchWidgetPlacement | null;
+}
+export declare function resolveWorkbenchWidgetZone(composition: WorkbenchWidgetZoneComposition, zoneId: string): ResolvedWorkbenchWidgetZone | null;
+export declare function listWorkbenchWidgetZonePlacements(composition: WorkbenchWidgetZoneComposition, zoneId: string, options?: {
+    includeHidden?: boolean;
+}): WorkbenchWidgetPlacement[];
+/**
+ * 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 declare function listWorkbenchWidgetZoneRenderedPlacements(resolvedZone: ResolvedWorkbenchWidgetZone | null): WorkbenchWidgetPlacement[];
+export declare function compareWorkbenchWidgetPlacements(left: WorkbenchWidgetPlacement, right: WorkbenchWidgetPlacement): number;
+export declare function activateWorkbenchWidgetPlacement(composition: WorkbenchWidgetZoneComposition, zoneId: string, placementId: string): WorkbenchWidgetZoneComposition;
+export declare function moveWorkbenchWidgetPlacement(composition: WorkbenchWidgetZoneComposition, move: WorkbenchWidgetPlacementMove): WorkbenchWidgetZoneComposition;
+export declare function createWorkbenchWidgetZoneLayoutState(composition: WorkbenchWidgetZoneComposition, zoneId: string): WorkbenchWidgetZoneLayoutState;
+export declare function applyWorkbenchWidgetZoneLayoutState(composition: WorkbenchWidgetZoneComposition, layoutStateByZoneId: WorkbenchWidgetZoneLayoutStateByZoneId): WorkbenchWidgetZoneComposition;
+export declare function createWorkbenchWidgetZoneComposition(input: {
+    zone: WorkbenchWidgetZoneDefinition;
+    placements: WorkbenchWidgetPlacement[];
+    activePlacementId?: string | null;
+}): WorkbenchWidgetZoneComposition;
+export declare function createSingleWorkbenchWidgetZoneComposition(input: {
+    zone: WorkbenchWidgetZoneDefinition;
+    placement: WorkbenchWidgetPlacement;
+}): WorkbenchWidgetZoneComposition;