@pstdio/workbench 0.2.1 → 0.4.0

package/dist/react.d.ts

@@ -11,6 +11,7 @@ import { ParamEditorProps } from '@pstdio/ui';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
+import { ResourceContextAction as ResourceContextAction_2 } from '@pstdio/ui';
 import { TerminalBridge } from '@pstdio/ui/terminal';
 import { ThemePreference as ThemePreference_3 } from '@pstdio/ui';
 import { ThemePreferenceOption as ThemePreferenceOption_3 } from '@pstdio/ui';
@@ -25,7 +26,7 @@ declare interface AttributeDescriptor {
     displayable?: boolean;
     editable?: boolean;
     display?: AttributeDisplayDescriptor;
-    render?: (value: unknown, row: DataRendererRow) => ReactNode;
+    render?: (value: unknown, row: KanbanRendererRow) => ReactNode;
     compare?: (a: unknown, b: unknown) => number;
 }
 
@@ -95,7 +96,7 @@ declare interface CollectionSettingsPanel<TItem = unknown> extends SettingsPanel
     itemLabel(item: TItem): string;
     itemIcon?(item: TItem): string | undefined;
     groupBy?: SettingsCollectionGroupBy<TItem>;
-    renderItem(item: TItem, input: WorkbenchWidgetRenderInput): unknown;
+    renderItem(item: TItem, input: WorkbenchPanelRenderInput): unknown;
     actions?: SettingsAction[];
 }
 
@@ -271,8 +272,6 @@ declare interface ControlsQueryResult {
     readOnly?: boolean;
 }
 
-declare type ControlsRendererArea = "main-right" | "secondary" | "overlay";
-
 declare interface ControlsRendererContribution {
     id: string;
     title: string;
@@ -292,12 +291,12 @@ declare interface ControlsRendererContribution {
     subscribe?: (listener: () => void) => Disposable_2 | (() => void);
 }
 
-declare type ControlsRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+declare type ControlsRendererImplementation = (input: WorkbenchPanelRenderInput & {
     controlsRendererId: string;
 }) => unknown;
 
 declare interface ControlsRendererLayout {
-    area?: ControlsRendererArea;
+    region?: ControlsRendererRegion;
     defaultPx?: number;
     minPx?: number;
     maxPx?: number;
@@ -309,6 +308,8 @@ declare interface ControlsRendererRefreshEvent {
 
 declare type ControlsRendererRefreshListener = (event: ControlsRendererRefreshEvent) => void;
 
+declare type ControlsRendererRegion = "main-right-menu" | "secondary" | "overlay";
+
 declare interface ControlsRendererRegistry {
     controlsStore: WorkbenchStore<ControlsRendererStoreState>;
     registerControlsRenderer(contribution: ControlsRendererContribution, metadata?: ContributionMetadata): Disposable_2;
@@ -369,10 +370,12 @@ declare interface CreateWorkbenchRendererRegistryInput {
     createHost?: () => HTMLElement;
 }
 
+export declare const createWorkbenchResourceActions: (workbench: WorkbenchCoreContributionContext, resource: ResourceRef) => ResourceContextAction_2[];
+
 export declare const createWorkbenchSettingsModule: (options?: WorkbenchSettingsModuleOptions) => WorkbenchModuleContribution;
 
 /**
- * Host-owned terminal surface: tabbed placements in the `secondary` area whose
+ * Host-owned terminal surface: tabbed placements in the `secondary` region whose
  * chrome, focus, lifecycle, and styling belong to the workbench. Sessions are
  * owned by `workbench.terminal` (the same registry the `terminal.session`
  * webview capability uses); the host injects a session opener via
@@ -387,108 +390,123 @@ export declare const createWorkbenchTerminalModule: () => WorkbenchModuleContrib
  */
 declare interface CustomSettingsPanel extends SettingsPanelBase {
     kind: "custom";
-    render(input: WorkbenchWidgetRenderInput): unknown;
+    render(input: WorkbenchPanelRenderInput): unknown;
 }
 
-declare interface DataRendererContribution<TRow extends DataRendererRow = DataRendererRow> {
+declare interface DataTableRendererColumn {
+    id: string;
+    label?: string;
+    description?: string;
+    icon?: unknown;
+    hidden?: boolean;
+    stat?: DataTableRendererColumnStat;
+    renderer?: DataTableRendererColumnRenderer;
+}
+
+declare type DataTableRendererColumnRenderer = {
+    type: "json";
+} | {
+    type: "color-scale";
+    stops: Array<{
+        value: number;
+        color: DataTableRendererThemeColor;
+    }>;
+} | {
+    type: "categorical-color";
+    categories: Array<{
+        value: string | number | boolean | null;
+        color: DataTableRendererThemeColor;
+    }>;
+};
+
+declare type DataTableRendererColumnStat = {
+    type: "unique";
+} | {
+    type: "histogram";
+    bins?: number;
+} | {
+    type: "top-values";
+    limit?: number;
+};
+
+declare interface DataTableRendererContribution {
     id: string;
     title: string;
     resourceKind?: string;
-    /**
-     * Declarative attribute schema. The renderer dispatches filter / group /
-     * sort / display / inline-edit behavior on each descriptor's `type.kind`.
-     *
-     * Pass an `AttributesSource` ({ subscribe, getSnapshot }) instead of a
-     * static array to let the contribution mutate its schema at runtime —
-     * `WorkbenchDataView` subscribes so additions / removals / kind changes
-     * propagate live without re-registering the renderer.
-     */
-    attributes: AttributeDescriptor[] | AttributesSource;
-    /** Per-board-column overrides (color, drag/create rules, custom actions). */
-    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
-    hideToolbar?: boolean;
+    columns?: DataTableRendererColumn[];
+    selectionMode?: "none" | "multiple";
+    selectionActions?: DataTableRendererSelectionAction[];
+    rowActions?: DataTableRendererRowAction[];
+    initialPageSize?: number;
+    pageSizeOptions?: number[];
     emptyTitle?: string;
     emptyDescription?: string;
-    /** Initial settings/filters applied when the data renderer mounts. */
-    defaultSettings?: Partial<DataRendererSettings>;
-    defaultFilters?: DataRendererFilterState;
-    /**
-     * Data source. Receives the current display state so backends can paginate
-     * / filter / sort. The renderer re-applies filter / sort / group locally,
-     * so this can return unfiltered rows in simple cases.
-     */
-    executeQuery(state: DataRendererQueryState): Promise<TRow[]> | TRow[];
+    executeQuery(context: DataTableRendererQueryContext): Promise<DataTableRendererQueryResult> | DataTableRendererQueryResult;
     subscribe?: (listener: () => void) => Disposable_2 | (() => void);
-    /** Row interactions surfaced by the renderer (mirrored from <DataRenderer>). */
-    onRowClick?: (row: TRow) => void;
-    /** Per-row right-click context menu actions (mirrored from <DataRenderer>). */
-    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
-    /**
-     * Fires for inline attribute edits AND for cross-column drag-to-reorder on
-     * the board (the renderer passes the grouping attribute id + the target
-     * column value).
-     */
-    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
-    /** Manual within-column reorder (only fires when ordering is manual). */
-    onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
-    onCreateRow?: (columnId: string) => void;
-    onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
+    onRowClick?: (row: DataTableRendererRow) => void;
 }
 
-declare type DataRendererFilterState = Record<string, string[]>;
-
-declare type DataRendererImplementation = (input: WorkbenchWidgetRenderInput & {
-    dataRendererId: string;
+declare type DataTableRendererImplementation = (input: WorkbenchPanelRenderInput & {
+    dataTableRendererId: string;
 }) => unknown;
 
-declare interface DataRendererOrdering {
-    attributeId: string | typeof MANUAL_ORDERING;
-    direction: SortDirection;
+declare interface DataTableRendererQueryContext {
+    resource?: ResourceRef;
+    modeId?: string;
 }
 
-declare interface DataRendererQueryState {
-    settings: DataRendererSettings;
-    filters: DataRendererFilterState;
+declare interface DataTableRendererQueryResult {
+    rows: DataTableRendererRow[];
+    columns?: DataTableRendererColumn[];
 }
 
-declare interface DataRendererRefreshEvent {
-    dataRendererId: string;
+declare interface DataTableRendererRefreshEvent {
+    dataTableRendererId: string;
 }
 
-declare type DataRendererRefreshListener = (event: DataRendererRefreshEvent) => void;
+declare interface DataTableRendererRegistry {
+    dataTableStore: WorkbenchStore<DataTableRendererStoreState>;
+    registerDataTableRenderer(contribution: DataTableRendererContribution, metadata?: ContributionMetadata): Disposable_2;
+    setDataTableRendererImplementation(implementation: DataTableRendererImplementation): void;
+    getDataTableRenderer(id: string): RegisteredDataTableRendererContribution | undefined;
+    listDataTableRenderers(): RegisteredDataTableRendererContribution[];
+    refreshDataTableRenderer(id: string): void;
+    onDidRefreshDataTableRenderer(listener: (event: DataTableRendererRefreshEvent) => void): Disposable_2;
+}
 
-declare interface DataRendererRegistry {
-    dataStore: WorkbenchStore<DataRendererStoreState>;
-    registerDataRenderer<TRow extends DataRendererRow = DataRendererRow>(contribution: DataRendererContribution<TRow>, metadata?: ContributionMetadata): Disposable_2;
-    setDataRendererImplementation(impl: DataRendererImplementation): void;
-    getDataRenderer(id: string): RegisteredDataRendererContribution | undefined;
-    listDataRenderers(): RegisteredDataRendererContribution[];
-    refreshDataRenderer(id: string): void;
-    onDidRefreshDataRenderer(listener: DataRendererRefreshListener): Disposable_2;
+declare interface DataTableRendererRow {
+    id: string;
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
 }
 
-declare interface DataRendererRow {
+declare interface DataTableRendererRowAction {
     id: string;
-    title: string;
-    /**
-     * Optional navigation handle. When set, the renderer's default click handler
-     * routes through the contribution's onRowClick (which typically opens the
-     * resource via the workbench).
-     */
-    resource?: unknown;
-    attributes: Record<string, unknown>;
+    label: string;
+    icon?: unknown;
+    destructive?: boolean;
+    run(row: DataTableRendererRow): Promise<void> | void;
 }
 
-declare interface DataRendererSettings {
-    viewMode: ViewMode;
-    columnGrouping: string | typeof NO_GROUPING;
-    rowGrouping: string | typeof NO_GROUPING;
-    ordering: DataRendererOrdering;
-    displayProperties: string[];
+declare interface DataTableRendererSelectionAction {
+    id: string;
+    label: string;
+    icon?: unknown;
+    destructive?: boolean;
+    run(rows: DataTableRendererRow[]): Promise<void> | void;
 }
 
-declare interface DataRendererStoreState {
-    renderers: Record<string, RegisteredDataRendererContribution>;
+declare interface DataTableRendererStoreState {
+    renderers: Record<string, RegisteredDataTableRendererContribution>;
+}
+
+declare interface DataTableRendererThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
 }
 
 declare interface Disposable_2 {
@@ -568,7 +586,7 @@ declare interface FileRendererContribution {
     save?(resource: ResourceRef | undefined, content: string): Promise<void> | void;
 }
 
-declare type FileRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+declare type FileRendererImplementation = (input: WorkbenchPanelRenderInput & {
     fileRendererId: string;
 }) => unknown;
 
@@ -599,28 +617,177 @@ declare interface HistoryController {
     goPrevious(): HistoryEntry | undefined;
     recentlyClosed(): readonly HistoryEntry[];
     reopenLastClosed(): HistoryEntry | undefined;
+    setPersistenceScope(scope: string | undefined): void;
+    getPersistenceScope(): string | undefined;
+    restore(): HistoryEntry | undefined;
+    flush(): void;
     clear(): void;
 }
 
-declare interface HistoryEntry {
-    entryId: string;
-    recordedAt: number;
-    kind: "resource" | "widget" | "mode";
-    modeId?: string;
-    resource?: ResourceRef;
-    widgetId?: string;
-    contributionId?: string;
-    title?: string;
-}
+declare type HistoryEntry = WorkbenchNavigationEntry;
 
 declare interface HistoryStoreState {
-    entries: readonly HistoryEntry[];
+    entries: readonly WorkbenchNavigationEntry[];
     cursor: number;
-    recentlyClosed: readonly HistoryEntry[];
+    recentlyClosed: readonly WorkbenchNavigationEntry[];
+    hydrating: boolean;
 }
 
 export declare const isSettingsScopeVisible: (scope: SettingsScope | undefined, hasProjectScope: boolean) => boolean;
 
+declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    /**
+     * Declarative attribute schema. The renderer dispatches filter / group /
+     * sort / display / inline-edit behavior on each descriptor's `type.kind`.
+     *
+     * Pass an `AttributesSource` ({ subscribe, getSnapshot }) instead of a
+     * static array to let the contribution mutate its schema at runtime —
+     * `WorkbenchKanbanView` subscribes so additions / removals / kind changes
+     * propagate live without re-registering the renderer.
+     */
+    attributes: AttributeDescriptor[] | AttributesSource;
+    /** Per-board-column overrides (color, drag/create rules, custom actions). */
+    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
+    hideToolbar?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Initial settings/filters applied when the kanban renderer mounts. */
+    defaultSettings?: Partial<KanbanRendererSettings>;
+    defaultFilters?: KanbanRendererFilterState;
+    defaultViews?: KanbanRendererSavedView[];
+    defaultActiveViewId?: string;
+    /**
+     * Data source. Receives the current display state so backends can paginate
+     * / filter / sort. The renderer re-applies filter / sort / group locally,
+     * so this can return unfiltered rows in simple cases.
+     */
+    executeQuery(state: KanbanRendererQueryState): Promise<TRow[]> | TRow[];
+    subscribe?: (listener: () => void) => Disposable_2 | (() => void);
+    /** Row interactions surfaced by the renderer (mirrored from <KanbanRenderer>). */
+    onRowClick?: (row: TRow) => void;
+    /** Per-row right-click context menu actions (mirrored from <KanbanRenderer>). */
+    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
+    /**
+     * Fires for inline attribute edits AND for cross-column drag-to-reorder on
+     * the board (the renderer passes the grouping attribute id + the target
+     * column value).
+     */
+    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
+    /** Manual within-column reorder (only fires when ordering is manual). */
+    onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
+    createRow?: KanbanRendererCreateRowConfig;
+    onCreateRow?: (submission: KanbanRendererCreateSubmission) => Promise<void> | void;
+    onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
+}
+
+declare interface KanbanRendererCreateField {
+    id: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    type: KanbanRendererCreateFieldType;
+    required?: boolean;
+    defaultValue?: unknown;
+    options?: EnumOption[];
+    /** `files` fields only. */
+    multiple?: boolean;
+    accept?: string;
+}
+
+declare type KanbanRendererCreateFieldType = "text" | "longtext" | "markdown" | "number" | "boolean" | "select" | "multi-select" | "files";
+
+/** Chrome copy is supplied by the caller so the dialog ships no strings of its own. */
+declare interface KanbanRendererCreateLabels {
+    cancel: string;
+    properties: string;
+    submitError: string;
+    removeFile: string;
+}
+
+declare interface KanbanRendererCreateRowConfig {
+    title: string;
+    submitLabel: string;
+    fields: KanbanRendererCreateField[];
+    labels: KanbanRendererCreateLabels;
+}
+
+declare interface KanbanRendererCreateSubmission {
+    columnId: string;
+    columnAttributeId?: string;
+    /** Declared field values, excluding `files` fields — those arrive as `files`. */
+    values: Record<string, unknown>;
+    /** Every editable attribute the user set, keyed by attribute id. */
+    attributeValues: Record<string, unknown>;
+    files: File[];
+}
+
+declare type KanbanRendererFilterState = Record<string, string[]>;
+
+declare type KanbanRendererImplementation = (input: WorkbenchPanelRenderInput & {
+    kanbanRendererId: string;
+}) => unknown;
+
+declare interface KanbanRendererOrdering {
+    attributeId: string | typeof MANUAL_ORDERING;
+    direction: SortDirection;
+}
+
+declare interface KanbanRendererQueryState {
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+}
+
+declare interface KanbanRendererRefreshEvent {
+    kanbanRendererId: string;
+}
+
+declare type KanbanRendererRefreshListener = (event: KanbanRendererRefreshEvent) => void;
+
+declare interface KanbanRendererRegistry {
+    dataStore: WorkbenchStore<KanbanRendererStoreState>;
+    registerKanbanRenderer<TRow extends KanbanRendererRow = KanbanRendererRow>(contribution: KanbanRendererContribution<TRow>, metadata?: ContributionMetadata): Disposable_2;
+    setKanbanRendererImplementation(impl: KanbanRendererImplementation): void;
+    getKanbanRenderer(id: string): RegisteredKanbanRendererContribution | undefined;
+    listKanbanRenderers(): RegisteredKanbanRendererContribution[];
+    refreshKanbanRenderer(id: string): void;
+    onDidRefreshKanbanRenderer(listener: KanbanRendererRefreshListener): Disposable_2;
+}
+
+declare interface KanbanRendererRow {
+    id: string;
+    title: string;
+    /**
+     * Optional navigation handle. When set, the renderer's default click handler
+     * routes through the contribution's onRowClick (which typically opens the
+     * resource via the workbench).
+     */
+    resource?: unknown;
+    attributes: Record<string, unknown>;
+}
+
+declare interface KanbanRendererSavedView {
+    id: string;
+    title: string;
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+    isDefault?: boolean;
+}
+
+declare interface KanbanRendererSettings {
+    viewMode: ViewMode;
+    columnGrouping: string | typeof NO_GROUPING;
+    rowGrouping: string | typeof NO_GROUPING;
+    ordering: KanbanRendererOrdering;
+    displayProperties: string[];
+}
+
+declare interface KanbanRendererStoreState {
+    renderers: Record<string, RegisteredKanbanRendererContribution>;
+}
+
 declare interface Keybinding {
     commandId: string;
     keybinding: KeybindingSequence;
@@ -646,33 +813,62 @@ declare interface LayoutModel {
     registerPlaceholder(placeholder: PlaceholderContribution, metadata?: ContributionMetadata): {
         dispose(): void;
     };
+    registerPanel(panel: WorkbenchPanelContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
     registerWidget(widget: WidgetContribution, metadata?: ContributionMetadata): {
         dispose(): void;
     };
+    registerLocation(location: WorkbenchLocationContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    registerSubPanel(subPanel: WorkbenchSubPanelContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    registerPanelMenu(panelMenu: WorkbenchPanelMenuContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
     unregisterWidget(id: string, options?: {
         removePlacements?: boolean;
         persist?: boolean;
     }): void;
-    getPlaceholder(areaId: WorkbenchArea_2): RegisteredPlaceholderContribution | undefined;
+    getPlaceholder(regionId: WorkbenchRegion_2): RegisteredPlaceholderContribution | undefined;
     getWidget(id: string): RegisteredWidgetContribution | undefined;
-    getAreaSize(areaId: WorkbenchArea_2): WorkbenchAreaSize | undefined;
-    getAreaCollapsible(areaId: WorkbenchArea_2): boolean;
-    getAreaHeaderBorderBottom(areaId: WorkbenchArea_2): boolean;
-    setAreaVisible(areaId: WorkbenchArea_2, visible: boolean): void;
-    setAreaSize(areaId: WorkbenchArea_2, size: number): void;
+    getPanel(id: string): WorkbenchPanelContribution | undefined;
+    getRegionSize(regionId: WorkbenchRegion_2): WorkbenchRegionSize | undefined;
+    getRegionCollapsible(regionId: WorkbenchRegion_2): boolean;
+    getRegionHeaderBorderBottom(regionId: WorkbenchRegion_2): boolean;
+    setRegionVisible(regionId: WorkbenchRegion_2, visible: boolean): void;
+    setRegionSize(regionId: WorkbenchRegion_2, size: number): void;
     listPlaceholders(): RegisteredPlaceholderContribution[];
     listWidgets(): RegisteredWidgetContribution[];
+    listPanels(): WorkbenchPanelContribution[];
+    listPanelInstances(region?: WorkbenchRegion_2): WorkbenchPanelInstance[];
+    getActivePanel(region?: WorkbenchRegion_2): WorkbenchPanelInstance | undefined;
     openWidget(id: string, input?: OpenWidgetInput): WorkbenchWidgetPlacement;
+    openPanel(id: string, input?: OpenWorkbenchPanelInput): WorkbenchPanelInstance;
+    updatePanel(instanceId: string, input: OpenWorkbenchPanelInput): WorkbenchPanelInstance;
+    reorderPanel(instanceId: string, position: WorkbenchTabPosition): void;
+    activatePanel(instanceId: string): WorkbenchPanelInstance;
+    closePanel(instanceId: string): WorkbenchPanelInstance | undefined;
     updateWidgetPlacement(widgetId: string, input: OpenWidgetInput): WorkbenchWidgetPlacement;
+    reorderWidget(widgetId: string, position: WorkbenchTabPosition): void;
+    expirePreviewTabs(ownerResourceUri?: string): void;
     activateWidget(widgetId: string): WorkbenchWidgetPlacement;
+    setRegionActiveWidget(regionId: WorkbenchRegion_2, widgetId: string | undefined): void;
     closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
     removeWidgetPlacement(widgetId: string): WorkbenchWidgetPlacement | undefined;
-    clearArea(areaId: WorkbenchArea_2): void;
-    resetAreas(): void;
+    clearRegion(regionId: WorkbenchRegion_2): void;
+    resetRegions(): void;
     getLayout(): WorkbenchLayout;
     restoreLayout(layout: WorkbenchLayout): void;
-    setPersistenceScope(scope: LayoutScope | undefined): void;
+    setPersistenceScope(scope: LayoutScope | undefined, input?: {
+        carryRegionState?: readonly WorkbenchRegion_2[];
+    }): void;
     getPersistenceScope(): LayoutScope | undefined;
+    onWillChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+        dispose(): void;
+    };
     onDidChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
         dispose(): void;
     };
@@ -686,6 +882,7 @@ declare const MANUAL_ORDERING = "manual";
 
 declare interface MenuItem {
     commandId: string;
+    sourceCommandId?: string;
     label?: string;
     description?: string;
     icon?: string;
@@ -750,7 +947,13 @@ declare interface NavigationTargetCompound {
     targets: readonly NavigationTargetItem[];
 }
 
-declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetView | NavigationTargetCommand;
+declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetPanel | NavigationTargetCommand;
+
+declare interface NavigationTargetPanel {
+    kind: "panel";
+    panelId: string;
+    input?: OpenWorkbenchPanelInput;
+}
 
 declare interface NavigationTargetResource {
     kind: "resource";
@@ -758,12 +961,6 @@ declare interface NavigationTargetResource {
     input?: OpenResourceInput;
 }
 
-declare interface NavigationTargetView {
-    kind: "view";
-    widgetId: string;
-    input?: OpenWidgetInput;
-}
-
 declare const NO_GROUPING = "none";
 
 export declare const normalizeWorkbenchKeybinding: (keybinding: KeybindingSequence) => KeybindingSequence;
@@ -784,20 +981,39 @@ declare interface OpenResourceInput {
 declare interface OpenWidgetInput {
     resource?: ResourceRef;
     title?: string;
-    area?: WorkbenchArea_2;
+    region?: WorkbenchRegion_2;
     ownerId?: string;
     source?: ContributionSource;
     pinned?: boolean;
     closable?: boolean;
     mountStrategy?: WidgetMountStrategy;
     hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention;
+    tabPosition?: WorkbenchTabPosition;
+    tab?: WorkbenchWidgetTab;
     replaceActive?: boolean;
+    replaceWidgetId?: string;
+}
+
+declare interface OpenWorkbenchPanelInput {
+    resource?: ResourceRef;
+    title?: string;
+    region?: WorkbenchRegion_2;
+    pinned?: boolean;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    tab?: WorkbenchPanelTab;
+    strategy?: WorkbenchPanelOpenStrategy;
 }
 
-export declare const openWorkbenchTerminal: (ctx: WorkbenchCoreContributionContext, input?: OpenWorkbenchTerminalInput) => WorkbenchWidgetPlacement_2;
+export declare const openWorkbenchTerminal: (ctx: WorkbenchCoreContributionContext, input?: OpenWorkbenchTerminalOptions) => WorkbenchPanelInstance_2;
 
 declare type OpenWorkbenchTerminalInput = NonNullable<Parameters<WorkbenchCoreContributionContext["layout"]["openWidget"]>[1]>;
 
+declare type OpenWorkbenchTerminalOptions = OpenWorkbenchTerminalInput & {
+    reveal?: boolean;
+};
+
 declare type ParamValue = Parameters<NonNullable<ParamEditorProps["onChange"]>>[1];
 
 export declare const paramValueToPreference: (schema: PreferencePropertySchema, value: ParamValue) => PreferenceValue;
@@ -805,10 +1021,10 @@ export declare const paramValueToPreference: (schema: PreferencePropertySchema,
 declare interface PlaceholderContribution {
     id: string;
     title: string;
-    area: WorkbenchArea_2;
+    region: WorkbenchRegion_2;
     rendererId: string;
-    areaSize?: WorkbenchAreaSize;
-    areaCollapsible?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
     config?: unknown;
     priority?: number;
 }
@@ -870,12 +1086,15 @@ declare interface RegisteredContributionMetadata {
 declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, RegisteredContributionMetadata {
 }
 
-declare interface RegisteredDataRendererContribution<TRow extends DataRendererRow = DataRendererRow> extends DataRendererContribution<TRow>, RegisteredContributionMetadata {
+declare interface RegisteredDataTableRendererContribution extends DataTableRendererContribution, RegisteredContributionMetadata {
 }
 
 declare interface RegisteredFileRendererContribution extends FileRendererContribution, RegisteredContributionMetadata {
 }
 
+declare interface RegisteredKanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> extends KanbanRendererContribution<TRow>, RegisteredContributionMetadata {
+}
+
 declare interface RegisteredKeepAliveHost {
     rendererId: string;
     host: HTMLElement;
@@ -911,8 +1130,10 @@ declare interface RegisteredTreeRendererContribution extends TreeRendererContrib
 }
 
 declare type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+    ownedPanelMenuIds?: readonly string[];
     singleton: boolean;
     reuse: WidgetReusePolicy;
+    role: WorkbenchWidgetRole;
 } & RegisteredContributionMetadata;
 
 declare interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
@@ -926,7 +1147,9 @@ declare interface RegisteredWorkbenchNotification extends RegisteredContribution
     metadata?: Record<string, unknown>;
 }
 
-declare type ResolvedResourceOpener = Required<ResourceOpener>;
+declare type ResolvedResourceHierarchyProvider = Required<ResourceHierarchyProvider>;
+
+declare type ResolvedResourcePresenter = Required<ResourcePresenter>;
 
 declare interface ResourceBrowseEntry {
     resource: ResourceRef;
@@ -948,6 +1171,13 @@ declare interface ResourceContextAction {
     separatorBefore?: boolean;
 }
 
+declare interface ResourceHierarchyProvider {
+    id: string;
+    priority?: number;
+    canResolve(resource: ResourceRef): boolean;
+    getParent(resource: ResourceRef): ResourceRef | undefined;
+}
+
 declare interface ResourceKindContribution {
     kind: string;
     label: string;
@@ -968,11 +1198,11 @@ declare interface ResourceNavigator<TResult = unknown> {
     navigate(resource: ResourceRef): TResult | Promise<TResult>;
 }
 
-declare interface ResourceOpener<TResult = unknown> {
+declare interface ResourcePresenter {
     id: string;
     priority?: number;
     canOpen(resource: ResourceRef): boolean;
-    open(resource: ResourceRef, input: OpenResourceInput): TResult | Promise<TResult>;
+    open(resource: ResourceRef, input: OpenResourceInput): WorkbenchPanelInstance | Promise<WorkbenchPanelInstance>;
 }
 
 declare interface ResourceProvider {
@@ -1005,19 +1235,24 @@ declare interface ResourceRegistry {
     getKind(kind: string): RegisteredResourceKind | undefined;
     getSurface(resource: ResourceRef): ResourceSurface | undefined;
     listKinds(): RegisteredResourceKind[];
-    registerOpener(opener: ResourceOpener): Disposable_2;
-    listOpeners(): ResolvedResourceOpener[];
+    registerPresenter(presenter: ResourcePresenter): Disposable_2;
+    listPresenters(): ResolvedResourcePresenter[];
     registerProvider(provider: ResourceProvider): Disposable_2;
     listProviders(): ResourceProvider[];
     listResources(query: string): readonly ResourceBrowseEntry[];
-    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<unknown>;
+    registerHierarchyProvider(provider: ResourceHierarchyProvider): Disposable_2;
+    listHierarchyProviders(): ResolvedResourceHierarchyProvider[];
+    walkHierarchy(resource: ResourceRef | undefined): ResourceRef[];
+    isOpeningResource(): boolean;
+    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<WorkbenchPanelInstance>;
     onDidOpenResource(listener: (resource: ResourceRef) => void): Disposable_2;
 }
 
 declare interface ResourceRegistryStoreState {
     kinds: Record<string, RegisteredResourceKind>;
-    openers: Record<string, ResolvedResourceOpener>;
+    presenters: Record<string, ResolvedResourcePresenter>;
     providers: Record<string, ResourceProvider>;
+    hierarchyProviders: Record<string, ResolvedResourceHierarchyProvider>;
 }
 
 declare type ResourceSurface = "primary" | "secondary" | "attached";
@@ -1102,7 +1337,7 @@ declare interface SettingsRegistryStoreState {
 /** Settings are stored either per-user (global) or per-project. Projectless surfaces show only global entries. */
 declare type SettingsScope = "global" | "project";
 
-/** An ordered sidebar container. Headerless when `title` is omitted. */
+/** An ordered sidenav container. Headerless when `title` is omitted. */
 declare interface SettingsSectionContribution {
     id: string;
     title?: string;
@@ -1210,6 +1445,8 @@ declare interface TreeNode {
     hiddenByDefault?: boolean;
     /** When true, the node (e.g. a header/footer row) opts in to the tree's hide/show customization menu. */
     canHide?: boolean;
+    /** When false, the node stays fixed within its Sidenav group. */
+    canReorder?: boolean;
 }
 
 declare type TreeNodeRowVariant = "empty-state";
@@ -1227,7 +1464,7 @@ declare interface TreeRendererContribution {
     getChildren(node: TreeNode, ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
 }
 
-declare type TreeRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+declare type TreeRendererImplementation = (input: WorkbenchPanelRenderInput & {
     treeId: string;
 }) => unknown;
 
@@ -1285,9 +1522,13 @@ declare interface TreeViewSection {
     hiddenByDefault?: boolean;
     /** When true, the section (category) opts in to the tree's hide/show customization menu. */
     canHide?: boolean;
+    /** When false, the section stays fixed within the Sidenav main region. */
+    canReorder?: boolean;
 }
 
-export declare const useWorkbenchClaim: () => WorkbenchWidgetRenderInput | undefined;
+export declare const useWorkbenchClaim: () => WorkbenchPanelRenderInput | undefined;
+
+export declare const useWorkbenchResourceActionResolver: (workbench: WorkbenchCoreContributionContext) => (resource: ResourceRef) => ResourceContextAction_2[];
 
 export declare const useWorkbenchStore: <TState, TSlice>(store: WorkbenchStore<TState>, selector: (state: TState) => TSlice) => TSlice;
 
@@ -1300,8 +1541,8 @@ export declare const useWorkbenchThemePreferences: (workbench: WorkbenchCore) =>
 })[];
 
 /**
- * Core-owned contracts for data renderer contributions. @pstdio/ui's
- * DataRenderer props are structurally identical; the React layer bridges the
+ * Core-owned contracts for kanban renderer contributions. @pstdio/ui's
+ * KanbanRenderer props are structurally identical; the React layer bridges the
  * two, so drift surfaces as a compile error there instead of coupling core's
  * API shape to UI package ownership.
  */
@@ -1310,19 +1551,26 @@ declare type ViewMode = "board" | "list";
 declare interface WidgetContribution {
     id: string;
     title: string;
-    area: WorkbenchArea_2;
-    fallbackArea?: WorkbenchArea_2;
+    icon?: string;
+    region: WorkbenchRegion_2;
+    fallbackRegion?: WorkbenchRegion_2;
     singleton?: boolean;
     reuse?: WidgetReusePolicy;
     mountStrategy?: WidgetMountStrategy;
     closable?: boolean;
     hiddenByDefault?: boolean;
-    areaSize?: WorkbenchAreaSize;
-    areaCollapsible?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
     headerBorderBottom?: boolean;
+    floatingPanels?: WorkbenchFloatingPanelVisibility;
     resourceKinds?: string[];
     priority?: number;
     rendererId: string;
+    openCommandId?: string;
+    role?: WorkbenchWidgetRole;
+    eligibleLocations?: WorkbenchLocationEligibility;
+    panelMenuOwner?: WorkbenchPanelMenuOwner;
+    tab?: WorkbenchWidgetTab;
     config?: unknown;
     canOpen?(resource: ResourceRef): boolean;
 }
@@ -1349,43 +1597,7 @@ export declare const WORKBENCH_TERMINAL_OPEN_COMMAND_ID = "workbench.terminal.op
 
 export declare const WORKBENCH_TERMINAL_WIDGET_ID = "workbench.terminal";
 
-export declare const WorkbenchArea: (props: WorkbenchAreaProps) => JSX.Element | null;
-
-declare type WorkbenchArea_2 = (typeof workbenchAreas)[number];
-
-declare interface WorkbenchAreaProps {
-    workbench: WorkbenchCore;
-    area: WorkbenchArea_2;
-    title?: string;
-    showHeader?: boolean;
-    hideSingleTabHeader?: boolean;
-    pointerEvents?: "auto" | "none";
-    transparent?: boolean;
-}
-
-declare const workbenchAreas: readonly ["nav", "activity", "left-header", "left", "main-header", "main-left", "main", "main-right", "secondary-header", "secondary", "status", "overlay", "floating-header", "floating"];
-
-declare interface WorkbenchAreaSize {
-    defaultPx?: number;
-    minPx?: number;
-    maxPx?: number;
-}
-
-declare interface WorkbenchAreaState {
-    id: WorkbenchArea_2;
-    visible: boolean;
-    size?: number;
-    widgets: WorkbenchWidgetPlacement[];
-    activeWidgetId?: string;
-}
-
-export declare const WorkbenchAreaTabs: (props: WorkbenchAreaTabsProps) => JSX.Element | null;
-
-declare interface WorkbenchAreaTabsProps {
-    workbench: WorkbenchCore;
-    area: WorkbenchArea_2;
-    visibilityStorageKey?: string;
-}
+export declare const WorkbenchAttachedSidePanel: (props: WorkbenchSidePanelProps) => JSX.Element;
 
 declare type WorkbenchBreadcrumbChangeListener = () => void;
 
@@ -1400,6 +1612,7 @@ declare interface WorkbenchBreadcrumbController {
 declare interface WorkbenchBreadcrumbItem {
     title: unknown;
     icon?: string;
+    indicator?: "session-status";
     url?: string;
     onClick?: () => void;
     resource?: ResourceRef;
@@ -1415,10 +1628,18 @@ declare interface WorkbenchBreadcrumbViewProps {
     workbench: WorkbenchCore;
 }
 
-export declare const WorkbenchClaimContext: Context<WorkbenchWidgetRenderInput | undefined>;
+export declare const WorkbenchClaimContext: Context<WorkbenchPanelRenderInput | undefined>;
+
+declare interface WorkbenchClosedSubPanel {
+    region: WorkbenchPanelRegion;
+    reference: WorkbenchSubPanelRef;
+    resource?: ResourceRef;
+    title?: string;
+}
 
 declare interface WorkbenchCommandExecutionContext {
     resource?: ResourceRef;
+    source?: "panel-add";
 }
 
 declare interface WorkbenchCommandExecutionError {
@@ -1484,6 +1705,7 @@ declare interface WorkbenchCommandParamsRequest {
 }
 
 declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
+    host: WorkbenchHost;
     registerModule(module: WorkbenchModuleContribution): Disposable_2;
     unregisterModule(moduleId: string): void;
 }
@@ -1507,7 +1729,8 @@ declare interface WorkbenchCoreContributionContext {
     renderers: WorkbenchRenderers;
     resources: ResourceRegistry;
     settings: SettingsRegistry;
-    sessionPanel: WorkbenchSessionPanelController;
+    shell: WorkbenchShellController;
+    sidePanel: WorkbenchSidePanelController;
     terminal: WorkbenchTerminalController;
     themes: ThemeRegistry;
     fileIconThemes: FileIconThemeRegistry;
@@ -1517,34 +1740,46 @@ declare interface WorkbenchCoreContributionContext {
     onDidChangeActiveResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
 }
 
+export declare const WorkbenchDataTableView: (props: WorkbenchDataTableViewProps) => JSX.Element;
+
+declare interface WorkbenchDataTableViewProps {
+    workbench: WorkbenchCore;
+    contribution: RegisteredDataTableRendererContribution;
+    placement: WorkbenchPanelInstance;
+}
+
 declare interface WorkbenchFileIconThemeStoreState {
     themes: readonly FileIconThemePreferenceOption[];
 }
 
-declare type WorkbenchFocusArea = (typeof workbenchFocusAreas)[number];
+declare type WorkbenchFloatingPanelVisibility = "visible" | "hidden";
 
-declare const workbenchFocusAreas: readonly ["activityBar", "sideBar", "main", "panel", "statusBar"];
+export declare const WorkbenchFloatingSidePanel: (props: WorkbenchSidePanelProps) => JSX.Element | null;
 
-declare type WorkbenchFocusChangeListener = (area: WorkbenchFocusArea | undefined) => void;
+declare type WorkbenchFocusChangeListener = (region: WorkbenchFocusRegionId | undefined) => void;
 
 declare interface WorkbenchFocusController {
     store: WorkbenchStore<WorkbenchFocusState>;
-    setActiveArea(area: WorkbenchFocusArea): void;
+    setActiveRegion(region: WorkbenchFocusRegionId): void;
     clearFocus(): void;
-    getActiveArea(): WorkbenchFocusArea | undefined;
+    getActiveRegion(): WorkbenchFocusRegionId | undefined;
     onDidChange(listener: WorkbenchFocusChangeListener): Disposable_2;
 }
 
 export declare const WorkbenchFocusRegion: (props: WorkbenchFocusRegionProps) => JSX.Element;
 
+declare type WorkbenchFocusRegionId = (typeof workbenchFocusRegions)[number];
+
 declare interface WorkbenchFocusRegionProps extends BoxProps {
     workbench: WorkbenchCore;
-    area: WorkbenchFocusArea;
+    region: WorkbenchFocusRegionId;
     children: ReactNode;
 }
 
+declare const workbenchFocusRegions: readonly ["activity", "sidenav", "main", "secondary", "side", "status"];
+
 declare interface WorkbenchFocusState {
-    activeArea: WorkbenchFocusArea | undefined;
+    activeRegion: WorkbenchFocusRegionId | undefined;
 }
 
 export declare const WorkbenchHeaderActions: (props: WorkbenchHeaderActionsProps) => JSX.Element | null;
@@ -1552,6 +1787,16 @@ export declare const WorkbenchHeaderActions: (props: WorkbenchHeaderActionsProps
 declare interface WorkbenchHeaderActionsProps {
     workbench: WorkbenchCore;
     menuPath: MenuPath;
+    controlSize?: "2xs" | "xs";
+}
+
+declare interface WorkbenchHost {
+    getSnapshot(): WorkbenchSnapshot;
+    restoreSnapshot(snapshot: WorkbenchSnapshot): void;
+    setPersistenceScope(scope: string | undefined, input?: {
+        carryRegions?: readonly WorkbenchRegion_2[];
+    }): void;
+    getPersistenceScope(): string | undefined;
 }
 
 export declare interface WorkbenchHotkeyRegistration {
@@ -1590,8 +1835,10 @@ declare interface WorkbenchLastResourceController {
 }
 
 declare interface WorkbenchLayout {
-    areas: Record<WorkbenchArea_2, WorkbenchAreaState>;
+    regions: Record<WorkbenchRegion_2, WorkbenchRegionState>;
+    locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion, string>>>;
     activeWidgetId?: string;
+    activeLocationWidgetId?: string;
     activeResourceUri?: string;
 }
 
@@ -1600,7 +1847,25 @@ declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
 declare interface WorkbenchLayoutStoreState {
     layout: WorkbenchLayout;
     widgets: Record<string, RegisteredWidgetContribution>;
-    placeholders: Partial<Record<WorkbenchArea_2, RegisteredPlaceholderContribution>>;
+    placeholders: Partial<Record<WorkbenchRegion_2, RegisteredPlaceholderContribution>>;
+}
+
+declare type WorkbenchLocationContribution = Omit<WidgetContribution, "role"> & WorkbenchPanelMenusContribution;
+
+declare interface WorkbenchLocationEligibility {
+    modeIds?: string[];
+    resourceKinds?: string[];
+    resourceIds?: string[];
+    canOpen?(resource: ResourceRef): boolean;
+}
+
+declare interface WorkbenchLocationRef {
+    key: string;
+    modeId?: string;
+    resource?: ResourceRef;
+    contributionId?: string;
+    instanceKey?: string;
+    title?: string;
 }
 
 export declare interface WorkbenchMenuItem {
@@ -1631,16 +1896,24 @@ declare type WorkbenchModeChangeListener = () => void;
 declare interface WorkbenchModeContribution {
     id: string;
     label?: string;
+    panels?: readonly WorkbenchPanelRegion[];
     activate(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+    seed?(ctx: WorkbenchModeActivationContext): void;
+    enter?(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
 }
 
 declare interface WorkbenchModeRegistry {
     store: WorkbenchStore<WorkbenchModeStoreState>;
+    dispose(): void;
     registerMode(mode: WorkbenchModeContribution): Disposable_2;
     getMode(id: string): WorkbenchModeContribution | undefined;
     listModes(): WorkbenchModeContribution[];
     getActiveModeId(): string | undefined;
-    setActiveMode(id: string | undefined): void;
+    isTransitioning(): boolean;
+    setActiveMode(id: string | undefined, input?: {
+        deferSeed?: boolean;
+    }): void;
+    seedActiveMode(): void;
     onDidChangeActive(listener: WorkbenchModeChangeListener): Disposable_2;
 }
 
@@ -1651,6 +1924,8 @@ declare interface WorkbenchModeStoreState {
 
 declare type WorkbenchModuleActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
 
+declare type WorkbenchModuleContext = WorkbenchCoreContributionContext;
+
 declare interface WorkbenchModuleContribution {
     id: string;
     source?: ContributionSource;
@@ -1658,7 +1933,7 @@ declare interface WorkbenchModuleContribution {
     activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
 }
 
-declare type WorkbenchModuleContributionContext = WorkbenchCoreContributionContext;
+declare type WorkbenchModuleContributionContext = WorkbenchModuleContext;
 
 export declare const WorkbenchModuleHost: (props: WorkbenchModuleHostProps) => null;
 
@@ -1671,6 +1946,20 @@ export declare interface WorkbenchModuleHostRegistration {
     disposable: Disposable_2;
 }
 
+declare interface WorkbenchNavigationEntry {
+    entryId: string;
+    recordedAt: number;
+    location: WorkbenchLocationRef;
+    selectedSubPanels: Partial<Record<WorkbenchPanelRegion, WorkbenchSubPanelRef>>;
+    kind: "resource" | "widget" | "mode";
+    modeId?: string;
+    resource?: ResourceRef;
+    widgetId?: string;
+    contributionId?: string;
+    title?: string;
+    closedSubPanel?: WorkbenchClosedSubPanel;
+}
+
 declare interface WorkbenchNotification {
     id?: string;
     level: WorkbenchNotificationLevel;
@@ -1734,20 +2023,171 @@ export declare interface WorkbenchOverlayWidgetConfig {
     closeTriggerTop?: string;
 }
 
+declare interface WorkbenchPanelContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    region: WorkbenchRegion_2;
+    fallbackRegion?: WorkbenchRegion_2;
+    rendererId: string;
+    closable: boolean;
+    singleton?: boolean;
+    reuse?: WorkbenchPanelReusePolicy;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
+    headerBorderBottom?: boolean;
+    floatingPanels?: WorkbenchFloatingPanelVisibility;
+    resourceKinds?: string[];
+    eligibleLocations?: WorkbenchLocationEligibility;
+    priority?: number;
+    openCommandId?: string;
+    tab?: WorkbenchPanelTab;
+    config?: unknown;
+    canOpen?(resource: ResourceRef): boolean;
+    ownerId?: string;
+    source?: ContributionSource;
+    panelMenus?: readonly WorkbenchPanelMenuDefinition[];
+}
+
+declare interface WorkbenchPanelInstance {
+    instanceId: string;
+    panelId: string;
+    ownerId?: string;
+    source?: ContributionSource;
+    resource?: ResourceRef;
+    resourceUri?: string;
+    ownerResourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable: boolean;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention;
+    tab?: WorkbenchPanelTab;
+}
+
+declare interface WorkbenchPanelInstance_2 {
+    instanceId: string;
+    panelId: string;
+    ownerId?: string;
+    source?: ContributionSource_2;
+    resource?: ResourceRef_2;
+    resourceUri?: string;
+    ownerResourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable: boolean;
+    mountStrategy?: WorkbenchPanelMountStrategy_2;
+    hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention_2;
+    tab?: WorkbenchPanelTab_2;
+}
+
+declare type WorkbenchPanelMenuContribution = Omit<WidgetContribution, "region" | "fallbackRegion" | "role"> & {
+    region: WorkbenchPanelMenuRegion;
+    fallbackRegion?: WorkbenchPanelMenuRegion;
+};
+
+declare interface WorkbenchPanelMenuDefinition {
+    id: string;
+    title: string;
+    icon?: string;
+    side: WorkbenchPanelMenuSide;
+    singleton?: boolean;
+    reuse?: WorkbenchPanelReusePolicy;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
+    headerBorderBottom?: boolean;
+    rendererId: string;
+    priority?: number;
+    config?: unknown;
+}
+
+declare type WorkbenchPanelMenuOwner = {
+    level: "panel";
+    contributionId?: string;
+} | {
+    level: "sub-panel";
+    contributionId: string;
+};
+
+declare type WorkbenchPanelMenuRegion = (typeof workbenchPanelMenuRegions)[WorkbenchPanelRegion][WorkbenchPanelMenuSide];
+
+declare const workbenchPanelMenuRegions: {
+    readonly main: {
+        readonly left: "main-left-menu";
+        readonly right: "main-right-menu";
+    };
+    readonly secondary: {
+        readonly left: "secondary-left-menu";
+        readonly right: "secondary-right-menu";
+    };
+    readonly side: {
+        readonly left: "side-left-menu";
+        readonly right: "side-right-menu";
+    };
+};
+
+declare interface WorkbenchPanelMenusContribution {
+    panelMenus?: readonly WorkbenchPanelMenuDefinition[];
+}
+
+declare type WorkbenchPanelMenuSide = "left" | "right";
+
+declare type WorkbenchPanelMountStrategy = WidgetMountStrategy;
+
+declare type WorkbenchPanelMountStrategy_2 = WidgetMountStrategy_2;
+
+declare type WorkbenchPanelOpenStrategy = {
+    kind: "activate-or-open";
+    position?: WorkbenchTabPosition;
+} | {
+    kind: "replace-active";
+} | {
+    kind: "replace-panel";
+    instanceId: string;
+} | {
+    kind: "preview";
+    position?: WorkbenchTabPosition;
+};
+
+declare type WorkbenchPanelRegion = (typeof workbenchPanelRegions)[number];
+
+declare const workbenchPanelRegions: readonly ["main", "secondary", "side"];
+
+export declare interface WorkbenchPanelRenderInput {
+    workbench: WorkbenchCore;
+    panel: WorkbenchPanelContribution | PlaceholderContribution | RegisteredPlaceholderContribution;
+    instance: WorkbenchPanelInstance;
+    refresh: () => void;
+}
+
+declare type WorkbenchPanelReusePolicy = WidgetReusePolicy;
+
 declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
 
 declare interface WorkbenchPanelsController {
     store: WorkbenchStore<WorkbenchPanelsState>;
-    isOpen(areaId: string): boolean;
-    setOpen(areaId: string, open: boolean): void;
-    toggle(areaId: string): void;
+    isOpen(regionId: string): boolean;
+    setOpen(regionId: string, open: boolean): void;
+    toggle(regionId: string): void;
+    setPersistenceScope(scope: string | undefined): void;
+    getPersistenceScope(): string | undefined;
     onDidChange(listener: WorkbenchPanelsChangeListener): Disposable_2;
 }
 
 declare interface WorkbenchPanelsState {
-    openByAreaId: Record<string, boolean>;
+    openByRegionId: Record<string, boolean>;
 }
 
+declare type WorkbenchPanelTab = WorkbenchWidgetTab;
+
+declare type WorkbenchPanelTab_2 = WorkbenchWidgetTab_2;
+
 export declare const WorkbenchPreferencesForm: (props: WorkbenchPreferencesFormProps) => JSX.Element;
 
 export declare interface WorkbenchPreferencesFormProps {
@@ -1768,12 +2208,48 @@ declare interface WorkbenchProps {
     renderParamField?: CommandParamFieldRenderer;
 }
 
+export declare const WorkbenchRegion: (props: WorkbenchRegionProps) => JSX.Element | null;
+
+declare type WorkbenchRegion_2 = (typeof workbenchRegions)[number];
+
+declare interface WorkbenchRegionProps {
+    workbench: WorkbenchCore;
+    region: WorkbenchRegion_2;
+    title?: string;
+    pointerEvents?: "auto" | "none";
+    transparent?: boolean;
+}
+
+declare const workbenchRegions: readonly ["nav", "activity", "sidenav-header", "sidenav", "main-header", "main-left-menu", "main", "main-right-menu", "secondary-header", "secondary-left-menu", "secondary", "secondary-right-menu", "side-header", "side-left-menu", "side", "side-right-menu", "status", "overlay"];
+
+declare interface WorkbenchRegionSize {
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface WorkbenchRegionState {
+    id: WorkbenchRegion_2;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement[];
+    activeWidgetId?: string;
+}
+
+export declare const WorkbenchRegionTabs: (props: WorkbenchRegionTabsProps) => JSX.Element | null;
+
+declare interface WorkbenchRegionTabsProps {
+    workbench: WorkbenchCore;
+    region: WorkbenchRegion_2;
+    visibilityStorageKey?: string;
+}
+
 declare type WorkbenchRendererChangeListener = () => void;
 
 export declare type WorkbenchRendererRegistration = {
     id: string;
     keepAlive?: false;
-    render: (input: WorkbenchWidgetRenderInput) => unknown;
+    render: (input: WorkbenchPanelRenderInput) => unknown;
 } | {
     id: string;
     keepAlive: true;
@@ -1786,50 +2262,68 @@ export declare interface WorkbenchRendererRegistry {
     getRenderer(id: string): WorkbenchRendererRegistration | undefined;
     listRenderers(): WorkbenchRendererRegistration[];
     onDidChange(listener: WorkbenchRendererChangeListener): Disposable_2;
-    claim(rendererId: string, slot: HTMLElement, input: WorkbenchWidgetRenderInput): Disposable_2;
+    claim(rendererId: string, slot: HTMLElement, input: WorkbenchPanelRenderInput): Disposable_2;
     getHost(rendererId: string): HTMLElement | undefined;
-    getClaim(rendererId: string): WorkbenchWidgetRenderInput | undefined;
+    getClaim(rendererId: string): WorkbenchPanelRenderInput | undefined;
 }
 
-declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & DataRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
+declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & KanbanRendererRegistry & DataTableRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
 
 declare interface WorkbenchRendererStoreState {
     renderers: Record<string, WorkbenchRendererRegistration>;
     hosts: Record<string, RegisteredKeepAliveHost>;
-    claims: Record<string, WorkbenchWidgetRenderInput>;
+    claims: Record<string, WorkbenchPanelRenderInput>;
+}
+
+export declare interface WorkbenchSettingsModuleOptions {
+    /** Maps a preference scope (e.g. "project") to its scope id; project entries hide until this resolves. */
+    resolveScopeId?: (scope: PreferenceScope) => string | undefined;
+    /** Heading shown at the top of the settings overlay. */
+    title?: string;
 }
 
-export declare const WorkbenchSessionAttachedPanel: (props: WorkbenchSessionPanelProps) => JSX.Element;
+declare interface WorkbenchShellController {
+    getRegionState(region: WorkbenchRegion_2): WorkbenchShellRegionState;
+    setRegionOpen(region: WorkbenchShellOpenRegion, open: boolean): void;
+    setRegionSize(region: WorkbenchRegion_2, size: number): void;
+    getSidePanelPresentation(): WorkbenchSidePanelPresentation;
+    setSidePanelPresentation(presentation: WorkbenchSidePanelPresentation): void;
+    onDidChange(listener: () => void): Disposable_2;
+}
 
-export declare const WorkbenchSessionBubbleContainer: (props: WorkbenchSessionPanelProps) => JSX.Element | null;
+declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | WorkbenchPanelMenuRegion;
 
-declare type WorkbenchSessionPanelChangeListener = (mode: WorkbenchSessionPanelMode) => void;
+declare interface WorkbenchShellRegionState {
+    open: boolean;
+    size?: number;
+}
+
+declare type WorkbenchSidePanelChangeListener = (mode: WorkbenchSidePanelMode) => void;
 
-declare interface WorkbenchSessionPanelController {
-    store: WorkbenchStore<WorkbenchSessionPanelState>;
-    getMode(): WorkbenchSessionPanelMode;
-    setMode(mode: WorkbenchSessionPanelMode): void;
-    onDidChange(listener: WorkbenchSessionPanelChangeListener): Disposable_2;
+declare interface WorkbenchSidePanelController {
+    store: WorkbenchStore<WorkbenchSidePanelState>;
+    getMode(): WorkbenchSidePanelMode;
+    setMode(mode: WorkbenchSidePanelMode): void;
+    onDidChange(listener: WorkbenchSidePanelChangeListener): Disposable_2;
 }
 
-declare type WorkbenchSessionPanelMode = "bubble" | "closed" | "attached";
+declare type WorkbenchSidePanelMode = "floating" | "closed" | "attached";
+
+declare type WorkbenchSidePanelPresentation = WorkbenchSidePanelMode;
 
-declare interface WorkbenchSessionPanelProps {
+declare interface WorkbenchSidePanelProps {
     workbench: WorkbenchCore;
     contentSlotRef: (node: HTMLDivElement | null) => void;
     bottomOffset?: string;
     header?: ReactNode;
 }
 
-declare interface WorkbenchSessionPanelState {
-    mode: WorkbenchSessionPanelMode;
+declare interface WorkbenchSidePanelState {
+    mode: WorkbenchSidePanelMode;
 }
 
-export declare interface WorkbenchSettingsModuleOptions {
-    /** Maps a preference scope (e.g. "project") to its scope id; project entries hide until this resolves. */
-    resolveScopeId?: (scope: PreferenceScope) => string | undefined;
-    /** Heading shown at the top of the settings overlay. */
-    title?: string;
+declare interface WorkbenchSnapshot {
+    layout: WorkbenchLayout;
 }
 
 declare interface WorkbenchStore<TState> {
@@ -1848,6 +2342,27 @@ declare type WorkbenchStoreSelector<TState, TValue> = (state: TState) => TValue;
 
 declare type WorkbenchStoreSelectorListener<TValue> = (value: TValue, previousValue: TValue) => void;
 
+declare type WorkbenchSubPanelContribution = Omit<WidgetContribution, "region" | "fallbackRegion" | "role"> & {
+    region: WorkbenchPanelRegion;
+    fallbackRegion?: WorkbenchPanelRegion;
+} & WorkbenchPanelMenusContribution;
+
+declare interface WorkbenchSubPanelRef {
+    contributionId: string;
+    resourceUri?: string;
+    instanceKey?: string;
+}
+
+declare type WorkbenchTabPosition = "start" | "end" | {
+    beforeWidgetId: string;
+} | {
+    afterWidgetId: string;
+};
+
+declare type WorkbenchTabRetention = "preview" | "persistent";
+
+declare type WorkbenchTabRetention_2 = "preview" | "persistent";
+
 declare interface WorkbenchTerminalController {
     store: WorkbenchStore<WorkbenchTerminalState>;
     /** True once the host injected a session opener. */
@@ -1882,14 +2397,15 @@ declare interface WorkbenchTerminalController {
 
 /**
  * Body of the host-owned terminal panel. Chrome (tab, title, close action,
- * resize) comes from the workbench `secondary` area; this component only mounts
- * the terminal bound to the workbench terminal controller. Closing the panel
- * unmounts the terminal, which kills its session (close = kill).
+ * resize) comes from the workbench `secondary` region; this component only mounts
+ * the terminal bound to the workbench terminal controller. Collapsing the panel
+ * keeps the terminal mounted. Closing its tab unmounts the terminal and kills
+ * its session (close = kill).
  */
 export declare const WorkbenchTerminalPanel: (props: WorkbenchTerminalPanelProps) => JSX.Element;
 
 declare interface WorkbenchTerminalPanelProps {
-    placement: WorkbenchWidgetPlacement;
+    placement: WorkbenchPanelInstance;
     workbench: WorkbenchCore;
 }
 
@@ -1972,6 +2488,7 @@ declare interface WorkbenchTreeViewProps {
     viewId?: string;
     renderParamField?: CommandParamFieldRenderer;
     onOpenResourceError?: (error: unknown) => void;
+    onSidenavContextActionsChange?: (actions: ResourceContextAction_2[]) => void;
 }
 
 export declare const WorkbenchWidgetHost: (props: WorkbenchWidgetHostProps) => JSX.Element;
@@ -1989,32 +2506,29 @@ declare interface WorkbenchWidgetPlacement {
     source?: ContributionSource;
     resource?: ResourceRef;
     resourceUri?: string;
+    ownerResourceUri?: string;
     title?: string;
     pinned?: boolean;
     closable?: boolean;
     mountStrategy?: WidgetMountStrategy;
     hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention;
+    tab?: WorkbenchWidgetTab;
+    role?: WorkbenchWidgetRole;
 }
 
-declare interface WorkbenchWidgetPlacement_2 {
-    widgetId: string;
-    contributionId: string;
-    ownerId?: string;
-    source?: ContributionSource_2;
-    resource?: ResourceRef_2;
-    resourceUri?: string;
-    title?: string;
-    pinned?: boolean;
-    closable?: boolean;
-    mountStrategy?: WidgetMountStrategy_2;
-    hiddenByDefault?: boolean;
+declare type WorkbenchWidgetRole = "content" | "location" | "sub-panel" | "panel-menu";
+
+declare interface WorkbenchWidgetTab {
+    contentRendererId?: string;
+    /** Custom actions shown when the user activates an already-active tab. */
+    customMenuRendererId?: string;
 }
 
-export declare interface WorkbenchWidgetRenderInput {
-    workbench: WorkbenchCore;
-    widget: RegisteredWidgetContribution | RegisteredPlaceholderContribution;
-    placement: WorkbenchWidgetPlacement;
-    refresh: () => void;
+declare interface WorkbenchWidgetTab_2 {
+    contentRendererId?: string;
+    /** Custom actions shown when the user activates an already-active tab. */
+    customMenuRendererId?: string;
 }
 
 export { }