@pstdio/workbench 0.12.0 → 0.36.0

package/dist/index-DSsmgN2a.d.ts

@@ -0,0 +1,2385 @@
+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 | undefined, signal: AbortSignal): 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 DataTableRendererBadgePalette = "gray" | "red" | "orange" | "yellow" | "green" | "teal" | "blue" | "cyan" | "purple" | "pink";
+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;
+  }>;
+} | {
+  type: "badge";
+  categories?: Array<{
+    value: string | number | boolean | null;
+    palette: DataTableRendererBadgePalette;
+  }>;
+} | {
+  type: "diff";
+} | {
+  type: "date";
+} | {
+  type: "path";
+};
+interface DataTableRendererColumn {
+  id: string;
+  label?: string;
+  description?: string;
+  icon?: unknown;
+  hidden?: boolean;
+  /** Starts unchecked in the column menu; viewers can still show the column. */
+  defaultHidden?: 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[];
+  /** Whether column statistics start visible. Defaults to `true`. */
+  defaultShowStats?: boolean;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  /** Context keys that choose which rows the query returns. A change drops the old rows and starts a new read. */
+  contextKeys?: string[];
+  executeQuery(context: DataTableRendererQueryContext, signal: AbortSignal): 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, signal: AbortSignal): 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, signal: AbortSignal): 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 {
+  signal?: AbortSignal;
+  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/renderer-read-registry.d.ts
+interface RendererReadRequest<T> {
+  queryKey: string;
+  load(signal: AbortSignal): Promise<T> | T;
+  onValue(value: T): void;
+  onError(error: unknown): void;
+}
+interface RendererReadBinding {
+  request<T>(request: RendererReadRequest<T>, reason?: "refresh" | "retry"): void;
+  dispose(): void;
+}
+interface RendererReadRegistry {
+  bind(key: string): RendererReadBinding;
+  dispose(): Promise<void>;
+}
+declare const createRendererReadRegistry: (options?: {
+  deadlineMs?: number;
+}) => RendererReadRegistry;
+//#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 {
+  reads: RendererReadRegistry;
+  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 isAvailable?: (resource: ResourceRef | undefined) => boolean;
+  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;
+  signal?: AbortSignal;
+}
+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 {
+  dispose(): Promise<void>;
+  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/registries/views/renderer-read-key.d.ts
+declare const rendererReadKey: (placement: WorkbenchPanelInstance, lane?: string) => string;
+//#endregion
+//#region src/core/registries/views/settle-read-batch.d.ts
+declare const settleReadBatch: <T>(tasks: ((signal: AbortSignal) => Promise<T> | T)[], signal?: AbortSignal) => Promise<Awaited<T>[]>;
+//#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 { WorkbenchStatusBarItem as $, resourceHierarchyCycleCode as $i, AttributeDescriptor as $n, WorkbenchPanelTab as $r, WorkbenchTerminalSessionError as $t, WorkbenchHost as A, CommandRegistry as Ai, createViewRegistry as An, DataTableRendererQueryContext as Ar, WorkbenchNotification as At, ThemePreference as B, ResourceRegistry as Bi, TreeNode as Bn, ControlsRendererLayout as Br, WorkbenchModePlacementRegistry as Bt, WorkbenchModeContribution as C, WorkbenchCommandPaletteController as Ci, WorkbenchViewMenuRegistry as Cn, FileRendererRefreshOrigin as Cr, WorkbenchShellPlacementRegistry as Ct, createWorkbench as D, CommandParamDescriptor as Di, WorkbenchViewContribution as Dn, DataTableRendererColumnRenderer as Dr, WorkbenchOverlayRegistry as Dt, isWorkbenchModePanelAvailable as E, CommandHandler as Ei, WorkbenchViewBody as En, DataTableRendererColumn as Er, WorkbenchOverlayContribution as Et, WorkbenchPagePersistenceScopeInput as F, ResourceBrowseEntry as Fi, createRendererReadRegistry as Fn, DataTableRendererThemeColor as Fr, NavigationTreeContribution as Ft, FileIconThemeFont as G, workbenchResourceMetadataContextKey as Gi, TreeRendererState as Gn, WorkbenchFocusRegionId as Gr, getKeybindingSteps as Gt, ThemePreferenceOption as H, createWorkbenchSelectionResourceMetadata as Hi, TreeQueryContext as Hn, ControlsUpdateValueInput as Hr, Keybinding as Ht, WorkbenchPersistenceAdapter as I, ResourceKindContribution as Ii, TreeAction as In, RegisteredDataTableRendererContribution as Ir, NavigationTreeOwner as It, WorkbenchStatusRegistryState as J, ResourceHierarchyCycle as Ji, MenuPath as Jn, RegisteredWidgetContribution as Jr, CommandPaletteResourceQueryContext as Jt, FileIconThemePreferenceOption as K, workbenchResourceTypeContextKey as Ki, TreeViewSection as Kn, LayoutPersistenceAdapter as Kr, CommandPaletteResourceProvider as Kt, WorkbenchSnapshot as L, ResourceListContext as Li, TreeContext as Ln, ControlsApplyInput as Lr, NavigationTreeRegistry as Lt, WorkbenchModuleContribution as M, WorkbenchCommandExecutionError as Mi, RendererReadBinding as Mn, DataTableRendererRow as Mr, WorkbenchNotificationEvent as Mt, WorkbenchModuleContributionContext as N, WorkbenchBreadcrumbController as Ni, RendererReadRegistry as Nn, DataTableRendererRowAction as Nr, WorkbenchNotificationLevel as Nt, WorkbenchCore as O, CommandParamOption as Oi, WorkbenchViewRegistry as On, DataTableRendererColumnStat as Or, NotificationRegistry as Ot, WorkbenchPagePersistenceScope as P, WorkbenchBreadcrumbItem as Pi, RendererReadRequest as Pn, DataTableRendererSelectionAction as Pr, NavigationTreeContext as Pt, createStatusRegistry as Q, isWorkbenchViewHierarchyNode as Qi, KanbanRendererQueryState as Qn, WorkbenchPanelMountStrategy as Qr, WorkbenchTerminalSessionAdapter as Qt, createWorkbenchInput as R, ResourceProvider as Ri, TreeMoveEndpoint as Rn, ControlsQueryResult$1 as Rr, NavigationTreeSlot as Rt, WorkbenchModeAddablePanelContext as S, NavigationTargetPanel$1 as Si, WorkbenchViewMenuContribution as Sn, FileRendererRefreshEnvelope as Sr, WorkbenchShellPlacementContribution as St, getWorkbenchModePanelForRegion as T, Command as Ti, WorkbenchReactViewBody as Tn, DataTableRendererBadgePalette as Tr, WorkbenchPlaceholderRegistry as Tt, ThemePreferenceTokens as U, getWorkbenchSelectionResourceKeys as Ui, TreeRendererContribution as Un, WorkbenchPanelRenderInput as Ur, KeybindingRegistry as Ut, ThemePreferenceMode as V, createWorkbenchResourceContextValues as Vi, TreeNodeInlineInput as Vn, ControlsResetInput as Vr, WorkbenchOwnedPlacementItem as Vt, FileIconThemeRegistry as W, workbenchResourceIdContextKey as Wi, TreeRendererPersistenceAdapter as Wn, WorkbenchFocusController as Wr, KeybindingSequence as Wt, WorkflowStatus as X, WorkbenchHierarchyNode as Xi, RegisteredMenuItem as Xn, WorkbenchLayout as Xr, CommandPaletteResourceResult as Xt, WorkbenchStatusSetContribution as Y, ResourceHierarchyProvider as Yi, MenuRegistry as Yn, WorkbenchCommandTarget as Yr, CommandPaletteResourceRegistry as Yt, WorkflowStatusAction as Z, WorkbenchViewHierarchyNode as Zi, KanbanRendererContribution as Zn, WorkbenchPanelInstance as Zr, WorkbenchTerminalController as Zt, resolveAnchorRegion as _, NavigationRegistry as _i, WorkbenchPageLocationDiagnostic as _n, ResourceContextAction as _r, PreferenceRegistry as _t, standardResourceIcons as a, matchesContextExpression as aa, WorkbenchTabRetention as ai, WorkbenchTerminalSessionStatus as an, BoardColumnConfig as ar, SchemaSettingsPanel as at, WorkbenchModeActivationResult as b, NavigationTargetCompound as bi, WorkbenchPageContribution as bn, FileRendererContent as br, PreferenceScopeRef as bt, headerLeadingMenuPath as c, WorkbenchWidgetTab as ci, WorkbenchShellOpenRegion as cn, EnumOptionsSource as cr, SettingsPanelBase as ct, workbenchCommandPaletteMenuPath as d, WorkbenchPanelRegion as di, WorkbenchSidePanelMode as dn, KanbanRendererCreateRowConfig as dr, SettingsRegistry as dt, ContributionMetadata as ea, WorkbenchRegionSize as ei, WorkbenchTerminalSessionExit as en, AttributeDisplayDescriptor as er, WorkbenchStatusBarRegistry as et, workbenchRegionTabAddMenuPath as f, WorkbenchRegion as fi, WorkbenchSidePanelPersistenceAdapter as fn, KanbanRendererCreateSubmission as fr, SettingsScope as ft, AnchorId as g, NavigationParser as gi, WorkbenchPageLocationController as gn, KanbanRendererSettings as gr, PreferencePropertySchema as gt, workbenchTopHeaderTrailingMenuPath as h, NavigationDispatcherContext as hi, WorkbenchPageLocationBrowser as hn, KanbanRendererRow as hr, PreferencePersistenceAdapter as ht, StandardResourceIcon as i, ContextKeyValue as ia, WorkbenchTabPosition as ii, WorkbenchTerminalSessionSink as in, BoardColumnAction as ir, CollectionSettingsPanel as it, WorkbenchModuleContext as j, WorkbenchCommandExecutionContext as ji, workbenchViewIdContextKey as jn, DataTableRendererQueryResult as jr, WorkbenchNotificationAction as jt, WorkbenchCoreContributionContext as k, CommandParamSchema as ki, WorkbenchViewRegistryStoreState as kn, DataTableRendererContribution as kr, RegisteredWorkbenchNotification as kt, headerTrailingMenuPath as l, WorkbenchPanelMenuRegion as li, WorkbenchShellRegionState as ln, KanbanRendererCreateField as lr, SettingsPanelContribution as lt, workbenchTopHeaderLeadingMenuPath as m, workbenchRegions as mi, WorkbenchPageBrowserEntry as mn, KanbanRendererOrdering as mr, ViewSettingsPanel as mt, settleReadBatch as n, ContextKeyScope as na, WorkbenchTabMenuGroup as ni, WorkbenchTerminalSessionOpener as nn, AttributeType as nr, WorkbenchStatusBarSlot as nt, DockedWorkbenchRegion$1 as o, WorkbenchStore as oa, WorkbenchTabSnapshot as oi, WorkbenchTerminalState as on, EnumOption as or, SettingsAction as ot, workbenchRegionTabLeadingMenuPath as p, workbenchPanelRegions as pi, WorkbenchPanelMenuStatePersistenceAdapter as pn, KanbanRendererFilterState as pr, SettingsSectionContribution as pt, WorkbenchStatusRegistry as q, workbenchSelectionResourceKeyMetadataKey as qi, MenuItem as qn, RegisteredPlaceholderContribution as qr, CommandPaletteResourceProviderResult as qt, rendererReadKey as r, ContextKeyService as ra, WorkbenchTabMenuRow as ri, WorkbenchTerminalSessionRequest as rn, AttributesSource as rr, createStatusBarRegistry as rt, dockedWorkbenchRegions as s, Disposable as sa, WorkbenchWidgetPlacement as si, WorkbenchShellController as sn, EnumOptions as sr, SettingsCollectionGroupBy as st, batchWorkbenchChanges as t, ContributionSource as ta, WorkbenchTabAction as ti, WorkbenchTerminalSessionModel as tn, AttributeKind as tr, WorkbenchStatusBarRegistryState as tt, resourceContextMenuPath as u, WorkbenchPanelMenuSide as ui, WorkbenchSidePanelPresentation as un, KanbanRendererCreateFieldType as ur, SettingsPanelPreference as ut, defaultPageResourceCodec as v, NavigationTarget$1 as vi, WorkbenchPageLocationPersistence as vn, SortDirection as vr, PreferenceSchemaContribution as vt, WorkbenchModeRegistry as w, WorkbenchCommandPaletteOpenInput as wi, RegisteredWorkbenchView as wn, FileRendererSaveResult as wr, WorkbenchPlaceholderContribution as wt, WorkbenchModeAddablePanel as x, NavigationTargetItem as xi, WorkbenchPlacementPresentation as xn, FileRendererContribution as xr, PreferenceValue as xt, WorkbenchModeActivationContext as y, NavigationTargetCommand as yi, WorkbenchPageNavigationResult as yn, ViewMode as yr, PreferenceScope as yt, ThemeRegistry as z, ResourceRef$1 as zi, TreeMovePolicy as zn, ControlsRendererContribution as zr, WorkbenchModePlacementContribution as zt };
+export {};