@pstdio/workbench 0.7.1 → 0.9.0

package/dist/index.d.ts

@@ -1,9 +1,28 @@
-import { ComponentType } from 'react';
-import { ReactNode } from 'react';
+import { ControlsQueryResult } from '@pstdio/sdk/extensions';
+import { ControlValue } from '@pstdio/sdk/extensions';
+import { ControlValueMap } from '@pstdio/sdk/extensions';
+import { DockedWorkbenchRegion } from '@pstdio/sdk/extensions';
+import { dockedWorkbenchRegions } from '@pstdio/sdk/extensions';
+import { FileRendererSectionTarget } from '@pstdio/sdk/extensions';
+import { KanbanRendererAttributeDisplay } from '@pstdio/sdk/extensions';
+import { Localizable } from '@pstdio/sdk/extensions';
+import { ModeRegionSettings } from '@pstdio/sdk/extensions';
+import { NavigationTargetPage as NavigationTargetPage_2 } from '@pstdio/sdk/extensions';
+import { NavigationTargetPanel as NavigationTargetPanel_2 } from '@pstdio/sdk/extensions';
+import { PageLocation } from '@pstdio/sdk/extensions';
+import { PageMain } from '@pstdio/sdk/extensions';
+import { PageOpenIntent } from '@pstdio/sdk/extensions';
+import { PageRef } from '@pstdio/sdk/extensions';
+import { PageSlot } from '@pstdio/sdk/extensions';
+import { PlacementIdentity } from '@pstdio/sdk/extensions';
+import { PlacementItem } from '@pstdio/sdk/extensions';
+import { PlacementRef } from '@pstdio/sdk/extensions';
+import { ResourceConstraint } from '@pstdio/sdk/extensions';
+import { ResourceRef } from '@pstdio/sdk/extensions';
 
 export declare type AnchorId = "primary" | "secondary" | "attached";
 
-export declare interface AttributeDescriptor {
+export declare interface AttributeDescriptor<TNode = unknown> {
     id: string;
     label: string;
     type: AttributeType;
@@ -13,14 +32,11 @@ export declare interface AttributeDescriptor {
     displayable?: boolean;
     editable?: boolean;
     display?: AttributeDisplayDescriptor;
-    render?: (value: unknown, row: KanbanRendererRow) => ReactNode;
+    render?: (value: unknown, row: KanbanRendererRow) => TNode;
     compare?: (a: unknown, b: unknown) => number;
 }
 
-export declare type AttributeDisplayDescriptor = {
-    kind: "workspace-badge";
-    itemsAttributeId: string;
-};
+export declare type AttributeDisplayDescriptor = KanbanRendererAttributeDisplay;
 
 export declare type AttributeKind = AttributeType["kind"];
 
@@ -28,9 +44,9 @@ 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.
  */
-declare interface AttributesSource {
+declare interface AttributesSource<TNode = unknown> {
     subscribe: (listener: () => void) => () => void;
-    getSnapshot: () => AttributeDescriptor[];
+    getSnapshot: () => AttributeDescriptor<TNode>[];
 }
 
 export declare type AttributeType = {
@@ -49,22 +65,20 @@ export declare type AttributeType = {
     kind: "user";
 };
 
-export declare interface BoardColumnAction {
+export declare interface BoardColumnAction<TIcon = unknown> {
     id: string;
     label: string;
-    icon: ComponentType<{
-        size?: number | string;
-    }>;
+    icon: TIcon;
 }
 
 /** Board-column behavior and menu configuration for a resolved column group. */
-export declare interface BoardColumnConfig {
+export declare interface BoardColumnConfig<TIcon = unknown> {
     /** Color palette token used for the column header and group badges. */
     color?: string;
     canDragIn?: boolean;
     canDragOut?: boolean;
     canCreate?: boolean;
-    actions?: BoardColumnAction[];
+    actions?: BoardColumnAction<TIcon>[];
 }
 
 /**
@@ -73,12 +87,12 @@ export declare interface BoardColumnConfig {
  */
 export declare interface CollectionSettingsPanel<TItem = unknown> extends SettingsPanelBase {
     kind: "collection";
+    viewId: string;
     items(): TItem[] | Promise<TItem[]>;
     itemId(item: TItem): string;
     itemLabel(item: TItem): string;
     itemIcon?(item: TItem): string | undefined;
     groupBy?: SettingsCollectionGroupBy<TItem>;
-    renderItem(item: TItem, input: WorkbenchPanelRenderInput): unknown;
     actions?: SettingsAction[];
 }
 
@@ -153,6 +167,7 @@ export declare interface CommandParamDescriptor {
     accept?: string;
     multiple?: boolean;
     metadata?: Record<string, unknown>;
+    resolvedFrom?: "resource";
 }
 
 export declare interface CommandParamOption {
@@ -180,70 +195,6 @@ declare interface CommandRegistryStoreState {
     commands: Record<string, RegisteredCommand>;
 }
 
-export declare interface CompositionDiagnostic {
-    code: "extension_resource_kind_missing" | "extension_resource_slot_missing" | "extension_resource_slot_closed" | "extension_panel_missing" | "extension_panel_placement_unresolvable" | "extension_mode_resource_unsupported" | "extension_placement_required_invalid" | "extension_resource_primary_invalid";
-    message: string;
-    panelId?: string;
-    slot?: string;
-}
-
-export declare interface CompositionModeDefinition {
-    id: string;
-    extensionId?: string;
-    resources?: Record<string, CompositionModeRecipe>;
-    modePanels?: Record<string, CompositionPlacementPolicy>;
-}
-
-export declare interface CompositionModeRecipe {
-    slots?: Record<string, CompositionPlacementPolicy>;
-    panels?: Record<string, CompositionPlacementPolicy>;
-}
-
-export declare interface CompositionPanelDefinition {
-    id: string;
-    extensionId: string;
-    title: string;
-    icon?: string;
-    show?: CompositionPanelPlacement | readonly CompositionPanelPlacement[];
-}
-
-declare interface CompositionPanelPlacement extends CompositionPlacementPolicy {
-    resourceKind?: string;
-}
-
-export declare interface CompositionPlacementPolicy {
-    region: DockedCompositionRegion;
-    allowedRegions?: readonly DockedCompositionRegion[];
-    required?: boolean;
-    defaultOpen?: boolean;
-    pinned?: boolean;
-}
-
-declare interface CompositionResolutionContext {
-    modeId: string;
-    resourceKind?: string;
-}
-
-export declare interface CompositionResourceKindDefinition {
-    id: string;
-    extensionId: string;
-    surface: "primary" | "secondary" | "attached";
-    slots: Record<string, CompositionSlotDefinition>;
-}
-
-export declare interface CompositionResourcePanelEdge {
-    id: string;
-    extensionId: string;
-    resourceKind: string;
-    panel: string;
-    slot: string;
-}
-
-export declare interface CompositionSlotDefinition {
-    cardinality: "one" | "many";
-    external: boolean;
-}
-
 export declare interface ContextKeyScope extends Disposable_2 {
     ownerId: string;
     set(key: string, value: ContextKeyValue): void;
@@ -277,16 +228,11 @@ export declare interface ContributionMetadata {
 export declare type ContributionSource = "module" | "extension";
 
 export declare interface ControlsApplyInput {
-    values: Record<string, unknown>;
+    values: ControlValueMap;
     resource?: ResourceRef;
 }
 
-export declare interface ControlsQueryResult {
-    params?: unknown[];
-    groups?: unknown[];
-    values?: Record<string, unknown>;
-    readOnly?: boolean;
-}
+export { ControlsQueryResult }
 
 export declare interface ControlsRendererContribution {
     id: string;
@@ -295,7 +241,7 @@ export declare interface ControlsRendererContribution {
     emptyTitle?: string;
     emptyDescription?: string;
     layout?: ControlsRendererLayout;
-    defaultValues?: Record<string, unknown>;
+    defaultValues?: ControlValueMap;
     /** Load the control declarations + current values for the active resource. */
     executeQuery(resource?: ResourceRef): Promise<ControlsQueryResult> | ControlsQueryResult;
     /** Live-save a single control edit. Omit for explicit-apply or read-only panels. */
@@ -307,10 +253,6 @@ export declare interface ControlsRendererContribution {
     subscribe?: (listener: () => void) => Disposable_2 | (() => void);
 }
 
-export declare type ControlsRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    controlsRendererId: string;
-}) => unknown;
-
 export declare interface ControlsRendererLayout {
     region?: ControlsRendererRegion;
     defaultPx?: number;
@@ -318,28 +260,8 @@ export declare interface ControlsRendererLayout {
     maxPx?: number;
 }
 
-export declare interface ControlsRendererRefreshEvent {
-    controlsRendererId: string;
-}
-
-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;
-    setControlsRendererImplementation(impl: ControlsRendererImplementation): void;
-    getControlsRenderer(id: string): RegisteredControlsRendererContribution | undefined;
-    listControlsRenderers(): RegisteredControlsRendererContribution[];
-    refreshControlsRenderer(id: string): void;
-    onDidRefreshControlsRenderer(listener: ControlsRendererRefreshListener): Disposable_2;
-}
-
-declare interface ControlsRendererStoreState {
-    renderers: Record<string, RegisteredControlsRendererContribution>;
-}
-
 export declare interface ControlsResetInput {
     controlIds?: string[];
     resource?: ResourceRef;
@@ -347,48 +269,54 @@ export declare interface ControlsResetInput {
 
 export declare interface ControlsUpdateValueInput {
     controlId: string;
-    value: unknown;
-    values: Record<string, unknown>;
+    value: ControlValue;
+    values: ControlValueMap;
     resource?: ResourceRef;
 }
 
-export declare const createResourceBreadcrumbItems: (resources: ResourceRegistry, resource: ResourceRef | undefined) => WorkbenchBreadcrumbItem[];
+export declare const createStatusBarRegistry: (input: CreateWorkbenchStatusBarRegistryInput) => WorkbenchStatusBarRegistry;
+
+export declare const createStatusRegistry: () => WorkbenchStatusRegistry;
 
-export declare const createWorkbenchCore: (input?: CreateWorkbenchCoreInput) => WorkbenchCore;
+export declare const createViewRegistry: (input: CreateWorkbenchViewRegistryInput) => WorkbenchViewRegistry;
 
-export declare interface CreateWorkbenchCoreInput {
+export declare const createWorkbench: (input?: createWorkbenchInput) => WorkbenchCore;
+
+export declare interface createWorkbenchInput {
     isInScope?: (resource: ResourceRef, primary: ResourceRef | undefined) => boolean;
     layoutPersistence?: LayoutPersistenceAdapter;
+    pageLocationBrowser?: WorkbenchPageLocationBrowser;
+    pageLocationPersistence?: WorkbenchPageLocationPersistence;
+    resolvePagePersistenceScope?(input: WorkbenchPagePersistenceScopeInput): WorkbenchPagePersistenceScope;
+    pageResources?: WorkbenchPageResourceCodec;
     persistence?: WorkbenchPersistenceAdapter;
-    historyPersistence?: WorkbenchHistoryPersistence;
     preferencePersistence?: PreferencePersistenceAdapter;
     treePersistence?: TreeRendererPersistenceAdapter;
-    panelsPersistence?: WorkbenchPanelsPersistenceAdapter;
+    panelMenuStatePersistence?: WorkbenchPanelMenuStatePersistenceAdapter;
     defaultPanelOpenByRegionId?: Partial<Record<WorkbenchRegion, boolean>>;
-    lastResourcePersistence?: LastResourcePersistenceAdapter;
+    /** Host-level region layout policy. The active mode's regionSettings win over it. */
+    regionSettings?: Partial<Record<WorkbenchRegion, WorkbenchRegionSettings>>;
     sidePanelPersistence?: WorkbenchSidePanelPersistenceAdapter;
+    /** Default floating policy. The active mode may override it. */
+    floatingPanels?: "visible" | "hidden";
     initialSidePanelMode?: WorkbenchSidePanelMode;
-    renderers?: CreateWorkbenchRendererRegistryInput;
-}
-
-declare interface CreateWorkbenchRendererRegistryInput {
-    initialRenderers?: WorkbenchRendererRegistration[];
-    createHost?: () => HTMLElement;
+    startPage?: PageRef;
 }
 
 export declare const createWorkbenchResourceContextValues: (resource: ResourceRef | undefined) => Record<string, ContextKeyValue>;
 
-export declare const createWorkbenchSelectionResourceMetadata: (resource: Pick<ResourceRef, "uri">) => {
-    "workbench.selectionResourceUri": string;
+export declare const createWorkbenchSelectionResourceMetadata: (resource: ResourceRef) => {
+    "workbench.selectionResourceKey": string;
 };
 
-/**
- * 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: WorkbenchPanelRenderInput): unknown;
+declare interface CreateWorkbenchStatusBarRegistryInput {
+    hasView(viewId: string): boolean;
+}
+
+declare interface CreateWorkbenchViewRegistryInput {
+    registerBody(view: WorkbenchViewContribution, metadata?: ContributionMetadata): Disposable_2 & {
+        refresh?(input?: unknown): void;
+    };
 }
 
 export declare interface DataTableRendererColumn {
@@ -444,10 +372,6 @@ export declare interface DataTableRendererContribution {
     onRowActivate?: (row: DataTableRendererRow) => Promise<void> | void;
 }
 
-export declare type DataTableRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    dataTableRendererId: string;
-}) => unknown;
-
 export declare interface DataTableRendererQueryContext {
     resource?: ResourceRef;
     modeId?: string;
@@ -458,20 +382,6 @@ export declare interface DataTableRendererQueryResult {
     columns?: DataTableRendererColumn[];
 }
 
-export declare interface DataTableRendererRefreshEvent {
-    dataTableRendererId: string;
-}
-
-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 DataTableRendererRow {
     id: string;
     values: Record<string, unknown>;
@@ -494,10 +404,6 @@ export declare interface DataTableRendererSelectionAction {
     run(rows: DataTableRendererRow[]): Promise<void> | void;
 }
 
-declare interface DataTableRendererStoreState {
-    renderers: Record<string, RegisteredDataTableRendererContribution>;
-}
-
 export declare interface DataTableRendererThemeColor {
     light: string;
     dark: string;
@@ -507,14 +413,19 @@ export declare interface DataTableRendererThemeColor {
     };
 }
 
+/** Resource URI conversion belongs to route and persistence adapters. */
+export declare const defaultPageResourceCodec: WorkbenchPageResourceCodec;
+
 declare interface Disposable_2 {
     dispose(): void;
 }
 export { Disposable_2 as Disposable }
 
-export declare type DockedCompositionRegion = (typeof dockedCompositionRegions)[number];
+declare type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+
+export { DockedWorkbenchRegion }
 
-export declare const dockedCompositionRegions: readonly ["sidenav", "main", "secondary", "side"];
+export { dockedWorkbenchRegions }
 
 export declare interface EnumOption {
     value: string;
@@ -600,86 +511,37 @@ export declare interface FileRendererContribution {
     save?(resource: ResourceRef | undefined, content: string, origin?: FileRendererRefreshOrigin): Promise<FileRendererSaveResult | undefined> | FileRendererSaveResult | void;
 }
 
-export declare type FileRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    fileRendererId: string;
-}) => unknown;
-
 export declare interface FileRendererRefreshEnvelope {
-    resourceUri?: string;
+    resourceKey?: string;
     origin?: FileRendererRefreshOrigin;
     revision?: string;
 }
 
-export declare interface FileRendererRefreshEvent extends FileRendererRefreshEnvelope {
-    fileRendererId: string;
-}
-
-declare type FileRendererRefreshListener = (event: FileRendererRefreshEvent) => void;
-
 export declare interface FileRendererRefreshOrigin {
     rendererId: string;
     instanceId: string;
     operationId: string;
 }
 
-export declare interface FileRendererRegistry {
-    fileRendererStore: WorkbenchStore<FileRendererStoreState>;
-    registerFileRenderer(contribution: FileRendererContribution, metadata?: ContributionMetadata): Disposable_2;
-    setFileRendererImplementation(impl: FileRendererImplementation): void;
-    getFileRenderer(id: string): RegisteredFileRendererContribution | undefined;
-    listFileRenderers(): RegisteredFileRendererContribution[];
-    refreshFileRenderer(id: string, event?: FileRendererRefreshEnvelope): void;
-    onDidRefreshFileRenderer(listener: FileRendererRefreshListener): Disposable_2;
-}
-
 export declare interface FileRendererSaveResult {
     revision?: string;
 }
 
-declare interface FileRendererStoreState {
-    renderers: Record<string, RegisteredFileRendererContribution>;
-}
-
 export declare const getKeybindingSteps: (keybinding: KeybindingSequence) => string[];
 
-export declare const getSwitchModeNavigationTargetModeId: (target: NavigationTarget) => string | undefined;
-
 export declare const getWorkbenchModePanelForRegion: (region: WorkbenchRegion) => "main" | "secondary" | "side" | undefined;
 
-export declare const getWorkbenchSelectionResourceUris: (resource: ResourceRef | undefined) => string[];
+export declare const getWorkbenchSelectionResourceKeys: (resource: ResourceRef | undefined) => string[];
 
 export declare const headerLeadingMenuPath: (region: string) => MenuPath;
 
 export declare const headerTrailingMenuPath: (region: string) => MenuPath;
 
-export declare interface HistoryController {
-    store: WorkbenchStore<HistoryStoreState>;
-    /** Snapshot the history for a compound navigation; the returned function restores it. */
-    createCheckpoint(): () => void;
-    goBack(): HistoryEntry | undefined;
-    goForward(): HistoryEntry | undefined;
-    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 type HistoryEntry = WorkbenchNavigationEntry;
-
-declare interface HistoryStoreState {
-    entries: readonly WorkbenchNavigationEntry[];
-    cursor: number;
-    recentlyClosed: readonly WorkbenchNavigationEntry[];
-    hydrating: boolean;
-}
-
 export declare const isWorkbenchModePanelAvailable: (mode: WorkbenchModeContribution | undefined, panel: WorkbenchPanelRegion) => boolean;
 
-export declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> {
+export declare const isWorkbenchViewHierarchyNode: (node: WorkbenchHierarchyNode) => node is WorkbenchViewHierarchyNode;
+
+export declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow, TNode = unknown, TIcon = unknown> {
     id: string;
     title: string;
     resourceKind?: string;
@@ -694,9 +556,9 @@ export declare interface KanbanRendererContribution<TRow extends KanbanRendererR
      * `WorkbenchKanbanView` subscribes so additions / removals / kind changes
      * propagate live without re-registering the renderer.
      */
-    attributes: AttributeDescriptor[] | AttributesSource;
+    attributes: AttributeDescriptor<TNode>[] | AttributesSource<TNode>;
     /** Per-board-column overrides (color, drag/create rules, custom actions). */
-    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
+    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig<TIcon>;
     hideToolbar?: boolean;
     emptyTitle?: string;
     emptyDescription?: string;
@@ -715,7 +577,7 @@ export declare interface KanbanRendererContribution<TRow extends KanbanRendererR
     /** Row activation surfaced by the renderer (mirrored from <KanbanRenderer>). */
     onRowActivate?: (row: TRow) => Promise<void> | void;
     /** Per-row right-click context menu actions (mirrored from <KanbanRenderer>). */
-    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
+    getRowContextMenuActions?: (row: TRow) => ResourceContextAction<TNode>[];
     /**
      * Fires for inline attribute edits AND for cross-column drag-to-reorder on
      * the board (the renderer passes the grouping attribute id + the target
@@ -772,10 +634,6 @@ export declare interface KanbanRendererCreateSubmission {
 
 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;
@@ -786,22 +644,6 @@ export declare interface KanbanRendererQueryState {
     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;
@@ -830,15 +672,11 @@ export declare interface KanbanRendererSettings {
     displayProperties: string[];
 }
 
-declare interface KanbanRendererStoreState {
-    renderers: Record<string, RegisteredKanbanRendererContribution>;
-}
-
 export declare interface Keybinding {
-    commandId: string;
+    /** Action the chord executes through the shared navigation executor. */
+    action: NavigationTarget;
     keybinding: KeybindingSequence;
     when?: string;
-    args?: unknown;
 }
 
 export declare interface KeybindingRegistry {
@@ -846,6 +684,11 @@ export declare interface KeybindingRegistry {
     registerKeybinding(keybinding: Keybinding, metadata?: ContributionMetadata): Disposable_2;
     listKeybindings(): RegisteredKeybinding[];
     listActiveKeybindings(): RegisteredKeybinding[];
+    /** Chords bound to plain command actions, for rendering shortcut hints beside commands. */
+    listCommandKeybindings(): {
+        commandId: string;
+        keybinding: KeybindingSequence;
+    }[];
 }
 
 declare interface KeybindingRegistryStoreState {
@@ -854,11 +697,6 @@ declare interface KeybindingRegistryStoreState {
 
 export declare type KeybindingSequence = string | string[];
 
-export declare interface LastResourcePersistenceAdapter {
-    getLastResource(): ResourceRef | undefined;
-    setLastResource(resource: ResourceRef | undefined): void;
-}
-
 declare interface LayoutModel {
     store: WorkbenchStore<WorkbenchLayoutStoreState>;
     registerPlaceholder(placeholder: PlaceholderContribution, metadata?: ContributionMetadata): {
@@ -870,12 +708,6 @@ declare interface LayoutModel {
     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;
     };
@@ -887,6 +719,7 @@ declare interface LayoutModel {
     getWidget(id: string): RegisteredWidgetContribution | undefined;
     getPanel(id: string): WorkbenchPanelContribution | undefined;
     getRegionSize(regionId: WorkbenchRegion): WorkbenchRegionSize | undefined;
+    getRegionSettings(regionId: WorkbenchRegion): WorkbenchRegionSettings | undefined;
     getRegionCollapsible(regionId: WorkbenchRegion): boolean;
     getRegionHeaderBorderBottom(regionId: WorkbenchRegion): boolean;
     setRegionVisible(regionId: WorkbenchRegion, visible: boolean): void;
@@ -904,7 +737,7 @@ declare interface LayoutModel {
     closePanel(instanceId: string): WorkbenchPanelInstance | undefined;
     updateWidgetPlacement(widgetId: string, input: OpenWidgetInput): WorkbenchWidgetPlacement;
     reorderWidget(widgetId: string, position: WorkbenchTabPosition): void;
-    expirePreviewTabs(ownerResourceUri?: string): void;
+    expirePreviewTabs(ownerResourceKey?: string): void;
     activateWidget(widgetId: string): WorkbenchWidgetPlacement;
     setRegionActiveWidget(regionId: WorkbenchRegion, widgetId: string | undefined): void;
     closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
@@ -982,14 +815,20 @@ declare interface MenuRegistryStoreState {
     itemsByPath: Record<string, RegisteredMenuItem[]>;
 }
 
+declare type NativeViewBody<Kind extends string, Contribution> = {
+    kind: Kind;
+} & Omit<Contribution, "id" | "title" | "icon">;
+
 export declare interface NavigationDispatcherContext {
-    canOpenResource?(resource: ResourceRef): boolean;
-    canOpenPanel?(panelId: string): boolean;
+    canOpenPanel?(target: NavigationTargetPanel): boolean;
     canExecuteCommand?(commandId: string): boolean;
-    createCheckpoint?(): undefined | (() => void);
-    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<unknown>;
-    openPanel(panelId: string, input?: OpenWorkbenchPanelInput): unknown;
+    prepareNavigation?(targets: readonly (NavigationTargetPage | NavigationTargetPanel)[]): {
+        commit(): unknown;
+    };
+    openPanelTarget?(target: NavigationTargetPanel): unknown;
+    openPageTarget?(target: NavigationTargetPage): unknown;
     executeCommand(commandId: string, args?: unknown): Promise<unknown> | unknown;
+    openHref?(href: string): Promise<unknown> | unknown;
 }
 
 export declare interface NavigationParser {
@@ -1005,16 +844,15 @@ export declare interface NavigationRegistry {
     listParsers(): RegisteredNavigationParser[];
     resolveLocation(location: string): NavigationTarget;
     openTarget(target: NavigationTarget): Promise<readonly unknown[]>;
+    /** Opens a page location through the shared executor. */
+    openPage(target: Omit<NavigationTargetPage, "kind">): Promise<readonly unknown[]>;
+    /** Opens or activates an owned panel through the shared executor. */
+    openPanel(target: DistributiveOmit<NavigationTargetPanel, "kind">): Promise<readonly unknown[]>;
     navigate(location: string): Promise<readonly unknown[]>;
-    registerNavigator(navigator: ResourceNavigator, metadata?: ContributionMetadata): Disposable_2;
-    listNavigators(): RegisteredResourceNavigator[];
-    createHref(resource: ResourceRef): string;
-    navigateResource(resource: ResourceRef): Promise<unknown>;
 }
 
 declare interface NavigationRegistryStoreState {
     parsers: Record<string, RegisteredNavigationParser>;
-    navigators: Record<string, RegisteredResourceNavigator>;
 }
 
 export declare type NavigationTarget = NavigationTargetItem | NavigationTargetCompound;
@@ -1027,23 +865,63 @@ export declare interface NavigationTargetCommand {
 
 export declare interface NavigationTargetCompound {
     kind: "compound";
-    targets: readonly NavigationTargetItem[];
+    targets: readonly (NavigationTargetPage | NavigationTargetPanel)[];
 }
 
-export declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetPanel | NavigationTargetCommand;
+declare interface NavigationTargetHref {
+    kind: "href";
+    href: string;
+}
+
+export declare type NavigationTargetItem = NavigationTargetPage | NavigationTargetPanel | NavigationTargetCommand | NavigationTargetHref;
+
+declare type NavigationTargetPage = NavigationTargetPage_2;
+
+export declare type NavigationTargetPanel = NavigationTargetPanel_2 | NavigationTargetShellPanel;
 
-export declare interface NavigationTargetPanel {
+declare interface NavigationTargetShellPanel {
     kind: "panel";
-    panelId: string;
-    input?: OpenWorkbenchPanelInput;
+    panel: ShellPlacementRef;
+    resource?: NavigationTargetPanel_2["resource"];
+    open?: NavigationTargetPanel_2["open"];
+    title?: string;
 }
 
-export declare interface NavigationTargetResource {
-    kind: "resource";
-    resource: ResourceRef;
-    input?: OpenResourceInput;
+export declare interface NavigationTreeContext {
+    resource?: ResourceRef;
+}
+
+export declare interface NavigationTreeContribution {
+    id: string;
+    /** Prefix projected section and node ids when they come from an independent tree renderer. */
+    idScope?: string;
+    owner: NavigationTreeOwner;
+    sourceExtensionId: string;
+    declarationIndex: number;
+    slot?: NavigationTreeSlot;
+    viewId?: string;
+    defaultExpandedSectionIds?: string[];
+    getSections?(context: NavigationTreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
+    getChildren?(node: TreeNode, context: NavigationTreeContext): Promise<TreeNode[]> | TreeNode[];
+}
+
+export declare interface NavigationTreeOwner {
+    kind: "mode" | "page";
+    id: string;
+    extensionId: string;
+}
+
+export declare interface NavigationTreeRegistry {
+    registerContribution(contribution: NavigationTreeContribution): Disposable_2;
+    resolveOwner(kind: NavigationTreeOwner["kind"], id: string): NavigationTreeOwner | undefined;
+    getSections(owner: NavigationTreeOwner, slot?: NavigationTreeSlot, context?: NavigationTreeContext): Promise<TreeViewSection[]>;
+    getChildren(node: TreeNode, context?: NavigationTreeContext): Promise<TreeNode[]>;
+    getDefaultExpandedSectionIds(owner: NavigationTreeOwner): string[];
+    onDidChange(listener: () => void): Disposable_2;
 }
 
+export declare type NavigationTreeSlot = "header" | "content" | "footer";
+
 declare const NO_GROUPING = "none";
 
 export declare interface NotificationRegistry {
@@ -1055,12 +933,15 @@ export declare interface NotificationRegistry {
     subscribe(listener: WorkbenchNotificationListener): Disposable_2;
 }
 
-export declare interface OpenResourceInput {
-    replaceActive?: boolean;
+declare interface OpenModePlacementTarget {
+    panel: PlacementRef;
+    resource?: ResourceRef;
+    open?: PageOpenIntent;
 }
 
 declare interface OpenWidgetInput {
-    resource?: ResourceRef;
+    viewId?: string | null;
+    resource?: ResourceRef | null;
     title?: string;
     region?: WorkbenchRegion;
     role?: WorkbenchWidgetRole;
@@ -1077,9 +958,17 @@ declare interface OpenWidgetInput {
     replaceWidgetId?: string;
 }
 
-export declare interface OpenWorkbenchPanelInput {
+declare interface OpenWorkbenchOverlayInput {
     resource?: ResourceRef;
     title?: string;
+}
+
+declare interface OpenWorkbenchPanelInput {
+    /** Set by the view registry. Low-level layout callers should leave this undefined. */
+    viewId?: string | null;
+    /** `null` explicitly clears an existing singleton placement's resource binding. */
+    resource?: ResourceRef | null;
+    title?: string;
     region?: WorkbenchRegion;
     role?: WorkbenchWidgetRole;
     pinned?: boolean;
@@ -1090,25 +979,39 @@ export declare interface OpenWorkbenchPanelInput {
     strategy?: WorkbenchPanelOpenStrategy;
 }
 
-export declare interface PersistedCompositionLayout {
-    regions: Partial<Record<DockedCompositionRegion, PersistedCompositionRegionState>>;
+declare interface OpenWorkbenchShellPlacementInput {
+    placementId: string;
+    resource?: ResourceRef;
+    open?: PageOpenIntent;
+    title?: string;
+}
+
+declare interface OwnedPlacementLocationContext {
+    modeId: string;
+    pageId?: string;
+    projectId?: string;
+    location?: PageLocation;
 }
 
-declare interface PersistedCompositionRegionState {
-    order: readonly string[];
-    activePanelId?: string;
+declare interface OwnedPlacementReconciliation<Value> {
+    add: readonly ResolvedOwnedPlacement<Value>[];
+    retain: readonly ResolvedOwnedPlacement<Value>[];
+    update: readonly OwnedPlacementUpdate<Value>[];
+    activate: readonly ResolvedOwnedPlacement<Value>[];
+    remove: readonly ResolvedOwnedPlacement<Value>[];
 }
 
-export declare interface PersistedTreeRendererStates {
-    statesByTreeId: Record<string, TreeRendererState>;
+declare interface OwnedPlacementUpdate<Value> {
+    current: ResolvedOwnedPlacement<Value>;
+    desired: ResolvedOwnedPlacement<Value>;
 }
 
-export declare interface PersistedWorkbenchHistory extends Omit<HistoryStoreState, "hydrating"> {
-    version: 1;
+declare interface PersistedTreeRendererStates {
+    statesByTreeId: Record<string, TreeRendererState>;
 }
 
-declare interface PersistedWorkbenchPanels {
-    openByRegionId: Record<string, boolean>;
+declare interface PersistedWorkbenchPanelMenuState {
+    openByMenuId: Record<string, boolean>;
 }
 
 declare interface PlaceholderContribution {
@@ -1171,24 +1074,6 @@ declare interface RegisteredContributionMetadata {
     priority: number;
 }
 
-declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, 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;
-    attachedTo?: HTMLElement;
-}
-
 declare interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {
 }
 
@@ -1208,8 +1093,6 @@ declare type RegisteredPreferenceSchema = PreferencePropertySchema & {
 declare interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {
 }
 
-declare type RegisteredResourceNavigator = Omit<ResourceNavigator, "priority"> & RegisteredContributionMetadata;
-
 declare type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
 
 declare type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
@@ -1234,52 +1117,21 @@ declare interface RegisteredWorkbenchNotification extends RegisteredContribution
     metadata?: Record<string, unknown>;
 }
 
-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 RegisteredWorkbenchStatusSet = WorkbenchStatusSetContribution & RegisteredContributionMetadata;
 
-export declare const resolveComposition: (input: ResolveCompositionInput) => ResolvedComposition;
-
-declare interface ResolveCompositionInput {
-    context: CompositionResolutionContext;
-    mode: CompositionModeDefinition;
-    composition: WorkbenchComposition;
-    persisted?: PersistedCompositionLayout;
-}
-
-export declare interface ResolvedComposition {
-    placements: readonly ResolvedCompositionPlacement[];
-    regionOrder: Partial<Record<DockedCompositionRegion, readonly string[]>>;
-    activePanelIds: Partial<Record<DockedCompositionRegion, string>>;
-    addablePanels: readonly ResolvedCompositionAddablePanel[];
-    diagnostics: readonly CompositionDiagnostic[];
-    requiredFallback?: {
-        panelId: string;
-    };
-}
+export declare type RegisteredWorkbenchView = WorkbenchViewContribution & RegisteredContributionMetadata;
 
-export declare interface ResolvedCompositionAddablePanel {
-    panelId: string;
-    region: DockedCompositionRegion;
-    allowedRegions: readonly DockedCompositionRegion[];
-    pinned?: boolean;
-}
+export declare const resolveAnchorRegion: (anchorId: AnchorId) => "status" | "main" | "nav" | "activity" | "sidenav" | "main-header" | "main-left-menu" | "main-right-menu" | "secondary-header" | "secondary-left-menu" | "secondary" | "secondary-right-menu" | "side-header" | "side-left-menu" | "side" | "side-right-menu" | "overlay";
 
-export declare interface ResolvedCompositionPlacement {
-    panelId: string;
-    region: DockedCompositionRegion;
-    slot?: string;
-    required: boolean;
-    defaultOpen: boolean;
-    pinned?: boolean;
-    allowedRegions: readonly DockedCompositionRegion[];
-    origin: "persisted" | "required" | "default";
+declare interface ResolvedOwnedPlacement<Value = unknown> {
+    identity: PlacementIdentity;
+    region: WorkbenchRegion;
+    order: number;
+    value: Value;
 }
 
 declare type ResolvedResourceHierarchyProvider = Required<ResourceHierarchyProvider>;
 
-declare type ResolvedResourcePresenter = Omit<ResourcePresenter, "priority"> & {
-    priority: number;
-};
-
 export declare interface ResourceBrowseEntry {
     resource: ResourceRef;
     searchText?: string;
@@ -1290,13 +1142,13 @@ export declare interface ResourceBrowseEntry {
 }
 
 /** Row-level context menu action surfaced by the renderer. */
-export declare interface ResourceContextAction {
+export declare interface ResourceContextAction<TNode = unknown> {
     key: string;
     label: string;
     onClick: () => Promise<void> | void;
     isDisabled?: boolean;
-    icon?: ReactNode;
-    endContent?: ReactNode;
+    icon?: TNode;
+    endContent?: TNode;
     separatorBefore?: boolean;
 }
 
@@ -1304,7 +1156,7 @@ export declare const resourceContextMenuPath: (resourceKind: string) => MenuPath
 
 export declare interface ResourceHierarchyCycle {
     code: typeof resourceHierarchyCycleCode;
-    path: ResourceRef[];
+    path: WorkbenchHierarchyNode[];
     repeatedUri: string;
 }
 
@@ -1314,81 +1166,47 @@ export declare interface ResourceHierarchyProvider {
     id: string;
     priority?: number;
     canResolve(resource: ResourceRef): boolean;
-    getParent(resource: ResourceRef): ResourceRef | undefined;
+    getParent(resource: ResourceRef): WorkbenchHierarchyNode | undefined;
 }
 
 export declare interface ResourceKindContribution {
     kind: string;
     label: string;
     icon?: string;
-    surface?: ResourceSurface;
-    paletteOpenInput?: OpenResourceInput;
 }
 
 export declare interface ResourceListContext {
     primary?: ResourceRef;
 }
 
-declare interface ResourceNavigator<TResult = unknown> {
-    id: string;
-    priority?: number;
-    canNavigate(resource: ResourceRef): boolean;
-    createHref?(resource: ResourceRef): string;
-    navigate(resource: ResourceRef): TResult | Promise<TResult>;
-}
-
-export declare interface ResourcePresenter {
-    id: string;
-    priority?: number;
-    canOpen(resource: ResourceRef): boolean;
-    open(resource: ResourceRef, input: OpenResourceInput): WorkbenchPanelInstance | Promise<WorkbenchPanelInstance>;
-    afterOpen?(resource: ResourceRef, instance: WorkbenchPanelInstance, input: OpenResourceInput): void;
-}
-
 export declare interface ResourceProvider {
     id: string;
     kind: string;
     list(query: string, context: ResourceListContext): readonly ResourceBrowseEntry[];
 }
 
-export declare interface ResourceRef {
-    kind: string;
-    uri: string;
-    id?: string;
-    label?: string;
-    icon?: string;
-    metadata?: Record<string, unknown>;
-}
+export { ResourceRef }
 
 export declare interface ResourceRegistry {
     store: WorkbenchStore<ResourceRegistryStoreState>;
     registerKind(kind: ResourceKindContribution, metadata?: ContributionMetadata): Disposable_2;
     getKind(kind: string): RegisteredResourceKind | undefined;
-    getSurface(resource: ResourceRef): ResourceSurface | undefined;
     listKinds(): RegisteredResourceKind[];
-    registerPresenter(presenter: ResourcePresenter): Disposable_2;
-    listPresenters(): ResolvedResourcePresenter[];
     registerProvider(provider: ResourceProvider): Disposable_2;
     listProviders(): ResourceProvider[];
     listResources(query: string): readonly ResourceBrowseEntry[];
     registerHierarchyProvider(provider: ResourceHierarchyProvider): Disposable_2;
     listHierarchyProviders(): ResolvedResourceHierarchyProvider[];
-    walkHierarchy(resource: ResourceRef | undefined): ResourceRef[];
+    walkHierarchy(resource: ResourceRef | undefined): WorkbenchHierarchyNode[];
     onDidDetectHierarchyCycle(listener: (cycle: ResourceHierarchyCycle) => void): Disposable_2;
-    isOpeningResource(): boolean;
-    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<WorkbenchPanelInstance>;
-    onDidOpenResource(listener: (resource: ResourceRef) => void): Disposable_2;
 }
 
 declare interface ResourceRegistryStoreState {
     kinds: Record<string, RegisteredResourceKind>;
-    presenters: Record<string, ResolvedResourcePresenter>;
     providers: Record<string, ResourceProvider>;
     hierarchyProviders: Record<string, ResolvedResourceHierarchyProvider>;
 }
 
-export declare type ResourceSurface = "primary" | "secondary" | "attached";
-
 /** Auto-rendered as a param editor from the registered preference schema. */
 export declare interface SchemaSettingsPanel extends SettingsPanelBase {
     kind: "schema";
@@ -1425,7 +1243,7 @@ export declare interface SettingsPanelBase {
     when?: string;
 }
 
-export declare type SettingsPanelContribution = SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel;
+export declare type SettingsPanelContribution = SchemaSettingsPanel | ViewSettingsPanel | CollectionSettingsPanel;
 
 /** A preference this panel edits; a bare string uses the preference name as its label. */
 export declare type SettingsPanelPreference = string | {
@@ -1436,11 +1254,13 @@ export declare type SettingsPanelPreference = string | {
 export declare interface SettingsRegistry {
     store: WorkbenchStore<SettingsRegistryStoreState>;
     registerSection(section: SettingsSectionContribution, metadata?: ContributionMetadata): Disposable_2;
-    registerPanel<TItem = unknown>(panel: SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel<TItem>, metadata?: ContributionMetadata): Disposable_2;
+    registerPanel<TItem = unknown>(panel: SchemaSettingsPanel | ViewSettingsPanel | CollectionSettingsPanel<TItem>, metadata?: ContributionMetadata): Disposable_2;
     getSection(id: string): RegisteredSettingsSection | undefined;
     getPanel(id: string): RegisteredSettingsPanel | undefined;
     listSections(): RegisteredSettingsSection[];
     listPanels(): RegisteredSettingsPanel[];
+    resolveCollectionItem(panelId: string, itemId: string): Promise<unknown | undefined>;
+    getCollectionItem(panelId: string, itemId: string): unknown | undefined;
     /** Signal that a collection's backing data changed so the surface refreshes. */
     refresh(): void;
 }
@@ -1464,6 +1284,12 @@ export declare interface SettingsSectionContribution {
     actions?: SettingsAction[];
 }
 
+/** Core-only panel ref for host-owned shell placements. Extensions cannot address them. */
+declare interface ShellPlacementRef {
+    kind: "shell-placement";
+    id: string;
+}
+
 export declare type SortDirection = "asc" | "desc";
 
 export declare type StandardResourceIcon = (typeof standardResourceIcons)[keyof typeof standardResourceIcons];
@@ -1514,15 +1340,29 @@ export declare interface TreeAction {
     run?(args?: unknown): Promise<void> | void;
 }
 
-export declare interface TreeContext {
-    filter?: string;
-    resource?: ResourceRef;
-    /** Widget/view contribution id for trees rendered through a view-backed widget. */
-    viewId?: string;
+export declare interface TreeContext extends TreeQueryContext {
+    state: Readonly<TreeRendererState>;
+    refresh(): void;
+    setSelectedNode(nodeId: string | undefined): void;
+}
+
+export declare interface TreeMoveEndpoint {
+    kind: "section" | "node";
+    sectionId: string;
+    id: string;
+    moveScope?: string;
 }
 
+export declare type TreeMovePolicy = (move: {
+    source: TreeMoveEndpoint;
+    destination: TreeMoveEndpoint;
+}) => boolean;
+
 export declare interface TreeNode {
     id: string;
+    selected?: boolean;
+    /** Host-owned customization boundary. Extension callbacks cannot set it. */
+    moveScope?: string;
     label: string;
     icon?: string;
     iconElement?: unknown;
@@ -1567,6 +1407,13 @@ export declare interface TreeNodeInlineInput {
 
 declare type TreeNodeRowVariant = "empty-state";
 
+declare interface TreeQueryContext {
+    filter?: string;
+    resource?: ResourceRef;
+    /** Widget/view contribution id for trees rendered through a view-backed widget. */
+    viewId?: string;
+}
+
 export declare interface TreeRendererContribution {
     id: string;
     title: string;
@@ -1577,37 +1424,38 @@ export declare interface TreeRendererContribution {
     defaultExpandedSectionIds?: string[];
     defaultExpandedNodeIds?: string[];
     getBody(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
-    getHeader?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
-    getFooter?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    getHeader?(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
+    getFooter?(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
     getChildren(node: TreeNode, ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    canMove?: TreeMovePolicy;
     moveNode?(source: TreeNode, target: TreeNode | undefined, ctx: TreeContext): Promise<void> | void;
 }
 
-export declare type TreeRendererImplementation = (input: WorkbenchPanelRenderInput & {
+declare type TreeRendererImplementation = (input: WorkbenchPanelRenderInput & {
     treeId: string;
 }) => unknown;
 
-export declare interface TreeRendererPersistenceAdapter {
+declare interface TreeRendererPersistenceAdapter {
     getTreeStates(): PersistedTreeRendererStates | undefined;
     setTreeStates(states: PersistedTreeRendererStates): void;
 }
 
-export declare interface TreeRendererRefreshEvent {
+declare interface TreeRendererRefreshEvent {
     treeId: string;
 }
 
 declare type TreeRendererRefreshListener = (event: TreeRendererRefreshEvent) => void;
 
-export declare interface TreeRendererRegistry {
+declare interface TreeRendererRegistry {
     treeStore: WorkbenchStore<TreeRendererStoreState>;
     registerTreeRenderer(view: TreeRendererContribution, metadata?: ContributionMetadata): Disposable_2;
     setTreeRendererImplementation(impl: TreeRendererImplementation): void;
     getTreeRenderer(id: string): RegisteredTreeRendererContribution | undefined;
     listTreeRenderers(): RegisteredTreeRendererContribution[];
-    getBody(id: string, ctx?: TreeContext): Promise<TreeViewSection[]>;
-    getHeader(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
-    getFooter(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
-    getChildren(id: string, node: TreeNode, ctx?: TreeContext): Promise<TreeNode[]>;
+    getBody(id: string, ctx?: TreeQueryContext): Promise<TreeViewSection[]>;
+    getHeader(id: string, ctx?: TreeQueryContext): Promise<TreeViewSection[]>;
+    getFooter(id: string, ctx?: TreeQueryContext): Promise<TreeViewSection[]>;
+    getChildren(id: string, node: TreeNode, ctx?: TreeQueryContext): Promise<TreeNode[]>;
     getTreeState(id: string): TreeRendererState;
     setNodeExpanded(id: string, nodeId: string, expanded: boolean): void;
     setSectionExpanded(id: string, sectionId: string, expanded: boolean): void;
@@ -1638,6 +1486,8 @@ declare interface TreeSectionEmptyState {
 
 export declare interface TreeViewSection {
     id: string;
+    /** Host-owned customization boundary. Extension callbacks cannot set it. */
+    moveScope?: string;
     label?: string;
     actions?: TreeAction[];
     collapsible?: boolean;
@@ -1658,6 +1508,11 @@ export declare interface TreeViewSection {
  */
 export declare type ViewMode = "board" | "list";
 
+export declare interface ViewSettingsPanel extends SettingsPanelBase {
+    kind: "view";
+    viewId: string;
+}
+
 declare interface WidgetContribution {
     id: string;
     title: string;
@@ -1669,15 +1524,13 @@ declare interface WidgetContribution {
     mountStrategy?: WidgetMountStrategy;
     closable?: boolean;
     hiddenByDefault?: boolean;
-    subPanelsOnly?: boolean;
     regionSize?: WorkbenchRegionSize;
     regionCollapsible?: boolean;
     headerBorderBottom?: boolean;
-    floatingPanels?: WorkbenchFloatingPanelVisibility;
     resourceKinds?: string[];
     priority?: number;
     rendererId: string;
-    openCommandId?: string;
+    openCommand?: WorkbenchCommandTarget;
     eligibleLocations?: WorkbenchLocationEligibility;
     panelMenuOwner?: WorkbenchPanelMenuOwner;
     tab?: WorkbenchWidgetTab;
@@ -1712,13 +1565,6 @@ 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";
@@ -1762,7 +1608,7 @@ declare interface WorkbenchCommandPaletteState {
     paramsRequest: WorkbenchCommandParamsRequest | null;
 }
 
-declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
+declare type WorkbenchCommandPaletteView = "main" | "theme";
 
 declare interface WorkbenchCommandParamsRequest {
     record: {
@@ -1777,14 +1623,14 @@ declare interface WorkbenchCommandParamsRequest {
     context?: WorkbenchCommandExecutionContext;
 }
 
-export declare interface WorkbenchComposition {
-    resourceKinds: readonly CompositionResourceKindDefinition[];
-    panels: readonly CompositionPanelDefinition[];
-    resourcePanels: readonly CompositionResourcePanelEdge[];
+export declare interface WorkbenchCommandTarget {
+    commandId: string;
+    args?: unknown;
 }
 
 declare interface WorkbenchCompositionAddablePanel extends WorkbenchModeAddablePanel {
     contribution: RegisteredWidgetContribution;
+    open?(resource?: ResourceRef): void;
 }
 
 declare interface WorkbenchCompositionController {
@@ -1799,11 +1645,14 @@ declare interface WorkbenchCompositionRegionPanels {
 
 export declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
     host: WorkbenchHost;
+    layout: WorkbenchLayoutModel;
     registerModule(module: WorkbenchModuleContribution): Disposable_2;
     unregisterModule(moduleId: string): void;
 }
 
 declare interface WorkbenchCoreContributionContext {
+    pinPlacement(identity: PlacementIdentity): void;
+    closePlacement(identity: PlacementIdentity): void;
     breadcrumbs: WorkbenchBreadcrumbController;
     commandPalette: WorkbenchCommandPaletteController;
     commandPaletteResources: CommandPaletteResourceRegistry;
@@ -1811,19 +1660,27 @@ declare interface WorkbenchCoreContributionContext {
     composition: WorkbenchCompositionController;
     context: ContextKeyService;
     focus: WorkbenchFocusController;
-    history: HistoryController;
     keybindings: KeybindingRegistry;
-    lastResource: WorkbenchLastResourceController;
-    layout: WorkbenchLayoutModel;
+    layout: WorkbenchModuleLayoutModel;
     modes: WorkbenchModeRegistry;
+    modePlacements: WorkbenchModePlacementRegistry;
+    shellPlacements: WorkbenchShellPlacementRegistry;
     navigation: NavigationRegistry;
-    navigator: WorkbenchNavigator;
+    navigationTrees: NavigationTreeRegistry;
     notifications: NotificationRegistry;
-    panels: WorkbenchPanelsController;
+    overlays: WorkbenchOverlayRegistry;
+    placeholders: WorkbenchPlaceholderRegistry;
+    pageLocations: WorkbenchPageLocationController;
+    pages: WorkbenchPageRegistry<WorkbenchWidgetPlacement>;
+    panelMenuState: WorkbenchPanelMenuStateController;
     preferences: PreferenceRegistry;
-    renderers: WorkbenchRenderers;
+    treeViews: WorkbenchTreeViews;
     resources: ResourceRegistry;
+    views: WorkbenchViewRegistry;
+    viewMenus: WorkbenchViewMenuRegistry;
     settings: SettingsRegistry;
+    statusBar: WorkbenchStatusBarRegistry;
+    statuses: WorkbenchStatusRegistry;
     shell: WorkbenchShellController;
     sidePanel: WorkbenchSidePanelController;
     terminal: WorkbenchTerminalController;
@@ -1833,14 +1690,13 @@ declare interface WorkbenchCoreContributionContext {
     onDidChangePrimaryResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
     getActiveResource(): ResourceRef | undefined;
     onDidChangeActiveResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
+    registerChildModule(module: WorkbenchModuleContribution): Disposable_2;
 }
 
 declare interface WorkbenchFileIconThemeStoreState {
     themes: readonly FileIconThemePreferenceOption[];
 }
 
-export declare type WorkbenchFloatingPanelVisibility = "visible" | "hidden";
-
 declare type WorkbenchFocusChangeListener = (region: WorkbenchFocusRegionId | undefined) => void;
 
 export declare interface WorkbenchFocusController {
@@ -1859,10 +1715,7 @@ declare interface WorkbenchFocusState {
     activeRegion: WorkbenchFocusRegionId | undefined;
 }
 
-declare interface WorkbenchHistoryPersistence {
-    getHistory(scope?: string): PersistedWorkbenchHistory | undefined;
-    setHistory(state: PersistedWorkbenchHistory, scope?: string): void;
-}
+export declare type WorkbenchHierarchyNode = ResourceRef | WorkbenchViewHierarchyNode;
 
 export declare interface WorkbenchHost {
     getSnapshot(): WorkbenchSnapshot;
@@ -1873,18 +1726,12 @@ export declare interface WorkbenchHost {
     getPersistenceScope(): string | undefined;
 }
 
-declare interface WorkbenchLastResourceController {
-    get(): ResourceRef | undefined;
-    set(resource: ResourceRef | undefined): void;
-    restore(): Promise<boolean>;
-}
-
 export declare interface WorkbenchLayout {
     regions: Record<WorkbenchRegion, WorkbenchRegionState>;
     locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion, string>>>;
     activeWidgetId?: string;
     activeLocationWidgetId?: string;
-    activeResourceUri?: string;
+    activeResourceKey?: string;
 }
 
 declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
@@ -1895,22 +1742,15 @@ declare interface WorkbenchLayoutStoreState {
     placeholders: Partial<Record<WorkbenchRegion, RegisteredPlaceholderContribution>>;
 }
 
-declare type WorkbenchLocationContribution = WidgetContribution & WorkbenchPanelMenusContribution;
-
-export declare interface WorkbenchLocationEligibility {
+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;
+    canOpenLocation?(location: {
+        resource?: ResourceRef;
+        viewId?: string;
+    }): boolean;
 }
 
 export declare type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
@@ -1934,7 +1774,12 @@ declare type WorkbenchModeChangeListener = () => void;
 export declare interface WorkbenchModeContribution {
     id: string;
     label?: string;
+    defaultTheme?: string;
+    floatingPanels?: "visible" | "hidden";
+    chrome?: Partial<Record<"nav" | "sidenav" | "activity" | "status", string | false>>;
     panels?: readonly WorkbenchPanelRegion[];
+    /** Region-level layout policy while this mode is active. */
+    regionSettings?: Partial<Record<WorkbenchRegion, WorkbenchRegionSettings>>;
     resourceKinds?: readonly string[];
     defaultResource?: ResourceRef | (() => Promise<ResourceRef | undefined> | ResourceRef | undefined);
     listAddablePanels?(context: WorkbenchModeAddablePanelContext): readonly WorkbenchModeAddablePanel[];
@@ -1944,6 +1789,31 @@ export declare interface WorkbenchModeContribution {
     reconcile?(ctx: WorkbenchModeActivationContext): void;
 }
 
+export declare interface WorkbenchModePlacementContribution extends WorkbenchPlacementPresentation {
+    readonly id: string;
+    readonly ref: PlacementRef;
+    readonly modeId: string;
+    readonly item: WorkbenchOwnedPlacementItem;
+    readonly region: DockedWorkbenchRegion;
+    readonly order?: number;
+    readonly movableTo?: readonly DockedWorkbenchRegion[];
+}
+
+export declare interface WorkbenchModePlacementRegistry {
+    registerPlacement(placement: WorkbenchModePlacementContribution): Disposable_2;
+    getPlacement(ref: PlacementRef): WorkbenchModePlacementContribution | undefined;
+    listPlacements(modeId?: string): WorkbenchModePlacementContribution[];
+    openPlacement(input: OpenModePlacementTarget): PlacementIdentity;
+    updatePlacement(identity: PlacementIdentity, input: {
+        resource?: ResourceRef;
+        title?: string;
+        open?: PageOpenIntent;
+    }): void;
+    closePlacement(identity: PlacementIdentity): void;
+    resolvePlacements(modeId: string, context?: OwnedPlacementLocationContext): readonly ResolvedOwnedPlacement<WorkbenchWidgetPlacement>[];
+    onDidChange(listener: () => void): Disposable_2;
+}
+
 export declare interface WorkbenchModeRegistry {
     store: WorkbenchStore<WorkbenchModeStoreState>;
     dispose(): void;
@@ -1977,74 +1847,7 @@ export declare interface WorkbenchModuleContribution {
 
 export declare type WorkbenchModuleContributionContext = WorkbenchModuleContext;
 
-declare interface WorkbenchNavigationCommit {
-    modeId: string | undefined;
-    resource: ResourceRef | undefined;
-    replaceActive: boolean;
-}
-
-declare type WorkbenchNavigationDiagnosticCode = "navigation_mode_missing" | "navigation_resource_missing" | "navigation_resource_incompatible" | "navigation_default_missing" | "navigation_target_stale";
-
-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 type WorkbenchNavigationResult = {
-    ok: true;
-    modeId: string | undefined;
-    resource: ResourceRef | undefined;
-} | {
-    ok: false;
-    code: WorkbenchNavigationDiagnosticCode;
-    message: string;
-};
-
-declare interface WorkbenchNavigationTarget {
-    modeId?: string;
-    resource?: ResourceRef;
-    replaceActive?: boolean;
-}
-
-declare interface WorkbenchNavigator {
-    configure(hooks: WorkbenchNavigatorHostHooks): void;
-    getSelectedResource(): ResourceRef | undefined;
-    open(target: WorkbenchNavigationTarget): Promise<WorkbenchNavigationResult>;
-    commitContext(input: WorkbenchNavigatorCommitInput): WorkbenchNavigationResult;
-    getLastResource(projectId: string | undefined, modeId: string): ResourceRef | undefined;
-    forgetResource(uri: string): void;
-    onDidCommit(listener: (commit: WorkbenchNavigationCommit) => void): {
-        dispose(): void;
-    };
-}
-
-declare interface WorkbenchNavigatorCommitInput {
-    modeId?: string | null;
-    resource?: ResourceRef | null;
-    replaceActive?: boolean;
-    present?: boolean;
-}
-
-declare interface WorkbenchNavigatorHostHooks {
-    getProjectId?(): string | undefined;
-    getSelectedResource?(): ResourceRef | undefined;
-    interpretSelection?(resource: ResourceRef): ResourceRef | undefined;
-    applySelection?(resource: ResourceRef | undefined): void;
-    applyScope?(commit: WorkbenchNavigationCommit): void;
-    applyBreadcrumb?(resource: ResourceRef | undefined): void;
-    presentResource?(resource: ResourceRef, input: {
-        replaceActive: boolean;
-    }): Promise<unknown> | unknown;
-}
+declare type WorkbenchModuleLayoutModel = Omit<WorkbenchLayoutModel, "registerPanel" | "registerWidget" | "openPanel" | "openWidget" | "registerPlaceholder" | "registerPanelMenu">;
 
 export declare interface WorkbenchNotification {
     id?: string;
@@ -2080,7 +1883,162 @@ declare interface WorkbenchNotificationStoreState {
     notifications: Record<string, RegisteredWorkbenchNotification>;
 }
 
-export declare interface WorkbenchPanelContribution {
+export declare interface WorkbenchOverlayContribution extends Omit<WorkbenchPlacementPresentation, "mountStrategy"> {
+    id: string;
+    viewId: string;
+    closable?: boolean;
+}
+
+export declare interface WorkbenchOverlayRegistry {
+    registerOverlay(overlay: WorkbenchOverlayContribution): Disposable_2;
+    getOverlay(id: string): WorkbenchOverlayContribution | undefined;
+    listOverlays(): WorkbenchOverlayContribution[];
+    openOverlay(id: string, input?: OpenWorkbenchOverlayInput): string;
+    closeOverlay(instanceId: string): void;
+}
+
+declare type WorkbenchOwnedPlacementItem = PlacementItem;
+
+export declare interface WorkbenchPageBrowserEntry {
+    url: string;
+    state?: unknown;
+}
+
+declare interface WorkbenchPageContribution {
+    id: string;
+    ref: PageRef;
+    title?: Localizable<string>;
+    icon?: string;
+    path: string;
+    modeId: string;
+    parentId?: string;
+    resource?: ResourceConstraint;
+    main: WorkbenchPageMain;
+    slots: readonly WorkbenchPageSlot[];
+}
+
+export declare interface WorkbenchPageLocationBrowser {
+    current(): WorkbenchPageBrowserEntry;
+    push(entry: WorkbenchPageBrowserEntry): void;
+    replace(entry: WorkbenchPageBrowserEntry): void;
+    back(): void;
+    forward(): void;
+    onPopState(listener: (entry: WorkbenchPageBrowserEntry) => void): {
+        dispose(): void;
+    };
+}
+
+export declare interface WorkbenchPageLocationController {
+    historyStore: WorkbenchStore<WorkbenchPageLocationHistoryState>;
+    setProject(projectId: string): void;
+    clearProject(): void;
+    isCurrentProjectUrl(projectId: string): boolean;
+    hasCurrentPageUrl(projectId: string): boolean;
+    boot(projectId: string): WorkbenchPageNavigationResult;
+    switchProject(projectId: string): WorkbenchPageNavigationResult;
+    navigate(target: NavigationTargetPage_2): WorkbenchPageNavigationResult;
+    replay(location: PageLocation): WorkbenchPageNavigationResult;
+    navigateToParent(): WorkbenchPageNavigationResult;
+    closePlacement(identity: PlacementIdentity): WorkbenchPageNavigationResult;
+    goBack(): void;
+    goForward(): void;
+    dispose(): void;
+}
+
+export declare interface WorkbenchPageLocationDiagnostic {
+    code: "page-location-unresolved";
+    source: "boot" | "history" | "navigation" | "project-switch";
+    message: string;
+}
+
+declare interface WorkbenchPageLocationHistoryState {
+    canGoBack: boolean;
+    canGoForward: boolean;
+}
+
+export declare interface WorkbenchPageLocationPersistence {
+    load(projectId: string): PageLocation | undefined;
+    save(projectId: string, location: PageLocation): void;
+}
+
+declare type WorkbenchPageMain = PageMain extends infer Main ? Main extends PageMain ? Omit<Main, "tab"> & {
+    readonly tab?: WorkbenchPlacementPresentation["tab"];
+} : never : never;
+
+export declare type WorkbenchPageNavigationResult = {
+    ok: true;
+    location: PageLocation;
+} | {
+    ok: false;
+    diagnostic: WorkbenchPageLocationDiagnostic;
+};
+
+export declare interface WorkbenchPagePersistenceScope {
+    scope?: string;
+    carryRegions?: readonly WorkbenchRegion[];
+}
+
+export declare interface WorkbenchPagePersistenceScopeInput {
+    currentScope?: string;
+    modeId?: string;
+    pageId?: string;
+    projectId?: string;
+    resource?: ResourceRef;
+}
+
+declare interface WorkbenchPageRegistry<Value> {
+    store: WorkbenchStore<WorkbenchPageRegistryStoreState<Value>>;
+    registerPage(page: WorkbenchPageContribution): {
+        dispose(): void;
+    };
+    getPage(pageId: string): WorkbenchPageContribution | undefined;
+    listPages(): WorkbenchPageContribution[];
+    pinPlacement(identity: PlacementIdentity): void;
+    openSlot(input: WorkbenchPageSlotOpenInput): void;
+}
+
+declare interface WorkbenchPageRegistryStoreState<Value> {
+    pages: Readonly<Record<string, WorkbenchPageContribution>>;
+    pageStates: Readonly<Record<string, WorkbenchPageRuntimeState>>;
+    projectId?: string;
+    location?: PageLocation;
+    activeModeId?: string;
+    activePageId?: string;
+    placements: readonly ResolvedOwnedPlacement<Value>[];
+    reconciliation: OwnedPlacementReconciliation<Value>;
+}
+
+declare interface WorkbenchPageResourceCodec {
+    normalize(resource: ResourceRef): ResourceRef;
+    toUri(resource: ResourceRef): string;
+    fromUri(uri: string): ResourceRef | undefined;
+}
+
+declare interface WorkbenchPageRuntimeState {
+    openStaticSlotIds: readonly string[];
+    resourceInstances: Readonly<Record<string, readonly WorkbenchPageSlotInstance[]>>;
+    activePrimaryInstanceKey?: string;
+}
+
+declare interface WorkbenchPageSlot extends Omit<PageSlot, "tab"> {
+    readonly tab?: WorkbenchPlacementPresentation["tab"];
+}
+
+declare interface WorkbenchPageSlotInstance {
+    instanceKey: string;
+    resource: ResourceRef;
+    section?: FileRendererSectionTarget;
+    open?: PageOpenIntent;
+}
+
+declare interface WorkbenchPageSlotOpenInput {
+    pageId: string;
+    slotId: string;
+    resource?: ResourceRef;
+    open?: PageOpenIntent;
+}
+
+declare interface WorkbenchPanelContribution {
     id: string;
     title: string;
     icon?: string;
@@ -2090,16 +2048,15 @@ export declare interface WorkbenchPanelContribution {
     singleton?: boolean;
     reuse?: WorkbenchPanelReusePolicy;
     mountStrategy?: WorkbenchPanelMountStrategy;
+    closable?: boolean;
     hiddenByDefault?: boolean;
-    subPanelsOnly?: boolean;
     regionSize?: WorkbenchRegionSize;
     regionCollapsible?: boolean;
     headerBorderBottom?: boolean;
-    floatingPanels?: WorkbenchFloatingPanelVisibility;
     resourceKinds?: string[];
     eligibleLocations?: WorkbenchLocationEligibility;
     priority?: number;
-    openCommandId?: string;
+    openCommand?: WorkbenchCommandTarget;
     tab?: WorkbenchPanelTab;
     config?: unknown;
     canOpen?(resource: ResourceRef): boolean;
@@ -2111,11 +2068,14 @@ export declare interface WorkbenchPanelContribution {
 export declare interface WorkbenchPanelInstance {
     instanceId: string;
     panelId: string;
+    placementIdentity?: PlacementIdentity;
+    viewId?: string;
     ownerId?: string;
     source?: ContributionSource;
     resource?: ResourceRef;
-    resourceUri?: string;
-    ownerResourceUri?: string;
+    section?: FileRendererSectionTarget;
+    resourceKey?: string;
+    ownerResourceKey?: string;
     title?: string;
     pinned?: boolean;
     closable: boolean;
@@ -2130,7 +2090,7 @@ declare type WorkbenchPanelMenuContribution = Omit<WidgetContribution, "region"
     fallbackRegion?: WorkbenchPanelMenuRegion;
 };
 
-export declare interface WorkbenchPanelMenuDefinition {
+declare interface WorkbenchPanelMenuDefinition {
     id: string;
     title: string;
     icon?: string;
@@ -2172,15 +2132,32 @@ declare const workbenchPanelMenuRegions: {
     };
 };
 
-declare interface WorkbenchPanelMenusContribution {
-    panelMenus?: readonly WorkbenchPanelMenuDefinition[];
+export declare type WorkbenchPanelMenuSide = "left" | "right";
+
+declare interface WorkbenchPanelMenuState {
+    openByMenuId: Record<string, boolean>;
 }
 
-export declare type WorkbenchPanelMenuSide = "left" | "right";
+declare type WorkbenchPanelMenuStateChangeListener = (state: WorkbenchPanelMenuState) => void;
+
+declare interface WorkbenchPanelMenuStateController {
+    store: WorkbenchStore<WorkbenchPanelMenuState>;
+    isOpen(menuId: string): boolean;
+    setOpen(menuId: string, open: boolean): void;
+    toggle(menuId: string): void;
+    setPersistenceScope(scope: string | undefined): void;
+    getPersistenceScope(): string | undefined;
+    onDidChange(listener: WorkbenchPanelMenuStateChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchPanelMenuStatePersistenceAdapter {
+    getMenuStates(scope?: string): PersistedWorkbenchPanelMenuState | undefined;
+    setMenuStates(state: PersistedWorkbenchPanelMenuState, scope?: string): void;
+}
 
 export declare type WorkbenchPanelMountStrategy = WidgetMountStrategy;
 
-export declare type WorkbenchPanelOpenStrategy = {
+declare type WorkbenchPanelOpenStrategy = {
     kind: "persistent";
     position?: WorkbenchTabPosition;
 } | {
@@ -2205,41 +2182,50 @@ export declare interface WorkbenchPanelRenderInput {
     refresh: () => void;
 }
 
-export declare type WorkbenchPanelReusePolicy = WidgetReusePolicy;
+declare type WorkbenchPanelReusePolicy = WidgetReusePolicy;
 
-declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
+export declare type WorkbenchPanelTab = WorkbenchWidgetTab;
 
-declare interface WorkbenchPanelsController {
-    store: WorkbenchStore<WorkbenchPanelsState>;
-    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 WorkbenchPersistenceAdapter {
+    getSnapshot(scope?: string): WorkbenchSnapshot | undefined;
+    setSnapshot(snapshot: WorkbenchSnapshot, scope?: string): void;
+    flush?(): void;
+    dispose?(): void;
 }
 
-declare interface WorkbenchPanelsPersistenceAdapter {
-    getPanelStates(scope?: string): PersistedWorkbenchPanels | undefined;
-    setPanelStates(state: PersistedWorkbenchPanels, scope?: string): void;
+export declare interface WorkbenchPlaceholderContribution {
+    id: string;
+    viewId: string;
+    title?: string;
+    region: WorkbenchRegion;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
+    config?: unknown;
 }
 
-declare interface WorkbenchPanelsState {
-    openByRegionId: Record<string, boolean>;
+export declare interface WorkbenchPlaceholderRegistry {
+    registerPlaceholder(placeholder: WorkbenchPlaceholderContribution, metadata?: ContributionMetadata): Disposable_2;
 }
 
-export declare type WorkbenchPanelTab = WorkbenchWidgetTab;
+export declare interface WorkbenchPlacementPresentation {
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+    headerBorderBottom?: boolean;
+    tab?: WorkbenchPanelTab;
+    config?: unknown;
+}
 
-export declare interface WorkbenchPersistenceAdapter {
-    getSnapshot(scope?: string): WorkbenchSnapshot | undefined;
-    setSnapshot(snapshot: WorkbenchSnapshot, scope?: string): void;
-    flush?(): void;
-    dispose?(): void;
+export declare interface WorkbenchReactViewBody {
+    kind: "react";
+    render: WorkbenchRendererRegistration["render"];
 }
 
 export declare type WorkbenchRegion = (typeof workbenchRegions)[number];
 
-export 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 const workbenchRegions: readonly ["nav", "activity", "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"];
+
+/** Region-level layout policy owned by the active mode or the host, never by a placement. */
+declare type WorkbenchRegionSettings = ModeRegionSettings;
 
 export declare interface WorkbenchRegionSize {
     defaultPx?: number;
@@ -2259,44 +2245,18 @@ export declare const workbenchRegionTabAddMenuPath: (region: string) => MenuPath
 
 export declare const workbenchRegionTabLeadingMenuPath: (region: string) => MenuPath;
 
-declare type WorkbenchRendererChangeListener = () => void;
-
-export declare type WorkbenchRendererRegistration = {
+declare interface WorkbenchRendererRegistration {
     id: string;
-    keepAlive?: false;
     render: (input: WorkbenchPanelRenderInput) => unknown;
-} | {
-    id: string;
-    keepAlive: true;
-    render: () => unknown;
-};
-
-export declare interface WorkbenchRendererRegistry {
-    store: WorkbenchStore<WorkbenchRendererStoreState>;
-    registerRenderer(renderer: WorkbenchRendererRegistration): Disposable_2;
-    getRenderer(id: string): WorkbenchRendererRegistration | undefined;
-    listRenderers(): WorkbenchRendererRegistration[];
-    onDidChange(listener: WorkbenchRendererChangeListener): Disposable_2;
-    claim(rendererId: string, slot: HTMLElement, input: WorkbenchPanelRenderInput): Disposable_2;
-    getHost(rendererId: string): HTMLElement | undefined;
-    getClaim(rendererId: string): WorkbenchPanelRenderInput | undefined;
-}
-
-declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & KanbanRendererRegistry & DataTableRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
-
-declare interface WorkbenchRendererStoreState {
-    renderers: Record<string, WorkbenchRendererRegistration>;
-    hosts: Record<string, RegisteredKeepAliveHost>;
-    claims: Record<string, WorkbenchPanelRenderInput>;
 }
 
 export declare const workbenchResourceIdContextKey = "workbench.resource.id";
 
-export declare const workbenchResourceKindContextKey = "workbench.resource.kind";
-
 export declare const workbenchResourceMetadataContextKey: (key: string) => string;
 
-export declare const workbenchSelectionResourceUriMetadataKey = "workbench.selectionResourceUri";
+export declare const workbenchResourceTypeContextKey = "workbench.resource.type";
+
+export declare const workbenchSelectionResourceKeyMetadataKey = "workbench.selectionResourceKey";
 
 export declare interface WorkbenchShellController {
     getRegionState(region: WorkbenchRegion): WorkbenchShellRegionState;
@@ -2307,7 +2267,29 @@ export declare interface WorkbenchShellController {
     onDidChange(listener: () => void): Disposable_2;
 }
 
-export declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | WorkbenchPanelMenuRegion;
+export declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | "side";
+
+export declare interface WorkbenchShellPlacementContribution extends WorkbenchPlacementPresentation {
+    readonly id: string;
+    readonly item: WorkbenchOwnedPlacementItem;
+    readonly region: WorkbenchRegion;
+    readonly order?: number;
+}
+
+export declare interface WorkbenchShellPlacementRegistry {
+    registerPlacement(placement: WorkbenchShellPlacementContribution): Disposable_2;
+    getPlacement(placementId: string): WorkbenchShellPlacementContribution | undefined;
+    listPlacements(): WorkbenchShellPlacementContribution[];
+    openPlacement(input: OpenWorkbenchShellPlacementInput): PlacementIdentity;
+    updatePlacement(identity: PlacementIdentity, input: {
+        resource?: ResourceRef;
+        title?: string;
+        open?: PageOpenIntent;
+    }): void;
+    closePlacement(identity: PlacementIdentity): void;
+    resolvePlacements(context?: OwnedPlacementLocationContext): readonly ResolvedOwnedPlacement<WorkbenchWidgetPlacement>[];
+    onDidChange(listener: () => void): Disposable_2;
+}
 
 export declare interface WorkbenchShellRegionState {
     open: boolean;
@@ -2317,6 +2299,7 @@ export declare interface WorkbenchShellRegionState {
 declare type WorkbenchSidePanelChangeListener = (mode: WorkbenchSidePanelMode) => void;
 
 declare interface WorkbenchSidePanelController {
+    canFloat(): boolean;
     store: WorkbenchStore<WorkbenchSidePanelState>;
     getMode(): WorkbenchSidePanelMode;
     setMode(mode: WorkbenchSidePanelMode): void;
@@ -2340,6 +2323,52 @@ export declare interface WorkbenchSnapshot {
     layout: WorkbenchLayout;
 }
 
+export declare interface WorkbenchStatusBarItem {
+    id: string;
+    viewId: string;
+    slot: WorkbenchStatusBarSlot;
+    order?: number;
+    isVisible?(): boolean;
+}
+
+export declare interface WorkbenchStatusBarRegistry {
+    store: WorkbenchStore<WorkbenchStatusBarRegistryState>;
+    registerItem(item: WorkbenchStatusBarItem): Disposable_2;
+    getItem(id: string): WorkbenchStatusBarItem | undefined;
+    listItems(): WorkbenchStatusBarItem[];
+    listVisibleItems(slot?: WorkbenchStatusBarSlot): WorkbenchStatusBarItem[];
+}
+
+export declare interface WorkbenchStatusBarRegistryState {
+    items: Record<string, WorkbenchStatusBarItem>;
+}
+
+export declare type WorkbenchStatusBarSlot = "leading" | "trailing";
+
+export declare interface WorkbenchStatusRegistry {
+    store: WorkbenchStore<WorkbenchStatusRegistryState>;
+    registerStatusSet(contribution: WorkbenchStatusSetContribution, metadata?: ContributionMetadata): Disposable_2;
+    getStatusSet(id: string): RegisteredWorkbenchStatusSet | undefined;
+    listStatusSets(): RegisteredWorkbenchStatusSet[];
+    getStatuses(id: string): readonly WorkflowStatus[] | undefined;
+    load(id: string): Promise<readonly WorkflowStatus[]>;
+    query(id: string): Promise<readonly WorkflowStatus[]>;
+    save(id: string, statuses: readonly WorkflowStatus[]): Promise<readonly WorkflowStatus[]>;
+}
+
+export declare interface WorkbenchStatusRegistryState {
+    statusSets: Record<string, RegisteredWorkbenchStatusSet>;
+    values: Record<string, readonly WorkflowStatus[]>;
+}
+
+export declare interface WorkbenchStatusSetContribution {
+    id: string;
+    title: string;
+    actions?: readonly WorkflowStatusAction[];
+    query(): Promise<readonly WorkflowStatus[]> | readonly WorkflowStatus[];
+    save?(statuses: readonly WorkflowStatus[]): Promise<readonly WorkflowStatus[]> | readonly WorkflowStatus[];
+}
+
 declare interface WorkbenchStore<TState> {
     getState(): TState;
     getInitialState(): TState;
@@ -2356,18 +2385,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"> & {
-    region: WorkbenchPanelRegion;
-    fallbackRegion?: WorkbenchPanelRegion;
-} & WorkbenchPanelMenusContribution;
+export declare type WorkbenchTabAction = ({
+    kind: "command";
+} & WorkbenchCommandTarget) | {
+    kind: "navigation";
+    target: NavigationTarget;
+};
 
-declare interface WorkbenchSubPanelRef {
-    contributionId: string;
-    resourceUri?: string;
-    instanceKey?: string;
+export declare interface WorkbenchTabMenuGroup {
+    id: string;
+    rows: readonly WorkbenchTabMenuRow[];
 }
 
-export declare const workbenchSwitchModeCommandId = "workbench.action.switchMode";
+export declare interface WorkbenchTabMenuRow {
+    id: string;
+    label: string;
+    icon?: string;
+    iconColor?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    action?: WorkbenchTabAction;
+}
 
 export declare type WorkbenchTabPosition = "start" | "end" | {
     beforeWidgetId: string;
@@ -2377,6 +2415,17 @@ export declare type WorkbenchTabPosition = "start" | "end" | {
 
 export declare type WorkbenchTabRetention = "preview" | "persistent";
 
+export declare interface WorkbenchTabSnapshot {
+    label?: string;
+    icon?: string;
+    indicator?: {
+        icon: string;
+        color?: string;
+        label?: string;
+    };
+    menu?: readonly WorkbenchTabMenuGroup[];
+}
+
 export declare interface WorkbenchTerminalController {
     store: WorkbenchStore<WorkbenchTerminalState>;
     /** True once the host injected a session opener. */
@@ -2384,6 +2433,7 @@ export declare interface WorkbenchTerminalController {
     setSessionOpener(opener: WorkbenchTerminalSessionOpener | null): void;
     /** Opens a session; the live adapter stays host-side and only the id is returned. */
     open(input: {
+        bindingId?: string;
         request: WorkbenchTerminalSessionRequest;
         title?: string;
     }): Promise<{
@@ -2402,6 +2452,7 @@ export declare interface WorkbenchTerminalController {
         sessionId: string;
         signal?: string;
     }): Promise<void>;
+    killBinding(bindingId: string): Promise<void>;
     subscribe(sessionId: string, sink: WorkbenchTerminalSessionSink): () => void;
     getSession(sessionId: string): WorkbenchTerminalSessionModel | undefined;
     listSessions(): WorkbenchTerminalSessionModel[];
@@ -2467,14 +2518,70 @@ export declare const workbenchTopHeaderLeadingMenuPath: MenuPath;
 
 export declare const workbenchTopHeaderTrailingMenuPath: MenuPath;
 
+declare type WorkbenchTreeViews = Pick<TreeRendererRegistry, "getTreeState" | "setNodeExpanded" | "setSectionExpanded" | "setSelectedNode">;
+
+export declare type WorkbenchViewBody = WorkbenchReactViewBody | NativeViewBody<"tree", TreeRendererContribution> | NativeViewBody<"file", FileRendererContribution> | NativeViewBody<"controls", ControlsRendererContribution> | NativeViewBody<"kanban", KanbanRendererContribution> | NativeViewBody<"dataTable", DataTableRendererContribution>;
+
+export declare interface WorkbenchViewContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    body: WorkbenchViewBody;
+}
+
+export declare interface WorkbenchViewHierarchyNode {
+    type: "view";
+    viewId: string;
+    label?: string;
+    icon?: string;
+}
+
+export declare const workbenchViewIdContextKey = "workbench.view.id";
+
+export declare interface WorkbenchViewMenuContribution {
+    id: string;
+    ownerViewId: string;
+    viewId: string;
+    side: "left" | "right";
+    priority?: number;
+    mountStrategy?: "active" | "keep-mounted";
+    hiddenByDefault?: boolean;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
+    headerBorderBottom?: boolean;
+    config?: unknown;
+}
+
+export declare interface WorkbenchViewMenuRegistry {
+    registerViewMenu(menu: WorkbenchViewMenuContribution): Disposable_2;
+    getViewMenu(id: string): WorkbenchViewMenuContribution | undefined;
+    listViewMenus(ownerViewId?: string): WorkbenchViewMenuContribution[];
+    definitionsFor(ownerViewId: string, placementId: string): readonly WorkbenchPanelMenuDefinition[];
+}
+
+export declare interface WorkbenchViewRegistry {
+    store: WorkbenchStore<WorkbenchViewRegistryStoreState>;
+    registerView(view: WorkbenchViewContribution, metadata?: ContributionMetadata): Disposable_2;
+    getView(viewId: string): RegisteredWorkbenchView | undefined;
+    listViews(): RegisteredWorkbenchView[];
+    refreshView(viewId: string, input?: unknown): void;
+}
+
+export declare interface WorkbenchViewRegistryStoreState {
+    views: Record<string, RegisteredWorkbenchView>;
+}
+
 export declare interface WorkbenchWidgetPlacement {
     widgetId: string;
     contributionId: string;
+    placementIdentity?: PlacementIdentity;
+    viewId?: string;
     ownerId?: string;
     source?: ContributionSource;
     resource?: ResourceRef;
-    resourceUri?: string;
-    ownerResourceUri?: string;
+    section?: FileRendererSectionTarget;
+    resourceKey?: string;
+    ownerResourceKey?: string;
     title?: string;
     pinned?: boolean;
     closable?: boolean;
@@ -2487,10 +2594,28 @@ export declare interface WorkbenchWidgetPlacement {
 
 declare type WorkbenchWidgetRole = "content" | "location" | "sub-panel" | "panel-menu";
 
-declare interface WorkbenchWidgetTab {
-    contentRendererId?: string;
-    /** Custom actions shown when the user activates an already-active tab. */
-    customMenuRendererId?: string;
+export declare interface WorkbenchWidgetTab {
+    getSnapshot(instance: WorkbenchPanelInstance): WorkbenchTabSnapshot;
+    subscribe?(listener: () => void): {
+        dispose(): void;
+    } | (() => void);
+    refreshEvents?: readonly string[];
+}
+
+export declare interface WorkflowStatus {
+    id: string;
+    label: string;
+    color: string;
+    icon?: string | null;
+    sortOrder: number;
+    isDefault?: boolean;
+    actions?: readonly string[];
+}
+
+export declare interface WorkflowStatusAction {
+    id: string;
+    label: string;
+    icon?: string;
 }
 
 export { }