@camunda/e2e-test-suite 0.0.1250 → 0.0.1252

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

@@ -9,6 +9,8 @@ const modelerCluster_1 = require("../../utils/modelerCluster");
 class ModelerCreatePage {
     page;
     processApplicationPage;
+    pendingFileSaves = 0;
+    lastFileSaveActivity = 0;
     generalPanel;
     taskDefinitionPanel;
     processIdInput;
@@ -43,7 +45,6 @@ class ModelerCreatePage {
     restConnectorOption;
     changeElementSearchInput;
     changeElementResults;
-    changeElementTabStrip;
     reusableAssetsTab;
     marketPlaceButton;
     clientIdTextbox;
@@ -108,6 +109,23 @@ class ModelerCreatePage {
     constructor(page) {
         this.page = page;
         this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
+        // Track the modeler's debounced autosave (PATCH /files/{id}) so a deploy
+        // can wait until the server holds the latest edits. See
+        // waitForFileSavesToSettle().
+        page.on('request', (request) => {
+            if (ModelerCreatePage.isFileSave(request)) {
+                this.pendingFileSaves++;
+                this.lastFileSaveActivity = Date.now();
+            }
+        });
+        const settleFileSave = (request) => {
+            if (ModelerCreatePage.isFileSave(request)) {
+                this.pendingFileSaves = Math.max(0, this.pendingFileSaves - 1);
+                this.lastFileSaveActivity = Date.now();
+            }
+        };
+        page.on('requestfinished', settleFileSave);
+        page.on('requestfailed', settleFileSave);
         this.generalPanel = page.locator('[data-group-id="group-general"]');
         this.taskDefinitionPanel = page
             .locator('div')
@@ -211,17 +229,17 @@ class ModelerCreatePage {
             .locator('[data-id="replace.template-io.camunda.connectors.HttpJson.v2"]');
         this.changeElementSearchInput = page.locator('.djs-popup-search input');
         this.changeElementResults = page.locator('.djs-popup-results');
-        this.changeElementTabStrip = page.locator('.djs-popup-tabs-container');
         // The tab renders its label as text content, and the product source
         // spells it both "Reusable Assets" and "Reusable assets".
         this.reusableAssetsTab = page.getByRole('tab', {
             name: /reusable assets/i,
         });
-        // A title query is ambiguous: when the filtered result list has no connector
-        // match the popup also renders an empty-state link carrying the same title,
-        // so the query resolves to two elements and clicking throws in strict mode.
-        // Target the popup header entry by its stable entry id instead.
-        this.marketPlaceButton = page.locator('[data-id="browseConnectors"]');
+        // Browse All replaces the legacy Marketplace entry only in large menus
+        // when the Design System is enabled; small or DS-off menus keep the
+        // original entry.
+        this.marketPlaceButton = page
+            .locator('[data-id="hub-browse-all"]')
+            .or(page.locator('[data-id="browseConnectors"]'));
         this.clientIdTextbox = page.getByLabel('Client ID');
         this.clientSecretTextbox = page.getByLabel('Client secret');
         this.rememberCredentialsCheckbox = page.getByText('Remember credentials');
@@ -455,9 +473,13 @@ class ModelerCreatePage {
         await legacyItem.click({ timeout: 90000 });
     }
     async runProcessInstance(variables = '', tenant = '', businessId = '') {
+        // ensureStageCluster may navigate away from the diagram, which would drop
+        // a save that is still debounced, so settle before and after it.
+        await this.waitForFileSavesToSettle();
         await this.processApplicationPage.ensureStageCluster(process.env.MODELER_CLUSTER_NAME);
-        await this.page.waitForTimeout(2000); // the canvas autosaves. This can take a second to save.
+        await this.waitForFileSavesToSettle();
         const maxRetries = 3;
+        let executeSucceeded = false;
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
                 await this.clickDeployAndRunMainButton();
@@ -482,9 +504,16 @@ class ModelerCreatePage {
                     });
                     await this.businessIdInput.fill(businessId);
                 }
-                await this.clickDeployAndRunSubButton();
-                await this.instanceStartedAssertion();
-                return;
+                const [executeResponse] = await Promise.all([
+                    this.page.waitForResponse((response) => response.request().method() === 'POST' &&
+                        // Workspace-era Hub builds execute via /v2/projects/{id}; older
+                        // builds used /process-applications/{id}.
+                        /\/(process-applications|projects)\/[^/]+\/execute$/.test(new URL(response.url()).pathname), { timeout: 30000 }),
+                    this.clickDeployAndRunSubButton(),
+                ]);
+                (0, test_1.expect)(executeResponse.ok(), await executeResponse.text()).toBeTruthy();
+                executeSucceeded = true;
+                break;
             }
             catch (error) {
                 if (attempt < maxRetries - 1) {
@@ -497,12 +526,33 @@ class ModelerCreatePage {
                 }
             }
         }
+        if (executeSucceeded) {
+            await this.instanceStartedAssertion();
+        }
     }
     // Test mode mounts a one-time "A new way to test your processes" modal
     // (camunda-hub TestAnnouncementModal) that covers the setup steps behind it.
     // It renders unless localStorage already carries the seen flag, which it
     // reads on mount; a fresh Playwright context always starts empty, so set the
     // flag before entering Test mode rather than clicking the modal away.
+    static isFileSave(request) {
+        return (request.method() === 'PATCH' &&
+            /\/api\/internal\/files\/[^/]+$/.test(new URL(request.url()).pathname));
+    }
+    // Deploy & run deploys the diagram the server holds, not what is on screen.
+    // Hub debounces edits for roughly a second before it sends
+    // PATCH /files/{id}, and the autosave label keeps showing the previous
+    // "Autosaved at ..." time during that window, so the label cannot prove the
+    // latest edits are stored. Wait until no file save is in flight and none
+    // has started for longer than the debounce, measured from this call, so a
+    // save queued by edits made just before it is observed and awaited.
+    async waitForFileSavesToSettle(quietMs = 2000, timeout = 60000) {
+        const start = Date.now();
+        await test_1.expect
+            .poll(() => this.pendingFileSaves === 0 &&
+            Date.now() - Math.max(start, this.lastFileSaveActivity) >= quietMs, { timeout, intervals: [250] })
+            .toBe(true);
+    }
     async suppressTestModeAnnouncement() {
         await this.page.evaluate(() => localStorage.setItem('play-testAnnouncementSeen', 'true'));
     }
@@ -996,15 +1046,13 @@ class ModelerCreatePage {
     // before bpmn-js attaches its search handler during the popup re-render.
     async searchAndClickRestConnector() {
         await (0, test_1.expect)(this.changeElementSearchInput).toBeVisible({ timeout: 30000 });
-        await this.changeElementSearchInput.click();
-        await this.changeElementSearchInput.fill('');
         // 'Send REST Request' is the template's current name -- connectors #7917
         // renamed it from 'REST Outbound Connector' on 2026-07-15, and "Outbound"
         // now appears in no searchable field, so the old filter matched nothing.
-        await this.changeElementSearchInput.pressSequentially('Send REST Request', {
-            delay: 50,
-        });
-        await (0, test_1.expect)(this.restConnectorOption).toBeVisible({ timeout: 90000 });
+        // Templates live under the popup's "Reusable assets" tab, so searching the
+        // BPMN tab alone never lists them.
+        await this.revealChangeElementTemplate(this.restConnectorOption, 'Send REST Request');
+        await (0, test_1.expect)(this.restConnectorOption).toBeVisible({ timeout: 30000 });
         await this.restConnectorOption.click({ timeout: 90000 });
     }
     async clickRestConnectorOption(recoverSession) {
@@ -1106,38 +1154,10 @@ class ModelerCreatePage {
             name: /^Configure (test case|scenario)$/,
         }))
             .first();
-        // 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.
-        // camunda-hub's "Play" -> "Test Studio" rebrand renamed this container's
-        // data-test from `play-configuration-overlay` to
-        // `test-studio-configuration-overlay`, and a later build dropped both
-        // container data-test attributes entirely (neither is present in the
-        // failing run's trace DOM), so those two gates now match nothing. The
-        // always-present anchor is the panel's heading, which the current build
-        // renders as "Set up environment" (verb, two words) -- the old
-        // `getByText('Setup environment')` (one word) never matched it and the
-        // whole chain timed out. Match the heading with a spelling-tolerant regex
-        // so a future flip between the two forms cannot re-break the gate, and keep
-        // the legacy data-test attributes for older modeler builds. This locator
-        // means "the setup panel is still on screen".
         const configurationOverlay = this.page
             .locator('[data-test="test-studio-configuration-overlay"]')
             .or(this.page.locator('[data-test="play-configuration-overlay"]'))
-            .or(this.page.getByText(/set ?up environment/i))
+            .or(this.page.getByText(/set up test run/i))
             .first();
         const configureTestPanel = this.page.getByTestId('configure-test-panel');
         await (0, test_1.expect)(configurationOverlay
@@ -1156,18 +1176,23 @@ class ModelerCreatePage {
         if (isNewFlow) {
             // Step 1: connect cluster if not yet connected (modal with cluster dropdown)
             const connectClusterButton = this.page.getByRole('button', {
-                name: 'Connect cluster',
+                name: 'Select environment',
             });
             const needsConnect = await connectClusterButton
                 .isVisible({ timeout: 3000 })
                 .catch(() => false);
             if (needsConnect) {
                 await connectClusterButton.click({ timeout });
+                // camunda-hub's TestModeDeployEndpointConfigModal replaced the
+                // "Configure environment" combobox dialog with a "Choose where to
+                // run" dialog: environments now render as a radio group (one radio
+                // per environment), not a dropdown. The first environment is
+                // auto-selected once the list loads, but click it explicitly rather
+                // than relying on that default.
                 const configureEnvDialog = this.page
                     .getByRole('dialog')
-                    .filter({ hasText: 'Configure environment' });
-                await configureEnvDialog.getByRole('combobox').click({ timeout });
-                await this.page.getByRole('option').first().click({ timeout });
+                    .filter({ hasText: 'Choose where to run' });
+                await configureEnvDialog.getByRole('radio').first().click({ timeout });
                 await configureEnvDialog
                     .getByRole('button', { name: 'Save' })
                     .click({ timeout });
@@ -1255,7 +1280,9 @@ class ModelerCreatePage {
         if (await this.isVisibleWithin(option, 5000)) {
             return true;
         }
-        if (await this.isVisibleWithin(this.changeElementTabStrip, 5000)) {
+        // The tab strip's container class changed across Hub builds; probe the
+        // "Reusable assets" tab itself instead of its wrapper.
+        if (await this.isVisibleWithin(this.reusableAssetsTab, 5000)) {
             // A failed tab click leaves the search path intact, so do not throw.
             await this.reusableAssetsTab.click({ timeout: 30000 }).catch(() => { });
             if (await this.isVisibleWithin(option, 15000)) {

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

@@ -1,4 +1,4 @@
-import { Page, Locator } from '@playwright/test';
+import { Browser, Page, Locator } from '@playwright/test';
 declare class ModelerHomePage {
     private page;
     private defaultFolderName;
@@ -57,6 +57,7 @@ declare class ModelerHomePage {
         username: string;
         password: string;
     }): Promise<void>;
+    assignWorkspaceEnvironmentAsOrgAdmin(browser: Browser): Promise<void>;
     clickCrossComponentProjectFolder(credentials?: {
         username: string;
         password: string;

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

@@ -349,6 +349,30 @@ class ModelerHomePage {
         // under flag-on that folder maps to a Workspace.
         await this.ensureWorkspaceOpen(credentials);
     }
+    // Only an org admin can assign Environments to a workspace (Hub 8.10), so a
+    // workspace created by a plain Member has nothing to deploy to until one does.
+    // Call while this page is inside that workspace: assigns an Environment as the
+    // default Identity first user (an org admin) in a separate browser context,
+    // leaving this page's session untouched.
+    async assignWorkspaceEnvironmentAsOrgAdmin(browser) {
+        const workspaceUrl = this.page.url();
+        const context = await browser.newContext({
+            baseURL: new URL(workspaceUrl).origin,
+        });
+        try {
+            const adminPage = await context.newPage();
+            await new NavigationPage_1.NavigationPage(adminPage).goToModeler();
+            await new ProcessApplicationPage_1.ProcessApplicationPage(adminPage).assignEnvironmentToWorkspace(workspaceUrl, process.env.MODELER_CLUSTER_NAME);
+        }
+        finally {
+            await context.close();
+        }
+        // This page loaded the workspace before the admin assigned the
+        // Environment in the other session, so Hub still holds the empty
+        // environment list and Deploy & run has no target until it refetches.
+        await this.page.reload({ waitUntil: 'domcontentloaded' });
+        this.processApplicationPage.markWorkspaceEnvironmentAssignedByAdmin(workspaceUrl);
+    }
     async clickCrossComponentProjectFolder(credentials) {
         // Kept name: callers use this to (re-)enter the shared Workspace's projects
         // listing after leaving Modeler. Creates the Workspace if it is somehow

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

@@ -119,7 +119,14 @@ class OperateHomePage {
         // yields `"updatedValue""` -- invalid JSON, and Apply rejects it exactly
         // like the per-character version did. Same recipe as
         // pages/c8Run-8.10/OperateHomePage.ts.
-        await this.page.keyboard.press('ControlOrMeta+A');
+        //
+        // Select with Home + Shift+End rather than ControlOrMeta+A: headless
+        // Chromium on macOS does not apply Meta+A as select-all inside Monaco's
+        // native edit context, so the insert landed mid-string. The value is a
+        // single-line JSON string, so selecting the line selects the document on
+        // every platform.
+        await this.page.keyboard.press('Home');
+        await this.page.keyboard.press('Shift+End');
         await this.page.keyboard.insertText(`"${newValue}`);
     }
     async clickSaveVariableButton() {

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

@@ -52,10 +52,19 @@ class OptimizeHomePage {
     }
     async assertProcessHasBeenImported(processId) {
         await this.clickDashboardLink();
-        await this.page.reload();
-        await (0, test_1.expect)(this.page.getByRole('link', { name: processId })).toBeVisible({
-            timeout: 180000,
-        });
+        // The process list is paginated, so on a cluster with more than one page
+        // of processes the new one is not rendered until the list is filtered by
+        // name. Import is asynchronous, so reload and re-filter until it appears.
+        const search = this.page
+            .getByPlaceholder(/Search for name/i)
+            .or(this.page.getByPlaceholder('Filter table'))
+            .first();
+        const processLink = this.page.getByRole('link', { name: processId });
+        await (0, test_1.expect)(async () => {
+            await this.page.reload();
+            await search.fill(processId, { timeout: 30000 });
+            await (0, test_1.expect)(processLink).toBeVisible({ timeout: 15000 });
+        }).toPass({ timeout: 180000, intervals: [5000, 10000, 15000] });
     }
     async clickOpenUserSettingsButton() {
         await this.openUserSettingsButton.click();

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

@@ -12,19 +12,24 @@ declare class ProcessApplicationPage {
     readonly titleBar: Locator;
     readonly createNewDropdown: Locator;
     readonly inlineNameInput: Locator;
-    readonly defineStagesDialog: Locator;
-    readonly developmentClusterSelect: Locator;
-    readonly defineStagesSaveButton: Locator;
+    readonly manageEnvironmentsHeading: Locator;
+    readonly assignedEnvironmentCards: Locator;
+    readonly editEnvironmentsButton: Locator;
+    readonly environmentEditorRegion: Locator;
+    readonly saveEnvironmentsButton: Locator;
     constructor(page: Page);
     private pageReady;
     waitForProcessApplication(timeout?: number): Promise<void>;
     clickCreateProcessApplicationButton(): Promise<void>;
     clickCreateProcessApplicationOption(): Promise<void>;
     nameNewProcessApplication(name: string): Promise<void>;
-    private defineDevelopmentStage;
     rememberResourceContainer(url: string): void;
+    private workspaceEnvironmentsUrl;
     ensureStageCluster(clusterName?: string): Promise<void>;
-    private openStageDefinition;
+    assignEnvironmentToWorkspace(workspaceUrl: string, clusterName?: string): Promise<void>;
+    markWorkspaceEnvironmentAssignedByAdmin(workspaceUrl: string): void;
+    private workspaceId;
+    private assignWorkspaceEnvironment;
     openByName(name: string): Promise<void>;
 }
 export { ProcessApplicationPage };

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

@@ -6,6 +6,10 @@ const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModal
 // ModelerHomePage creates the container, while ModelerCreatePage later binds
 // its stage. Both page objects share the same Playwright Page.
 const resourceContainers = new WeakMap();
+// Workspace ids whose Environment an org admin assigned from a separate session
+// (see assignEnvironmentToWorkspace), keyed by the non-admin user's Page. That
+// user cannot open the workspace Environments tab, so ensureStageCluster skips it.
+const adminAssignedWorkspaces = new WeakMap();
 // Flag-on Self-Managed 8.10 (camunda-hub#27903: workspaces-enabled=true) renamed
 // the entity hierarchy: the legacy "project folder" is now a Workspace and the
 // legacy "process application" is now a Project (camunda-hub#28005). A Project is
@@ -14,11 +18,19 @@ const resourceContainers = new WeakMap();
 // from the workspace's projects listing via the "Create project" split button +
 // dialog, and the app lands on `/workspace/{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
-// ModelerHomePage so the ~150 existing spec call sites keep working unchanged.
-// Method names are kept from the flag-off era ("...ProcessApplication...") so the
-// callers do not have to change.
+// camunda-hub#29210 ("Environments phase1") then moved cluster assignment up a
+// level again: a Project no longer has its own "Define stages" dialog or
+// "Connected clusters" card at all. Assignment is now an Environment (backed by
+// a registered cluster) assigned to the whole Workspace via its Environments
+// settings tab (`/workspaces/{wsId}/settings?tab=environments`), shared by every
+// Project inside that Workspace.
+//
+// This page object owns that container's surface (creating a Project) plus the
+// Workspace-level Environment assignment Deploy/Play need. Entering and leaving
+// it is driven from ModelerHomePage so the ~150 existing spec call sites keep
+// working unchanged. Method names are kept from the flag-off era
+// ("...ProcessApplication...", "...StageCluster...") so the callers do not have
+// to change.
 class ProcessApplicationPage {
     page;
     // The workspace projects listing's "Create project" split button. exact:true
@@ -40,9 +52,15 @@ class ProcessApplicationPage {
     titleBar;
     createNewDropdown;
     inlineNameInput;
-    defineStagesDialog;
-    developmentClusterSelect;
-    defineStagesSaveButton;
+    // Workspace management -> Environments tab (camunda-hub#29210). Page-scoped,
+    // not container-scoped: this tab lives on a different page
+    // (`/workspaces/{wsId}/settings`) than the Project detail these other
+    // locators target.
+    manageEnvironmentsHeading;
+    assignedEnvironmentCards;
+    editEnvironmentsButton;
+    environmentEditorRegion;
+    saveEnvironmentsButton;
     constructor(page) {
         this.page = page;
         this.createProcessApplicationButton = page
@@ -95,11 +113,20 @@ class ProcessApplicationPage {
             .or(page.getByRole('button', { name: 'Create new' }))
             .first();
         this.inlineNameInput = page.locator('[data-test="editable-input"]');
-        this.defineStagesDialog = page
-            .getByRole('dialog')
-            .filter({ hasText: 'Define stages' });
-        this.developmentClusterSelect = this.defineStagesDialog.locator('#dropdown-development-cluster');
-        this.defineStagesSaveButton = this.defineStagesDialog.getByRole('button', {
+        // "Assigned environments" heading: WorkspaceEnvironmentsTab's ready signal
+        // (it only renders once the workspace-scoped read has resolved).
+        this.manageEnvironmentsHeading = page.locator('[data-test="manage-environments-heading"]');
+        this.assignedEnvironmentCards = page.locator('[data-test="environment-card"]');
+        // Reads "Add environments" with none assigned yet, "Edit environments"
+        // otherwise -- same data-test either way.
+        this.editEnvironmentsButton = page.locator('[data-test="edit-environments-button"]');
+        this.environmentEditorRegion = page.getByRole('group', {
+            name: 'Edit assigned environments',
+        });
+        // Page-scoped, not environmentEditorRegion-scoped: Save/Cancel are
+        // rendered in the tab's header row, a SIBLING of the "Edit assigned
+        // environments" group, not a descendant of it.
+        this.saveEnvironmentsButton = page.getByRole('button', {
             name: 'Save',
             exact: true,
         });
@@ -152,82 +179,150 @@ class ProcessApplicationPage {
         await this.inlineNameInput.press('Enter');
         await this.waitForProcessApplication();
     }
-    async defineDevelopmentStage(clusterName) {
-        await (0, test_1.expect)(this.defineStagesDialog).toBeVisible({ timeout: 60000 });
-        await this.developmentClusterSelect.click({ timeout: 30000 });
-        const escapedClusterName = clusterName?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        // The listbox leads with a "No cluster" entry that unassigns the stage; the
-        // placeholder "Select a development cluster" is only the trigger's text, not an
-        // option. Excluding just the placeholder leaves "No cluster" first, so an
-        // unnamed pick binds no cluster and saves defaultDevClusterId=null -- which
-        // makes the later Deploy dialog report "Clusters not configured for stages".
-        // Exclude "No cluster" too so the fallback lands on a real cluster.
-        const option = clusterName
-            ? this.page
-                .getByRole('option', { name: new RegExp(`^${escapedClusterName}`) })
-                .first()
-            : this.page
-                .getByRole('option')
-                .filter({ hasNotText: 'Select a development cluster' })
-                .filter({ hasNotText: 'No cluster' })
-                .first();
-        await option.click({ timeout: 30000 });
-        await this.defineStagesSaveButton.click({ timeout: 30000 });
-        await (0, test_1.expect)(this.defineStagesDialog).toBeHidden({ timeout: 60000 });
-    }
     rememberResourceContainer(url) {
         resourceContainers.set(this.page, { url });
     }
+    // Derives the shared Workspace's Environments settings URL from a Project
+    // detail URL (".../workspaces/<wsId>/projects/<projectId>[?...]"): the
+    // origin/app-root plus "/workspaces/<wsId>/settings?tab=environments" -- the
+    // same deep link camunda-hub's own useManageEnvironmentsLink builds for the
+    // deploy dialog's "Manage environments" link. Always emits the plural
+    // "workspaces" regardless of which spelling the container URL used
+    // (ModelerHomePage.openWorkspaceTile still tolerates a singular
+    // "/workspace/<id>/projects" from camunda-hub#28928 not yet being merged
+    // everywhere) -- the settings route itself (App.tsx) is plural-only, with no
+    // singular alias, so reusing a singular prefix verbatim would 404.
+    workspaceEnvironmentsUrl(containerUrl) {
+        const match = containerUrl.match(/^(.*)\/workspaces?\/([^/?#]+)\//);
+        if (!match) {
+            throw new Error(`Could not derive the workspace Environments URL from "${containerUrl}": ` +
+                'expected a "/workspaces/<id>/..." segment.');
+        }
+        const [, origin, workspaceId] = match;
+        return `${origin}/workspaces/${workspaceId}/settings?tab=environments`;
+    }
+    // Assigns an Environment to the shared Workspace via its Environments
+    // settings tab, so Deploy/Play (and Play's "Configure environment") find a
+    // usable target instead of rendering "No environments assigned" and staying
+    // disabled -- camunda-hub#29210 moved this out of the Project detail's own
+    // "Define stages" dialog and up to the Workspace, shared by every Project
+    // inside it.
+    //
+    // Checks the read-only "Assigned environments" list before entering edit
+    // mode, so a Workspace another (parallel) test already assigned is left
+    // alone regardless of this Page's own memo flag below -- required because
+    // every test's Project lives in the one shared Workspace. This is a
+    // best-effort check, not a lock: two tests racing to assign at once each
+    // still write their own snapshot of the selected set (Save persists the
+    // whole set, it does not merge), so a genuine concurrent race could still
+    // trigger two writes. It converges correctly here only because every test
+    // targets the one MODELER_CLUSTER_NAME (or, when unset, is happy with
+    // whichever single Environment ends up assigned).
     async ensureStageCluster(clusterName) {
         const container = resourceContainers.get(this.page);
         if (!container ||
             (container.stageBound && container.developmentCluster === clusterName)) {
             return;
         }
+        if (adminAssignedWorkspaces
+            .get(this.page)
+            ?.has(this.workspaceId(container.url))) {
+            container.stageBound = true;
+            container.developmentCluster = clusterName;
+            return;
+        }
         const returnTo = this.page.url();
-        // Under workspaces-enabled there is no `/connected-clusters` sub-route: the
-        // "Connected clusters" card lives in the Project detail's sidebar and its
-        // "Configure" button opens the Define stages modal (see camunda-hub
-        // ConnectedClustersDs). So navigate to the Project detail itself and let
-        // openStageDefinition() click that button.
-        const processApplicationUrl = container.url
-            .replace(/[?#].*$/, '')
-            .replace(/\/$/, '');
-        await (0, test_1.expect)(async () => {
-            await this.page.goto(processApplicationUrl, {
-                waitUntil: 'domcontentloaded',
-            });
-            await this.waitForProcessApplication();
-            await this.openStageDefinition();
-            await this.defineDevelopmentStage(clusterName);
-        }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
+        await this.assignEnvironmentToWorkspace(container.url, clusterName);
         container.stageBound = true;
         container.developmentCluster = clusterName;
         await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
     }
-    async openStageDefinition() {
-        const opened = await this.defineStagesDialog
-            .waitFor({ state: 'visible', timeout: 3000 })
+    // Assigns an Environment to the workspace that `workspaceUrl` (any
+    // "/workspaces/<id>/..." URL) belongs to, driving this Page's own session.
+    async assignEnvironmentToWorkspace(workspaceUrl, clusterName) {
+        const environmentsUrl = this.workspaceEnvironmentsUrl(workspaceUrl);
+        await (0, test_1.expect)(async () => {
+            await this.page.goto(environmentsUrl, { waitUntil: 'domcontentloaded' });
+            await this.assignWorkspaceEnvironment(clusterName);
+        }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
+    }
+    markWorkspaceEnvironmentAssignedByAdmin(workspaceUrl) {
+        const assigned = adminAssignedWorkspaces.get(this.page) ?? new Set();
+        assigned.add(this.workspaceId(workspaceUrl));
+        adminAssignedWorkspaces.set(this.page, assigned);
+    }
+    workspaceId(workspaceUrl) {
+        const match = workspaceUrl.match(/\/workspaces?\/([^/?#]+)\//);
+        if (!match) {
+            throw new Error(`Could not derive the workspace id from "${workspaceUrl}": ` +
+                'expected a "/workspaces/<id>/..." segment.');
+        }
+        return match[1];
+    }
+    async assignWorkspaceEnvironment(clusterName) {
+        const tabReady = await this.manageEnvironmentsHeading
+            .or(this.editEnvironmentsButton)
+            .first()
+            .waitFor({ state: 'visible', timeout: 90000 })
             .then(() => true)
             .catch(() => false);
-        if (opened) {
+        if (!tabReady) {
+            // WorkspaceManageBody silently normalises an unrecognised/unusable
+            // "?tab=environments" back to Members -- e.g. isEnvironmentsEnabled()
+            // off, or the current user failing canManageWorkspaceEnvironments
+            // (assigning is stricter than viewing: a plain Editor with no
+            // elevated/DevOps org role cannot assign at all). Name the likely
+            // cause rather than timing out with an opaque "not visible".
+            const onMembersTab = await this.page
+                .locator('[data-test="tab-members"][data-state="active"]')
+                .isVisible()
+                .catch(() => false);
+            throw new Error('The workspace Environments settings tab never rendered' +
+                (onMembersTab ? ' -- landed on the Members tab instead' : '') +
+                '. Either the Environments feature is off for this deployment, or the ' +
+                "current user lacks permission to manage this workspace's environments.");
+        }
+        const alreadyAssigned = clusterName
+            ? this.assignedEnvironmentCards.filter({ hasText: clusterName })
+            : this.assignedEnvironmentCards;
+        if (await alreadyAssigned
+            .first()
+            .isVisible()
+            .catch(() => false)) {
             return;
         }
-        // The "Connected clusters" card's action is labelled "Configure"; earlier
-        // shells used "Define stages" / "Edit stages".
-        const reopen = this.page
-            .getByRole('button', { name: /^(define stages|edit stages|configure)$/i })
-            .first();
-        const canReopen = await reopen
-            .waitFor({ state: 'visible', timeout: 15000 })
+        await this.editEnvironmentsButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.environmentEditorRegion).toBeVisible({ timeout: 30000 });
+        const escapedClusterName = clusterName?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // A picker card's toggle button is "Select <name> (<clusterName or
+        // clusterId>)" (see camunda-hub EnvironmentPickerCard) -- match the
+        // cluster name in that parenthetical rather than the environment's own
+        // display name, which is a separate, admin-chosen field that need not
+        // match the cluster at all.
+        const targetOption = clusterName
+            ? this.environmentEditorRegion
+                .getByRole('button', {
+                name: new RegExp(`^Select .*\\(${escapedClusterName}\\)`),
+            })
+                .first()
+            : this.environmentEditorRegion
+                .getByRole('button', { name: /^Select / })
+                .first();
+        const optionAppeared = await targetOption
+            .waitFor({ state: 'visible', timeout: 30000 })
             .then(() => true)
             .catch(() => false);
-        if (!canReopen) {
-            throw new Error('Could not open the "Define stages" dialog: it did not open by ' +
-                'itself and no "Configure" / "Define stages" / "Edit stages" ' +
-                'control was found on the Project detail page.');
+        if (!optionAppeared) {
+            throw new Error(clusterName
+                ? `No Environment backed by cluster "${clusterName}" is available to assign to this ` +
+                    'workspace. Register the cluster (or its Environment) first.'
+                : 'No Environment is available to assign to this workspace: the picker shows "No ' +
+                    'environments available".');
         }
-        await reopen.click({ timeout: 30000 });
+        await targetOption.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.saveEnvironmentsButton).toBeEnabled({ timeout: 30000 });
+        await this.saveEnvironmentsButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.environmentEditorRegion).toBeHidden({ timeout: 60000 });
     }
     async openByName(name) {
         // Workspace-mode projects table: the whole row is the click target (see the