diff --git a/docs/requirements/e2e-test-guidelines.md b/docs/requirements/e2e-test-guidelines.md
index efbdfcc3d6..79b1a067a6 100644
--- a/docs/requirements/e2e-test-guidelines.md
+++ b/docs/requirements/e2e-test-guidelines.md
@@ -67,6 +67,16 @@ page.locator(".mx-name-myForm").getByRole("button", { name: "Save" });
 page.locator(".mx-name-myWidget").getByLabel("Start date");
 ```
 
+## Keyboard Interaction
+
+| Don't                                                | Do Instead                                                   | Why                                                                                                                                      |
+| ---------------------------------------------------- | ------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `press("Escape")` on a page opened as a popup        | Reach the state another way, or test Escape on a plain page  | The Mendix client closes the popup on Escape — widgets that only `preventDefault()` still let it bubble, so the widget unmounts mid-test |
+| `input.click()` to focus a field that may be empty   | Click a stable sibling that focuses it, or `locator.focus()` | Widgets collapse empty unfocused inputs (e.g. `max-width: 0`), and Playwright cannot click a zero-sized box                              |
+| `container.click()` when children own click handlers | Click a child with no handler of its own                     | Clicks land on the element's centre; a child under that point receives the event instead                                                 |
+
+A widget losing focus to `document.body` mid-test looks identical to a locator bug — assert `toBeFocused()` on the expected element after each keystroke so the step that actually broke is named.
+
 ## Screenshot Testing
 
 - No per-test `{ threshold: N }` or `{ maxDiffPixels: N }` overrides — use global config (`threshold: 0.1`)
diff --git a/packages/pluggableWidgets/combobox-web/CHANGELOG.md b/packages/pluggableWidgets/combobox-web/CHANGELOG.md
index f648423ef0..fdca9b58cb 100644
--- a/packages/pluggableWidgets/combobox-web/CHANGELOG.md
+++ b/packages/pluggableWidgets/combobox-web/CHANGELOG.md
@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+### Fixed
+
+- We fixed an issue where selecting all of the typed text in a multi-select combobox and pressing Backspace did not permanently clear it, so the text reappeared after clicking away and back into the combobox.
+
+- We fixed an issue where removing a selected item of a multi-select combobox with Backspace or Delete moved keyboard focus out of the combobox, unless the removed item was the last one. Focus now stays on the selected items so you can keep navigating and removing them with the keyboard.
+
 ## [2.9.0] - 2026-07-24
 
 ### Fixed
diff --git a/packages/pluggableWidgets/combobox-web/e2e/ComboboxMultiSelectionKeys.spec.js b/packages/pluggableWidgets/combobox-web/e2e/ComboboxMultiSelectionKeys.spec.js
new file mode 100644
index 0000000000..c5759241d9
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/e2e/ComboboxMultiSelectionKeys.spec.js
@@ -0,0 +1,213 @@
+import { expect, test } from "@mendix/run-e2e/fixtures";
+
+// NOTE for anyone extending this file: do not press Escape. These tests run on a Mendix popup
+// page (opened by .mx-name-actionButton1) and the client closes that popup on Escape. The
+// combobox's own Escape handler only calls preventDefault(), so the keydown still bubbles and
+// the whole widget leaves the DOM mid-test, which shows up as chips silently dropping to 0.
+// Everything below therefore leaves the menu open, which is also where the filter input already
+// holds focus after an option is picked.
+
+/**
+ * Leaves the combobox with exactly `count` chips, the menu open and the filter input focused.
+ *
+ * The test page ships this combobox with options already selected, so tests that address chips
+ * by index clear it first and re-select from the top. Nothing is persisted — the popup's Save
+ * button is never pressed — so this stays local to the test. In row click selection mode
+ * selected options drop out of the menu, hence clicking the first option each pass picks a new
+ * one.
+ */
+async function selectChips(comboBox, count) {
+    const chips = comboBox.locator(".widget-combobox-selected-item");
+    const options = comboBox.locator("[role=listbox] [role=option]");
+
+    // Only the widget-level clear button is a <button>; a chip's own × is a <span>.
+    await comboBox.locator("button.widget-combobox-clear-button").click();
+    await expect(chips).toHaveCount(0);
+
+    await comboBox.click();
+    for (let selected = 0; selected < count; selected++) {
+        await expect(options.first()).toBeVisible();
+        await options.first().click({ delay: 10 });
+        await expect(chips).toHaveCount(selected + 1);
+    }
+
+    // Picking an option returns focus to the filter input, which is where a keyboard user
+    // continues from. Assert it so the arrow keys below start from a known place.
+    await expect(comboBox.locator("input")).toBeFocused();
+}
+
+/**
+ * Focuses the filter input from scratch, without changing the selection.
+ *
+ * Clicking the input itself does not work: while it is empty and unfocused the widget collapses
+ * it to `max-width: 0`, so Playwright never sees a clickable box. So open the menu instead —
+ * downshift focuses the input whenever the menu opens without it already being focused.
+ *
+ * The down arrow is the target rather than the surrounding input container: a click lands on the
+ * element's centre, and with chips present the container's centre can sit on a chip, which
+ * activates that chip instead. The arrow has no handler of its own, so the click bubbles to the
+ * container's toggle handler.
+ */
+async function focusFilterInput(comboBox) {
+    await comboBox.locator(".widget-combobox-down-arrow").click();
+    await expect(comboBox.locator("input")).toBeFocused();
+}
+
+// Regression for WC-3347: in a multi-select combobox with at least one selected chip,
+// selecting all filter text and pressing Backspace used to leave the text in place —
+// the custom onKeyDown treated a select-all range (selectionStart === 0) as "caret at
+// the start" and moved focus to the last chip, which reverted the pending input change.
+// Delete never entered that branch, hence the reported Backspace/Delete asymmetry.
+test.describe("combobox-web multi-selection filter input keys", () => {
+    test.beforeEach(async ({ page }) => {
+        await page.goto("/p/combobox");
+        await page.click(".mx-name-actionButton1");
+        await page.click(".mx-name-tabPage2");
+    });
+
+    for (const key of ["Backspace", "Delete"]) {
+        test(`clears the filter for good when all text is selected and ${key} is pressed`, async ({ page }) => {
+            const comboBox = page.locator(".mx-name-comboBox4");
+            await expect(comboBox).toBeVisible({ timeout: 10000 });
+
+            // Arrange: select two options so chips exist. The bug only surfaces with at
+            // least one chip — with none, setActiveIndex(-1) is a no-op.
+            await comboBox.click();
+            const options = comboBox.locator("[role=listbox] [role=option]");
+            await expect(options.first()).toBeVisible();
+            await options.nth(0).click({ delay: 10 });
+            await options.nth(1).click({ delay: 10 });
+
+            const chips = comboBox.locator(".widget-combobox-selected-item");
+            await expect(chips.first()).toBeVisible();
+
+            const input = comboBox.locator("input");
+            await input.click();
+            await page.keyboard.type("zzz");
+            await expect(input).toHaveValue("zzz");
+
+            // Act
+            await input.press("ControlOrMeta+a");
+            await input.press(key);
+
+            // Assert: cleared immediately, and still cleared after leaving and re-entering
+            // the widget. Click the container rather than the input: once the text is
+            // genuinely gone the input can collapse to zero width and not be clickable.
+            await expect(input).toHaveValue("");
+            await page.locator("body").click({ position: { x: 5, y: 5 } });
+            await comboBox.locator(".widget-combobox-input-container").click();
+            await expect(input).toHaveValue("");
+        });
+    }
+
+    test("Backspace with a partial text selection removes only the selected characters", async ({ page }) => {
+        // The unit suite cannot cover this one: jsdom does not perform native text deletion,
+        // so only a real browser shows whether the unselected tail survives.
+        const comboBox = page.locator(".mx-name-comboBox4");
+        await expect(comboBox).toBeVisible({ timeout: 10000 });
+
+        // Chips are the precondition for the bug — with none, activating one is a no-op.
+        const chips = comboBox.locator(".widget-combobox-selected-item");
+        await expect(chips.first()).toBeVisible();
+
+        const input = comboBox.locator("input");
+        await focusFilterInput(comboBox);
+        await page.keyboard.type("abc");
+        await expect(input).toHaveValue("abc");
+
+        // Select "ab" without leaving the input: step the caret back over "c", then extend
+        // the selection left to position 0. Pressing Home instead is not portable across
+        // platforms in a text field.
+        await page.keyboard.press("ArrowLeft");
+        await page.keyboard.press("Shift+ArrowLeft");
+        await page.keyboard.press("Shift+ArrowLeft");
+
+        // Act
+        await page.keyboard.press("Backspace");
+
+        // Assert: the selection is gone, the tail is kept, and no chip took the keystroke.
+        await expect(input).toHaveValue("c");
+        await expect(input).toBeFocused();
+    });
+});
+
+// Regression for the chip-focus follow-up: removing a selected chip with Backspace/Delete
+// used to drop keyboard focus to the document body unless the chip was the last one in the
+// row. downshift only re-focuses when its own activeIndex changes, which it does not when a
+// chip other than the last is removed.
+test.describe("combobox-web multi-selection chip removal keys", () => {
+    test.beforeEach(async ({ page }) => {
+        await page.goto("/p/combobox");
+        await page.click(".mx-name-actionButton1");
+        await page.click(".mx-name-tabPage2");
+    });
+
+    for (const key of ["Backspace", "Delete"]) {
+        test(`keeps keyboard focus on the selected items when ${key} removes a middle chip`, async ({ page }) => {
+            const comboBox = page.locator(".mx-name-comboBox4");
+            await expect(comboBox).toBeVisible({ timeout: 10000 });
+
+            // Arrange: exactly three chips, so a middle one exists and the indexes below are
+            // unambiguous.
+            const chips = comboBox.locator(".widget-combobox-selected-item");
+            await selectChips(comboBox, 3);
+
+            // Walk from the filter input onto the middle chip.
+            await page.keyboard.press("ArrowLeft");
+            await expect(chips.nth(2)).toBeFocused();
+            await page.keyboard.press("ArrowLeft");
+            await expect(chips.nth(1)).toBeFocused();
+
+            // Act
+            await page.keyboard.press(key);
+
+            // Assert: the chip is gone and focus moved to the chip that took its place,
+            // so navigation continues instead of falling back to the page.
+            await expect(chips).toHaveCount(2);
+            await expect(chips.nth(1)).toBeFocused();
+            await page.keyboard.press("ArrowLeft");
+            await expect(chips.nth(0)).toBeFocused();
+        });
+
+        test(`returns focus to the filter input when ${key} removes the only chip`, async ({ page }) => {
+            const comboBox = page.locator(".mx-name-comboBox4");
+            await expect(comboBox).toBeVisible({ timeout: 10000 });
+
+            const chips = comboBox.locator(".widget-combobox-selected-item");
+            await selectChips(comboBox, 1);
+
+            await page.keyboard.press("ArrowLeft");
+            await expect(chips.first()).toBeFocused();
+
+            // Act
+            await page.keyboard.press(key);
+
+            // Assert: with no chip left to hold focus it belongs in the filter input, so the
+            // user can keep typing instead of tabbing back into the widget.
+            await expect(chips).toHaveCount(0);
+            await expect(comboBox.locator("input")).toBeFocused();
+        });
+    }
+
+    test("Backspace on an empty filter input reaches the last chip and removes it on the second press", async ({
+        page
+    }) => {
+        // The gating rewrite that fixed WC-3347 must not cost the shortcut it gates: Backspace
+        // on an empty filter input still has to walk into the chips.
+        const comboBox = page.locator(".mx-name-comboBox4");
+        await expect(comboBox).toBeVisible({ timeout: 10000 });
+
+        const chips = comboBox.locator(".widget-combobox-selected-item");
+        await selectChips(comboBox, 3);
+        await expect(comboBox.locator("input")).toHaveValue("");
+
+        // Act
+        await page.keyboard.press("Backspace");
+        await expect(chips.nth(2)).toBeFocused();
+        await page.keyboard.press("Backspace");
+
+        // Assert: the last chip is gone and focus moved to the chip on its left.
+        await expect(chips).toHaveCount(2);
+        await expect(chips.nth(1)).toBeFocused();
+    });
+});
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/.openspec.yaml b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/.openspec.yaml
new file mode 100644
index 0000000000..4af864176c
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-08-14
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/design.md b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/design.md
new file mode 100644
index 0000000000..feadd890c8
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/design.md
@@ -0,0 +1,95 @@
+## Context
+
+`MultiSelection` layers a custom `onKeyDown` on top of the props returned by downshift's `useMultipleSelection().getDropdownProps()` and `useCombobox().getInputProps()`:
+
+```ts
+// src/components/MultiSelection/MultiSelection.tsx:59-65
+onKeyDown: (event: KeyboardEvent) => {
+    if (
+        (event.key === "Backspace" && inputRef.current?.selectionStart === 0) ||
+        (event.key === "ArrowLeft" && isSelectedItemsBoxStyle && inputRef.current?.selectionStart === 0)
+    ) {
+        setActiveIndex(selectedItems.length - 1);
+    }
+```
+
+The intent is "the caret has nowhere left to go inside the filter input, so hand keyboard focus to the last selected chip". The check is wrong because `selectionStart === 0` is also true for a _range_ selection that begins at 0 — which is exactly what Ctrl/Cmd+A produces. Only the start of the range is inspected; `selectionEnd` is never consulted.
+
+**Why the text comes back.** The multi-select combobox deliberately preserves typed filter text across focus changes — its `stateReducer` returns the previous state on blur:
+
+```ts
+// src/hooks/useDownshiftMultiSelectProps.ts:222-223
+case useCombobox.stateChangeTypes.InputBlur:
+    return { ...state, highlightedIndex: -1 };
+```
+
+`setActiveIndex(selectedItems.length - 1)` makes downshift move DOM focus onto the chip, so the input blurs in the _same_ keystroke that natively deleted the selected text. The `InputBlur` branch then resolves to `state` — the snapshot from before the deletion — discarding the `InputChange` that would have set `inputValue` to `""`. The input is controlled by `inputValue`, so the widget re-renders with the old text; the user sees it again on the next focus. Delete never enters the branch, never steals focus, and so never triggers this — matching the reported asymmetry.
+
+**Confirmed by the reproduction (WC-3347 diagnostic).** The revert is immediate, not deferred to the next focus: right after select-all + Backspace the input still reads `value="zzz"` across the full 5s assertion retry window (14 samples), with `aria-expanded="true"`. The controlled input snaps back within the same render pass. The user perceives it as "the text came back when I clicked in again" only because focus had already jumped to a chip, so they were not looking at the input in between. Delete, run as a control in the same spec, passes — the input clears and stays clear.
+
+The dispatch ordering inside downshift has not been step-through verified, but the observable outcome and the responsible branch are confirmed.
+
+**The decisive find:** downshift already ships precisely the predicate this handler needs, and applies it to its _own_ dropdown Backspace handler:
+
+```js
+// downshift 7.6.2, dist/downshift.cjs.js:3432
+function isKeyDownOperationPermitted(event) {
+    if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) return false;
+    var element = event.target;
+    if (
+        element instanceof HTMLInputElement &&
+        element.value !== "" &&
+        (element.selectionStart !== 0 || element.selectionEnd !== 0)
+    )
+        return false;
+    return true;
+}
+```
+
+So downshift's rule is: permit chip interaction only when the input is empty, **or** the caret is collapsed at position 0, and no modifier is held. Our custom handler checks one third of that. It is not exported from the package (absent from `typings/index.d.ts` and from the CJS exports), so it cannot be imported.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- Deleting a full text selection with Backspace clears the filter input permanently — no resurfacing on blur/refocus.
+- Chip focus transfer keeps working for the case it was written for: Backspace with an empty filter input.
+- Align this handler's gating with downshift's own semantics, so the widget and the library agree on when a key belongs to the text field versus the chip list.
+- Close the Backspace/Delete asymmetry with regression coverage on both paths.
+
+**Non-Goals:**
+
+- Changing how multi-select preserves filter text across blur/focus. The `InputBlur` reducer returning previous state is intentional and stays; we fix the unintended focus steal instead.
+- Touching `SingleSelection`, which guards on `e.currentTarget.value === ""` and is unaffected.
+- Upgrading downshift (the repo also has 9.3.6 in the store for other packages; this widget stays on `^7.6.2`).
+- Reworking chip removal, `selectedItemsStyle`, or menu behaviour.
+
+## Decisions
+
+### 1. Mirror downshift's `isKeyDownOperationPermitted` in a local helper rather than inventing a new condition
+
+Extract a small predicate in the widget (e.g. `isChipNavigationPermitted(event)`) replicating downshift's logic, and require it in both branches.
+
+_Why:_ the bug is a divergence from the library's own contract, so converging on that contract fixes this instance and the neighbouring ones (modifier-held keypresses, range selections not anchored at 0) in one move. Copying ~6 lines is preferable to inventing a subtly different rule that will drift from downshift's behaviour on the chips themselves.
+
+_Alternatives considered:_
+
+- **Minimal patch — add `&& selectionEnd === 0` to both branches.** Fixes the reported bug and is the smallest diff, but leaves the modifier-key gap and permits activation with a collapsed caret at 0 while text is present, where downshift itself would refuse. Acceptable fallback if reviewers want the tightest possible change; noted as the reduced-scope option.
+- **Guard on `value === ""` only (copy `SingleSelection`).** Simple and consistent across the two components, but strictly narrower than downshift: it would drop chip navigation for a collapsed caret at position 0 with text present, a case downshift explicitly permits. Rejected as an unnecessary behaviour regression for the ArrowLeft path.
+- **Fix the `InputBlur` reducer to accept `changes.inputValue`.** Treats the symptom at the state layer, and risks discarding the deliberate "keep the filter text across blur" behaviour that other flows depend on. Rejected.
+
+### 2. Apply the same guard to the ArrowLeft branch
+
+ArrowLeft with an active text selection should collapse that selection, per standard text-field semantics, not jump to a chip. The branch shares the identical faulty check, so it is corrected together rather than left as a known-latent twin of the same bug.
+
+### 3. Verify both key paths, and promote the diagnostic into a real regression test
+
+The investigation's throwaway spec (`e2e/WC-backspace-stale-diagnostic.spec.js`) confirmed the Backspace failure but its Delete control case was never observed green (a click timeout plus Playwright grep-flag trouble). The change must land coverage that actually executes both, so "Delete is fine" stops being a code-reading inference. Unit tests with React Testing Library are the cheaper home for the key-handling matrix; an e2e test covers the blur/refocus round trip that produced the user-visible symptom. Prefer unit coverage for the matrix, plus one e2e for the round trip.
+
+## Risks / Trade-offs
+
+- **Copied library internals can drift from downshift on upgrade** → keep the helper small, comment it with the downshift source reference and version, and note that a downshift major upgrade should re-check it against `isKeyDownOperationPermitted`.
+- **Some users may rely on Backspace-at-caret-0-with-text reaching the chips** → this is preserved: downshift's predicate permits a collapsed caret at 0. Only range selections and modifier-held presses change, which is the defect being fixed.
+- **Hidden dependence on the current (buggy) behaviour in existing tests** → run the widget's full unit suite and the existing `e2e/Combobox.spec.js` before concluding; the known Backspace test there is single-select (`comboBox2`, enum) and should be unaffected.
+- **Mechanism is inferred, not instrumented** → the fix targets the trigger (the guard), which the reproduction directly implicates, so it holds even if the precise dispatch ordering differs. The regression test, not the mechanism narrative, is what gates success.
+- **Reproduction requires a running test project** and the multi-select combobox with at least one existing chip (`comboBox4` on tab page 2); `setActiveIndex(-1)` on an empty selection means the bug does not surface with zero chips.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/proposal.md b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/proposal.md
new file mode 100644
index 0000000000..c93b0f92ac
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/proposal.md
@@ -0,0 +1,30 @@
+## Why
+
+In a multi-select Combobox that already has at least one selected chip, selecting all filter text and pressing Backspace appears to clear the input, but the text silently returns as soon as the user clicks outside the widget and back in. A customer reported this; it has been reproduced against a live test project. Pressing Delete instead of Backspace does not show the problem, which makes the behaviour look arbitrary and erodes trust in the widget's basic text editing.
+
+## What Changes
+
+- Backspace no longer moves focus to the last selected chip when the filter input has a non-collapsed text selection (e.g. after select-all). Chip activation stays reserved for a collapsed caret sitting at position 0, which is the case the behaviour was designed for.
+- The same collapsed-caret condition is applied to the ArrowLeft chip-navigation path in "boxes" selected-items style, which shares the identical faulty check.
+- Deleting a full text selection with Backspace now clears the filter input for good — the text does not reappear on blur/refocus.
+- Regression coverage is added for both key paths (Backspace and Delete) so the asymmetry cannot silently return.
+- No changes to single-select behaviour, and no changes to the chip-removal behaviour users rely on today (Backspace on an empty input still targets the last chip).
+
+## Capabilities
+
+### New Capabilities
+
+- `multiselect-keyboard-interaction`: Keyboard behaviour of the multi-select Combobox filter input — when Backspace/ArrowLeft transfer focus to selected chips for removal versus when they act as ordinary text editing within the filter input.
+
+### Modified Capabilities
+
+<!-- None. The package has no existing specs (openspec/specs/ is empty), so this
+     change introduces the first spec for this behaviour rather than modifying one. -->
+
+## Impact
+
+- **Code**: `src/components/MultiSelection/MultiSelection.tsx` — the `onKeyDown` handler passed into `getInputProps` (the `selectionStart === 0` guard on the Backspace and ArrowLeft branches).
+- **Not affected**: `src/components/SingleSelection/SingleSelection.tsx` guards its Backspace branch on `e.currentTarget.value === ""`, so single-select never hits this defect.
+- **Tests**: new regression coverage in `e2e/` and/or `src/**/__tests__/`. A throwaway diagnostic spec (`e2e/WC-backspace-stale-diagnostic.spec.js`) exists from the investigation and must be either promoted to a proper regression test or deleted.
+- **Release**: patch version bump kept in sync across `package.json` and `src/package.xml`, plus a user-facing `CHANGELOG.md` entry under `## [Unreleased]`.
+- **Dependencies**: none. Downshift stays on its current version; the fix is local to the widget's own key handler.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/specs/multiselect-keyboard-interaction/spec.md b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/specs/multiselect-keyboard-interaction/spec.md
new file mode 100644
index 0000000000..2b25111132
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/specs/multiselect-keyboard-interaction/spec.md
@@ -0,0 +1,62 @@
+## ADDED Requirements
+
+### Requirement: Filter input text editing takes precedence over chip navigation
+
+In a multi-select Combobox, keys pressed while the filter input holds an active (non-collapsed) text selection SHALL act on that text and MUST NOT transfer keyboard focus to the selected items (chips). Focus transfer to chips SHALL be permitted only when the filter input is empty, or when the caret is collapsed at position 0, and no modifier key (Shift, Control, Meta, Alt) is held — matching the gating downshift applies to its own dropdown key handling.
+
+#### Scenario: Backspace deletes a full text selection instead of activating a chip
+
+- **WHEN** a multi-select Combobox has at least one selected chip, the user has typed filter text, selected all of it (Ctrl/Cmd+A), and presses Backspace
+- **THEN** the filter input is cleared, keyboard focus remains in the filter input, and no chip becomes active
+
+#### Scenario: Cleared text does not reappear after leaving and re-entering the widget
+
+- **WHEN** the user has cleared a full text selection with Backspace, then clicks outside the Combobox and clicks back into the filter input
+- **THEN** the filter input is still empty
+
+#### Scenario: Delete behaves identically to Backspace on a full text selection
+
+- **WHEN** a multi-select Combobox has at least one selected chip, the user has typed filter text, selected all of it, and presses Delete
+- **THEN** the filter input is cleared, it remains empty after clicking outside and back in, and no chip becomes active
+
+#### Scenario: Partial text selection is not treated as chip navigation
+
+- **WHEN** the user selects part of the filter text starting at position 0 (leaving trailing text unselected) and presses Backspace
+- **THEN** only the selected characters are removed, the remaining text is preserved, and no chip becomes active
+
+### Requirement: Backspace on an empty filter input activates the last selected chip
+
+Chip removal by keyboard SHALL remain available: when the filter input is empty, Backspace SHALL make the last selected chip the active item so it can be removed. This behaviour is unchanged by the text-editing precedence rule above.
+
+#### Scenario: Backspace with an empty filter input targets the last chip
+
+- **WHEN** a multi-select Combobox has one or more selected chips and the filter input is empty, and the user presses Backspace
+- **THEN** the last selected chip becomes the active item
+
+#### Scenario: Backspace with an empty filter input and no chips does nothing
+
+- **WHEN** a multi-select Combobox has no selected chips and the filter input is empty, and the user presses Backspace
+- **THEN** no chip is activated and the widget state is unchanged
+
+### Requirement: ArrowLeft chip navigation requires a collapsed caret
+
+In "boxes" selected-items style, ArrowLeft SHALL move focus to the last selected chip only when the caret is collapsed at position 0. When an active text selection exists, ArrowLeft SHALL follow standard text-field behaviour and MUST NOT transfer focus to the chips.
+
+#### Scenario: ArrowLeft with a collapsed caret at the start reaches the chips
+
+- **WHEN** the selected-items style is "boxes", the caret sits collapsed at position 0 of the filter input, and the user presses ArrowLeft
+- **THEN** the last selected chip becomes the active item
+
+#### Scenario: ArrowLeft with an active text selection stays in the filter input
+
+- **WHEN** the selected-items style is "boxes", the filter text is fully selected, and the user presses ArrowLeft
+- **THEN** keyboard focus remains in the filter input and no chip becomes active
+
+### Requirement: Single-select behaviour is unaffected
+
+The single-select Combobox SHALL continue to clear its selection when Backspace is pressed with an empty filter input, unchanged by this change.
+
+#### Scenario: Single-select clear-with-Backspace still works
+
+- **WHEN** a clearable single-select Combobox has a selected value and the user presses Backspace with an empty filter input
+- **THEN** the selection is cleared and the placeholder is shown
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/tasks.md b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/tasks.md
new file mode 100644
index 0000000000..a4cd3edb3b
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/archive/2026-08-14-fix-combobox-multiselect-backspace-select-all/tasks.md
@@ -0,0 +1,35 @@
+## 1. Baseline
+
+- [x] 1.1 Confirm the existing unit suite is green before any change: `cd packages/pluggableWidgets/combobox-web && pnpm run test`
+- [x] 1.2 Get the Backspace reproduction and the Delete control BOTH executing against the running test project, using `e2e/WC-backspace-stale-diagnostic.spec.js` as the starting point — the Delete case has never been observed green (click timeout on refocus after blur). Fix the selectors/waits so the run shows Backspace failing and Delete passing.
+
+## 2. Fix the key handler
+
+- [x] 2.1 Add a local predicate in `src/components/MultiSelection/` replicating downshift 7.6.2's `isKeyDownOperationPermitted`: return false if `shiftKey || metaKey || ctrlKey || altKey`, and false if the target is an `HTMLInputElement` whose `value !== ""` and `(selectionStart !== 0 || selectionEnd !== 0)`. Comment it with the downshift source reference and version so a future upgrade re-checks it.
+- [x] 2.2 Require that predicate in the Backspace branch of the `onKeyDown` passed to `getInputProps` in `MultiSelection.tsx` (currently `event.key === "Backspace" && inputRef.current?.selectionStart === 0`).
+- [x] 2.3 Require the same predicate in the ArrowLeft branch (`isSelectedItemsBoxStyle` path), replacing its identical `selectionStart === 0` check.
+- [x] 2.4 Read the event's own target rather than reaching through `inputRef.current` where practical, so the guard evaluates the element that actually received the key.
+
+## 3. Unit coverage
+
+- [x] 3.1 Add unit tests (Jest + RTL) under `src/**/__tests__/` covering the multi-select key matrix from the spec: Backspace with full selection clears text and activates no chip; Backspace with empty input activates the last chip; Backspace with empty input and zero chips is a no-op; partial selection anchored at 0 removes only selected characters; Delete with full selection matches Backspace.
+- [x] 3.2 Add unit tests for ArrowLeft in "boxes" style: collapsed caret at 0 reaches the chips; active text selection does not.
+- [x] 3.3 Run `pnpm run test` and confirm all pass, including the pre-existing single-select Backspace behaviour.
+
+## 4. End-to-end regression
+
+- [x] 4.1 Promote the diagnostic into a proper regression test in `e2e/` covering the user-visible round trip: type filter text with chips present → select all → Backspace → click outside → click back in → input still empty. Follow `docs/requirements/e2e-test-guidelines.md` (including `window.mx.session.logout()` cleanup).
+- [x] 4.2 Cover the Delete path in the same regression test file so the asymmetry cannot silently return.
+- [x] 4.3 Delete the throwaway `e2e/WC-backspace-stale-diagnostic.spec.js` once its coverage lives in the regression test.
+- [x] 4.4 Run the widget's existing `e2e/Combobox.spec.js` to confirm nothing regressed — in particular the single-select "clears with backspace" and "types filter when selected" tests.
+
+## 5. Verify the fix
+
+- [x] 5.1 Build and deploy to the Studio Pro test project: `export MX_PROJECT_PATH=<combobox test project>` then `pnpm --filter @mendix/combobox-web run build`
+- [x] 5.2 Re-run the regression test against the deployed widget and confirm both the Backspace and Delete cases pass. If Backspace still fails, return to the design's mechanism section rather than guessing another fix.
+
+## 6. Release housekeeping
+
+- [x] 6.1 Bump 2.9.0 → 2.9.1 in `package.json` and in the `<clientModule version="2.9.0">` attribute in `src/package.xml` (leave the `version="1.0"` XML declaration alone), keeping the two in sync.
+- [x] 6.2 Add a user-facing entry under `## [Unreleased]` → `### Fixed` in `CHANGELOG.md` describing the behaviour only (e.g. selecting all text in a multi-select combobox and pressing Backspace now clears it permanently), with no implementation detail.
+- [x] 6.3 Confirm lint is clean for the touched package.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/.openspec.yaml b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/.openspec.yaml
new file mode 100644
index 0000000000..e685d45e5f
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-08-25
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/design.md b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/design.md
new file mode 100644
index 0000000000..77af57c1a4
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/design.md
@@ -0,0 +1,91 @@
+## Context
+
+Chip focus management is entirely downshift's job today. `MultiSelection` renders each selected item with `getSelectedItemProps({ selectedItem, index })` and passes nothing else; `useMultipleSelection` owns `activeIndex`, moves DOM focus, and sets the roving `tabIndex` (`isFocusable = index === activeIndex`).
+
+Two pieces of downshift 7.6.2 disagree about removal.
+
+**The reducer keeps `activeIndex` unchanged for a non-last chip** (`node_modules/downshift/dist/downshift.cjs.js:3557-3575`):
+
+```js
+case SelectedItemKeyDownBackspace:
+case SelectedItemKeyDownDelete: {
+    if (activeIndex < 0) break;
+    var newActiveIndex = activeIndex;
+    if (selectedItems.length === 1) {
+        newActiveIndex = -1;
+    } else if (activeIndex === selectedItems.length - 1) {
+        newActiveIndex = selectedItems.length - 2;
+    }
+    changes = { selectedItems: [...slice(0, activeIndex), ...slice(activeIndex + 1)], activeIndex: newActiveIndex };
+}
+```
+
+**The focus effect only reacts to a change in `activeIndex`** (`downshift.cjs.js:3699-3708`):
+
+```js
+react.useEffect(
+    function () {
+        if (isInitialMountRef.current) return;
+        if (activeIndex === -1 && dropdownRef.current) {
+            dropdownRef.current.focus();
+        } else if (selectedItemRefs.current[activeIndex]) {
+            selectedItemRefs.current[activeIndex].focus();
+        }
+    },
+    [activeIndex]
+);
+```
+
+So removing a middle chip produces the same `activeIndex`, the effect does not re-run, the focused chip's DOM node unmounts, and focus falls back to `<body>`. Removing the last chip changes `activeIndex` (`length-1 → length-2`), the effect re-runs, and the neighbour is focused — the asymmetry as reported. Removing the only chip yields `activeIndex === -1`, which the widget already handles by focusing the input (`src/hooks/useDownshiftMultiSelectProps.ts:63-69`).
+
+Note that `activeIndex` itself is _correct_ after the removal — it points at the item that shifted into the freed slot. Only the DOM focus is missing.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- After Backspace/Delete on any chip, keyboard focus stays inside the widget and lands on the chip downshift considers active, so arrow navigation and further removals continue without re-entering the widget.
+- Keep downshift as the single source of truth for `activeIndex` and the roving `tabIndex`; add focus restoration only.
+- Cover all three positions (first, middle, last) plus the single-chip case with tests, so the asymmetry cannot come back for a different position.
+
+**Non-Goals:**
+
+- Changing which keys reach the chips. The WC-3347 gating in the filter input's `onKeyDown` is untouched.
+- Changing focus behaviour for mouse removal via the chip's × button, where the user's focus expectation is different and no report exists.
+- Upgrading or patching downshift.
+- Reworking `activeIndex` bookkeeping, chip ordering, or `selectedItemsStyle`.
+
+## Decisions
+
+### 1. Restore focus in `MultiSelection`, not in the hook
+
+`useDownshiftMultiSelectProps` has no access to the chip DOM nodes — downshift keeps its own `selectedItemRefs` private and exposes no imperative "refocus" call. `MultiSelection` renders the chips, so it can hold its own node array via the `ref` option of `getSelectedItemProps` (downshift composes it through `handleRefs`, `downshift.cjs.js:125-137`) and focus the right one itself.
+
+_Why not the hook:_ passing DOM refs up into the hook only to focus them there adds indirection with no gain; the hook stays about state.
+
+### 2. Record the intent on the chip's `onKeyDown`, act in an effect keyed on the chip count
+
+`getSelectedItemProps` composes a caller-supplied `onKeyDown` before its own via `callAllEventHandlers`, so the widget sees the key first and can note "chip at index _i_ is being removed" in a ref. An effect keyed on `selectedItems.length` then focuses `chipRefs.current[Math.min(i, length - 1)]` once the removal has actually rendered, and clears the ref.
+
+`Math.min(i, length - 1)` reproduces downshift's `newActiveIndex` for every case — middle chip (`i`), last chip (`length - 2` after removal is the new last index), single chip (`-1`, handled as "focus the input"). Focusing the same element downshift targets means the two never fight, and the focused chip is the one that renders with `tabIndex=0`.
+
+_Why key the effect on `length` rather than the `selectedItems` array:_ `selectedItems` is `selector.currentId ?? []`, which can be a fresh array on any render. Keying on the count makes the effect fire on the removal itself, not on an unrelated re-render where the removed chip is still mounted (which would focus the node that is about to unmount and then clear the ref, reproducing the bug).
+
+_Why `useEffect` and not `useLayoutEffect`:_ effects run in declaration order within a component, and downshift's focus effect is declared inside the hook call, i.e. before ours. Passive-vs-passive means ours runs last and wins; a layout effect would run _before_ downshift's and could be overridden.
+
+_Alternatives considered:_
+
+- **Nudge `activeIndex` to force downshift's effect** (`setActiveIndex(-1)` then back). Fires the effect twice, momentarily focuses the input, and emits misleading a11y status changes. Rejected.
+- **Take over removal entirely** — handle Backspace/Delete on the chip, `preventDownshiftDefault`, call `removeSelectedItem` and `setActiveIndex` ourselves. `removeSelectedItem` (`FunctionRemoveSelectedItem`, `downshift.cjs.js:3596-3613`) computes the same index the same way, so `setActiveIndex` to an unchanged value is a no-op state update and the effect still would not fire. More code, same bug. Rejected.
+- **Focus the chip from the keydown handler with a `requestAnimationFrame`/`setTimeout`.** Works by accident of timing and is untestable without fake timers. Rejected in favour of the render-driven effect.
+
+### 3. Fall back to the filter input when no chips remain
+
+The hook's `onStateChange` already focuses the input when `activeIndex === -1`, but the same branch in the new effect costs one line and makes `MultiSelection` correct on its own, independent of which of the two runs first.
+
+## Risks / Trade-offs
+
+- **Duplicating downshift's index arithmetic** → it is one `Math.min`, derived from the reducer quoted above; the unit tests pin all three positions, so a downshift change that alters the rule fails loudly rather than silently drifting. Comment it with the version reference, as the WC-3347 helper does.
+- **Ref array staleness** → inline `ref` callbacks are re-invoked on every render (their identity changes), so the array is rebuilt each time; the focus lookup is still bounds-checked and null-safe rather than trusting the array length.
+- **Mendix may apply `selector.setValue` asynchronously** → the effect is driven by the rendered chip count, not by the keystroke, so a deferred update just means the effect fires later, on the render that actually removes the chip.
+- **jsdom focus fidelity** → RTL asserts `document.activeElement`, which jsdom models for programmatic `.focus()`; the e2e case covers the real browser round trip including continued arrow navigation.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/proposal.md b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/proposal.md
new file mode 100644
index 0000000000..643ad38540
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/proposal.md
@@ -0,0 +1,29 @@
+## Why
+
+In a multi-select Combobox with "boxes" selected-items style, a user can walk the selected chips with the arrow keys and remove them with Backspace/Delete. Removing the **last** chip in the row works as expected: the neighbouring chip becomes active and navigation continues. Removing any **other** chip drops keyboard focus out of the widget entirely — focus falls back to the document body, so the next arrow key or Tab starts over from the top of the page and the user has to find their way back into the combobox.
+
+Reported as a UX follow-up to WC-3347 while verifying the chip-navigation fix on the same branch. The inconsistency is the giveaway: the same keystroke on two chips one position apart behaves differently, which reads as the widget losing track of the user.
+
+## What Changes
+
+- Removing a selected chip with Backspace or Delete keeps keyboard focus inside the widget: focus moves to the chip that takes the removed chip's place (or, when the removed chip was last, to the chip on its left), so arrow-key navigation continues from there.
+- Removing the only remaining chip continues to return focus to the filter input, as it does today.
+- Behaviour is unchanged for the keys that reach the chips (the WC-3347 gating rules stay as they are) and for chip removal via the chip's × button with the mouse.
+
+## Capabilities
+
+### New Capabilities
+
+<!-- None. -->
+
+### Modified Capabilities
+
+- `multiselect-keyboard-interaction`: adds a requirement covering where keyboard focus lands **after** a chip is removed. The existing requirements describe only how a key reaches the chips, not what happens once one is deleted.
+
+## Impact
+
+- **Code**: `src/components/MultiSelection/MultiSelection.tsx` — the chip rendering block and the props passed into `getSelectedItemProps`. No change to `src/hooks/useDownshiftMultiSelectProps.ts`, whose `onStateChange` already handles the "list became empty" case.
+- **Not affected**: `SingleSelection` (no chips), the filter input's own `onKeyDown` gating, the menu, and mouse-driven removal.
+- **Tests**: unit coverage in `src/__tests__/MultiSelection.spec.tsx` (extending the existing WC-3347 describe block, which already has chip helpers), plus an e2e case in `e2e/ComboboxMultiSelectionKeys.spec.js`.
+- **Release**: user-facing entry under `## [Unreleased]` → `### Fixed` in `CHANGELOG.md`. No version bump — versions are bumped at release time.
+- **Dependencies**: none. Downshift stays on `^7.6.2`.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/specs/multiselect-keyboard-interaction/spec.md b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/specs/multiselect-keyboard-interaction/spec.md
new file mode 100644
index 0000000000..a05e1e185e
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/specs/multiselect-keyboard-interaction/spec.md
@@ -0,0 +1,30 @@
+## ADDED Requirements
+
+### Requirement: Keyboard focus survives chip removal
+
+When a selected item (chip) is removed with Backspace or Delete while it holds keyboard focus, focus SHALL remain inside the Combobox. Focus SHALL move to the chip that takes the removed chip's position, or to the chip to its left when the removed chip was the last one, matching the item the widget marks as active. When the removed chip was the only one, focus SHALL move to the filter input. Arrow-key navigation SHALL continue from the newly focused chip without the user re-entering the widget.
+
+#### Scenario: Removing a chip in the middle of the row keeps focus on the row
+
+- **WHEN** a multi-select Combobox has three or more selected chips, the user has moved keyboard focus to a chip that is neither the first nor the last, and presses Backspace or Delete
+- **THEN** that chip is removed and keyboard focus moves to the chip that took its position, so the next ArrowLeft/ArrowRight press continues navigating the chips
+
+#### Scenario: Removing the first chip keeps focus on the row
+
+- **WHEN** a multi-select Combobox has two or more selected chips, keyboard focus is on the first chip, and the user presses Backspace or Delete
+- **THEN** that chip is removed and keyboard focus moves to the chip that became the first one
+
+#### Scenario: Removing the last chip keeps focus on the row
+
+- **WHEN** a multi-select Combobox has two or more selected chips, keyboard focus is on the last chip, and the user presses Backspace or Delete
+- **THEN** that chip is removed and keyboard focus moves to the chip on its left
+
+#### Scenario: Removing the only chip returns focus to the filter input
+
+- **WHEN** a multi-select Combobox has exactly one selected chip, keyboard focus is on it, and the user presses Backspace or Delete
+- **THEN** the chip is removed and keyboard focus moves to the filter input
+
+#### Scenario: Focus is never dropped to the page
+
+- **WHEN** a chip is removed by keyboard in any of the situations above
+- **THEN** keyboard focus is never left on the document body, so pressing Tab afterwards continues from within the Combobox rather than from the start of the page
diff --git a/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/tasks.md b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/tasks.md
new file mode 100644
index 0000000000..d6e4611860
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/changes/fix-combobox-chip-focus-after-removal/tasks.md
@@ -0,0 +1,44 @@
+## 1. Baseline
+
+- [x] 1.1 Confirm the unit suite is green before any change: `cd packages/pluggableWidgets/combobox-web && pnpm run test`
+- [x] 1.2 Write a failing unit test first: with three chips in "boxes" style, focus a middle chip, press Delete, and assert `document.activeElement` is the chip that took its place. Confirm it fails with focus on `document.body`, which is the reported defect.
+    - Note: the mocked `ReferenceSetValue` updates in place instead of pushing new props, and `selector.currentId` is only recomputed when `Combobox` re-renders (`useGetSelector` calls `updateProps` during render). The tests therefore call `component.rerender(...)` after the keystroke to model the Mendix client feeding the new value back in — that re-render is what unmounts the chip.
+
+## 2. Restore focus after keyboard removal
+
+- [x] 2.1 In `src/components/MultiSelection/MultiSelection.tsx`, add a chip node array ref populated through the `ref` option of `getSelectedItemProps`, alongside downshift's own ref (downshift composes both via `handleRefs`).
+- [x] 2.2 Pass an `onKeyDown` into `getSelectedItemProps` that records the chip's index in a ref when the key is `Backspace` or `Delete`. It must not call `preventDefault` or set `preventDownshiftDefault` — downshift still performs the removal.
+- [x] 2.3 Add a `useEffect` keyed on the chip count that, when an index was recorded, focuses the chip at `Math.min(index, count - 1)`, focuses the filter input when no chips remain, and clears the recorded index. Bounds-check and null-check the lookup.
+- [x] 2.4 Comment the index arithmetic with the downshift 7.6.2 reducer reference (`SelectedItemKeyDownBackspace`/`Delete`, `dist/downshift.cjs.js`) so a downshift upgrade re-checks it, matching the convention of the existing `isChipNavigationPermitted` helper.
+
+## 3. Unit coverage
+
+- [x] 3.1 Extend `src/__tests__/MultiSelection.spec.tsx` with a `focus after keyboard chip removal` describe block whose setup renders the widget with three pre-selected items in "boxes" style.
+- [x] 3.2 Cover, for both `Backspace` and `Delete` via `it.each`: first chip, middle chip and last chip removal each leave focus on the expected remaining chip.
+- [x] 3.3 Cover removal of the only chip returning focus to the filter input.
+- [x] 3.4 Assert in each case that `document.activeElement` is not `document.body`, which is the specific regression.
+- [x] 3.5 Run `pnpm run test` and confirm the whole suite passes, including the pre-existing WC-3347 cases. — 61 tests, 6 suites, all green.
+- [x] 3.6 Confirm the new tests fail without the fix: stashing only `MultiSelection.tsx` fails the middle-chip, first-chip and continued-navigation cases while the last-chip and only-chip cases still pass, matching the reported asymmetry.
+
+## 4. End-to-end regression
+
+- [x] 4.1 Add a case to `e2e/ComboboxMultiSelectionKeys.spec.js` on `.mx-name-comboBox4`: select three options, ArrowLeft from the empty filter input into the chips, ArrowLeft again to reach a non-last chip, press Delete, and assert the focused element is still a `.widget-combobox-selected-item`.
+- [x] 4.2 In the same case, press ArrowLeft once more and assert navigation continues (the focused chip changes), proving focus was genuinely restored to the chip row.
+- [x] 4.3 Follow `docs/requirements/e2e-test-guidelines.md` for structure, waits and cleanup; verified with the `eslint-plugin-playwright` rules from `automation/run-e2e/eslint.config.mjs` (clean).
+- [ ] 4.4 Run `e2e/Combobox.spec.js` and `e2e/ComboboxMultiSelectionKeys.spec.js` (`pnpm run e2e`) to confirm the new case passes and the WC-3347 cases do not regress. **First run done in CI: 18 passed, 6 failed** — all 6 in `ComboboxMultiSelectionKeys.spec.js`, and both root causes were in the tests rather than the widget (see 4.8 and 4.9). Needs a re-run after those fixes; cannot be run locally, as no Mendix `mxbuild`/`mxruntime` images are cached here and `run-e2e` has no spec filter.
+- [x] 4.5 Fix the arrange step of 4.1: `.mx-name-comboBox4` ships with three options already selected on the test page (see the `comboBoxAssociationRowClick` baseline and the `nth(3)` clear button in `Combobox.spec.js`), so asserting a chip count of 1 after the first click could never pass. Clear the widget first, then select from the top, via a shared `selectChips` helper.
+- [x] 4.6 Cover the remaining scenarios of the requirement in e2e: removing the only chip returns focus to the filter input (both keys), and Backspace on an empty filter input still reaches the last chip and removes it on the second press — the shortcut the WC-3347 gating rewrite is closest to breaking.
+- [x] 4.7 Cover the WC-3347 partial-selection scenario in e2e as well: it asserts that the unselected tail of the text survives, which jsdom cannot verify because it does not perform native text deletion.
+- [x] 4.8 Fix the four chip-navigation cases that failed in CI with chips silently dropping from 3 to 0 and `.mx-name-comboBox4 input` reported as not found: each pressed Escape first to close the menu. These specs run on a popup page (`.mx-name-actionButton1`), the Mendix client closes that popup on Escape, and downshift's input Escape handler only calls `preventDefault()` without stopping propagation, so the widget left the DOM mid-test. Escape is not needed at all — picking an option already leaves the filter input focused (`MultiSelection`'s `onOptionClick`), which `selectChips` now asserts as a postcondition.
+- [x] 4.9 Fix the partial-selection case that failed in CI on `locator.click: element is not visible`: an empty, unfocused filter input is `max-width: 0` (`src/ui/Combobox.scss`). Focus it by opening the menu instead — downshift focuses the input whenever the menu opens without it already being focused (`useCombobox`'s `[isOpen]` effect, downshift 7.6.2) — clicking the down arrow rather than the input container, since a centre click on the container can land on a chip.
+- [x] 4.10 Record both traps in `docs/requirements/e2e-test-guidelines.md`, since neither is combobox-specific.
+
+## 5. Verify against a running app
+
+- [x] 5.1 Build the widget to type-check the change: `pnpm run build` (clean).
+- [ ] 5.2 Deploy to the Studio Pro test project (`export MX_PROJECT_PATH=<combobox test project>`), then manually walk the chips with the arrow keys and delete the first, a middle and the last chip, confirming focus stays on the chip row each time and that a subsequent arrow key continues navigation.
+
+## 6. Release housekeeping
+
+- [x] 6.1 Add a user-facing entry under `## [Unreleased]` → `### Fixed` in `CHANGELOG.md` describing the behaviour only, with no implementation detail. No version bump — versions are bumped at release time.
+- [x] 6.2 Confirm lint is clean for the touched package: `pnpm run lint` reports 0 errors and no warnings in the touched files.
diff --git a/packages/pluggableWidgets/combobox-web/openspec/specs/multiselect-keyboard-interaction/spec.md b/packages/pluggableWidgets/combobox-web/openspec/specs/multiselect-keyboard-interaction/spec.md
new file mode 100644
index 0000000000..0dc9d9cbd1
--- /dev/null
+++ b/packages/pluggableWidgets/combobox-web/openspec/specs/multiselect-keyboard-interaction/spec.md
@@ -0,0 +1,68 @@
+# multiselect-keyboard-interaction Specification
+
+## Purpose
+
+TBD - created by archiving change fix-combobox-multiselect-backspace-select-all. Update Purpose after archive.
+
+## Requirements
+
+### Requirement: Filter input text editing takes precedence over chip navigation
+
+In a multi-select Combobox, keys pressed while the filter input holds an active (non-collapsed) text selection SHALL act on that text and MUST NOT transfer keyboard focus to the selected items (chips). Focus transfer to chips SHALL be permitted only when the filter input is empty, or when the caret is collapsed at position 0, and no modifier key (Shift, Control, Meta, Alt) is held — matching the gating downshift applies to its own dropdown key handling.
+
+#### Scenario: Backspace deletes a full text selection instead of activating a chip
+
+- **WHEN** a multi-select Combobox has at least one selected chip, the user has typed filter text, selected all of it (Ctrl/Cmd+A), and presses Backspace
+- **THEN** the filter input is cleared, keyboard focus remains in the filter input, and no chip becomes active
+
+#### Scenario: Cleared text does not reappear after leaving and re-entering the widget
+
+- **WHEN** the user has cleared a full text selection with Backspace, then clicks outside the Combobox and clicks back into the filter input
+- **THEN** the filter input is still empty
+
+#### Scenario: Delete behaves identically to Backspace on a full text selection
+
+- **WHEN** a multi-select Combobox has at least one selected chip, the user has typed filter text, selected all of it, and presses Delete
+- **THEN** the filter input is cleared, it remains empty after clicking outside and back in, and no chip becomes active
+
+#### Scenario: Partial text selection is not treated as chip navigation
+
+- **WHEN** the user selects part of the filter text starting at position 0 (leaving trailing text unselected) and presses Backspace
+- **THEN** only the selected characters are removed, the remaining text is preserved, and no chip becomes active
+
+### Requirement: Backspace on an empty filter input activates the last selected chip
+
+Chip removal by keyboard SHALL remain available: when the filter input is empty, Backspace SHALL make the last selected chip the active item so it can be removed. This behaviour is unchanged by the text-editing precedence rule above.
+
+#### Scenario: Backspace with an empty filter input targets the last chip
+
+- **WHEN** a multi-select Combobox has one or more selected chips and the filter input is empty, and the user presses Backspace
+- **THEN** the last selected chip becomes the active item
+
+#### Scenario: Backspace with an empty filter input and no chips does nothing
+
+- **WHEN** a multi-select Combobox has no selected chips and the filter input is empty, and the user presses Backspace
+- **THEN** no chip is activated and the widget state is unchanged
+
+### Requirement: ArrowLeft chip navigation requires a collapsed caret
+
+In "boxes" selected-items style, ArrowLeft SHALL move focus to the last selected chip only when the caret is collapsed at position 0. When an active text selection exists, ArrowLeft SHALL follow standard text-field behaviour and MUST NOT transfer focus to the chips.
+
+#### Scenario: ArrowLeft with a collapsed caret at the start reaches the chips
+
+- **WHEN** the selected-items style is "boxes", the caret sits collapsed at position 0 of the filter input, and the user presses ArrowLeft
+- **THEN** the last selected chip becomes the active item
+
+#### Scenario: ArrowLeft with an active text selection stays in the filter input
+
+- **WHEN** the selected-items style is "boxes", the filter text is fully selected, and the user presses ArrowLeft
+- **THEN** keyboard focus remains in the filter input and no chip becomes active
+
+### Requirement: Single-select behaviour is unaffected
+
+The single-select Combobox SHALL continue to clear its selection when Backspace is pressed with an empty filter input, unchanged by this change.
+
+#### Scenario: Single-select clear-with-Backspace still works
+
+- **WHEN** a clearable single-select Combobox has a selected value and the user presses Backspace with an empty filter input
+- **THEN** the selection is cleared and the placeholder is shown
diff --git a/packages/pluggableWidgets/combobox-web/src/__tests__/MultiSelection.spec.tsx b/packages/pluggableWidgets/combobox-web/src/__tests__/MultiSelection.spec.tsx
index a665983f33..ee7264f1b3 100644
--- a/packages/pluggableWidgets/combobox-web/src/__tests__/MultiSelection.spec.tsx
+++ b/packages/pluggableWidgets/combobox-web/src/__tests__/MultiSelection.spec.tsx
@@ -170,6 +170,270 @@ describe("Combo box (Association)", () => {
         expect(defaultProps.attributeAssociation?.value).toHaveLength(4);
     });
 
+    describe("filter input keys vs chip navigation (WC-3347)", () => {
+        // These assert WHERE the key goes: text editing in the filter input, or focus
+        // transfer to the selected items (chips). jsdom does not perform native text
+        // deletion on keyDown, so chip activation is the observable under test.
+        async function setup(
+            overrides: Partial<ComboboxContainerProps> = {}
+        ): Promise<{ component: RenderResult; input: HTMLInputElement }> {
+            const component = render(<Combobox {...defaultProps} selectedItemsStyle="boxes" {...overrides} />);
+            const input = await getInput(component);
+            fireEvent.click(input);
+            await waitFor(() => {
+                expect(component.getAllByRole("option")).toHaveLength(4);
+            });
+            return { component, input };
+        }
+
+        function chips(component: RenderResult): HTMLElement[] {
+            return Array.from(
+                component.container.getElementsByClassName("widget-combobox-selected-item")
+            ) as HTMLElement[];
+        }
+
+        function type(input: HTMLInputElement, value: string): void {
+            fireEvent.change(input, { target: { value } });
+        }
+
+        it.each(["Backspace", "Delete"])(
+            "keeps focus in the filter input when %s is pressed with all text selected",
+            async key => {
+                const { component, input } = await setup();
+                type(input, "zzz");
+                expect(input.value).toBe("zzz");
+                input.setSelectionRange(0, 3);
+
+                fireEvent.keyDown(input, { key });
+
+                expect(document.activeElement).toBe(input);
+                expect(chips(component).some(chip => chip === document.activeElement)).toBe(false);
+            }
+        );
+
+        it("keeps focus in the filter input when Backspace is pressed with a partial selection from position 0", async () => {
+            const { component, input } = await setup();
+            type(input, "zzz");
+            input.setSelectionRange(0, 2);
+
+            fireEvent.keyDown(input, { key: "Backspace" });
+
+            expect(document.activeElement).toBe(input);
+            expect(chips(component).some(chip => chip === document.activeElement)).toBe(false);
+        });
+
+        it("keeps focus in the filter input when Backspace is pressed with the caret at the end of the text", async () => {
+            const { component, input } = await setup();
+            type(input, "zzz");
+            input.setSelectionRange(3, 3);
+
+            fireEvent.keyDown(input, { key: "Backspace" });
+
+            expect(document.activeElement).toBe(input);
+            expect(chips(component).some(chip => chip === document.activeElement)).toBe(false);
+        });
+
+        it("activates the last chip when Backspace is pressed with an empty filter input", async () => {
+            const { component, input } = await setup();
+            expect(input.value).toBe("");
+            input.setSelectionRange(0, 0);
+
+            fireEvent.keyDown(input, { key: "Backspace" });
+
+            const allChips = chips(component);
+            expect(allChips).toHaveLength(1);
+            await waitFor(() => {
+                expect(document.activeElement).toBe(allChips[allChips.length - 1]);
+            });
+        });
+
+        it("does not throw when Backspace is pressed with an empty filter input and no chips", async () => {
+            const { component, input } = await setup({
+                attributeAssociation: new ReferenceSetValueBuilder().withValue([]).build()
+            });
+            expect(chips(component)).toHaveLength(0);
+
+            expect(() => fireEvent.keyDown(input, { key: "Backspace" })).not.toThrow();
+        });
+
+        it("does not activate a chip when a modifier key is held", async () => {
+            const { component, input } = await setup();
+            input.setSelectionRange(0, 0);
+
+            fireEvent.keyDown(input, { key: "Backspace", ctrlKey: true });
+
+            expect(chips(component).some(chip => chip === document.activeElement)).toBe(false);
+        });
+
+        it("activates the last chip on ArrowLeft with a collapsed caret at position 0 in boxes style", async () => {
+            const { component, input } = await setup();
+            type(input, "zzz");
+            input.setSelectionRange(0, 0);
+
+            fireEvent.keyDown(input, { key: "ArrowLeft" });
+
+            const allChips = chips(component);
+            await waitFor(() => {
+                expect(document.activeElement).toBe(allChips[allChips.length - 1]);
+            });
+        });
+
+        it("keeps focus in the filter input on ArrowLeft when text is selected in boxes style", async () => {
+            const { component, input } = await setup();
+            type(input, "zzz");
+            input.setSelectionRange(0, 3);
+
+            fireEvent.keyDown(input, { key: "ArrowLeft" });
+
+            expect(document.activeElement).toBe(input);
+            expect(chips(component).some(chip => chip === document.activeElement)).toBe(false);
+        });
+    });
+
+    describe("focus after keyboard chip removal", () => {
+        // downshift only re-focuses a chip when its own activeIndex changes, which it does
+        // not when a chip other than the last one is removed. These assert that focus stays
+        // on the chip row instead of dropping to document.body.
+        interface Setup {
+            component: RenderResult;
+            input: HTMLInputElement;
+            /**
+             * The mocked reference set updates its value in place instead of pushing new
+             * props, so re-render the widget to model the Mendix client feeding the new
+             * value back in — which is what removes the chip from the DOM.
+             */
+            applyValueChange: () => void;
+        }
+
+        async function setup(objectIds: string[]): Promise<Setup> {
+            const props: ComboboxContainerProps = {
+                ...defaultProps,
+                selectedItemsStyle: "boxes",
+                attributeAssociation: new ReferenceSetValueBuilder().withValue(objectIds.map(obj)).build()
+            };
+            const component = render(<Combobox {...props} />);
+            const input = await getInput(component);
+            return {
+                component,
+                input,
+                applyValueChange: () => component.rerender(<Combobox {...props} />)
+            };
+        }
+
+        function chips(component: RenderResult): HTMLElement[] {
+            return Array.from(
+                component.container.getElementsByClassName("widget-combobox-selected-item")
+            ) as HTMLElement[];
+        }
+
+        function captions(component: RenderResult): string[] {
+            return chips(component).map(chip => chip.textContent ?? "");
+        }
+
+        /** Walks from the filter input onto the chip at `index`, the way a keyboard user does. */
+        async function focusChip(component: RenderResult, input: HTMLInputElement, index: number): Promise<void> {
+            input.setSelectionRange(0, 0);
+            fireEvent.keyDown(input, { key: "ArrowLeft" });
+            const allChips = chips(component);
+            await waitFor(() => {
+                expect(document.activeElement).toBe(allChips[allChips.length - 1]);
+            });
+
+            for (let current = allChips.length - 1; current > index; current--) {
+                fireEvent.keyDown(document.activeElement!, { key: "ArrowLeft" });
+                const expected = chips(component)[current - 1];
+                await waitFor(() => {
+                    expect(document.activeElement).toBe(expected);
+                });
+            }
+        }
+
+        it.each(["Backspace", "Delete"])(
+            "moves focus to the chip that took its place when %s removes a middle chip",
+            async key => {
+                const { component, input, applyValueChange } = await setup(["111", "222", "333"]);
+                await focusChip(component, input, 1);
+
+                fireEvent.keyDown(document.activeElement!, { key });
+                applyValueChange();
+
+                expect(captions(component)).toEqual(["obj_111", "obj_333"]);
+                await waitFor(() => {
+                    expect(document.activeElement).toBe(chips(component)[1]);
+                });
+                expect(document.activeElement).not.toBe(document.body);
+            }
+        );
+
+        it.each(["Backspace", "Delete"])(
+            "moves focus to the new first chip when %s removes the first chip",
+            async key => {
+                const { component, input, applyValueChange } = await setup(["111", "222", "333"]);
+                await focusChip(component, input, 0);
+
+                fireEvent.keyDown(document.activeElement!, { key });
+                applyValueChange();
+
+                expect(captions(component)).toEqual(["obj_222", "obj_333"]);
+                await waitFor(() => {
+                    expect(document.activeElement).toBe(chips(component)[0]);
+                });
+                expect(document.activeElement).not.toBe(document.body);
+            }
+        );
+
+        it.each(["Backspace", "Delete"])(
+            "moves focus to the left neighbour when %s removes the last chip",
+            async key => {
+                const { component, input, applyValueChange } = await setup(["111", "222", "333"]);
+                await focusChip(component, input, 2);
+
+                fireEvent.keyDown(document.activeElement!, { key });
+                applyValueChange();
+
+                expect(captions(component)).toEqual(["obj_111", "obj_222"]);
+                await waitFor(() => {
+                    expect(document.activeElement).toBe(chips(component)[1]);
+                });
+                expect(document.activeElement).not.toBe(document.body);
+            }
+        );
+
+        it.each(["Backspace", "Delete"])(
+            "returns focus to the filter input when %s removes the only chip",
+            async key => {
+                const { component, input, applyValueChange } = await setup(["111"]);
+                await focusChip(component, input, 0);
+
+                fireEvent.keyDown(document.activeElement!, { key });
+                applyValueChange();
+
+                expect(chips(component)).toHaveLength(0);
+                await waitFor(() => {
+                    expect(document.activeElement).toBe(input);
+                });
+            }
+        );
+
+        it("keeps chip navigation working after a middle chip is removed", async () => {
+            const { component, input, applyValueChange } = await setup(["111", "222", "333"]);
+            await focusChip(component, input, 1);
+
+            fireEvent.keyDown(document.activeElement!, { key: "Delete" });
+            applyValueChange();
+            expect(captions(component)).toEqual(["obj_111", "obj_333"]);
+            await waitFor(() => {
+                expect(document.activeElement).toBe(chips(component)[1]);
+            });
+
+            fireEvent.keyDown(document.activeElement!, { key: "ArrowLeft" });
+
+            await waitFor(() => {
+                expect(document.activeElement).toBe(chips(component)[0]);
+            });
+        });
+    });
+
     describe("with lazy loading", () => {
         it("calls loadMore only when menu opens", async () => {
             const setLimit = jest.fn();
diff --git a/packages/pluggableWidgets/combobox-web/src/components/MultiSelection/MultiSelection.tsx b/packages/pluggableWidgets/combobox-web/src/components/MultiSelection/MultiSelection.tsx
index 294a722b36..86907e007b 100644
--- a/packages/pluggableWidgets/combobox-web/src/components/MultiSelection/MultiSelection.tsx
+++ b/packages/pluggableWidgets/combobox-web/src/components/MultiSelection/MultiSelection.tsx
@@ -1,5 +1,5 @@
 import classNames from "classnames";
-import { Fragment, KeyboardEvent, ReactElement, useMemo, useRef } from "react";
+import { Fragment, KeyboardEvent, ReactElement, useEffect, useMemo, useRef } from "react";
 import { ClearButton } from "../../assets/icons";
 import { MultiSelector, SelectionBaseProps } from "../../helpers/types";
 import { getInputLabel, getSelectedCaptionsPlaceholder, getValidationErrorId } from "../../helpers/utils";
@@ -11,6 +11,33 @@ import { InputPlaceholder } from "../Placeholder";
 import { MultiSelectionMenu } from "./MultiSelectionMenu";
 import { SelectAllButton } from "./SelectAllButton";
 
+/**
+ * Whether a key press in the filter input may be redirected to the selected items (chips)
+ * instead of being handled as text editing.
+ *
+ * Mirrors downshift's own `isKeyDownOperationPermitted` (downshift 7.6.2,
+ * dist/downshift.cjs.js), which gates its dropdown key handlers but is not exported.
+ * Keeping the same rule here stops the widget and the library from disagreeing about
+ * whether a key belongs to the text field or to the chip list.
+ *
+ * Re-check this against downshift's implementation when upgrading downshift.
+ */
+function isChipNavigationPermitted(event: KeyboardEvent): boolean {
+    if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) {
+        return false;
+    }
+
+    const element = event.target;
+
+    // Text still present and the caret is either not at the start or is highlighting a
+    // range (e.g. after select-all) -> the key belongs to the text field.
+    return !(
+        element instanceof HTMLInputElement &&
+        element.value !== "" &&
+        (element.selectionStart !== 0 || element.selectionEnd !== 0)
+    );
+}
+
 export function MultiSelection({
     selector,
     tabIndex,
@@ -20,6 +47,10 @@ export function MultiSelection({
     ...options
 }: SelectionBaseProps<MultiSelector>): ReactElement {
     const inputRef = useRef<HTMLInputElement>(null);
+    /** Chip DOM nodes by index, so focus can be restored after a chip is removed. */
+    const chipRefs = useRef<Array<HTMLElement | null>>([]);
+    /** Index of the chip a Backspace/Delete press is about to remove, or null. */
+    const chipToRefocusRef = useRef<number | null>(null);
     const {
         isOpen,
         getToggleButtonProps,
@@ -58,8 +89,8 @@ export function MultiSelection({
         ref: inputRef,
         onKeyDown: (event: KeyboardEvent) => {
             if (
-                (event.key === "Backspace" && inputRef.current?.selectionStart === 0) ||
-                (event.key === "ArrowLeft" && isSelectedItemsBoxStyle && inputRef.current?.selectionStart === 0)
+                isChipNavigationPermitted(event) &&
+                (event.key === "Backspace" || (event.key === "ArrowLeft" && isSelectedItemsBoxStyle))
             ) {
                 setActiveIndex(selectedItems.length - 1);
             }
@@ -77,6 +108,39 @@ export function MultiSelection({
         "aria-label": !hasLabel && options.ariaLabel ? options.ariaLabel : undefined
     });
 
+    /**
+     * Keeps keyboard focus on the selected items when one of them is removed with
+     * Backspace/Delete.
+     *
+     * downshift removes the chip but only moves DOM focus when its own `activeIndex`
+     * changes: its `SelectedItemKeyDownBackspace`/`SelectedItemKeyDownDelete` reducer
+     * (downshift 7.6.2, dist/downshift.cjs.js) keeps `activeIndex` unchanged for every chip
+     * except the last one, while its focus effect depends on `[activeIndex]`. So removing a
+     * chip from anywhere but the end unmounts the focused element without focusing anything
+     * else, and focus falls back to the document body.
+     *
+     * `Math.min(index, count - 1)` reproduces downshift's new `activeIndex` for every
+     * position, so this focuses the element downshift also marks as active (tabIndex 0).
+     *
+     * Re-check this against downshift's implementation when upgrading downshift.
+     */
+    useEffect(() => {
+        const removedIndex = chipToRefocusRef.current;
+        if (removedIndex === null) {
+            return;
+        }
+        chipToRefocusRef.current = null;
+        const indexToFocus = Math.min(removedIndex, selectedItems.length - 1);
+        if (indexToFocus < 0) {
+            inputRef.current?.focus();
+            return;
+        }
+        chipRefs.current[indexToFocus]?.focus();
+        // Keyed on the number of chips so this runs on the render that actually removes the
+        // chip: `selectedItems` can be a new array on any render, and running earlier would
+        // focus the node that is about to unmount.
+    }, [selectedItems.length]);
+
     const memoizedselectedCaptions = useMemo(
         () => getSelectedCaptionsPlaceholder(selector, selectedItems),
         [selector, selectedItems]
@@ -122,7 +186,17 @@ export function MultiSelection({
                                     key={selectedItemForRender}
                                     {...getSelectedItemProps({
                                         selectedItem: selectedItemForRender,
-                                        index
+                                        index,
+                                        ref: (node: HTMLElement | null) => {
+                                            chipRefs.current[index] = node;
+                                        },
+                                        onKeyDown: (event: KeyboardEvent) => {
+                                            // downshift removes the chip after this handler runs; remember
+                                            // which slot keyboard focus must return to once that renders.
+                                            if (event.key === "Backspace" || event.key === "Delete") {
+                                                chipToRefocusRef.current = index;
+                                            }
+                                        }
                                     })}
                                 >
                                     {selector.caption.render(selectedItemForRender, "label")}