@pstdio/workbench 0.11.4 → 0.35.0

package/dist/index-DDmpcM-n.d.ts

@@ -0,0 +1,2336 @@
+import { ControlValue, ControlValueMap, ControlsQueryResult, ControlsQueryResult as ControlsQueryResult$1, DockedWorkbenchRegion, DockedWorkbenchRegion as DockedWorkbenchRegion$1, FileRendererSectionTarget, KanbanRendererAttributeDisplay, Localizable, ModeRegionSettings, NavigationTargetPage, NavigationTargetPanel, PageLocation, PageMain, PageOpenIntent, PageRef, PageSlot, PlacementIdentity, PlacementItem, PlacementRef, ResourceConstraint, ResourceRef, ResourceRef as ResourceRef$1, defaultPageResourceCodec, dockedWorkbenchRegions } from "@pstdio/sdk/extensions";
+//#region src/core/shared/disposable.d.ts
+interface Disposable {
+  dispose(): void;
+}
+//#endregion
+//#region src/core/shared/store/workbench-store.d.ts
+type WorkbenchStoreSelector<TState, TValue> = (state: TState) => TValue;
+type WorkbenchStoreListener<TState> = (state: TState, previousState: TState) => void;
+type WorkbenchStoreSelectorListener<TValue> = (value: TValue, previousValue: TValue) => void;
+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;
+}
+//#endregion
+//#region src/core/shared/context/context-key-service.d.ts
+type ContextKeyValue = boolean | number | string | undefined;
+interface ContextKeyStoreState {
+  values: Record<string, ContextKeyValue>;
+}
+interface ContextKeyScope extends Disposable {
+  ownerId: string;
+  set(key: string, value: ContextKeyValue): void;
+  get(key: string): ContextKeyValue;
+  delete(key: string): void;
+}
+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 const matchesContextExpression: (values: Record<string, ContextKeyValue>, expression?: string) => boolean;
+//#endregion
+//#region src/core/shared/contributions/metadata.d.ts
+type ContributionSource = "module" | "extension";
+interface ContributionMetadata {
+  source?: ContributionSource;
+  ownerId?: string;
+  priority?: number;
+}
+interface RegisteredContributionMetadata {
+  source: ContributionSource;
+  ownerId: string;
+  priority: number;
+}
+//#endregion
+//#region src/core/registries/resources/resource-hierarchy.d.ts
+interface WorkbenchViewHierarchyNode {
+  type: "view";
+  viewId: string;
+  label?: string;
+  icon?: string;
+}
+type WorkbenchHierarchyNode = ResourceRef$1 | WorkbenchViewHierarchyNode;
+declare const isWorkbenchViewHierarchyNode: (node: WorkbenchHierarchyNode) => node is WorkbenchViewHierarchyNode;
+interface ResourceHierarchyProvider {
+  id: string;
+  priority?: number;
+  canResolve(resource: ResourceRef$1): boolean;
+  getParent(resource: ResourceRef$1): WorkbenchHierarchyNode | undefined;
+}
+type ResolvedResourceHierarchyProvider = Required<ResourceHierarchyProvider>;
+declare const resourceHierarchyCycleCode = "resource_hierarchy_cycle";
+interface ResourceHierarchyCycle {
+  code: typeof resourceHierarchyCycleCode;
+  path: WorkbenchHierarchyNode[];
+  repeatedUri: string;
+}
+//#endregion
+//#region src/core/registries/resources/resource-registry.d.ts
+declare const workbenchResourceTypeContextKey = "workbench.resource.type";
+declare const workbenchResourceIdContextKey = "workbench.resource.id";
+declare const workbenchResourceMetadataContextKey: (key: string) => string;
+declare const workbenchSelectionResourceKeyMetadataKey = "workbench.selectionResourceKey";
+declare const createWorkbenchResourceContextValues: (resource: ResourceRef | undefined) => Record<string, ContextKeyValue>;
+declare const createWorkbenchSelectionResourceMetadata: (resource: ResourceRef) => {
+  "workbench.selectionResourceKey": string;
+};
+declare const getWorkbenchSelectionResourceKeys: (resource: ResourceRef | undefined) => string[];
+interface ResourceKindContribution {
+  kind: string;
+  label: string;
+  icon?: string;
+}
+interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {}
+interface ResourceBrowseEntry {
+  resource: ResourceRef;
+  searchText?: string;
+  description?: string;
+  group?: string;
+  order?: number;
+  activate?: (resource: ResourceRef) => unknown | Promise<unknown>;
+}
+interface ResourceListContext {
+  primary?: ResourceRef;
+}
+interface ResourceProvider {
+  id: string;
+  kind: string;
+  list(query: string, context: ResourceListContext): readonly ResourceBrowseEntry[];
+}
+interface ResourceRegistryStoreState {
+  kinds: Record<string, RegisteredResourceKind>;
+  providers: Record<string, ResourceProvider>;
+  hierarchyProviders: Record<string, ResolvedResourceHierarchyProvider>;
+}
+interface ResourceRegistry {
+  removed(resource: ResourceRef): void;
+  onWillRemove(listener: (resource: ResourceRef) => readonly PlacementIdentity[]): Disposable;
+  store: WorkbenchStore<ResourceRegistryStoreState>;
+  registerKind(kind: ResourceKindContribution, metadata?: ContributionMetadata): Disposable;
+  getKind(kind: string): RegisteredResourceKind | undefined;
+  listKinds(): RegisteredResourceKind[];
+  registerProvider(provider: ResourceProvider): Disposable;
+  listProviders(): ResourceProvider[];
+  listResources(query: string): readonly ResourceBrowseEntry[];
+  registerHierarchyProvider(provider: ResourceHierarchyProvider): Disposable;
+  listHierarchyProviders(): ResolvedResourceHierarchyProvider[];
+  walkHierarchy(resource: ResourceRef | undefined): WorkbenchHierarchyNode[];
+  onDidDetectHierarchyCycle(listener: (cycle: ResourceHierarchyCycle) => void): Disposable;
+}
+//#endregion
+//#region src/core/controllers/breadcrumbs/breadcrumb-registry.d.ts
+interface WorkbenchBreadcrumbItem {
+  title: unknown;
+  icon?: string;
+  indicator?: "session-status";
+  url?: string;
+  onClick?: () => void;
+  resource?: ResourceRef$1;
+}
+type WorkbenchBreadcrumbChangeListener = () => void;
+interface WorkbenchBreadcrumbState {
+  items: WorkbenchBreadcrumbItem[] | undefined;
+}
+interface WorkbenchBreadcrumbController {
+  store: WorkbenchStore<WorkbenchBreadcrumbState>;
+  setItems(items: WorkbenchBreadcrumbItem[]): Disposable;
+  clearItems(): void;
+  getItems(): WorkbenchBreadcrumbItem[] | undefined;
+  onDidChange(listener: WorkbenchBreadcrumbChangeListener): Disposable;
+}
+//#endregion
+//#region src/core/registries/commands/command-registry.d.ts
+interface WorkbenchCommandExecutionError {
+  commandId: string;
+  args: unknown;
+  error: unknown;
+}
+type WorkbenchCommandExecutionErrorListener = (event: WorkbenchCommandExecutionError) => void;
+interface WorkbenchCommandExecutionContext {
+  resource?: ResourceRef$1;
+  source?: "panel-add";
+}
+interface CommandParamOption {
+  label: string;
+  value: string;
+  icon?: string;
+}
+interface CommandParamDescriptor {
+  type: string;
+  label?: string;
+  description?: string;
+  required?: boolean;
+  defaultValue?: unknown;
+  options?: CommandParamOption[];
+  templateType?: string;
+  resourceType?: string;
+  accept?: string;
+  multiple?: boolean;
+  metadata?: Record<string, unknown>;
+  resolvedFrom?: "resource";
+}
+type CommandParamSchema = Record<string, CommandParamDescriptor>;
+interface Command {
+  id: string;
+  label: string;
+  category?: string;
+  description?: string;
+  icon?: string;
+  when?: string;
+  params?: CommandParamSchema;
+}
+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>;
+  isEnabled?(args: TArgs): boolean;
+  isVisible?(args: TArgs): boolean;
+  isToggled?(args: TArgs): boolean;
+}
+interface RegisteredCommand extends RegisteredContributionMetadata {
+  command: Command;
+  handler: CommandHandler;
+}
+interface CommandRegistryStoreState {
+  commands: Record<string, RegisteredCommand>;
+}
+interface CommandRegistry {
+  store: WorkbenchStore<CommandRegistryStoreState>;
+  registerCommand<TArgs = unknown, TResult = unknown>(command: Command, handler: CommandHandler<TArgs, TResult>, metadata?: ContributionMetadata): Disposable;
+  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;
+  prepareCommandArgs(id: string, args: unknown, context?: WorkbenchCommandExecutionContext, onArgsChange?: (args: unknown) => void): Promise<unknown>;
+  executeCommand(id: string, args?: unknown, context?: WorkbenchCommandExecutionContext): Promise<unknown>;
+  onDidExecuteError(listener: WorkbenchCommandExecutionErrorListener): Disposable;
+}
+//#endregion
+//#region src/core/controllers/command-palette/command-palette-controller.d.ts
+type WorkbenchCommandPaletteChangeListener = (open: boolean) => void;
+type WorkbenchCommandPaletteView = "main" | "theme";
+interface WorkbenchCommandParamsRequest {
+  record: {
+    command: {
+      id: string;
+      label: string;
+      params?: CommandParamSchema;
+    };
+  };
+  label: string;
+  args?: unknown;
+  context?: WorkbenchCommandExecutionContext;
+}
+interface WorkbenchCommandPaletteState {
+  open: boolean;
+  view: WorkbenchCommandPaletteView;
+  initialQuery: string;
+  paramsRequest: WorkbenchCommandParamsRequest | null;
+}
+interface WorkbenchCommandPaletteOpenInput {
+  view?: WorkbenchCommandPaletteView;
+  initialQuery?: string;
+}
+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;
+}
+//#endregion
+//#region src/core/registries/navigation/navigation-registry.d.ts
+/** Core-only panel ref for host-owned shell placements. Extensions cannot address them. */
+interface ShellPlacementRef {
+  kind: "shell-placement";
+  id: string;
+}
+interface NavigationTargetShellPanel {
+  kind: "panel";
+  panel: ShellPlacementRef;
+  resource?: NavigationTargetPanel["resource"];
+  open?: NavigationTargetPanel["open"];
+  title?: string;
+}
+type NavigationTargetPanel$1 = NavigationTargetPanel | NavigationTargetShellPanel;
+type NavigationTargetPage$1 = NavigationTargetPage;
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+interface NavigationTargetCommand {
+  kind: "command";
+  commandId: string;
+  args?: unknown;
+}
+interface NavigationTargetHref {
+  kind: "href";
+  href: string;
+}
+type NavigationTargetItem = NavigationTargetPage$1 | NavigationTargetPanel$1 | NavigationTargetCommand | NavigationTargetHref;
+interface NavigationTargetCompound {
+  kind: "compound";
+  targets: readonly (NavigationTargetPage$1 | NavigationTargetPanel$1)[];
+}
+type NavigationTarget$1 = NavigationTargetItem | NavigationTargetCompound;
+interface NavigationParser {
+  id: string;
+  priority?: number;
+  canParse(location: string): boolean;
+  parse(location: string): NavigationTarget$1;
+}
+type RegisteredNavigationParser = Omit<NavigationParser, "priority"> & RegisteredContributionMetadata;
+interface NavigationDispatcherContext {
+  canOpenPanel?(target: NavigationTargetPanel$1): boolean;
+  canExecuteCommand?(commandId: string): boolean;
+  prepareNavigation?(targets: readonly (NavigationTargetPage$1 | NavigationTargetPanel$1)[]): {
+    commit(): unknown;
+  };
+  openPanelTarget?(target: NavigationTargetPanel$1): unknown;
+  openPageTarget?(target: NavigationTargetPage$1): unknown;
+  executeCommand(commandId: string, args?: unknown): Promise<unknown> | unknown;
+  openHref?(href: string): Promise<unknown> | unknown;
+}
+interface NavigationRegistryStoreState {
+  parsers: Record<string, RegisteredNavigationParser>;
+}
+interface NavigationRegistry {
+  store: WorkbenchStore<NavigationRegistryStoreState>;
+  registerParser(parser: NavigationParser, metadata?: ContributionMetadata): Disposable;
+  listParsers(): RegisteredNavigationParser[];
+  resolveLocation(location: string): NavigationTarget$1;
+  openTarget(target: NavigationTarget$1): Promise<readonly unknown[]>;
+  /** Opens a page location through the shared executor. */
+  openPage(target: Omit<NavigationTargetPage$1, "kind">): Promise<readonly unknown[]>;
+  /** Opens or activates an owned panel through the shared executor. */
+  openPanel(target: DistributiveOmit<NavigationTargetPanel$1, "kind">): Promise<readonly unknown[]>;
+  navigate(location: string): Promise<readonly unknown[]>;
+}
+//#endregion
+//#region src/core/registries/layout/layout-regions.d.ts
+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"];
+type WorkbenchRegion = (typeof workbenchRegions)[number];
+declare const workbenchPanelRegions: readonly ["main", "secondary", "side"];
+type WorkbenchPanelRegion = (typeof workbenchPanelRegions)[number];
+type WorkbenchPanelMenuSide = "left" | "right";
+declare const workbenchPanelMenuRegions: {
+  readonly main: {
+    readonly left: "main-left-menu";
+    readonly right: "main-right-menu";
+  };
+  readonly secondary: {
+    readonly left: "secondary-left-menu";
+    readonly right: "secondary-right-menu";
+  };
+  readonly side: {
+    readonly left: "side-left-menu";
+    readonly right: "side-right-menu";
+  };
+};
+type WorkbenchPanelMenuRegion = (typeof workbenchPanelMenuRegions)[WorkbenchPanelRegion][WorkbenchPanelMenuSide];
+//#endregion
+//#region src/core/registries/layout/layout-types.d.ts
+interface WorkbenchRegionSize {
+  defaultPx?: number;
+  minPx?: number;
+  maxPx?: number;
+}
+/** Region-level layout policy owned by the active mode or the host, never by a placement. */
+type WorkbenchRegionSettings = ModeRegionSettings;
+type WidgetReusePolicy = "resource" | "none";
+type WidgetMountStrategy = "active" | "keep-mounted";
+type WorkbenchPanelReusePolicy = WidgetReusePolicy;
+type WorkbenchPanelMountStrategy = WidgetMountStrategy;
+type WorkbenchWidgetRole = "content" | "location" | "sub-panel" | "panel-menu";
+type WorkbenchTabRetention = "preview" | "persistent";
+type WorkbenchTabPosition = "start" | "end" | {
+  beforeWidgetId: string;
+} | {
+  afterWidgetId: string;
+};
+interface WorkbenchLocationEligibility {
+  modeIds?: string[];
+  resourceKinds?: string[];
+  resourceIds?: string[];
+  canOpen?(resource: ResourceRef$1): boolean;
+  canOpenLocation?(location: {
+    resource?: ResourceRef$1;
+    viewId?: string;
+  }): boolean;
+}
+type WorkbenchPanelMenuOwner = {
+  level: "panel";
+  contributionId?: string;
+} | {
+  level: "sub-panel";
+  contributionId: string;
+};
+interface WorkbenchCommandTarget {
+  commandId: string;
+  args?: unknown;
+}
+type WorkbenchTabAction = ({
+  kind: "command";
+} & WorkbenchCommandTarget) | {
+  kind: "navigation";
+  target: NavigationTarget$1;
+};
+interface WorkbenchTabMenuRow {
+  id: string;
+  label: string;
+  icon?: string;
+  iconColor?: string;
+  selected?: boolean;
+  disabled?: boolean;
+  action?: WorkbenchTabAction;
+}
+interface WorkbenchTabMenuGroup {
+  id: string;
+  rows: readonly WorkbenchTabMenuRow[];
+}
+interface WorkbenchTabSnapshot {
+  label?: string;
+  icon?: string;
+  indicator?: {
+    icon: string;
+    color?: string;
+    label?: string;
+  };
+  menu?: readonly WorkbenchTabMenuGroup[];
+}
+interface WorkbenchWidgetTab {
+  getSnapshot(instance: WorkbenchPanelInstance): WorkbenchTabSnapshot;
+  subscribe?(listener: () => void): {
+    dispose(): void;
+  } | (() => void);
+  refreshEvents?: readonly string[];
+}
+type WorkbenchPanelTab = WorkbenchWidgetTab;
+interface WidgetContribution {
+  id: string;
+  title: string;
+  icon?: string;
+  region: WorkbenchRegion;
+  fallbackRegion?: WorkbenchRegion;
+  singleton?: boolean;
+  reuse?: WidgetReusePolicy;
+  mountStrategy?: WidgetMountStrategy;
+  closable?: boolean;
+  hiddenByDefault?: boolean;
+  regionSize?: WorkbenchRegionSize;
+  regionCollapsible?: boolean;
+  headerBorderBottom?: boolean;
+  resourceKinds?: string[];
+  priority?: number;
+  rendererId: string;
+  openCommand?: WorkbenchCommandTarget;
+  eligibleLocations?: WorkbenchLocationEligibility;
+  panelMenuOwner?: WorkbenchPanelMenuOwner;
+  tab?: WorkbenchWidgetTab;
+  config?: unknown;
+  canOpen?(resource: ResourceRef$1): boolean;
+}
+interface WorkbenchPanelMenuDefinition {
+  id: string;
+  title: string;
+  icon?: string;
+  side: WorkbenchPanelMenuSide;
+  singleton?: boolean;
+  reuse?: WorkbenchPanelReusePolicy;
+  mountStrategy?: WorkbenchPanelMountStrategy;
+  hiddenByDefault?: boolean;
+  regionSize?: WorkbenchRegionSize;
+  regionCollapsible?: boolean;
+  headerBorderBottom?: boolean;
+  rendererId: string;
+  priority?: number;
+  config?: unknown;
+}
+interface WorkbenchPanelContribution {
+  id: string;
+  title: string;
+  icon?: string;
+  region: WorkbenchRegion;
+  fallbackRegion?: WorkbenchRegion;
+  rendererId: string;
+  singleton?: boolean;
+  reuse?: WorkbenchPanelReusePolicy;
+  mountStrategy?: WorkbenchPanelMountStrategy;
+  closable?: boolean;
+  hiddenByDefault?: boolean;
+  regionSize?: WorkbenchRegionSize;
+  regionCollapsible?: boolean;
+  headerBorderBottom?: boolean;
+  resourceKinds?: string[];
+  eligibleLocations?: WorkbenchLocationEligibility;
+  priority?: number;
+  openCommand?: WorkbenchCommandTarget;
+  tab?: WorkbenchPanelTab;
+  config?: unknown;
+  canOpen?(resource: ResourceRef$1): boolean;
+  ownerId?: string;
+  source?: ContributionSource;
+  panelMenus?: readonly WorkbenchPanelMenuDefinition[];
+}
+type WorkbenchPanelMenuContribution = Omit<WidgetContribution, "region" | "fallbackRegion"> & {
+  region: WorkbenchPanelMenuRegion;
+  fallbackRegion?: WorkbenchPanelMenuRegion;
+};
+type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+  ownedPanelMenuIds?: readonly string[];
+  singleton: boolean;
+  reuse: WidgetReusePolicy;
+} & RegisteredContributionMetadata;
+interface PlaceholderContribution {
+  id: string;
+  title: string;
+  region: WorkbenchRegion;
+  rendererId: string;
+  regionSize?: WorkbenchRegionSize;
+  regionCollapsible?: boolean;
+  config?: unknown;
+  priority?: number;
+}
+type RegisteredPlaceholderContribution = Omit<PlaceholderContribution, "priority"> & RegisteredContributionMetadata;
+interface WorkbenchWidgetPlacement {
+  widgetId: string;
+  contributionId: string;
+  placementIdentity?: PlacementIdentity;
+  viewId?: string;
+  ownerId?: string;
+  source?: ContributionSource;
+  resource?: ResourceRef$1;
+  section?: FileRendererSectionTarget;
+  resourceKey?: string;
+  ownerResourceKey?: string;
+  title?: string;
+  pinned?: boolean;
+  closable?: boolean;
+  mountStrategy?: WidgetMountStrategy;
+  hiddenByDefault?: boolean;
+  tabRetention?: WorkbenchTabRetention;
+  tab?: WorkbenchWidgetTab;
+  role?: WorkbenchWidgetRole;
+}
+interface WorkbenchPanelInstance {
+  instanceId: string;
+  panelId: string;
+  placementIdentity?: PlacementIdentity;
+  viewId?: string;
+  ownerId?: string;
+  source?: ContributionSource;
+  resource?: ResourceRef$1;
+  section?: FileRendererSectionTarget;
+  resourceKey?: string;
+  ownerResourceKey?: string;
+  title?: string;
+  pinned?: boolean;
+  closable: boolean;
+  mountStrategy?: WorkbenchPanelMountStrategy;
+  hiddenByDefault?: boolean;
+  tabRetention?: WorkbenchTabRetention;
+  tab?: WorkbenchPanelTab;
+}
+interface WorkbenchRegionState {
+  id: WorkbenchRegion;
+  visible: boolean;
+  size?: number;
+  widgets: WorkbenchWidgetPlacement[];
+  activeWidgetId?: string;
+}
+interface WorkbenchLayout {
+  regions: Record<WorkbenchRegion, WorkbenchRegionState>;
+  locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion, string>>>;
+  activeWidgetId?: string;
+  activeLocationWidgetId?: string;
+  activeResourceKey?: string;
+}
+interface WorkbenchLayoutStoreState {
+  layout: WorkbenchLayout;
+  widgets: Record<string, RegisteredWidgetContribution>;
+  placeholders: Partial<Record<WorkbenchRegion, RegisteredPlaceholderContribution>>;
+}
+interface OpenWidgetInput {
+  viewId?: string | null;
+  resource?: ResourceRef$1 | null;
+  title?: string;
+  region?: WorkbenchRegion;
+  role?: WorkbenchWidgetRole;
+  ownerId?: string;
+  source?: ContributionSource;
+  pinned?: boolean;
+  closable?: boolean;
+  mountStrategy?: WidgetMountStrategy;
+  hiddenByDefault?: boolean;
+  tabRetention?: WorkbenchTabRetention;
+  tabPosition?: WorkbenchTabPosition;
+  tab?: WorkbenchWidgetTab;
+  replaceActive?: boolean;
+  replaceWidgetId?: string;
+}
+type WorkbenchPanelOpenStrategy = {
+  kind: "persistent";
+  position?: WorkbenchTabPosition;
+} | {
+  kind: "replace-active";
+} | {
+  kind: "replace-panel";
+  instanceId: string;
+  retention?: WorkbenchTabRetention;
+} | {
+  kind: "preview";
+  position?: WorkbenchTabPosition;
+};
+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$1 | null;
+  title?: string;
+  region?: WorkbenchRegion;
+  role?: WorkbenchWidgetRole;
+  pinned?: boolean;
+  closable?: boolean;
+  mountStrategy?: WorkbenchPanelMountStrategy;
+  hiddenByDefault?: boolean;
+  tab?: WorkbenchPanelTab;
+  strategy?: WorkbenchPanelOpenStrategy;
+}
+//#endregion
+//#region src/core/registries/layout/layout-model-types.d.ts
+type LayoutScope = string;
+interface LayoutPersistenceAdapter {
+  getLayout(scope?: LayoutScope): WorkbenchLayout | undefined;
+  setLayout(layout: WorkbenchLayout, scope?: LayoutScope): void;
+  listScopes?(projectId: string): LayoutScope[];
+  transformLayouts?(projectId: string, transform: (layout: WorkbenchLayout, scope: LayoutScope) => WorkbenchLayout | undefined): void;
+  getCompatibilityMarker?(key: string): string | undefined;
+  setCompatibilityMarker?(key: string, value: string): void;
+  advanceWriteGeneration?(): number;
+  flush?(): void;
+  dispose?(): void;
+}
+interface LayoutModel {
+  store: WorkbenchStore<WorkbenchLayoutStoreState>;
+  registerPlaceholder(placeholder: PlaceholderContribution, metadata?: ContributionMetadata): {
+    dispose(): void;
+  };
+  registerPanel(panel: WorkbenchPanelContribution, metadata?: ContributionMetadata): {
+    dispose(): void;
+  };
+  registerWidget(widget: WidgetContribution, metadata?: ContributionMetadata): {
+    dispose(): void;
+  };
+  registerPanelMenu(panelMenu: WorkbenchPanelMenuContribution, metadata?: ContributionMetadata): {
+    dispose(): void;
+  };
+  unregisterWidget(id: string, options?: {
+    removePlacements?: boolean;
+    persist?: boolean;
+  }): void;
+  getPlaceholder(regionId: WorkbenchRegion): RegisteredPlaceholderContribution | undefined;
+  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;
+  setRegionSize(regionId: WorkbenchRegion, size: number): void;
+  listPlaceholders(): RegisteredPlaceholderContribution[];
+  listWidgets(): RegisteredWidgetContribution[];
+  listPanels(): WorkbenchPanelContribution[];
+  listPanelInstances(region?: WorkbenchRegion): WorkbenchPanelInstance[];
+  getActivePanel(region?: WorkbenchRegion): WorkbenchPanelInstance | undefined;
+  openWidget(id: string, input?: OpenWidgetInput): WorkbenchWidgetPlacement;
+  openPanel(id: string, input?: OpenWorkbenchPanelInput): WorkbenchPanelInstance;
+  updatePanel(instanceId: string, input: OpenWorkbenchPanelInput): WorkbenchPanelInstance;
+  reorderPanel(instanceId: string, position: WorkbenchTabPosition): void;
+  activatePanel(instanceId: string): WorkbenchPanelInstance;
+  closePanel(instanceId: string): WorkbenchPanelInstance | undefined;
+  updateWidgetPlacement(widgetId: string, input: OpenWidgetInput): WorkbenchWidgetPlacement;
+  reorderWidget(widgetId: string, position: WorkbenchTabPosition): void;
+  expirePreviewTabs(ownerResourceKey?: string): void;
+  activateWidget(widgetId: string): WorkbenchWidgetPlacement;
+  setRegionActiveWidget(regionId: WorkbenchRegion, widgetId: string | undefined): void;
+  closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
+  removeWidgetPlacement(widgetId: string): WorkbenchWidgetPlacement | undefined;
+  clearRegion(regionId: WorkbenchRegion): void;
+  resetRegions(): void;
+  getLayout(): WorkbenchLayout;
+  restoreLayout(layout: WorkbenchLayout): void;
+  setPersistenceScope(scope: LayoutScope | undefined, input?: {
+    carryRegionState?: readonly WorkbenchRegion[];
+  }): void;
+  getPersistenceScope(): LayoutScope | undefined;
+  /** True when the current persistence scope already stores a layout. A new scope returns false. */
+  /** Whether anything is stored for the active scope right now. */
+  hasPersistedLayout(): boolean;
+  /**
+   * Whether the active scope was entered with a layout the user already had. Unlike
+   * `hasPersistedLayout`, writes made while entering a mode do not change the answer.
+   */
+  enteredWithPersistedLayout(): boolean;
+  /** Moves owned panel menus beside their owner's current region and removes orphan menus. */
+  reconcilePanelMenus(): void;
+  onWillChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+    dispose(): void;
+  };
+  onDidChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+    dispose(): void;
+  };
+}
+//#endregion
+//#region src/core/controllers/focus/focus-controller.d.ts
+declare const workbenchFocusRegions: readonly ["activity", "sidenav", "main", "secondary", "side", "status"];
+type WorkbenchFocusRegionId = (typeof workbenchFocusRegions)[number];
+type WorkbenchFocusChangeListener = (region: WorkbenchFocusRegionId | undefined) => void;
+interface WorkbenchFocusState {
+  activeRegion: WorkbenchFocusRegionId | undefined;
+}
+interface WorkbenchFocusController {
+  store: WorkbenchStore<WorkbenchFocusState>;
+  setActiveRegion(region: WorkbenchFocusRegionId): void;
+  clearFocus(): void;
+  getActiveRegion(): WorkbenchFocusRegionId | undefined;
+  onDidChange(listener: WorkbenchFocusChangeListener): Disposable;
+}
+//#endregion
+//#region src/core/registries/layout/placement-reconciliation.d.ts
+interface ResolvedOwnedPlacement<Value = unknown> {
+  identity: PlacementIdentity;
+  region: WorkbenchRegion;
+  order: number;
+  value: Value;
+}
+interface OwnedPlacementUpdate<Value> {
+  current: ResolvedOwnedPlacement<Value>;
+  desired: ResolvedOwnedPlacement<Value>;
+}
+interface OwnedPlacementReconciliation<Value> {
+  add: readonly ResolvedOwnedPlacement<Value>[];
+  retain: readonly ResolvedOwnedPlacement<Value>[];
+  update: readonly OwnedPlacementUpdate<Value>[];
+  activate: readonly ResolvedOwnedPlacement<Value>[];
+  remove: readonly ResolvedOwnedPlacement<Value>[];
+}
+//#endregion
+//#region src/core/registries/renderers/renderer-registry.d.ts
+interface WorkbenchPanelRenderInput {
+  workbench: WorkbenchCore;
+  panel: WorkbenchPanelContribution | PlaceholderContribution | RegisteredPlaceholderContribution;
+  instance: WorkbenchPanelInstance;
+  refresh: () => void;
+}
+interface WorkbenchRendererRegistration {
+  id: string;
+  render: (input: WorkbenchPanelRenderInput) => unknown;
+}
+//#endregion
+//#region src/core/registries/renderers/controls-renderer-registry.d.ts
+type ControlsRendererRegion = "main-right-menu" | "secondary" | "overlay";
+interface ControlsRendererLayout {
+  region?: ControlsRendererRegion;
+  defaultPx?: number;
+  minPx?: number;
+  maxPx?: number;
+}
+interface ControlsUpdateValueInput {
+  controlId: string;
+  value: ControlValue;
+  values: ControlValueMap;
+  resource?: ResourceRef$1;
+}
+interface ControlsApplyInput {
+  values: ControlValueMap;
+  resource?: ResourceRef$1;
+}
+interface ControlsResetInput {
+  controlIds?: string[];
+  resource?: ResourceRef$1;
+}
+interface ControlsRendererContribution {
+  id: string;
+  title: string;
+  resourceKind?: string;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  layout?: ControlsRendererLayout;
+  defaultValues?: ControlValueMap;
+  /** Load the control declarations + current values for the active resource. */
+  executeQuery(resource?: ResourceRef$1): 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 | (() => void);
+}
+//#endregion
+//#region src/core/registries/renderers/data-table-renderer-registry.d.ts
+interface DataTableRendererThemeColor {
+  light: string;
+  dark: string;
+  foreground?: {
+    light: string;
+    dark: string;
+  };
+}
+type DataTableRendererColumnStat = {
+  type: "unique";
+} | {
+  type: "histogram";
+  bins?: number;
+} | {
+  type: "top-values";
+  limit?: number;
+};
+type DataTableRendererColumnRenderer = {
+  type: "json";
+} | {
+  type: "color-scale";
+  stops: Array<{
+    value: number;
+    color: DataTableRendererThemeColor;
+  }>;
+} | {
+  type: "categorical-color";
+  categories: Array<{
+    value: string | number | boolean | null;
+    color: DataTableRendererThemeColor;
+  }>;
+};
+interface DataTableRendererColumn {
+  id: string;
+  label?: string;
+  description?: string;
+  icon?: unknown;
+  hidden?: boolean;
+  stat?: DataTableRendererColumnStat;
+  renderer?: DataTableRendererColumnRenderer;
+}
+interface DataTableRendererRow {
+  id: string;
+  values: Record<string, unknown>;
+  resource?: ResourceRef$1;
+}
+interface DataTableRendererQueryResult {
+  rows: DataTableRendererRow[];
+  columns?: DataTableRendererColumn[];
+}
+interface DataTableRendererQueryContext {
+  resource?: ResourceRef$1;
+  modeId?: string;
+}
+interface DataTableRendererRowAction {
+  id: string;
+  label: string;
+  icon?: unknown;
+  destructive?: boolean;
+  run(row: DataTableRendererRow): Promise<void> | void;
+}
+interface DataTableRendererSelectionAction {
+  id: string;
+  label: string;
+  icon?: unknown;
+  destructive?: boolean;
+  run(rows: DataTableRendererRow[]): Promise<void> | void;
+}
+interface DataTableRendererContribution {
+  id: string;
+  title: string;
+  resourceKind?: string;
+  columns?: DataTableRendererColumn[];
+  selectionMode?: "none" | "multiple";
+  selectionActions?: DataTableRendererSelectionAction[];
+  rowActions?: DataTableRendererRowAction[];
+  initialPageSize?: number;
+  pageSizeOptions?: number[];
+  emptyTitle?: string;
+  emptyDescription?: string;
+  executeQuery(context: DataTableRendererQueryContext): Promise<DataTableRendererQueryResult> | DataTableRendererQueryResult;
+  subscribe?: (listener: () => void) => Disposable | (() => void);
+  onRowActivate?: (row: DataTableRendererRow) => Promise<void> | void;
+}
+interface RegisteredDataTableRendererContribution extends DataTableRendererContribution, RegisteredContributionMetadata {}
+//#endregion
+//#region src/core/registries/renderers/file-renderer-registry.d.ts
+interface FileRendererContent {
+  fileName?: string;
+  /** Workspace-relative path shown above the file preview. */
+  filePath?: string;
+  mimeType?: string;
+  content?: string;
+  dataUrl?: string;
+  placeholder?: string;
+  /** Override contribution-level save support for one loaded file. */
+  editable?: boolean;
+  /** Request Monaco for text that automatic dispatch would open as markdown. */
+  textRenderer?: "automatic" | "monaco";
+  /** Represent a deliberate no-file selection without an editable blank document. */
+  emptyState?: {
+    title: string;
+    description?: string;
+  };
+  /** Ordered backing-store revision when one is available. */
+  revision?: string;
+}
+interface FileRendererRefreshOrigin {
+  rendererId: string;
+  instanceId: string;
+  operationId: string;
+}
+interface FileRendererRefreshEnvelope {
+  resourceKey?: string;
+  origin?: FileRendererRefreshOrigin;
+  revision?: string;
+}
+interface FileRendererSaveResult {
+  revision?: string;
+}
+interface FileRendererContribution {
+  id: string;
+  title: string;
+  resourceKind?: string;
+  /** Resolve the file's content (and identity) for the bound resource. */
+  load(resource: ResourceRef$1 | undefined): Promise<FileRendererContent> | FileRendererContent;
+  /** Persist edited text. Absent ⇒ read-only. Never called for images. */
+  save?(resource: ResourceRef$1 | undefined, content: string, origin?: FileRendererRefreshOrigin): Promise<FileRendererSaveResult | undefined> | FileRendererSaveResult | void;
+}
+//#endregion
+//#region src/core/registries/renderers/kanban-renderer-contracts.d.ts
+/**
+ * Core-owned contracts for kanban renderer contributions. @pstdio/ui's
+ * KanbanRenderer props are structurally identical; the React layer bridges the
+ * two, so drift surfaces as a compile error there instead of coupling core's
+ * API shape to UI package ownership.
+ */
+type ViewMode = "board" | "list";
+type SortDirection = "asc" | "desc";
+declare const NO_GROUPING = "none";
+declare const MANUAL_ORDERING = "manual";
+interface EnumOption {
+  value: string;
+  label: string;
+  color?: string;
+  icon?: string | null;
+}
+/**
+ * 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.
+ */
+interface EnumOptionsSource {
+  subscribe: (listener: () => void) => () => void;
+  getSnapshot: () => EnumOption[];
+}
+type EnumOptions = EnumOption[] | EnumOptionsSource;
+type AttributeType = {
+  kind: "enum";
+  options: EnumOptions;
+} | {
+  kind: "enum-multi";
+  options: EnumOptions;
+} | {
+  kind: "string";
+} | {
+  kind: "date";
+} | {
+  kind: "number";
+} | {
+  kind: "user";
+};
+type AttributeKind = AttributeType["kind"];
+type AttributeDisplayDescriptor = KanbanRendererAttributeDisplay;
+interface AttributeDescriptor<TNode = unknown> {
+  id: string;
+  label: string;
+  type: AttributeType;
+  filterable?: boolean;
+  groupable?: boolean;
+  sortable?: boolean;
+  displayable?: boolean;
+  editable?: boolean;
+  display?: AttributeDisplayDescriptor;
+  render?: (value: unknown, row: KanbanRendererRow) => TNode;
+  compare?: (a: unknown, b: unknown) => number;
+}
+/**
+ * Reactive source for an entire attribute schema. Lets a contribution
+ * add/remove/edit attributes at runtime without re-registering.
+ */
+interface AttributesSource<TNode = unknown> {
+  subscribe: (listener: () => void) => () => void;
+  getSnapshot: () => AttributeDescriptor<TNode>[];
+}
+interface KanbanRendererRow {
+  id: string;
+  title: string;
+  /**
+   * Optional navigation handle. When set, the renderer's default click handler
+   * routes through the contribution's onRowActivate (which typically opens the
+   * resource via the workbench).
+   */
+  resource?: unknown;
+  attributes: Record<string, unknown>;
+}
+interface KanbanRendererOrdering {
+  attributeId: string | typeof MANUAL_ORDERING;
+  direction: SortDirection;
+}
+interface KanbanRendererSettings {
+  viewMode: ViewMode;
+  columnGrouping: string | typeof NO_GROUPING;
+  rowGrouping: string | typeof NO_GROUPING;
+  ordering: KanbanRendererOrdering;
+  displayProperties: string[];
+}
+type KanbanRendererFilterState = Record<string, string[]>;
+interface KanbanRendererSavedView {
+  id: string;
+  title: string;
+  settings: KanbanRendererSettings;
+  filters: KanbanRendererFilterState;
+  isDefault?: boolean;
+}
+type KanbanRendererCreateFieldType = "text" | "longtext" | "markdown" | "number" | "boolean" | "select" | "multi-select" | "files";
+interface KanbanRendererCreateField {
+  id: string;
+  label: string;
+  description?: string;
+  placeholder?: string;
+  type: KanbanRendererCreateFieldType;
+  required?: boolean;
+  defaultValue?: unknown;
+  options?: EnumOption[];
+  /** `files` fields only. */
+  multiple?: boolean;
+  accept?: string;
+}
+/** Chrome copy is supplied by the caller so the dialog ships no strings of its own. */
+interface KanbanRendererCreateLabels {
+  cancel: string;
+  properties: string;
+  submitError: string;
+  removeFile: string;
+}
+interface KanbanRendererCreateRowConfig {
+  title: string;
+  submitLabel: string;
+  fields: KanbanRendererCreateField[];
+  labels: KanbanRendererCreateLabels;
+}
+interface KanbanRendererCreateSubmission {
+  columnId: string;
+  columnAttributeId?: string;
+  /** Declared field values, excluding `files` fields — those arrive as `files`. */
+  values: Record<string, unknown>;
+  /** Every editable attribute the user set, keyed by attribute id. */
+  attributeValues: Record<string, unknown>;
+  files: File[];
+}
+interface BoardColumnAction<TIcon = unknown> {
+  id: string;
+  label: string;
+  icon: TIcon;
+}
+/** Board-column behavior and menu configuration for a resolved column group. */
+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<TIcon>[];
+}
+/** Row-level context menu action surfaced by the renderer. */
+interface ResourceContextAction<TNode = unknown> {
+  key: string;
+  label: string;
+  onClick: () => Promise<void> | void;
+  isDisabled?: boolean;
+  icon?: TNode;
+  endContent?: TNode;
+  separatorBefore?: boolean;
+}
+//#endregion
+//#region src/core/registries/renderers/kanban-renderer-registry.d.ts
+interface KanbanRendererQueryState {
+  settings: KanbanRendererSettings;
+  filters: KanbanRendererFilterState;
+}
+interface KanbanRendererContribution<TRow extends KanbanRendererRow = KanbanRendererRow, TNode = unknown, TIcon = unknown> {
+  id: string;
+  title: string;
+  resourceKind?: string;
+  /** Host-owned scope for persisted display settings. */
+  storageScope?: string;
+  /**
+   * Declarative attribute schema. The renderer dispatches filter / group /
+   * sort / display / inline-edit behavior on each descriptor's `type.kind`.
+   *
+   * Pass an `AttributesSource` ({ subscribe, getSnapshot }) instead of a
+   * static array to let the contribution mutate its schema at runtime —
+   * `WorkbenchKanbanView` subscribes so additions / removals / kind changes
+   * propagate live without re-registering the renderer.
+   */
+  attributes: AttributeDescriptor<TNode>[] | AttributesSource<TNode>;
+  /** Per-board-column overrides (color, drag/create rules, custom actions). */
+  getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig<TIcon>;
+  hideToolbar?: boolean;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  /** Initial settings/filters applied when the kanban renderer mounts. */
+  defaultSettings?: Partial<KanbanRendererSettings>;
+  defaultFilters?: KanbanRendererFilterState;
+  defaultViews?: KanbanRendererSavedView[];
+  defaultActiveViewId?: string;
+  /**
+   * Data source. Receives the current display state so backends can paginate
+   * / filter / sort. The renderer re-applies filter / sort / group locally,
+   * so this can return unfiltered rows in simple cases.
+   */
+  executeQuery(state: KanbanRendererQueryState): Promise<TRow[]> | TRow[];
+  subscribe?: (listener: () => void) => Disposable | (() => void);
+  /** 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<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
+   * column value).
+   */
+  onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
+  /** Manual within-column reorder (only fires when ordering is manual). */
+  onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
+  createRow?: KanbanRendererCreateRowConfig;
+  onCreateRow?: (submission: KanbanRendererCreateSubmission) => Promise<void> | void;
+  onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
+}
+//#endregion
+//#region src/core/registries/menus/menu-registry.d.ts
+type MenuPath = readonly string[];
+interface MenuItem {
+  commandId: string;
+  sourceCommandId?: 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;
+}
+interface RegisteredMenuItem extends MenuItem, RegisteredContributionMetadata {
+  path: MenuPath;
+}
+interface MenuRegistryStoreState {
+  itemsByPath: Record<string, RegisteredMenuItem[]>;
+}
+interface MenuRegistry {
+  menuStore: WorkbenchStore<MenuRegistryStoreState>;
+  registerMenuItem(path: MenuPath, item: MenuItem, metadata?: ContributionMetadata): Disposable;
+  listMenuItems(path: MenuPath): RegisteredMenuItem[];
+}
+//#endregion
+//#region src/core/registries/renderers/tree-renderer-types.d.ts
+interface TreeQueryContext {
+  filter?: string;
+  resource?: ResourceRef$1;
+  /** Widget/view contribution id for trees rendered through a view-backed widget. */
+  viewId?: string;
+}
+interface TreeContext extends TreeQueryContext {
+  state: Readonly<TreeRendererState>;
+  refresh(): void;
+  setSelectedNode(nodeId: string | undefined): void;
+}
+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;
+}
+type TreeNodeRowVariant = "empty-state";
+interface TreeNodeInlineInput {
+  ariaLabel: string;
+  defaultValue?: string;
+  placeholder?: string;
+  onCommit(value: string): Promise<void> | void;
+  onCancel?(): void;
+}
+interface TreeNode {
+  id: string;
+  selected?: boolean;
+  /** Host-owned customization boundary. Extension callbacks cannot set it. */
+  moveScope?: string;
+  label: string;
+  icon?: string;
+  iconElement?: unknown;
+  iconColor?: string;
+  iconTooltip?: string;
+  endContent?: unknown;
+  commandId?: string;
+  resource?: ResourceRef$1;
+  target?: NavigationTarget$1;
+  /** Visual row variant for non-data rows such as placeholders. */
+  rowVariant?: TreeNodeRowVariant;
+  inlineInput?: TreeNodeInlineInput;
+  actions?: TreeAction[];
+  contextMenuActions?: TreeAction[];
+  contextMenuPath?: MenuPath;
+  menuPath?: MenuPath;
+  menuPlacement?: "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "left-start";
+  showContextMenuTrigger?: boolean;
+  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;
+  /** When false, the node stays fixed within its Sidenav group. */
+  canReorder?: boolean;
+  /** Allow this node to be moved to another tree location. */
+  canDrag?: boolean;
+  /** Allow movable nodes to be dropped on this node. */
+  canDrop?: boolean;
+}
+interface TreeSectionEmptyState {
+  title: string;
+  description?: string;
+  icon?: string;
+}
+interface TreeViewSection {
+  id: string;
+  /** Host-owned customization boundary. Extension callbacks cannot set it. */
+  moveScope?: 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;
+  /** When false, the section stays fixed within the Sidenav main region. */
+  canReorder?: boolean;
+}
+interface TreeMoveEndpoint {
+  kind: "section" | "node";
+  sectionId: string;
+  id: string;
+  moveScope?: string;
+}
+type TreeMovePolicy = (move: {
+  source: TreeMoveEndpoint;
+  destination: TreeMoveEndpoint;
+}) => boolean;
+interface TreeRendererContribution {
+  id: string;
+  title: string;
+  icon?: string;
+  searchable?: boolean;
+  searchPlaceholder?: string;
+  when?: string;
+  defaultExpandedSectionIds?: string[];
+  defaultExpandedNodeIds?: string[];
+  getBody(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
+  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;
+}
+interface RegisteredTreeRendererContribution extends TreeRendererContribution, RegisteredContributionMetadata {}
+interface TreeRendererState {
+  expandedNodeIds: string[];
+  expandedSectionIds: string[];
+  selectedNodeId?: string;
+  loading?: boolean;
+}
+interface TreeRendererRefreshEvent {
+  treeId: string;
+}
+interface TreeRendererStoreState {
+  trees: Record<string, RegisteredTreeRendererContribution>;
+  statesByTreeId: Record<string, TreeRendererState>;
+  refreshKeysByTreeId: Record<string, number>;
+}
+interface PersistedTreeRendererStates {
+  statesByTreeId: Record<string, TreeRendererState>;
+}
+interface TreeRendererPersistenceAdapter {
+  getTreeStates(): PersistedTreeRendererStates | undefined;
+  setTreeStates(states: PersistedTreeRendererStates): void;
+}
+type TreeRendererImplementation = (input: WorkbenchPanelRenderInput & {
+  treeId: string;
+}) => unknown;
+type TreeRendererRefreshListener = (event: TreeRendererRefreshEvent) => void;
+interface TreeRendererRegistry {
+  treeStore: WorkbenchStore<TreeRendererStoreState>;
+  registerTreeRenderer(view: TreeRendererContribution, metadata?: ContributionMetadata): Disposable;
+  setTreeRendererImplementation(impl: TreeRendererImplementation): void;
+  getTreeRenderer(id: string): RegisteredTreeRendererContribution | undefined;
+  listTreeRenderers(): RegisteredTreeRendererContribution[];
+  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;
+  setSelectedNode(id: string, nodeId: string | undefined): void;
+  setLoading(id: string, loading: boolean): void;
+  refresh(id: string): void;
+  onDidRefresh(listener: TreeRendererRefreshListener): Disposable;
+}
+//#endregion
+//#region src/core/registries/views/view-registry.d.ts
+declare const workbenchViewIdContextKey = "workbench.view.id";
+type NativeViewBody<Kind extends string, Contribution> = {
+  kind: Kind;
+} & Omit<Contribution, "id" | "title" | "icon">;
+interface WorkbenchReactViewBody {
+  kind: "react";
+  render: WorkbenchRendererRegistration["render"];
+}
+type WorkbenchViewBody = WorkbenchReactViewBody | NativeViewBody<"tree", TreeRendererContribution> | NativeViewBody<"file", FileRendererContribution> | NativeViewBody<"controls", ControlsRendererContribution> | NativeViewBody<"kanban", KanbanRendererContribution> | NativeViewBody<"dataTable", DataTableRendererContribution>;
+interface WorkbenchViewContribution {
+  id: string;
+  title: string;
+  icon?: string;
+  body: WorkbenchViewBody;
+}
+type RegisteredWorkbenchView = WorkbenchViewContribution & RegisteredContributionMetadata;
+interface WorkbenchViewRegistryStoreState {
+  views: Record<string, RegisteredWorkbenchView>;
+}
+interface WorkbenchViewRegistry {
+  store: WorkbenchStore<WorkbenchViewRegistryStoreState>;
+  registerView(view: WorkbenchViewContribution, metadata?: ContributionMetadata): Disposable;
+  getView(viewId: string): RegisteredWorkbenchView | undefined;
+  listViews(): RegisteredWorkbenchView[];
+  refreshView(viewId: string, input?: unknown): void;
+}
+interface CreateWorkbenchViewRegistryInput {
+  registerBody(view: WorkbenchViewContribution, metadata?: ContributionMetadata): Disposable & {
+    refresh?(input?: unknown): void;
+  };
+}
+declare const createViewRegistry: (input: CreateWorkbenchViewRegistryInput) => WorkbenchViewRegistry;
+//#endregion
+//#region src/core/registries/view-menus/view-menu-registry.d.ts
+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;
+}
+interface WorkbenchViewMenuRegistry {
+  registerViewMenu(menu: WorkbenchViewMenuContribution): Disposable;
+  getViewMenu(id: string): WorkbenchViewMenuContribution | undefined;
+  listViewMenus(ownerViewId?: string): WorkbenchViewMenuContribution[];
+  definitionsFor(ownerViewId: string, placementId: string): readonly WorkbenchPanelMenuDefinition[];
+}
+//#endregion
+//#region src/core/registries/views/view-placement.d.ts
+interface WorkbenchPlacementPresentation {
+  mountStrategy?: WidgetMountStrategy;
+  hiddenByDefault?: boolean;
+  headerBorderBottom?: boolean;
+  tab?: WorkbenchPanelTab;
+  config?: unknown;
+}
+//#endregion
+//#region src/core/registries/pages/page-registry-types.d.ts
+interface WorkbenchPageSlot extends Omit<PageSlot, "tab"> {
+  readonly tab?: WorkbenchPlacementPresentation["tab"];
+}
+type WorkbenchPageMain = PageMain extends (infer Main) ? Main extends PageMain ? Omit<Main, "tab"> & {
+  readonly tab?: WorkbenchPlacementPresentation["tab"];
+} : never : never;
+interface WorkbenchPageContribution {
+  id: string;
+  ref: PageRef;
+  title?: Localizable<string>;
+  icon?: string;
+  path: string;
+  modeId: string;
+  parentId?: string;
+  resource?: ResourceConstraint;
+  main: WorkbenchPageMain;
+  slots: readonly WorkbenchPageSlot[];
+}
+interface WorkbenchPageResourceCodec {
+  normalize(resource: ResourceRef): ResourceRef;
+  toUri(resource: ResourceRef): string;
+  fromUri(uri: string): ResourceRef | undefined;
+}
+interface WorkbenchPageSlotOpenInput {
+  pageId: string;
+  slotId: string;
+  resource?: ResourceRef;
+  open?: PageOpenIntent;
+}
+interface WorkbenchPageSlotInstance {
+  instanceKey: string;
+  resource: ResourceRef;
+  section?: FileRendererSectionTarget;
+  open?: PageOpenIntent;
+}
+interface WorkbenchPageRuntimeState {
+  openStaticSlotIds: readonly string[];
+  resourceInstances: Readonly<Record<string, readonly WorkbenchPageSlotInstance[]>>;
+  activePrimaryInstanceKey?: string;
+}
+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>;
+}
+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;
+}
+//#endregion
+//#region src/core/controllers/page-location/page-location-types.d.ts
+interface WorkbenchPageBrowserEntry {
+  url: string;
+  state?: unknown;
+}
+interface WorkbenchPageLocationBrowser {
+  current(): WorkbenchPageBrowserEntry;
+  push(entry: WorkbenchPageBrowserEntry): void;
+  replace(entry: WorkbenchPageBrowserEntry): void;
+  back(): void;
+  forward(): void;
+  onPopState(listener: (entry: WorkbenchPageBrowserEntry) => void): {
+    dispose(): void;
+  };
+}
+interface WorkbenchPageLocationPersistence {
+  load(projectId: string): PageLocation | undefined;
+  save(projectId: string, location: PageLocation): void;
+}
+interface WorkbenchPageLocationDiagnostic {
+  code: "page-location-unresolved";
+  source: "boot" | "history" | "navigation" | "project-switch";
+  message: string;
+}
+type WorkbenchPageNavigationResult = {
+  ok: true;
+  location: PageLocation;
+} | {
+  ok: false;
+  diagnostic: WorkbenchPageLocationDiagnostic;
+};
+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): WorkbenchPageNavigationResult;
+  replay(location: PageLocation): WorkbenchPageNavigationResult;
+  navigateToParent(): WorkbenchPageNavigationResult;
+  closePlacement(identity: PlacementIdentity): WorkbenchPageNavigationResult;
+  removeResource(resource: ResourceRef, retained: readonly PlacementIdentity[]): void;
+  goBack(): void;
+  goForward(): void;
+  dispose(): void;
+}
+interface WorkbenchPageLocationHistoryState {
+  canGoBack: boolean;
+  canGoForward: boolean;
+}
+//#endregion
+//#region src/core/controllers/panel-menus/panel-menu-state-controller.d.ts
+interface WorkbenchPanelMenuState {
+  openByMenuId: Record<string, boolean>;
+}
+interface PersistedWorkbenchPanelMenuState {
+  openByMenuId: Record<string, boolean>;
+}
+interface WorkbenchPanelMenuStatePersistenceAdapter {
+  getMenuStates(scope?: string): PersistedWorkbenchPanelMenuState | undefined;
+  setMenuStates(state: PersistedWorkbenchPanelMenuState, scope?: string): void;
+}
+type WorkbenchPanelMenuStateChangeListener = (state: WorkbenchPanelMenuState) => void;
+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;
+}
+//#endregion
+//#region src/core/controllers/side-panel/side-panel-controller.d.ts
+type WorkbenchSidePanelMode = "floating" | "closed" | "attached";
+type WorkbenchSidePanelChangeListener = (mode: WorkbenchSidePanelMode) => void;
+interface WorkbenchSidePanelState {
+  mode: WorkbenchSidePanelMode;
+}
+interface WorkbenchSidePanelController {
+  canFloat(): boolean;
+  store: WorkbenchStore<WorkbenchSidePanelState>;
+  getMode(): WorkbenchSidePanelMode;
+  setMode(mode: WorkbenchSidePanelMode): void;
+  onDidChange(listener: WorkbenchSidePanelChangeListener): Disposable;
+}
+interface WorkbenchSidePanelPersistenceAdapter {
+  getMode(): WorkbenchSidePanelMode | undefined;
+  setMode(mode: WorkbenchSidePanelMode): void;
+}
+//#endregion
+//#region src/core/controllers/shell/shell-controller.d.ts
+type WorkbenchSidePanelPresentation = WorkbenchSidePanelMode;
+type WorkbenchShellOpenRegion = "sidenav" | "secondary" | "side";
+interface WorkbenchShellRegionState {
+  open: boolean;
+  size?: number;
+}
+interface WorkbenchShellController {
+  getRegionState(region: WorkbenchRegion): WorkbenchShellRegionState;
+  setRegionOpen(region: WorkbenchShellOpenRegion, open: boolean): void;
+  setRegionSize(region: WorkbenchRegion, size: number): void;
+  getSidePanelPresentation(): WorkbenchSidePanelPresentation;
+  setSidePanelPresentation(presentation: WorkbenchSidePanelPresentation): void;
+  onDidChange(listener: () => void): Disposable;
+}
+//#endregion
+//#region src/core/controllers/terminal/terminal-controller.d.ts
+interface WorkbenchTerminalSessionRequest {
+  command?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  cols: number;
+  rows: number;
+}
+interface WorkbenchTerminalSessionExit {
+  code: number | null;
+  signal: string | null;
+}
+interface WorkbenchTerminalSessionError {
+  message: string;
+}
+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;
+}
+type WorkbenchTerminalSessionOpener = (request: WorkbenchTerminalSessionRequest) => Promise<WorkbenchTerminalSessionAdapter>;
+type WorkbenchTerminalSessionStatus = "running" | "exited" | "killed";
+interface WorkbenchTerminalSessionModel {
+  id: string;
+  title: string;
+  status: WorkbenchTerminalSessionStatus;
+  exit?: WorkbenchTerminalSessionExit;
+}
+interface WorkbenchTerminalState {
+  sessionsById: Record<string, WorkbenchTerminalSessionModel>;
+}
+interface WorkbenchTerminalSessionSink {
+  onData?(chunk: Uint8Array): void;
+  onExit?(exit: WorkbenchTerminalSessionExit): void;
+  onError?(error: WorkbenchTerminalSessionError): void;
+}
+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: {
+    bindingId?: string;
+    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>;
+  killBinding(bindingId: 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>;
+}
+//#endregion
+//#region src/core/registries/command-palette-resources/command-palette-resource-registry.d.ts
+interface CommandPaletteResourceQueryContext {
+  query: string;
+  limit: number;
+}
+interface CommandPaletteResourceResult {
+  id: string;
+  label: string;
+  description?: string;
+  icon?: string;
+  keywords?: string[];
+  group?: string;
+  activate(): void | Promise<void>;
+}
+interface CommandPaletteResourceProvider {
+  id: string;
+  title: string;
+  refreshEventIds?: string[];
+  query(context: CommandPaletteResourceQueryContext): Promise<readonly CommandPaletteResourceResult[]>;
+}
+interface CommandPaletteResourceProviderResult {
+  providerId: string;
+  title: string;
+  results: readonly CommandPaletteResourceResult[];
+}
+interface CommandPaletteResourceRegistryStoreState {
+  providers: Record<string, CommandPaletteResourceProvider>;
+  refreshToken: number;
+}
+interface CommandPaletteResourceRegistry {
+  store: WorkbenchStore<CommandPaletteResourceRegistryStoreState>;
+  registerProvider(provider: CommandPaletteResourceProvider): Disposable;
+  listProviders(): CommandPaletteResourceProvider[];
+  queryProviders(context: CommandPaletteResourceQueryContext): Promise<CommandPaletteResourceProviderResult[]>;
+  refresh(): void;
+}
+//#endregion
+//#region src/core/registries/keybindings/keybinding-registry.d.ts
+interface Keybinding {
+  /** Action the chord executes through the shared navigation executor. */
+  action: NavigationTarget$1;
+  keybinding: KeybindingSequence;
+  when?: string;
+}
+type KeybindingSequence = string | string[];
+interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {}
+interface KeybindingRegistryStoreState {
+  keybindings: RegisteredKeybinding[];
+}
+interface KeybindingRegistry {
+  store: WorkbenchStore<KeybindingRegistryStoreState>;
+  registerKeybinding(keybinding: Keybinding, metadata?: ContributionMetadata): Disposable;
+  listKeybindings(): RegisteredKeybinding[];
+  listActiveKeybindings(): RegisteredKeybinding[];
+  /** Chords bound to plain command actions, for rendering shortcut hints beside commands. */
+  listCommandKeybindings(): {
+    commandId: string;
+    keybinding: KeybindingSequence;
+  }[];
+}
+declare const getKeybindingSteps: (keybinding: KeybindingSequence) => string[];
+//#endregion
+//#region src/core/registries/placements/owned-placement-lifecycle.d.ts
+type WorkbenchOwnedPlacementItem = PlacementItem;
+//#endregion
+//#region src/core/registries/placements/owned-placement-preparation.d.ts
+interface OwnedPlacementLocationContext {
+  modeId: string;
+  pageId?: string;
+  projectId?: string;
+  location?: PageLocation;
+}
+//#endregion
+//#region src/core/registries/modes/mode-placement-registry.d.ts
+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[];
+}
+interface OpenModePlacementTarget {
+  panel: PlacementRef;
+  resource?: ResourceRef$1;
+  open?: PageOpenIntent;
+}
+interface WorkbenchModePlacementRegistry {
+  registerPlacement(placement: WorkbenchModePlacementContribution): Disposable;
+  getPlacement(ref: PlacementRef): WorkbenchModePlacementContribution | undefined;
+  listPlacements(modeId?: string): WorkbenchModePlacementContribution[];
+  openPlacement(input: OpenModePlacementTarget): PlacementIdentity;
+  updatePlacement(identity: PlacementIdentity, input: {
+    resource?: ResourceRef$1;
+    title?: string;
+    open?: PageOpenIntent;
+  }): void;
+  closePlacement(identity: PlacementIdentity): void;
+  resolvePlacements(modeId: string, context?: OwnedPlacementLocationContext): readonly ResolvedOwnedPlacement<WorkbenchWidgetPlacement>[];
+  onDidChange(listener: () => void): Disposable;
+}
+//#endregion
+//#region src/core/registries/navigation/navigation-tree-registry.d.ts
+type NavigationTreeSlot = "header" | "content" | "footer";
+interface NavigationTreeOwner {
+  kind: "mode" | "page";
+  id: string;
+  extensionId: string;
+}
+interface NavigationTreeContext {
+  resource?: ResourceRef$1;
+}
+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[];
+}
+interface NavigationTreeRegistry {
+  registerContribution(contribution: NavigationTreeContribution): Disposable;
+  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;
+}
+//#endregion
+//#region src/core/registries/notifications/notification-registry.d.ts
+type WorkbenchNotificationLevel = "info" | "success" | "warning" | "error";
+interface WorkbenchNotificationAction {
+  commandId: string;
+  title: string;
+  args?: unknown;
+}
+interface WorkbenchNotification {
+  id?: string;
+  level: WorkbenchNotificationLevel;
+  title: string;
+  message?: string;
+  createdAt?: string;
+  resource?: ResourceRef$1;
+  actions?: WorkbenchNotificationAction[];
+  metadata?: Record<string, unknown>;
+}
+interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
+  id: string;
+  level: WorkbenchNotificationLevel;
+  title: string;
+  message?: string;
+  createdAt: string;
+  resource?: ResourceRef$1;
+  actions?: WorkbenchNotificationAction[];
+  metadata?: Record<string, unknown>;
+}
+type WorkbenchNotificationEvent = {
+  type: "show";
+  id: string;
+  notification: RegisteredWorkbenchNotification;
+} | {
+  type: "dismiss";
+  id: string;
+};
+type WorkbenchNotificationListener = (event: WorkbenchNotificationEvent) => void;
+interface WorkbenchNotificationStoreState {
+  notifications: Record<string, RegisteredWorkbenchNotification>;
+}
+interface NotificationRegistry {
+  store: WorkbenchStore<WorkbenchNotificationStoreState>;
+  show(notification: WorkbenchNotification, metadata?: ContributionMetadata): RegisteredWorkbenchNotification;
+  dismiss(id: string): boolean;
+  clear(): void;
+  listNotifications(): RegisteredWorkbenchNotification[];
+  subscribe(listener: WorkbenchNotificationListener): Disposable;
+}
+//#endregion
+//#region src/core/registries/overlays/overlay-registry.d.ts
+interface WorkbenchOverlayContribution extends Omit<WorkbenchPlacementPresentation, "mountStrategy"> {
+  id: string;
+  viewId: string;
+  closable?: boolean;
+}
+interface OpenWorkbenchOverlayInput {
+  resource?: ResourceRef$1;
+  title?: string;
+}
+interface WorkbenchOverlayRegistry {
+  registerOverlay(overlay: WorkbenchOverlayContribution): Disposable;
+  getOverlay(id: string): WorkbenchOverlayContribution | undefined;
+  listOverlays(): WorkbenchOverlayContribution[];
+  openOverlay(id: string, input?: OpenWorkbenchOverlayInput): string;
+  closeOverlay(instanceId: string): void;
+}
+//#endregion
+//#region src/core/registries/placeholders/placeholder-registry.d.ts
+interface WorkbenchPlaceholderContribution {
+  id: string;
+  viewId: string;
+  title?: string;
+  region: WorkbenchRegion;
+  regionSize?: WorkbenchRegionSize;
+  regionCollapsible?: boolean;
+  config?: unknown;
+}
+interface WorkbenchPlaceholderRegistry {
+  registerPlaceholder(placeholder: WorkbenchPlaceholderContribution, metadata?: ContributionMetadata): Disposable;
+}
+//#endregion
+//#region src/core/registries/placements/shell-placement-registry.d.ts
+interface WorkbenchShellPlacementContribution extends WorkbenchPlacementPresentation {
+  readonly id: string;
+  readonly item: WorkbenchOwnedPlacementItem;
+  readonly region: WorkbenchRegion;
+  readonly order?: number;
+}
+interface OpenWorkbenchShellPlacementInput {
+  placementId: string;
+  resource?: ResourceRef$1;
+  open?: PageOpenIntent;
+  title?: string;
+}
+interface WorkbenchShellPlacementRegistry {
+  registerPlacement(placement: WorkbenchShellPlacementContribution): Disposable;
+  getPlacement(placementId: string): WorkbenchShellPlacementContribution | undefined;
+  listPlacements(): WorkbenchShellPlacementContribution[];
+  openPlacement(input: OpenWorkbenchShellPlacementInput): PlacementIdentity;
+  updatePlacement(identity: PlacementIdentity, input: {
+    resource?: ResourceRef$1;
+    title?: string;
+    open?: PageOpenIntent;
+  }): void;
+  closePlacement(identity: PlacementIdentity): void;
+  resolvePlacements(context?: OwnedPlacementLocationContext): readonly ResolvedOwnedPlacement<WorkbenchWidgetPlacement>[];
+  onDidChange(listener: () => void): Disposable;
+}
+//#endregion
+//#region src/core/registries/preferences/preference-registry.d.ts
+type PreferenceScope = "default" | "user" | "project" | "repo" | "workspace" | "extension" | "session";
+type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
+interface PreferencePropertySchema {
+  type: "boolean" | "number" | "string" | "array" | "object";
+  enum?: PreferenceValue[];
+  default?: PreferenceValue;
+  scope: PreferenceScope;
+  description?: string;
+}
+interface PreferenceSchemaContribution {
+  properties: Record<string, PreferencePropertySchema>;
+}
+interface PreferenceScopeRef {
+  scope: PreferenceScope;
+  scopeId?: string;
+}
+interface PreferencePersistenceAdapter {
+  getValue(name: string, scope: PreferenceScopeRef): PreferenceValue | undefined;
+  setValue(name: string, value: PreferenceValue, scope: PreferenceScopeRef): void;
+}
+type RegisteredPreferenceSchema = PreferencePropertySchema & {
+  ownerId: string;
+  source: string;
+};
+interface PreferenceRegistryStoreState {
+  schemas: Record<string, RegisteredPreferenceSchema>;
+}
+interface PreferenceRegistry {
+  store: WorkbenchStore<PreferenceRegistryStoreState>;
+  registerSchema(schema: PreferenceSchemaContribution, metadata?: ContributionMetadata): Disposable;
+  getSchema(name: string): RegisteredPreferenceSchema | undefined;
+  setValue(name: string, value: PreferenceValue, scope: PreferenceScopeRef): void;
+  getValue(name: string, scope?: PreferenceScopeRef): PreferenceValue | undefined;
+}
+//#endregion
+//#region src/core/registries/settings/settings-registry.d.ts
+/** Settings are stored either per-user (global) or per-project. Projectless surfaces show only global entries. */
+type SettingsScope = "global" | "project";
+/** A "+ create"-style action surfaced on a section or a collection's parent node. */
+interface SettingsAction {
+  id: string;
+  label: string;
+  icon?: string;
+  run(): void | Promise<void>;
+}
+/** An ordered sidenav container. Headerless when `title` is omitted. */
+interface SettingsSectionContribution {
+  id: string;
+  title?: string;
+  order?: number;
+  scope?: SettingsScope;
+  actions?: SettingsAction[];
+}
+type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
+/** A preference this panel edits; a bare string uses the preference name as its label. */
+type SettingsPanelPreference = string | {
+  name: string;
+  label?: string;
+};
+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;
+}
+/** Auto-rendered as a param editor from the registered preference schema. */
+interface SchemaSettingsPanel extends SettingsPanelBase {
+  kind: "schema";
+  preferences: SettingsPanelPreference[];
+  /** "live" persists on change (default); "apply" stages edits behind Save/Discard. */
+  save?: "live" | "apply";
+}
+interface ViewSettingsPanel extends SettingsPanelBase {
+  kind: "view";
+  viewId: string;
+}
+interface SettingsCollectionGroupBy<TItem> {
+  key(item: TItem): string;
+  order?: string[];
+  label(key: string): string;
+  icon?(key: string): string | undefined;
+}
+/**
+ * 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.
+ */
+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>;
+  actions?: SettingsAction[];
+}
+type SettingsPanelContribution = SchemaSettingsPanel | ViewSettingsPanel | CollectionSettingsPanel;
+type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
+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;
+}
+interface SettingsRegistry {
+  store: WorkbenchStore<SettingsRegistryStoreState>;
+  registerSection(section: SettingsSectionContribution, metadata?: ContributionMetadata): Disposable;
+  registerPanel<TItem = unknown>(panel: SchemaSettingsPanel | ViewSettingsPanel | CollectionSettingsPanel<TItem>, metadata?: ContributionMetadata): Disposable;
+  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;
+}
+//#endregion
+//#region src/core/registries/status-bar/status-bar-registry.d.ts
+type WorkbenchStatusBarSlot = "leading" | "trailing";
+interface WorkbenchStatusBarItem {
+  id: string;
+  viewId: string;
+  slot: WorkbenchStatusBarSlot;
+  order?: number;
+  isVisible?(): boolean;
+}
+interface WorkbenchStatusBarRegistryState {
+  items: Record<string, WorkbenchStatusBarItem>;
+}
+interface WorkbenchStatusBarRegistry {
+  store: WorkbenchStore<WorkbenchStatusBarRegistryState>;
+  registerItem(item: WorkbenchStatusBarItem): Disposable;
+  getItem(id: string): WorkbenchStatusBarItem | undefined;
+  listItems(): WorkbenchStatusBarItem[];
+  listVisibleItems(slot?: WorkbenchStatusBarSlot): WorkbenchStatusBarItem[];
+}
+interface CreateWorkbenchStatusBarRegistryInput {
+  hasView(viewId: string): boolean;
+}
+declare const createStatusBarRegistry: (input: CreateWorkbenchStatusBarRegistryInput) => WorkbenchStatusBarRegistry;
+//#endregion
+//#region src/core/registries/statuses/status-registry.d.ts
+interface WorkflowStatus {
+  id: string;
+  label: string;
+  color: string;
+  icon?: string | null;
+  sortOrder: number;
+  isDefault?: boolean;
+  actions?: readonly string[];
+}
+interface WorkflowStatusAction {
+  id: string;
+  label: string;
+  icon?: string;
+}
+interface WorkbenchStatusSetContribution {
+  id: string;
+  title: string;
+  actions?: readonly WorkflowStatusAction[];
+  query(): Promise<readonly WorkflowStatus[]> | readonly WorkflowStatus[];
+  save?(statuses: readonly WorkflowStatus[]): Promise<readonly WorkflowStatus[]> | readonly WorkflowStatus[];
+}
+type RegisteredWorkbenchStatusSet = WorkbenchStatusSetContribution & RegisteredContributionMetadata;
+interface WorkbenchStatusRegistryState {
+  statusSets: Record<string, RegisteredWorkbenchStatusSet>;
+  values: Record<string, readonly WorkflowStatus[]>;
+}
+interface WorkbenchStatusRegistry {
+  store: WorkbenchStore<WorkbenchStatusRegistryState>;
+  registerStatusSet(contribution: WorkbenchStatusSetContribution, metadata?: ContributionMetadata): Disposable;
+  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 const createStatusRegistry: () => WorkbenchStatusRegistry;
+//#endregion
+//#region src/core/registries/themes/file-icon-theme-contracts.d.ts
+/**
+ * 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.
+ */
+interface FileIconThemeFont {
+  fontFamily: string;
+  src: {
+    url: string;
+    format?: string;
+  }[];
+  weight?: string;
+  style?: string;
+}
+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[];
+}
+//#endregion
+//#region src/core/registries/themes/file-icon-theme-registry.d.ts
+interface WorkbenchFileIconThemeStoreState {
+  themes: readonly FileIconThemePreferenceOption[];
+}
+interface FileIconThemeRegistry {
+  store: WorkbenchStore<WorkbenchFileIconThemeStoreState>;
+  register(themes: readonly FileIconThemePreferenceOption[]): Disposable;
+  listThemes(): readonly FileIconThemePreferenceOption[];
+}
+//#endregion
+//#region src/core/registries/themes/theme-contracts.d.ts
+/**
+ * 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.
+ */
+type ThemePreference = string;
+type ThemePreferenceMode = "light" | "dark";
+type ThemePreferenceTokens = Record<string, string>;
+interface ThemePreferenceOption {
+  id: ThemePreference;
+  title?: string;
+  mode: ThemePreferenceMode;
+  tokens?: ThemePreferenceTokens;
+  monacoTheme?: unknown;
+}
+//#endregion
+//#region src/core/registries/themes/theme-registry.d.ts
+interface WorkbenchThemeStoreState {
+  themes: readonly ThemePreferenceOption[];
+}
+interface ThemeRegistry {
+  store: WorkbenchStore<WorkbenchThemeStoreState>;
+  register(themes: readonly ThemePreferenceOption[]): Disposable;
+  listThemes(): readonly ThemePreferenceOption[];
+}
+//#endregion
+//#region src/core/workbench-core-types.d.ts
+type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
+type WorkbenchModuleLayoutModel = Omit<WorkbenchLayoutModel, "registerPanel" | "registerWidget" | "openPanel" | "openWidget" | "registerPlaceholder" | "registerPanelMenu">;
+type WorkbenchTreeViews = Pick<TreeRendererRegistry, "getTreeState" | "setNodeExpanded" | "setSectionExpanded" | "setSelectedNode">;
+interface WorkbenchCoreContributionContext {
+  pinPlacement(identity: import("@pstdio/sdk/extensions").PlacementIdentity): void;
+  closePlacement(identity: import("@pstdio/sdk/extensions").PlacementIdentity): void;
+  breadcrumbs: WorkbenchBreadcrumbController;
+  commandPalette: WorkbenchCommandPaletteController;
+  commandPaletteResources: CommandPaletteResourceRegistry;
+  commands: CommandRegistry;
+  composition: WorkbenchCompositionController;
+  context: ContextKeyService;
+  focus: WorkbenchFocusController;
+  keybindings: KeybindingRegistry;
+  layout: WorkbenchModuleLayoutModel;
+  modes: WorkbenchModeRegistry;
+  modePlacements: WorkbenchModePlacementRegistry;
+  shellPlacements: WorkbenchShellPlacementRegistry;
+  navigation: NavigationRegistry;
+  navigationTrees: NavigationTreeRegistry;
+  notifications: NotificationRegistry;
+  overlays: WorkbenchOverlayRegistry;
+  placeholders: WorkbenchPlaceholderRegistry;
+  pageLocations: WorkbenchPageLocationController;
+  pages: WorkbenchPageRegistry<WorkbenchWidgetPlacement>;
+  panelMenuState: WorkbenchPanelMenuStateController;
+  preferences: PreferenceRegistry;
+  treeViews: WorkbenchTreeViews;
+  resources: ResourceRegistry;
+  views: WorkbenchViewRegistry;
+  viewMenus: WorkbenchViewMenuRegistry;
+  settings: SettingsRegistry;
+  statusBar: WorkbenchStatusBarRegistry;
+  statuses: WorkbenchStatusRegistry;
+  shell: WorkbenchShellController;
+  sidePanel: WorkbenchSidePanelController;
+  terminal: WorkbenchTerminalController;
+  themes: ThemeRegistry;
+  fileIconThemes: FileIconThemeRegistry;
+  getPrimaryResource(): ResourceRef$1 | undefined;
+  onDidChangePrimaryResource(listener: (resource: ResourceRef$1 | undefined) => void): Disposable;
+  getActiveResource(): ResourceRef$1 | undefined;
+  onDidChangeActiveResource(listener: (resource: ResourceRef$1 | undefined) => void): Disposable;
+  registerChildModule(module: WorkbenchModuleContribution): Disposable;
+}
+interface WorkbenchSnapshot {
+  layout: WorkbenchLayout;
+}
+interface WorkbenchPersistenceAdapter {
+  getSnapshot(scope?: string): WorkbenchSnapshot | undefined;
+  setSnapshot(snapshot: WorkbenchSnapshot, scope?: string): void;
+  flush?(): void;
+  dispose?(): void;
+}
+interface WorkbenchHost {
+  getSnapshot(): WorkbenchSnapshot;
+  restoreSnapshot(snapshot: WorkbenchSnapshot): void;
+  setPersistenceScope(scope: string | undefined, input?: {
+    carryRegions?: readonly WorkbenchRegion[];
+  }): void;
+  getPersistenceScope(): string | undefined;
+}
+interface WorkbenchCore extends WorkbenchCoreContributionContext {
+  host: WorkbenchHost;
+  layout: WorkbenchLayoutModel;
+  registerModule(module: WorkbenchModuleContribution): Disposable;
+  unregisterModule(moduleId: string): void;
+}
+type WorkbenchModuleContext = WorkbenchCoreContributionContext;
+type WorkbenchModuleContributionContext = WorkbenchModuleContext;
+interface WorkbenchPagePersistenceScopeInput {
+  currentScope?: string;
+  modeId?: string;
+  pageId?: string;
+  projectId?: string;
+  resource?: ResourceRef$1;
+}
+interface WorkbenchPagePersistenceScope {
+  scope?: string;
+  carryRegions?: readonly WorkbenchRegion[];
+}
+interface createWorkbenchInput {
+  isInScope?: (resource: ResourceRef$1, primary: ResourceRef$1 | undefined) => boolean;
+  layoutPersistence?: LayoutPersistenceAdapter;
+  pageLocationBrowser?: WorkbenchPageLocationBrowser;
+  pageLocationPersistence?: WorkbenchPageLocationPersistence;
+  resolvePagePersistenceScope?(input: WorkbenchPagePersistenceScopeInput): WorkbenchPagePersistenceScope;
+  pageResources?: WorkbenchPageResourceCodec;
+  persistence?: WorkbenchPersistenceAdapter;
+  preferencePersistence?: PreferencePersistenceAdapter;
+  treePersistence?: TreeRendererPersistenceAdapter;
+  panelMenuStatePersistence?: WorkbenchPanelMenuStatePersistenceAdapter;
+  defaultPanelOpenByRegionId?: Partial<Record<WorkbenchRegion, boolean>>;
+  /** Host-level region layout policy. The active mode's regionSettings win over it. */
+  regionSettings?: Partial<Record<WorkbenchRegion, WorkbenchRegionSettings>>;
+  sidePanelPersistence?: WorkbenchSidePanelPersistenceAdapter;
+  /** Default floating policy. The active mode may override it. */
+  floatingPanels?: "visible" | "hidden";
+  initialSidePanelMode?: WorkbenchSidePanelMode;
+  startPage?: PageRef;
+}
+type WorkbenchModuleActivationResult = Disposable | readonly Disposable[] | undefined;
+interface WorkbenchModuleContribution {
+  id: string;
+  source?: ContributionSource;
+  ownerId?: string;
+  activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
+}
+//#endregion
+//#region src/core/workbench-core.d.ts
+declare const createWorkbench: (input?: createWorkbenchInput) => WorkbenchCore;
+//#endregion
+//#region src/core/registries/modes/mode-layout.d.ts
+declare const getWorkbenchModePanelForRegion: (region: WorkbenchRegion) => "main" | "secondary" | "side" | undefined;
+declare const isWorkbenchModePanelAvailable: (mode: WorkbenchModeContribution | undefined, panel: WorkbenchPanelRegion) => boolean;
+//#endregion
+//#region src/core/registries/modes/mode-registry.d.ts
+type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
+type WorkbenchModeActivationResult = Disposable | readonly Disposable[] | undefined;
+interface WorkbenchModeAddablePanel {
+  panelId: string;
+  region: WorkbenchPanelRegion;
+  allowedRegions?: readonly WorkbenchRegion[];
+  pinned?: boolean;
+}
+interface WorkbenchModeAddablePanelContext {
+  layout: WorkbenchLayout;
+  resource?: ResourceRef$1;
+}
+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$1 | (() => Promise<ResourceRef$1 | undefined> | ResourceRef$1 | undefined);
+  listAddablePanels?(context: WorkbenchModeAddablePanelContext): readonly WorkbenchModeAddablePanel[];
+  activate(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+  seed?(ctx: WorkbenchModeActivationContext): void;
+  enter?(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+  reconcile?(ctx: WorkbenchModeActivationContext): void;
+}
+type WorkbenchModeChangeListener = () => void;
+interface WorkbenchModeStoreState {
+  modes: Record<string, WorkbenchModeContribution>;
+  activeModeId: string | undefined;
+}
+interface WorkbenchModeRegistry {
+  store: WorkbenchStore<WorkbenchModeStoreState>;
+  dispose(): void;
+  registerMode(mode: WorkbenchModeContribution): Disposable;
+  getMode(id: string): WorkbenchModeContribution | undefined;
+  listModes(): WorkbenchModeContribution[];
+  getActiveModeId(): string | undefined;
+  isTransitioning(): boolean;
+  setActiveMode(id: string | undefined, input?: {
+    deferSeed?: boolean;
+  }): void;
+  seedActiveMode(): void;
+  onDidChangeActive(listener: WorkbenchModeChangeListener): Disposable;
+}
+//#endregion
+//#region src/core/controllers/composition/composition-controller.d.ts
+interface WorkbenchCompositionAddablePanel extends WorkbenchModeAddablePanel {
+  contribution: RegisteredWidgetContribution;
+  open?(resource?: ResourceRef$1): void;
+}
+interface WorkbenchCompositionRegionPanels {
+  open: readonly WorkbenchWidgetPlacement[];
+  addable: readonly WorkbenchCompositionAddablePanel[];
+  closable: readonly string[];
+}
+interface WorkbenchCompositionController {
+  panelsFor(region: WorkbenchPanelRegion): WorkbenchCompositionRegionPanels;
+}
+//#endregion
+//#region src/core/registries/layout/surface-map.d.ts
+type AnchorId = "primary" | "secondary" | "attached";
+declare const resolveAnchorRegion: (anchorId: AnchorId) => "activity" | "sidenav" | "main" | "secondary" | "side" | "status" | "nav" | "main-header" | "main-left-menu" | "main-right-menu" | "secondary-header" | "secondary-left-menu" | "secondary-right-menu" | "side-header" | "side-left-menu" | "side-right-menu" | "overlay";
+//#endregion
+//#region src/core/registries/menus/workbench-menu-paths.d.ts
+declare const headerLeadingMenuPath: (region: string) => MenuPath;
+declare const headerTrailingMenuPath: (region: string) => MenuPath;
+declare const workbenchRegionTabLeadingMenuPath: (region: string) => MenuPath;
+declare const workbenchRegionTabAddMenuPath: (region: string) => MenuPath;
+declare const workbenchCommandPaletteMenuPath: readonly ["workbench", "commandPalette"];
+declare const workbenchTopHeaderLeadingMenuPath: MenuPath;
+declare const workbenchTopHeaderTrailingMenuPath: MenuPath;
+declare const resourceContextMenuPath: (resourceKind: string) => MenuPath;
+//#endregion
+//#region src/core/registries/resources/resource-icons.d.ts
+declare const standardResourceIcons: {
+  readonly project: "folder-root";
+  readonly workspace: "computer";
+  readonly worktree: "git-pull-request-draft";
+  readonly settings: "settings";
+  readonly kanbanRenderer: "table-properties";
+};
+type StandardResourceIcon = (typeof standardResourceIcons)[keyof typeof standardResourceIcons];
+//#endregion
+//#region src/core/shared/store/workbench-batch.d.ts
+/** Commit related stores before their subscribers read the resulting workbench state. */
+declare const batchWorkbenchChanges: <Result>(commit: () => Result) => Result;
+//#endregion
+export { WorkbenchStatusBarRegistryState as $, Disposable as $i, EnumOption as $n, WorkbenchWidgetPlacement as $r, WorkbenchTerminalSessionModel as $t, WorkbenchModuleContribution as A, ResourceProvider as Ai, TreeAction as An, ControlsQueryResult$1 as Ar, WorkbenchNotificationEvent as At, ThemePreferenceOption as B, ResourceHierarchyCycle as Bi, MenuItem as Bn, RegisteredWidgetContribution as Br, Keybinding as Bt, getWorkbenchModePanelForRegion as C, WorkbenchCommandExecutionContext as Ci, WorkbenchReactViewBody as Cn, DataTableRendererQueryResult as Cr, WorkbenchPlaceholderRegistry as Ct, WorkbenchCoreContributionContext as D, ResourceBrowseEntry as Di, WorkbenchViewRegistryStoreState as Dn, DataTableRendererThemeColor as Dr, RegisteredWorkbenchNotification as Dt, WorkbenchCore as E, WorkbenchBreadcrumbItem as Ei, WorkbenchViewRegistry as En, DataTableRendererSelectionAction as Er, NotificationRegistry as Et, WorkbenchSnapshot as F, getWorkbenchSelectionResourceKeys as Fi, TreeNodeInlineInput as Fn, WorkbenchPanelRenderInput as Fr, NavigationTreeRegistry as Ft, WorkbenchStatusRegistry as G, resourceHierarchyCycleCode as Gi, KanbanRendererQueryState as Gn, WorkbenchPanelTab as Gr, CommandPaletteResourceProviderResult as Gt, FileIconThemeRegistry as H, WorkbenchHierarchyNode as Hi, MenuRegistry as Hn, WorkbenchLayout as Hr, KeybindingSequence as Ht, createWorkbenchInput as I, workbenchResourceIdContextKey as Ii, TreeRendererContribution as In, WorkbenchFocusController as Ir, NavigationTreeSlot as It, WorkflowStatus as J, ContextKeyScope as Ji, AttributeKind as Jn, WorkbenchTabMenuGroup as Jr, CommandPaletteResourceResult as Jt, WorkbenchStatusRegistryState as K, ContributionMetadata as Ki, AttributeDescriptor as Kn, WorkbenchRegionSize as Kr, CommandPaletteResourceQueryContext as Kt, ThemeRegistry as L, workbenchResourceMetadataContextKey as Li, TreeRendererPersistenceAdapter as Ln, WorkbenchFocusRegionId as Lr, WorkbenchModePlacementContribution as Lt, WorkbenchPagePersistenceScope as M, ResourceRegistry as Mi, TreeMoveEndpoint as Mn, ControlsRendererLayout as Mr, NavigationTreeContext as Mt, WorkbenchPagePersistenceScopeInput as N, createWorkbenchResourceContextValues as Ni, TreeMovePolicy as Nn, ControlsResetInput as Nr, NavigationTreeContribution as Nt, WorkbenchHost as O, ResourceKindContribution as Oi, createViewRegistry as On, RegisteredDataTableRendererContribution as Or, WorkbenchNotification as Ot, WorkbenchPersistenceAdapter as P, createWorkbenchSelectionResourceMetadata as Pi, TreeNode as Pn, ControlsUpdateValueInput as Pr, NavigationTreeOwner as Pt, WorkbenchStatusBarRegistry as Q, WorkbenchStore as Qi, BoardColumnConfig as Qn, WorkbenchTabSnapshot as Qr, WorkbenchTerminalSessionExit as Qt, ThemePreference as R, workbenchResourceTypeContextKey as Ri, TreeRendererState as Rn, LayoutPersistenceAdapter as Rr, WorkbenchModePlacementRegistry as Rt, WorkbenchModeRegistry as S, CommandRegistry as Si, RegisteredWorkbenchView as Sn, DataTableRendererQueryContext as Sr, WorkbenchPlaceholderContribution as St, createWorkbench as T, WorkbenchBreadcrumbController as Ti, WorkbenchViewContribution as Tn, DataTableRendererRowAction as Tr, WorkbenchOverlayRegistry as Tt, FileIconThemeFont as U, WorkbenchViewHierarchyNode as Ui, RegisteredMenuItem as Un, WorkbenchPanelInstance as Ur, getKeybindingSteps as Ut, ThemePreferenceTokens as V, ResourceHierarchyProvider as Vi, MenuPath as Vn, WorkbenchCommandTarget as Vr, KeybindingRegistry as Vt, FileIconThemePreferenceOption as W, isWorkbenchViewHierarchyNode as Wi, KanbanRendererContribution as Wn, WorkbenchPanelMountStrategy as Wr, CommandPaletteResourceProvider as Wt, createStatusRegistry as X, ContextKeyValue as Xi, AttributesSource as Xn, WorkbenchTabPosition as Xr, WorkbenchTerminalSessionAdapter as Xt, WorkflowStatusAction as Y, ContextKeyService as Yi, AttributeType as Yn, WorkbenchTabMenuRow as Yr, WorkbenchTerminalController as Yt, WorkbenchStatusBarItem as Z, matchesContextExpression as Zi, BoardColumnAction as Zn, WorkbenchTabRetention as Zr, WorkbenchTerminalSessionError as Zt, WorkbenchModeActivationContext as _, Command as _i, WorkbenchPageNavigationResult as _n, FileRendererSaveResult as _r, PreferenceScope as _t, dockedWorkbenchRegions as a, workbenchPanelRegions as ai, WorkbenchShellController as an, KanbanRendererCreateSubmission as ar, SettingsCollectionGroupBy as at, WorkbenchModeAddablePanelContext as b, CommandParamOption as bi, WorkbenchViewMenuContribution as bn, DataTableRendererColumnStat as br, WorkbenchShellPlacementContribution as bt, resourceContextMenuPath as c, NavigationParser as ci, WorkbenchSidePanelPresentation as cn, KanbanRendererRow as cr, SettingsPanelPreference as ct, workbenchRegionTabLeadingMenuPath as d, NavigationTargetCommand as di, WorkbenchPanelMenuStatePersistenceAdapter as dn, SortDirection as dr, SettingsSectionContribution as dt, WorkbenchWidgetTab as ei, WorkbenchTerminalSessionOpener as en, EnumOptions as er, WorkbenchStatusBarSlot as et, workbenchTopHeaderLeadingMenuPath as f, NavigationTargetCompound as fi, WorkbenchPageBrowserEntry as fn, ViewMode as fr, ViewSettingsPanel as ft, defaultPageResourceCodec as g, WorkbenchCommandPaletteOpenInput as gi, WorkbenchPageLocationPersistence as gn, FileRendererRefreshOrigin as gr, PreferenceSchemaContribution as gt, resolveAnchorRegion as h, WorkbenchCommandPaletteController as hi, WorkbenchPageLocationDiagnostic as hn, FileRendererRefreshEnvelope as hr, PreferenceRegistry as ht, DockedWorkbenchRegion$1 as i, WorkbenchRegion as ii, WorkbenchTerminalState as in, KanbanRendererCreateRowConfig as ir, SettingsAction as it, WorkbenchModuleContributionContext as j, ResourceRef$1 as ji, TreeContext as jn, ControlsRendererContribution as jr, WorkbenchNotificationLevel as jt, WorkbenchModuleContext as k, ResourceListContext as ki, workbenchViewIdContextKey as kn, ControlsApplyInput as kr, WorkbenchNotificationAction as kt, workbenchCommandPaletteMenuPath as l, NavigationRegistry as li, WorkbenchSidePanelMode as ln, KanbanRendererSettings as lr, SettingsRegistry as lt, AnchorId as m, NavigationTargetPanel$1 as mi, WorkbenchPageLocationController as mn, FileRendererContribution as mr, PreferencePropertySchema as mt, StandardResourceIcon as n, WorkbenchPanelMenuSide as ni, WorkbenchTerminalSessionSink as nn, KanbanRendererCreateField as nr, CollectionSettingsPanel as nt, headerLeadingMenuPath as o, workbenchRegions as oi, WorkbenchShellOpenRegion as on, KanbanRendererFilterState as or, SettingsPanelBase as ot, workbenchTopHeaderTrailingMenuPath as p, NavigationTargetItem as pi, WorkbenchPageLocationBrowser as pn, FileRendererContent as pr, PreferencePersistenceAdapter as pt, WorkbenchStatusSetContribution as q, ContributionSource as qi, AttributeDisplayDescriptor as qn, WorkbenchTabAction as qr, CommandPaletteResourceRegistry as qt, standardResourceIcons as r, WorkbenchPanelRegion as ri, WorkbenchTerminalSessionStatus as rn, KanbanRendererCreateFieldType as rr, SchemaSettingsPanel as rt, headerTrailingMenuPath as s, NavigationDispatcherContext as si, WorkbenchShellRegionState as sn, KanbanRendererOrdering as sr, SettingsPanelContribution as st, batchWorkbenchChanges as t, WorkbenchPanelMenuRegion as ti, WorkbenchTerminalSessionRequest as tn, EnumOptionsSource as tr, createStatusBarRegistry as tt, workbenchRegionTabAddMenuPath as u, NavigationTarget$1 as ui, WorkbenchSidePanelPersistenceAdapter as un, ResourceContextAction as ur, SettingsScope as ut, WorkbenchModeActivationResult as v, CommandHandler as vi, WorkbenchPageContribution as vn, DataTableRendererColumn as vr, PreferenceScopeRef as vt, isWorkbenchModePanelAvailable as w, WorkbenchCommandExecutionError as wi, WorkbenchViewBody as wn, DataTableRendererRow as wr, WorkbenchOverlayContribution as wt, WorkbenchModeContribution as x, CommandParamSchema as xi, WorkbenchViewMenuRegistry as xn, DataTableRendererContribution as xr, WorkbenchShellPlacementRegistry as xt, WorkbenchModeAddablePanel as y, CommandParamDescriptor as yi, WorkbenchPlacementPresentation as yn, DataTableRendererColumnRenderer as yr, PreferenceValue as yt, ThemePreferenceMode as z, workbenchSelectionResourceKeyMetadataKey as zi, TreeViewSection as zn, RegisteredPlaceholderContribution as zr, WorkbenchOwnedPlacementItem as zt };
+export {};