@pstdio/workbench 0.7.1 → 0.9.0

package/dist/extensions.d.ts

@@ -1,22 +1,37 @@
 import { CommandExecuteRequest } from '@pstdio/sdk/api';
 import { CommandExecuteResponse } from '@pstdio/sdk/api';
 import { ComponentType } 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 { ExtensionCommandPaletteContribution } from '@pstdio/sdk/api';
 import { ExtensionMenuContribution } from '@pstdio/sdk/api';
-import { HostCapability } from 'pstdio-extensions/bridge/contract';
-import { HostCapabilityRegistry } from 'pstdio-extensions/bridge/contract';
-import { HostEventPublisher } from 'pstdio-extensions/bridge/host';
+import { FileRendererSectionTarget } from '@pstdio/sdk/extensions';
 import { JSX } from 'react/jsx-runtime';
+import { KanbanRendererAttributeDisplay } from '@pstdio/sdk/extensions';
 import { Localizable } from '@pstdio/sdk/extensions';
+import { ModeRegionSettings } from '@pstdio/sdk/extensions';
+import { NavigationTarget as NavigationTarget_2 } 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 { ReactNode } from 'react';
-import { ThemePreference as ThemePreference_2 } from 'pstdio-extensions/bridge/contract';
+import { ResourceConstraint } from '@pstdio/sdk/extensions';
+import { ResourceRef } from '@pstdio/sdk/extensions';
+import { WebviewHostCapability } from '@pstdio/sdk/extensions';
 import { WorkbenchExtensionCommandPaletteResourceRecord } from '@pstdio/sdk/api';
-import { WorkbenchExtensionControlsRendererRecord } from '@pstdio/sdk/api';
-import { WorkbenchExtensionDataTableRendererRecord } from 'pstdio-api-contracts';
-import { WorkbenchExtensionKanbanRendererRecord } from '@pstdio/sdk/api';
 import { WorkbenchExtensionMetadata } from '@pstdio/sdk/api';
+import { z } from 'zod';
 
-declare interface AttributeDescriptor {
+declare interface AttributeDescriptor<TNode = unknown> {
     id: string;
     label: string;
     type: AttributeType;
@@ -26,22 +41,19 @@ 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;
 }
 
-declare type AttributeDisplayDescriptor = {
-    kind: "workspace-badge";
-    itemsAttributeId: string;
-};
+declare type AttributeDisplayDescriptor = KanbanRendererAttributeDisplay;
 
 /**
  * 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>[];
 }
 
 declare type AttributeType = {
@@ -60,26 +72,22 @@ declare type AttributeType = {
     kind: "user";
 };
 
-declare interface BoardColumnAction {
+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. */
-declare interface BoardColumnConfig {
+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>[];
 }
 
-export declare const BRIDGE_WEBVIEW_RENDERER_ID = "webview:bridge";
-
 export declare interface BridgeWebviewConfig {
     title?: string;
     runtimeUrl: string;
@@ -97,24 +105,22 @@ export declare interface BridgeWebviewRenderContext {
 }
 
 export declare const buildWorkbenchExtensionCommandPaletteRegistrations: (input: {
-    metadata: WorkbenchExtensionMetadata;
+    metadata: CommandContributionMetadata;
     createCommandId?: (contribution: ExtensionCommandPaletteContribution) => string;
     resolveString?: WorkbenchExtensionStringResolver;
 }) => WorkbenchExtensionCommandPaletteRegistration[];
 
 export declare const buildWorkbenchExtensionMenuRegistrations: (input: {
-    metadata: WorkbenchExtensionMetadata;
+    metadata: CommandContributionMetadata;
     menuSlotsById: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
     menuTargetsById?: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
     createCommandId?: (contribution: ExtensionMenuContribution) => string;
     createWhenExpression?: WorkbenchExtensionMenuWhenBuilder;
     resolveString?: WorkbenchExtensionStringResolver;
-}) => WorkbenchExtensionMenuRegistration[];
-
-export declare const buildWorkbenchExtensionRouteEntries: (input: {
-    metadata: WorkbenchExtensionMetadata | undefined;
-    createResource: (resourceInput: WorkbenchExtensionRouteResourceInput) => ResourceRef;
-}) => any;
+}) => {
+    registrations: WorkbenchExtensionMenuRegistration[];
+    unresolved: UnresolvedWorkbenchExtensionMenuContribution[];
+};
 
 /**
  * A data-driven list of items, each opening a contributor-supplied editor. The
@@ -122,12 +128,12 @@ export declare const buildWorkbenchExtensionRouteEntries: (input: {
  */
 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[];
 }
 
@@ -141,6 +147,8 @@ declare interface Command {
     params?: CommandParamSchema;
 }
 
+declare type CommandContributionMetadata = Pick<WorkbenchExtensionMetadata, "commands" | "commandPaletteContributions" | "menuContributions">;
+
 declare interface CommandHandler<TArgs = unknown, TResult = unknown> {
     prepareArgs?(args: TArgs, context?: WorkbenchCommandExecutionContext, onArgsChange?: (args: TArgs) => void): TArgs | Promise<TArgs>;
     execute(args: TArgs, context?: WorkbenchCommandExecutionContext): TResult | Promise<TResult>;
@@ -202,6 +210,7 @@ declare interface CommandParamDescriptor {
     accept?: string;
     multiple?: boolean;
     metadata?: Record<string, unknown>;
+    resolvedFrom?: "resource";
 }
 
 declare interface CommandParamOption {
@@ -229,72 +238,6 @@ declare interface CommandRegistryStoreState {
     commands: Record<string, RegisteredCommand>;
 }
 
-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;
-}
-
-declare interface CompositionModeDefinition {
-    id: string;
-    extensionId?: string;
-    resources?: Record<string, CompositionModeRecipe>;
-    modePanels?: Record<string, CompositionPlacementPolicy>;
-}
-
-declare interface CompositionModeRecipe {
-    slots?: Record<string, CompositionPlacementPolicy>;
-    panels?: Record<string, CompositionPlacementPolicy>;
-}
-
-declare interface CompositionPanelDefinition {
-    id: string;
-    extensionId: string;
-    title: string;
-    icon?: string;
-    show?: CompositionPanelPlacement | readonly CompositionPanelPlacement[];
-}
-
-declare interface CompositionPanelPlacement extends CompositionPlacementPolicy {
-    resourceKind?: string;
-}
-
-declare interface CompositionPlacementPolicy {
-    region: DockedCompositionRegion;
-    allowedRegions?: readonly DockedCompositionRegion[];
-    required?: boolean;
-    defaultOpen?: boolean;
-    pinned?: boolean;
-}
-
-declare interface CompositionReconcileContext {
-    layout: LayoutModel;
-    notifications: NotificationRegistry;
-}
-
-export declare const compositionRequiredNotificationId: (modeId: string) => string;
-
-declare interface CompositionResourceKindDefinition {
-    id: string;
-    extensionId: string;
-    surface: "primary" | "secondary" | "attached";
-    slots: Record<string, CompositionSlotDefinition>;
-}
-
-declare interface CompositionResourcePanelEdge {
-    id: string;
-    extensionId: string;
-    resourceKind: string;
-    panel: string;
-    slot: string;
-}
-
-declare interface CompositionSlotDefinition {
-    cardinality: "one" | "many";
-    external: boolean;
-}
-
 declare interface ContextKeyScope extends Disposable_2 {
     ownerId: string;
     set(key: string, value: ContextKeyValue): void;
@@ -327,20 +270,11 @@ declare interface ContributionMetadata {
 
 declare type ContributionSource = "module" | "extension";
 
-declare type ContributionSource_2 = "module" | "extension";
-
 declare interface ControlsApplyInput {
-    values: Record<string, unknown>;
+    values: ControlValueMap;
     resource?: ResourceRef;
 }
 
-declare interface ControlsQueryResult {
-    params?: unknown[];
-    groups?: unknown[];
-    values?: Record<string, unknown>;
-    readOnly?: boolean;
-}
-
 declare interface ControlsRendererContribution {
     id: string;
     title: string;
@@ -348,7 +282,7 @@ 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. */
@@ -360,10 +294,6 @@ declare interface ControlsRendererContribution {
     subscribe?: (listener: () => void) => Disposable_2 | (() => void);
 }
 
-declare type ControlsRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    controlsRendererId: string;
-}) => unknown;
-
 declare interface ControlsRendererLayout {
     region?: ControlsRendererRegion;
     defaultPx?: number;
@@ -371,28 +301,8 @@ declare interface ControlsRendererLayout {
     maxPx?: number;
 }
 
-declare interface ControlsRendererRefreshEvent {
-    controlsRendererId: string;
-}
-
-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;
-    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>;
-}
-
 declare interface ControlsResetInput {
     controlIds?: string[];
     resource?: ResourceRef;
@@ -400,28 +310,15 @@ declare interface ControlsResetInput {
 
 declare interface ControlsUpdateValueInput {
     controlId: string;
-    value: unknown;
-    values: Record<string, unknown>;
+    value: ControlValue;
+    values: ControlValueMap;
     resource?: ResourceRef;
 }
 
-declare type ControlsViewRecord = WorkbenchExtensionMetadata["panels"][number];
-
 export declare type CreateBridgeWebviewHostCapabilities = (context: BridgeWebviewRenderContext) => HostCapabilityRegistry;
 
 export declare type CreateBridgeWebviewProps = (context: BridgeWebviewRenderContext) => unknown;
 
-export declare const createBridgeWebviewRenderer: (input?: CreateBridgeWebviewRendererInput) => {
-    id: string;
-    render: (renderInput: WorkbenchPanelRenderInput) => JSX.Element | null;
-};
-
-declare interface CreateBridgeWebviewRendererInput {
-    createHostCapabilities?: CreateBridgeWebviewHostCapabilities;
-    createProps?: CreateBridgeWebviewProps;
-    createTheme?: CreateBridgeWebviewTheme;
-}
-
 export declare type CreateBridgeWebviewTheme = (context: BridgeWebviewRenderContext) => ThemePreference_2;
 
 /**
@@ -437,12 +334,10 @@ declare interface CreateTerminalSessionCapabilityInput {
     hostEvents: HostEventPublisher;
 }
 
-export declare const createWorkbenchCompositionRegistry: () => WorkbenchCompositionRegistry;
-
 export declare const createWorkbenchWebviewHostCapabilities: (input: CreateWorkbenchWebviewHostCapabilitiesInput) => {
     "terminal.session"?: HostCapability | undefined;
     "commands.execute": (params: unknown) => Promise<unknown>;
-    "resource.open": (params: unknown) => Promise<WorkbenchPanelInstance_2>;
+    "navigation.open": (params: unknown) => Promise<readonly unknown[]>;
     "notification.show": (params: unknown) => RegisteredWorkbenchNotification;
     "preferences.get": (params: unknown) => PreferenceValue | undefined;
     "preferences.set": (params: unknown) => {
@@ -450,24 +345,17 @@ export declare const createWorkbenchWebviewHostCapabilities: (input: CreateWorkb
         value: PreferenceValue;
     };
     "host.dispatchKeyboardEvent": (params: unknown) => void;
+    "placement.close"?: ((params: unknown) => void) | undefined;
 };
 
 declare interface CreateWorkbenchWebviewHostCapabilitiesInput {
     dispatchKeyboardEvent?: (event: KeyboardEventInit) => void;
     workbench: WorkbenchCore;
+    placement?: WorkbenchPanelInstance;
     /** Event channel into the guest; terminal.session is only offered when present. */
     hostEvents?: HostEventPublisher;
 }
 
-/**
- * Renders its own page. `render` returns `unknown` so core stays React-free — the
- * React layer treats the result as a node, exactly like WorkbenchRendererRegistration.
- */
-declare interface CustomSettingsPanel extends SettingsPanelBase {
-    kind: "custom";
-    render(input: WorkbenchPanelRenderInput): unknown;
-}
-
 declare interface DataTableRendererColumn {
     id: string;
     label?: string;
@@ -521,10 +409,6 @@ declare interface DataTableRendererContribution {
     onRowActivate?: (row: DataTableRendererRow) => Promise<void> | void;
 }
 
-declare type DataTableRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    dataTableRendererId: string;
-}) => unknown;
-
 declare interface DataTableRendererQueryContext {
     resource?: ResourceRef;
     modeId?: string;
@@ -535,20 +419,6 @@ declare interface DataTableRendererQueryResult {
     columns?: DataTableRendererColumn[];
 }
 
-declare interface DataTableRendererRefreshEvent {
-    dataTableRendererId: string;
-}
-
-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 DataTableRendererRow {
     id: string;
     values: Record<string, unknown>;
@@ -571,10 +441,6 @@ declare interface DataTableRendererSelectionAction {
     run(rows: DataTableRendererRow[]): Promise<void> | void;
 }
 
-declare interface DataTableRendererStoreState {
-    renderers: Record<string, RegisteredDataTableRendererContribution>;
-}
-
 declare interface DataTableRendererThemeColor {
     light: string;
     dark: string;
@@ -584,30 +450,31 @@ declare interface DataTableRendererThemeColor {
     };
 }
 
-declare type DataTableViewRecord = WorkbenchExtensionMetadata["panels"][number];
-
-declare interface DeclaredPanelPlacement {
-    for?: string;
-    region: DockedCompositionRegion;
-    allowedRegions?: readonly DockedCompositionRegion[];
-    required?: boolean;
-    defaultOpen?: boolean;
-    pinned?: boolean;
-}
-
 declare interface Disposable_2 {
     dispose(): void;
 }
 
-declare type DockedCompositionRegion = (typeof dockedCompositionRegions)[number];
-
-declare type DockedCompositionRegion_2 = (typeof dockedCompositionRegions_2)[number];
-
-declare const dockedCompositionRegions: readonly ["sidenav", "main", "secondary", "side"];
-
-declare const dockedCompositionRegions_2: readonly ["sidenav", "main", "secondary", "side"];
-
-export declare const emptyWorkbenchExtensionMetadata: WorkbenchExtensionMetadata;
+declare type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+
+export declare const emptyWorkbenchExtensionMetadata: {
+    commands: never[];
+    commandPaletteContributions: never[];
+    diagnostics: never[];
+    extensions: never[];
+    menuContributions: never[];
+    modes: never[];
+    pages: never[];
+    views: never[];
+    viewMenus: never[];
+    placements: never[];
+    resourceKinds: never[];
+    navigationItems: never[];
+    navigationTrees: never[];
+    statusBarItems: never[];
+    statuses: never[];
+    settingsPanels: never[];
+    settingsDefinitions: never[];
+};
 
 declare interface EnumOption {
     value: string;
@@ -628,21 +495,596 @@ declare interface EnumOptionsSource {
     getSnapshot: () => EnumOption[];
 }
 
-declare type ExtensionPanelRecord = WorkbenchExtensionMetadata["panels"][number];
-
-declare type ExtensionResourcePanels = WorkbenchExtensionMetadata["resourcePanels"];
-
-declare type ExtensionTreeRendererRecord = NonNullable<WorkbenchExtensionMetadata["treeRenderers"]>[number];
-
-declare interface ExtensionTreeResource {
-    type: string;
-    id: string;
-    label?: string;
-    metadata?: Record<string, unknown>;
+declare const extensionCommandPaletteResourceRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    queryHandlerId: z.ZodString;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+
+declare const extensionControlsRendererRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    icon: z.ZodOptional<z.ZodString>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emptyTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    emptyDescription: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    queryHandlerId: z.ZodString;
+    valueChangeHandlerId: z.ZodOptional<z.ZodString>;
+    applyHandlerId: z.ZodOptional<z.ZodString>;
+    resetHandlerId: z.ZodOptional<z.ZodString>;
+    defaultValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodString>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strict>]>>>;
+}, z.core.$strip>;
+
+declare type ExtensionDataTableRendererRecord = z.infer<typeof extensionDataTableRendererRecordSchema>;
+
+declare const extensionDataTableRendererRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    icon: z.ZodOptional<z.ZodString>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emptyTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    emptyDescription: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        icon: z.ZodOptional<z.ZodString>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        stat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"unique">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"histogram">;
+            bins: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"top-values">;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "type">>;
+        renderer: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"json">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"color-scale">;
+            stops: z.ZodArray<z.ZodObject<{
+                value: z.ZodNumber;
+                color: z.ZodObject<{
+                    light: z.ZodString;
+                    dark: z.ZodString;
+                    foreground: z.ZodOptional<z.ZodObject<{
+                        light: z.ZodString;
+                        dark: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"categorical-color">;
+            categories: z.ZodArray<z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                color: z.ZodObject<{
+                    light: z.ZodString;
+                    dark: z.ZodString;
+                    foreground: z.ZodOptional<z.ZodObject<{
+                        light: z.ZodString;
+                        dark: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>>>;
+    queryHandlerId: z.ZodString;
+    selectionMode: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        multiple: "multiple";
+    }>>;
+    selectionActions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        icon: z.ZodOptional<z.ZodString>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+        commandId: z.ZodString;
+    }, z.core.$strip>>>;
+    rowActions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        icon: z.ZodOptional<z.ZodString>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+        commandId: z.ZodString;
+    }, z.core.$strip>>>;
+    rowActivationHandlerId: z.ZodOptional<z.ZodString>;
+    initialPageSize: z.ZodOptional<z.ZodNumber>;
+    pageSizeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+
+declare const extensionFileRendererRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    icon: z.ZodOptional<z.ZodString>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emptyTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    emptyDescription: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    loadHandlerId: z.ZodString;
+    saveHandlerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+declare const extensionKanbanRendererRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    icon: z.ZodOptional<z.ZodString>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emptyTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    emptyDescription: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    extensionInstanceId: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        type: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"enum">;
+            options: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    $l10n: z.ZodString;
+                    default: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+                color: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"enum-multi">;
+            options: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    $l10n: z.ZodString;
+                    default: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+                color: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"status">;
+            statuses: z.ZodObject<{
+                extensionId: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"status">;
+                id: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"string">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"date">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+        }, z.core.$strip>], "kind">;
+        filterable: z.ZodOptional<z.ZodBoolean>;
+        groupable: z.ZodOptional<z.ZodBoolean>;
+        sortable: z.ZodOptional<z.ZodBoolean>;
+        displayable: z.ZodOptional<z.ZodBoolean>;
+        editable: z.ZodOptional<z.ZodBoolean>;
+        display: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"badge-list">;
+            itemsAttributeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodString;
+        }, z.core.$loose>]>>;
+    }, z.core.$strip>>>;
+    queryHandlerId: z.ZodString;
+    attributeChangeHandlerId: z.ZodOptional<z.ZodString>;
+    reorderHandlerId: z.ZodOptional<z.ZodString>;
+    columnActionHandlerId: z.ZodOptional<z.ZodString>;
+    createRow: z.ZodOptional<z.ZodObject<{
+        commandId: z.ZodString;
+        title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        submitLabel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        columnParam: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodUnknown>>>>;
+        attributesParam: z.ZodOptional<z.ZodString>;
+        attachments: z.ZodOptional<z.ZodObject<{
+            commandId: z.ZodString;
+            resourceParam: z.ZodString;
+            fileParam: z.ZodString;
+        }, z.core.$strip>>;
+        labels: z.ZodOptional<z.ZodObject<{
+            cancel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                $l10n: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            properties: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                $l10n: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            submitError: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                $l10n: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            removeFile: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                $l10n: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    rowActions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        icon: z.ZodOptional<z.ZodString>;
+        commandId: z.ZodString;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    rowActivationHandlerId: z.ZodOptional<z.ZodString>;
+    defaultSettings: z.ZodOptional<z.ZodObject<{
+        viewMode: z.ZodOptional<z.ZodEnum<{
+            board: "board";
+            list: "list";
+        }>>;
+        columnGrouping: z.ZodOptional<z.ZodString>;
+        rowGrouping: z.ZodOptional<z.ZodString>;
+        ordering: z.ZodOptional<z.ZodObject<{
+            attributeId: z.ZodString;
+            direction: z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>;
+        }, z.core.$strip>>;
+        displayProperties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    defaultFilters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    defaultViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        settings: z.ZodObject<{
+            viewMode: z.ZodEnum<{
+                board: "board";
+                list: "list";
+            }>;
+            columnGrouping: z.ZodString;
+            rowGrouping: z.ZodString;
+            ordering: z.ZodObject<{
+                attributeId: z.ZodString;
+                direction: z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>;
+            }, z.core.$strip>;
+            displayProperties: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        filters: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    defaultActiveViewId: z.ZodOptional<z.ZodString>;
+    hideToolbar: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+declare type ExtensionKeybindingRecord = z.infer<typeof extensionKeybindingRecordSchema>;
+
+declare const extensionKeybindingRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    action: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodType<MetadataPageTarget, unknown, z.core.$ZodTypeInternals<MetadataPageTarget, unknown>>, z.ZodObject<{
+        kind: z.ZodLiteral<"panel">;
+        panel: z.ZodUnion<readonly [z.ZodObject<{
+            extensionId: z.ZodString;
+            kind: z.ZodLiteral<"placement">;
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"page-slot">;
+            page: z.ZodObject<{
+                extensionId: z.ZodString;
+                kind: z.ZodLiteral<"page">;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            id: z.ZodString;
+        }, z.core.$strip>]>;
+        resource: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+            projectId: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            extensionId: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strip>>;
+        open: z.ZodOptional<z.ZodEnum<{
+            preview: "preview";
+            pin: "pin";
+        }>>;
+    }, z.core.$strip>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"command">;
+        target: z.ZodObject<{
+            command: z.ZodObject<{
+                extensionId: z.ZodString;
+                kind: z.ZodLiteral<"command">;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            params: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"href">;
+        href: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"compound">;
+        targets: z.ZodArray<z.ZodUnion<readonly [z.ZodType<MetadataPageTarget, unknown, z.core.$ZodTypeInternals<MetadataPageTarget, unknown>>, z.ZodObject<{
+            kind: z.ZodLiteral<"panel">;
+            panel: z.ZodUnion<readonly [z.ZodObject<{
+                extensionId: z.ZodString;
+                kind: z.ZodLiteral<"placement">;
+                id: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"page-slot">;
+                page: z.ZodObject<{
+                    extensionId: z.ZodString;
+                    kind: z.ZodLiteral<"page">;
+                    id: z.ZodString;
+                }, z.core.$strip>;
+                id: z.ZodString;
+            }, z.core.$strip>]>;
+            resource: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                projectId: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                extensionId: z.ZodOptional<z.ZodString>;
+                metadata: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+            }, z.core.$strip>>;
+            open: z.ZodOptional<z.ZodEnum<{
+                preview: "preview";
+                pin: "pin";
+            }>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>]>;
+    key: z.ZodString;
+    canonicalChord: z.ZodString;
+    parsed: z.ZodObject<{
+        key: z.ZodString;
+        ctrl: z.ZodBoolean;
+        shift: z.ZodBoolean;
+        alt: z.ZodBoolean;
+        meta: z.ZodBoolean;
+        modifiers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    platformOverrides: z.ZodOptional<z.ZodObject<{
+        mac: z.ZodOptional<z.ZodString>;
+        linux: z.ZodOptional<z.ZodString>;
+        win: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        source: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            event: "event";
+            schedule: "schedule";
+            api: "api";
+            cli: "cli";
+            dashboard: "dashboard";
+            automation: "automation";
+            "command-panel": "command-panel";
+        }>>>;
+        viewId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resourceType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare type ExtensionMenuContribution_2 = z.infer<typeof extensionMenuContributionSchema>;
+
+declare const extensionMenuContributionSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    commandId: z.ZodString;
+    slotId: z.ZodString;
+    target: z.ZodOptional<z.ZodEnum<{
+        "workbench.nav.actions": "workbench.nav.actions";
+        "workbench.nav.overflow": "workbench.nav.overflow";
+    }>>;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    group: z.ZodOptional<z.ZodString>;
+    placement: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        first: "first";
+        last: "last";
+    }>>;
+    icon: z.ZodOptional<z.ZodString>;
+    presentation: z.ZodOptional<z.ZodEnum<{
+        button: "button";
+        "menu-item": "menu-item";
+        "icon-button": "icon-button";
+    }>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    when: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        source: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            event: "event";
+            schedule: "schedule";
+            api: "api";
+            cli: "cli";
+            dashboard: "dashboard";
+            automation: "automation";
+            "command-panel": "command-panel";
+        }>>>;
+        viewId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        resourceType: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare const extensionResourceRefSchema: z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    extensionId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+}, z.core.$strip>;
+
+declare type ExtensionSettingDefinitionRecord = z.infer<typeof extensionSettingDefinitionRecordSchema>;
+
+declare const extensionSettingDefinitionRecordSchema: z.ZodObject<{
+    key: z.ZodString;
+    extensionId: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+    }>;
+    scope: z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+
+declare type ExtensionSettingsSectionRecord = z.infer<typeof extensionSettingsSectionRecordSchema>;
+
+declare const extensionSettingsSectionRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+declare type ExtensionTreeRendererRecord = NonNullable<InternalWorkbenchExtensionMetadata["treeRenderers"]>[number];
+
+declare const extensionTreeRendererRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    extensionId: z.ZodString;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    icon: z.ZodOptional<z.ZodString>;
+    resourceKind: z.ZodOptional<z.ZodString>;
+    refreshEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emptyTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    emptyDescription: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    searchable: z.ZodOptional<z.ZodBoolean>;
+    searchPlaceholder: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        $l10n: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    headerHandlerId: z.ZodOptional<z.ZodString>;
+    bodyHandlerId: z.ZodString;
+    childrenHandlerId: z.ZodOptional<z.ZodString>;
+    footerHandlerId: z.ZodOptional<z.ZodString>;
+    defaultExpandedSectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultExpandedNodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+
+declare type ExtensionTreeResource = ResourceRef;
+
+declare type ExtensionTreeViewRecord = InternalWorkbenchExtensionMetadata["panels"][number] | NonNullable<InternalWorkbenchExtensionMetadata["panels"][number]["panelMenus"]>[number];
+
+export declare interface ExtensionWebviewArtifactCapabilities {
+    read(params: unknown, context: {
+        webviewId: string;
+    }): Promise<unknown> | unknown;
 }
 
-declare type ExtensionTreeViewRecord = WorkbenchExtensionMetadata["panels"][number] | NonNullable<WorkbenchExtensionMetadata["panels"][number]["panelMenus"]>[number];
-
 export declare interface ExtensionWebviewFileCapabilities {
     delete(params: unknown): Promise<unknown> | unknown;
     list(params: unknown): Promise<unknown> | unknown;
@@ -714,71 +1156,46 @@ declare interface FileRendererContribution {
     save?(resource: ResourceRef | undefined, content: string, origin?: FileRendererRefreshOrigin): Promise<FileRendererSaveResult | undefined> | FileRendererSaveResult | void;
 }
 
-declare type FileRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    fileRendererId: string;
-}) => unknown;
-
 declare interface FileRendererRefreshEnvelope {
-    resourceUri?: string;
+    resourceKey?: string;
     origin?: FileRendererRefreshOrigin;
     revision?: string;
 }
 
 export declare const fileRendererRefreshEnvelopeFromCommand: (body: CommandExecuteRequest, response: CommandExecuteResponse) => FileRendererRefreshEnvelope | undefined;
 
-declare interface FileRendererRefreshEvent extends FileRendererRefreshEnvelope {
-    fileRendererId: string;
-}
-
-declare type FileRendererRefreshListener = (event: FileRendererRefreshEvent) => void;
-
 declare interface FileRendererRefreshOrigin {
     rendererId: string;
     instanceId: string;
     operationId: string;
 }
 
-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;
-}
-
 declare interface FileRendererSaveResult {
     revision?: string;
 }
 
-declare interface FileRendererStoreState {
-    renderers: Record<string, RegisteredFileRendererContribution>;
-}
+export declare const getBridgeWebviewHostEventPublisher: (workbench: WorkbenchCore, instance: WorkbenchPanelInstance) => HostEventPublisher;
 
-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;
-}
+declare type HostCapability<TParams = unknown, TResult = unknown> = (params: TParams) => Promise<TResult> | TResult;
 
-declare type HistoryEntry = WorkbenchNavigationEntry;
+declare type HostCapabilityRegistry = Partial<Record<WebviewHostCapability, HostCapability>>;
 
-declare interface HistoryStoreState {
-    entries: readonly WorkbenchNavigationEntry[];
-    cursor: number;
-    recentlyClosed: readonly WorkbenchNavigationEntry[];
-    hydrating: boolean;
+declare type HostEventMessage = {
+    scope: string;
+    payload: unknown;
+};
+
+/**
+ * Host-side fan-in for events pushed into one guest webview. Capability
+ * implementations `emit` while the frame owns the transport: events emitted
+ * before the guest connection is up are buffered and flushed on `bind`.
+ */
+declare interface HostEventPublisher {
+    emit(message: HostEventMessage): void;
+    bind(sink: (message: HostEventMessage) => void): void;
+    onDisconnect(listener: () => void): () => void;
+    /** Drop the current sink and return to buffering until the next bind. */
+    unbind(): void;
 }
 
 declare interface HostTreeDefaultNodesInput {
@@ -789,7 +1206,133 @@ declare interface HostTreeDefaultNodesInput {
 
 declare type HostTreeDefaultNodesResolver = (input: HostTreeDefaultNodesInput) => Promise<TreeNode[]> | TreeNode[];
 
-declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> {
+declare interface InternalWorkbenchExtensionMetadata {
+    extensions: WorkbenchExtensionMetadata["extensions"];
+    commands: WorkbenchExtensionMetadata["commands"];
+    menuContributions: ExtensionMenuContribution_2[];
+    commandPaletteContributions: WorkbenchExtensionMetadata["commandPaletteContributions"];
+    modes: Array<{
+        id: string;
+        extensionId: string;
+        modeId: string;
+        label: WorkbenchExtensionMetadata["modes"][number]["label"];
+        icon?: string;
+        defaultTheme?: string;
+        chrome?: Partial<Record<"nav" | "sidenav" | "activity" | "status", string | false>>;
+        panelRegions: WorkbenchExtensionMetadata["modes"][number]["regions"];
+        regionSettings?: WorkbenchExtensionMetadata["modes"][number]["regionSettings"];
+        floatingPanels?: WorkbenchExtensionMetadata["modes"][number]["floatingPanels"];
+    }>;
+    pages: WorkbenchPageContribution[];
+    placements: Array<{
+        id: string;
+        ref: {
+            extensionId: string;
+            kind: "placement";
+            id: string;
+        };
+        modeId: string;
+        item: WorkbenchOwnedPlacementItem;
+        region: "main" | "secondary" | "side";
+        order?: number;
+        movableTo?: readonly ("main" | "secondary" | "side")[];
+    } & WorkbenchPlacementPresentation>;
+    panels: InternalWorkbenchExtensionPanel[];
+    resourceKinds: Array<{
+        id: string;
+        extensionId: string;
+        label?: WorkbenchExtensionMetadata["resourceKinds"][number]["label"];
+        icon?: string;
+        menuSlots: Record<string, {
+            placement: "header-primary" | "header-overflow" | "context-menu";
+            external: boolean;
+            order?: number;
+        }>;
+    }>;
+    resourceHierarchyProviders: Array<{
+        id: string;
+        extensionId: string;
+        resourceKind: string;
+    }>;
+    settingsSections: ExtensionSettingsSectionRecord[];
+    settingsPanels: Array<{
+        id: string;
+        extensionId: string;
+        viewId: string;
+        slotId: string;
+        scope: "global" | "project";
+        title: MetadataView["title"];
+        icon?: string;
+        section?: string;
+    }>;
+    kanbanRenderers: WorkbenchExtensionKanbanRendererRecord[];
+    dataTableRenderers: WorkbenchExtensionDataTableRendererRecord[];
+    commandPaletteResources: WorkbenchExtensionCommandPaletteResourceRecord_2[];
+    treeRenderers: WorkbenchExtensionTreeRendererRecord[];
+    fileRenderers: WorkbenchExtensionFileRendererRecord[];
+    controlsRenderers: WorkbenchExtensionControlsRendererRecord[];
+    keybindings: ExtensionKeybindingRecord[];
+    settingsDefinitions: ExtensionSettingDefinitionRecord[];
+    statuses: WorkbenchExtensionMetadata["statuses"];
+    statusBarItems: Array<{
+        id: string;
+        extensionId: string;
+        viewId: string;
+        slot: "leading" | "trailing";
+        order?: number;
+        when?: {
+            mode?: string | string[];
+            source?: string[];
+            viewId?: string | string[];
+            resourceType?: string[];
+            metadata?: Record<string, unknown>;
+        };
+    }>;
+    diagnostics: WorkbenchExtensionMetadata["diagnostics"];
+}
+
+declare interface InternalWorkbenchExtensionPanel {
+    id: string;
+    extensionId: string;
+    title: MetadataView["title"];
+    icon?: string;
+    webview?: MetadataWebview;
+    renderer?: {
+        kind: MetadataRendererKind;
+        id: string;
+    };
+    panelMenus?: InternalWorkbenchExtensionPanelMenu[];
+}
+
+declare interface InternalWorkbenchExtensionPanelMenu {
+    id: string;
+    extensionId: string;
+    ownerPanelId: string;
+    viewId: string;
+    title: MetadataView["title"];
+    side: "left" | "right";
+    group?: string;
+    placement?: "first" | "default" | "last";
+    hostTreeHeader?: "default" | "none";
+    hostTreeFooter?: "default" | "none";
+    webview?: MetadataWebview;
+    renderer?: {
+        kind: MetadataRendererKind;
+        id: string;
+    };
+}
+
+export declare const isExtensionNavigationTarget: (value: unknown) => value is NavigationTarget_2;
+
+declare type JsonObject = {
+    [key: string]: JsonValue;
+};
+
+declare type JsonPrimitive = string | number | boolean | null;
+
+declare type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+
+declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow, TNode = unknown, TIcon = unknown> {
     id: string;
     title: string;
     resourceKind?: string;
@@ -804,9 +1347,9 @@ declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = Ka
      * `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;
@@ -825,7 +1368,7 @@ declare interface KanbanRendererContribution<TRow extends KanbanRendererRow = Ka
     /** 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
@@ -882,10 +1425,6 @@ declare interface KanbanRendererCreateSubmission {
 
 declare type KanbanRendererFilterState = Record<string, string[]>;
 
-declare type KanbanRendererImplementation = (input: WorkbenchPanelRenderInput & {
-    kanbanRendererId: string;
-}) => unknown;
-
 declare interface KanbanRendererOrdering {
     attributeId: string | typeof MANUAL_ORDERING;
     direction: SortDirection;
@@ -896,22 +1435,6 @@ declare interface KanbanRendererQueryState {
     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;
@@ -924,7 +1447,7 @@ declare interface KanbanRendererRow {
     attributes: Record<string, unknown>;
 }
 
-declare type KanbanRendererRow_2 = Awaited<ReturnType<KanbanRendererContribution["executeQuery"]>>[number];
+declare type KanbanRendererRow_2 = Awaited<ReturnType<ReactKanbanRendererContribution["executeQuery"]>>[number];
 
 declare interface KanbanRendererSavedView {
     id: string;
@@ -942,15 +1465,11 @@ declare interface KanbanRendererSettings {
     displayProperties: string[];
 }
 
-declare interface KanbanRendererStoreState {
-    renderers: Record<string, RegisteredKanbanRendererContribution>;
-}
-
 declare interface Keybinding {
-    commandId: string;
+    /** Action the chord executes through the shared navigation executor. */
+    action: NavigationTarget;
     keybinding: KeybindingSequence;
     when?: string;
-    args?: unknown;
 }
 
 declare interface KeybindingRegistry {
@@ -958,6 +1477,11 @@ 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 {
@@ -977,12 +1501,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;
     };
@@ -994,6 +1512,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;
@@ -1011,7 +1530,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;
@@ -1044,13 +1563,6 @@ declare interface LayoutModel {
 
 declare type LayoutScope = string;
 
-export declare const listCompositionAddablePanels: (input: {
-    registry: WorkbenchCompositionRegistry;
-    modeId: string;
-    layout: ReturnType<LayoutModel["getLayout"]>;
-    resourceKind?: string;
-}) => readonly ResolvedCompositionAddablePanel[];
-
 declare type Localizer = (value: unknown, fallback?: string) => string;
 
 declare const MANUAL_ORDERING = "manual";
@@ -1084,6 +1596,31 @@ declare interface MenuRegistryStoreState {
     itemsByPath: Record<string, RegisteredMenuItem[]>;
 }
 
+declare interface MetadataPageTarget {
+    kind: "page";
+    page: z.infer<typeof pageRefSchema>;
+    resource?: z.infer<typeof extensionResourceRefSchema>;
+    open?: "preview" | "pin";
+    section?: z.infer<typeof sectionSchema>;
+    parent?: MetadataPageTarget;
+}
+
+declare type MetadataRendererKind = Exclude<MetadataView["body"]["kind"], "webview">;
+
+declare type MetadataView = WorkbenchExtensionMetadata["views"][number];
+
+declare type MetadataWebview = Extract<MetadataView["body"], {
+    kind: "webview";
+}>["webview"];
+
+declare type NativeViewBody<Kind extends string, Contribution> = {
+    kind: Kind;
+} & Omit<Contribution, "id" | "title" | "icon">;
+
+declare type NavigationOperation = Extract<NavigationTarget_2, {
+    kind: "page" | "panel";
+}>;
+
 declare interface NavigationParser {
     id: string;
     priority?: number;
@@ -1097,16 +1634,15 @@ 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>;
 }
 
 declare type NavigationTarget = NavigationTargetItem | NavigationTargetCompound;
@@ -1119,23 +1655,63 @@ declare interface NavigationTargetCommand {
 
 declare interface NavigationTargetCompound {
     kind: "compound";
-    targets: readonly NavigationTargetItem[];
+    targets: readonly (NavigationTargetPage | NavigationTargetPanel)[];
+}
+
+declare interface NavigationTargetHref {
+    kind: "href";
+    href: string;
 }
 
-declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetPanel | NavigationTargetCommand;
+declare type NavigationTargetItem = NavigationTargetPage | NavigationTargetPanel | NavigationTargetCommand | NavigationTargetHref;
+
+declare type NavigationTargetPage = NavigationTargetPage_2;
 
-declare interface NavigationTargetPanel {
+declare type NavigationTargetPanel = NavigationTargetPanel_2 | NavigationTargetShellPanel;
+
+declare interface NavigationTargetShellPanel {
     kind: "panel";
-    panelId: string;
-    input?: OpenWorkbenchPanelInput;
+    panel: ShellPlacementRef;
+    resource?: NavigationTargetPanel_2["resource"];
+    open?: NavigationTargetPanel_2["open"];
+    title?: string;
 }
 
-declare interface NavigationTargetResource {
-    kind: "resource";
-    resource: ResourceRef;
-    input?: OpenResourceInput;
+declare interface NavigationTreeContext {
+    resource?: ResourceRef;
+}
+
+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[];
+}
+
+declare interface NavigationTreeOwner {
+    kind: "mode" | "page";
+    id: string;
+    extensionId: string;
+}
+
+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;
 }
 
+declare type NavigationTreeSlot = "header" | "content" | "footer";
+
 declare const NO_GROUPING = "none";
 
 declare interface NotificationRegistry {
@@ -1147,12 +1723,15 @@ declare interface NotificationRegistry {
     subscribe(listener: WorkbenchNotificationListener): Disposable_2;
 }
 
-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;
@@ -1169,9 +1748,17 @@ declare interface OpenWidgetInput {
     replaceWidgetId?: string;
 }
 
-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;
@@ -1182,9 +1769,38 @@ declare interface OpenWorkbenchPanelInput {
     strategy?: WorkbenchPanelOpenStrategy;
 }
 
-export declare const panelMenuDeclarationOffsets: <T extends {
-    panelMenus?: readonly unknown[];
-}>(panels: readonly T[]) => number[];
+declare interface OpenWorkbenchShellPlacementInput {
+    placementId: string;
+    resource?: ResourceRef;
+    open?: PageOpenIntent;
+    title?: string;
+}
+
+declare interface OwnedPlacementLocationContext {
+    modeId: string;
+    pageId?: string;
+    projectId?: string;
+    location?: PageLocation;
+}
+
+declare interface OwnedPlacementReconciliation<Value> {
+    add: readonly ResolvedOwnedPlacement<Value>[];
+    retain: readonly ResolvedOwnedPlacement<Value>[];
+    update: readonly OwnedPlacementUpdate<Value>[];
+    activate: readonly ResolvedOwnedPlacement<Value>[];
+    remove: readonly ResolvedOwnedPlacement<Value>[];
+}
+
+declare interface OwnedPlacementUpdate<Value> {
+    current: ResolvedOwnedPlacement<Value>;
+    desired: ResolvedOwnedPlacement<Value>;
+}
+
+declare const pageRefSchema: z.ZodObject<{
+    extensionId: z.ZodString;
+    kind: z.ZodLiteral<"page">;
+    id: z.ZodString;
+}, z.core.$strip>;
 
 declare interface PlaceholderContribution {
     id: string;
@@ -1230,12 +1846,13 @@ declare interface PreferenceScopeRef {
 
 declare type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
 
-export declare const reconcileCompositionLayout: (ctx: CompositionReconcileContext, input: {
-    registry: WorkbenchCompositionRegistry;
-    modeId: string;
-    resourceKind?: string;
-    seeding?: boolean;
-}) => ResolvedComposition | undefined;
+declare type ReactAttributeDescriptor = AttributeDescriptor<ReactNode>;
+
+declare type ReactColumnIcon = ComponentType<{
+    size?: number | string;
+}>;
+
+declare type ReactKanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow> = KanbanRendererContribution<TRow, ReactNode, ReactColumnIcon>;
 
 export declare const refreshOpenWorkbenchExtensionWebviews: (workbench: WorkbenchModuleContext, metadata: WorkbenchExtensionMetadata) => void;
 
@@ -1252,24 +1869,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 {
 }
 
@@ -1289,8 +1888,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;
@@ -1315,36 +1912,48 @@ declare interface RegisteredWorkbenchNotification extends RegisteredContribution
     metadata?: Record<string, unknown>;
 }
 
+declare type RegisteredWorkbenchStatusSet = WorkbenchStatusSetContribution & RegisteredContributionMetadata;
+
+declare type RegisteredWorkbenchView = WorkbenchViewContribution & RegisteredContributionMetadata;
+
 export declare const registerWorkbenchExtensionCommandPaletteResources: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionCommandPaletteResourceRecord[]) => {
     dispose(): void;
 };
 
-export declare const registerWorkbenchExtensionContributions: (input: RegisterWorkbenchExtensionContributionsInput) => {
+export declare const registerWorkbenchExtensionContributions: (sourceInput: RegisterWorkbenchExtensionContributionsInput) => {
     dispose(): void;
 };
 
 export declare interface RegisterWorkbenchExtensionContributionsInput {
+    createKeybindingWhenExpression?: (when: ExtensionKeybindingRecord["when"]) => string | undefined;
     createMenuWhenExpression?: WorkbenchExtensionMenuWhenBuilder;
+    createNavigationWhenExpression?: (when: WorkbenchExtensionMetadata["navigationItems"][number]["when"]) => string | undefined;
     createWebviewHostCapabilities?: CreateBridgeWebviewHostCapabilities;
     createWebviewHostCapabilityOverrides?: CreateBridgeWebviewHostCapabilities;
     createWebviewProps?: CreateBridgeWebviewProps;
     createWebviewTheme?: CreateBridgeWebviewTheme;
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    kanbanAdapter?: WorkbenchExtensionKanbanRendererAdapter;
     menuSlotsById?: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
     menuTargetsById?: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
+    menuRegistrations?: readonly WorkbenchExtensionHostMenuRegistration[];
     metadata: WorkbenchExtensionMetadata;
     openHref?: (href: string) => unknown;
+    prepareCommandArgs?(commandId: string, args: unknown, context?: WorkbenchCommandExecutionContext, onArgsChange?: (args: unknown) => void): Promise<unknown> | unknown;
     projectId: string;
-    routeResourceKind?: string;
+    resolveTreeNodeResource?: RegisterWorkbenchExtensionTreeRenderersInput["resolveNodeResource"];
+    renderWebview?(input: WorkbenchPanelRenderInput): unknown;
     settingsSectionId?: string;
     settingsSectionTitle?: string;
+    subscribeRefreshEvents?: (listener: (event: WorkbenchExtensionRefreshEvent) => void) => Disposable_2;
+    webviewArtifacts?: ExtensionWebviewArtifactCapabilities;
     webviewFiles?: ExtensionWebviewFileCapabilities;
     workbench: WorkbenchModuleContext;
 }
 
-export declare const registerWorkbenchExtensionControlsRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionControlsRendererRecord[], panels: ControlsViewRecord[], adapter?: WorkbenchExtensionControlsAdapter, resourcePanels?: WorkbenchExtensionMetadata["resourcePanels"]) => Disposable_2;
+export declare const registerWorkbenchExtensionControlsRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionControlsRendererRecord[], adapter?: WorkbenchExtensionControlsAdapter) => Disposable_2;
 
-export declare const registerWorkbenchExtensionDataTableRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionDataTableRendererRecord[], panels: DataTableViewRecord[], resourcePanels?: WorkbenchExtensionMetadata["resourcePanels"]) => Disposable_2;
+export declare const registerWorkbenchExtensionDataTableRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionDataTableRendererRecord[]) => Disposable_2;
 
 export declare const registerWorkbenchExtensionFileRenderers: (input: RegisterWorkbenchExtensionFileRenderersInput) => {
     dispose(): void;
@@ -1352,22 +1961,15 @@ export declare const registerWorkbenchExtensionFileRenderers: (input: RegisterWo
 
 export declare interface RegisterWorkbenchExtensionFileRenderersInput {
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
-    metadata: WorkbenchExtensionMetadata;
+    metadata: InternalWorkbenchExtensionMetadata;
     projectId: string;
     workbench: WorkbenchModuleContext;
 }
 
-export declare const registerWorkbenchExtensionKanbanRenderers: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionKanbanRendererRecord[], adapter?: WorkbenchExtensionKanbanRendererAdapter, panels?: WorkbenchExtensionMetadata["panels"], resourcePanels?: WorkbenchExtensionMetadata["resourcePanels"]) => {
+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 registerWorkbenchExtensionRendererRefreshEvents: (input: RegisterWorkbenchExtensionRendererRefreshEventsInput) => Disposable_2;
 
 export declare interface RegisterWorkbenchExtensionRendererRefreshEventsInput {
@@ -1384,7 +1986,7 @@ export declare interface RegisterWorkbenchExtensionTreeRenderersInput {
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
     getHostTreeFooterNodes?: HostTreeDefaultNodesResolver;
     getHostTreeHeaderNodes?: HostTreeDefaultNodesResolver;
-    metadata: WorkbenchExtensionMetadata;
+    metadata: InternalWorkbenchExtensionMetadata;
     projectId: string;
     /**
      * Host canonicalization for node resources. A host that gives extension
@@ -1411,48 +2013,15 @@ declare interface RendererRefreshTarget {
     kind: WorkbenchExtensionRendererKind;
 }
 
-declare interface ResolvedComposition {
-    placements: readonly ResolvedCompositionPlacement[];
-    regionOrder: Partial<Record<DockedCompositionRegion, readonly string[]>>;
-    activePanelIds: Partial<Record<DockedCompositionRegion, string>>;
-    addablePanels: readonly ResolvedCompositionAddablePanel_2[];
-    diagnostics: readonly CompositionDiagnostic[];
-    requiredFallback?: {
-        panelId: string;
-    };
-}
-
-declare interface ResolvedCompositionAddablePanel {
-    panelId: string;
-    region: DockedCompositionRegion_2;
-    allowedRegions: readonly DockedCompositionRegion_2[];
-    pinned?: boolean;
-}
-
-declare interface ResolvedCompositionAddablePanel_2 {
-    panelId: string;
-    region: DockedCompositionRegion;
-    allowedRegions: readonly DockedCompositionRegion[];
-    pinned?: boolean;
-}
-
-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;
-};
-
 declare interface ResourceBrowseEntry {
     resource: ResourceRef;
     searchText?: string;
@@ -1463,19 +2032,19 @@ declare interface ResourceBrowseEntry {
 }
 
 /** Row-level context menu action surfaced by the renderer. */
-declare interface ResourceContextAction {
+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;
 }
 
 declare interface ResourceHierarchyCycle {
     code: typeof resourceHierarchyCycleCode;
-    path: ResourceRef[];
+    path: WorkbenchHierarchyNode[];
     repeatedUri: string;
 }
 
@@ -1485,90 +2054,45 @@ declare interface ResourceHierarchyProvider {
     id: string;
     priority?: number;
     canResolve(resource: ResourceRef): boolean;
-    getParent(resource: ResourceRef): ResourceRef | undefined;
+    getParent(resource: ResourceRef): WorkbenchHierarchyNode | undefined;
 }
 
 declare interface ResourceKindContribution {
     kind: string;
     label: string;
     icon?: string;
-    surface?: ResourceSurface;
-    paletteOpenInput?: OpenResourceInput;
 }
 
 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>;
-}
-
-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;
-}
-
-declare interface ResourceProvider {
+declare interface ResourceProvider {
     id: string;
     kind: string;
     list(query: string, context: ResourceListContext): readonly ResourceBrowseEntry[];
 }
 
-declare interface ResourceRef {
-    kind: string;
-    uri: string;
-    id?: string;
-    label?: string;
-    icon?: string;
-    metadata?: Record<string, unknown>;
-}
-
-declare interface ResourceRef_2 {
-    kind: string;
-    uri: string;
-    id?: string;
-    label?: string;
-    icon?: string;
-    metadata?: Record<string, unknown>;
-}
-
 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>;
 }
 
-declare type ResourceSurface = "primary" | "secondary" | "attached";
-
 declare type RowAction = NonNullable<WorkbenchExtensionKanbanRendererRecord["rowActions"]>[number];
 
 /** Auto-rendered as a param editor from the registered preference schema. */
@@ -1579,6 +2103,14 @@ declare interface SchemaSettingsPanel extends SettingsPanelBase {
     save?: "live" | "apply";
 }
 
+declare const sectionSchema: z.ZodObject<{
+    anchors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        heading: z.ZodString;
+        occurrence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
 /** A "+ create"-style action surfaced on a section or a collection's parent node. */
 declare interface SettingsAction {
     id: string;
@@ -1607,7 +2139,7 @@ declare interface SettingsPanelBase {
     when?: string;
 }
 
-declare type SettingsPanelContribution = SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel;
+declare type SettingsPanelContribution = SchemaSettingsPanel | ViewSettingsPanel | CollectionSettingsPanel;
 
 /** A preference this panel edits; a bare string uses the preference name as its label. */
 declare type SettingsPanelPreference = string | {
@@ -1618,11 +2150,13 @@ declare type SettingsPanelPreference = string | {
 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;
 }
@@ -1646,6 +2180,12 @@ 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;
+}
+
 declare type SortDirection = "asc" | "desc";
 
 /**
@@ -1655,6 +2195,8 @@ declare type SortDirection = "asc" | "desc";
  */
 declare type ThemePreference = string;
 
+declare type ThemePreference_2 = "dark" | "light";
+
 declare type ThemePreferenceMode = "light" | "dark";
 
 declare interface ThemePreferenceOption {
@@ -1673,16 +2215,29 @@ declare interface ThemeRegistry {
     listThemes(): readonly ThemePreferenceOption[];
 }
 
-export declare const toPanelPlacements: (show: DeclaredPanelPlacement | readonly DeclaredPanelPlacement[] | undefined) => any[];
+export declare function toWorkbenchNavigationTarget(target: NavigationOperation, input?: ToWorkbenchNavigationTargetInput): NavigationOperation;
 
-export declare const toWorkbenchCompositionPanelContribution: (input: {
-    panel: ExtensionPanelRecord;
-    rendererId: string;
-    declarationIndex: number;
-    menuDeclarationOffset: number;
-    resourcePanels?: ExtensionResourcePanels;
-    config?: WorkbenchPanelContribution["config"];
-}) => WorkbenchPanelContribution;
+export declare function toWorkbenchNavigationTarget(target: NavigationTarget_2, input?: ToWorkbenchNavigationTargetInput): NavigationTarget;
+
+export declare interface ToWorkbenchNavigationTargetInput {
+    commandIdOf?(command: Extract<NavigationTarget_2, {
+        kind: "command";
+    }>["target"]["command"]): string | undefined;
+    commandTargetOf?(target: Extract<NavigationTarget_2, {
+        kind: "command";
+    }>): NavigationTargetCommand;
+    extensionId?: string;
+}
+
+export declare const toWorkbenchNavigationTargetResult: (value: unknown, input?: ToWorkbenchNavigationTargetInput) => NavigationTarget | undefined;
+
+export declare const toWorkbenchWhenExpression: (when: WorkbenchExtensionMetadata["navigationItems"][number]["when"] | WorkbenchExtensionMetadata["statusBarItems"][number]["when"]) => {
+    mode: string | string[] | undefined;
+    source: ("event" | "schedule" | "api" | "cli" | "dashboard" | "automation" | "command-panel")[] | undefined;
+    viewId: string | string[] | undefined;
+    resourceType: string[] | undefined;
+    metadata: Record<string, unknown> | undefined;
+} | undefined;
 
 declare interface TreeAction {
     id: string;
@@ -1697,15 +2252,29 @@ declare interface TreeAction {
     run?(args?: unknown): Promise<void> | void;
 }
 
-declare interface TreeContext {
-    filter?: string;
-    resource?: ResourceRef;
-    /** Widget/view contribution id for trees rendered through a view-backed widget. */
-    viewId?: string;
+declare interface TreeContext extends TreeQueryContext {
+    state: Readonly<TreeRendererState>;
+    refresh(): void;
+    setSelectedNode(nodeId: string | undefined): void;
 }
 
+declare interface TreeMoveEndpoint {
+    kind: "section" | "node";
+    sectionId: string;
+    id: string;
+    moveScope?: string;
+}
+
+declare type TreeMovePolicy = (move: {
+    source: TreeMoveEndpoint;
+    destination: TreeMoveEndpoint;
+}) => boolean;
+
 declare interface TreeNode {
     id: string;
+    selected?: boolean;
+    /** Host-owned customization boundary. Extension callbacks cannot set it. */
+    moveScope?: string;
     label: string;
     icon?: string;
     iconElement?: unknown;
@@ -1750,6 +2319,13 @@ 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;
+}
+
 declare interface TreeRendererContribution {
     id: string;
     title: string;
@@ -1760,9 +2336,10 @@ 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;
 }
 
@@ -1782,10 +2359,10 @@ declare interface TreeRendererRegistry {
     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;
@@ -1816,6 +2393,8 @@ declare interface TreeSectionEmptyState {
 
 declare interface TreeViewSection {
     id: string;
+    /** Host-owned customization boundary. Extension callbacks cannot set it. */
+    moveScope?: string;
     label?: string;
     actions?: TreeAction[];
     collapsible?: boolean;
@@ -1828,6 +2407,11 @@ declare interface TreeViewSection {
     canReorder?: boolean;
 }
 
+declare interface UnresolvedWorkbenchExtensionMenuContribution {
+    contribution: ExtensionMenuContribution;
+    targetId: string;
+}
+
 /**
  * Core-owned contracts for kanban renderer contributions. @pstdio/ui's
  * KanbanRenderer props are structurally identical; the React layer bridges the
@@ -1836,6 +2420,11 @@ declare interface TreeViewSection {
  */
 declare type ViewMode = "board" | "list";
 
+declare interface ViewSettingsPanel extends SettingsPanelBase {
+    kind: "view";
+    viewId: string;
+}
+
 declare interface WidgetContribution {
     id: string;
     title: string;
@@ -1847,15 +2436,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;
@@ -1865,8 +2452,6 @@ declare interface WidgetContribution {
 
 declare type WidgetMountStrategy = "active" | "keep-mounted";
 
-declare type WidgetMountStrategy_2 = "active" | "keep-mounted";
-
 declare type WidgetReusePolicy = "resource" | "none";
 
 declare type WorkbenchBreadcrumbChangeListener = () => void;
@@ -1892,13 +2477,6 @@ 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";
@@ -1940,7 +2518,7 @@ declare interface WorkbenchCommandPaletteState {
     paramsRequest: WorkbenchCommandParamsRequest | null;
 }
 
-declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
+declare type WorkbenchCommandPaletteView = "main" | "theme";
 
 declare interface WorkbenchCommandParamsRequest {
     record: {
@@ -1955,14 +2533,14 @@ declare interface WorkbenchCommandParamsRequest {
     context?: WorkbenchCommandExecutionContext;
 }
 
-declare interface WorkbenchComposition {
-    resourceKinds: readonly CompositionResourceKindDefinition[];
-    panels: readonly CompositionPanelDefinition[];
-    resourcePanels: readonly CompositionResourcePanelEdge[];
+declare interface WorkbenchCommandTarget {
+    commandId: string;
+    args?: unknown;
 }
 
 declare interface WorkbenchCompositionAddablePanel extends WorkbenchModeAddablePanel {
     contribution: RegisteredWidgetContribution;
+    open?(resource?: ResourceRef): void;
 }
 
 declare interface WorkbenchCompositionController {
@@ -1975,22 +2553,16 @@ declare interface WorkbenchCompositionRegionPanels {
     closable: readonly string[];
 }
 
-export declare interface WorkbenchCompositionRegistry {
-    registerResourceKind(definition: CompositionResourceKindDefinition): Disposable_2;
-    registerPanelCapability(definition: CompositionPanelDefinition): Disposable_2;
-    registerResourcePanel(edge: CompositionResourcePanelEdge): Disposable_2;
-    registerModeComposition(definition: CompositionModeDefinition): Disposable_2;
-    getComposition(): WorkbenchComposition;
-    getModeComposition(modeId: string): CompositionModeDefinition | undefined;
-}
-
 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;
@@ -1998,19 +2570,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;
@@ -2020,10 +2600,12 @@ 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;
 }
 
 export declare interface WorkbenchExtensionCommandContext {
     executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    prepareCommandArgs?(commandId: string, args: unknown, context?: WorkbenchCommandExecutionContext, onArgsChange?: (args: unknown) => void): Promise<unknown> | unknown;
     projectId: string;
     workbench: WorkbenchModuleContext;
 }
@@ -2035,16 +2617,31 @@ export declare interface WorkbenchExtensionCommandPaletteRegistration {
     targetCommandId: string;
 }
 
+declare type WorkbenchExtensionCommandPaletteResourceRecord_2 = z.infer<typeof extensionCommandPaletteResourceRecordSchema>;
+
 export declare interface WorkbenchExtensionControlsAdapter {
     /** Supply a fallback resource when the widget placement carries none. */
     resolveResource?: (record: WorkbenchExtensionControlsRendererRecord) => ResourceRef | undefined;
 }
 
+declare type WorkbenchExtensionControlsRendererRecord = z.infer<typeof extensionControlsRendererRecordSchema>;
+
+declare type WorkbenchExtensionDataTableRendererRecord = ExtensionDataTableRendererRecord;
+
+declare type WorkbenchExtensionFileRendererRecord = z.infer<typeof extensionFileRendererRecordSchema>;
+
+export declare interface WorkbenchExtensionHostMenuRegistration extends Omit<WorkbenchExtensionMenuRegistration, "menuItem" | "menuPath"> {
+    menuItems: Array<{
+        menuItem: MenuItem;
+        menuPath: MenuPath;
+    }>;
+}
+
 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: WorkbenchExtensionKanbanRendererRecord, attribute: AttributeDescriptor) => AttributeDescriptor;
+    decorateAttribute?: (record: WorkbenchExtensionKanbanRendererRecord, attribute: ReactAttributeDescriptor) => ReactAttributeDescriptor;
     /**
      * Translate a row's transport-shaped resource (`{ type, id }`) into a workbench
      * `ResourceRef`. Defaults to the workbench `pstdio://extension-resource/...`
@@ -2070,17 +2667,13 @@ export declare interface WorkbenchExtensionKanbanRendererAdapter {
         runDefault: () => Promise<void>;
     }) => void | Promise<void>;
     /**
-     * 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 presenter exists yet).
+     * Handle a row click when the renderer has no declared activation handler.
      */
     onRowClick?: (input: {
         record: WorkbenchExtensionKanbanRendererRecord;
         row: KanbanRendererRow_2;
         resource: ResourceRef | undefined;
     }) => void;
-    /** Translate extension navigation resource targets into host resources. */
-    resolveNavigationResource?: (record: WorkbenchExtensionKanbanRendererRecord, resource: NonNullable<CommandExecuteRequest["resource"]>) => ResourceRef;
     /** Called after a successful renderer-owned create form submission. */
     onAfterCreate?: (input: {
         record: WorkbenchExtensionKanbanRendererRecord;
@@ -2091,11 +2684,13 @@ export declare interface WorkbenchExtensionKanbanRendererAdapter {
      * 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.refreshKanbanRenderer(id)`.
+     * `ctx.views.refreshView(id)`.
      */
     onAfterMutation?: (record: WorkbenchExtensionKanbanRendererRecord) => void;
 }
 
+declare type WorkbenchExtensionKanbanRendererRecord = z.infer<typeof extensionKanbanRendererRecordSchema>;
+
 export declare interface WorkbenchExtensionMenuRegistration {
     command: Command;
     contribution: ExtensionMenuContribution;
@@ -2120,20 +2715,14 @@ declare interface WorkbenchExtensionRefreshEvent extends FileRendererRefreshEnve
 
 export declare type WorkbenchExtensionRendererKind = "tree" | "file" | "controls" | "dataTable" | "kanban";
 
-export declare type WorkbenchExtensionRoute = WorkbenchExtensionMetadata["routes"][number];
-
-export declare interface WorkbenchExtensionRouteResourceInput {
-    route: WorkbenchExtensionRoute;
-}
-
 declare type WorkbenchExtensionStringResolver = (value: Localizable<string> | undefined, extensionId: string) => string;
 
+declare type WorkbenchExtensionTreeRendererRecord = z.infer<typeof extensionTreeRendererRecordSchema>;
+
 declare interface WorkbenchFileIconThemeStoreState {
     themes: readonly FileIconThemePreferenceOption[];
 }
 
-declare type WorkbenchFloatingPanelVisibility = "visible" | "hidden";
-
 declare type WorkbenchFocusChangeListener = (region: WorkbenchFocusRegionId | undefined) => void;
 
 declare interface WorkbenchFocusController {
@@ -2152,6 +2741,8 @@ declare interface WorkbenchFocusState {
     activeRegion: WorkbenchFocusRegionId | undefined;
 }
 
+declare type WorkbenchHierarchyNode = ResourceRef | WorkbenchViewHierarchyNode;
+
 declare interface WorkbenchHost {
     getSnapshot(): WorkbenchSnapshot;
     restoreSnapshot(snapshot: WorkbenchSnapshot): void;
@@ -2161,18 +2752,12 @@ declare interface WorkbenchHost {
     getPersistenceScope(): string | undefined;
 }
 
-declare interface WorkbenchLastResourceController {
-    get(): ResourceRef | undefined;
-    set(resource: ResourceRef | undefined): void;
-    restore(): Promise<boolean>;
-}
-
 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;
@@ -2183,22 +2768,15 @@ declare interface WorkbenchLayoutStoreState {
     placeholders: Partial<Record<WorkbenchRegion, RegisteredPlaceholderContribution>>;
 }
 
-declare type WorkbenchLocationContribution = WidgetContribution & 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;
+    canOpenLocation?(location: {
+        resource?: ResourceRef;
+        viewId?: string;
+    }): boolean;
 }
 
 declare type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
@@ -2222,7 +2800,12 @@ declare type WorkbenchModeChangeListener = () => void;
 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[];
@@ -2232,6 +2815,31 @@ declare interface WorkbenchModeContribution {
     reconcile?(ctx: WorkbenchModeActivationContext): void;
 }
 
+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[];
+}
+
+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;
+}
+
 declare interface WorkbenchModeRegistry {
     store: WorkbenchStore<WorkbenchModeStoreState>;
     dispose(): void;
@@ -2265,74 +2873,7 @@ declare interface WorkbenchModuleContribution {
 
 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">;
 
 declare interface WorkbenchNotification {
     id?: string;
@@ -2368,6 +2909,121 @@ declare interface WorkbenchNotificationStoreState {
     notifications: Record<string, RegisteredWorkbenchNotification>;
 }
 
+declare interface WorkbenchOverlayContribution extends Omit<WorkbenchPlacementPresentation, "mountStrategy"> {
+    id: string;
+    viewId: string;
+    closable?: boolean;
+}
+
+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;
+
+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[];
+}
+
+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;
+}
+
+declare interface WorkbenchPageLocationDiagnostic {
+    code: "page-location-unresolved";
+    source: "boot" | "history" | "navigation" | "project-switch";
+    message: string;
+}
+
+declare interface WorkbenchPageLocationHistoryState {
+    canGoBack: boolean;
+    canGoForward: boolean;
+}
+
+declare type WorkbenchPageMain = PageMain extends infer Main ? Main extends PageMain ? Omit<Main, "tab"> & {
+    readonly tab?: WorkbenchPlacementPresentation["tab"];
+} : never : never;
+
+declare type WorkbenchPageNavigationResult = {
+    ok: true;
+    location: PageLocation;
+} | {
+    ok: false;
+    diagnostic: WorkbenchPageLocationDiagnostic;
+};
+
+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 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;
@@ -2378,16 +3034,15 @@ 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;
@@ -2399,11 +3054,14 @@ declare interface WorkbenchPanelContribution {
 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;
@@ -2413,23 +3071,6 @@ declare interface WorkbenchPanelInstance {
     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"> & {
     region: WorkbenchPanelMenuRegion;
     fallbackRegion?: WorkbenchPanelMenuRegion;
@@ -2477,15 +3118,25 @@ declare const workbenchPanelMenuRegions: {
     };
 };
 
-declare interface WorkbenchPanelMenusContribution {
-    panelMenus?: readonly WorkbenchPanelMenuDefinition[];
+declare type WorkbenchPanelMenuSide = "left" | "right";
+
+declare interface WorkbenchPanelMenuState {
+    openByMenuId: Record<string, boolean>;
 }
 
-declare type WorkbenchPanelMenuSide = "left" | "right";
+declare type WorkbenchPanelMenuStateChangeListener = (state: WorkbenchPanelMenuState) => void;
 
-declare type WorkbenchPanelMountStrategy = WidgetMountStrategy;
+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 type WorkbenchPanelMountStrategy_2 = WidgetMountStrategy_2;
+declare type WorkbenchPanelMountStrategy = WidgetMountStrategy;
 
 declare type WorkbenchPanelOpenStrategy = {
     kind: "persistent";
@@ -2514,29 +3165,41 @@ declare interface WorkbenchPanelRenderInput {
 
 declare type WorkbenchPanelReusePolicy = WidgetReusePolicy;
 
-declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
+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;
+declare interface WorkbenchPlaceholderContribution {
+    id: string;
+    viewId: string;
+    title?: string;
+    region: WorkbenchRegion;
+    regionSize?: WorkbenchRegionSize;
+    regionCollapsible?: boolean;
+    config?: unknown;
 }
 
-declare interface WorkbenchPanelsState {
-    openByRegionId: Record<string, boolean>;
+declare interface WorkbenchPlaceholderRegistry {
+    registerPlaceholder(placeholder: WorkbenchPlaceholderContribution, metadata?: ContributionMetadata): Disposable_2;
 }
 
-declare type WorkbenchPanelTab = WorkbenchWidgetTab;
+declare interface WorkbenchPlacementPresentation {
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+    headerBorderBottom?: boolean;
+    tab?: WorkbenchPanelTab;
+    config?: unknown;
+}
 
-declare type WorkbenchPanelTab_2 = WorkbenchWidgetTab_2;
+declare interface WorkbenchReactViewBody {
+    kind: "react";
+    render: WorkbenchRendererRegistration["render"];
+}
 
 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 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;
 
 declare interface WorkbenchRegionSize {
     defaultPx?: number;
@@ -2552,35 +3215,9 @@ declare interface WorkbenchRegionState {
     activeWidgetId?: string;
 }
 
-declare type WorkbenchRendererChangeListener = () => void;
-
-declare type WorkbenchRendererRegistration = {
+declare interface WorkbenchRendererRegistration {
     id: string;
-    keepAlive?: false;
     render: (input: WorkbenchPanelRenderInput) => unknown;
-} | {
-    id: string;
-    keepAlive: true;
-    render: () => unknown;
-};
-
-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>;
 }
 
 declare interface WorkbenchShellController {
@@ -2592,7 +3229,29 @@ declare interface WorkbenchShellController {
     onDidChange(listener: () => void): Disposable_2;
 }
 
-declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | WorkbenchPanelMenuRegion;
+declare type WorkbenchShellOpenRegion = "sidenav" | "secondary" | "side";
+
+declare interface WorkbenchShellPlacementContribution extends WorkbenchPlacementPresentation {
+    readonly id: string;
+    readonly item: WorkbenchOwnedPlacementItem;
+    readonly region: WorkbenchRegion;
+    readonly order?: number;
+}
+
+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;
+}
 
 declare interface WorkbenchShellRegionState {
     open: boolean;
@@ -2602,6 +3261,7 @@ declare interface WorkbenchShellRegionState {
 declare type WorkbenchSidePanelChangeListener = (mode: WorkbenchSidePanelMode) => void;
 
 declare interface WorkbenchSidePanelController {
+    canFloat(): boolean;
     store: WorkbenchStore<WorkbenchSidePanelState>;
     getMode(): WorkbenchSidePanelMode;
     setMode(mode: WorkbenchSidePanelMode): void;
@@ -2620,6 +3280,52 @@ declare interface WorkbenchSnapshot {
     layout: WorkbenchLayout;
 }
 
+declare interface WorkbenchStatusBarItem {
+    id: string;
+    viewId: string;
+    slot: WorkbenchStatusBarSlot;
+    order?: number;
+    isVisible?(): boolean;
+}
+
+declare interface WorkbenchStatusBarRegistry {
+    store: WorkbenchStore<WorkbenchStatusBarRegistryState>;
+    registerItem(item: WorkbenchStatusBarItem): Disposable_2;
+    getItem(id: string): WorkbenchStatusBarItem | undefined;
+    listItems(): WorkbenchStatusBarItem[];
+    listVisibleItems(slot?: WorkbenchStatusBarSlot): WorkbenchStatusBarItem[];
+}
+
+declare interface WorkbenchStatusBarRegistryState {
+    items: Record<string, WorkbenchStatusBarItem>;
+}
+
+declare type WorkbenchStatusBarSlot = "leading" | "trailing";
+
+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[]>;
+}
+
+declare interface WorkbenchStatusRegistryState {
+    statusSets: Record<string, RegisteredWorkbenchStatusSet>;
+    values: Record<string, readonly WorkflowStatus[]>;
+}
+
+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;
@@ -2636,15 +3342,26 @@ 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;
+declare type WorkbenchTabAction = ({
+    kind: "command";
+} & WorkbenchCommandTarget) | {
+    kind: "navigation";
+    target: NavigationTarget;
+};
 
-declare interface WorkbenchSubPanelRef {
-    contributionId: string;
-    resourceUri?: string;
-    instanceKey?: string;
+declare interface WorkbenchTabMenuGroup {
+    id: string;
+    rows: readonly WorkbenchTabMenuRow[];
+}
+
+declare interface WorkbenchTabMenuRow {
+    id: string;
+    label: string;
+    icon?: string;
+    iconColor?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    action?: WorkbenchTabAction;
 }
 
 declare type WorkbenchTabPosition = "start" | "end" | {
@@ -2655,7 +3372,16 @@ declare type WorkbenchTabPosition = "start" | "end" | {
 
 declare type WorkbenchTabRetention = "preview" | "persistent";
 
-declare type WorkbenchTabRetention_2 = "preview" | "persistent";
+declare interface WorkbenchTabSnapshot {
+    label?: string;
+    icon?: string;
+    indicator?: {
+        icon: string;
+        color?: string;
+        label?: string;
+    };
+    menu?: readonly WorkbenchTabMenuGroup[];
+}
 
 declare interface WorkbenchTerminalController {
     store: WorkbenchStore<WorkbenchTerminalState>;
@@ -2664,6 +3390,7 @@ 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<{
@@ -2682,6 +3409,7 @@ 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[];
@@ -2743,14 +3471,68 @@ declare interface WorkbenchThemeStoreState {
     themes: readonly ThemePreferenceOption[];
 }
 
+declare type WorkbenchTreeViews = Pick<TreeRendererRegistry, "getTreeState" | "setNodeExpanded" | "setSectionExpanded" | "setSelectedNode">;
+
+declare type WorkbenchViewBody = WorkbenchReactViewBody | NativeViewBody<"tree", TreeRendererContribution> | NativeViewBody<"file", FileRendererContribution> | NativeViewBody<"controls", ControlsRendererContribution> | NativeViewBody<"kanban", KanbanRendererContribution> | NativeViewBody<"dataTable", DataTableRendererContribution>;
+
+declare interface WorkbenchViewContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    body: WorkbenchViewBody;
+}
+
+declare interface WorkbenchViewHierarchyNode {
+    type: "view";
+    viewId: string;
+    label?: string;
+    icon?: string;
+}
+
+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;
+}
+
+declare interface WorkbenchViewMenuRegistry {
+    registerViewMenu(menu: WorkbenchViewMenuContribution): Disposable_2;
+    getViewMenu(id: string): WorkbenchViewMenuContribution | undefined;
+    listViewMenus(ownerViewId?: string): WorkbenchViewMenuContribution[];
+    definitionsFor(ownerViewId: string, placementId: string): readonly WorkbenchPanelMenuDefinition[];
+}
+
+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;
+}
+
+declare interface WorkbenchViewRegistryStoreState {
+    views: Record<string, RegisteredWorkbenchView>;
+}
+
 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;
@@ -2764,15 +3546,27 @@ 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;
+    getSnapshot(instance: WorkbenchPanelInstance): WorkbenchTabSnapshot;
+    subscribe?(listener: () => void): {
+        dispose(): void;
+    } | (() => void);
+    refreshEvents?: readonly string[];
 }
 
-declare interface WorkbenchWidgetTab_2 {
-    contentRendererId?: string;
-    /** Custom actions shown when the user activates an already-active tab. */
-    customMenuRendererId?: string;
+declare interface WorkflowStatus {
+    id: string;
+    label: string;
+    color: string;
+    icon?: string | null;
+    sortOrder: number;
+    isDefault?: boolean;
+    actions?: readonly string[];
+}
+
+declare interface WorkflowStatusAction {
+    id: string;
+    label: string;
+    icon?: string;
 }
 
 export { }