@pstdio/workbench 0.2.1 → 0.4.0

package/dist/extensions.d.ts

@@ -11,7 +11,8 @@ import { ReactNode } from 'react';
 import { ThemePreference as ThemePreference_2 } from 'pstdio-extensions/bridge/contract';
 import { WorkbenchExtensionCommandPaletteResourceRecord } from '@pstdio/sdk/api';
 import { WorkbenchExtensionControlsRendererRecord } from '@pstdio/sdk/api';
-import { WorkbenchExtensionDataRendererRecord } from '@pstdio/sdk/api';
+import { WorkbenchExtensionDataTableRendererRecord } from 'pstdio-api-contracts';
+import { WorkbenchExtensionKanbanRendererRecord } from '@pstdio/sdk/api';
 import { WorkbenchExtensionMetadata } from '@pstdio/sdk/api';
 
 declare interface AttributeDescriptor {
@@ -24,7 +25,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;
 }
 
@@ -89,7 +90,7 @@ export declare interface BridgeWebviewConfig {
 export declare interface BridgeWebviewRenderContext {
     workbench: WorkbenchCore;
     webviewId: string;
-    placement: WorkbenchWidgetPlacement;
+    placement: WorkbenchPanelInstance;
     /** Channel for pushing host events (e.g. terminal output) into this webview. */
     hostEvents: HostEventPublisher;
 }
@@ -127,7 +128,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[];
 }
 
@@ -270,8 +271,6 @@ declare interface ControlsQueryResult {
     readOnly?: boolean;
 }
 
-declare type ControlsRendererArea = "main-right" | "secondary" | "overlay";
-
 declare interface ControlsRendererContribution {
     id: string;
     title: string;
@@ -291,12 +290,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;
@@ -308,6 +307,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;
@@ -334,7 +335,7 @@ declare interface ControlsUpdateValueInput {
     resource?: ResourceRef;
 }
 
-declare type ControlsViewRecord = WorkbenchExtensionMetadata["views"][number];
+declare type ControlsViewRecord = WorkbenchExtensionMetadata["panels"][number];
 
 export declare type CreateBridgeWebviewHostCapabilities = (context: BridgeWebviewRenderContext) => HostCapabilityRegistry;
 
@@ -342,7 +343,7 @@ export declare type CreateBridgeWebviewProps = (context: BridgeWebviewRenderCont
 
 export declare const createBridgeWebviewRenderer: (input?: CreateBridgeWebviewRendererInput) => {
     id: string;
-    render: (renderInput: WorkbenchWidgetRenderInput) => JSX.Element | null;
+    render: (renderInput: WorkbenchPanelRenderInput) => JSX.Element | null;
 };
 
 declare interface CreateBridgeWebviewRendererInput {
@@ -369,8 +370,8 @@ declare interface CreateTerminalSessionCapabilityInput {
 export declare const createWorkbenchWebviewHostCapabilities: (input: CreateWorkbenchWebviewHostCapabilitiesInput) => {
     "terminal.session"?: HostCapability | undefined;
     "commands.execute": (params: unknown) => Promise<unknown>;
-    "resource.open": (params: unknown) => Promise<unknown>;
-    "notification.show": (params: unknown) => RegisteredWorkbenchNotification_2;
+    "resource.open": (params: unknown) => Promise<WorkbenchPanelInstance_2>;
+    "notification.show": (params: unknown) => RegisteredWorkbenchNotification;
     "preferences.get": (params: unknown) => PreferenceValue | undefined;
     "preferences.set": (params: unknown) => {
         name: string;
@@ -392,112 +393,127 @@ declare interface CreateWorkbenchWebviewHostCapabilitiesInput {
  */
 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 type DataRendererRow_2 = Awaited<ReturnType<DataRendererContribution["executeQuery"]>>[number];
+declare interface DataTableRendererSelectionAction {
+    id: string;
+    label: string;
+    icon?: unknown;
+    destructive?: boolean;
+    run(rows: 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 DataTableRendererStoreState {
+    renderers: Record<string, RegisteredDataTableRendererContribution>;
 }
 
-declare interface DataRendererStoreState {
-    renderers: Record<string, RegisteredDataRendererContribution>;
+declare interface DataTableRendererThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
 }
 
+declare type DataTableViewRecord = WorkbenchExtensionMetadata["panels"][number];
+
 declare interface Disposable_2 {
     dispose(): void;
 }
@@ -511,13 +527,14 @@ export declare const emptyWorkbenchExtensionMetadata: {
     modes: never[];
     navigation: never[];
     routes: never[];
-    dataRenderers: never[];
+    kanbanRenderers: never[];
+    dataTableRenderers: never[];
     treeRenderers: never[];
     fileRenderers: never[];
     settingsPanels: never[];
     settingsDefinitions: never[];
     treeItems: never[];
-    views: never[];
+    panels: never[];
 };
 
 declare interface EnumOption {
@@ -541,7 +558,7 @@ declare interface EnumOptionsSource {
 
 declare type ExtensionTreeRendererRecord = NonNullable<WorkbenchExtensionMetadata["treeRenderers"]>[number];
 
-declare type ExtensionTreeViewRecord = WorkbenchExtensionMetadata["views"][number];
+declare type ExtensionTreeViewRecord = WorkbenchExtensionMetadata["panels"][number] | NonNullable<WorkbenchExtensionMetadata["panels"][number]["panelMenus"]>[number];
 
 export declare interface ExtensionWebviewFileCapabilities {
     delete(params: unknown): Promise<unknown> | unknown;
@@ -601,7 +618,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;
 
@@ -632,34 +649,185 @@ 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;
 }
 
 declare interface HostTreeDefaultNodesInput {
     ctx: TreeContext;
     record: ExtensionTreeRendererRecord;
-    view: ExtensionTreeViewRecord;
+    panel: ExtensionTreeViewRecord;
 }
 
 declare type HostTreeDefaultNodesResolver = (input: HostTreeDefaultNodesInput) => Promise<TreeNode[]> | TreeNode[];
 
+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 type KanbanRendererRow_2 = Awaited<ReturnType<KanbanRendererContribution["executeQuery"]>>[number];
+
+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;
@@ -685,33 +853,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): 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;
     };
@@ -725,6 +922,7 @@ declare const MANUAL_ORDERING = "manual";
 
 declare interface MenuItem {
     commandId: string;
+    sourceCommandId?: string;
     label?: string;
     description?: string;
     icon?: string;
@@ -789,7 +987,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";
@@ -797,12 +1001,6 @@ declare interface NavigationTargetResource {
     input?: OpenResourceInput;
 }
 
-declare interface NavigationTargetView {
-    kind: "view";
-    widgetId: string;
-    input?: OpenWidgetInput;
-}
-
 declare const NO_GROUPING = "none";
 
 declare interface NotificationRegistry {
@@ -821,23 +1019,38 @@ 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;
+}
+
+declare interface OpenWorkbenchPanelInput {
+    resource?: ResourceRef;
+    title?: string;
+    region?: WorkbenchRegion;
+    pinned?: boolean;
+    mountStrategy?: WorkbenchPanelMountStrategy;
+    hiddenByDefault?: boolean;
+    tab?: WorkbenchPanelTab;
+    strategy?: WorkbenchPanelOpenStrategy;
 }
 
 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;
 }
@@ -875,9 +1088,9 @@ declare interface PreferenceScopeRef {
 
 declare type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
 
-export declare const refreshOpenWorkbenchExtensionWebviews: (workbench: WorkbenchModuleContributionContext, metadata: WorkbenchExtensionMetadata) => void;
+export declare const refreshOpenWorkbenchExtensionWebviews: (workbench: WorkbenchModuleContext, metadata: WorkbenchExtensionMetadata) => void;
 
-export declare const refreshWorkbenchExtensionContributions: (workbench: WorkbenchModuleContributionContext, metadata: WorkbenchExtensionMetadata, commandId: string) => void;
+export declare const refreshWorkbenchExtensionContributions: (workbench: WorkbenchModuleContext, metadata: WorkbenchExtensionMetadata, commandId: string) => void;
 
 declare interface RegisteredCommand extends RegisteredContributionMetadata {
     command: Command;
@@ -890,21 +1103,18 @@ declare interface RegisteredContributionMetadata {
     priority: number;
 }
 
-declare interface RegisteredContributionMetadata_2 {
-    source: ContributionSource_2;
-    ownerId: string;
-    priority: number;
-}
-
 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;
@@ -940,8 +1150,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 {
@@ -955,17 +1167,6 @@ declare interface RegisteredWorkbenchNotification extends RegisteredContribution
     metadata?: Record<string, unknown>;
 }
 
-declare interface RegisteredWorkbenchNotification_2 extends RegisteredContributionMetadata_2 {
-    id: string;
-    level: WorkbenchNotificationLevel_2;
-    title: string;
-    message?: string;
-    createdAt: string;
-    resource?: ResourceRef_2;
-    actions?: WorkbenchNotificationAction_2[];
-    metadata?: Record<string, unknown>;
-}
-
 export declare const registerWorkbenchExtensionCommandPaletteResources: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionCommandPaletteResourceRecord[]) => {
     dispose(): void;
 };
@@ -990,14 +1191,12 @@ export declare interface RegisterWorkbenchExtensionContributionsInput {
     settingsSectionId?: string;
     settingsSectionTitle?: string;
     webviewFiles?: ExtensionWebviewFileCapabilities;
-    workbench: WorkbenchModuleContributionContext;
+    workbench: WorkbenchModuleContext;
 }
 
-export declare const registerWorkbenchExtensionControlsRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionControlsRendererRecord[], views: ControlsViewRecord[], adapter?: WorkbenchExtensionControlsAdapter) => Disposable_2;
+export declare const registerWorkbenchExtensionControlsRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionControlsRendererRecord[], panels: ControlsViewRecord[], adapter?: WorkbenchExtensionControlsAdapter) => Disposable_2;
 
-export declare const registerWorkbenchExtensionDataRenderers: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionDataRendererRecord[], adapter?: WorkbenchExtensionDataRendererAdapter) => {
-    dispose(): void;
-};
+export declare const registerWorkbenchExtensionDataTableRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionDataTableRendererRecord[], panels: DataTableViewRecord[]) => Disposable_2;
 
 export declare const registerWorkbenchExtensionFileRenderers: (input: RegisterWorkbenchExtensionFileRenderersInput) => {
     dispose(): void;
@@ -1007,7 +1206,18 @@ export declare interface RegisterWorkbenchExtensionFileRenderersInput {
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
     metadata: WorkbenchExtensionMetadata;
     projectId: string;
-    workbench: WorkbenchModuleContributionContext;
+    workbench: WorkbenchModuleContext;
+}
+
+export declare const registerWorkbenchExtensionKanbanRenderers: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionKanbanRendererRecord[], adapter?: WorkbenchExtensionKanbanRendererAdapter) => {
+    dispose(): void;
+};
+
+export declare const registerWorkbenchExtensionPanel: (input: RegisterWorkbenchExtensionPanelInput) => Disposable_2;
+
+export declare interface RegisterWorkbenchExtensionPanelInput {
+    contribution: WorkbenchPanelContribution;
+    workbench: WorkbenchModuleContext;
 }
 
 export declare const registerWorkbenchExtensionTreeRenderers: (input: RegisterWorkbenchExtensionTreeRenderersInput) => {
@@ -1020,7 +1230,7 @@ export declare interface RegisterWorkbenchExtensionTreeRenderersInput {
     getHostTreeHeaderNodes?: HostTreeDefaultNodesResolver;
     metadata: WorkbenchExtensionMetadata;
     projectId: string;
-    workbench: WorkbenchModuleContributionContext;
+    workbench: WorkbenchModuleContext;
 }
 
 export declare const renderBridgeWebviewFrame: (input: {
@@ -1033,7 +1243,9 @@ export declare const renderBridgeWebviewFrame: (input: {
     webview: BridgeWebviewConfig;
 }) => JSX.Element;
 
-declare type ResolvedResourceOpener = Required<ResourceOpener>;
+declare type ResolvedResourceHierarchyProvider = Required<ResourceHierarchyProvider>;
+
+declare type ResolvedResourcePresenter = Required<ResourcePresenter>;
 
 declare interface ResourceBrowseEntry {
     resource: ResourceRef;
@@ -1055,6 +1267,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;
@@ -1075,11 +1294,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 {
@@ -1112,24 +1331,29 @@ 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";
 
-declare type RowAction = NonNullable<WorkbenchExtensionDataRendererRecord["rowActions"]>[number];
+declare type RowAction = NonNullable<WorkbenchExtensionKanbanRendererRecord["rowActions"]>[number];
 
 /** Auto-rendered as a param editor from the registered preference schema. */
 declare interface SchemaSettingsPanel extends SettingsPanelBase {
@@ -1197,7 +1421,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;
@@ -1206,6 +1430,8 @@ declare interface SettingsSectionContribution {
     actions?: SettingsAction[];
 }
 
+export declare const shouldRefreshWorkbenchExtensionDataTableRenderers: (metadata: WorkbenchExtensionMetadata, commandId: string) => boolean;
+
 export declare const shouldRefreshWorkbenchExtensionTrees: (metadata: WorkbenchExtensionMetadata, commandId: string) => boolean;
 
 declare type SortDirection = "asc" | "desc";
@@ -1281,6 +1507,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";
@@ -1298,7 +1526,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;
 
@@ -1356,11 +1584,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;
 }
 
 /**
- * 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.
  */
@@ -1369,44 +1599,35 @@ declare type ViewMode = "board" | "list";
 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;
 }
 
 declare type WidgetMountStrategy = "active" | "keep-mounted";
 
-declare type WidgetReusePolicy = "resource" | "none";
-
-declare type WorkbenchArea = (typeof workbenchAreas)[number];
-
-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 type WidgetMountStrategy_2 = "active" | "keep-mounted";
 
-declare interface WorkbenchAreaState {
-    id: WorkbenchArea;
-    visible: boolean;
-    size?: number;
-    widgets: WorkbenchWidgetPlacement[];
-    activeWidgetId?: string;
-}
+declare type WidgetReusePolicy = "resource" | "none";
 
 declare type WorkbenchBreadcrumbChangeListener = () => void;
 
@@ -1421,6 +1642,7 @@ declare interface WorkbenchBreadcrumbController {
 declare interface WorkbenchBreadcrumbItem {
     title: unknown;
     icon?: string;
+    indicator?: "session-status";
     url?: string;
     onClick?: () => void;
     resource?: ResourceRef;
@@ -1430,8 +1652,16 @@ declare interface WorkbenchBreadcrumbState {
     items: WorkbenchBreadcrumbItem[] | undefined;
 }
 
+declare interface WorkbenchClosedSubPanel {
+    region: WorkbenchPanelRegion;
+    reference: WorkbenchSubPanelRef;
+    resource?: ResourceRef;
+    title?: string;
+}
+
 declare interface WorkbenchCommandExecutionContext {
     resource?: ResourceRef;
+    source?: "panel-add";
 }
 
 declare interface WorkbenchCommandExecutionError {
@@ -1486,6 +1716,7 @@ declare interface WorkbenchCommandParamsRequest {
 }
 
 declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
+    host: WorkbenchHost;
     registerModule(module: WorkbenchModuleContribution): Disposable_2;
     unregisterModule(moduleId: string): void;
 }
@@ -1509,7 +1740,8 @@ declare interface WorkbenchCoreContributionContext {
     renderers: WorkbenchRenderers;
     resources: ResourceRegistry;
     settings: SettingsRegistry;
-    sessionPanel: WorkbenchSessionPanelController;
+    shell: WorkbenchShellController;
+    sidePanel: WorkbenchSidePanelController;
     terminal: WorkbenchTerminalController;
     themes: ThemeRegistry;
     fileIconThemes: FileIconThemeRegistry;
@@ -1522,7 +1754,7 @@ declare interface WorkbenchCoreContributionContext {
 export declare interface WorkbenchExtensionCommandContext {
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
     projectId: string;
-    workbench: WorkbenchModuleContributionContext;
+    workbench: WorkbenchModuleContext;
 }
 
 export declare interface WorkbenchExtensionCommandPaletteRegistration {
@@ -1537,67 +1769,58 @@ export declare interface WorkbenchExtensionControlsAdapter {
     resolveResource?: (record: WorkbenchExtensionControlsRendererRecord) => ResourceRef | undefined;
 }
 
-export declare interface WorkbenchExtensionDataRendererAdapter {
+export declare interface WorkbenchExtensionKanbanRendererAdapter {
     /** Override label resolution. Defaults to workbench's `text(value, fallback)`. */
     resolveLabel?: Localizer;
     /** Post-process an attribute descriptor (after localization). Defaults to identity. */
-    decorateAttribute?: (record: WorkbenchExtensionDataRendererRecord, attribute: AttributeDescriptor) => AttributeDescriptor;
+    decorateAttribute?: (record: WorkbenchExtensionKanbanRendererRecord, attribute: AttributeDescriptor) => AttributeDescriptor;
     /**
      * Translate a row's transport-shaped resource (`{ type, id }`) into a workbench
      * `ResourceRef`. Defaults to the workbench `pstdio://extension-resource/...`
      * scheme — dashboard supplies its own. Returns `undefined` for rows that do not
      * carry an explicit resource.
      */
-    resolveRowResource?: (record: WorkbenchExtensionDataRendererRecord, row: DataRendererRow_2) => ResourceRef | undefined;
+    resolveRowResource?: (record: WorkbenchExtensionKanbanRendererRecord, row: KanbanRendererRow_2) => ResourceRef | undefined;
     /**
      * Synthesize a `ResourceRef` for row-action execution context when the row does
      * not carry an explicit resource. Defaults to a `pstdio://extension-resource/`
      * fallback built from `record.resourceKind` and `row.id`.
      */
-    resolveRowActionResource?: (record: WorkbenchExtensionDataRendererRecord, row: DataRendererRow_2) => ResourceRef | undefined;
+    resolveRowActionResource?: (record: WorkbenchExtensionKanbanRendererRecord, row: KanbanRendererRow_2) => ResourceRef | undefined;
     /**
      * Override the row-action runner. `runDefault` performs the workbench's standard
      * flow (look up the row-action command, request params if needed, execute it).
      */
     executeRowAction?: (input: {
-        record: WorkbenchExtensionDataRendererRecord;
+        record: WorkbenchExtensionKanbanRendererRecord;
         action: RowAction;
-        row: DataRendererRow_2;
+        row: KanbanRendererRow_2;
         resource: ResourceRef | undefined;
         runDefault: () => Promise<void>;
     }) => void | Promise<void>;
     /**
-     * Override the row click handler. When unset the view layer falls back to
+     * Override the row click handler. When unset the panel layer falls back to
      * opening the row's resource via `ctx.resources.openResource` — set this to
-     * intercept the click (e.g. swallow rejections when no opener exists yet).
+     * intercept the click (e.g. swallow rejections when no presenter exists yet).
      */
     onRowClick?: (input: {
-        record: WorkbenchExtensionDataRendererRecord;
-        row: DataRendererRow_2;
+        record: WorkbenchExtensionKanbanRendererRecord;
+        row: KanbanRendererRow_2;
         resource: ResourceRef | undefined;
     }) => void;
-    /**
-     * Override the inline-create handler. `executeDefault` runs the record's create
-     * command with the column param. When omitted, the default executes and any
-     * configured `onAfterCreate` runs with the returned value.
-     */
-    onCreateRow?: (input: {
-        record: WorkbenchExtensionDataRendererRecord;
-        columnId: string;
-        executeDefault: () => Promise<unknown>;
-    }) => void;
-    /** Called after a successful default create (when `onCreateRow` is not provided). */
+    /** Called after a successful renderer-owned create form submission. */
     onAfterCreate?: (input: {
-        record: WorkbenchExtensionDataRendererRecord;
+        record: WorkbenchExtensionKanbanRendererRecord;
         created: unknown;
-    }) => void;
+        submission: KanbanRendererCreateSubmission;
+    }) => void | Promise<void>;
     /**
      * Called after any mutation (attribute change, reorder, column action, default
      * create) resolves successfully. Hosts that drive refresh via the outer command
      * pipeline (testbench / workbench) leave this unset; dashboard supplies
-     * `ctx.renderers.refreshDataRenderer(id)`.
+     * `ctx.renderers.refreshKanbanRenderer(id)`.
      */
-    onAfterMutation?: (record: WorkbenchExtensionDataRendererRecord) => void;
+    onAfterMutation?: (record: WorkbenchExtensionKanbanRendererRecord) => void;
 }
 
 export declare interface WorkbenchExtensionMenuRegistration {
@@ -1630,22 +1853,33 @@ 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"];
-
-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;
 }
 
+declare type WorkbenchFocusRegionId = (typeof workbenchFocusRegions)[number];
+
+declare const workbenchFocusRegions: readonly ["activity", "sidenav", "main", "secondary", "side", "status"];
+
 declare interface WorkbenchFocusState {
-    activeArea: WorkbenchFocusArea | undefined;
+    activeRegion: WorkbenchFocusRegionId | undefined;
+}
+
+declare interface WorkbenchHost {
+    getSnapshot(): WorkbenchSnapshot;
+    restoreSnapshot(snapshot: WorkbenchSnapshot): void;
+    setPersistenceScope(scope: string | undefined, input?: {
+        carryRegions?: readonly WorkbenchRegion[];
+    }): void;
+    getPersistenceScope(): string | undefined;
 }
 
 declare interface WorkbenchLastResourceController {
@@ -1655,8 +1889,10 @@ declare interface WorkbenchLastResourceController {
 }
 
 declare interface WorkbenchLayout {
-    areas: Record<WorkbenchArea, WorkbenchAreaState>;
+    regions: Record<WorkbenchRegion, WorkbenchRegionState>;
+    locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion, string>>>;
     activeWidgetId?: string;
+    activeLocationWidgetId?: string;
     activeResourceUri?: string;
 }
 
@@ -1665,7 +1901,25 @@ declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
 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;
+
+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;
 }
 
 declare type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
@@ -1677,16 +1931,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;
 }
 
@@ -1697,6 +1959,8 @@ declare interface WorkbenchModeStoreState {
 
 declare type WorkbenchModuleActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
 
+declare type WorkbenchModuleContext = WorkbenchCoreContributionContext;
+
 declare interface WorkbenchModuleContribution {
     id: string;
     source?: ContributionSource;
@@ -1704,7 +1968,21 @@ declare interface WorkbenchModuleContribution {
     activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
 }
 
-declare type WorkbenchModuleContributionContext = WorkbenchCoreContributionContext;
+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;
+}
 
 declare interface WorkbenchNotification {
     id?: string;
@@ -1723,12 +2001,6 @@ declare interface WorkbenchNotificationAction {
     args?: unknown;
 }
 
-declare interface WorkbenchNotificationAction_2 {
-    commandId: string;
-    title: string;
-    args?: unknown;
-}
-
 declare type WorkbenchNotificationEvent = {
     type: "show";
     id: string;
@@ -1740,26 +2012,193 @@ declare type WorkbenchNotificationEvent = {
 
 declare type WorkbenchNotificationLevel = "info" | "success" | "warning" | "error";
 
-declare type WorkbenchNotificationLevel_2 = "info" | "success" | "warning" | "error";
-
 declare type WorkbenchNotificationListener = (event: WorkbenchNotificationEvent) => void;
 
 declare interface WorkbenchNotificationStoreState {
     notifications: Record<string, RegisteredWorkbenchNotification>;
 }
 
+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[];
+}
+
+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"];
+
+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;
+
+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"];
+
+declare interface WorkbenchRegionSize {
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface WorkbenchRegionState {
+    id: WorkbenchRegion;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement[];
+    activeWidgetId?: string;
 }
 
 declare type WorkbenchRendererChangeListener = () => void;
@@ -1767,7 +2206,7 @@ declare type WorkbenchRendererChangeListener = () => void;
 declare type WorkbenchRendererRegistration = {
     id: string;
     keepAlive?: false;
-    render: (input: WorkbenchWidgetRenderInput) => unknown;
+    render: (input: WorkbenchPanelRenderInput) => unknown;
 } | {
     id: string;
     keepAlive: true;
@@ -1780,32 +2219,54 @@ 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>;
+}
+
+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;
 }
 
-declare type WorkbenchSessionPanelChangeListener = (mode: WorkbenchSessionPanelMode) => void;
+declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | WorkbenchPanelMenuRegion;
 
-declare interface WorkbenchSessionPanelController {
-    store: WorkbenchStore<WorkbenchSessionPanelState>;
-    getMode(): WorkbenchSessionPanelMode;
-    setMode(mode: WorkbenchSessionPanelMode): void;
-    onDidChange(listener: WorkbenchSessionPanelChangeListener): Disposable_2;
+declare interface WorkbenchShellRegionState {
+    open: boolean;
+    size?: number;
+}
+
+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 WorkbenchSessionPanelMode = "bubble" | "closed" | "attached";
+declare type WorkbenchSidePanelMode = "floating" | "closed" | "attached";
+
+declare type WorkbenchSidePanelPresentation = WorkbenchSidePanelMode;
 
-declare interface WorkbenchSessionPanelState {
-    mode: WorkbenchSessionPanelMode;
+declare interface WorkbenchSidePanelState {
+    mode: WorkbenchSidePanelMode;
+}
+
+declare interface WorkbenchSnapshot {
+    layout: WorkbenchLayout;
 }
 
 declare interface WorkbenchStore<TState> {
@@ -1824,6 +2285,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. */
@@ -1917,18 +2399,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 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;
+}
+
+declare interface WorkbenchWidgetTab_2 {
+    contentRendererId?: string;
+    /** Custom actions shown when the user activates an already-active tab. */
+    customMenuRendererId?: string;
 }
 
 export { }