@camunda/e2e-test-suite 0.0.1009 → 0.0.1011

package/dist/pages/8.10/FormJsPage.d.ts

@@ -1,6 +1,7 @@
 import { Page, Locator } from '@playwright/test';
 declare class FormJsPage {
     private page;
+    private processApplicationPage;
     readonly aiFormGeneratorButton: Locator;
     readonly formRequestInput: Locator;
     readonly generateFormButton: Locator;
@@ -31,6 +32,7 @@ declare class FormJsPage {
     selectCluster(clusterName: string): Promise<void>;
     clickDeployButton(): Promise<void>;
     clickDeploySubButton(): Promise<void>;
+    selectOnlyThisResource(): Promise<void>;
     deployForm(clusterName: string): Promise<void>;
 }
 export { FormJsPage };

package/dist/pages/8.10/FormJsPage.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormJsPage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class FormJsPage {
     page;
+    processApplicationPage;
     aiFormGeneratorButton;
     formRequestInput;
     generateFormButton;
@@ -23,6 +25,7 @@ class FormJsPage {
     deploySuccessNotification;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.aiFormGeneratorButton = page.getByRole('button', {
             name: 'AI Form Generator',
         });
@@ -44,9 +47,12 @@ class FormJsPage {
         this.deployButton = page
             .locator('[data-test="action-bar"]')
             .getByRole('button', { name: 'Deploy', exact: true });
+        // Inside a process application hub titles this modal for the application
+        // rather than for the form, so 'Deploy form' never matches and the dialog
+        // reads as absent. pages/SM-8.10 filters on 'Deploy' for the same reason.
         this.dialog = page
             .locator('.cds--modal-container[role="dialog"]')
-            .filter({ hasText: 'Deploy form' });
+            .filter({ hasText: 'Deploy' });
         this.deploySubButton = this.dialog.getByRole('button', {
             name: 'Deploy',
             exact: true,
@@ -120,6 +126,31 @@ class FormJsPage {
     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) {
+            await (0, test_1.expect)(this.dialog.getByText(clusterName, { exact: false }).first()).toBeVisible({ timeout: 30000 });
+            return;
+        }
         const healthyRegex = new RegExp(`${clusterName}[\\s\\S]*?HealthydevManage`);
         const cluster = this.dialog.locator(`[title="${clusterName}"]`);
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
@@ -138,12 +169,39 @@ class FormJsPage {
     async clickDeploySubButton() {
         await this.deploySubButton.click({ timeout: 60000 });
     }
+    // Since camunda/camunda-hub#25831 a form lives inside a process application,
+    // and Hub then scopes Deploy to the WHOLE application by default -- it calls
+    // deployProcessApplication, not deployFile, so the "Form deployed!" toast
+    // never fires (hub's own form-deploy-action.spec.sm.tsx asserts exactly that
+    // default). Narrowing the scope keeps this a form-deploy test instead of
+    // silently turning it into a process-application deploy. The combobox only
+    // exists inside a container, hence the boolean probe.
+    async selectOnlyThisResource() {
+        const scopeSelect = this.dialog.getByRole('combobox', {
+            name: 'Resources to deploy',
+        });
+        const hasScopeSelect = await scopeSelect
+            .waitFor({ state: 'visible', timeout: 10000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!hasScopeSelect) {
+            return;
+        }
+        await scopeSelect.click();
+        await this.dialog
+            .getByRole('option', { name: 'Only this resource' })
+            .or(this.dialog.getByText('Only this resource', { exact: true }))
+            .first()
+            .click({ timeout: 30000 });
+    }
     async deployForm(clusterName) {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         await this.clickDeployButton();
         await (0, test_1.expect)(this.dialog).toBeVisible({
             timeout: 30000,
         });
         await this.selectCluster(clusterName);
+        await this.selectOnlyThisResource();
         await this.clickDeploySubButton();
         await (0, test_1.expect)(this.deploySuccessNotification).toBeVisible({ timeout: 30000 });
     }

package/dist/pages/8.10/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.10/ModelerCreatePage.js

@@ -4,9 +4,11 @@ exports.ModelerCreatePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const ConnectorMarketplacePage_1 = require("./ConnectorMarketplacePage");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
 class ModelerCreatePage {
     page;
+    processApplicationPage;
     generalPanel;
     deployDiagramDialog;
     processIdInput;
@@ -117,6 +119,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();
@@ -269,8 +272,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',
@@ -604,6 +611,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,
@@ -620,6 +628,7 @@ class ModelerCreatePage {
         await this.deployAndRunSubButton.click({ timeout: 30000 });
     }
     async runProcessInstance(clusterName, variables = '', formVariables = {}, textToVisible = '', hasDeploymentPermission = true, businessId = '') {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         const maxRetries = 10;
         const retryDelayMs = 20000;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -683,6 +692,31 @@ 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) {
+            await (0, test_1.expect)(this.dialog.getByText(clusterName, { exact: false }).first()).toBeVisible({ timeout: 30000 });
+            return;
+        }
         const healthyRegex = new RegExp(`${clusterName}.*?HealthydevManage`);
         const clusterLabel = this.dialog
             .locator('label')
@@ -708,8 +742,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] });
     }
     // The rename can silently no-op: camunda-hub's breadcrumb name editor
     // (InlineEditable) resets its input back to the stored diagram name whenever
@@ -1288,6 +1359,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
@@ -1311,19 +1392,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 a cluster only if none is connected yet.
             //
@@ -1386,13 +1485,33 @@ class ModelerCreatePage {
                 // Wait for Deploy button to become enabled after cluster is saved.
                 await (0, test_1.expect)(setupDeployButton).toBeEnabled({ timeout: 30000 });
             }
-            // 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.10/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;
@@ -35,11 +39,19 @@ 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>;
     enterFormNameWithRetry(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>;
     clickOpenOrganizationsButton(): Promise<void>;
     createForm(formName: string): Promise<void>;

package/dist/pages/8.10/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.10.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;
@@ -32,6 +48,7 @@ class ModelerHomePage {
     formNameBreadcrumb;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.modelerPageBanner = page.getByRole('banner', {
             name: 'Camunda Modeler',
         });
@@ -52,13 +69,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,17 +181,33 @@ 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() {
-        // Navigation-class wait: this is the first control on the project page, so
-        // it is reached right after navigating into the project (or back via the
-        // breadcrumb) and its render waits on the project's resource list. 15s was
-        // short enough that a slow project load failed with
-        // `locator('[data-test="diagram-dropdown"]') ... element(s) not found`.
+        await this.enterResourceContainer();
+        const dropdown = this.processApplicationPage.createNewDropdown;
+        // Navigation-class wait: the dropdown's render waits on the container's
+        // resource list, so a slow load otherwise fails with
+        // `element(s) not found`.
+        await (0, test_1.expect)(dropdown).toBeVisible({ timeout: 60000 });
+        await dropdown.click();
+    }
+    // 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() {
         await (0, test_1.expect)(this.diagramTypeDropdown).toBeVisible({
             timeout: 60000,
         });
@@ -214,8 +254,109 @@ class ModelerHomePage {
                 `(attempt ${attempt}/${maxRetries}). Re-entering the name.`);
         }
     }
+    // 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.dismissBlockingDialog();
+    }
+    // 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() {
         try {

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

@@ -0,0 +1,29 @@
+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;
+    ensureStageCluster(clusterName: string): Promise<boolean>;
+    private openStageDefinition;
+    openByName(name: string): Promise<void>;
+}
+export { ProcessApplicationPage };