@scion/workbench 20.0.0-beta.7 → 20.0.0-beta.9

package/index.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_cdk_portal from '@angular/cdk/portal';
 import { ComponentType } from '@angular/cdk/portal';
 import * as i0 from '@angular/core';
-import { InjectionToken, Signal, Injector, Type, EnvironmentProviders, ElementRef, StaticProvider, ViewContainerRef, TemplateRef, WritableSignal, ComponentRef, Provider, OnDestroy, OnInit, AfterViewInit, AbstractType, PipeTransform } from '@angular/core';
+import { InjectionToken, Signal, Injector, Type, EnvironmentProviders, ElementRef, StaticProvider, ViewContainerRef, TemplateRef, WritableSignal, ComponentRef, Provider, OnDestroy, OnInit, DestroyableInjector, AbstractType, PipeTransform } from '@angular/core';
 import { MicrofrontendPlatformConfig } from '@scion/microfrontend-platform';
 import * as _angular_router from '@angular/router';
 import { UrlSegment, NavigationExtras, ActivatedRoute, CanMatchFn } from '@angular/router';
@@ -175,7 +175,7 @@ type PopupId = `${typeof POPUP_ID_PREFIX}${string}`;
  *
  * Each activity is assigned a unique identifier (e.g., `activity.9fdf7ab4`, `activity.c6485225`, etc.).
  *
- * @docs-private Not public API, intended for internal use only.
+ * @docs-private Not public API. For internal use only.
  */
 type ActivityId = `${typeof ACTIVITY_ID_PREFIX}${string}`;
 /**
@@ -237,9 +237,9 @@ interface WorkbenchNavigationExtras extends NavigationExtras {
      * Controls where to open the view. Defaults to `auto`.
      *
      * One of:
-     * - 'auto':   Navigates existing views that match the path, or opens a new view otherwise. Matrix params do not affect view resolution.
-     * - 'blank':  Opens a new view and navigates it.
-     * - <viewId>: Navigates the specified view. If already opened, replaces it, or opens a new view otherwise.
+     * - `auto`:   Navigates existing views that match the path, or opens a new view otherwise. Matrix params do not affect view resolution.
+     * - `blank`:  Opens a new view and navigates it.
+     * - `<viewId>`: Navigates the specified view. If already opened, replaces it, or opens a new view otherwise.
      */
     target?: ViewId | string | 'blank' | 'auto';
     /**
@@ -437,7 +437,7 @@ declare abstract class WorkbenchLayoutFactory {
  * The workbench layout is an arrangement of parts and views. Parts can be docked to the side or positioned relative to each other.
  * Views are stacked in parts and can be dragged to other parts. Content can be displayed in both parts and views.
  *
- * A typical workbench application has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to
+ * A typical workbench application has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to
  * support the user's workflow.
  *
  * Multiple layouts, called perspectives, can be created. Users can switch between perspectives. Perspectives share the same main area, if any.
@@ -659,6 +659,14 @@ interface WorkbenchLayout {
      * @return a copy of this layout with the part activated.
      */
     activatePart(id: string): WorkbenchLayout;
+    /**
+     * Tests if given part is contained in the layout.
+     */
+    hasPart(id: string): boolean;
+    /**
+     * Tests if given view is contained in the layout.
+     */
+    hasView(id: string): boolean;
     /**
      * Applies a modification function to this layout, enabling conditional changes while maintaining method chaining.
      *
@@ -706,15 +714,16 @@ interface PartExtras {
     activate?: boolean;
 }
 /**
- * Controls the appearance and behavior of a docked part.
+ * Controls the appearance of a docked part and its toggle button.
  *
  * A docked part is a part that is docked to the left, right, or bottom side of the workbench.
+ *
  * Docked parts can be minimized to create more space for the main content. Users cannot drag
  * views into or out of docked parts.
  */
 interface DockedPartExtras {
     /**
-     * Icon (key) of the toggle button in the sidebar, used to open or close the docked part.
+     * Icon (key) displayed in the toggle button.
      *
      * The actual icon is resolved through an {@link WorkbenchIconProviderFn} registered in {@link WorkbenchConfig.iconProvider}.
      *
@@ -729,13 +738,13 @@ interface DockedPartExtras {
      */
     icon: string;
     /**
-     * Label of the toggle button in the sidebar.
+     * Label displayed in the toggle button.
      *
      * Can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
      */
     label: Translatable;
     /**
-     * Tooltip displayed when hovering over the toggle button in the sidebar.
+     * Tooltip displayed when hovering over the toggle button.
      *
      * Can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
      */
@@ -752,10 +761,14 @@ interface DockedPartExtras {
      * CSS class(es) to add to the docked part and its toggle button, e.g., to locate the part in tests.
      */
     cssClass?: string | string[];
+    /**
+     * Controls whether to activate the docked part. Defaults to `false`.
+     */
+    activate?: boolean;
     /**
      * Internal identifier for the docked part.
      *
-     * @docs-private Not public API, intended for internal use only.
+     * @docs-private Not public API. For internal use only.
      */
     ɵactivityId?: ActivityId;
 }
@@ -783,7 +796,7 @@ interface DockingArea {
  *
  * Refer to this part to align parts relative to the main area.
  *
- * The main area is a special part that can be added to the layout. The main area is where the workbench opens new views by default.
+ * The main area is a special part that can be added to the layout. The main area is where the workbench opens views by default.
  * It is shared between perspectives and its layout is not reset when resetting perspectives.
  */
 declare const MAIN_AREA: MAIN_AREA;
@@ -802,8 +815,8 @@ type MAIN_AREA = 'part.main-area';
  * The workbench layout is an arrangement of parts and views. Parts can be docked to the side or positioned relative to each other.
  * Views are stacked in parts and can be dragged to other parts. Content can be displayed in both parts and views.
  *
- * The layout typically has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to support
- * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens new views by default.
+ * The layout typically has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to support
+ * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens views by default.
  * Unlike any other part, the main area is shared between perspectives, and its layout is not reset when resetting perspectives.
 
  * ## Steps to create the layout
@@ -959,8 +972,8 @@ interface WorkbenchPerspectiveDefinition {
      * A perspective defines an arrangement of parts and views. Parts can be docked to the side or positioned relative to each other.
      * Views are stacked in parts and can be dragged to other parts. Content can be displayed in both parts and views.
      *
-     * A perspective typically has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to support
-     * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens new views by default.
+     * A perspective typically has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to support
+     * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens views by default.
      * Unlike any other part, the main area is shared between perspectives, and its layout is not reset when resetting perspectives.
      *
      * See {@link WorkbenchLayoutFn} for more information and an example.
@@ -1072,8 +1085,8 @@ declare abstract class WorkbenchConfig {
      * Parts can be docked to the side or positioned relative to each other. Views are stacked in parts and can be dragged to other parts.
      * Content can be displayed in both parts and views.
      *
-     * A perspective typically has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to support
-     * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens new views by default.
+     * A perspective typically has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to support
+     * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens views by default.
      * Unlike any other part, the main area is shared between perspectives, and its layout is not reset when resetting perspectives.
      *
      * See {@link WorkbenchLayoutFn} for more information and an example.
@@ -1247,11 +1260,11 @@ declare abstract class WorkbenchConfig {
      */
     abstract dialog?: {
         /**
-         * Configures the area to block for application-modal dialogs. If not set, defaults to `workbench`.
-         *
-         * - **workbench:** blocks the {@link WorkbenchComponent|workbench element}, still allowing interaction with elements outside the workbench element.
+         * Configures the area to block for application-modal dialogs. Defaults to `workbench`.
          *
-         * - **viewport** blocks the browser viewport, preventing interaction with the application until application-modal dialogs are closed.
+         * One of:
+         * - `workbench`: Blocks the workbench, still allowing interaction with elements outside the workbench.
+         * - `viewport`: Blocks the browser viewport, preventing interaction with the application until application-modal dialogs are closed.
          */
         modalityScope?: 'workbench' | 'viewport';
     };
@@ -1405,11 +1418,11 @@ interface MenuItemConfig {
  * Parts can be docked to the side or positioned relative to each other. Views are stacked in parts and can be dragged to other parts.
  * Content can be displayed in both parts and views.
  *
- * Users can personalize the layout of a perspective and switch between perspectives. The workbench remembers the last layout of each perspective,
+ * Users can personalize the layout of a perspective and switch between perspectives. The workbench remembers the layout of a perspective,
  * restoring it the next time it is activated.
  *
- * A perspective typically has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to support
- * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens new views by default. Users can split
+ * A perspective typically has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to support
+ * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens views by default. Users can split
  * the main area (or any other part) by dragging views side-by-side, vertically and horizontally, even across windows.
  *
  * Unlike any other part, the main area is shared between perspectives, and its layout is not reset when resetting perspectives. Having a main area and
@@ -1492,8 +1505,8 @@ interface Disposable {
 }
 
 /**
- * A part is a visual workbench element to create the workbench layout. Parts can be docked to the side or
- * positioned relative to each other. A part can be a stack of views or display content.
+ * A part is a visual element of the workbench layout. Parts can be docked to the side or
+ * positioned relative to each other. A part can display content or stack views.
  *
  * The part component can inject this handle to interact with the part.
  *
@@ -1971,34 +1984,28 @@ interface BottomRightPoint {
 }
 
 /**
- * Configures the content to be displayed in a popup.
- *
- * A popup is a visual workbench component for displaying content above other content. It is positioned relative to an anchor,
- * which can be either a page coordinate (x/y) or an HTML element. When using an element as the popup anchor, the popup also
- * moves when the anchor element moves.
+ * Controls the appearance and behavior of a popup.
  */
 declare abstract class PopupConfig {
     /**
      * Controls where to open the popup.
      *
-     * Can be an HTML element or coordinates:
-     * - Using an element: The popup opens and sticks to the element.
-     * - Using coordinates: The popup opens and sticks relative to the view or page bounds.
+     * Can be an HTML element or a coordinate. The coordinate is relative to the {@link context}, defaulting to the calling context.
      *
      * Supported coordinate pairs:
-     * - x/y: Relative to the top/left corner of the view or page.
+     * - x/y: Relative to the top/left corner of the context.
      * - top/left: Same as x/y.
-     * - top/right: Relative to the top/right corner.
-     * - bottom/left: Relative to the bottom/left corner.
-     * - bottom/right: Relative to the bottom/right corner.
+     * - top/right: Relative to the top/right corner of the context.
+     * - bottom/left: Relative to the bottom/left corner of the context.
+     * - bottom/right: Relative to the bottom/right corner of the context.
      *
-     * Coordinates can be updated using an Observable. The popup displays when the Observable emits the first coordinate.
+     * Passing an Observable allows for updating the coordinate.
      */
     abstract readonly anchor: ElementRef<Element> | Element | PopupOrigin | Observable<PopupOrigin>;
     /**
      * Specifies the component to display in the popup.
      *
-     * In the component, you can inject the popup handle {@link Popup} to interact with the popup, such as to close it
+     * In the component, you can inject the popup handle {@link WorkbenchPopup} to interact with the popup, such as to close it
      * or obtain its input data.
      */
     abstract readonly component: Type<any>;
@@ -2039,7 +2046,7 @@ declare abstract class PopupConfig {
      */
     readonly align?: 'east' | 'west' | 'north' | 'south';
     /**
-     * Optional data to pass to the popup component. In the component, you can inject the popup handle {@link Popup} to read input data.
+     * Optional data to pass to the popup component. In the component, you can inject the popup handle {@link WorkbenchPopup} to read input data.
      */
     readonly input?: any;
     /**
@@ -2055,26 +2062,20 @@ declare abstract class PopupConfig {
      */
     readonly cssClass?: string | string[];
     /**
-     * Specifies the context in which to open the popup.
+     * Binds the popup to a context (e.g., a part or view). Defaults to the calling context.
+     *
+     * The popup is displayed only if the context is visible and closes when the context is disposed.
+     *
+     * Set to `null` to open the popup outside a context.
      */
-    readonly context?: {
-        /**
-         * Specifies the view the popup belongs to.
-         *
-         * Binds the popup to the lifecycle of a view so that it displays only if the view is active and closes when the view is closed.
-         *
-         * By default, if opening the popup in the context of a view, that view is used as the popup's contextual view.
-         * If you set the view id to `null`, the popup will open without referring to the contextual view.
-         */
-        viewId?: ViewId | null;
-    };
+    abstract context?: ViewId | PartId | DialogId | PopupId | Context$2 | null;
 }
 /**
  * Specifies when to close the popup.
  */
 interface CloseStrategy {
     /**
-     * Controls if to close the popup on focus loss, returning the result set via {@link Popup#setResult} to the popup opener.
+     * Controls if to close the popup on focus loss, returning the result set via {@link WorkbenchPopup#setResult} to the popup opener.
      * Defaults to `true`.
      */
     onFocusLost?: boolean;
@@ -2114,10 +2115,23 @@ interface PopupSize {
     maxWidth?: string;
 }
 /**
- * Represents a handle that a popup component can inject to interact with the popup, for example,
- * to read input data or the configured size, or to close the popup.
+ * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
  */
-declare abstract class Popup<T = unknown, R = unknown> {
+interface Context$2 {
+    /**
+     * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
+     */
+    viewId?: ViewId | null;
+}
+
+/**
+ * Handle to interact with a popup opened via {@link WorkbenchPopupService}.
+ *
+ * The popup component can inject this handle to interact with the popup.
+ *
+ * Popup inputs are available via {@link WorkbenchPopup.input} property.
+ */
+declare abstract class WorkbenchPopup<T = unknown, R = unknown> {
     /**
      * Unique identity of this popup.
      */
@@ -2338,7 +2352,7 @@ interface WorkbenchTheme {
 /**
  * Union of workbench elements.
  */
-type WorkbenchElement = WorkbenchPart | WorkbenchView | WorkbenchDialog | Popup;
+type WorkbenchElement = WorkbenchPart | WorkbenchView | WorkbenchDialog | WorkbenchPopup;
 
 /**
  * The central class of the SCION Workbench.
@@ -2351,11 +2365,11 @@ type WorkbenchElement = WorkbenchPart | WorkbenchView | WorkbenchDialog | Popup;
  * Parts can be docked to the side or positioned relative to each other. Views are stacked in parts and can be dragged to other parts.
  * Content can be displayed in both parts and views.
  *
- * Users can personalize the layout of a perspective and switch between perspectives. The workbench remembers the last layout of each perspective,
+ * Users can personalize the layout of a perspective and switch between perspectives. The workbench remembers the layout of a perspective,
  * restoring it the next time it is activated.
  *
- * A perspective typically has a main area part and other parts docked to the side, providing navigation and context-sensitive assistance to support
- * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens new views by default. Users can split
+ * A perspective typically has a main area part and parts docked to the side, providing navigation and context-sensitive assistance to support
+ * the user's workflow. Initially empty or displaying a welcome page, the main area is where the workbench opens views by default. Users can split
  * the main area (or any other part) by dragging views side-by-side, vertically and horizontally, even across windows.
  *
  * Unlike any other part, the main area is shared between perspectives, and its layout is not reset when resetting perspectives. Having a main area and
@@ -2405,24 +2419,48 @@ declare abstract class WorkbenchService {
      * Each handle represents a part in the layout. The handle has methods to interact with the part. Parts are added to the layout via {@link WorkbenchRouter}.
      */
     abstract readonly parts: Signal<WorkbenchPart[]>;
-    /**
-     * Returns the handle of the specified part, or `null` if not found.
-     *
-     * A handle represents a part in the layout. The handle has methods to interact with the part. A part is added to the layout via {@link WorkbenchRouter}.
-     */
-    abstract getPart(partId: PartId): WorkbenchPart | null;
     /**
      * Provides the handles of the views in the current workbench layout.
      *
      * Each handle represents a view in the layout. The handle has methods to interact with the view. Views are opened via {@link WorkbenchRouter}.
      */
     abstract readonly views: Signal<WorkbenchView[]>;
+    /**
+     * Provides the handles of the dialogs opened in the workbench.
+     *
+     * Each handle represents a dialog. The handle has methods to interact with the dialog. Dialogs are opened via {@link WorkbenchDialogService}.
+     */
+    abstract readonly dialogs: Signal<WorkbenchDialog[]>;
+    /**
+     * Provides the handles of the popups opened in the workbench.
+     *
+     * Each handle represents a popup. The handle has methods to interact with the popup. Popups are opened via {@link WorkbenchPopupService}.
+     */
+    abstract readonly popups: Signal<WorkbenchPopup[]>;
+    /**
+     * Returns the handle of the specified part, or `null` if not found.
+     *
+     * A handle represents a part in the layout. The handle has methods to interact with the part. A part is added to the layout via {@link WorkbenchRouter}.
+     */
+    abstract getPart(partId: PartId): WorkbenchPart | null;
     /**
      * Returns the handle of the specified view, or `null` if not found.
      *
      * A handle represents a view in the layout. The handle has methods to interact with the view. A view is opened via {@link WorkbenchRouter}.
      */
     abstract getView(viewId: ViewId): WorkbenchView | null;
+    /**
+     * Returns the handle of the specified dialog, or `null` if not found.
+     *
+     * A handle represents a dialog opened in the workbench. The handle has methods to interact with the dialog. A dialog is opened via {@link WorkbenchDialogService}.
+     */
+    abstract getDialog(dialogId: DialogId): WorkbenchDialog | null;
+    /**
+     * Returns the handle of the specified popup, or `null` if not found.
+     *
+     * A handle represents a popup opened in the workbench. The handle has methods to interact with the popup. A popup is opened via {@link WorkbenchPopupService}.
+     */
+    abstract getPopup(popupId: PopupId): WorkbenchPopup | null;
     /**
      * Closes the specified workbench views.
      *
@@ -2629,7 +2667,7 @@ declare class MTreeNode {
 /**
  * Represents a part in the grid.
  *
- * A part can be a stack of views or display content.
+ * A part can display content or stack views.
  *
  * The M-prefix indicates this object is a model object that is serialized and stored, requiring migration on breaking change.
  */
@@ -2893,15 +2931,11 @@ declare class ɵWorkbenchLayout implements WorkbenchLayout {
      * Indicates if this layout contains activities.
      */
     hasActivities(): boolean;
-    /**
-     * Tests if given part is contained in the specified grid.
-     */
+    /** @inheritDoc */
     hasPart(id: string, options?: {
         grid?: keyof WorkbenchGrids;
     }): boolean;
-    /**
-     * Tests if given view is contained in the specified grid.
-     */
+    /** @inheritDoc */
     hasView(id: string, options?: {
         grid?: keyof WorkbenchGrids;
     }): boolean;
@@ -3570,7 +3604,7 @@ interface ReferenceElement extends ReferencePart {
  * TestBed.overrideProvider(MAIN_AREA_INITIAL_PART_ID, {useValue: 'part.initial'})
  * ```
  *
- * @docs-private Not public API, intended for internal use only.
+ * @docs-private Not public API. For internal use only.
  */
 declare const MAIN_AREA_INITIAL_PART_ID: InjectionToken<`part.${string}`>;
 /**
@@ -3760,6 +3794,51 @@ type ClassListScopes = 'layout' | 'navigation' | 'route' | 'application';
  */
 type ClassListMap = ReadonlyMap<ClassListScopes, string[]>;
 
+/**
+ * Represents an object that is blocking another object, preventing user interaction with the other object.
+ */
+interface Blocking {
+    /**
+     * Identifies the object that is blocking another object.
+     */
+    readonly id: string;
+    /**
+     * Instructs the blocking object to gain focus.
+     */
+    focus(): void;
+    /**
+     * Instructs the blocking object to signal the user to continue interacting with this object.
+     */
+    blink(): void;
+}
+
+/**
+ * Represents an object that can be blocked by another object, such as a dialog, preventing user interaction with the object.
+ */
+interface Blockable {
+    /**
+     * Indicates whether an object (typically a dialog) blocks this object.
+     */
+    blockedBy: Signal<Blocking | null>;
+}
+
+/**
+ * Prevents user interaction of the host when blocked by placing a glass pane over the host element.
+ *
+ * Configure this direktive via the following DI tokens. These tokens must be provided at the component level.
+ * - {@link GLASS_PANE_BLOCKABLE}: Represents the object to be blocked.
+ * - {@link GLASS_PANE_TARGET_ELEMENT}: Controls the HTML element to block. Defaults to the directive's host element if not set.
+ * - {@link GLASS_PANE_OPTIONS}: Configures the glass pane.
+ */
+declare class GlassPaneDirective {
+    private readonly _targetElement;
+    private readonly _options;
+    constructor();
+    private installGlassPane;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlassPaneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GlassPaneDirective, "[wbGlassPane]", never, {}, {}, never, never, true, never>;
+}
+
 /**
  * Acts as a placeholder for a part's content that Angular fills based on the current router state of the associated part outlet.
  */
@@ -3788,7 +3867,7 @@ declare class PartSlotComponent implements OnAttach, OnDetach {
      */
     private unsetActiveElementOnPartDeactivate;
     static ɵfac: i0.ɵɵFactoryDeclaration<PartSlotComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PartSlotComponent, "wb-part-slot", never, {}, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PartSlotComponent, "wb-part-slot", never, {}, {}, never, never, true, [{ directive: typeof GlassPaneDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -4148,90 +4227,8 @@ declare class PartComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<PartComponent, "wb-part", never, {}, {}, never, never, true, never>;
 }
 
-declare class ɵWorkbenchPart implements WorkbenchPart {
-    readonly id: PartId;
-    private readonly _partEnvironmentInjector;
-    private readonly _workbenchRouter;
-    private readonly _rootOutletContexts;
-    private readonly _focusMonitor;
-    private readonly _layout;
-    private readonly _title;
-    private readonly _titleComputed;
-    readonly alternativeId: string | undefined;
-    readonly navigation: WritableSignal<WorkbenchPartNavigation | undefined>;
-    readonly activationInstant: WritableSignal<number>;
-    readonly active: WritableSignal<boolean>;
-    readonly focused: Signal<boolean>;
-    readonly viewIds: Signal<`view.${string}`[]>;
-    readonly activeViewId: Signal<`view.${string}` | null>;
-    readonly mPart: WritableSignal<MPart>;
-    readonly gridName: WritableSignal<keyof WorkbenchGrids>;
-    readonly peripheral: WritableSignal<boolean>;
-    readonly referencePart: WritableSignal<boolean>;
-    readonly topLeft: WritableSignal<boolean>;
-    readonly topRight: WritableSignal<boolean>;
-    readonly activity: WritableSignal<MActivity | null>;
-    readonly canMinimize: Signal<boolean>;
-    readonly actions: Signal<WorkbenchPartAction[]>;
-    readonly activeView: Signal<ɵWorkbenchView | null>;
-    readonly views: Signal<ɵWorkbenchView[]>;
-    readonly classList: ClassList;
-    readonly portal: WbComponentPortal<MainAreaPartComponent | PartComponent>;
-    readonly slot: {
-        portal: WbComponentPortal<PartSlotComponent>;
-    };
-    private _isInMainArea;
-    constructor(id: PartId, layout: ɵWorkbenchLayout);
-    focus(): void;
-    private createPortal;
-    /**
-     * Method invoked when the workbench layout has changed.
-     *
-     * This method:
-     * - is called on every layout change, enabling the update of part properties defined in the layout (navigation hint, navigation data, ...).
-     * - is called on route activation (after destroyed the previous component (if any), but before constructing the new component).
-     */
-    private onLayoutChange;
-    private computeTitle;
-    /**
-     * Returns the component of this part. Returns `null` if not displaying navigated content.
-     */
-    getComponent<T = unknown>(): T | null;
-    /** @inheritDoc */
-    activate(): Promise<boolean>;
-    /** @inheritDoc */
-    get isInMainArea(): boolean;
-    /**
-     * Reference to the handle's injector. The injector will be destroyed when removing the part.
-     */
-    get injector(): Injector;
-    /** @inheritDoc */
-    get title(): Signal<Translatable | undefined>;
-    /** @inheritDoc */
-    set title(title: Translatable | undefined);
-    /** @inheritDoc */
-    set cssClass(cssClass: string | string[]);
-    /** @inheritDoc */
-    get cssClass(): Signal<string[]>;
-    /**
-     * Sets up automatic synchronization of {@link WorkbenchPart} on every layout change.
-     *
-     * If the operation is cancelled (e.g., due to a navigation failure), it reverts the changes.
-     */
-    private installModelUpdater;
-    /**
-     * Activates this part when focused.
-     */
-    private activateOnFocus;
-    /**
-     * Focuses this part when activated, either by focus or routing.
-     */
-    private focusOnActivate;
-    destroy(): void;
-}
-
 /**
- * Controls how to open a dialog.
+ * Controls the appearance and behavior of a dialog.
  */
 interface WorkbenchDialogOptions {
     /**
@@ -4246,16 +4243,24 @@ interface WorkbenchDialogOptions {
         [name: string]: unknown;
     };
     /**
-     * Controls which area of the application to block by the dialog.
+     * Controls which area of the application to block by the dialog. Defaults to `context`.
      *
-     * - **Application-modal:**
-     *   Use to block the workbench, or the browser's viewport if configured in {@link WorkbenchConfig.dialog.modalityScope}.
+     * One of:
+     * - 'none': Non-blocking dialog.
+     * - `context`: Blocks a specific part of the application, as specified in {@link context}, defaulting to the calling context.
+     * - `application`: Blocks the workbench or browser viewport, based on {@link WorkbenchConfig.dialog.modalityScope}.
+     * - `view`: Deprecated. Same as `context`. Will be removed in version 22.
+     */
+    modality?: 'none' | 'context' | 'application' | ViewModality$1;
+    /**
+     * Binds the dialog to a context (e.g., a part or view). Defaults to the calling context.
+     *
+     * The dialog is displayed only if the context is visible and closes when the context is disposed.
+     * The dialog is opened in the center of its context, if any, unless opened from the peripheral area.
      *
-     * - **View-modal:**
-     *   Use to block only the contextual view of the dialog, allowing the user to interact with other views.
-     *   This is the default if opening the dialog in the context of a view.
+     * Set to `null` to open the dialog outside a context.
      */
-    modality?: 'application' | 'view';
+    context?: ViewId | PartId | DialogId | PopupId | Context$1 | null;
     /**
      * Sets the injector for the instantiation of the dialog component, giving control over the objects available
      * for injection into the dialog component. If not specified, uses the application's root injector, or the view's
@@ -4280,17 +4285,19 @@ interface WorkbenchDialogOptions {
      * Controls whether to animate the opening of the dialog. Defaults to `false`.
      */
     animate?: boolean;
+}
+/**
+ * @deprecated since version 20.0.0-beta.9. Renamed to `context`. Will be removed in version 22.
+ */
+type ViewModality$1 = 'view';
+/**
+ * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
+ */
+interface Context$1 {
     /**
-     * Specifies the context in which to open the dialog.
+     * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
      */
-    context?: {
-        /**
-         * Controls which view to block when opening a dialog view-modal.
-         *
-         * By default, if opening the dialog in the context of a view, that view is used as the contextual view.
-         */
-        viewId?: ViewId;
-    };
+    viewId?: ViewId | null;
 }
 
 /**
@@ -4370,72 +4377,69 @@ declare class WorkbenchDialogHeaderDirective {
 }
 
 /**
- * Represents an object that is blocking another object, preventing user interaction with the other object.
+ * Information about the source of an invocation.
  */
-interface Blocking {
+interface WorkbenchInvocationContext {
     /**
-     * Identifies the object that is blocking another object.
+     * Identifies the element that initiated the interaction.
      */
-    readonly id: string;
+    elementId: PartId | ViewId | DialogId | PopupId;
     /**
-     * Instructs the blocking object to gain focus.
+     * Indicates whether the source is attached to the DOM.
      */
-    focus(): void;
+    attached: Signal<boolean>;
     /**
-     * Instructs the blocking object to signal the user to continue interacting with this object.
+     * Tracks the source's bounding box.
      */
-    blink(): void;
-}
-
-/**
- * Represents an object that can be blocked by another object, such as a dialog, preventing user interaction with the object.
- */
-interface Blockable {
+    bounds: Signal<DOMRect | undefined>;
+    /**
+     * Indicates whether the source is located in the peripheral area of the workbench layout.
+     */
+    peripheral: Signal<boolean>;
     /**
-     * Emits the object blocking this object, or `null` if not blocked.
+     * Indicates whether the source has been destroyed.
      */
-    blockedBy$: Observable<Blocking | null>;
+    destroyed: Signal<boolean>;
 }
 
 /** @inheritDoc */
 declare class ɵWorkbenchDialog<R = unknown> implements WorkbenchDialog<R>, Blockable, Blocking {
     id: DialogId;
     component: ComponentType<unknown>;
+    invocationContext: WorkbenchInvocationContext | null;
     private _options;
-    private readonly _dialogEnvironmentInjector;
+    /** Injector for the dialog; destroyed when the dialog is closed. */
+    readonly injector: DestroyableInjector;
     private readonly _overlayRef;
     private readonly _portal;
     private readonly _workbenchDialogRegistry;
     private readonly _workbenchConfig;
-    private readonly _destroyRef;
     private readonly _blink$;
     private readonly _focusMonitor;
-    private readonly _attached;
     private readonly _title;
     private readonly _closable;
     private readonly _resizable;
     private readonly _padding;
     private readonly _cssClass;
-    /**
-     * Result (or error) to be passed to the dialog opener.
-     */
+    /** Result (or error) to be passed to the dialog opener. */
     private _result;
     private _componentRef;
-    /**
-     * Indicates whether this dialog is blocked by other dialog(s) that overlay this dialog.
-     */
-    readonly blockedBy$: BehaviorSubject<ɵWorkbenchDialog<unknown> | null>;
+    readonly blockedBy: Signal<ɵWorkbenchDialog | null>;
     readonly size: WorkbenchDialogSize;
     readonly focused: Signal<boolean>;
+    readonly attached: Signal<boolean>;
+    readonly destroyed: i0.WritableSignal<boolean>;
+    readonly bounds: Signal<DOMRect | undefined>;
+    readonly modal: boolean;
     readonly blinking$: BehaviorSubject<boolean>;
-    readonly context: {
-        view: ɵWorkbenchView | null;
-    };
     header: WorkbenchDialogHeaderDirective | undefined;
     footer: WorkbenchDialogFooterDirective | undefined;
     actions: WorkbenchDialogActionDirective[];
-    constructor(id: DialogId, component: ComponentType<unknown>, _options: WorkbenchDialogOptions);
-    open(): Promise<R | undefined>;
+    constructor(id: DialogId, component: ComponentType<unknown>, invocationContext: WorkbenchInvocationContext | null, _options: WorkbenchDialogOptions);
+    /**
+     * Waits for the dialog to close, resolving to its result or rejecting if closed with an error.
+     */
+    waitForClose(): Promise<R | undefined>;
     /** @inheritDoc */
     close(result?: R | Error): void;
     /**
@@ -4480,9 +4484,8 @@ declare class ɵWorkbenchDialog<R = unknown> implements WorkbenchDialog<R>, Bloc
     /** @inheritDoc */
     blink(): void;
     /**
-     * Reference to the handle's injector. The injector will be destroyed when closing the dialog.
+     * Creates a portal to render {@link WorkbenchDialogComponent} in the dialog's injection context.
      */
-    get injector(): Injector;
     private createPortal;
     /**
      * Creates a dedicated overlay per dialog to place it on top of previously created overlays, such as dialogs, popups, dropdowns, etc.
@@ -4501,39 +4504,114 @@ declare class ɵWorkbenchDialog<R = unknown> implements WorkbenchDialog<R>, Bloc
      */
     private monitorHostElementAttached;
     /**
-     * Aligns this dialog with the boundaries of the host element.
+     * Binds this dialog to its workbench host element, displaying it only when the host element is attached.
+     *
+     * Dialogs opened in non-peripheral area are displayed in the center of the host.
      */
-    private stickToHostElement;
+    private bindToHostElement;
     /**
-     * Blocks this dialog if not the topmost dialog in its context.
+     * Computes if this dialog is blocked by another dialog.
      */
-    private blockWhenNotOnTop;
+    private computeBlocked;
     private blinkOnRequest;
+    /**
+     * Closes the dialog when the context element is destroyed.
+     */
+    private closeOnHostDestroy;
     /**
      * Destroys this dialog and associated resources.
      */
     destroy(): void;
 }
 
-/**
- * Prevents user interaction of the host when blocked by placing a glass pane over the host element.
- *
- * Configure this direktive via the following DI tokens. These tokens must be provided at the component level.
- * - {@link GLASS_PANE_BLOCKABLE}: Represents the object to be blocked.
- * - {@link GLASS_PANE_TARGET_ELEMENT}: Controls the HTML element to block. Defaults to the directive's host element if not set.
- * - {@link GLASS_PANE_OPTIONS}: Configures the glass pane.
- */
-declare class GlassPaneDirective implements OnDestroy, AfterViewInit {
-    private readonly _injector;
-    private readonly _targetElement;
-    private readonly _options;
-    private _glassPane;
-    constructor();
-    ngAfterViewInit(): void;
-    private installGlassPane;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlassPaneDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<GlassPaneDirective, "[wbGlassPane]", never, {}, {}, never, never, true, never>;
+/** @inheritDoc */
+declare class ɵWorkbenchPart implements WorkbenchPart, Blockable {
+    readonly id: PartId;
+    /** Injector for the part; destroyed when the part is removed. */
+    readonly injector: DestroyableInjector;
+    private readonly _workbenchRouter;
+    private readonly _rootOutletContexts;
+    private readonly _focusMonitor;
+    private readonly _layout;
+    private readonly _title;
+    private readonly _titleComputed;
+    readonly alternativeId: string | undefined;
+    readonly navigation: WritableSignal<WorkbenchPartNavigation | undefined>;
+    readonly activationInstant: WritableSignal<number>;
+    readonly active: WritableSignal<boolean>;
+    readonly focused: Signal<boolean>;
+    readonly viewIds: Signal<`view.${string}`[]>;
+    readonly activeViewId: Signal<`view.${string}` | null>;
+    readonly mPart: WritableSignal<MPart>;
+    readonly gridName: WritableSignal<keyof WorkbenchGrids>;
+    readonly peripheral: WritableSignal<boolean>;
+    readonly referencePart: WritableSignal<boolean>;
+    readonly topLeft: WritableSignal<boolean>;
+    readonly topRight: WritableSignal<boolean>;
+    readonly activity: WritableSignal<MActivity | null>;
+    readonly canMinimize: Signal<boolean>;
+    readonly actions: Signal<WorkbenchPartAction[]>;
+    readonly activeView: Signal<ɵWorkbenchView | null>;
+    readonly views: Signal<ɵWorkbenchView[]>;
+    readonly classList: ClassList;
+    readonly portal: WbComponentPortal<MainAreaPartComponent | PartComponent>;
+    readonly bounds: Signal<DOMRect | undefined>;
+    readonly blockedBy: Signal<ɵWorkbenchDialog | null>;
+    readonly slot: {
+        portal: WbComponentPortal<PartSlotComponent>;
+        bounds: Signal<DOMRect | undefined>;
+    };
+    private _isInMainArea;
+    constructor(id: PartId, layout: ɵWorkbenchLayout);
+    focus(): void;
+    /**
+     * Creates a portal to render {@link PartComponent} or {@link MainAreaPartComponent} in the part's injection context.
+     */
+    private createPartPortal;
+    /**
+     * Creates a portal to render {@link PartSlotComponent} in the part's injection context.
+     */
+    private createPartSlotPortal;
+    /**
+     * Method invoked when the workbench layout has changed.
+     *
+     * This method:
+     * - is called on every layout change, enabling the update of part properties defined in the layout (navigation hint, navigation data, ...).
+     * - is called on route activation (after destroyed the previous component (if any), but before constructing the new component).
+     */
+    private onLayoutChange;
+    private computeTitle;
+    /**
+     * Returns the component of this part. Returns `null` if not displaying navigated content.
+     */
+    getComponent<T = unknown>(): T | null;
+    /** @inheritDoc */
+    activate(): Promise<boolean>;
+    /** @inheritDoc */
+    get isInMainArea(): boolean;
+    /** @inheritDoc */
+    get title(): Signal<Translatable | undefined>;
+    /** @inheritDoc */
+    set title(title: Translatable | undefined);
+    /** @inheritDoc */
+    set cssClass(cssClass: string | string[]);
+    /** @inheritDoc */
+    get cssClass(): Signal<string[]>;
+    /**
+     * Sets up automatic synchronization of {@link WorkbenchPart} on every layout change.
+     *
+     * If the operation is cancelled (e.g., due to a navigation failure), it reverts the changes.
+     */
+    private installModelUpdater;
+    /**
+     * Activates this part when focused.
+     */
+    private activateOnFocus;
+    /**
+     * Focuses this part when activated, either by focus or routing.
+     */
+    private focusOnActivate;
+    destroy(): void;
 }
 
 /**
@@ -4571,9 +4649,11 @@ declare class ViewSlotComponent implements OnAttach, OnDetach {
     static ɵcmp: i0.ɵɵComponentDeclaration<ViewSlotComponent, "wb-view-slot", never, {}, {}, never, never, true, [{ directive: typeof GlassPaneDirective; inputs: {}; outputs: {}; }]>;
 }
 
+/** @inheritDoc */
 declare class ɵWorkbenchView implements WorkbenchView, Blockable {
     readonly id: ViewId;
-    private readonly _viewEnvironmentInjector;
+    /** Injector for the view; destroyed when the view is closed. */
+    readonly injector: DestroyableInjector;
     private readonly _workbenchId;
     private readonly _workbenchService;
     private readonly _layout;
@@ -4581,7 +4661,6 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
     private readonly _rootOutletContexts;
     private readonly _partRegistry;
     private readonly _viewDragService;
-    private readonly _workbenchDialogRegistry;
     private readonly _focusMonitor;
     private readonly _logger;
     private readonly _adapters;
@@ -4589,7 +4668,6 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
     private readonly _heading;
     private readonly _dirty;
     private readonly _closable;
-    private readonly _blockedBy;
     private readonly _scrolledIntoView;
     alternativeId: string | undefined;
     readonly navigation: i0.WritableSignal<WorkbenchViewNavigation | undefined>;
@@ -4605,9 +4683,10 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
     readonly active: i0.WritableSignal<boolean>;
     readonly focused: Signal<boolean>;
     readonly menuItems: Signal<WorkbenchMenuItem[]>;
-    readonly blockedBy$: Observable<ɵWorkbenchDialog | null>;
+    readonly blockedBy: Signal<ɵWorkbenchDialog | null>;
     readonly slot: {
         portal: WbComponentPortal<ViewSlotComponent>;
+        bounds: Signal<DOMRect | undefined>;
     };
     readonly classList: ClassList;
     readonly isClosable: Signal<boolean>;
@@ -4618,6 +4697,9 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
      */
     canCloseGuard: (() => Promise<boolean>) | undefined;
     constructor(id: ViewId, layout: ɵWorkbenchLayout);
+    /**
+     * Creates a portal to render {@link ViewSlotComponent} in the view's injection context.
+     */
     private createPortal;
     /**
      * Method invoked when the workbench layout has changed.
@@ -4669,10 +4751,6 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
     }): void;
     /** @inheritDoc */
     canClose(canClose: CanCloseFn): CanCloseRef;
-    /**
-     * Reference to the handle's injector. The injector will be destroyed when closing the view.
-     */
-    get injector(): Injector;
     /**
      * Registers an adapter for this view, replacing any previously registered adapter of the same type.
      *
@@ -4713,7 +4791,8 @@ declare class ɵWorkbenchView implements WorkbenchView, Blockable {
  * @inheritDoc
  */
 declare class ɵWorkbenchPerspective implements WorkbenchPerspective {
-    private readonly _perspectiveEnvironmentInjector;
+    /** Injector for the perspective; destroyed when the perspective is unregistered. */
+    readonly injector: DestroyableInjector;
     private readonly _workbenchLayoutFactory;
     private readonly _workbenchLayoutService;
     private readonly _workbenchLayoutMerger;
@@ -4738,10 +4817,6 @@ declare class ɵWorkbenchPerspective implements WorkbenchPerspective {
      * Resets this perspective to its initial layout.
      */
     reset(): Promise<void>;
-    /**
-     * Reference to the handle's injector. The injector will be destroyed when unregistering the perspective.
-     */
-    get injector(): Injector;
     /**
      * Creates the perspective layout using the main area of the current layout.
      */
@@ -4768,18 +4843,103 @@ declare class ɵWorkbenchPerspective implements WorkbenchPerspective {
     destroy(): void;
 }
 
+/** @inheritDoc */
+declare class ɵWorkbenchPopup<T = unknown, R = unknown> implements WorkbenchPopup<T, R>, Blockable {
+    id: PopupId;
+    invocationContext: WorkbenchInvocationContext | null;
+    private _config;
+    /** Injector for the popup; destroyed when the popup is closed. */
+    readonly injector: DestroyableInjector;
+    private readonly _overlayRef;
+    private readonly _focusMonitor;
+    private readonly _portal;
+    private readonly _componentRef;
+    private readonly _popupOrigin;
+    readonly cssClasses: string[];
+    readonly focused: Signal<boolean>;
+    readonly attached: Signal<boolean>;
+    readonly destroyed: i0.WritableSignal<boolean>;
+    readonly bounds: Signal<DOMRect | undefined>;
+    readonly blockedBy: Signal<ɵWorkbenchDialog | null>;
+    result: R | Error | undefined;
+    constructor(id: PopupId, invocationContext: WorkbenchInvocationContext | null, _config: PopupConfig);
+    /**
+     * Waits for the popup to close, resolving to its result or rejecting if closed with an error.
+     */
+    waitForClose(): Promise<R | undefined>;
+    /**
+     * Creates a portal to render {@link PopupComponent} in the popup's injection context.
+     */
+    private createPortal;
+    /**
+     * Creates a dedicated overlay per popup to place it on top of previously created overlays, such as dialogs, popups, dropdowns, etc.
+     */
+    private createOverlay;
+    private focus;
+    /**
+     * Moves the popup with the anchor.
+     */
+    private stickToAnchor;
+    /**
+     * Monitors attachment of the host element.
+     */
+    private monitorHostElementAttached;
+    /**
+     * Repositions the popup position when resized.
+     */
+    private repositionOnResize;
+    /**
+     * Closes the popup on focus loss, if configured.
+     */
+    private closeOnFocusLoss;
+    /**
+     * Closes the popup on escape keystroke.
+     */
+    private closeOnEscape;
+    /**
+     * Closes the popup when the context element is destroyed.
+     */
+    private closeOnHostDestroy;
+    /**
+     * Binds this popup to its workbench host element, displaying it only when the host element is attached.
+     */
+    private bindToHostElement;
+    /**
+     * Creates a signal that tracks the position of the popup anchor.
+     */
+    private trackPopupOrigin;
+    /** @inheritDoc */
+    setResult(result?: R): void;
+    /** @inheritDoc */
+    close(result?: R | Error): void;
+    /** @inheritDoc */
+    get input(): T | undefined;
+    /** @inheritDoc */
+    get size(): PopupSize | undefined;
+    get component(): Type<any>;
+    get viewContainerRef(): ViewContainerRef | undefined;
+    /**
+     * Destroys this popup and associated resources.
+     */
+    destroy(): void;
+}
+
 declare class ɵWorkbenchService implements WorkbenchService {
     private readonly _workbenchRouter;
     private readonly _perspectiveRegistry;
     private readonly _partRegistry;
+    private readonly _viewRegistry;
+    private readonly _dialogRegistry;
+    private readonly _popupRegistry;
     private readonly _partActionRegistry;
     private readonly _viewMenuItemRegistry;
-    private readonly _viewRegistry;
     private readonly _perspectiveService;
     readonly layout: Signal<ɵWorkbenchLayout>;
     readonly perspectives: Signal<ɵWorkbenchPerspective[]>;
     readonly parts: Signal<ɵWorkbenchPart[]>;
     readonly views: Signal<ɵWorkbenchView[]>;
+    readonly dialogs: Signal<ɵWorkbenchDialog<unknown>[]>;
+    readonly popups: Signal<ɵWorkbenchPopup<unknown, unknown>[]>;
     readonly activePerspective: Signal<ɵWorkbenchPerspective | undefined>;
     readonly activeElement: Signal<_scion_workbench.WorkbenchElement | null>;
     readonly theme: Signal<WorkbenchTheme | null>;
@@ -4795,6 +4955,10 @@ declare class ɵWorkbenchService implements WorkbenchService {
     /** @inheritDoc */
     getView(viewId: ViewId): ɵWorkbenchView | null;
     /** @inheritDoc */
+    getDialog(dialogId: DialogId): ɵWorkbenchDialog | null;
+    /** @inheritDoc */
+    getPopup(popupId: PopupId): ɵWorkbenchPopup | null;
+    /** @inheritDoc */
     registerPerspective(perspective: WorkbenchPerspectiveDefinition): Promise<void>;
     /** @inheritDoc */
     switchPerspective(id: string): Promise<boolean>;
@@ -4968,6 +5132,8 @@ declare class WorkbenchViewMenuItemDirective {
     readonly cssClass: i0.InputSignal<string | string[] | undefined>;
     /**
      * Emits when the menu item is clicked.
+     *
+     * The function can call `inject` to get any required dependencies.
      */
     readonly action: i0.OutputEmitterRef<WorkbenchView>;
     constructor();
@@ -5014,6 +5180,7 @@ declare class WorkbenchViewMenuItemDirective {
  * Alternatively, actions can be added using a factory function and registered via {@link WorkbenchService.registerPartAction}.
  */
 declare class WorkbenchPartActionDirective {
+    private readonly _injector;
     /**
      * Specifies where to place this action in the part bar. Defaults to `end`.
      */
@@ -5323,16 +5490,24 @@ interface WorkbenchMessageBoxOptions {
      */
     severity?: 'info' | 'warn' | 'error';
     /**
-     * Controls which area of the application to block by the message box.
+     * Controls which area of the application to block by the message box. Defaults to `context`.
      *
-     * - **Application-modal:**
-     *   Use to block the workbench, or the browser's viewport if configured in {@link WorkbenchConfig.dialog.modalityScope}.
+     * One of:
+     * - 'none': Non-blocking message box.
+     * - `context`: Blocks a specific part of the application, as specified in {@link context}, defaulting to the calling context.
+     * - `application`: Blocks the workbench or browser viewport, based on {@link WorkbenchConfig.dialog.modalityScope}.
+     * - `view`: Deprecated. Same as `context`. Marked for removal in version 22.
+     */
+    modality?: 'none' | 'context' | 'application' | ViewModality;
+    /**
+     * Binds the message box to a context (e.g., a part or view). Defaults to the calling context.
+     *
+     * The message box is displayed only if the context is visible and closes when the context is disposed.
+     * The message box is opened in the center of its context, if any, unless opened from the peripheral area.
      *
-     * - **View-modal:**
-     *   Use to block only the contextual view of the message box, allowing the user to interact with other views.
-     *   This is the default if opening the message box in the context of a view.
+     * Set to `null` to open the message box outside a context.
      */
-    modality?: 'application' | 'view';
+    context?: ViewId | PartId | DialogId | PopupId | Context | null;
     /**
      * Specifies if the user can select text displayed in the message box. Defaults to `false`.
      */
@@ -5371,17 +5546,19 @@ interface WorkbenchMessageBoxOptions {
      * Specifies CSS class(es) to add to the message box, e.g., to locate the message box in tests.
      */
     cssClass?: string | string[];
+}
+/**
+ * @deprecated since version 20.0.0-beta.9. Renamed to `context`. Marked for removal in version 22.
+ */
+type ViewModality = 'view';
+/**
+ * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
+ */
+interface Context {
     /**
-     * Specifies the context in which to open the message box.
+     * @deprecated since version 20.0.0-beta.9. Set view id directly. Migrate `{context: {viewId: 'view.x'}}` to `{context: 'view.x'}`. Marked for removal in version 22.
      */
-    context?: {
-        /**
-         * Allows controlling which view to block when opening a view-modal message box.
-         *
-         * By default, if opening the message box in the context of a view, that view is used as the contextual view.
-         */
-        viewId?: ViewId;
-    };
+    viewId?: ViewId | null;
 }
 
 /**
@@ -5389,15 +5566,21 @@ interface WorkbenchMessageBoxOptions {
  * or for prompting the user for confirmation. The message can be plain text or a component, allowing for
  * structured content or input prompts.
  *
+ * Displayed on top of other content, a modal message box blocks interaction with other parts of the application.
+ *
  * ## Modality
- * Displayed on top of other content, a message box blocks interaction with other parts of the application.
+ * A message box can be context-modal or application-modal. Context-modal blocks a specific part of the application, as specified by the context;
+ * application-modal blocks the workbench or browser viewport, based on {@link WorkbenchConfig.dialog.modalityScope}.
+ *
+ * ## Context
+ * A message box can be bound to a context (e.g., a part or view), defaulting to the calling context.
+ * The message box is displayed only if the context is visible and closes when the context is disposed.
  *
- * A message box can be view-modal or application-modal. A view-modal message box blocks only a specific view,
- * allowing the user to interact with other views. An application-modal message box blocks the workbench,
- * or the browser's viewport if configured in {@link WorkbenchConfig.dialog.modalityScope}.
+ * ## Positioning
+ * A message box is opened in the center of its context, if any, unless opened from the peripheral area.
  *
  * ## Stacking
- * Multiple message boxes are stacked, and only the topmost message box in each modality stack can be interacted with.
+ * Message boxes are stacked per modality, with only the topmost message box in each stack being interactive.
  *
  * ## Styling
  * The following CSS variables can be set to customize the default look of a message box.
@@ -5415,11 +5598,9 @@ declare abstract class WorkbenchMessageBoxService {
     /**
      * Displays the specified message in a message box.
      *
-     * By default, the calling context determines the modality of the message box. If the message box is opened from a view, only this view is blocked.
-     * To open the message box with a different modality, specify the modality in {@link WorkbenchMessageBoxOptions.modality}.
-     *
-     * **Example:**
+     * By default, the message box is modal to the calling context. Specify a different modality in {@link WorkbenchMessageBoxOptions.modality}.
      *
+     * @example
      * ```ts
      * const action = await inject(WorkbenchMessageBoxService).open('Do you want to save changes?', {
      *   actions: {
@@ -5439,14 +5620,12 @@ declare abstract class WorkbenchMessageBoxService {
     /**
      * Displays the specified component in a message box.
      *
-     * By default, the calling context determines the modality of the message box. If the message box is opened from a view, only this view is blocked.
-     * To open the message box with a different modality, specify the modality in {@link WorkbenchMessageBoxOptions.modality}.
+     * By default, the message box is modal to the calling context. Specify a different modality in {@link WorkbenchMessageBoxOptions.modality}.
      *
      * Data can be passed to the component as inputs via {@link WorkbenchMessageBoxOptions.inputs} property or by providing a custom injector
      * via {@link WorkbenchMessageBoxOptions.injector} property. Inputs are available as input properties in the component.
      *
-     * **Example:**
-     *
+     * @example
      * ```ts
      * const action = await inject(WorkbenchMessageBoxService).open(SomeComponent, {
      *   inputs: {
@@ -5483,21 +5662,26 @@ declare abstract class WorkbenchMessageBoxService {
 }
 
 /**
- * Enables the display of a component in a modal dialog.
+ * Enables the display of a component in a dialog.
  *
  * A dialog is a visual element for focused interaction with the user, such as prompting the user for input or confirming actions.
- * The user can move or resize a dialog.
+ * The user can move and resize a dialog.
  *
- * Displayed on top of other content, a dialog blocks interaction with other parts of the application.
+ * Displayed on top of other content, a modal dialog blocks interaction with other parts of the application.
  *
  * ## Modality
- * A dialog can be view-modal or application-modal.
+ * A dialog can be context-modal or application-modal. Context-modal blocks a specific part of the application, as specified by the context;
+ * application-modal blocks the workbench or browser viewport, based on {@link WorkbenchConfig.dialog.modalityScope}.
  *
- * A view-modal dialog blocks only a specific view, allowing the user to interact with other views. An application-modal dialog blocks
- * the workbench, or the browser's viewport if configured in {@link WorkbenchConfig.dialog.modalityScope}.
+ * ## Context
+ * A dialog can be bound to a context (e.g., a part or view), defaulting to the calling context.
+ * The dialog is displayed only if the context is visible and closes when the context is disposed.
  *
- * ## Dialog Stack
- * Multiple dialogs are stacked, and only the topmost dialog in each modality stack can be interacted with.
+ * ## Positioning
+ * A dialog is opened in the center of its context, if any, unless opened from the peripheral area.
+ *
+ * ## Stacking
+ * Dialogs are stacked per modality, with only the topmost dialog in each stack being interactive.
  *
  * ## Dialog Component
  * The dialog component can inject the {@link WorkbenchDialog} handle to interact with the dialog, such as setting the title or closing the dialog.
@@ -5561,14 +5745,13 @@ declare abstract class WorkbenchDialogService {
     /**
      * Opens a dialog with the specified component and options.
      *
-     * By default, the calling context determines the modality of the dialog. If the dialog is opened from a view, only this view is blocked.
-     * To open the dialog with a different modality, specify the modality in {@link WorkbenchDialogOptions.modality}.
+     * By default, the dialog is modal to the calling context. Specify a different modality in {@link WorkbenchDialogOptions.modality}.
      *
      * Data can be passed to the component as inputs via {@link WorkbenchDialogOptions.inputs} property or by providing a custom injector
      * via {@link WorkbenchDialogOptions.injector} property. Dialog inputs are available as input properties in the dialog component.
      *
      * @param component - Specifies the component to display in the dialog.
-     * @param options - Controls how to open a dialog.
+     * @param options - Controls the appearance and behavior of the dialog.
      * @returns Promise that resolves to the dialog result, if any, or that rejects if the dialog couldn't be opened or was closed with an error.
      */
     abstract open<R>(component: ComponentType<unknown>, options?: WorkbenchDialogOptions): Promise<R | undefined>;
@@ -5611,6 +5794,10 @@ declare abstract class Notification<T = any> {
      * Specifies CSS class(es) to add to the notification, e.g., to locate the notification in tests.
      */
     abstract setCssClass(cssClass: string | string[]): void;
+    /**
+     * Closes the notification.
+     */
+    abstract close(): void;
 }
 
 /**
@@ -5713,6 +5900,7 @@ interface NotificationConfig {
  */
 declare class NotificationService {
     private readonly _zone;
+    private readonly _injector;
     private readonly _document;
     private readonly _notifications$;
     constructor();
@@ -5750,59 +5938,30 @@ declare class NotificationService {
 /**
  * Enables the display of a component in a popup.
  *
- * A popup is a visual workbench component for displaying content above other content. It is positioned relative to an anchor and
- * moves when the anchor moves. Unlike a dialog, the popup closes on focus loss.
+ * A popup is a visual workbench element for displaying content above other content. It is positioned relative to an anchor,
+ * which can be an element or a coordinate. The popup moves with the anchor. By default, the popup closes on focus loss or
+ * when pressing the escape key.
+ *
+ * A popup can be bound to a context (e.g., a part or view), displaying the popup only if the context is visible and closing
+ * it when the context is disposed. Defaults to the calling context.
  */
-declare class PopupService {
-    private readonly _environmentInjector;
-    private readonly _overlay;
-    private readonly _focusManager;
-    private readonly _viewRegistry;
-    private readonly _popupRegistry;
-    private readonly _zone;
-    private readonly _document;
-    private readonly _view;
+declare abstract class WorkbenchPopupService {
     /**
      * Opens a popup with the specified component and options.
      *
-     * The anchor is used to position the popup based on its preferred alignment:
-     * - Using an element: The popup opens and sticks to the element.
-     * - Using coordinates: The popup opens and sticks relative to the view or page bounds.
+     * An anchor is used to position the popup based on its preferred alignment. The anchor can be an element or a coordinate.
      *
-     * If the popup is opened within a view, it only displays if the view is active and closes when the view is closed.
+     * Data can be passed to the component via {@link PopupConfig.input} property. The component can inject the popup handle {@link WorkbenchPopup} to
+     * read input data or to close the popup.
      *
      * By default, the popup closes on focus loss or when pressing the escape key.
      *
-     * Pass data to the popup via {@link PopupConfig#input}. The component can inject the popup handle {@link Popup} to
-     * read input data or to close the popup.
-     *
-     * @param config - Controls popup behavior
+     * @param config - Controls the appearance and behavior of the popup.
      * @returns Promise that resolves to the popup result, if any, or that rejects if the popup couldn't be opened or was closed with an error.
      */
-    open<R>(config: PopupConfig): Promise<R | undefined>;
-    /**
-     * Creates the popup handle.
-     */
-    private createPopup;
-    /**
-     * Closes the popup depending on the configured popup closing strategy.
-     */
-    private installPopupCloser;
-    /**
-     * Hides the popup when its contextual view is detached, and displays it when it is reattached. Also restores the focus on re-activation.
-     * The contextual view is detached if not active, or located in the peripheral area and the main area is maximized.
-     */
-    private hidePopupOnViewDetach;
-    /**
-     * Creates a signal that tracks the position of the popup anchor.
-     */
-    private trackPopupOrigin;
-    /**
-     * Resolves the contextual view to which the popup is bound.
-     */
-    private resolveContextualView;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PopupService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<PopupService>;
+    abstract open<R>(config: PopupConfig): Promise<R | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchPopupService>;
 }
 
 /**
@@ -6229,5 +6388,5 @@ declare class IconComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "wb-icon", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { IconComponent, LogAppender, LogLevel, Logger, LoggerName, MAIN_AREA, MAIN_AREA_INITIAL_PART_ID, MICROFRONTEND_PLATFORM_POST_STARTUP, MICROFRONTEND_PLATFORM_PRE_STARTUP, MicrofrontendPlatformConfigLoader, MicrofrontendPlatformStartupPhase, Notification, NotificationService, Popup, PopupConfig, PopupService, TextPipe, VIEW_TAB_RENDERING_CONTEXT, WORKBENCH_ID, WORKBENCH_POST_STARTUP, WORKBENCH_PRE_STARTUP, WORKBENCH_STARTUP, WorkbenchComponent, WorkbenchConfig, WorkbenchDesktopDirective, WorkbenchDialog, WorkbenchDialogActionDirective, WorkbenchDialogFooterDirective, WorkbenchDialogHeaderDirective, WorkbenchDialogService, WorkbenchLauncher, WorkbenchLayoutFactory, WorkbenchMessageBoxService, WorkbenchPart, WorkbenchPartActionDirective, WorkbenchPerspectiveData, WorkbenchRouteData, WorkbenchRouter, WorkbenchRouterLinkDirective, WorkbenchService, WorkbenchStartup, WorkbenchStartupPhase, WorkbenchStorage, WorkbenchView, WorkbenchViewMenuItemDirective, canMatchWorkbenchOutlet, canMatchWorkbenchPart, canMatchWorkbenchPerspective, canMatchWorkbenchView, provideMicrofrontendPlatformInitializer, provideWorkbench, provideWorkbenchInitializer, text };
+export { IconComponent, LogAppender, LogLevel, Logger, LoggerName, MAIN_AREA, MAIN_AREA_INITIAL_PART_ID, MICROFRONTEND_PLATFORM_POST_STARTUP, MICROFRONTEND_PLATFORM_PRE_STARTUP, MicrofrontendPlatformConfigLoader, MicrofrontendPlatformStartupPhase, Notification, NotificationService, WorkbenchPopup as Popup, PopupConfig, WorkbenchPopupService as PopupService, TextPipe, VIEW_TAB_RENDERING_CONTEXT, WORKBENCH_ID, WORKBENCH_POST_STARTUP, WORKBENCH_PRE_STARTUP, WORKBENCH_STARTUP, WorkbenchComponent, WorkbenchConfig, WorkbenchDesktopDirective, WorkbenchDialog, WorkbenchDialogActionDirective, WorkbenchDialogFooterDirective, WorkbenchDialogHeaderDirective, WorkbenchDialogService, WorkbenchLauncher, WorkbenchLayoutFactory, WorkbenchMessageBoxService, WorkbenchPart, WorkbenchPartActionDirective, WorkbenchPerspectiveData, WorkbenchPopup, WorkbenchPopupService, WorkbenchRouteData, WorkbenchRouter, WorkbenchRouterLinkDirective, WorkbenchService, WorkbenchStartup, WorkbenchStartupPhase, WorkbenchStorage, WorkbenchView, WorkbenchViewMenuItemDirective, canMatchWorkbenchOutlet, canMatchWorkbenchPart, canMatchWorkbenchPerspective, canMatchWorkbenchView, provideMicrofrontendPlatformInitializer, provideWorkbench, provideWorkbenchInitializer, text };
 export type { ActivityId, BottomLeftPoint, BottomRightPoint, CanCloseFn, CanCloseRef, CloseStrategy, Commands, DialogId, Disposable, DockedPartExtras, DockingArea, LogEvent, MenuItemConfig, MicrofrontendPlatformInitializerOptions, NavigateFn, NavigationData, NavigationState, NotificationConfig, PartExtras, PartId, Point, PopupId, PopupOrigin, PopupSize, ReferencePart, TopLeftPoint, TopRightPoint, Translatable, ViewId, ViewMenuItemsConfig, ViewTabRenderingContext, WorkbenchDialogOptions, WorkbenchDialogSize, WorkbenchElement, WorkbenchIconDescriptor, WorkbenchIconProviderFn, WorkbenchInitializer, WorkbenchInitializerFn, WorkbenchInitializerOptions, WorkbenchLayout, WorkbenchLayoutFn, WorkbenchMenuItem, WorkbenchMessageBoxOptions, WorkbenchNavigationExtras, WorkbenchPartAction, WorkbenchPartActionFn, WorkbenchPartNavigation, WorkbenchPerspective, WorkbenchPerspectiveDefinition, WorkbenchPerspectiveSelectionFn, WorkbenchPerspectives, WorkbenchTextProviderFn, WorkbenchTheme, WorkbenchViewMenuItemFn, WorkbenchViewNavigation };