diff --git a/common/web/input-processor/src/text/inputProcessor.ts b/common/web/input-processor/src/text/inputProcessor.ts
index 76d8b288f42..55f7a1e8b6b 100644
--- a/common/web/input-processor/src/text/inputProcessor.ts
+++ b/common/web/input-processor/src/text/inputProcessor.ts
@@ -107,8 +107,20 @@ export default class InputProcessor {
       if(keyEvent.baseTranscriptionToken) {
         const transcription = this.contextCache.get(keyEvent.baseTranscriptionToken);
         if(transcription) {
-          // Restores full context, including deadkeys in their exact pre-keystroke state.
-          outputTarget.restoreTo(transcription.preInput);
+          // Has there been a context change at any point during the multitap?  If so, we need
+          // to revert it.  If not, we assume it's a layer-change multitap, in which case
+          // no such reset is needed.
+          if(!isEmptyTransform(transcription.transform) || !transcription.preInput.isEqual(Mock.from(outputTarget))) {
+            // Restores full context, including deadkeys in their exact pre-keystroke state.
+            outputTarget.restoreTo(transcription.preInput);
+          }
+          /*
+            else:
+            1. We don't need to restore the original context, as it's already
+               in-place.
+            2. Restoring anyway would obliterate any selected text, which is bad
+               if this is a purely-layer-switching multitap.  (#11230)
+          */
         } else {
           console.warn('The base context for the multitap could not be found');
         }
diff --git a/common/web/keyboard-processor/src/text/deadkeys.ts b/common/web/keyboard-processor/src/text/deadkeys.ts
index e5b32a788fb..31bfa1100df 100644
--- a/common/web/keyboard-processor/src/text/deadkeys.ts
+++ b/common/web/keyboard-processor/src/text/deadkeys.ts
@@ -38,6 +38,10 @@ export class Deadkey {
     return dk;
   }
 
+  equal(other: Deadkey) {
+    return this.d == other.d && this.p == other.d && this.o == other.o;
+  }
+
   /**
    * Sorts the deadkeys in reverse order.
    */
@@ -151,6 +155,24 @@ export class DeadkeyTracker {
     }
   }
 
+  equal(other: DeadkeyTracker) {
+    if(this.dks.length != other.dks.length) {
+      return false;
+    }
+
+    const otherDks = other.dks;
+    const matchedDks: Deadkey[] = [];
+
+    for(let dk of this.dks) {
+      const match = otherDks.find((otherDk) => dk.equal(otherDk));
+      if(!match) {
+        return false;
+      }
+    }
+
+    return matchedDks.length == otherDks.length;
+  }
+
   count(): number {
     return this.dks.length;
   }
diff --git a/common/web/keyboard-processor/src/text/outputTarget.ts b/common/web/keyboard-processor/src/text/outputTarget.ts
index ef3a3d74e33..c7f42d8ee56 100644
--- a/common/web/keyboard-processor/src/text/outputTarget.ts
+++ b/common/web/keyboard-processor/src/text/outputTarget.ts
@@ -446,6 +446,18 @@ export class Mock extends OutputTarget {
     this.text = this.getTextBeforeCaret() + s;
   }
 
+  /**
+   * Indicates if this Mock represents an identical context to that of another Mock.
+   * @param other
+   * @returns
+   */
+  isEqual(other: Mock) {
+    return this.text == other.text
+      && this.selStart == other.selStart
+      && this.selEnd == other.selEnd
+      && this.deadkeys().equal(other.deadkeys());
+  }
+
   doInputEvent() {
     // Mock isn't backed by an element, so it won't have any event listeners.
   }