@camunda/e2e-test-suite 0.0.1181 → 0.0.1183

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

@@ -31,7 +31,7 @@ declare class AppsPage {
     openOperateWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
     clickTasklist(clusterName: string): Promise<void>;
     openTasklistWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
-    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number, totalTimeout?: number): Promise<void>;
     clickAdmin(clusterName: string): Promise<void>;
     private doClickClusterInOperate;
     private doClickClusterInTasklist;

package/dist/pages/8.10/AppsPage.js

@@ -352,20 +352,37 @@ class AppsPage {
     // instead. Every other 8.10 spec already asserts `optimizeBanner` right
     // after `clickOptimize` for exactly this reason; only the smoke flow did
     // not.
-    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3) {
+    // `totalTimeout` is what makes the stated budget true. Retrying on a thrown
+    // hand-off (rather than escaping on the first throw) is correct, but it also
+    // multiplies the cost: a worst-case attempt here is clickCamundaApps (~188s
+    // when it has to hunt for a trigger) + clickOptimize (~456s across its own
+    // three retries) + the banner wait, so four attempts could reach ~43 min and
+    // blow the 36-minute test.slow() budget of the specs that call this. Checked
+    // between attempts, so the real ceiling is the deadline plus at most one
+    // attempt -- bounded, which "N x timeout" arithmetic alone never was.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3, totalTimeout = 600000) {
+        const start = Date.now();
         for (let attempt = 0; attempt < maxRetries; attempt++) {
-            await this.clickCamundaApps();
-            await this.clickOptimize(clusterName);
             try {
+                // Inside the try, not before it: `clickOptimize` throws after its own
+                // retries, and `clickCamundaApps` can throw on a click timeout. With
+                // those calls outside, the first such throw escaped this helper before
+                // it ever reached the `page.goto('/')` below -- so in exactly the dead
+                // page case this wrapper exists for, the recovery was skipped and the
+                // remaining attempts never ran.
+                await this.clickCamundaApps();
+                await this.clickOptimize(clusterName);
                 await (0, test_1.expect)(banner).toBeVisible({ timeout });
                 return;
             }
             catch (error) {
-                if (attempt === maxRetries - 1) {
+                const elapsed = Date.now() - start;
+                if (attempt === maxRetries - 1 || elapsed >= totalTimeout) {
                     throw error;
                 }
-                console.warn(`Optimize banner not visible on attempt ${attempt + 1}; ` +
-                    're-entering through the apps menu.');
+                console.warn(`Optimize hand-off failed on attempt ${attempt + 1} ` +
+                    `(${Math.round(elapsed / 1000)}s elapsed); re-entering through ` +
+                    `the apps menu. ${error}`);
                 await this.page.goto('/', { waitUntil: 'domcontentloaded' });
             }
         }

package/dist/pages/8.10/ClusterPage.js

@@ -462,37 +462,69 @@ class ClusterPage {
             exact: true,
         });
         const start = Date.now();
-        const maxRetries = 5;
+        // The loop is bounded by `totalTimeout` alone; it used to also stop at a
+        // hardcoded `maxRetries = 5`. What that cap changed is the *reload* rate,
+        // not the budget: with `visibilityTimeout` at 120s (what
+        // createClusterIfNotExists passes) five attempts of ~123s each already
+        // consumed the full 600s, so the old loop was not giving budget back.
+        //
+        // What it did do is reload the cluster list only 5 times across those 600s.
+        // `pollTimeout` caps how long any single `waitFor` blocks, which raises that
+        // to ~33 reloads for the same wall clock. That matters because the Healthy
+        // badge is only re-read after a reload -- a `waitFor` sitting on an
+        // already-rendered page cannot observe a status that changed server-side,
+        // so the effective polling resolution is the reload interval (~123s before,
+        // ~18s now), not the `waitFor` timeout.
+        //
+        // Worth knowing if you touch this: if the cluster list ever starts
+        // live-updating its status without a reload, this change stops buying
+        // anything, because then the old loop's long `waitFor` would already notice
+        // the transition the moment it happened.
+        const pollTimeout = Math.min(visibilityTimeout, 15000);
         let attempt = 0;
-        let unhealthyConsecutive = 0;
+        // Unhealthy is confirmed by how long it persists, not by a poll count: a
+        // cluster mid-provisioning can flash through Unhealthy during the
+        // Unhealthy -> Creating -> Healthy transition. The old "2 consecutive
+        // polls" gate was poll-rate dependent -- at a `visibilityTimeout`-long
+        // interval it meant roughly 2 x visibilityTimeout of Unhealthy -- so now
+        // that we poll every 15s it has to be expressed as elapsed time, or the
+        // tolerance silently shrinks to 30s.
+        //
+        // It is derived from the caller's `visibilityTimeout` rather than fixed, so
+        // each caller keeps the tolerance it had: createClusterIfNotExists (120s)
+        // gets 4 minutes, and console-user-flows' cluster-creation check (300s,
+        // with a 25-minute total budget) keeps its ~10 minutes instead of being cut
+        // to 2. The floor matters for callers that pass a small visibilityTimeout.
+        const unhealthyConfirmMs = Math.max(2 * visibilityTimeout, 120000);
+        let unhealthySince = null;
         let lastErr;
-        while (Date.now() - start < totalTimeout && attempt < maxRetries) {
+        while (Date.now() - start < totalTimeout) {
             attempt++;
             try {
                 await this.page.reload();
                 await (0, test_1.expect)(this.clusterRow(name)).toBeVisible({ timeout: 10000 });
-                // Only treat Unhealthy as terminal if it persists across two
-                // consecutive polling attempts. A cluster mid-provisioning can flash
-                // through Unhealthy briefly during the Unhealthy → Creating → Healthy
-                // transition and we don't want a single transient reading to abort
-                // the whole helper — earlier versions gated only on `attempt > 1`
-                // which still false-positived when the transient Unhealthy showed up
-                // on attempt 2.
+                // Only treat Unhealthy as terminal once it has persisted for
+                // `unhealthyConfirmMs`. A cluster mid-provisioning can flash through
+                // Unhealthy briefly during the Unhealthy → Creating → Healthy
+                // transition and we don't want a transient reading to abort the whole
+                // helper — earlier versions gated on `attempt > 1`, then on two
+                // consecutive polls, both of which are poll-rate dependent.
                 const isUnhealthy = await unhealthy
                     .isVisible({ timeout: 2000 })
                     .catch(() => false);
                 if (isUnhealthy) {
-                    unhealthyConsecutive++;
+                    unhealthySince ??= Date.now();
+                    const unhealthyFor = Date.now() - unhealthySince;
+                    if (unhealthyFor >= unhealthyConfirmMs) {
+                        throw new Error(`Cluster "${name}" reached terminal Unhealthy state after ${Math.round((Date.now() - start) / 1000)}s (Unhealthy continuously for ${Math.round(unhealthyFor / 1000)}s); aborting Healthy poll.`);
+                    }
                 }
                 else {
-                    unhealthyConsecutive = 0;
-                }
-                if (unhealthyConsecutive >= 2) {
-                    throw new Error(`Cluster "${name}" reached terminal Unhealthy state after ${Math.round((Date.now() - start) / 1000)}s (${unhealthyConsecutive} consecutive Unhealthy polls); aborting Healthy poll.`);
+                    unhealthySince = null;
                 }
                 await this.clusterHealthiness(name).waitFor({
                     state: 'visible',
-                    timeout: visibilityTimeout,
+                    timeout: pollTimeout,
                 });
                 console.log('Cluster is healthy:', name);
                 return;
@@ -503,11 +535,17 @@ class ClusterPage {
                     throw err;
                 }
                 lastErr = err;
-                console.log(`Attempt ${attempt} failed for cluster "${name}" Healthy check, retrying...`, err instanceof Error ? err.message : err);
+                // Only log every 8th attempt now that we poll every 15s: the previous
+                // one-line-per-attempt output was 4 lines, it would otherwise be ~40
+                // identical lines per cluster and this suite creates several.
+                if (attempt === 1 || attempt % 8 === 0) {
+                    console.log(`Attempt ${attempt} failed for cluster "${name}" Healthy check ` +
+                        `(${Math.round((Date.now() - start) / 1000)}s elapsed), retrying...`, err instanceof Error ? err.message : err);
+                }
                 await this.page.waitForTimeout(500);
             }
         }
-        throw new Error(`Cluster "${name}" did not become Healthy after ${attempt} attempts. Last error: ${lastErr instanceof Error ? lastErr.message : lastErr}`);
+        throw new Error(`Cluster "${name}" did not become Healthy within ${Math.round(totalTimeout / 1000)}s (${attempt} polls). Last error: ${lastErr instanceof Error ? lastErr.message : lastErr}`);
     }
     async clickAlphaTab() {
         await this.alphaTab.click();

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

@@ -29,6 +29,8 @@ declare class ModelerHomePage {
     readonly createIdpApplicationButton: Locator;
     readonly dialog: Locator;
     readonly closeButton: Locator;
+    readonly blockingDialog: Locator;
+    readonly blockingDialogDismiss: Locator;
     readonly optionsButton: Locator;
     readonly formNameBreadcrumb: (formName: string) => Locator;
     readonly breadcrumbProjectMenu: Locator;
@@ -68,6 +70,7 @@ declare class ModelerHomePage {
     clickManageButton(retries?: number): Promise<void>;
     clickUploadFilesButton(): Promise<void>;
     dismissBlockingDialog(): Promise<void>;
+    private dismissUncataloguedDialog;
     clickMessageBanner(): Promise<void>;
     selectCluster(clusterName: string): Promise<void>;
     clickIdpApplicationTemplateOption(): Promise<void>;

package/dist/pages/8.10/ModelerHomePage.js

@@ -47,6 +47,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     optionsButton;
     formNameBreadcrumb;
     breadcrumbProjectMenu;
@@ -132,6 +134,25 @@ class ModelerHomePage {
         this.closeButton = page
             .locator('button:visible', { hasText: /^Got it/ })
             .first();
+        // Not every modal hub stacks over the projects list carries a "Got it"
+        // control. When one does not, the `closeButton` probe above finds nothing
+        // and `dismissBlockingDialog` returns having dismissed *nothing*, so the
+        // caller clicks straight into an overlay that is still there. Run
+        // 35102164337 lost 9 tests that way: the project link resolved "visible,
+        // enabled and stable", then the click retried 116 times against a modal
+        // reported as intercepting pointer events.
+        //
+        // Anchored on the visible dialog so an announcement nobody has catalogued
+        // yet is still cleared, rather than on one more label. `:visible` matters —
+        // the Modeler home page keeps several `role="dialog"` containers mounted
+        // and hidden, which is why the label-first lookup above exists at all.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').first();
+        // Only unambiguous dismissals. Deliberately NOT "Cancel": that is a form
+        // action on the dialogs specs open on purpose (cluster select, deploy), and
+        // clicking it would break a working test rather than unblock a stuck one.
+        this.blockingDialogDismiss = this.blockingDialog
+            .getByRole('button', { name: /^(Got it|Close|Dismiss)/i })
+            .first();
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -585,17 +606,42 @@ class ModelerHomePage {
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
         for (let attempt = 0; attempt < 3; attempt++) {
-            const isOpen = await this.closeButton
-                .waitFor({ state: 'visible', timeout: 10000 })
-                .then(() => true)
-                .catch(() => false);
+            const isOpen = await this.becameVisible(this.closeButton, 10000);
+            // `break`, not `return`: a modal without a "Got it" control is exactly
+            // the case the generic pass below exists for, and returning here is what
+            // let it through.
             if (!isOpen)
-                return;
+                break;
             await this.closeButton.click({ timeout: 5000 }).catch(() => { });
             await this.closeButton
                 .waitFor({ state: 'hidden', timeout: 5000 })
                 .catch(() => false);
         }
+        await this.dismissUncataloguedDialog();
+    }
+    // Second pass for a modal the label-based probe above cannot see. Kept cheap
+    // because `dismissBlockingDialog` is called from a dozen places on the happy
+    // path: when nothing is open this costs one 2s probe, so it cannot turn into
+    // the kind of hidden budget the Optimize retry sizing did.
+    async dismissUncataloguedDialog() {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            if (!(await this.becameVisible(this.blockingDialog, 2000)))
+                return;
+            if (!(await this.becameVisible(this.blockingDialogDismiss, 2000))) {
+                // Nothing safe to click. Leave it rather than guess: pressing Escape
+                // blindly does not close a Carbon dialog (focus sits on the body after
+                // a load), and clicking an unrecognised footer button could confirm
+                // something. The caller's own assertion then reports the real blocker.
+                return;
+            }
+            await this.blockingDialogDismiss.click({ timeout: 5000 }).catch(() => { });
+            const closed = await this.blockingDialog
+                .waitFor({ state: 'hidden', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed)
+                return;
+        }
     }
     async clickMessageBanner() {
         try {

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

@@ -11,6 +11,7 @@ declare class ModelerCreatePage {
     readonly userTaskOption: Locator;
     readonly appendEndEventButton: Locator;
     readonly viewProcessInstanceLink: Locator;
+    readonly autosaveIndicator: Locator;
     readonly nameInput: Locator;
     readonly diagramBreadcrumb: Locator;
     readonly renameDiagramNameButton: Locator;
@@ -135,7 +136,8 @@ declare class ModelerCreatePage {
     runProcessInstance(clusterName: string, variables?: string, formVariables?: {
         [key: string]: string;
     }, textToVisible?: string): Promise<void>;
-    retryRunProcess(maxRetries?: number): Promise<void>;
+    retryRunProcess(clusterName: string, fillDialog?: () => Promise<void>, maxRetries?: number): Promise<void>;
+    private reopenDeployAndRunDialog;
     clickViewProcessInstanceLink(): Promise<void>;
     clickNameInput(): Promise<void>;
     fillNamedInput(name: string): Promise<void>;
@@ -197,6 +199,7 @@ declare class ModelerCreatePage {
     clickIdInput(): Promise<void>;
     fillIdInput(id: string): Promise<void>;
     setAndVerifyProcessId(processId: string): Promise<void>;
+    waitForAutosaveAfterEdits(timeout?: number): Promise<void>;
     fillStartFormName(name: string): Promise<void>;
     fillStartFormDate(date: string): Promise<void>;
     checkStartFormCheckbox(): Promise<void>;

package/dist/pages/8.7/ModelerCreatePage.js

@@ -17,6 +17,7 @@ class ModelerCreatePage {
     userTaskOption;
     appendEndEventButton;
     viewProcessInstanceLink;
+    autosaveIndicator;
     nameInput;
     diagramBreadcrumb;
     renameDiagramNameButton;
@@ -150,6 +151,7 @@ class ModelerCreatePage {
             name: 'View process instance',
         });
         this.viewProcessLink = page.getByText('view process in Operate');
+        this.autosaveIndicator = page.locator('[data-test="autosave"]');
         this.nameInput = page.getByLabel('Name', { exact: true });
         this.diagramBreadcrumb = page.locator('[data-test="breadcrumb-diagram"]');
         this.renameDiagramNameButton = page.getByText('Rename');
@@ -558,35 +560,39 @@ class ModelerCreatePage {
             await this.clickDeployAndRunMainButton();
             await this.selectCluster(clusterName, 120000);
         }
-        if (variables.length > 0) {
-            await (0, test_1.expect)(this.variableInput).toBeVisible({
-                timeout: 60000,
-            });
-            await this.clickVariableInput();
-            await this.fillVariableInput(variables);
-        }
-        if (Object.keys(formVariables).length > 0) {
-            if ('formName' in formVariables && formVariables['formName']) {
-                await this.fillStartFormName(formVariables['formName']);
-            }
-            if ('checkbox' in formVariables && formVariables['checkbox'] == 'true') {
-                await this.checkStartFormCheckbox();
+        const fillDialog = async () => {
+            if (variables.length > 0) {
+                await (0, test_1.expect)(this.variableInput).toBeVisible({
+                    timeout: 60000,
+                });
+                await this.clickVariableInput();
+                await this.fillVariableInput(variables);
             }
-            if ('startDate' in formVariables && formVariables['startDate']) {
-                await this.fillStartFormDate(formVariables['startDate']);
+            if (Object.keys(formVariables).length > 0) {
+                if ('formName' in formVariables && formVariables['formName']) {
+                    await this.fillStartFormName(formVariables['formName']);
+                }
+                if ('checkbox' in formVariables &&
+                    formVariables['checkbox'] == 'true') {
+                    await this.checkStartFormCheckbox();
+                }
+                if ('startDate' in formVariables && formVariables['startDate']) {
+                    await this.fillStartFormDate(formVariables['startDate']);
+                }
+                if ('startNumber' in formVariables && formVariables['startNumber']) {
+                    await this.fillStartFormNumber(formVariables['startNumber']);
+                }
             }
-            if ('startNumber' in formVariables && formVariables['startNumber']) {
-                await this.fillStartFormNumber(formVariables['startNumber']);
+            if (textToVisible.length > 0) {
+                await (0, test_1.expect)(this.dialog.getByText(textToVisible)).toBeVisible({
+                    timeout: 30000,
+                });
             }
-        }
-        if (textToVisible.length > 0) {
-            await (0, test_1.expect)(this.dialog.getByText(textToVisible)).toBeVisible({
-                timeout: 30000,
-            });
-        }
-        await this.retryRunProcess();
+        };
+        await fillDialog();
+        await this.retryRunProcess(clusterName, fillDialog);
     }
-    async retryRunProcess(maxRetries = 3) {
+    async retryRunProcess(clusterName, fillDialog, maxRetries = 3) {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
                 await this.clickDeployAndRunSubButton();
@@ -596,16 +602,38 @@ class ModelerCreatePage {
                 return;
             }
             catch (error) {
-                if (attempt < maxRetries - 1) {
-                    console.warn(`Attempt ${attempt + 1} failed for running process. Retrying...`);
-                }
-                else {
+                if (attempt === maxRetries - 1) {
                     console.error(error);
                     throw new Error(`Running process failed after ${maxRetries} attempts`);
                 }
+                console.warn(`Attempt ${attempt + 1} failed for running process. Retrying...`);
+                // The dialog closes on a successful deploy and switches to an error
+                // screen when the backend rejects one, so in both cases the sub button
+                // is gone and re-clicking it can only time out -- which is how a
+                // single rejected deploy burned all three attempts in the nightly.
+                // Drive the deploy from the top again whenever the button is no longer
+                // on offer, so the next attempt is a real one.
+                const stillOffered = await this.deployAndRunSubButton
+                    .isVisible()
+                    .catch(() => false);
+                if (!stillOffered) {
+                    await this.reopenDeployAndRunDialog(clusterName);
+                    await fillDialog?.();
+                }
             }
         }
     }
+    async reopenDeployAndRunDialog(clusterName) {
+        const closeButton = this.dialog
+            .getByRole('button', { name: 'Close', exact: true })
+            .first();
+        if (await closeButton.isVisible().catch(() => false)) {
+            await closeButton.click({ timeout: 30000 });
+        }
+        await (0, test_1.expect)(this.dialog).toBeHidden({ timeout: 30000 });
+        await this.clickDeployAndRunMainButton();
+        await this.selectCluster(clusterName, 120000);
+    }
     async clickViewProcessInstanceLink() {
         await this.viewProcessInstanceLink.click({ timeout: 180000 });
     }
@@ -998,6 +1026,33 @@ class ModelerCreatePage {
         }
         await (0, test_1.expect)(this.processIdInput).toHaveValue(processId, { timeout: 10000 });
     }
+    // Web Modeler persists editor edits on a debounced autosave, and
+    // "Deploy & run" deploys what the server holds for the process application,
+    // not what is on screen. The nightly trace shows the PATCH that stored the
+    // renamed process id being acknowledged 61ms before the deploy POST, so the
+    // still-stale file was deployed and the follow-up instance creation was
+    // rejected with "Command 'CREATE' rejected with code 'NOT_FOUND': Expected
+    // to find process definition with process ID '<id>', but none found". The
+    // fixed ten-second wait this replaces raced that debounce, which is itself
+    // about ten seconds. Wait for the modeler's own autosave indicator to report
+    // a save that started after the last edit instead.
+    async waitForAutosaveAfterEdits(timeout = 60000) {
+        const readIndicator = () => this.autosaveIndicator.textContent({ timeout: 10000 }).catch(() => null);
+        const beforeEdits = await readIndicator();
+        try {
+            await test_1.expect
+                .poll(readIndicator, { timeout, intervals: [1000] })
+                .not.toBe(beforeEdits);
+        }
+        catch {
+            // The window between the last edit and the baseline read is a few
+            // milliseconds, so the only way the label does not move within a wait
+            // this much longer than the debounce is that the save had already landed
+            // when the baseline was taken -- the edits are persisted either way.
+            console.warn('Autosave indicator did not change after the diagram edits; ' +
+                'treating the edits as already persisted.');
+        }
+    }
     async fillStartFormName(name) {
         await this.payloadNameInput.fill(name);
     }

package/dist/pages/8.7/UtilitiesPage.js

@@ -302,7 +302,10 @@ async function modelDiagramFromFile(page, modelerHomePage, modelerCreatePage, pr
             await modelerCreatePage.clickCanvas();
         }
     }
-    await (0, sleep_1.sleep)(10000);
+    // "Deploy & run" deploys the copy of the diagram the server holds, so the
+    // rename above has to be persisted first. A fixed ten-second sleep raced the
+    // modeler's own ten-second autosave debounce; wait for the save instead.
+    await modelerCreatePage.waitForAutosaveAfterEdits();
 }
 exports.modelDiagramFromFile = modelDiagramFromFile;
 async function disableRBA(clusterName, homePage, clusterPage, clusterDetailsPage, appsPage) {

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

@@ -44,6 +44,7 @@ declare class AppsPage {
     private doClickClusterInOptimize;
     clickOperate(clusterName: string): Promise<void>;
     clickOptimize(clusterName: string): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number, totalTimeout?: number): Promise<void>;
     clickCamundaApps(maxRetries?: number): Promise<void>;
     private dismissBlockingModal;
     clickConsoleLink(): Promise<void>;

package/dist/pages/8.8/AppsPage.js

@@ -322,6 +322,56 @@ class AppsPage {
         }
         throw new Error(`Failed to click the optimize link after ${maxRetries} attempts.`);
     }
+    // `clickOptimize` returns once it has clicked, not once Optimize has
+    // rendered, so a hand-off that lands somewhere else (an SSO bounce to
+    // `/login`, or `/login?error`) is reported as success. Retrying the click
+    // from there does not help: on a dead page none of the app-switcher buttons
+    // is visible, so `clickCamundaApps` below burns its three rounds probing and
+    // then throws `Failed to open app switcher after 3 attempts` -- and a caller
+    // that just re-clicks re-probes the same page until its budget runs out.
+    // Going back to `/` first is the only thing that recovers, which is what this
+    // wrapper adds: the throw is caught below and turned into a re-entry.
+    //
+    // Note this is where 8.8 differs from 8.9/8.10, whose `clickCamundaApps`
+    // falls out of the same loop and returns *without* throwing. The recovery
+    // this wrapper provides is needed either way, but do not carry that
+    // description back here -- on 8.8 the failure arrives as an exception.
+    // `totalTimeout` is what makes the stated budget true. Retrying on a thrown
+    // hand-off (rather than escaping on the first throw) is correct, but it also
+    // multiplies the cost: a worst-case attempt here is clickCamundaApps (~188s
+    // when it has to hunt for a trigger) + clickOptimize (~456s across its own
+    // three retries) + the banner wait, so four attempts could reach ~43 min and
+    // blow the 36-minute test.slow() budget of the specs that call this. Checked
+    // between attempts, so the real ceiling is the deadline plus at most one
+    // attempt -- bounded, which "N x timeout" arithmetic alone never was.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3, totalTimeout = 600000) {
+        const start = Date.now();
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Inside the try, not before it: both of these throw -- `clickOptimize`
+                // after its own retries, `clickCamundaApps` once its probes are
+                // exhausted or a click times out. With those calls outside, the first
+                // such throw escaped this helper before it ever reached the
+                // `page.goto('/')` below -- so in exactly the dead page case this
+                // wrapper exists for, the recovery was skipped and the remaining
+                // attempts never ran.
+                await this.clickCamundaApps();
+                await this.clickOptimize(clusterName);
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                const elapsed = Date.now() - start;
+                if (attempt === maxRetries - 1 || elapsed >= totalTimeout) {
+                    throw error;
+                }
+                console.warn(`Optimize hand-off failed on attempt ${attempt + 1} ` +
+                    `(${Math.round(elapsed / 1000)}s elapsed); re-entering through ` +
+                    `the apps menu. ${error}`);
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
     async clickCamundaApps(maxRetries = 3) {
         await (0, sleep_1.sleep)(2000);
         const appButtons = [

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

@@ -29,12 +29,15 @@ declare class ModelerHomePage {
     readonly createIdpApplicationButton: Locator;
     readonly dialog: Locator;
     readonly closeButton: Locator;
+    readonly blockingDialog: Locator;
+    readonly blockingDialogDismiss: Locator;
     readonly cancelButton: Locator;
     readonly optionsButton: Locator;
     readonly formNameBreadcrumb: (formName: string) => Locator;
     readonly buttonSkipCustomization: Locator;
     constructor(page: Page);
     dismissBlockingDialog(): Promise<void>;
+    private dismissUncataloguedDialog;
     dismissOverlays(): Promise<void>;
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;

package/dist/pages/8.8/ModelerHomePage.js

@@ -49,6 +49,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     cancelButton;
     optionsButton;
     formNameBreadcrumb;
@@ -127,6 +129,37 @@ class ModelerHomePage {
         this.closeButton = page
             .locator('button:visible', { hasText: /^Got it/ })
             .first();
+        // Not every modal hub stacks over the projects list carries a "Got it"
+        // control. When one does not, the `closeButton` probe finds nothing and
+        // `dismissBlockingDialog` returns having dismissed *nothing*, so the caller
+        // clicks straight into an overlay that is still there. Observed on this
+        // version in run 35102270880 (chromium-v2), which lost `Public Start Form`,
+        // `RBA On User Flow - No User Permission`, `- Permission for One Process`
+        // and `Form.js Integration with User Task and AI Generated Form` to exactly
+        // that.
+        //
+        // Anchored on the visible dialog so an announcement nobody has catalogued
+        // yet is still cleared, rather than on one more label. `:visible` matters --
+        // the Modeler home page keeps several `role="dialog"` containers mounted
+        // and hidden, which is why the label-first lookup above exists at all.
+        //
+        // `.last()`, not `.first()`: Carbon stacks modals in DOM order, so the last
+        // one is the topmost, and it is the topmost backdrop that intercepts the
+        // pointer events this whole helper exists to clear. Targeting `.first()`
+        // would click the dismiss button of a *covered* dialog and leave the
+        // blocker up -- reproducing the interception rather than fixing it. Same
+        // reasoning, and the same conclusion, as `HomePage.closeInformationDialog`.
+        // The nth here is deliberate rather than the accidental kind CLAUDE.md
+        // warns about: picking the top of a page-wide stack is the whole point, so
+        // there is no parent to scope to, and `:visible` already excludes the
+        // mounted-but-hidden containers.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').last();
+        // Only unambiguous dismissals. Deliberately NOT "Cancel": that is a form
+        // action on the dialogs specs open on purpose (cluster select, deploy), and
+        // clicking it would break a working test rather than unblock a stuck one.
+        this.blockingDialogDismiss = this.blockingDialog
+            .getByRole('button', { name: /^(Got it|Close|Dismiss)/i })
+            .first();
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -151,17 +184,60 @@ class ModelerHomePage {
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
         for (let attempt = 0; attempt < 3; attempt++) {
-            const isOpen = await this.closeButton
-                .waitFor({ state: 'visible', timeout: 10000 })
-                .then(() => true)
-                .catch(() => false);
+            const isOpen = await this.becameVisible(this.closeButton, 10000);
+            // `break`, not `return`: a modal without a "Got it" control is exactly
+            // the case the generic pass below exists for, and returning here is what
+            // let it through.
             if (!isOpen)
-                return;
+                break;
             await this.closeButton.click({ timeout: 5000 }).catch(() => { });
             await this.closeButton
                 .waitFor({ state: 'hidden', timeout: 5000 })
                 .catch(() => false);
         }
+        await this.dismissUncataloguedDialog();
+    }
+    // Second pass for a modal the label-based probe above cannot see. Kept cheap
+    // because `dismissBlockingDialog` is called from a dozen places on the happy
+    // path: when nothing is open this costs one 2s probe.
+    async dismissUncataloguedDialog() {
+        // Peel the stack from the top, re-resolving `blockingDialog` each round:
+        // closing the topmost uncovers the next, and `.last()` then points at it.
+        // Three rounds covers the two hub is known to stack (What's New plus the
+        // migration notice) and still terminates on the probe below when the stack
+        // is clear; it is not a budget to burn, so a clear page costs one 2s probe.
+        let lastClickError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            if (!(await this.becameVisible(this.blockingDialog, 2000)))
+                return;
+            if (!(await this.becameVisible(this.blockingDialogDismiss, 2000))) {
+                // Nothing safe to click. Leave it rather than guess: pressing Escape
+                // blindly does not close a Carbon dialog (focus sits on the body after
+                // a load), and clicking an unrecognised footer button could confirm
+                // something. The caller's own assertion then reports the real blocker.
+                return;
+            }
+            try {
+                await this.blockingDialogDismiss.click({ timeout: 5000 });
+                lastClickError = undefined;
+            }
+            catch (error) {
+                // Held, not swallowed. A click can fail here for reasons the next round
+                // clears on its own -- a backdrop fading in over the button, a dialog
+                // re-rendering mid-animation -- so give it that round. If a dialog is
+                // still up once the rounds are spent, this error is what gets reported.
+                lastClickError = error;
+            }
+        }
+        // Still blocked after three rounds. Say so here rather than letting the
+        // caller click into the overlay and report "intercepts pointer events" from
+        // a line that has nothing to do with the dialog.
+        if (await this.blockingDialog.isVisible().catch(() => false)) {
+            throw new Error('A blocking Modeler dialog is still visible after 3 dismiss attempts.' +
+                (lastClickError === undefined
+                    ? ' Its dismiss control was clicked without closing it.'
+                    : ` Last dismiss click failed: ${lastClickError}`));
+        }
     }
     async dismissOverlays() {
         // Before the generic pass: clickMessageBanner and the loop below resolve

package/dist/pages/8.9/AppsPage.d.ts

@@ -29,6 +29,7 @@ declare class AppsPage {
     private doClickClusterInOptimize;
     clickOperate(clusterName: string): Promise<void>;
     clickOptimize(clusterName: string): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number, totalTimeout?: number): Promise<void>;
     clickCamundaApps(maxRetries?: number): Promise<void>;
     private dismissBlockingOverlays;
     clickConsoleLink(): Promise<void>;

package/dist/pages/8.9/AppsPage.js

@@ -285,6 +285,49 @@ class AppsPage {
         }
         throw new Error(`Failed to click the optimize link after ${maxRetries} attempts.`);
     }
+    // `clickOptimize` returns once it has clicked, not once Optimize has
+    // rendered, so a hand-off that lands somewhere else (an SSO bounce to
+    // `/login`, or `/login?error`) is reported as success. Retrying the click
+    // from there does not help: `clickCamundaApps` below exits its loop without
+    // throwing when none of the app-switcher buttons is visible, which is exactly
+    // the state a dead page is in, so a caller that re-clicks just re-probes the
+    // same page until its budget runs out. Going back to `/` first is the only
+    // thing that recovers, which is what this wrapper adds.
+    // `totalTimeout` is what makes the stated budget true. Retrying on a thrown
+    // hand-off (rather than escaping on the first throw) is correct, but it also
+    // multiplies the cost: a worst-case attempt here is clickCamundaApps (~188s
+    // when it has to hunt for a trigger) + clickOptimize (~456s across its own
+    // three retries) + the banner wait, so four attempts could reach ~51 min and
+    // blow the 36-minute test.slow() budget of the specs that call this. Checked
+    // between attempts, so the real ceiling is the deadline plus at most one
+    // attempt -- bounded, which "N x timeout" arithmetic alone never was.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3, totalTimeout = 600000) {
+        const start = Date.now();
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Inside the try, not before it: `clickOptimize` throws after its own
+                // retries, and `clickCamundaApps` can throw on a click timeout. With
+                // those calls outside, the first such throw escaped this helper before
+                // it ever reached the `page.goto('/')` below -- so in exactly the dead
+                // page case this wrapper exists for, the recovery was skipped and the
+                // remaining attempts never ran.
+                await this.clickCamundaApps();
+                await this.clickOptimize(clusterName);
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                const elapsed = Date.now() - start;
+                if (attempt === maxRetries - 1 || elapsed >= totalTimeout) {
+                    throw error;
+                }
+                console.warn(`Optimize hand-off failed on attempt ${attempt + 1} ` +
+                    `(${Math.round(elapsed / 1000)}s elapsed); re-entering through ` +
+                    `the apps menu. ${error}`);
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
     async clickCamundaApps(maxRetries = 3) {
         await (0, sleep_1.sleep)(2000);
         await this.dismissBlockingOverlays();

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

@@ -28,10 +28,13 @@ declare class ModelerHomePage {
     readonly createIdpApplicationButton: Locator;
     readonly dialog: Locator;
     readonly closeButton: Locator;
+    readonly blockingDialog: Locator;
+    readonly blockingDialogDismiss: Locator;
     readonly optionsButton: Locator;
     readonly formNameBreadcrumb: (formName: string) => Locator;
     constructor(page: Page);
     dismissBlockingDialog(): Promise<void>;
+    private dismissUncataloguedDialog;
     dismissOverlays(): Promise<void>;
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;

package/dist/pages/8.9/ModelerHomePage.js

@@ -45,6 +45,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     optionsButton;
     formNameBreadcrumb;
     constructor(page) {
@@ -122,6 +124,26 @@ class ModelerHomePage {
         this.closeButton = page
             .locator('button:visible', { hasText: /^Got it/ })
             .first();
+        // Not every modal hub stacks over the projects list carries a "Got it"
+        // control. When one does not, the `closeButton` probe finds nothing and
+        // `dismissBlockingDialog` returns having dismissed *nothing*, so the caller
+        // clicks straight into an overlay that is still there. Observed on this
+        // version in run 35102229469, which lost `RBA On User Flow - Permission for
+        // All Processes with Full Permissions` and `- Permission for Selected
+        // Processes Only` to exactly that, with 9 "New project" click failures in
+        // the log.
+        //
+        // Anchored on the visible dialog so an announcement nobody has catalogued
+        // yet is still cleared, rather than on one more label. `:visible` matters --
+        // the Modeler home page keeps several `role="dialog"` containers mounted
+        // and hidden, which is why the label-first lookup above exists at all.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').first();
+        // Only unambiguous dismissals. Deliberately NOT "Cancel": that is a form
+        // action on the dialogs specs open on purpose (cluster select, deploy), and
+        // clicking it would break a working test rather than unblock a stuck one.
+        this.blockingDialogDismiss = this.blockingDialog
+            .getByRole('button', { name: /^(Got it|Close|Dismiss)/i })
+            .first();
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -143,17 +165,41 @@ class ModelerHomePage {
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
         for (let attempt = 0; attempt < 3; attempt++) {
-            const isOpen = await this.closeButton
-                .waitFor({ state: 'visible', timeout: 10000 })
-                .then(() => true)
-                .catch(() => false);
+            const isOpen = await this.becameVisible(this.closeButton, 10000);
+            // `break`, not `return`: a modal without a "Got it" control is exactly
+            // the case the generic pass below exists for, and returning here is what
+            // let it through.
             if (!isOpen)
-                return;
+                break;
             await this.closeButton.click({ timeout: 5000 }).catch(() => { });
             await this.closeButton
                 .waitFor({ state: 'hidden', timeout: 5000 })
                 .catch(() => false);
         }
+        await this.dismissUncataloguedDialog();
+    }
+    // Second pass for a modal the label-based probe above cannot see. Kept cheap
+    // because `dismissBlockingDialog` is called from a dozen places on the happy
+    // path: when nothing is open this costs one 2s probe.
+    async dismissUncataloguedDialog() {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            if (!(await this.becameVisible(this.blockingDialog, 2000)))
+                return;
+            if (!(await this.becameVisible(this.blockingDialogDismiss, 2000))) {
+                // Nothing safe to click. Leave it rather than guess: pressing Escape
+                // blindly does not close a Carbon dialog (focus sits on the body after
+                // a load), and clicking an unrecognised footer button could confirm
+                // something. The caller's own assertion then reports the real blocker.
+                return;
+            }
+            await this.blockingDialogDismiss.click({ timeout: 5000 }).catch(() => { });
+            const closed = await this.blockingDialog
+                .waitFor({ state: 'hidden', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed)
+                return;
+        }
     }
     async dismissOverlays() {
         // Before the generic pass: the loop below closes whichever overlay it finds

package/dist/pages/SM-8.10/Authorization.d.ts

@@ -10,6 +10,8 @@ declare class Authorization {
     protected readonly createAuthorizationOwnerOption: (name: string) => Locator;
     protected readonly createAuthorizationOwnerSearchInput: Locator;
     protected readonly createAuthorizationOwnerSearchOption: (name: string) => Locator;
+    protected readonly createAuthorizationOwnerCommandInput: Locator;
+    protected readonly createAuthorizationOwnerCommandOptions: Locator;
     protected readonly createAuthorizationResourceTypeDropdown: Locator;
     protected readonly createAuthorizationResourceTypeOption: (name: string) => Locator;
     protected readonly createAuthorizationResourceIdField: Locator;

package/dist/pages/SM-8.10/Authorization.js

@@ -16,6 +16,8 @@ class Authorization {
     createAuthorizationOwnerOption;
     createAuthorizationOwnerSearchInput;
     createAuthorizationOwnerSearchOption;
+    createAuthorizationOwnerCommandInput;
+    createAuthorizationOwnerCommandOptions;
     createAuthorizationResourceTypeDropdown;
     createAuthorizationResourceTypeOption;
     createAuthorizationResourceIdField;
@@ -72,6 +74,18 @@ class Authorization {
             .locator('.cds--list-box__menu-item, [role="option"]')
             .filter({ hasText: name })
             .first();
+        // In the design-system build the closed Owner control is a combobox-role
+        // trigger that paints "Search by owner ID" as static text (no placeholder
+        // attribute), and the cmdk search box plus its result listbox only mount
+        // in a popover once the trigger is opened. That popover is portalled out
+        // of the dialog, and while it is open Radix marks the dialog aria-hidden,
+        // so both must be queried from the page root.
+        this.createAuthorizationOwnerCommandInput = this.page
+            .locator('[data-slot="command-input"]')
+            .first();
+        this.createAuthorizationOwnerCommandOptions = this.page
+            .getByRole('listbox')
+            .getByRole('option');
         this.createAuthorizationResourceTypeDropdown =
             this.createAuthorizationModal.getByRole('combobox', {
                 name: 'Resource type',
@@ -133,7 +147,10 @@ class Authorization {
             .click({ timeout: Math.min(timeout, 30000) });
     }
     // Released 8.10 alpha images still render the Carbon combobox that lists
-    // every owner, so accept whichever owner field this build shows.
+    // every owner, so accept whichever of the three owner fields this build
+    // shows: the Carbon search dropdown, the Carbon combobox that lists every
+    // owner inline, or the design-system combobox whose cmdk popover only loads
+    // results once the owner ID is typed.
     async selectAuthorizationOwner(ownerId) {
         await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput.or(this.createAuthorizationOwnerComboBox)).toBeVisible({ timeout: 30000 });
         if (await this.createAuthorizationOwnerSearchInput.isVisible()) {
@@ -151,10 +168,29 @@ class Authorization {
             return;
         }
         await this.createAuthorizationOwnerComboBox.click();
-        await (0, test_1.expect)(this.createAuthorizationOwnerOption(ownerId)).toBeVisible({
+        const commandInput = this.createAuthorizationOwnerCommandInput;
+        const inlineOwnerOption = this.createAuthorizationOwnerOption(ownerId);
+        await (0, test_1.expect)(commandInput.or(inlineOwnerOption).first()).toBeVisible({
+            timeout: 30000,
+        });
+        if (await commandInput.isVisible()) {
+            await commandInput.fill(ownerId);
+            // The result list is served by the API and debounced, and each option is
+            // labelled "<owner id> — <name>" rather than the bare ID, so narrow the
+            // search to the single row this unique owner ID resolves to instead of
+            // matching on the label text.
+            const ownerOptions = this.createAuthorizationOwnerCommandOptions;
+            await (0, test_1.expect)(ownerOptions).toHaveCount(1, { timeout: 60000 });
+            await ownerOptions.first().click({ timeout: 30000, force: true });
+            // Committing the choice closes the popover, which is what hands the
+            // dialog back to the accessibility tree for the fields that follow.
+            await (0, test_1.expect)(commandInput).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await (0, test_1.expect)(inlineOwnerOption).toBeVisible({
             timeout: 30000,
         });
-        await this.createAuthorizationOwnerOption(ownerId).click({
+        await inlineOwnerOption.click({
             timeout: 30000,
         });
     }

package/dist/pages/SM-8.10/ModelerHomePage.js

@@ -24,7 +24,7 @@ class ModelerHomePage {
     // Flag-on (workspaces-enabled) state. Under camunda-hub#27903 the c8-e2e
     // "project folder" maps to a Workspace and the "process application" to a
     // Project: `/` redirects to the `/workspaces` overview, a Workspace holds a
-    // projects listing at `/workspace/{wsId}/projects`, and a Project (the
+    // projects listing at `/workspaces/{wsId}/projects`, and a Project (the
     // resource container) lives one level deeper. These remember the shared
     // Workspace's projects-listing URL and the overview URL so returns don't
     // re-walk the hierarchy from the root each time.
@@ -324,7 +324,7 @@ class ModelerHomePage {
         await this.ensureWorkspaceOpen();
     }
     // Ensures the shared "Cross Component Test Project" Workspace is open and the
-    // browser is on its projects listing (`/workspace/{wsId}/projects`), where the
+    // browser is on its projects listing (`/workspaces/{wsId}/projects`), where the
     // per-test Project is later created. Retries the whole navigation+login on a
     // transient web-modeler 500 rather than a bare reload, which would drop the
     // authenticated SPA state and land on the empty login form.
@@ -440,7 +440,7 @@ class ModelerHomePage {
             ? openButton.first()
             : this.crossComponentProjectFolder;
         await target.click({ timeout: 60000 });
-        await this.page.waitForURL(/\/workspace\/[^/]+\/projects/, {
+        await this.page.waitForURL(/\/workspaces\/[^/]+\/projects/, {
             timeout: 120000,
         });
         this.workspaceProjectsUrl = this.page.url();

package/dist/pages/SM-8.10/OCTenantPage.js

@@ -303,6 +303,17 @@ class OCTenantPage {
         }
     }
     async fillRoleIdSearchBox(roleId, roleIdentifier) {
+        // The option row renders the ID followed by the name, so the name is the
+        // tail of `roleIdentifier`.
+        const roleName = roleIdentifier.startsWith(roleId)
+            ? roleIdentifier.slice(roleId.length)
+            : '';
+        // The design-system row separates the two parts with an em dash
+        // ('connectors — Connectors') while the legacy Carbon row concatenates
+        // them ('connectorsConnectors'), so match both with an optional
+        // dash/whitespace run between the ID and the name.
+        const escapeForRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const rolePattern = new RegExp(`${escapeForRegExp(roleId)}[-\\s\\u2010-\\u2015]*${escapeForRegExp(roleName)}`);
         // The design-system shell portals the matches into a listbox rendered as
         // a sibling of the dialog, so they cannot be scoped to the modal. The
         // legacy Carbon list stays inside it and must remain scoped: the tenant's
@@ -311,19 +322,15 @@ class OCTenantPage {
         // the modal overlay.
         const result = this.page
             .getByRole('option')
-            .filter({ hasText: roleIdentifier })
-            .or(this.assignRoleModal.getByText(roleIdentifier))
+            .filter({ hasText: rolePattern })
+            .or(this.assignRoleModal.getByText(rolePattern))
             .first();
         // The dropdown no longer filters client-side: it queries
         // `/v2/roles/search` with `name: {$like: '*<typed>*'}`, which is
         // case-sensitive, so the role ID ('connectors') never matches the default
-        // role's name ('Connectors'). The option row renders the ID followed by
-        // the name, so the name is the tail of `roleIdentifier`: search the ID
-        // first for the shells that still match on it, then fall back to the name.
+        // role's name ('Connectors'): search the ID first for the shells that
+        // still match on it, then fall back to the name.
         const searchTerms = [roleId];
-        const roleName = roleIdentifier.startsWith(roleId)
-            ? roleIdentifier.slice(roleId.length)
-            : '';
         if (roleName !== '' && roleName !== roleId) {
             searchTerms.push(roleName);
         }

package/dist/pages/SM-8.10/ProcessApplicationPage.js

@@ -12,7 +12,7 @@ const resourceContainers = new WeakMap();
 // the resource container -- files, folders and uploads live directly inside it,
 // there is no separate process-application level to descend into. It is created
 // from the workspace's projects listing via the "Create project" split button +
-// dialog, and the app lands on `/workspace/{wsId}/projects/{projectId}`.
+// dialog, and the app lands on `/workspaces/{wsId}/projects/{projectId}`.
 //
 // This page object owns that container's surface (creating a Project, and binding
 // its development-stage cluster). Entering and leaving it is driven from

package/dist/tests/8.10/access-user-role-management.spec.js

@@ -154,7 +154,32 @@ _8_10_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_9,
                 password: process.env.C8_PASSWORD_TEST_9,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_10_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_10_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -245,7 +270,32 @@ _8_10_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_10,
                 password: process.env.C8_PASSWORD_TEST_10,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_10_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_10_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();

package/dist/tests/8.8/access-user-role-management.spec.js

@@ -157,7 +157,33 @@ _8_8_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_9,
                 password: process.env.C8_PASSWORD_TEST_9,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_8_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where no app-switcher button is visible, so
+            // clickCamundaApps() burns its rounds probing and then throws
+            // 'Failed to open app switcher after 3 attempts'. Re-clicking would just
+            // retry the same dead page until the budget ran out. openOptimizeWithRetry
+            // catches that throw and does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_8_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -247,7 +273,33 @@ _8_8_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_10,
                 password: process.env.C8_PASSWORD_TEST_10,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_8_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where no app-switcher button is visible, so
+            // clickCamundaApps() burns its rounds probing and then throws
+            // 'Failed to open app switcher after 3 attempts'. Re-clicking would just
+            // retry the same dead page until the budget ran out. openOptimizeWithRetry
+            // catches that throw and does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_8_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();

package/dist/tests/8.9/access-user-role-management.spec.js

@@ -154,7 +154,32 @@ _8_9_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_9,
                 password: process.env.C8_PASSWORD_TEST_9,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_9_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_9_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -245,7 +270,32 @@ _8_9_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_10,
                 password: process.env.C8_PASSWORD_TEST_10,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_9_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_9_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1181",
+  "version": "0.0.1183",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",