@camunda/e2e-test-suite 0.0.1014 → 0.0.1016

package/dist/pages/8.8/ModelerCreatePage.d.ts

@@ -1,6 +1,7 @@
 import { Page, Locator } from '@playwright/test';
 declare class ModelerCreatePage {
     private page;
+    private processApplicationPage;
     readonly generalPanel: Locator;
     private deployDiagramDialog;
     readonly processIdInput: Locator;

package/dist/pages/8.8/ModelerCreatePage.js

@@ -5,8 +5,10 @@ const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
 const ConnectorMarketplacePage_1 = require("./ConnectorMarketplacePage");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class ModelerCreatePage {
     page;
+    processApplicationPage;
     generalPanel;
     deployDiagramDialog;
     processIdInput;
@@ -115,6 +117,7 @@ class ModelerCreatePage {
     diagramNameBreadcrumb;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.generalPanel = page.locator('[data-group-id="group-general"]');
         this.processIdInput = page.getByLabel('ID', { exact: true });
         this.startEventElement = page.locator('.djs-hit').first();
@@ -253,8 +256,12 @@ class ModelerCreatePage {
         this.rbaEnabledDeployedDialog = page.getByRole('dialog', {
             name: 'Process successfully deployed',
         });
+        // Since camunda/camunda-hub#25831 a diagram deploys as part of its process
+        // application and hub titles the modal for the application, not for the
+        // single resource, so an exact 'Deploy diagram' name no longer matches.
+        // Match on the verb -- pages/SM-8.10 already leaves this unfiltered.
         this.deployDiagramDialog = page.getByRole('dialog', {
-            name: 'Deploy diagram',
+            name: /^Deploy/,
         });
         this.appendGatewayButton = page.getByRole('button', {
             name: 'Append gateway',
@@ -565,6 +572,7 @@ class ModelerCreatePage {
         await this.deployMenuItem.click({ timeout: 60000 });
     }
     async deployDiagram(clusterName) {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         await this.clickDeployButtonWithRetry();
         await (0, test_1.expect)(this.deployDiagramDialog).toBeVisible({
             timeout: 30000,
@@ -605,6 +613,10 @@ class ModelerCreatePage {
         const retryDelayMs = 20000;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
+                // Inside the loop, not before it: a no-op once bound, but selectCluster
+                // clears the binding when the dialog does not offer the cluster, so the
+                // next attempt rebinds rather than reopening an unchanged dialog.
+                await this.processApplicationPage.ensureStageCluster(clusterName);
                 await this.clickStartInstanceMainButton();
                 await this.selectCluster(clusterName);
                 if (variables.length > 0) {
@@ -661,6 +673,46 @@ class ModelerCreatePage {
     async selectCluster(clusterName) {
         await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 30000 });
         const healthCheckTimeout = 30000;
+        // Inside a process application the deploy dialog renders
+        // ProcessAppClusterSelection, not the per-deploy ClusterSelection toggle
+        // list: it shows only clusters assigned to one of the application's stages
+        // and auto-selects the first, so there is no label to click. Confirm the
+        // intended cluster is the one on offer instead.
+        //
+        // The unconfigured case is called out explicitly: without this the symptom
+        // is the cluster toggle never appearing, retried until the test times out,
+        // which says nothing about the actual cause.
+        const notConfigured = this.dialog.getByText('Clusters not configured for stages');
+        if (await notConfigured.isVisible().catch(() => false)) {
+            throw new Error(`Process application has no cluster assigned to any stage, so "${clusterName}" cannot be deployed to. ` +
+                'ProcessApplicationPage.ensureStageCluster() should have bound it before the deploy dialog was opened.');
+        }
+        const legacyClusterToggle = this.dialog.locator('label').filter({
+            hasText: new RegExp(`^${clusterName}`),
+        });
+        const isLegacyDialog = await legacyClusterToggle
+            .first()
+            .isVisible()
+            .catch(() => false);
+        if (!isLegacyDialog) {
+            const offered = await this.dialog
+                .getByText(clusterName, { exact: false })
+                .first()
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!offered) {
+                // Forget the binding before failing. The dialog lists exactly the
+                // clusters this application's stages point at, so a missing cluster
+                // means the binding did not take -- and no amount of reopening the
+                // dialog will make it appear. Clearing the record lets the caller's
+                // next attempt rebind instead of re-checking an unchanged dialog.
+                this.processApplicationPage.forgetStageCluster();
+                throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
+                    'binding did not take. It will be rebound on the next attempt.');
+            }
+            return;
+        }
         const healthyRegex = new RegExp(`${clusterName}.*?HealthydevManage`);
         const clusterLabel = this.dialog
             .locator('label')
@@ -704,8 +756,45 @@ class ModelerCreatePage {
     async clickDiagramBreadcrumb() {
         await this.diagramBreadcrumb.click({ timeout: 10000 });
     }
+    // Opening the breadcrumb menu leaves the pointer on the breadcrumb button,
+    // and hub renders that button's truncated-name tooltip on top of the menu,
+    // where it swallows the click on "Rename" -- playwright reports
+    // `<div role="tooltip">…</div> intercepts pointer events`. Since
+    // camunda/camunda-hub#25831 the breadcrumb carries an extra
+    // process-application crumb, so the name truncates, and the tooltip renders,
+    // as the rule rather than the exception. Park the pointer away from the
+    // breadcrumb and let the tooltip unmount before clicking; reopen the menu if
+    // a previous attempt closed it.
     async clickEditDiagramNameButton() {
-        await this.renameDiagramNameButton.click({ timeout: 10000 });
+        const openTooltip = this.page.locator('[role="tooltip"][aria-hidden="false"]');
+        await (0, test_1.expect)(async () => {
+            const menuOpen = await this.renameDiagramNameButton
+                .isVisible()
+                .catch(() => false);
+            if (!menuOpen) {
+                await this.clickDiagramBreadcrumb();
+            }
+            // Park the pointer so the breadcrumb's own tooltip gets a chance to
+            // unmount -- best effort, because it is not reliably hover-driven, and
+            // requiring it to go turned an interceptable click into a hard failure.
+            await this.page.mouse.move(0, 0);
+            await openTooltip
+                .first()
+                .waitFor({ state: 'hidden', timeout: 2000 })
+                .catch(() => false);
+            try {
+                await this.renameDiagramNameButton.click({ timeout: 10000 });
+            }
+            catch {
+                // The tooltip renders over the menu and swallows the click (playwright
+                // reports `<div role="tooltip">…</div> intercepts pointer events`).
+                // Dispatching on the element bypasses hit-testing, which no amount of
+                // waiting achieves when the tooltip never unmounts. Not a swallowed
+                // failure: the assertion below is what decides whether this worked.
+                await this.renameDiagramNameButton.dispatchEvent('click');
+            }
+            await (0, test_1.expect)(this.diagramNameInput).toBeVisible({ timeout: 10000 });
+        }).toPass({ timeout: 60000, intervals: [1000, 2000, 5000] });
     }
     async enterDiagramName(name) {
         await this.diagramNameInput.fill(name, { timeout: 90000 });
@@ -1278,6 +1367,16 @@ class ModelerCreatePage {
         await this.playTab.click();
     }
     async completePlayConfiguration(clusterName) {
+        // Play is a tab on the diagram page, not its own URL, so the stage-cluster
+        // detour's goto() lands back on the Modeler tab and every Play locator
+        // below would then look for a panel that is no longer rendered. Re-enter
+        // Play when the detour actually navigated. Binding cannot simply move
+        // before switchToPlay(): this is the first point in the flow that knows
+        // which cluster the test plays on.
+        const reboundStageCluster = await this.processApplicationPage.ensureStageCluster(clusterName);
+        if (reboundStageCluster) {
+            await this.switchToPlay();
+        }
         const timeout = 30000;
         // New flow (8.10+): "Setup environment" panel with three steps:
         //   1. Connect cluster → "Configure environment" modal → select cluster → Save
@@ -1301,19 +1400,37 @@ class ModelerCreatePage {
             name: /^Configure (test case|scenario)$/,
         }))
             .first();
-        // Wait up to 15s for EITHER the new-flow setup panel OR the legacy Continue
-        // button to appear. Using .or() avoids separate sequential timeouts that would
-        // both expire before the page finishes loading on a slow cluster.
-        const setupOrContinue = setupDeployButton.or(this.continueToPlayButton);
-        const panelAppeared = await setupOrContinue
-            .first()
-            .isVisible({ timeout: 15000 })
-            .catch(() => false);
-        if (!panelAppeared) {
-            // Neither appeared — Play is already configured and ready.
+        // Play settles into exactly ONE of three states, and which one is not
+        // knowable up front, so race them instead of timing out on each in turn:
+        // the setup overlay, the legacy Continue button, or the configure-test
+        // panel (meaning setup is already done for this diagram).
+        //
+        // Waiting only for the first two and reading "neither" as "already ready"
+        // was wrong once the diagram moved inside a process application.
+        // ConfigurationOverlay renders null until isDeploymentStateValidated, and
+        // it sets that flag synchronously ONLY when processApplicationId is
+        // undefined -- exactly what a project-root diagram used to give it. With
+        // the diagram in a process application the id is defined, so the overlay
+        // must first await checkExistingDeployment(). The old 15s probe raced that
+        // async call, concluded "already ready" and returned while the overlay was
+        // still about to appear. ConfigureTestPanel returns null for as long as the
+        // overlay is up, so the Start button never existed and
+        // clickStartInstanceButton burned its entire retry budget looking for it.
+        const configurationOverlay = this.page.locator('[data-test="play-configuration-overlay"]');
+        const configureTestPanel = this.page.getByTestId('configure-test-panel');
+        await (0, test_1.expect)(configurationOverlay
+            .or(this.continueToPlayButton)
+            .or(configureTestPanel)
+            .first()).toBeVisible({ timeout: 90000 });
+        if (await configureTestPanel.isVisible()) {
+            // Already past setup for this diagram -- nothing to drive.
             return;
         }
-        const isNewFlow = await setupDeployButton.isVisible().catch(() => false);
+        // Keyed on the overlay itself, not on its Deploy button: when
+        // checkExistingDeployment finds a deployment the overlay opens with the
+        // deploy step already complete, so there is no Deploy button to see and
+        // keying on it would fall through to the legacy Continue flow.
+        const isNewFlow = await configurationOverlay.isVisible();
         if (isNewFlow) {
             // Step 1: connect cluster if not yet connected (modal with cluster dropdown)
             const connectClusterButton = this.page.getByRole('button', {
@@ -1352,13 +1469,33 @@ class ModelerCreatePage {
                     .getByRole('button', { name: 'Save' })
                     .click({ timeout });
             }
-            // Step 2: deploy — wait for enabled; button stays disabled until the cluster
-            // connection is confirmed by the backend after the Save in step 1.
-            await (0, test_1.expect)(setupDeployButton).toBeEnabled({ timeout: 30000 });
-            await setupDeployButton.click({ timeout });
-            await (0, test_1.expect)(this.page.getByText('Process has been successfully deployed')).toBeVisible({ timeout: 90000 });
-            // Step 3: configure scenario
-            await configureScenarioButton.click({ timeout });
+            // Step 2: deploy, unless the overlay already opened with the
+            // deploy step complete. checkExistingDeployment only runs when
+            // processApplicationId is defined, which it now is, so re-entering
+            // Play on an already-deployed process application legitimately
+            // has nothing to deploy and renders no Deploy button at all.
+            const alreadyDeployed = await configureScenarioButton
+                .isVisible({ timeout: 3000 })
+                .catch(() => false);
+            if (!alreadyDeployed) {
+                // Step 2: deploy — wait for enabled; button stays disabled until the cluster
+                // connection is confirmed by the backend after the Save in step 1.
+                await (0, test_1.expect)(setupDeployButton).toBeEnabled({ timeout: 30000 });
+                await setupDeployButton.click({ timeout });
+                await (0, test_1.expect)(this.page.getByText('Process has been successfully deployed')).toBeVisible({ timeout: 90000 });
+            }
+            // Step 3: leave the overlay, and confirm we actually left it. The
+            // button only calls hideConfigurationOverlay(); the overlay's own
+            // cluster-change effect can then fire resetDeployment and bring it
+            // straight back, and ConfigureTestPanel stays null while it is up.
+            // Assert the panel really rendered, and re-drive the click if the
+            // overlay returned.
+            await (0, test_1.expect)(async () => {
+                if (await configurationOverlay.isVisible()) {
+                    await configureScenarioButton.click({ timeout });
+                }
+                await (0, test_1.expect)(configureTestPanel).toBeVisible({ timeout: 15000 });
+            }).toPass({ timeout: 90000 });
             return;
         }
         // Legacy flow: select cluster via dialog, then click Continue.

package/dist/pages/8.8/ModelerHomePage.d.ts

@@ -2,6 +2,9 @@ import { Page, Locator } from '@playwright/test';
 declare class ModelerHomePage {
     private defaultFolderName;
     private page;
+    private processApplicationPage;
+    private processApplicationUrl?;
+    private processApplicationName?;
     readonly modelerPageBanner: Locator;
     readonly createNewProjectButton: Locator;
     readonly projectNameInput: Locator;
@@ -11,6 +14,7 @@ declare class ModelerHomePage {
     readonly bpmnTemplateOption: Locator;
     readonly formTemplateOption: Locator;
     readonly projectBreadcrumb: Locator;
+    readonly workspaceBreadcrumb: Locator;
     readonly openOrganizationsButton: Locator;
     readonly manageButton: Locator;
     readonly crossComponentProjectFolder: Locator;
@@ -37,10 +41,18 @@ declare class ModelerHomePage {
     getProjectNames(name: string): Promise<string[]>;
     clickProcessDiagram(name: string): Promise<void>;
     clickDiagramTypeDropdown(): Promise<void>;
+    clickWorkspaceDiagramTypeDropdown(): Promise<void>;
     clickBpmnTemplateOption(): Promise<void>;
     clickFormOption(): Promise<void>;
     enterFormName(name: string): Promise<void>;
     clickProjectBreadcrumb(): Promise<void>;
+    clickWorkspaceBreadcrumb(): Promise<void>;
+    enterResourceContainer(name?: string): Promise<void>;
+    private clickCreateProcessApplication;
+    private ensureInResourceContainer;
+    returnToResourceContainer(): Promise<void>;
+    startBlankBpmnDiagram(): Promise<void>;
+    private becameVisible;
     clickHomeBreadcrumb(): Promise<void>;
     private dismissBlockingDialogs;
     clickOpenOrganizationsButton(): Promise<void>;

package/dist/pages/8.8/ModelerHomePage.js

@@ -4,9 +4,24 @@ exports.ModelerHomePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const randomName_1 = require("../../utils/randomName");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class ModelerHomePage {
     defaultFolderName = 'Cross Component Test Project';
     page;
+    // Since camunda/camunda-hub#25831 files and folders cannot sit at a
+    // workspace ("project" in today's UI) root -- only process applications and
+    // IDP applications can. The container is therefore entered lazily, at the
+    // point a resource is created, and remembered for the lifetime of this page
+    // object (one instance per test, see fixtures/8.8.ts). Specs that only
+    // need the workspace itself -- collaborators, IDP applications -- never
+    // trigger the hop.
+    processApplicationPage;
+    // Load-bearing: hub renders no process-application breadcrumb on a diagram
+    // page at container root, so the remembered URL -- not a breadcrumb click --
+    // is how we get back. Hub's own Playwright suite does the same.
+    processApplicationUrl;
+    processApplicationName;
     modelerPageBanner;
     createNewProjectButton;
     projectNameInput;
@@ -16,6 +31,7 @@ class ModelerHomePage {
     bpmnTemplateOption;
     formTemplateOption;
     projectBreadcrumb;
+    workspaceBreadcrumb;
     openOrganizationsButton;
     manageButton;
     crossComponentProjectFolder;
@@ -34,6 +50,7 @@ class ModelerHomePage {
     buttonSkipCustomization;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.modelerPageBanner = page.getByRole('banner', {
             name: 'Camunda Modeler',
         });
@@ -55,13 +72,20 @@ class ModelerHomePage {
             .locator('[data-test="create-idp-application"]')
             .getByText('IDP Application');
         this.diagramTypeDropdown = page.locator('[data-test="diagram-dropdown"]');
-        this.bpmnTemplateOption = page
-            .locator('[data-test="create-bpmn-diagram"]')
-            .getByText('BPMN Diagram');
-        this.formTemplateOption = page
-            .locator('[data-test="create-form"]')
-            .getByText('Form');
+        // Matched on the test id alone: hub's design-system variant of the create
+        // menu renders "BPMN diagram" (lowercase d), so a text filter breaks the
+        // day that variant ships.
+        this.bpmnTemplateOption = page.locator('[data-test="create-bpmn-diagram"]');
+        this.formTemplateOption = page.locator('[data-test="create-form"]');
         this.projectBreadcrumb = page.locator('[data-test="breadcrumb-project"]');
+        // Kept separate from projectBreadcrumb, which now means "the container my
+        // resources live in". When hub's workspaces terminology flag flips,
+        // breadcrumb-project comes to denote the process application, so the
+        // workspace level needs its own name from the start.
+        this.workspaceBreadcrumb = page
+            .locator('[data-test="breadcrumb-project"]')
+            .or(page.locator('[data-test="breadcrumb-workspace"]'))
+            .first();
         this.homeBreadcrumb = page.locator('[data-test="breadcrumb-home"]');
         this.openOrganizationsButton = page.getByLabel('Open Organizations');
         this.manageButton = page.getByRole('menuitem', { name: 'Manage' });
@@ -157,12 +181,49 @@ class ModelerHomePage {
             .map((el) => el.textContent || '')
             .filter((text) => text !== ''));
     }
+    // Opens a resource where this test put it. Several specs leave Modeler
+    // entirely (to Operate, to Optimize) and come back via
+    // clickCrossComponentProjectFolder(), which lands at workspace root -- the
+    // resource is one level down, so re-enter the container first.
     async clickProcessDiagram(name) {
+        await this.ensureInResourceContainer();
         const process = this.rows.filter({ hasText: name }).getByTitle(name).first();
         await (0, test_1.expect)(process).toBeVisible({ timeout: 90000 });
         await process.click();
     }
+    // Opens the create menu inside this test's process application. The menu at
+    // workspace root no longer offers BPMN, Form or Upload -- those resources
+    // cannot live there -- so the container is entered first. Callers are
+    // unchanged, which is why the existing spec call sites need no edit.
     async clickDiagramTypeDropdown() {
+        await this.enterResourceContainer();
+        const dropdown = this.processApplicationPage.createNewDropdown;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            try {
+                await this.dismissOverlays();
+                await (0, test_1.expect)(dropdown).toBeVisible({
+                    timeout: 45000,
+                });
+                await dropdown.click({ timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                if (attempt >= 3) {
+                    throw error;
+                }
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                await this.page.waitForLoadState('domcontentloaded');
+                // Recover into the container rather than the workspace: the reload
+                // above can land on either, and the create menu we want is the
+                // container's.
+                await this.returnToResourceContainer();
+            }
+        }
+    }
+    // Opens the create menu at workspace root, which is the only place process
+    // applications and IDP applications can be created. Everything else has to
+    // go through clickDiagramTypeDropdown().
+    async clickWorkspaceDiagramTypeDropdown() {
         for (let attempt = 0; attempt < 4; attempt++) {
             try {
                 await this.dismissOverlays();
@@ -194,8 +255,109 @@ class ModelerHomePage {
         await this.formNameInput.fill(name, { timeout: 60000 });
         await this.formNameInput.press('Enter');
     }
+    // Kept under its original name because it is what the existing call sites
+    // already mean: "go back to where my resources live". That is now the
+    // process application, not the workspace root.
     async clickProjectBreadcrumb() {
-        await this.projectBreadcrumb.click({ timeout: 60000 });
+        await this.returnToResourceContainer();
+    }
+    // The workspace ("project") level itself, for the surfaces that genuinely
+    // live there -- collaborators, IDP applications, published element
+    // templates.
+    async clickWorkspaceBreadcrumb() {
+        await this.workspaceBreadcrumb.click({ timeout: 60000 });
+    }
+    // Creates, once per test, the process application that holds this test's
+    // resources, and leaves the browser inside it. Idempotent: called again while
+    // already in the container it is a no-op, so a spec that creates several
+    // resources in a row pays for the container once.
+    //
+    // One container per test rather than one shared with the seeded workspace:
+    // deploying is process-application-wide, so a shared container would let one
+    // spec's deploy pick up every other spec's half-modelled diagram.
+    async enterResourceContainer(name) {
+        if (this.processApplicationUrl) {
+            const stillInside = await this.becameVisible(this.processApplicationPage.breadcrumb, 5000);
+            if (!stillInside) {
+                await this.returnToResourceContainer();
+            }
+            return;
+        }
+        this.processApplicationName =
+            name ??
+                (await (0, randomName_1.randomNameAgregator)('Cross Component Process Application'));
+        console.log(`Creating process application ${this.processApplicationName} inside ${this.defaultFolderName}`);
+        await this.clickCreateProcessApplication();
+        await this.processApplicationPage.nameNewProcessApplication(this.processApplicationName);
+        this.processApplicationUrl = this.page.url();
+        // Remember the container; its stage cluster is bound on the first deploy,
+        // by ProcessApplicationPage.ensureStageCluster, which -- unlike this point
+        // in the flow -- knows which cluster the test is going to deploy to.
+        this.processApplicationPage.rememberResourceContainer(this.processApplicationUrl);
+    }
+    // Which control creates a process application depends on the hub version
+    // under test. Since camunda/camunda-hub#25831 it is a plain primary button on
+    // the workspace root, and the "Create new" menu explicitly hides the item
+    // (hideProcessApplication) because a process application is no longer just
+    // another resource. Before that change the menu item was the only way in.
+    // Race both entry points so neither version pays a full timeout, then use
+    // whichever one rendered.
+    async clickCreateProcessApplication() {
+        const button = this.processApplicationPage.createProcessApplicationButton;
+        const rootLoaded = await this.becameVisible(button.or(this.diagramTypeDropdown).first(), 60000);
+        if (!rootLoaded) {
+            await this.page.reload();
+        }
+        // Short: the joint probe above already settled which branch rendered, and
+        // hub renders exactly one of them (EntityTable renders the toolbar's create
+        // menu OR the empty state, never both), so this only confirms which.
+        if (await this.becameVisible(button, 5000)) {
+            await this.processApplicationPage.clickCreateProcessApplicationButton();
+            return;
+        }
+        await this.clickWorkspaceDiagramTypeDropdown();
+        await this.processApplicationPage.clickCreateProcessApplicationOption();
+    }
+    // Re-enters this test's container if it already has one, without creating
+    // one: opening an existing resource must not have the side effect of
+    // creating a container for a spec that never asked for it.
+    async ensureInResourceContainer() {
+        if (!this.processApplicationUrl) {
+            return;
+        }
+        await this.enterResourceContainer();
+    }
+    // Navigates back to this test's process application by the remembered URL
+    // rather than by a breadcrumb click: hub renders no process-application
+    // breadcrumb on a diagram page at container root, and the breadcrumb that
+    // does exist on the container page doubles as its rename control. Hub's own
+    // Playwright suite navigates back the same way.
+    async returnToResourceContainer() {
+        if (!this.processApplicationUrl) {
+            await this.clickWorkspaceBreadcrumb();
+            return;
+        }
+        await this.page.goto(this.processApplicationUrl, {
+            waitUntil: 'domcontentloaded',
+        });
+        await this.processApplicationPage.waitForProcessApplication();
+        await this.dismissOverlays();
+    }
+    // Single seam for "give me an empty BPMN diagram in this test's container".
+    // A process application always ships an auto-created main process; this adds
+    // a new diagram rather than adopting that one, so every existing modelling
+    // assertion keeps its current subject.
+    async startBlankBpmnDiagram() {
+        await this.clickDiagramTypeDropdown();
+        await this.clickBpmnTemplateOption();
+    }
+    // Boolean visibility probe. waitFor rather than isVisible, which resolves
+    // immediately and would report a false negative on a still-rendering page.
+    async becameVisible(locator, timeout) {
+        return locator
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
+            .catch(() => false);
     }
     async clickHomeBreadcrumb() {
         // The Console shell's HelpCenter panel ("Your recommendations") renders on

package/dist/pages/8.8/ProcessApplicationPage.d.ts

@@ -0,0 +1,30 @@
+import { Locator, Page } from '@playwright/test';
+declare class ProcessApplicationPage {
+    private page;
+    readonly createProcessApplicationButton: Locator;
+    readonly createProcessApplicationOption: Locator;
+    readonly creationDialog: Locator;
+    readonly nameInput: Locator;
+    readonly submitButton: Locator;
+    readonly cancelButton: Locator;
+    readonly breadcrumb: Locator;
+    readonly folderExplorer: Locator;
+    readonly createNewDropdown: Locator;
+    readonly inlineNameInput: Locator;
+    readonly defineStagesDialog: Locator;
+    readonly developmentClusterSelect: Locator;
+    readonly defineStagesSaveButton: Locator;
+    constructor(page: Page);
+    private pageReady;
+    waitForProcessApplication(timeout?: number): Promise<void>;
+    clickCreateProcessApplicationButton(): Promise<void>;
+    clickCreateProcessApplicationOption(): Promise<void>;
+    nameNewProcessApplication(name: string): Promise<void>;
+    defineDevelopmentStage(clusterName?: string): Promise<void>;
+    rememberResourceContainer(url: string): void;
+    forgetStageCluster(): void;
+    ensureStageCluster(clusterName: string): Promise<boolean>;
+    private openStageDefinition;
+    openByName(name: string): Promise<void>;
+}
+export { ProcessApplicationPage };