@pstdio/workbench 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -1,28 +1,8 @@
 import { ComponentType } from 'react';
-import { NamedSet } from 'zustand/middleware';
 import { ReactNode } from 'react';
-import { StoreApi } from 'zustand/vanilla';
-
-declare type AnchorCandidates = "global" | "scoped";
 
 export declare type AnchorId = "primary" | "secondary" | "attached";
 
-declare type AnchorPersistence = "primary" | "derived" | "detached";
-
-export declare type AnchorReadId = "primary" | "attached";
-
-export declare type AnchorReconcileAction = {
-    area: WorkbenchArea;
-    action: "keep" | "clear";
-};
-
-declare interface AnchorSurface {
-    role: "anchor";
-    anchor: AnchorId;
-    persistence: AnchorPersistence;
-    candidates: AnchorCandidates;
-}
-
 export declare interface AttributeDescriptor {
     id: string;
     label: string;
@@ -33,7 +13,7 @@ export 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;
 }
 
@@ -48,7 +28,7 @@ export declare type AttributeKind = AttributeType["kind"];
  * Reactive source for an entire attribute schema. Lets a contribution
  * add/remove/edit attributes at runtime without re-registering.
  */
-export declare interface AttributesSource {
+declare interface AttributesSource {
     subscribe: (listener: () => void) => () => void;
     getSnapshot: () => AttributeDescriptor[];
 }
@@ -87,10 +67,6 @@ export declare interface BoardColumnConfig {
     actions?: BoardColumnAction[];
 }
 
-declare interface ChromeSurface {
-    role: "chrome";
-}
-
 /**
  * A data-driven list of items, each opening a contributor-supplied editor. The
  * framework knows nothing about what an item is — it only calls these hooks.
@@ -102,7 +78,7 @@ export declare interface CollectionSettingsPanel<TItem = unknown> extends Settin
     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[];
 }
 
@@ -243,8 +219,6 @@ export declare interface ControlsQueryResult {
     readOnly?: boolean;
 }
 
-declare type ControlsRendererArea = "main-right" | "secondary" | "overlay";
-
 export declare interface ControlsRendererContribution {
     id: string;
     title: string;
@@ -264,12 +238,12 @@ export declare interface ControlsRendererContribution {
     subscribe?: (listener: () => void) => Disposable_2 | (() => void);
 }
 
-export declare type ControlsRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+export declare type ControlsRendererImplementation = (input: WorkbenchPanelRenderInput & {
     controlsRendererId: string;
 }) => unknown;
 
 export declare interface ControlsRendererLayout {
-    area?: ControlsRendererArea;
+    region?: ControlsRendererRegion;
     defaultPx?: number;
     minPx?: number;
     maxPx?: number;
@@ -281,6 +255,8 @@ export declare interface ControlsRendererRefreshEvent {
 
 declare type ControlsRendererRefreshListener = (event: ControlsRendererRefreshEvent) => void;
 
+declare type ControlsRendererRegion = "main-right-menu" | "secondary" | "overlay";
+
 export declare interface ControlsRendererRegistry {
     controlsStore: WorkbenchStore<ControlsRendererStoreState>;
     registerControlsRenderer(contribution: ControlsRendererContribution, metadata?: ContributionMetadata): Disposable_2;
@@ -291,7 +267,7 @@ export declare interface ControlsRendererRegistry {
     onDidRefreshControlsRenderer(listener: ControlsRendererRefreshListener): Disposable_2;
 }
 
-export declare interface ControlsRendererStoreState {
+declare interface ControlsRendererStoreState {
     renderers: Record<string, RegisteredControlsRendererContribution>;
 }
 
@@ -307,137 +283,25 @@ export declare interface ControlsUpdateValueInput {
     resource?: ResourceRef;
 }
 
-export declare const createCommandPaletteResourceRegistry: () => CommandPaletteResourceRegistry;
-
-export declare const createCommandRegistry: (input?: CreateCommandRegistryInput) => CommandRegistry;
-
-declare interface CreateCommandRegistryInput {
-    context?: ContextKeyService;
-}
-
-export declare const createContextKeyService: () => ContextKeyService;
-
-export declare const createControlsRendererRegistry: (input: CreateControlsRendererRegistryInput) => ControlsRendererRegistry;
-
-export declare interface CreateControlsRendererRegistryInput {
-    rendererRegistry: WorkbenchRendererRegistry;
-}
-
-export declare const createDataRendererRegistry: (input: CreateDataRendererRegistryInput) => DataRendererRegistry;
-
-export declare interface CreateDataRendererRegistryInput {
-    rendererRegistry: WorkbenchRendererRegistry;
-}
-
-export declare const createDefaultWorkbenchLayout: () => WorkbenchLayout;
-
-export declare const createFileIconThemeRegistry: () => FileIconThemeRegistry;
-
-export declare const createFileRendererRegistry: (input: CreateFileRendererRegistryInput) => FileRendererRegistry;
-
-export declare interface CreateFileRendererRegistryInput {
-    rendererRegistry: WorkbenchRendererRegistry;
-}
-
-export declare const createHistoryController: (input: CreateHistoryControllerInput) => HistoryController;
-
-export declare interface CreateHistoryControllerInput {
-    layout: LayoutModel;
-    modes?: Pick<WorkbenchModeRegistry, "getActiveModeId" | "getMode" | "onDidChangeActive" | "setActiveMode">;
-    resources: ResourceRegistry;
-    maxEntries?: number;
-}
-
-export declare const createKeybindingRegistry: (deps: KeybindingRegistryDeps) => KeybindingRegistry;
-
-export declare const createLayoutModel: (input?: CreateLayoutModelInput) => LayoutModel;
-
-export declare interface CreateLayoutModelInput {
-    persistence?: LayoutPersistenceAdapter;
-}
-
-export declare const createMenuRegistry: (deps: MenuRegistryDeps) => MenuRegistry;
-
-export declare const createNavigationRegistry: (input?: CreateNavigationRegistryInput) => NavigationRegistry;
-
-export declare interface CreateNavigationRegistryInput {
-    resolveDispatcher?(): NavigationDispatcherContext;
-}
-
-export declare const createNotificationRegistry: () => NotificationRegistry;
-
-export declare const createPreferenceRegistry: (input?: CreatePreferenceRegistryInput) => PreferenceRegistry;
-
-export declare interface CreatePreferenceRegistryInput {
-    persistence?: PreferencePersistenceAdapter;
-}
-
-export declare const createResourceRegistry: (input?: CreateResourceRegistryInput) => ResourceRegistry;
-
-export declare interface CreateResourceRegistryInput {
-    getPrimary?: () => ResourceRef | undefined;
-}
-
-export declare const createSettingsRegistry: () => SettingsRegistry;
-
-export declare const createThemeRegistry: () => ThemeRegistry;
-
-export declare const createTreeRendererRegistry: (input: CreateTreeRendererRegistryInput) => TreeRendererRegistry;
-
-export declare interface CreateTreeRendererRegistryInput {
-    rendererRegistry: WorkbenchRendererRegistry;
-    persistence?: TreeRendererPersistenceAdapter;
-}
-
-export declare const createWorkbenchBreadcrumbController: () => WorkbenchBreadcrumbController;
-
-export declare const createWorkbenchCommandPaletteController: (input?: CreateWorkbenchCommandPaletteControllerInput) => WorkbenchCommandPaletteController;
-
-export declare interface CreateWorkbenchCommandPaletteControllerInput {
-    initialOpen?: boolean;
-}
+export declare const createResourceBreadcrumbItems: (resources: ResourceRegistry, resource: ResourceRef | undefined) => WorkbenchBreadcrumbItem[];
 
 export declare const createWorkbenchCore: (input?: CreateWorkbenchCoreInput) => WorkbenchCore;
 
 export declare interface CreateWorkbenchCoreInput {
     isInScope?: (resource: ResourceRef, primary: ResourceRef | undefined) => boolean;
     layoutPersistence?: LayoutPersistenceAdapter;
+    persistence?: WorkbenchPersistenceAdapter;
+    historyPersistence?: WorkbenchHistoryPersistence;
     preferencePersistence?: PreferencePersistenceAdapter;
     treePersistence?: TreeRendererPersistenceAdapter;
     panelsPersistence?: WorkbenchPanelsPersistenceAdapter;
+    defaultPanelOpenByRegionId?: Partial<Record<WorkbenchRegion, boolean>>;
     lastResourcePersistence?: LastResourcePersistenceAdapter;
-    initialSessionPanelMode?: WorkbenchSessionPanelMode;
+    initialSidePanelMode?: WorkbenchSidePanelMode;
     renderers?: CreateWorkbenchRendererRegistryInput;
 }
 
-export declare const createWorkbenchFocusController: (input: CreateWorkbenchFocusControllerInput) => WorkbenchFocusController;
-
-export declare interface CreateWorkbenchFocusControllerInput {
-    context: ContextKeyService;
-}
-
-export declare const createWorkbenchLastResourceController: (input: CreateWorkbenchLastResourceControllerInput) => WorkbenchLastResourceController;
-
-export declare interface CreateWorkbenchLastResourceControllerInput {
-    persistence?: LastResourcePersistenceAdapter;
-    openResource(resource: ResourceRef): Promise<unknown>;
-}
-
-export declare const createWorkbenchModeRegistry: (input: CreateWorkbenchModeRegistryInput) => WorkbenchModeRegistry;
-
-declare interface CreateWorkbenchModeRegistryInput {
-    resolveContext(): WorkbenchModeActivationContext;
-}
-
-export declare const createWorkbenchPanelsController: (input?: CreateWorkbenchPanelsControllerInput) => WorkbenchPanelsController;
-
-export declare interface CreateWorkbenchPanelsControllerInput {
-    persistence?: WorkbenchPanelsPersistenceAdapter;
-}
-
-export declare const createWorkbenchRendererRegistry: (input?: CreateWorkbenchRendererRegistryInput) => WorkbenchRendererRegistry;
-
-export declare interface CreateWorkbenchRendererRegistryInput {
+declare interface CreateWorkbenchRendererRegistryInput {
     initialRenderers?: WorkbenchRendererRegistration[];
     createHost?: () => HTMLElement;
 }
@@ -448,129 +312,129 @@ export declare const createWorkbenchSelectionResourceMetadata: (resource: Pick<R
     "workbench.selectionResourceUri": string;
 };
 
-export declare const createWorkbenchSessionPanelController: (input?: CreateWorkbenchSessionPanelControllerInput) => WorkbenchSessionPanelController;
-
-export declare interface CreateWorkbenchSessionPanelControllerInput {
-    initialMode?: WorkbenchSessionPanelMode;
-}
-
-export declare const createWorkbenchStore: <TState>(input: CreateWorkbenchStoreInput<TState>) => InternalWorkbenchStore<TState>;
-
-export declare interface CreateWorkbenchStoreInput<TState> {
-    name?: string;
-    initialState: TState;
-}
-
-export declare const createWorkbenchTerminalController: () => WorkbenchTerminalController;
-
 /**
  * Renders its own page. `render` returns `unknown` so core stays React-free — the
  * React layer treats the result as a node, exactly like WorkbenchRendererRegistration.
  */
 export declare interface CustomSettingsPanel extends SettingsPanelBase {
     kind: "custom";
-    render(input: WorkbenchWidgetRenderInput): unknown;
+    render(input: WorkbenchPanelRenderInput): unknown;
 }
 
-export declare interface DataRendererContribution<TRow extends DataRendererRow = DataRendererRow> {
+export declare interface DataTableRendererColumn {
+    id: string;
+    label?: string;
+    description?: string;
+    icon?: unknown;
+    hidden?: boolean;
+    stat?: DataTableRendererColumnStat;
+    renderer?: DataTableRendererColumnRenderer;
+}
+
+export 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;
+    }>;
+};
+
+export declare type DataTableRendererColumnStat = {
+    type: "unique";
+} | {
+    type: "histogram";
+    bins?: number;
+} | {
+    type: "top-values";
+    limit?: number;
+};
+
+export 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;
 }
 
-export declare type DataRendererFilterState = Record<string, string[]>;
-
-export declare type DataRendererImplementation = (input: WorkbenchWidgetRenderInput & {
-    dataRendererId: string;
+export declare type DataTableRendererImplementation = (input: WorkbenchPanelRenderInput & {
+    dataTableRendererId: string;
 }) => unknown;
 
-export declare interface DataRendererOrdering {
-    attributeId: string | typeof MANUAL_ORDERING;
-    direction: SortDirection;
+export declare interface DataTableRendererQueryContext {
+    resource?: ResourceRef;
+    modeId?: string;
 }
 
-export declare interface DataRendererQueryState {
-    settings: DataRendererSettings;
-    filters: DataRendererFilterState;
+export declare interface DataTableRendererQueryResult {
+    rows: DataTableRendererRow[];
+    columns?: DataTableRendererColumn[];
 }
 
-declare interface DataRendererRefreshEvent {
-    dataRendererId: string;
+export declare interface DataTableRendererRefreshEvent {
+    dataTableRendererId: string;
 }
 
-declare type DataRendererRefreshListener = (event: DataRendererRefreshEvent) => void;
+export 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;
+}
 
-export 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;
+export declare interface DataTableRendererRow {
+    id: string;
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
 }
 
-export declare interface DataRendererRow {
+export 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;
 }
 
-export declare interface DataRendererSettings {
-    viewMode: ViewMode;
-    columnGrouping: string | typeof NO_GROUPING;
-    rowGrouping: string | typeof NO_GROUPING;
-    ordering: DataRendererOrdering;
-    displayProperties: string[];
+export declare interface DataTableRendererSelectionAction {
+    id: string;
+    label: string;
+    icon?: unknown;
+    destructive?: boolean;
+    run(rows: DataTableRendererRow[]): Promise<void> | void;
 }
 
-export declare interface DataRendererStoreState {
-    renderers: Record<string, RegisteredDataRendererContribution>;
+declare interface DataTableRendererStoreState {
+    renderers: Record<string, RegisteredDataTableRendererContribution>;
+}
+
+export declare interface DataTableRendererThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
 }
 
 declare interface Disposable_2 {
@@ -649,7 +513,7 @@ export declare interface FileRendererContribution {
     save?(resource: ResourceRef | undefined, content: string): Promise<void> | void;
 }
 
-export declare type FileRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+export declare type FileRendererImplementation = (input: WorkbenchPanelRenderInput & {
     fileRendererId: string;
 }) => unknown;
 
@@ -669,21 +533,19 @@ export declare interface FileRendererRegistry {
     onDidRefreshFileRenderer(listener: FileRendererRefreshListener): Disposable_2;
 }
 
-export declare interface FileRendererStoreState {
+declare interface FileRendererStoreState {
     renderers: Record<string, RegisteredFileRendererContribution>;
 }
 
-export declare const getAnchorResource: (layout: WorkbenchLayout, anchorId: AnchorId) => ResourceRef | undefined;
-
 export declare const getKeybindingSteps: (keybinding: KeybindingSequence) => string[];
 
-export declare const getSurface: (area: WorkbenchArea) => SurfaceDescriptor;
+export declare const getWorkbenchModePanelForRegion: (region: WorkbenchRegion) => "main" | "secondary" | "side" | undefined;
 
 export declare const getWorkbenchSelectionResourceUris: (resource: ResourceRef | undefined) => string[];
 
-export declare const headerLeadingMenuPath: (area: string) => MenuPath;
+export declare const headerLeadingMenuPath: (region: string) => MenuPath;
 
-export declare const headerTrailingMenuPath: (area: string) => MenuPath;
+export declare const headerTrailingMenuPath: (region: string) => MenuPath;
 
 export declare interface HistoryController {
     store: WorkbenchStore<HistoryStoreState>;
@@ -692,29 +554,175 @@ export 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;
 }
 
-export declare interface HistoryEntry {
-    entryId: string;
-    recordedAt: number;
-    kind: "resource" | "widget" | "mode";
-    modeId?: string;
-    resource?: ResourceRef;
-    widgetId?: string;
-    contributionId?: string;
-    title?: string;
-}
+export declare type HistoryEntry = WorkbenchNavigationEntry;
 
-export declare interface HistoryStoreState {
-    entries: readonly HistoryEntry[];
+declare interface HistoryStoreState {
+    entries: readonly WorkbenchNavigationEntry[];
     cursor: number;
-    recentlyClosed: readonly HistoryEntry[];
+    recentlyClosed: readonly WorkbenchNavigationEntry[];
+    hydrating: boolean;
 }
 
-declare interface InternalWorkbenchStore<TState> extends WorkbenchStore<TState> {
-    setState: NamedSet<TState>;
-    api: StoreApi<TState>;
+export declare const isWorkbenchModePanelAvailable: (mode: WorkbenchModeContribution | undefined, panel: WorkbenchPanelRegion) => boolean;
+
+export 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;
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export declare interface KanbanRendererCreateRowConfig {
+    title: string;
+    submitLabel: string;
+    fields: KanbanRendererCreateField[];
+    labels: KanbanRendererCreateLabels;
+}
+
+export 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[];
+}
+
+export declare type KanbanRendererFilterState = Record<string, string[]>;
+
+export declare type KanbanRendererImplementation = (input: WorkbenchPanelRenderInput & {
+    kanbanRendererId: string;
+}) => unknown;
+
+export declare interface KanbanRendererOrdering {
+    attributeId: string | typeof MANUAL_ORDERING;
+    direction: SortDirection;
+}
+
+export declare interface KanbanRendererQueryState {
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+}
+
+declare interface KanbanRendererRefreshEvent {
+    kanbanRendererId: string;
+}
+
+declare type KanbanRendererRefreshListener = (event: KanbanRendererRefreshEvent) => void;
+
+export 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;
+}
+
+export 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;
+}
+
+export 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>;
 }
 
 export declare interface Keybinding {
@@ -731,11 +739,6 @@ export declare interface KeybindingRegistry {
     listActiveKeybindings(): RegisteredKeybinding[];
 }
 
-declare interface KeybindingRegistryDeps {
-    commands: CommandRegistry;
-    context: ContextKeyService;
-}
-
 declare interface KeybindingRegistryStoreState {
     keybindings: RegisteredKeybinding[];
 }
@@ -747,55 +750,80 @@ export declare interface LastResourcePersistenceAdapter {
     setLastResource(resource: ResourceRef | undefined): void;
 }
 
-export declare interface LayoutModel {
+declare interface LayoutModel {
     store: WorkbenchStore<WorkbenchLayoutStoreState>;
     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): RegisteredPlaceholderContribution | undefined;
+    getPlaceholder(regionId: WorkbenchRegion): RegisteredPlaceholderContribution | undefined;
     getWidget(id: string): RegisteredWidgetContribution | undefined;
-    getAreaSize(areaId: WorkbenchArea): WorkbenchAreaSize | undefined;
-    getAreaCollapsible(areaId: WorkbenchArea): boolean;
-    getAreaHeaderBorderBottom(areaId: WorkbenchArea): boolean;
-    setAreaVisible(areaId: WorkbenchArea, visible: boolean): void;
-    setAreaSize(areaId: WorkbenchArea, size: number): void;
+    getPanel(id: string): WorkbenchPanelContribution | undefined;
+    getRegionSize(regionId: WorkbenchRegion): WorkbenchRegionSize | undefined;
+    getRegionCollapsible(regionId: WorkbenchRegion): boolean;
+    getRegionHeaderBorderBottom(regionId: WorkbenchRegion): boolean;
+    setRegionVisible(regionId: WorkbenchRegion, visible: boolean): void;
+    setRegionSize(regionId: WorkbenchRegion, size: number): void;
     listPlaceholders(): RegisteredPlaceholderContribution[];
     listWidgets(): RegisteredWidgetContribution[];
+    listPanels(): WorkbenchPanelContribution[];
+    listPanelInstances(region?: WorkbenchRegion): WorkbenchPanelInstance[];
+    getActivePanel(region?: WorkbenchRegion): 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, widgetId: string | undefined): void;
     closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
     removeWidgetPlacement(widgetId: string): WorkbenchWidgetPlacement | undefined;
-    clearArea(areaId: WorkbenchArea): void;
-    resetAreas(): void;
+    clearRegion(regionId: WorkbenchRegion): void;
+    resetRegions(): void;
     getLayout(): WorkbenchLayout;
     restoreLayout(layout: WorkbenchLayout): void;
-    setPersistenceScope(scope: LayoutScope | undefined): void;
+    setPersistenceScope(scope: LayoutScope | undefined, input?: {
+        carryRegionState?: readonly WorkbenchRegion[];
+    }): void;
     getPersistenceScope(): LayoutScope | undefined;
+    onWillChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+        dispose(): void;
+    };
     onDidChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
         dispose(): void;
     };
 }
 
-export declare interface LayoutPersistenceAdapter {
+declare interface LayoutPersistenceAdapter {
     getLayout(scope?: LayoutScope): WorkbenchLayout | undefined;
     setLayout(layout: WorkbenchLayout, scope?: LayoutScope): void;
+    flush?(): void;
+    dispose?(): void;
 }
 
-export declare type LayoutScope = string;
-
-export declare const listAnchorAreas: () => ("status" | "secondary" | "main" | "nav" | "activity" | "left-header" | "left" | "main-header" | "main-left" | "main-right" | "secondary-header" | "overlay" | "floating-header" | "floating")[];
-
-export declare const listProjectionAreas: () => ("status" | "secondary" | "main" | "nav" | "activity" | "left-header" | "left" | "main-header" | "main-left" | "main-right" | "secondary-header" | "overlay" | "floating-header" | "floating")[];
-
-export declare const listProjectionsReading: (anchorId: AnchorReadId) => ("status" | "secondary" | "main" | "nav" | "activity" | "left-header" | "left" | "main-header" | "main-left" | "main-right" | "secondary-header" | "overlay" | "floating-header" | "floating")[];
+declare type LayoutScope = string;
 
 declare const MANUAL_ORDERING = "manual";
 
@@ -803,6 +831,7 @@ export declare const matchesContextExpression: (values: Record<string, ContextKe
 
 export declare interface MenuItem {
     commandId: string;
+    sourceCommandId?: string;
     label?: string;
     description?: string;
     icon?: string;
@@ -825,21 +854,17 @@ export declare interface MenuRegistry {
     listMenuItems(path: MenuPath): RegisteredMenuItem[];
 }
 
-declare interface MenuRegistryDeps {
-    commands: CommandRegistry;
-}
-
 declare interface MenuRegistryStoreState {
     itemsByPath: Record<string, RegisteredMenuItem[]>;
 }
 
 export declare interface NavigationDispatcherContext {
     canOpenResource?(resource: ResourceRef): boolean;
-    canOpenWidget?(widgetId: string): boolean;
+    canOpenPanel?(panelId: string): boolean;
     canExecuteCommand?(commandId: string): boolean;
     createCheckpoint?(): undefined | (() => void);
     openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<unknown>;
-    openWidget(widgetId: string, input?: OpenWidgetInput): unknown;
+    openPanel(panelId: string, input?: OpenWorkbenchPanelInput): unknown;
     executeCommand(commandId: string, args?: unknown): Promise<unknown> | unknown;
 }
 
@@ -881,7 +906,13 @@ export declare interface NavigationTargetCompound {
     targets: readonly NavigationTargetItem[];
 }
 
-export declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetView | NavigationTargetCommand;
+export declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetPanel | NavigationTargetCommand;
+
+export declare interface NavigationTargetPanel {
+    kind: "panel";
+    panelId: string;
+    input?: OpenWorkbenchPanelInput;
+}
 
 export declare interface NavigationTargetResource {
     kind: "resource";
@@ -889,12 +920,6 @@ export declare interface NavigationTargetResource {
     input?: OpenResourceInput;
 }
 
-export declare interface NavigationTargetView {
-    kind: "view";
-    widgetId: string;
-    input?: OpenWidgetInput;
-}
-
 declare const NO_GROUPING = "none";
 
 export declare interface NotificationRegistry {
@@ -913,31 +938,50 @@ export declare interface OpenResourceInput {
 declare interface OpenWidgetInput {
     resource?: ResourceRef;
     title?: string;
-    area?: WorkbenchArea;
+    region?: WorkbenchRegion;
     ownerId?: string;
     source?: ContributionSource;
     pinned?: boolean;
     closable?: boolean;
     mountStrategy?: WidgetMountStrategy;
     hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention;
+    tabPosition?: WorkbenchTabPosition;
+    tab?: WorkbenchWidgetTab;
     replaceActive?: boolean;
+    replaceWidgetId?: string;
+}
+
+export declare interface OpenWorkbenchPanelInput {
+    resource?: ResourceRef;
+    title?: string;
+    region?: WorkbenchRegion;
+    pinned?: boolean;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    tab?: WorkbenchPanelTab;
+    strategy?: WorkbenchPanelOpenStrategy;
 }
 
 export declare interface PersistedTreeRendererStates {
     statesByTreeId: Record<string, TreeRendererState>;
 }
 
-export declare interface PersistedWorkbenchPanels {
-    openByAreaId: Record<string, boolean>;
+export declare interface PersistedWorkbenchHistory extends Omit<HistoryStoreState, "hydrating"> {
+    version: 1;
+}
+
+declare interface PersistedWorkbenchPanels {
+    openByRegionId: Record<string, boolean>;
 }
 
-export declare interface PlaceholderContribution {
+declare interface PlaceholderContribution {
     id: string;
     title: string;
-    area: WorkbenchArea;
+    region: WorkbenchRegion;
     rendererId: string;
-    areaSize?: WorkbenchAreaSize;
-    areaCollapsible?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
     config?: unknown;
     priority?: number;
 }
@@ -980,80 +1024,71 @@ export declare interface PreferenceScopeRef {
 
 export declare type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
 
-declare interface ProjectionSurface {
-    role: "projection";
-    reads: AnchorReadId[];
-    navigator?: boolean;
-}
-
-export declare const reconcileAnchors: ({ layout, primary, isInScope }: ReconcileAnchorsInput) => AnchorReconcileAction[];
-
-export declare interface ReconcileAnchorsInput {
-    layout: WorkbenchLayout;
-    primary: ResourceRef | undefined;
-    isInScope: (resource: ResourceRef, primary: ResourceRef | undefined) => boolean;
-}
-
-export declare interface RegisteredCommand extends RegisteredContributionMetadata {
+declare interface RegisteredCommand extends RegisteredContributionMetadata {
     command: Command;
     handler: CommandHandler;
 }
 
-export declare interface RegisteredContributionMetadata {
+declare interface RegisteredContributionMetadata {
     source: ContributionSource;
     ownerId: string;
     priority: number;
 }
 
-export declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, RegisteredContributionMetadata {
+declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, RegisteredContributionMetadata {
 }
 
-export declare interface RegisteredDataRendererContribution<TRow extends DataRendererRow = DataRendererRow> extends DataRendererContribution<TRow>, RegisteredContributionMetadata {
+declare interface RegisteredDataTableRendererContribution extends DataTableRendererContribution, RegisteredContributionMetadata {
 }
 
-export declare interface RegisteredFileRendererContribution extends FileRendererContribution, RegisteredContributionMetadata {
+declare interface RegisteredFileRendererContribution extends FileRendererContribution, RegisteredContributionMetadata {
 }
 
-export declare interface RegisteredKeepAliveHost {
+declare interface RegisteredKanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> extends KanbanRendererContribution<TRow>, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredKeepAliveHost {
     rendererId: string;
     host: HTMLElement;
     attachedTo?: HTMLElement;
 }
 
-export declare interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {
+declare interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {
 }
 
-export declare interface RegisteredMenuItem extends MenuItem, RegisteredContributionMetadata {
+declare interface RegisteredMenuItem extends MenuItem, RegisteredContributionMetadata {
     path: MenuPath;
 }
 
-export declare type RegisteredNavigationParser = Omit<NavigationParser, "priority"> & RegisteredContributionMetadata;
+declare type RegisteredNavigationParser = Omit<NavigationParser, "priority"> & RegisteredContributionMetadata;
 
-export declare type RegisteredPlaceholderContribution = Omit<PlaceholderContribution, "priority"> & RegisteredContributionMetadata;
+declare type RegisteredPlaceholderContribution = Omit<PlaceholderContribution, "priority"> & RegisteredContributionMetadata;
 
 declare type RegisteredPreferenceSchema = PreferencePropertySchema & {
     ownerId: string;
     source: string;
 };
 
-export declare interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {
+declare interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {
 }
 
-export declare type RegisteredResourceNavigator = Omit<ResourceNavigator, "priority"> & RegisteredContributionMetadata;
+declare type RegisteredResourceNavigator = Omit<ResourceNavigator, "priority"> & RegisteredContributionMetadata;
 
-export declare type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
+declare type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
 
-export declare type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
+declare type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
 
-export declare interface RegisteredTreeRendererContribution extends TreeRendererContribution, RegisteredContributionMetadata {
+declare interface RegisteredTreeRendererContribution extends TreeRendererContribution, RegisteredContributionMetadata {
 }
 
-export declare type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+declare type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+    ownedPanelMenuIds?: readonly string[];
     singleton: boolean;
     reuse: WidgetReusePolicy;
+    role: WorkbenchWidgetRole;
 } & RegisteredContributionMetadata;
 
-export declare interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
+declare interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
     id: string;
     level: WorkbenchNotificationLevel;
     title: string;
@@ -1064,9 +1099,11 @@ export declare interface RegisteredWorkbenchNotification extends RegisteredContr
     metadata?: Record<string, unknown>;
 }
 
-export declare const resolveAnchorArea: (anchorId: AnchorId) => "status" | "secondary" | "main" | "nav" | "activity" | "left-header" | "left" | "main-header" | "main-left" | "main-right" | "secondary-header" | "overlay" | "floating-header" | "floating";
+export declare const resolveAnchorRegion: (anchorId: AnchorId) => "status" | "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" | "overlay";
 
-declare type ResolvedResourceOpener = Required<ResourceOpener>;
+declare type ResolvedResourceHierarchyProvider = Required<ResourceHierarchyProvider>;
+
+declare type ResolvedResourcePresenter = Required<ResourcePresenter>;
 
 export declare interface ResourceBrowseEntry {
     resource: ResourceRef;
@@ -1090,6 +1127,13 @@ export declare interface ResourceContextAction {
 
 export declare const resourceContextMenuPath: (resourceKind: string) => MenuPath;
 
+export declare interface ResourceHierarchyProvider {
+    id: string;
+    priority?: number;
+    canResolve(resource: ResourceRef): boolean;
+    getParent(resource: ResourceRef): ResourceRef | undefined;
+}
+
 export declare interface ResourceKindContribution {
     kind: string;
     label: string;
@@ -1102,7 +1146,7 @@ export declare interface ResourceListContext {
     primary?: ResourceRef;
 }
 
-export declare interface ResourceNavigator<TResult = unknown> {
+declare interface ResourceNavigator<TResult = unknown> {
     id: string;
     priority?: number;
     canNavigate(resource: ResourceRef): boolean;
@@ -1110,11 +1154,11 @@ export declare interface ResourceNavigator<TResult = unknown> {
     navigate(resource: ResourceRef): TResult | Promise<TResult>;
 }
 
-export declare interface ResourceOpener<TResult = unknown> {
+export 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>;
 }
 
 export declare interface ResourceProvider {
@@ -1138,19 +1182,24 @@ export 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>;
 }
 
 export declare type ResourceSurface = "primary" | "secondary" | "attached";
@@ -1211,7 +1260,7 @@ export declare interface SettingsRegistry {
     refresh(): void;
 }
 
-export declare interface SettingsRegistryStoreState {
+declare interface SettingsRegistryStoreState {
     sections: Record<string, RegisteredSettingsSection>;
     panels: Record<string, RegisteredSettingsPanel>;
     /** Bumped by refresh() so the surface re-reads collection items() after backing data changes. */
@@ -1221,7 +1270,7 @@ export declare interface SettingsRegistryStoreState {
 /** Settings are stored either per-user (global) or per-project. Projectless surfaces show only global entries. */
 export declare type SettingsScope = "global" | "project";
 
-/** An ordered sidebar container. Headerless when `title` is omitted. */
+/** An ordered sidenav container. Headerless when `title` is omitted. */
 export declare interface SettingsSectionContribution {
     id: string;
     title?: string;
@@ -1239,13 +1288,9 @@ export declare const standardResourceIcons: {
     readonly workspace: "computer";
     readonly worktree: "git-pull-request-draft";
     readonly settings: "settings";
-    readonly dataRenderer: "table-properties";
+    readonly kanbanRenderer: "table-properties";
 };
 
-export declare type SurfaceDescriptor = AnchorSurface | ProjectionSurface | ChromeSurface | TransientSurface;
-
-export declare const surfaceMap: Record<WorkbenchArea, SurfaceDescriptor>;
-
 /**
  * Core-owned contract for theme registrations. Structurally identical to
  * @pstdio/ui's ThemePreferenceOption; the React layer bridges the two so core
@@ -1271,10 +1316,6 @@ export declare interface ThemeRegistry {
     listThemes(): readonly ThemePreferenceOption[];
 }
 
-declare interface TransientSurface {
-    role: "transient";
-}
-
 export declare interface TreeAction {
     id: string;
     label?: string;
@@ -1321,6 +1362,8 @@ export 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";
@@ -1338,7 +1381,7 @@ export declare interface TreeRendererContribution {
     getChildren(node: TreeNode, ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
 }
 
-export declare type TreeRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+export declare type TreeRendererImplementation = (input: WorkbenchPanelRenderInput & {
     treeId: string;
 }) => unknown;
 
@@ -1379,7 +1422,7 @@ export declare interface TreeRendererState {
     loading?: boolean;
 }
 
-export declare interface TreeRendererStoreState {
+declare interface TreeRendererStoreState {
     trees: Record<string, RegisteredTreeRendererContribution>;
     statesByTreeId: Record<string, TreeRendererState>;
     refreshKeysByTreeId: Record<string, number>;
@@ -1401,61 +1444,50 @@ export 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;
 }
 
 /**
- * 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.
  */
 export declare type ViewMode = "board" | "list";
 
-export declare interface WidgetContribution {
+declare interface WidgetContribution {
     id: string;
     title: string;
-    area: WorkbenchArea;
-    fallbackArea?: WorkbenchArea;
+    icon?: string;
+    region: WorkbenchRegion;
+    fallbackRegion?: WorkbenchRegion;
     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;
 }
 
-export declare type WidgetMountStrategy = "active" | "keep-mounted";
-
-export declare type WidgetReusePolicy = "resource" | "none";
-
-export declare type WorkbenchArea = (typeof workbenchAreas)[number];
-
-export declare const workbenchAreas: readonly ["nav", "activity", "left-header", "left", "main-header", "main-left", "main", "main-right", "secondary-header", "secondary", "status", "overlay", "floating-header", "floating"];
-
-export declare interface WorkbenchAreaSize {
-    defaultPx?: number;
-    minPx?: number;
-    maxPx?: number;
-}
-
-export declare interface WorkbenchAreaState {
-    id: WorkbenchArea;
-    visible: boolean;
-    size?: number;
-    widgets: WorkbenchWidgetPlacement[];
-    activeWidgetId?: string;
-}
+declare type WidgetMountStrategy = "active" | "keep-mounted";
 
-export declare const workbenchAreaTabLeadingMenuPath: (area: string) => MenuPath;
+declare type WidgetReusePolicy = "resource" | "none";
 
-export declare type WorkbenchBreadcrumbChangeListener = () => void;
+declare type WorkbenchBreadcrumbChangeListener = () => void;
 
 export declare interface WorkbenchBreadcrumbController {
     store: WorkbenchStore<WorkbenchBreadcrumbState>;
@@ -1468,6 +1500,7 @@ export declare interface WorkbenchBreadcrumbController {
 export declare interface WorkbenchBreadcrumbItem {
     title: unknown;
     icon?: string;
+    indicator?: "session-status";
     url?: string;
     onClick?: () => void;
     resource?: ResourceRef;
@@ -1477,8 +1510,16 @@ declare interface WorkbenchBreadcrumbState {
     items: WorkbenchBreadcrumbItem[] | undefined;
 }
 
+declare interface WorkbenchClosedSubPanel {
+    region: WorkbenchPanelRegion;
+    reference: WorkbenchSubPanelRef;
+    resource?: ResourceRef;
+    title?: string;
+}
+
 export declare interface WorkbenchCommandExecutionContext {
     resource?: ResourceRef;
+    source?: "panel-add";
 }
 
 export declare interface WorkbenchCommandExecutionError {
@@ -1487,9 +1528,9 @@ export declare interface WorkbenchCommandExecutionError {
     error: unknown;
 }
 
-export declare type WorkbenchCommandExecutionErrorListener = (event: WorkbenchCommandExecutionError) => void;
+declare type WorkbenchCommandExecutionErrorListener = (event: WorkbenchCommandExecutionError) => void;
 
-export declare type WorkbenchCommandPaletteChangeListener = (open: boolean) => void;
+declare type WorkbenchCommandPaletteChangeListener = (open: boolean) => void;
 
 export declare interface WorkbenchCommandPaletteController {
     store: WorkbenchStore<WorkbenchCommandPaletteState>;
@@ -1512,14 +1553,14 @@ export declare interface WorkbenchCommandPaletteOpenInput {
     initialQuery?: string;
 }
 
-export declare interface WorkbenchCommandPaletteState {
+declare interface WorkbenchCommandPaletteState {
     open: boolean;
     view: WorkbenchCommandPaletteView;
     initialQuery: string;
     paramsRequest: WorkbenchCommandParamsRequest | null;
 }
 
-export declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
+declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
 
 declare interface WorkbenchCommandParamsRequest {
     record: {
@@ -1535,11 +1576,12 @@ declare interface WorkbenchCommandParamsRequest {
 }
 
 export declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
+    host: WorkbenchHost;
     registerModule(module: WorkbenchModuleContribution): Disposable_2;
     unregisterModule(moduleId: string): void;
 }
 
-export declare interface WorkbenchCoreContributionContext {
+declare interface WorkbenchCoreContributionContext {
     breadcrumbs: WorkbenchBreadcrumbController;
     commandPalette: WorkbenchCommandPaletteController;
     commandPaletteResources: CommandPaletteResourceRegistry;
@@ -1558,7 +1600,8 @@ export declare interface WorkbenchCoreContributionContext {
     renderers: WorkbenchRenderers;
     resources: ResourceRegistry;
     settings: SettingsRegistry;
-    sessionPanel: WorkbenchSessionPanelController;
+    shell: WorkbenchShellController;
+    sidePanel: WorkbenchSidePanelController;
     terminal: WorkbenchTerminalController;
     themes: ThemeRegistry;
     fileIconThemes: FileIconThemeRegistry;
@@ -1568,46 +1611,82 @@ export declare interface WorkbenchCoreContributionContext {
     onDidChangeActiveResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
 }
 
-export declare interface WorkbenchFileIconThemeStoreState {
+declare interface WorkbenchFileIconThemeStoreState {
     themes: readonly FileIconThemePreferenceOption[];
 }
 
-export declare type WorkbenchFocusArea = (typeof workbenchFocusAreas)[number];
-
-export declare const workbenchFocusAreas: readonly ["activityBar", "sideBar", "main", "panel", "statusBar"];
+export declare type WorkbenchFloatingPanelVisibility = "visible" | "hidden";
 
-export declare type WorkbenchFocusChangeListener = (area: WorkbenchFocusArea | undefined) => void;
+declare type WorkbenchFocusChangeListener = (region: WorkbenchFocusRegionId | undefined) => void;
 
 export 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 interface WorkbenchFocusState {
-    activeArea: WorkbenchFocusArea | undefined;
+export declare type WorkbenchFocusRegionId = (typeof workbenchFocusRegions)[number];
+
+declare const workbenchFocusRegions: readonly ["activity", "sidenav", "main", "secondary", "side", "status"];
+
+declare interface WorkbenchFocusState {
+    activeRegion: WorkbenchFocusRegionId | undefined;
+}
+
+declare interface WorkbenchHistoryPersistence {
+    getHistory(scope?: string): PersistedWorkbenchHistory | undefined;
+    setHistory(state: PersistedWorkbenchHistory, scope?: string): void;
+}
+
+export declare interface WorkbenchHost {
+    getSnapshot(): WorkbenchSnapshot;
+    restoreSnapshot(snapshot: WorkbenchSnapshot): void;
+    setPersistenceScope(scope: string | undefined, input?: {
+        carryRegions?: readonly WorkbenchRegion[];
+    }): void;
+    getPersistenceScope(): string | undefined;
 }
 
-export declare interface WorkbenchLastResourceController {
+declare interface WorkbenchLastResourceController {
     get(): ResourceRef | undefined;
     set(resource: ResourceRef | undefined): void;
     restore(): Promise<boolean>;
 }
 
 export declare interface WorkbenchLayout {
-    areas: Record<WorkbenchArea, WorkbenchAreaState>;
+    regions: Record<WorkbenchRegion, WorkbenchRegionState>;
+    locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion, string>>>;
     activeWidgetId?: string;
+    activeLocationWidgetId?: string;
     activeResourceUri?: string;
 }
 
-export declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
+declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
 
-export declare interface WorkbenchLayoutStoreState {
+declare interface WorkbenchLayoutStoreState {
     layout: WorkbenchLayout;
     widgets: Record<string, RegisteredWidgetContribution>;
-    placeholders: Partial<Record<WorkbenchArea, RegisteredPlaceholderContribution>>;
+    placeholders: Partial<Record<WorkbenchRegion, RegisteredPlaceholderContribution>>;
+}
+
+declare type WorkbenchLocationContribution = Omit<WidgetContribution, "role"> & WorkbenchPanelMenusContribution;
+
+export 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 type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
@@ -1619,16 +1698,24 @@ declare type WorkbenchModeChangeListener = () => void;
 export declare interface WorkbenchModeContribution {
     id: string;
     label?: string;
+    panels?: readonly WorkbenchPanelRegion[];
     activate(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+    seed?(ctx: WorkbenchModeActivationContext): void;
+    enter?(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
 }
 
 export 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;
 }
 
@@ -1639,6 +1726,8 @@ declare interface WorkbenchModeStoreState {
 
 declare type WorkbenchModuleActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
 
+export declare type WorkbenchModuleContext = WorkbenchCoreContributionContext;
+
 export declare interface WorkbenchModuleContribution {
     id: string;
     source?: ContributionSource;
@@ -1646,7 +1735,21 @@ export declare interface WorkbenchModuleContribution {
     activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
 }
 
-export declare type WorkbenchModuleContributionContext = WorkbenchCoreContributionContext;
+export declare type WorkbenchModuleContributionContext = WorkbenchModuleContext;
+
+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;
+}
 
 export declare interface WorkbenchNotification {
     id?: string;
@@ -1682,31 +1785,190 @@ declare interface WorkbenchNotificationStoreState {
     notifications: Record<string, RegisteredWorkbenchNotification>;
 }
 
-export declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
+export declare interface WorkbenchPanelContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    region: WorkbenchRegion;
+    fallbackRegion?: WorkbenchRegion;
+    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[];
+}
+
+export 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 type WorkbenchPanelMenuContribution = Omit<WidgetContribution, "region" | "fallbackRegion" | "role"> & {
+    region: WorkbenchPanelMenuRegion;
+    fallbackRegion?: WorkbenchPanelMenuRegion;
+};
+
+export 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;
+};
+
+export 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[];
+}
 
-export declare interface WorkbenchPanelsController {
+export declare type WorkbenchPanelMenuSide = "left" | "right";
+
+export declare type WorkbenchPanelMountStrategy = WidgetMountStrategy;
+
+export 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;
+}
+
+export 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;
 }
 
-export declare interface WorkbenchPanelsPersistenceAdapter {
-    getPanelStates(): PersistedWorkbenchPanels | undefined;
-    setPanelStates(state: PersistedWorkbenchPanels): void;
+declare interface WorkbenchPanelsPersistenceAdapter {
+    getPanelStates(scope?: string): PersistedWorkbenchPanels | undefined;
+    setPanelStates(state: PersistedWorkbenchPanels, scope?: string): void;
+}
+
+declare interface WorkbenchPanelsState {
+    openByRegionId: Record<string, boolean>;
+}
+
+export declare type WorkbenchPanelTab = WorkbenchWidgetTab;
+
+export declare interface WorkbenchPersistenceAdapter {
+    getSnapshot(scope?: string): WorkbenchSnapshot | undefined;
+    setSnapshot(snapshot: WorkbenchSnapshot, scope?: string): void;
+    flush?(): void;
+    dispose?(): void;
+}
+
+export declare type WorkbenchRegion = (typeof workbenchRegions)[number];
+
+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"];
+
+export declare interface WorkbenchRegionSize {
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
 }
 
-export declare interface WorkbenchPanelsState {
-    openByAreaId: Record<string, boolean>;
+declare interface WorkbenchRegionState {
+    id: WorkbenchRegion;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement[];
+    activeWidgetId?: string;
 }
 
+export declare const workbenchRegionTabAddMenuPath: (region: string) => MenuPath;
+
+export declare const workbenchRegionTabLeadingMenuPath: (region: string) => MenuPath;
+
 declare type WorkbenchRendererChangeListener = () => void;
 
 export declare type WorkbenchRendererRegistration = {
     id: string;
     keepAlive?: false;
-    render: (input: WorkbenchWidgetRenderInput) => unknown;
+    render: (input: WorkbenchPanelRenderInput) => unknown;
 } | {
     id: string;
     keepAlive: true;
@@ -1719,17 +1981,17 @@ 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;
 }
 
-export declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & DataRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
+declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & KanbanRendererRegistry & DataTableRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
 
-export declare interface WorkbenchRendererStoreState {
+declare interface WorkbenchRendererStoreState {
     renderers: Record<string, WorkbenchRendererRegistration>;
     hosts: Record<string, RegisteredKeepAliveHost>;
-    claims: Record<string, WorkbenchWidgetRenderInput>;
+    claims: Record<string, WorkbenchPanelRenderInput>;
 }
 
 export declare const workbenchResourceIdContextKey = "workbench.resource.id";
@@ -1740,22 +2002,44 @@ export declare const workbenchResourceMetadataContextKey: (key: string) => strin
 
 export declare const workbenchSelectionResourceUriMetadataKey = "workbench.selectionResourceUri";
 
-export declare type WorkbenchSessionPanelChangeListener = (mode: WorkbenchSessionPanelMode) => void;
+export declare interface WorkbenchShellController {
+    getRegionState(region: WorkbenchRegion): WorkbenchShellRegionState;
+    setRegionOpen(region: WorkbenchShellOpenRegion, open: boolean): void;
+    setRegionSize(region: WorkbenchRegion, size: number): void;
+    getSidePanelPresentation(): WorkbenchSidePanelPresentation;
+    setSidePanelPresentation(presentation: WorkbenchSidePanelPresentation): void;
+    onDidChange(listener: () => void): Disposable_2;
+}
+
+export declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | WorkbenchPanelMenuRegion;
 
-export declare interface WorkbenchSessionPanelController {
-    store: WorkbenchStore<WorkbenchSessionPanelState>;
-    getMode(): WorkbenchSessionPanelMode;
-    setMode(mode: WorkbenchSessionPanelMode): void;
-    onDidChange(listener: WorkbenchSessionPanelChangeListener): Disposable_2;
+export declare interface WorkbenchShellRegionState {
+    open: boolean;
+    size?: number;
 }
 
-export declare type WorkbenchSessionPanelMode = "bubble" | "closed" | "attached";
+declare type WorkbenchSidePanelChangeListener = (mode: WorkbenchSidePanelMode) => void;
+
+declare interface WorkbenchSidePanelController {
+    store: WorkbenchStore<WorkbenchSidePanelState>;
+    getMode(): WorkbenchSidePanelMode;
+    setMode(mode: WorkbenchSidePanelMode): void;
+    onDidChange(listener: WorkbenchSidePanelChangeListener): Disposable_2;
+}
+
+declare type WorkbenchSidePanelMode = "floating" | "closed" | "attached";
+
+export declare type WorkbenchSidePanelPresentation = WorkbenchSidePanelMode;
+
+declare interface WorkbenchSidePanelState {
+    mode: WorkbenchSidePanelMode;
+}
 
-export declare interface WorkbenchSessionPanelState {
-    mode: WorkbenchSessionPanelMode;
+export declare interface WorkbenchSnapshot {
+    layout: WorkbenchLayout;
 }
 
-export declare interface WorkbenchStore<TState> {
+declare interface WorkbenchStore<TState> {
     getState(): TState;
     getInitialState(): TState;
     subscribe(listener: WorkbenchStoreListener<TState>): () => void;
@@ -1765,11 +2049,30 @@ export declare interface WorkbenchStore<TState> {
     }): () => void;
 }
 
-export declare type WorkbenchStoreListener<TState> = (state: TState, previousState: TState) => void;
+declare type WorkbenchStoreListener<TState> = (state: TState, previousState: TState) => void;
+
+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;
+}
 
-export declare type WorkbenchStoreSelector<TState, TValue> = (state: TState) => TValue;
+export declare type WorkbenchTabPosition = "start" | "end" | {
+    beforeWidgetId: string;
+} | {
+    afterWidgetId: string;
+};
 
-export declare type WorkbenchStoreSelectorListener<TValue> = (value: TValue, previousValue: TValue) => void;
+export declare type WorkbenchTabRetention = "preview" | "persistent";
 
 export declare interface WorkbenchTerminalController {
     store: WorkbenchStore<WorkbenchTerminalState>;
@@ -1853,7 +2156,7 @@ export declare interface WorkbenchTerminalState {
     sessionsById: Record<string, WorkbenchTerminalSessionModel>;
 }
 
-export declare interface WorkbenchThemeStoreState {
+declare interface WorkbenchThemeStoreState {
     themes: readonly ThemePreferenceOption[];
 }
 
@@ -1861,25 +2164,30 @@ export declare const workbenchTopHeaderLeadingMenuPath: MenuPath;
 
 export declare const workbenchTopHeaderTrailingMenuPath: MenuPath;
 
-export declare interface WorkbenchWidgetPlacement {
+declare interface WorkbenchWidgetPlacement {
     widgetId: string;
     contributionId: string;
     ownerId?: string;
     source?: ContributionSource;
     resource?: ResourceRef;
     resourceUri?: string;
+    ownerResourceUri?: string;
     title?: string;
     pinned?: boolean;
     closable?: boolean;
     mountStrategy?: WidgetMountStrategy;
     hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention;
+    tab?: WorkbenchWidgetTab;
+    role?: WorkbenchWidgetRole;
 }
 
-export declare interface WorkbenchWidgetRenderInput {
-    workbench: WorkbenchCore;
-    widget: RegisteredWidgetContribution | RegisteredPlaceholderContribution;
-    placement: WorkbenchWidgetPlacement;
-    refresh: () => void;
+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 { }