@pstdio/workbench 0.1.0

package/dist/extensions.d.ts

@@ -0,0 +1,1934 @@
+import { CommandExecuteRequest } from '@pstdio/sdk/api';
+import { ComponentType } from 'react';
+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 { JSX } from 'react/jsx-runtime';
+import { Localizable } from '@pstdio/sdk/extensions';
+import { ReactNode } from 'react';
+import { ThemePreference as ThemePreference_2 } from 'pstdio-extensions/bridge/contract';
+import { WorkbenchExtensionCommandPaletteResourceRecord } from '@pstdio/sdk/api';
+import { WorkbenchExtensionControlsRendererRecord } from '@pstdio/sdk/api';
+import { WorkbenchExtensionDataRendererRecord } from '@pstdio/sdk/api';
+import { WorkbenchExtensionMetadata } from '@pstdio/sdk/api';
+
+declare interface AttributeDescriptor {
+    id: string;
+    label: string;
+    type: AttributeType;
+    filterable?: boolean;
+    groupable?: boolean;
+    sortable?: boolean;
+    displayable?: boolean;
+    editable?: boolean;
+    display?: AttributeDisplayDescriptor;
+    render?: (value: unknown, row: DataRendererRow) => ReactNode;
+    compare?: (a: unknown, b: unknown) => number;
+}
+
+declare type AttributeDisplayDescriptor = {
+    kind: "workspace-badge";
+    itemsAttributeId: string;
+};
+
+/**
+ * Reactive source for an entire attribute schema. Lets a contribution
+ * add/remove/edit attributes at runtime without re-registering.
+ */
+declare interface AttributesSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => AttributeDescriptor[];
+}
+
+declare type AttributeType = {
+    kind: "enum";
+    options: EnumOptions;
+} | {
+    kind: "enum-multi";
+    options: EnumOptions;
+} | {
+    kind: "string";
+} | {
+    kind: "date";
+} | {
+    kind: "number";
+} | {
+    kind: "user";
+};
+
+declare interface BoardColumnAction {
+    id: string;
+    label: string;
+    icon: ComponentType<{
+        size?: number | string;
+    }>;
+}
+
+/** Board-column behavior and menu configuration for a resolved column group. */
+declare interface BoardColumnConfig {
+    /** Color palette token used for the column header and group badges. */
+    color?: string;
+    canDragIn?: boolean;
+    canDragOut?: boolean;
+    canCreate?: boolean;
+    actions?: BoardColumnAction[];
+}
+
+export declare const BRIDGE_WEBVIEW_RENDERER_ID = "webview:bridge";
+
+export declare interface BridgeWebviewConfig {
+    title?: string;
+    runtimeUrl: string;
+    moduleUrl: string;
+    styles?: string[];
+    capabilities?: string[];
+}
+
+export declare interface BridgeWebviewRenderContext {
+    workbench: WorkbenchCore;
+    webviewId: string;
+    placement: WorkbenchWidgetPlacement;
+    /** Channel for pushing host events (e.g. terminal output) into this webview. */
+    hostEvents: HostEventPublisher;
+}
+
+export declare const buildWorkbenchExtensionCommandPaletteRegistrations: (input: {
+    metadata: WorkbenchExtensionMetadata;
+    createCommandId?: (contribution: ExtensionCommandPaletteContribution) => string;
+    resolveString?: WorkbenchExtensionStringResolver;
+}) => WorkbenchExtensionCommandPaletteRegistration[];
+
+export declare const buildWorkbenchExtensionMenuRegistrations: (input: {
+    metadata: WorkbenchExtensionMetadata;
+    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;
+}) => {
+    resource: ResourceRef;
+}[];
+
+/**
+ * A data-driven list of items, each opening a contributor-supplied editor. The
+ * framework knows nothing about what an item is — it only calls these hooks.
+ */
+declare interface CollectionSettingsPanel<TItem = unknown> extends SettingsPanelBase {
+    kind: "collection";
+    items(): TItem[] | Promise<TItem[]>;
+    itemId(item: TItem): string;
+    itemLabel(item: TItem): string;
+    itemIcon?(item: TItem): string | undefined;
+    groupBy?: SettingsCollectionGroupBy<TItem>;
+    renderItem(item: TItem, input: WorkbenchWidgetRenderInput): unknown;
+    actions?: SettingsAction[];
+}
+
+declare interface Command {
+    id: string;
+    label: string;
+    category?: string;
+    description?: string;
+    icon?: string;
+    when?: string;
+    params?: CommandParamSchema;
+}
+
+declare interface CommandHandler<TArgs = unknown, TResult = unknown> {
+    execute(args: TArgs, context?: WorkbenchCommandExecutionContext): TResult | Promise<TResult>;
+    isEnabled?(args: TArgs): boolean;
+    isVisible?(args: TArgs): boolean;
+    isToggled?(args: TArgs): boolean;
+}
+
+declare interface CommandPaletteResourceProvider {
+    id: string;
+    title: string;
+    refreshEventIds?: string[];
+    query(context: CommandPaletteResourceQueryContext): Promise<readonly CommandPaletteResourceResult[]>;
+}
+
+declare interface CommandPaletteResourceProviderResult {
+    providerId: string;
+    title: string;
+    results: readonly CommandPaletteResourceResult[];
+}
+
+declare interface CommandPaletteResourceQueryContext {
+    query: string;
+    limit: number;
+}
+
+declare interface CommandPaletteResourceRegistry {
+    store: WorkbenchStore<CommandPaletteResourceRegistryStoreState>;
+    registerProvider(provider: CommandPaletteResourceProvider): Disposable_2;
+    listProviders(): CommandPaletteResourceProvider[];
+    queryProviders(context: CommandPaletteResourceQueryContext): Promise<CommandPaletteResourceProviderResult[]>;
+    refresh(): void;
+}
+
+declare interface CommandPaletteResourceRegistryStoreState {
+    providers: Record<string, CommandPaletteResourceProvider>;
+    refreshToken: number;
+}
+
+declare interface CommandPaletteResourceResult {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    keywords?: string[];
+    group?: string;
+    activate(): void | Promise<void>;
+}
+
+declare interface CommandParamDescriptor {
+    type: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: unknown;
+    options?: CommandParamOption[];
+    templateType?: string;
+    resourceType?: string;
+    metadata?: Record<string, unknown>;
+}
+
+declare interface CommandParamOption {
+    label: string;
+    value: string;
+}
+
+declare type CommandParamSchema = Record<string, CommandParamDescriptor>;
+
+declare interface CommandRegistry {
+    store: WorkbenchStore<CommandRegistryStoreState>;
+    registerCommand<TArgs = unknown, TResult = unknown>(command: Command, handler: CommandHandler<TArgs, TResult>, metadata?: ContributionMetadata): Disposable_2;
+    getCommand(id: string): RegisteredCommand | undefined;
+    listCommands(): RegisteredCommand[];
+    isCommandEnabled(id: string, args?: unknown): boolean;
+    isCommandVisible(id: string, args?: unknown): boolean;
+    isCommandToggled(id: string, args?: unknown): boolean;
+    executeCommand(id: string, args?: unknown, context?: WorkbenchCommandExecutionContext): Promise<unknown>;
+    onDidExecuteError(listener: WorkbenchCommandExecutionErrorListener): Disposable_2;
+}
+
+declare interface CommandRegistryStoreState {
+    commands: Record<string, RegisteredCommand>;
+}
+
+declare interface ContextKeyScope extends Disposable_2 {
+    ownerId: string;
+    set(key: string, value: ContextKeyValue): void;
+    get(key: string): ContextKeyValue;
+    delete(key: string): void;
+}
+
+declare interface ContextKeyService {
+    store: WorkbenchStore<ContextKeyStoreState>;
+    set(key: string, value: ContextKeyValue): void;
+    get(key: string): ContextKeyValue;
+    delete(key: string): void;
+    createScope(ownerId: string): ContextKeyScope;
+    deleteOwner(ownerId: string): void;
+    snapshot(): Record<string, ContextKeyValue>;
+    matches(expression?: string): boolean;
+}
+
+declare interface ContextKeyStoreState {
+    values: Record<string, ContextKeyValue>;
+}
+
+declare type ContextKeyValue = boolean | number | string | undefined;
+
+declare interface ContributionMetadata {
+    source?: ContributionSource;
+    ownerId?: string;
+    priority?: number;
+}
+
+declare type ContributionSource = "module" | "extension";
+
+declare type ContributionSource_2 = "module" | "extension";
+
+declare interface ControlsApplyInput {
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
+}
+
+declare interface ControlsQueryResult {
+    params?: unknown[];
+    groups?: unknown[];
+    values?: Record<string, unknown>;
+    readOnly?: boolean;
+}
+
+declare type ControlsRendererArea = "main-right" | "secondary" | "overlay";
+
+declare interface ControlsRendererContribution {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    layout?: ControlsRendererLayout;
+    defaultValues?: Record<string, unknown>;
+    /** 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. */
+    updateValue?(input: ControlsUpdateValueInput): Promise<void> | void;
+    /** Commit the full value map from a sticky footer. */
+    apply?(input: ControlsApplyInput): Promise<void> | void;
+    /** Reset some or all controls to their defaults. */
+    reset?(input: ControlsResetInput): Promise<void> | void;
+    subscribe?: (listener: () => void) => Disposable_2 | (() => void);
+}
+
+declare type ControlsRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    controlsRendererId: string;
+}) => unknown;
+
+declare interface ControlsRendererLayout {
+    area?: ControlsRendererArea;
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface ControlsRendererRefreshEvent {
+    controlsRendererId: string;
+}
+
+declare type ControlsRendererRefreshListener = (event: ControlsRendererRefreshEvent) => void;
+
+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;
+}
+
+declare interface ControlsUpdateValueInput {
+    controlId: string;
+    value: unknown;
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
+}
+
+declare type ControlsViewRecord = WorkbenchExtensionMetadata["views"][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: WorkbenchWidgetRenderInput) => JSX.Element | null;
+};
+
+declare interface CreateBridgeWebviewRendererInput {
+    createHostCapabilities?: CreateBridgeWebviewHostCapabilities;
+    createProps?: CreateBridgeWebviewProps;
+    createTheme?: CreateBridgeWebviewTheme;
+}
+
+export declare type CreateBridgeWebviewTheme = (context: BridgeWebviewRenderContext) => ThemePreference_2;
+
+/**
+ * Host side of the `terminal.session` webview capability. Sessions live in the
+ * workbench terminal controller; only serializable operation payloads and session
+ * ids cross the webview boundary. Output/exit events flow through the host event
+ * publisher under the `terminal.session` scope.
+ */
+export declare const createTerminalSessionCapability: (input: CreateTerminalSessionCapabilityInput) => HostCapability;
+
+declare interface CreateTerminalSessionCapabilityInput {
+    terminal: WorkbenchTerminalController;
+    hostEvents: HostEventPublisher;
+}
+
+export declare const createWorkbenchWebviewHostCapabilities: (input: CreateWorkbenchWebviewHostCapabilitiesInput) => {
+    "terminal.session"?: HostCapability | undefined;
+    "commands.execute": (params: unknown) => Promise<unknown>;
+    "resource.open": (params: unknown) => Promise<unknown>;
+    "notification.show": (params: unknown) => RegisteredWorkbenchNotification_2;
+    "preferences.get": (params: unknown) => PreferenceValue | undefined;
+    "preferences.set": (params: unknown) => {
+        name: string;
+        value: PreferenceValue;
+    };
+    "host.dispatchKeyboardEvent": (params: unknown) => void;
+};
+
+declare interface CreateWorkbenchWebviewHostCapabilitiesInput {
+    dispatchKeyboardEvent?: (event: KeyboardEventInit) => void;
+    workbench: WorkbenchCore;
+    /** 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: WorkbenchWidgetRenderInput): unknown;
+}
+
+declare interface DataRendererContribution<TRow extends DataRendererRow = DataRendererRow> {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    /**
+     * Declarative attribute schema. The renderer dispatches filter / group /
+     * sort / display / inline-edit behavior on each descriptor's `type.kind`.
+     *
+     * Pass an `AttributesSource` ({ subscribe, getSnapshot }) instead of a
+     * static array to let the contribution mutate its schema at runtime —
+     * `WorkbenchDataView` subscribes so additions / removals / kind changes
+     * propagate live without re-registering the renderer.
+     */
+    attributes: AttributeDescriptor[] | AttributesSource;
+    /** Per-board-column overrides (color, drag/create rules, custom actions). */
+    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
+    hideToolbar?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Initial settings/filters applied when the data renderer mounts. */
+    defaultSettings?: Partial<DataRendererSettings>;
+    defaultFilters?: DataRendererFilterState;
+    /**
+     * Data source. Receives the current display state so backends can paginate
+     * / filter / sort. The renderer re-applies filter / sort / group locally,
+     * so this can return unfiltered rows in simple cases.
+     */
+    executeQuery(state: DataRendererQueryState): Promise<TRow[]> | TRow[];
+    subscribe?: (listener: () => void) => Disposable_2 | (() => void);
+    /** Row interactions surfaced by the renderer (mirrored from <DataRenderer>). */
+    onRowClick?: (row: TRow) => void;
+    /** Per-row right-click context menu actions (mirrored from <DataRenderer>). */
+    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
+    /**
+     * Fires for inline attribute edits AND for cross-column drag-to-reorder on
+     * the board (the renderer passes the grouping attribute id + the target
+     * column value).
+     */
+    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
+    /** Manual within-column reorder (only fires when ordering is manual). */
+    onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
+    onCreateRow?: (columnId: string) => void;
+    onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
+}
+
+declare type DataRendererFilterState = Record<string, string[]>;
+
+declare type DataRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    dataRendererId: string;
+}) => unknown;
+
+declare interface DataRendererOrdering {
+    attributeId: string | typeof MANUAL_ORDERING;
+    direction: SortDirection;
+}
+
+declare interface DataRendererQueryState {
+    settings: DataRendererSettings;
+    filters: DataRendererFilterState;
+}
+
+declare interface DataRendererRefreshEvent {
+    dataRendererId: string;
+}
+
+declare type DataRendererRefreshListener = (event: DataRendererRefreshEvent) => void;
+
+declare interface DataRendererRegistry {
+    dataStore: WorkbenchStore<DataRendererStoreState>;
+    registerDataRenderer<TRow extends DataRendererRow = DataRendererRow>(contribution: DataRendererContribution<TRow>, metadata?: ContributionMetadata): Disposable_2;
+    setDataRendererImplementation(impl: DataRendererImplementation): void;
+    getDataRenderer(id: string): RegisteredDataRendererContribution | undefined;
+    listDataRenderers(): RegisteredDataRendererContribution[];
+    refreshDataRenderer(id: string): void;
+    onDidRefreshDataRenderer(listener: DataRendererRefreshListener): Disposable_2;
+}
+
+declare interface DataRendererRow {
+    id: string;
+    title: string;
+    /**
+     * Optional navigation handle. When set, the renderer's default click handler
+     * routes through the contribution's onRowClick (which typically opens the
+     * resource via the workbench).
+     */
+    resource?: unknown;
+    attributes: Record<string, unknown>;
+}
+
+declare type DataRendererRow_2 = Awaited<ReturnType<DataRendererContribution["executeQuery"]>>[number];
+
+declare interface DataRendererSettings {
+    viewMode: ViewMode;
+    columnGrouping: string | typeof NO_GROUPING;
+    rowGrouping: string | typeof NO_GROUPING;
+    ordering: DataRendererOrdering;
+    displayProperties: string[];
+}
+
+declare interface DataRendererStoreState {
+    renderers: Record<string, RegisteredDataRendererContribution>;
+}
+
+declare interface Disposable_2 {
+    dispose(): void;
+}
+
+export declare const emptyWorkbenchExtensionMetadata: {
+    commands: never[];
+    commandPaletteContributions: never[];
+    diagnostics: never[];
+    extensions: never[];
+    menuContributions: never[];
+    modes: never[];
+    navigation: never[];
+    routes: never[];
+    dataRenderers: never[];
+    treeRenderers: never[];
+    fileRenderers: never[];
+    settingsPanels: never[];
+    settingsDefinitions: never[];
+    treeItems: never[];
+    views: never[];
+};
+
+declare interface EnumOption {
+    value: string;
+    label: string;
+    color?: string;
+    icon?: string | null;
+}
+
+declare type EnumOptions = EnumOption[] | EnumOptionsSource;
+
+/**
+ * Reactive options source for enum / enum-multi attributes. Mirrors React's
+ * useSyncExternalStore contract so a contribution can hand its options off as
+ * a live collection instead of a frozen array.
+ */
+declare interface EnumOptionsSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => EnumOption[];
+}
+
+declare type ExtensionTreeRendererRecord = NonNullable<WorkbenchExtensionMetadata["treeRenderers"]>[number];
+
+declare type ExtensionTreeViewRecord = WorkbenchExtensionMetadata["views"][number];
+
+export declare interface ExtensionWebviewFileCapabilities {
+    delete(params: unknown): Promise<unknown> | unknown;
+    list(params: unknown): Promise<unknown> | unknown;
+    upload(params: unknown): Promise<unknown> | unknown;
+}
+
+/**
+ * Core-owned contract for file icon theme registrations. Structurally identical
+ * to @pstdio/ui's FileIconThemePreferenceOption; the React layer bridges the two
+ * so core does not depend on UI package ownership.
+ */
+declare interface FileIconThemeFont {
+    fontFamily: string;
+    src: {
+        url: string;
+        format?: string;
+    }[];
+    weight?: string;
+    style?: string;
+}
+
+declare interface FileIconThemePreferenceOption {
+    id: string;
+    title?: string;
+    definitions: Record<string, unknown>;
+    fileExtensions: Record<string, string>;
+    fileNames: Record<string, string>;
+    defaults: {
+        file?: string;
+        folder?: string;
+    };
+    fonts: FileIconThemeFont[];
+}
+
+declare interface FileIconThemeRegistry {
+    store: WorkbenchStore<WorkbenchFileIconThemeStoreState>;
+    register(themes: readonly FileIconThemePreferenceOption[]): Disposable_2;
+    listThemes(): readonly FileIconThemePreferenceOption[];
+}
+
+declare interface FileRendererContent {
+    fileName?: string;
+    mimeType?: string;
+    content?: string;
+    dataUrl?: string;
+    placeholder?: string;
+}
+
+declare interface FileRendererContribution {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    /** Resolve the file's content (and identity) for the bound resource. */
+    load(resource: ResourceRef | undefined): Promise<FileRendererContent> | FileRendererContent;
+    /** Persist edited text. Absent ⇒ read-only. Never called for images. */
+    save?(resource: ResourceRef | undefined, content: string): Promise<void> | void;
+}
+
+declare type FileRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    fileRendererId: string;
+}) => unknown;
+
+declare interface FileRendererRefreshEvent {
+    fileRendererId: string;
+}
+
+declare type FileRendererRefreshListener = (event: FileRendererRefreshEvent) => void;
+
+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): void;
+    onDidRefreshFileRenderer(listener: FileRendererRefreshListener): Disposable_2;
+}
+
+declare interface FileRendererStoreState {
+    renderers: Record<string, RegisteredFileRendererContribution>;
+}
+
+declare interface HistoryController {
+    store: WorkbenchStore<HistoryStoreState>;
+    goBack(): HistoryEntry | undefined;
+    goForward(): HistoryEntry | undefined;
+    goPrevious(): HistoryEntry | undefined;
+    recentlyClosed(): readonly HistoryEntry[];
+    reopenLastClosed(): HistoryEntry | undefined;
+    clear(): void;
+}
+
+declare interface HistoryEntry {
+    entryId: string;
+    recordedAt: number;
+    kind: "resource" | "widget" | "mode";
+    modeId?: string;
+    resource?: ResourceRef;
+    widgetId?: string;
+    contributionId?: string;
+    title?: string;
+}
+
+declare interface HistoryStoreState {
+    entries: readonly HistoryEntry[];
+    cursor: number;
+    recentlyClosed: readonly HistoryEntry[];
+}
+
+declare interface HostTreeDefaultNodesInput {
+    ctx: TreeContext;
+    record: ExtensionTreeRendererRecord;
+    view: ExtensionTreeViewRecord;
+}
+
+declare type HostTreeDefaultNodesResolver = (input: HostTreeDefaultNodesInput) => Promise<TreeNode[]> | TreeNode[];
+
+declare interface Keybinding {
+    commandId: string;
+    keybinding: KeybindingSequence;
+    when?: string;
+    args?: unknown;
+}
+
+declare interface KeybindingRegistry {
+    store: WorkbenchStore<KeybindingRegistryStoreState>;
+    registerKeybinding(keybinding: Keybinding, metadata?: ContributionMetadata): Disposable_2;
+    listKeybindings(): RegisteredKeybinding[];
+    listActiveKeybindings(): RegisteredKeybinding[];
+}
+
+declare interface KeybindingRegistryStoreState {
+    keybindings: RegisteredKeybinding[];
+}
+
+declare type KeybindingSequence = string | string[];
+
+declare interface LayoutModel {
+    store: WorkbenchStore<WorkbenchLayoutStoreState>;
+    registerPlaceholder(placeholder: PlaceholderContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    registerWidget(widget: WidgetContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    unregisterWidget(id: string, options?: {
+        removePlacements?: boolean;
+        persist?: boolean;
+    }): void;
+    getPlaceholder(areaId: WorkbenchArea): RegisteredPlaceholderContribution | undefined;
+    getWidget(id: string): RegisteredWidgetContribution | undefined;
+    getAreaSize(areaId: WorkbenchArea): WorkbenchAreaSize | undefined;
+    getAreaCollapsible(areaId: WorkbenchArea): boolean;
+    getAreaHeaderBorderBottom(areaId: WorkbenchArea): boolean;
+    setAreaVisible(areaId: WorkbenchArea, visible: boolean): void;
+    setAreaSize(areaId: WorkbenchArea, size: number): void;
+    listPlaceholders(): RegisteredPlaceholderContribution[];
+    listWidgets(): RegisteredWidgetContribution[];
+    openWidget(id: string, input?: OpenWidgetInput): WorkbenchWidgetPlacement;
+    updateWidgetPlacement(widgetId: string, input: OpenWidgetInput): WorkbenchWidgetPlacement;
+    activateWidget(widgetId: string): WorkbenchWidgetPlacement;
+    closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
+    removeWidgetPlacement(widgetId: string): WorkbenchWidgetPlacement | undefined;
+    clearArea(areaId: WorkbenchArea): void;
+    resetAreas(): void;
+    getLayout(): WorkbenchLayout;
+    restoreLayout(layout: WorkbenchLayout): void;
+    setPersistenceScope(scope: LayoutScope | undefined): void;
+    getPersistenceScope(): LayoutScope | undefined;
+    onDidChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+        dispose(): void;
+    };
+}
+
+declare type LayoutScope = string;
+
+declare type Localizer = (value: unknown, fallback?: string) => string;
+
+declare const MANUAL_ORDERING = "manual";
+
+declare interface MenuItem {
+    commandId: string;
+    label?: string;
+    description?: string;
+    icon?: string;
+    iconSrc?: string;
+    overflowLabel?: string;
+    when?: string;
+    group?: string;
+    order?: number;
+    args?: unknown;
+    readOnly?: boolean;
+    /** Marks a menu action that navigates outside the app, rendered with a trailing external-link icon. */
+    external?: boolean;
+}
+
+declare type MenuPath = readonly string[];
+
+declare interface MenuRegistry {
+    menuStore: WorkbenchStore<MenuRegistryStoreState>;
+    registerMenuItem(path: MenuPath, item: MenuItem, metadata?: ContributionMetadata): Disposable_2;
+    listMenuItems(path: MenuPath): RegisteredMenuItem[];
+}
+
+declare interface MenuRegistryStoreState {
+    itemsByPath: Record<string, RegisteredMenuItem[]>;
+}
+
+declare interface NavigationParser {
+    id: string;
+    priority?: number;
+    canParse(location: string): boolean;
+    parse(location: string): NavigationTarget;
+}
+
+declare interface NavigationRegistry {
+    store: WorkbenchStore<NavigationRegistryStoreState>;
+    registerParser(parser: NavigationParser, metadata?: ContributionMetadata): Disposable_2;
+    listParsers(): RegisteredNavigationParser[];
+    resolveLocation(location: string): NavigationTarget;
+    openTarget(target: NavigationTarget): 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;
+
+declare interface NavigationTargetCommand {
+    kind: "command";
+    commandId: string;
+    args?: unknown;
+}
+
+declare interface NavigationTargetCompound {
+    kind: "compound";
+    targets: readonly NavigationTargetItem[];
+}
+
+declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetView | NavigationTargetCommand;
+
+declare interface NavigationTargetResource {
+    kind: "resource";
+    resource: ResourceRef;
+    input?: OpenResourceInput;
+}
+
+declare interface NavigationTargetView {
+    kind: "view";
+    widgetId: string;
+    input?: OpenWidgetInput;
+}
+
+declare const NO_GROUPING = "none";
+
+declare interface NotificationRegistry {
+    store: WorkbenchStore<WorkbenchNotificationStoreState>;
+    show(notification: WorkbenchNotification, metadata?: ContributionMetadata): RegisteredWorkbenchNotification;
+    dismiss(id: string): boolean;
+    clear(): void;
+    listNotifications(): RegisteredWorkbenchNotification[];
+    subscribe(listener: WorkbenchNotificationListener): Disposable_2;
+}
+
+declare interface OpenResourceInput {
+    replaceActive?: boolean;
+}
+
+declare interface OpenWidgetInput {
+    resource?: ResourceRef;
+    title?: string;
+    area?: WorkbenchArea;
+    ownerId?: string;
+    source?: ContributionSource;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+    replaceActive?: boolean;
+}
+
+declare interface PlaceholderContribution {
+    id: string;
+    title: string;
+    area: WorkbenchArea;
+    rendererId: string;
+    areaSize?: WorkbenchAreaSize;
+    areaCollapsible?: boolean;
+    config?: unknown;
+    priority?: number;
+}
+
+declare interface PreferencePropertySchema {
+    type: "boolean" | "number" | "string" | "array" | "object";
+    enum?: PreferenceValue[];
+    default?: PreferenceValue;
+    scope: PreferenceScope;
+    description?: string;
+}
+
+declare interface PreferenceRegistry {
+    store: WorkbenchStore<PreferenceRegistryStoreState>;
+    registerSchema(schema: PreferenceSchemaContribution, metadata?: ContributionMetadata): Disposable_2;
+    getSchema(name: string): RegisteredPreferenceSchema | undefined;
+    setValue(name: string, value: PreferenceValue, scope: PreferenceScopeRef): void;
+    getValue(name: string, scope?: PreferenceScopeRef): PreferenceValue | undefined;
+}
+
+declare interface PreferenceRegistryStoreState {
+    schemas: Record<string, RegisteredPreferenceSchema>;
+}
+
+declare interface PreferenceSchemaContribution {
+    properties: Record<string, PreferencePropertySchema>;
+}
+
+declare type PreferenceScope = "default" | "user" | "project" | "repo" | "workspace" | "extension" | "session";
+
+declare interface PreferenceScopeRef {
+    scope: PreferenceScope;
+    scopeId?: string;
+}
+
+declare type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
+
+export declare const refreshOpenWorkbenchExtensionWebviews: (workbench: WorkbenchModuleContributionContext, metadata: WorkbenchExtensionMetadata) => void;
+
+export declare const refreshWorkbenchExtensionContributions: (workbench: WorkbenchModuleContributionContext, metadata: WorkbenchExtensionMetadata, commandId: string) => void;
+
+declare interface RegisteredCommand extends RegisteredContributionMetadata {
+    command: Command;
+    handler: CommandHandler;
+}
+
+declare interface RegisteredContributionMetadata {
+    source: ContributionSource;
+    ownerId: string;
+    priority: number;
+}
+
+declare interface RegisteredContributionMetadata_2 {
+    source: ContributionSource_2;
+    ownerId: string;
+    priority: number;
+}
+
+declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredDataRendererContribution<TRow extends DataRendererRow = DataRendererRow> extends DataRendererContribution<TRow>, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredFileRendererContribution extends FileRendererContribution, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredKeepAliveHost {
+    rendererId: string;
+    host: HTMLElement;
+    attachedTo?: HTMLElement;
+}
+
+declare interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredMenuItem extends MenuItem, RegisteredContributionMetadata {
+    path: MenuPath;
+}
+
+declare type RegisteredNavigationParser = Omit<NavigationParser, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredPlaceholderContribution = Omit<PlaceholderContribution, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredPreferenceSchema = PreferencePropertySchema & {
+    ownerId: string;
+    source: string;
+};
+
+declare interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {
+}
+
+declare type RegisteredResourceNavigator = Omit<ResourceNavigator, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
+
+declare type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
+
+declare interface RegisteredTreeRendererContribution extends TreeRendererContribution, RegisteredContributionMetadata {
+}
+
+declare type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+    singleton: boolean;
+    reuse: WidgetReusePolicy;
+} & RegisteredContributionMetadata;
+
+declare interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
+    id: string;
+    level: WorkbenchNotificationLevel;
+    title: string;
+    message?: string;
+    createdAt: string;
+    resource?: ResourceRef;
+    actions?: WorkbenchNotificationAction[];
+    metadata?: Record<string, unknown>;
+}
+
+declare interface RegisteredWorkbenchNotification_2 extends RegisteredContributionMetadata_2 {
+    id: string;
+    level: WorkbenchNotificationLevel_2;
+    title: string;
+    message?: string;
+    createdAt: string;
+    resource?: ResourceRef_2;
+    actions?: WorkbenchNotificationAction_2[];
+    metadata?: Record<string, unknown>;
+}
+
+export declare const registerWorkbenchExtensionCommandPaletteResources: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionCommandPaletteResourceRecord[]) => {
+    dispose(): void;
+};
+
+export declare const registerWorkbenchExtensionContributions: (input: RegisterWorkbenchExtensionContributionsInput) => {
+    dispose(): void;
+};
+
+export declare interface RegisterWorkbenchExtensionContributionsInput {
+    createMenuWhenExpression?: WorkbenchExtensionMenuWhenBuilder;
+    createWebviewHostCapabilities?: CreateBridgeWebviewHostCapabilities;
+    createWebviewHostCapabilityOverrides?: CreateBridgeWebviewHostCapabilities;
+    createWebviewProps?: CreateBridgeWebviewProps;
+    createWebviewTheme?: CreateBridgeWebviewTheme;
+    executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    menuSlotsById?: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
+    menuTargetsById?: ReadonlyMap<string, WorkbenchExtensionMenuSlotConfig>;
+    metadata: WorkbenchExtensionMetadata;
+    openHref?: (href: string) => unknown;
+    projectId: string;
+    routeResourceKind?: string;
+    settingsSectionId?: string;
+    settingsSectionTitle?: string;
+    webviewFiles?: ExtensionWebviewFileCapabilities;
+    workbench: WorkbenchModuleContributionContext;
+}
+
+export declare const registerWorkbenchExtensionControlsRenderers: (context: WorkbenchExtensionCommandContext, records: WorkbenchExtensionControlsRendererRecord[], views: ControlsViewRecord[], adapter?: WorkbenchExtensionControlsAdapter) => Disposable_2;
+
+export declare const registerWorkbenchExtensionDataRenderers: (context: WorkbenchExtensionCommandContext, records: readonly WorkbenchExtensionDataRendererRecord[], adapter?: WorkbenchExtensionDataRendererAdapter) => {
+    dispose(): void;
+};
+
+export declare const registerWorkbenchExtensionFileRenderers: (input: RegisterWorkbenchExtensionFileRenderersInput) => {
+    dispose(): void;
+};
+
+export declare interface RegisterWorkbenchExtensionFileRenderersInput {
+    executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    metadata: WorkbenchExtensionMetadata;
+    projectId: string;
+    workbench: WorkbenchModuleContributionContext;
+}
+
+export declare const registerWorkbenchExtensionTreeRenderers: (input: RegisterWorkbenchExtensionTreeRenderersInput) => {
+    dispose(): void;
+};
+
+export declare interface RegisterWorkbenchExtensionTreeRenderersInput {
+    executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    getHostTreeFooterNodes?: HostTreeDefaultNodesResolver;
+    getHostTreeHeaderNodes?: HostTreeDefaultNodesResolver;
+    metadata: WorkbenchExtensionMetadata;
+    projectId: string;
+    workbench: WorkbenchModuleContributionContext;
+}
+
+export declare const renderBridgeWebviewFrame: (input: {
+    context: BridgeWebviewRenderContext;
+    createHostCapabilities: CreateBridgeWebviewHostCapabilities;
+    createProps: CreateBridgeWebviewProps;
+    createTheme?: CreateBridgeWebviewTheme;
+    ownerId?: string;
+    title: string;
+    webview: BridgeWebviewConfig;
+}) => JSX.Element;
+
+declare type ResolvedResourceOpener = Required<ResourceOpener>;
+
+declare interface ResourceBrowseEntry {
+    resource: ResourceRef;
+    searchText?: string;
+    description?: string;
+    group?: string;
+    order?: number;
+    activate?: (resource: ResourceRef) => unknown | Promise<unknown>;
+}
+
+/** Row-level context menu action surfaced by the renderer. */
+declare interface ResourceContextAction {
+    key: string;
+    label: string;
+    onClick: () => Promise<void> | void;
+    isDisabled?: boolean;
+    icon?: ReactNode;
+    endContent?: ReactNode;
+    separatorBefore?: boolean;
+}
+
+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 ResourceOpener<TResult = unknown> {
+    id: string;
+    priority?: number;
+    canOpen(resource: ResourceRef): boolean;
+    open(resource: ResourceRef, input: OpenResourceInput): TResult | Promise<TResult>;
+}
+
+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[];
+    registerOpener(opener: ResourceOpener): Disposable_2;
+    listOpeners(): ResolvedResourceOpener[];
+    registerProvider(provider: ResourceProvider): Disposable_2;
+    listProviders(): ResourceProvider[];
+    listResources(query: string): readonly ResourceBrowseEntry[];
+    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<unknown>;
+    onDidOpenResource(listener: (resource: ResourceRef) => void): Disposable_2;
+}
+
+declare interface ResourceRegistryStoreState {
+    kinds: Record<string, RegisteredResourceKind>;
+    openers: Record<string, ResolvedResourceOpener>;
+    providers: Record<string, ResourceProvider>;
+}
+
+declare type ResourceSurface = "primary" | "secondary" | "attached";
+
+declare type RowAction = NonNullable<WorkbenchExtensionDataRendererRecord["rowActions"]>[number];
+
+/** Auto-rendered as a param editor from the registered preference schema. */
+declare interface SchemaSettingsPanel extends SettingsPanelBase {
+    kind: "schema";
+    preferences: SettingsPanelPreference[];
+    /** "live" persists on change (default); "apply" stages edits behind Save/Discard. */
+    save?: "live" | "apply";
+}
+
+/** A "+ create"-style action surfaced on a section or a collection's parent node. */
+declare interface SettingsAction {
+    id: string;
+    label: string;
+    icon?: string;
+    run(): void | Promise<void>;
+}
+
+declare interface SettingsCollectionGroupBy<TItem> {
+    key(item: TItem): string;
+    order?: string[];
+    label(key: string): string;
+    icon?(key: string): string | undefined;
+}
+
+declare interface SettingsPanelBase {
+    id: string;
+    title: string;
+    description?: string;
+    /** Section id this panel belongs to. */
+    section?: string;
+    icon?: string;
+    /** Lower sorts first; ties fall back to contribution priority then registration order. */
+    order?: number;
+    scope?: SettingsScope;
+    when?: string;
+}
+
+declare type SettingsPanelContribution = SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel;
+
+/** A preference this panel edits; a bare string uses the preference name as its label. */
+declare type SettingsPanelPreference = string | {
+    name: string;
+    label?: 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;
+    getSection(id: string): RegisteredSettingsSection | undefined;
+    getPanel(id: string): RegisteredSettingsPanel | undefined;
+    listSections(): RegisteredSettingsSection[];
+    listPanels(): RegisteredSettingsPanel[];
+    /** Signal that a collection's backing data changed so the surface refreshes. */
+    refresh(): void;
+}
+
+declare interface SettingsRegistryStoreState {
+    sections: Record<string, RegisteredSettingsSection>;
+    panels: Record<string, RegisteredSettingsPanel>;
+    /** Bumped by refresh() so the surface re-reads collection items() after backing data changes. */
+    revision: number;
+}
+
+/** Settings are stored either per-user (global) or per-project. Projectless surfaces show only global entries. */
+declare type SettingsScope = "global" | "project";
+
+/** An ordered sidebar container. Headerless when `title` is omitted. */
+declare interface SettingsSectionContribution {
+    id: string;
+    title?: string;
+    order?: number;
+    scope?: SettingsScope;
+    actions?: SettingsAction[];
+}
+
+export declare const shouldRefreshWorkbenchExtensionTrees: (metadata: WorkbenchExtensionMetadata, commandId: string) => boolean;
+
+declare type SortDirection = "asc" | "desc";
+
+/**
+ * Core-owned contract for theme registrations. Structurally identical to
+ * @pstdio/ui's ThemePreferenceOption; the React layer bridges the two so core
+ * does not depend on UI package ownership.
+ */
+declare type ThemePreference = string;
+
+declare type ThemePreferenceMode = "light" | "dark";
+
+declare interface ThemePreferenceOption {
+    id: ThemePreference;
+    title?: string;
+    mode: ThemePreferenceMode;
+    tokens?: ThemePreferenceTokens;
+    monacoTheme?: unknown;
+}
+
+declare type ThemePreferenceTokens = Record<string, string>;
+
+declare interface ThemeRegistry {
+    store: WorkbenchStore<WorkbenchThemeStoreState>;
+    register(themes: readonly ThemePreferenceOption[]): Disposable_2;
+    listThemes(): readonly ThemePreferenceOption[];
+}
+
+declare interface TreeAction {
+    id: string;
+    label?: string;
+    icon?: string;
+    commandId?: string;
+    args?: unknown;
+    params?: CommandParamSchema;
+    submitLabel?: string;
+    when?: string;
+    disabled?: boolean;
+    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 TreeNode {
+    id: string;
+    label: string;
+    icon?: string;
+    iconElement?: unknown;
+    iconColor?: string;
+    iconTooltip?: string;
+    endContent?: unknown;
+    commandId?: string;
+    resource?: ResourceRef;
+    target?: NavigationTarget;
+    /** Visual row variant for non-data rows such as placeholders. */
+    rowVariant?: TreeNodeRowVariant;
+    actions?: TreeAction[];
+    contextMenuActions?: TreeAction[];
+    contextMenuPath?: MenuPath;
+    menuPath?: MenuPath;
+    menuPlacement?: "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "left-start";
+    collapsible?: boolean;
+    disabled?: boolean;
+    children?: TreeNode[];
+    description?: string;
+    contextValue?: string;
+    hiddenByDefault?: boolean;
+    /** When true, the node (e.g. a header/footer row) opts in to the tree's hide/show customization menu. */
+    canHide?: boolean;
+}
+
+declare type TreeNodeRowVariant = "empty-state";
+
+declare interface TreeRendererContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    when?: string;
+    defaultExpandedSectionIds?: string[];
+    defaultExpandedNodeIds?: string[];
+    getBody(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
+    getHeader?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    getFooter?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    getChildren(node: TreeNode, ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+}
+
+declare type TreeRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    treeId: string;
+}) => unknown;
+
+declare interface TreeRendererRefreshEvent {
+    treeId: string;
+}
+
+declare type TreeRendererRefreshListener = (event: TreeRendererRefreshEvent) => void;
+
+declare interface TreeRendererRegistry {
+    treeStore: WorkbenchStore<TreeRendererStoreState>;
+    registerTreeRenderer(view: TreeRendererContribution, metadata?: ContributionMetadata): Disposable_2;
+    setTreeRendererImplementation(impl: TreeRendererImplementation): void;
+    getTreeRenderer(id: string): RegisteredTreeRendererContribution | undefined;
+    listTreeRenderers(): RegisteredTreeRendererContribution[];
+    getBody(id: string, ctx?: TreeContext): Promise<TreeViewSection[]>;
+    getHeader(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
+    getFooter(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
+    getChildren(id: string, node: TreeNode, ctx?: TreeContext): Promise<TreeNode[]>;
+    getTreeState(id: string): TreeRendererState;
+    setNodeExpanded(id: string, nodeId: string, expanded: boolean): void;
+    setSectionExpanded(id: string, sectionId: string, expanded: boolean): void;
+    setSelectedNode(id: string, nodeId: string | undefined): void;
+    setLoading(id: string, loading: boolean): void;
+    refresh(id: string): void;
+    onDidRefresh(listener: TreeRendererRefreshListener): Disposable_2;
+}
+
+declare interface TreeRendererState {
+    expandedNodeIds: string[];
+    expandedSectionIds: string[];
+    selectedNodeId?: string;
+    loading?: boolean;
+}
+
+declare interface TreeRendererStoreState {
+    trees: Record<string, RegisteredTreeRendererContribution>;
+    statesByTreeId: Record<string, TreeRendererState>;
+    refreshKeysByTreeId: Record<string, number>;
+}
+
+declare interface TreeSectionEmptyState {
+    title: string;
+    description?: string;
+    icon?: string;
+}
+
+declare interface TreeViewSection {
+    id: string;
+    label?: string;
+    actions?: TreeAction[];
+    collapsible?: boolean;
+    emptyState?: TreeSectionEmptyState;
+    nodes: TreeNode[];
+    hiddenByDefault?: boolean;
+    /** When true, the section (category) opts in to the tree's hide/show customization menu. */
+    canHide?: boolean;
+}
+
+/**
+ * Core-owned contracts for data renderer contributions. @pstdio/ui's
+ * DataRenderer props are structurally identical; the React layer bridges the
+ * two, so drift surfaces as a compile error there instead of coupling core's
+ * API shape to UI package ownership.
+ */
+declare type ViewMode = "board" | "list";
+
+declare interface WidgetContribution {
+    id: string;
+    title: string;
+    area: WorkbenchArea;
+    fallbackArea?: WorkbenchArea;
+    singleton?: boolean;
+    reuse?: WidgetReusePolicy;
+    mountStrategy?: WidgetMountStrategy;
+    closable?: boolean;
+    hiddenByDefault?: boolean;
+    areaSize?: WorkbenchAreaSize;
+    areaCollapsible?: boolean;
+    headerBorderBottom?: boolean;
+    resourceKinds?: string[];
+    priority?: number;
+    rendererId: string;
+    config?: unknown;
+    canOpen?(resource: ResourceRef): boolean;
+}
+
+declare type WidgetMountStrategy = "active" | "keep-mounted";
+
+declare type WidgetReusePolicy = "resource" | "none";
+
+declare type WorkbenchArea = (typeof workbenchAreas)[number];
+
+declare const workbenchAreas: readonly ["nav", "activity", "left-header", "left", "main-header", "main-left", "main", "main-right", "secondary-header", "secondary", "status", "overlay", "floating-header", "floating"];
+
+declare interface WorkbenchAreaSize {
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface WorkbenchAreaState {
+    id: WorkbenchArea;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement[];
+    activeWidgetId?: string;
+}
+
+declare type WorkbenchBreadcrumbChangeListener = () => void;
+
+declare interface WorkbenchBreadcrumbController {
+    store: WorkbenchStore<WorkbenchBreadcrumbState>;
+    setItems(items: WorkbenchBreadcrumbItem[]): Disposable_2;
+    clearItems(): void;
+    getItems(): WorkbenchBreadcrumbItem[] | undefined;
+    onDidChange(listener: WorkbenchBreadcrumbChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchBreadcrumbItem {
+    title: unknown;
+    icon?: string;
+    url?: string;
+    onClick?: () => void;
+    resource?: ResourceRef;
+}
+
+declare interface WorkbenchBreadcrumbState {
+    items: WorkbenchBreadcrumbItem[] | undefined;
+}
+
+declare interface WorkbenchCommandExecutionContext {
+    resource?: ResourceRef;
+}
+
+declare interface WorkbenchCommandExecutionError {
+    commandId: string;
+    args: unknown;
+    error: unknown;
+}
+
+declare type WorkbenchCommandExecutionErrorListener = (event: WorkbenchCommandExecutionError) => void;
+
+declare type WorkbenchCommandPaletteChangeListener = (open: boolean) => void;
+
+declare interface WorkbenchCommandPaletteController {
+    store: WorkbenchStore<WorkbenchCommandPaletteState>;
+    isOpen(): boolean;
+    getView(): WorkbenchCommandPaletteView;
+    getInitialQuery(): string;
+    getParamsRequest(): WorkbenchCommandParamsRequest | null;
+    open(input?: WorkbenchCommandPaletteOpenInput): void;
+    close(): void;
+    toggle(): void;
+    requestParams(request: WorkbenchCommandParamsRequest): void;
+    clearParams(): void;
+    onDidChange(listener: WorkbenchCommandPaletteChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchCommandPaletteOpenInput {
+    view?: WorkbenchCommandPaletteView;
+    initialQuery?: string;
+}
+
+declare interface WorkbenchCommandPaletteState {
+    open: boolean;
+    view: WorkbenchCommandPaletteView;
+    initialQuery: string;
+    paramsRequest: WorkbenchCommandParamsRequest | null;
+}
+
+declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
+
+declare interface WorkbenchCommandParamsRequest {
+    record: {
+        command: {
+            id: string;
+            label: string;
+            params?: CommandParamSchema;
+        };
+    };
+    label: string;
+    args?: unknown;
+    context?: WorkbenchCommandExecutionContext;
+}
+
+declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
+    registerModule(module: WorkbenchModuleContribution): Disposable_2;
+    unregisterModule(moduleId: string): void;
+}
+
+declare interface WorkbenchCoreContributionContext {
+    breadcrumbs: WorkbenchBreadcrumbController;
+    commandPalette: WorkbenchCommandPaletteController;
+    commandPaletteResources: CommandPaletteResourceRegistry;
+    commands: CommandRegistry;
+    context: ContextKeyService;
+    focus: WorkbenchFocusController;
+    history: HistoryController;
+    keybindings: KeybindingRegistry;
+    lastResource: WorkbenchLastResourceController;
+    layout: WorkbenchLayoutModel;
+    modes: WorkbenchModeRegistry;
+    navigation: NavigationRegistry;
+    notifications: NotificationRegistry;
+    panels: WorkbenchPanelsController;
+    preferences: PreferenceRegistry;
+    renderers: WorkbenchRenderers;
+    resources: ResourceRegistry;
+    settings: SettingsRegistry;
+    sessionPanel: WorkbenchSessionPanelController;
+    terminal: WorkbenchTerminalController;
+    themes: ThemeRegistry;
+    fileIconThemes: FileIconThemeRegistry;
+    getPrimaryResource(): ResourceRef | undefined;
+    onDidChangePrimaryResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
+    getActiveResource(): ResourceRef | undefined;
+    onDidChangeActiveResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
+}
+
+export declare interface WorkbenchExtensionCommandContext {
+    executeCommand(commandId: string, body: CommandExecuteRequest): Promise<unknown> | unknown;
+    projectId: string;
+    workbench: WorkbenchModuleContributionContext;
+}
+
+export declare interface WorkbenchExtensionCommandPaletteRegistration {
+    command: Command;
+    contribution: ExtensionCommandPaletteContribution;
+    menuItem: MenuItem;
+    targetCommandId: string;
+}
+
+export declare interface WorkbenchExtensionControlsAdapter {
+    /** Supply a fallback resource when the widget placement carries none. */
+    resolveResource?: (record: WorkbenchExtensionControlsRendererRecord) => ResourceRef | undefined;
+}
+
+export declare interface WorkbenchExtensionDataRendererAdapter {
+    /** Override label resolution. Defaults to workbench's `text(value, fallback)`. */
+    resolveLabel?: Localizer;
+    /** Post-process an attribute descriptor (after localization). Defaults to identity. */
+    decorateAttribute?: (record: WorkbenchExtensionDataRendererRecord, attribute: AttributeDescriptor) => AttributeDescriptor;
+    /**
+     * Translate a row's transport-shaped resource (`{ type, id }`) into a workbench
+     * `ResourceRef`. Defaults to the workbench `pstdio://extension-resource/...`
+     * scheme — dashboard supplies its own. Returns `undefined` for rows that do not
+     * carry an explicit resource.
+     */
+    resolveRowResource?: (record: WorkbenchExtensionDataRendererRecord, row: DataRendererRow_2) => ResourceRef | undefined;
+    /**
+     * Synthesize a `ResourceRef` for row-action execution context when the row does
+     * not carry an explicit resource. Defaults to a `pstdio://extension-resource/`
+     * fallback built from `record.resourceKind` and `row.id`.
+     */
+    resolveRowActionResource?: (record: WorkbenchExtensionDataRendererRecord, row: DataRendererRow_2) => ResourceRef | undefined;
+    /**
+     * Override the row-action runner. `runDefault` performs the workbench's standard
+     * flow (look up the row-action command, request params if needed, execute it).
+     */
+    executeRowAction?: (input: {
+        record: WorkbenchExtensionDataRendererRecord;
+        action: RowAction;
+        row: DataRendererRow_2;
+        resource: ResourceRef | undefined;
+        runDefault: () => Promise<void>;
+    }) => void | Promise<void>;
+    /**
+     * Override the row click handler. When unset the view layer falls back to
+     * opening the row's resource via `ctx.resources.openResource` — set this to
+     * intercept the click (e.g. swallow rejections when no opener exists yet).
+     */
+    onRowClick?: (input: {
+        record: WorkbenchExtensionDataRendererRecord;
+        row: DataRendererRow_2;
+        resource: ResourceRef | undefined;
+    }) => void;
+    /**
+     * Override the inline-create handler. `executeDefault` runs the record's create
+     * command with the column param. When omitted, the default executes and any
+     * configured `onAfterCreate` runs with the returned value.
+     */
+    onCreateRow?: (input: {
+        record: WorkbenchExtensionDataRendererRecord;
+        columnId: string;
+        executeDefault: () => Promise<unknown>;
+    }) => void;
+    /** Called after a successful default create (when `onCreateRow` is not provided). */
+    onAfterCreate?: (input: {
+        record: WorkbenchExtensionDataRendererRecord;
+        created: unknown;
+    }) => void;
+    /**
+     * Called after any mutation (attribute change, reorder, column action, default
+     * create) resolves successfully. Hosts that drive refresh via the outer command
+     * pipeline (testbench / workbench) leave this unset; dashboard supplies
+     * `ctx.renderers.refreshDataRenderer(id)`.
+     */
+    onAfterMutation?: (record: WorkbenchExtensionDataRendererRecord) => void;
+}
+
+export declare interface WorkbenchExtensionMenuRegistration {
+    command: Command;
+    contribution: ExtensionMenuContribution;
+    menuItem: MenuItem;
+    menuPath: MenuPath;
+    targetCommandId: string;
+}
+
+export declare interface WorkbenchExtensionMenuSlotConfig {
+    menuPath: MenuPath;
+    group?: string;
+    overflowLabel?: string;
+}
+
+export declare type WorkbenchExtensionMenuWhenBuilder = (contribution: ExtensionMenuContribution) => string | undefined;
+
+export { WorkbenchExtensionMetadata }
+
+export declare type WorkbenchExtensionRoute = WorkbenchExtensionMetadata["routes"][number];
+
+export declare interface WorkbenchExtensionRouteResourceInput {
+    route: WorkbenchExtensionRoute;
+}
+
+declare type WorkbenchExtensionStringResolver = (value: Localizable<string> | undefined, extensionId: string) => string;
+
+declare interface WorkbenchFileIconThemeStoreState {
+    themes: readonly FileIconThemePreferenceOption[];
+}
+
+declare type WorkbenchFocusArea = (typeof workbenchFocusAreas)[number];
+
+declare const workbenchFocusAreas: readonly ["activityBar", "sideBar", "main", "panel", "statusBar"];
+
+declare type WorkbenchFocusChangeListener = (area: WorkbenchFocusArea | undefined) => void;
+
+declare interface WorkbenchFocusController {
+    store: WorkbenchStore<WorkbenchFocusState>;
+    setActiveArea(area: WorkbenchFocusArea): void;
+    clearFocus(): void;
+    getActiveArea(): WorkbenchFocusArea | undefined;
+    onDidChange(listener: WorkbenchFocusChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchFocusState {
+    activeArea: WorkbenchFocusArea | undefined;
+}
+
+declare interface WorkbenchLastResourceController {
+    get(): ResourceRef | undefined;
+    set(resource: ResourceRef | undefined): void;
+    restore(): Promise<boolean>;
+}
+
+declare interface WorkbenchLayout {
+    areas: Record<WorkbenchArea, WorkbenchAreaState>;
+    activeWidgetId?: string;
+    activeResourceUri?: string;
+}
+
+declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
+
+declare interface WorkbenchLayoutStoreState {
+    layout: WorkbenchLayout;
+    widgets: Record<string, RegisteredWidgetContribution>;
+    placeholders: Partial<Record<WorkbenchArea, RegisteredPlaceholderContribution>>;
+}
+
+declare type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
+
+declare type WorkbenchModeActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
+
+declare type WorkbenchModeChangeListener = () => void;
+
+declare interface WorkbenchModeContribution {
+    id: string;
+    label?: string;
+    activate(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+}
+
+declare interface WorkbenchModeRegistry {
+    store: WorkbenchStore<WorkbenchModeStoreState>;
+    registerMode(mode: WorkbenchModeContribution): Disposable_2;
+    getMode(id: string): WorkbenchModeContribution | undefined;
+    listModes(): WorkbenchModeContribution[];
+    getActiveModeId(): string | undefined;
+    setActiveMode(id: string | undefined): void;
+    onDidChangeActive(listener: WorkbenchModeChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchModeStoreState {
+    modes: Record<string, WorkbenchModeContribution>;
+    activeModeId: string | undefined;
+}
+
+declare type WorkbenchModuleActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
+
+declare interface WorkbenchModuleContribution {
+    id: string;
+    source?: ContributionSource;
+    ownerId?: string;
+    activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
+}
+
+declare type WorkbenchModuleContributionContext = WorkbenchCoreContributionContext;
+
+declare interface WorkbenchNotification {
+    id?: string;
+    level: WorkbenchNotificationLevel;
+    title: string;
+    message?: string;
+    createdAt?: string;
+    resource?: ResourceRef;
+    actions?: WorkbenchNotificationAction[];
+    metadata?: Record<string, unknown>;
+}
+
+declare interface WorkbenchNotificationAction {
+    commandId: string;
+    title: string;
+    args?: unknown;
+}
+
+declare interface WorkbenchNotificationAction_2 {
+    commandId: string;
+    title: string;
+    args?: unknown;
+}
+
+declare type WorkbenchNotificationEvent = {
+    type: "show";
+    id: string;
+    notification: RegisteredWorkbenchNotification;
+} | {
+    type: "dismiss";
+    id: string;
+};
+
+declare type WorkbenchNotificationLevel = "info" | "success" | "warning" | "error";
+
+declare type WorkbenchNotificationLevel_2 = "info" | "success" | "warning" | "error";
+
+declare type WorkbenchNotificationListener = (event: WorkbenchNotificationEvent) => void;
+
+declare interface WorkbenchNotificationStoreState {
+    notifications: Record<string, RegisteredWorkbenchNotification>;
+}
+
+declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
+
+declare interface WorkbenchPanelsController {
+    store: WorkbenchStore<WorkbenchPanelsState>;
+    isOpen(areaId: string): boolean;
+    setOpen(areaId: string, open: boolean): void;
+    toggle(areaId: string): void;
+    onDidChange(listener: WorkbenchPanelsChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchPanelsState {
+    openByAreaId: Record<string, boolean>;
+}
+
+declare type WorkbenchRendererChangeListener = () => void;
+
+declare type WorkbenchRendererRegistration = {
+    id: string;
+    keepAlive?: false;
+    render: (input: WorkbenchWidgetRenderInput) => 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: WorkbenchWidgetRenderInput): Disposable_2;
+    getHost(rendererId: string): HTMLElement | undefined;
+    getClaim(rendererId: string): WorkbenchWidgetRenderInput | undefined;
+}
+
+declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & DataRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
+
+declare interface WorkbenchRendererStoreState {
+    renderers: Record<string, WorkbenchRendererRegistration>;
+    hosts: Record<string, RegisteredKeepAliveHost>;
+    claims: Record<string, WorkbenchWidgetRenderInput>;
+}
+
+declare type WorkbenchSessionPanelChangeListener = (mode: WorkbenchSessionPanelMode) => void;
+
+declare interface WorkbenchSessionPanelController {
+    store: WorkbenchStore<WorkbenchSessionPanelState>;
+    getMode(): WorkbenchSessionPanelMode;
+    setMode(mode: WorkbenchSessionPanelMode): void;
+    onDidChange(listener: WorkbenchSessionPanelChangeListener): Disposable_2;
+}
+
+declare type WorkbenchSessionPanelMode = "bubble" | "closed" | "attached";
+
+declare interface WorkbenchSessionPanelState {
+    mode: WorkbenchSessionPanelMode;
+}
+
+declare interface WorkbenchStore<TState> {
+    getState(): TState;
+    getInitialState(): TState;
+    subscribe(listener: WorkbenchStoreListener<TState>): () => void;
+    subscribeSelector<TValue>(selector: WorkbenchStoreSelector<TState, TValue>, listener: WorkbenchStoreSelectorListener<TValue>, options?: {
+        equalityFn?: (left: TValue, right: TValue) => boolean;
+        fireImmediately?: boolean;
+    }): () => void;
+}
+
+declare type WorkbenchStoreListener<TState> = (state: TState, previousState: TState) => void;
+
+declare type WorkbenchStoreSelector<TState, TValue> = (state: TState) => TValue;
+
+declare type WorkbenchStoreSelectorListener<TValue> = (value: TValue, previousValue: TValue) => void;
+
+declare interface WorkbenchTerminalController {
+    store: WorkbenchStore<WorkbenchTerminalState>;
+    /** True once the host injected a session opener. */
+    isAvailable(): boolean;
+    setSessionOpener(opener: WorkbenchTerminalSessionOpener | null): void;
+    /** Opens a session; the live adapter stays host-side and only the id is returned. */
+    open(input: {
+        request: WorkbenchTerminalSessionRequest;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    write(input: {
+        sessionId: string;
+        data: string | Uint8Array;
+    }): void;
+    resize(input: {
+        sessionId: string;
+        cols: number;
+        rows: number;
+    }): void;
+    kill(input: {
+        sessionId: string;
+        signal?: string;
+    }): Promise<void>;
+    subscribe(sessionId: string, sink: WorkbenchTerminalSessionSink): () => void;
+    getSession(sessionId: string): WorkbenchTerminalSessionModel | undefined;
+    listSessions(): WorkbenchTerminalSessionModel[];
+    /** Kills every live session. Called when the owning workbench is torn down. */
+    dispose(): Promise<void>;
+}
+
+declare interface WorkbenchTerminalSessionAdapter {
+    readonly id: string;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): Promise<void> | void;
+    onData(handler: (chunk: Uint8Array) => void): () => void;
+    /** Foreground process name updates, when the opener can report them (real PTYs). */
+    onTitle?(handler: (title: string) => void): () => void;
+    onExit(handler: (exit: WorkbenchTerminalSessionExit) => void): () => void;
+    onError(handler: (error: WorkbenchTerminalSessionError) => void): () => void;
+}
+
+declare interface WorkbenchTerminalSessionError {
+    message: string;
+}
+
+declare interface WorkbenchTerminalSessionExit {
+    code: number | null;
+    signal: string | null;
+}
+
+declare interface WorkbenchTerminalSessionModel {
+    id: string;
+    title: string;
+    status: WorkbenchTerminalSessionStatus;
+    exit?: WorkbenchTerminalSessionExit;
+}
+
+declare type WorkbenchTerminalSessionOpener = (request: WorkbenchTerminalSessionRequest) => Promise<WorkbenchTerminalSessionAdapter>;
+
+declare interface WorkbenchTerminalSessionRequest {
+    command?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    cols: number;
+    rows: number;
+}
+
+declare interface WorkbenchTerminalSessionSink {
+    onData?(chunk: Uint8Array): void;
+    onExit?(exit: WorkbenchTerminalSessionExit): void;
+    onError?(error: WorkbenchTerminalSessionError): void;
+}
+
+declare type WorkbenchTerminalSessionStatus = "running" | "exited" | "killed";
+
+declare interface WorkbenchTerminalState {
+    sessionsById: Record<string, WorkbenchTerminalSessionModel>;
+}
+
+declare interface WorkbenchThemeStoreState {
+    themes: readonly ThemePreferenceOption[];
+}
+
+declare interface WorkbenchWidgetPlacement {
+    widgetId: string;
+    contributionId: string;
+    ownerId?: string;
+    source?: ContributionSource;
+    resource?: ResourceRef;
+    resourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+}
+
+declare interface WorkbenchWidgetRenderInput {
+    workbench: WorkbenchCore;
+    widget: RegisteredWidgetContribution | RegisteredPlaceholderContribution;
+    placement: WorkbenchWidgetPlacement;
+    refresh: () => void;
+}
+
+export { }