diff --git a/build/check-bundle-size.ts b/build/check-bundle-size.ts
index bd12f69f..80f80a0c 100644
--- a/build/check-bundle-size.ts
+++ b/build/check-bundle-size.ts
@@ -7,9 +7,9 @@ const BUDGET_BYTES: Record<string, number> = {
   ".css": 46_000,
   // Raised from 280 kB for the production Logitech onboard-profile codec,
   // guarded flash editor, verification exporter, upstream Finalmouse driver,
-  // the dedicated Viper Mini protocol driver, and Viper V3 sleep/low-power
-  // protocol support. Preview fixtures remain dev-only.
-  ".js": 320_000,
+  // the dedicated Viper Mini protocol driver, and Viper V3 sleep/low-power plus
+  // asymmetric lift-off protocol and controls. Preview fixtures remain dev-only.
+  ".js": 325_000,
 };
 
 const ASSETS = join("dist", "assets");
diff --git a/package-lock.json b/package-lock.json
index 2985c3aa..52f56e8a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -887,9 +887,9 @@
       }
     },
     "node_modules/nanoid": {
-      "version": "3.3.16",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
-      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "version": "3.3.18",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",
+      "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",
       "dev": true,
       "funding": [
         {
diff --git a/src/control-events.ts b/src/control-events.ts
index ecc74e21..658a1825 100644
--- a/src/control-events.ts
+++ b/src/control-events.ts
@@ -49,6 +49,9 @@ export interface ControlEventHandlers {
   applyFinalmouseSetting(setting: "dongleLed" | "tournamentScroll" | "tournamentTimeout", value: number): void;
   applyPollingRate(rate: number): void;
   applyLiftOffDistance(lod: NonNullable<MouseStatus["liftOffDistance"]>): void;
+  applyLiftOffMode(mode: "single" | "asymmetric"): void;
+  applyAsymmetricLiftOff(liftOff: number, landing: number): void;
+  capLandingToLiftOff(): void;
   applyGamingSurfaceMode(mode: NonNullable<MouseStatus["gamingSurfaceMode"]>): void;
   applyLightforceSwitchMode(mode: NonNullable<MouseStatus["lightforceSwitchMode"]>): void;
   // Mode and profile selection apply immediately: both are volatile navigation
@@ -226,6 +229,25 @@ export function bindControlEvents(handlers: ControlEventHandlers): void {
       if (lod) void handlers.applyLiftOffDistance(lod);
     });
   });
+  document.querySelectorAll<HTMLButtonElement>("[data-lod-mode]").forEach((button) => {
+    button.addEventListener("click", () => {
+      const mode = button.dataset.lodMode;
+      if (mode === "single" || mode === "asymmetric") handlers.applyLiftOffMode(mode);
+    });
+  });
+  const liftOffSlider = document.querySelector<HTMLInputElement>("#lod-lift-off");
+  const landingSlider = document.querySelector<HTMLInputElement>("#lod-landing");
+  for (const slider of [liftOffSlider, landingSlider]) {
+    // `input` keeps the readout and the landing ceiling honest while dragging;
+    // `change` fires on release, so a drag stages one change rather than thirty.
+    slider?.addEventListener("input", () => handlers.capLandingToLiftOff());
+    slider?.addEventListener("change", () => {
+      handlers.capLandingToLiftOff();
+      const liftOff = Number(liftOffSlider?.value);
+      const landing = Number(landingSlider?.value);
+      if (Number.isFinite(liftOff) && Number.isFinite(landing)) handlers.applyAsymmetricLiftOff(liftOff, landing);
+    });
+  }
   document.querySelectorAll<HTMLButtonElement>("[data-gaming-surface]").forEach((button) => {
     button.addEventListener("click", () => {
       const mode = button.dataset.gamingSurface as MouseStatus["gamingSurfaceMode"];
diff --git a/src/control-template.ts b/src/control-template.ts
index 268bcce6..417bfb8b 100644
--- a/src/control-template.ts
+++ b/src/control-template.ts
@@ -76,7 +76,7 @@ export function controlTemplate(buildLabel: string): string {
         <section class="settings-grid device-data" aria-label="Mouse status">
           <article class="setting-card dpi-card" data-pending-key="dpi"><div class="setting-heading"><div><p>DPI</p><h2>Sensitivity<span class="setting-scope" id="dpi-scope-badge" hidden></span></h2></div><div class="dpi-header-actions"><input id="dpi-output" type="text" inputmode="numeric" value="— DPI" aria-label="DPI value" readonly /><button id="custom-dpi" type="button" disabled>Custom</button></div></div><div id="dpi-presets" class="segmented dpi-presets" role="group" aria-label="Common DPI values"></div><div id="logitech-axis-controls" style="display:none"><div class="axis-grid"><label>X axis<input id="logitech-dpi-x" type="number" min="100" step="50" /></label><label>Y axis<input id="logitech-dpi-y" type="number" min="100" step="50" /></label><button id="apply-logitech-axes" class="axis-apply" type="button">Apply</button></div></div><div id="logitech-dpi-slots" hidden><div class="dpi-slot-header"><span>Slots in use</span><div id="dpi-slot-count" class="dpi-slot-count" role="group" aria-label="Number of DPI slots"></div></div><div class="dpi-slot-rule"></div><div id="dpi-slot-list" class="dpi-slot-list"></div><small id="dpi-slot-note" class="setting-note"></small></div><div class="setting-action"><span id="dpi-pending">Choose a DPI value</span></div></article>
           <article id="polling-card" class="setting-card" data-pending-key="polling-rate"><div class="setting-heading"><div><p>POLLING RATE</p><h2>Report frequency<span class="setting-scope" id="rate-scope-badge" hidden></span></h2></div></div><div id="profile-rate-rows" hidden><div id="profile-rate-wireless" class="rate-slider" data-rate-link="wireless"></div><div id="profile-rate-wired" class="rate-slider" data-rate-link="wired"></div></div><div id="host-rate-slider" class="rate-slider"></div><small id="polling-note" class="setting-note">Higher rates update cursor movement more often, but use more battery.</small></article>
-          <article class="setting-card" data-pending-key="lift-off-distance gaming-surface"><div class="setting-heading tight"><div><p>SENSOR</p></div></div><div id="gaming-surface-row" hidden><div class="setting-heading"><div><h2>Gaming surface</h2></div></div><div class="segmented three" role="group" aria-label="Gaming surface"><button data-gaming-surface="On" disabled>On</button><button data-gaming-surface="Off" disabled>Off</button><button data-gaming-surface="Auto" disabled>Auto</button></div><small class="setting-note">Tunes the sensor for gaming mouse pads. Auto lets the mouse decide; turn it off if tracking misbehaves on a non-gaming surface.</small></div><div id="host-lod-row"><div class="setting-heading"><div><h2>Lift-off distance</h2></div></div><div class="segmented three" role="group" aria-label="Lift-off distance"><button data-lod="Low" disabled>Low</button><button data-lod="Medium" disabled>Medium</button><button data-lod="High" disabled>High</button></div><small id="lod-note" class="setting-note">Controls how far you can lift the mouse before tracking stops. Higher values keep tracking a little longer.</small></div></article>
+          <article class="setting-card" data-pending-key="lift-off-distance gaming-surface"><div class="setting-heading tight"><div><p>SENSOR</p></div></div><div id="gaming-surface-row" hidden><div class="setting-heading"><div><h2>Gaming surface</h2></div></div><div class="segmented three" role="group" aria-label="Gaming surface"><button data-gaming-surface="On" disabled>On</button><button data-gaming-surface="Off" disabled>Off</button><button data-gaming-surface="Auto" disabled>Auto</button></div><small class="setting-note">Tunes the sensor for gaming mouse pads. Auto lets the mouse decide; turn it off if tracking misbehaves on a non-gaming surface.</small></div><div id="host-lod-row"><div class="setting-heading"><div><h2>Lift-off distance</h2></div></div><div id="lod-mode-row" class="lod-mode" hidden><div class="segmented two" role="group" aria-label="Lift-off mode"><button data-lod-mode="single" disabled>Single</button><button data-lod-mode="asymmetric" disabled>Asymmetric</button></div></div><div id="lod-single"><div class="segmented three" role="group" aria-label="Lift-off distance"><button data-lod="Low" disabled>Low</button><button data-lod="Medium" disabled>Medium</button><button data-lod="High" disabled>High</button></div></div><div id="lod-asymmetric" class="lod-sliders" hidden><label>Lift-off<output id="lod-lift-off-value">—</output><input id="lod-lift-off" type="range" min="2" max="26" step="1" /></label><label>Landing<output id="lod-landing-value">—</output><input id="lod-landing" type="range" min="1" max="25" step="1" /></label></div><small id="lod-note" class="setting-note">Controls how far you can lift the mouse before tracking stops. Higher values keep tracking a little longer.</small></div></article>
           <article id="lightforce-card" class="setting-card" data-pending-key="lightforce-switch-mode" hidden><div class="setting-heading"><div><p>SWITCHES</p><h2>LightForce</h2></div></div><div class="segmented" role="group" aria-label="LightForce switch mode"><button data-lightforce="Hybrid" disabled>Hybrid</button><button data-lightforce="Optical" disabled>Optical only</button></div><small class="setting-note">Hybrid saves power by using the mechanical contact and only waking the optical sensor when needed. Optical only is consistent but uses more battery.</small><div id="bunny-hop-row" hidden><div class="setting-heading"><div><h2>Bunny hop<span class="setting-scope">Per-profile</span></h2></div></div><div class="bunny-hop-controls"><button id="bunny-hop-enabled" class="${TOGGLE}" type="button" role="switch" aria-checked="false">Off</button><input id="bunny-hop-input" type="number" min="100" max="1000" step="10" value="100" aria-label="Bunny hop time in milliseconds" /><span>ms</span></div><small class="setting-note" id="bunny-hop-note"></small></div></article>
         </section>
         <section id="logitech-device-details" class="device-data" style="display:none">
diff --git a/src/control.css b/src/control.css
index f22ff7d8..a4172328 100644
--- a/src/control.css
+++ b/src/control.css
@@ -1,6 +1,11 @@
 @import "./control-devices.css";
 @import "./control-profiles.css";
 
+/* Any author-level `display` beats the browser's own `[hidden]` rule, so a
+   `hidden` property set from script silently does nothing on anything laid out
+   with grid or flex. Several controls are hidden that way. */
+[hidden] { display: none !important; }
+
 :root {
   --ink: #09090b;
   --sidebar: #0d0d0f;
@@ -143,6 +148,7 @@ nav { display: grid; gap: .3rem; margin-top: 1.4rem; }
 
 .segmented { display: grid; grid-template-columns: repeat(4, 1fr); gap: .4rem; }
 .segmented.two { grid-template-columns: repeat(2, 1fr); }
+.segmented.three { grid-template-columns: repeat(3, 1fr); }
 .segmented button { padding: .6rem .4rem; border: 1px solid #303034; border-radius: 7px; background: var(--input); color: var(--muted); font-size: .72rem; }
 .segmented button:hover { border-color: var(--ghost); color: #fff; }
 .segmented button.selected { border-color: var(--text); background: var(--text); color: var(--ink); }
@@ -169,6 +175,14 @@ nav { display: grid; gap: .3rem; margin-top: 1.4rem; }
 .axis-grid input { width: 100%; box-sizing: border-box; margin-top: .2rem; padding: .42rem; border: 1px solid var(--line-strong); border-radius: 6px; background: #171719; color: #eee; }
 .axis-apply { padding: .45rem .6rem; border: 1px solid #45454a; border-radius: 6px; background: #202023; color: var(--bright); font-size: .62rem; }
 #gaming-surface-row { margin-bottom: .85rem; }
+.lod-mode { margin-bottom: .5rem; }
+/* Sliders rather than number fields, so a landing above the lift-off is not
+   expressible. The device stores an inverted pair without complaint. */
+.lod-sliders { display: grid; gap: .55rem; }
+.lod-sliders label { display: grid; grid-template-columns: 1fr auto; align-items: baseline; gap: .1rem .5rem; color: var(--faint); font-size: .62rem; }
+.lod-sliders output { color: var(--bright); font-family: var(--font-mono); font-size: .72rem; }
+.lod-sliders input[type="range"] { grid-column: 1 / -1; width: 100%; margin: .1rem 0 0; accent-color: var(--ui-accent); }
+.lod-sliders input[type="range"]:disabled { opacity: .45; }
 
 .switch-button { min-width: 42px; padding: .2rem .45rem; border: 1px solid var(--edge); border-radius: 999px; background: #202023; color: #8b8b90; font-size: .58rem; }
 .switch-row { display: flex; align-items: center; justify-content: space-between; gap: .5rem; padding: .2rem 0; color: var(--dim); font-size: .7rem; }
diff --git a/src/control.ts b/src/control.ts
index e28c4212..a3053887 100644
--- a/src/control.ts
+++ b/src/control.ts
@@ -401,6 +401,9 @@ function renderControl(): void {
     applyFinalmouseSetting,
     applyPollingRate,
     applyLiftOffDistance,
+    applyLiftOffMode,
+    applyAsymmetricLiftOff,
+    capLandingToLiftOff,
     applyGamingSurfaceMode,
     applyLightforceSwitchMode,
     flashPendingChanges,
@@ -1265,6 +1268,7 @@ function showStatus(deviceStatus: MouseStatus): void {
     const lodNeedsSurface = ui?.lodRequiresSurface === true && status.gamingSurfaceMode === "Off";
     button.disabled = hideLow || unsupported || settingsPending || legacyLogitechLow || lodNeedsSurface;
   });
+  renderAsymmetricLiftOff(status, settingsPending);
   // Runs after the DPI controls above so the slot editor, when it is in charge,
   // has the last word on which of them are visible.
   renderDpiSlots();
@@ -2931,6 +2935,9 @@ function applyLiftOffDistance(lod: NonNullable<MouseStatus["liftOffDistance"]>):
     progress: `Setting ${lod.toLowerCase()} lift-off distance…`,
     preview: (status) => {
       status.liftOffDistance = lod;
+      // Writing a tracking level is also how a mouse with a pair leaves
+      // asymmetric mode, so the switch has to follow.
+      if (status.asymmetricLiftOff) status.asymmetricLiftOff = { ...status.asymmetricLiftOff, enabled: false };
     },
     apply: async () => {
       await requireClientMethod("setLiftOffDistance", "the lift-off distance").setLiftOffDistance(lod);
@@ -2938,6 +2945,97 @@ function applyLiftOffDistance(lod: NonNullable<MouseStatus["liftOffDistance"]>):
   });
 }
 
+/**
+ * Mice that expose separate cut-off and re-engage heights get a mode switch, in
+ * the shape the vendor software uses: one control or the other, never both.
+ * Drivers that do not report the pair never see the switch and keep the plain
+ * three-stop control.
+ */
+function renderAsymmetricLiftOff(status: MouseStatus, settingsPending: boolean): void {
+  const pair = status.asymmetricLiftOff;
+  const modeRow = document.querySelector<HTMLElement>("#lod-mode-row");
+  const single = document.querySelector<HTMLElement>("#lod-single");
+  const asymmetric = document.querySelector<HTMLElement>("#lod-asymmetric");
+  if (!modeRow || !single || !asymmetric) return;
+  modeRow.hidden = !pair;
+  // A driver that cannot establish the mode leaves both buttons unselected
+  // rather than claiming one, and the single control stays visible. Choosing
+  // either mode writes it, so one click makes the display true.
+  const showPair = pair?.enabled === true;
+  single.hidden = Boolean(pair) && showPair;
+  asymmetric.hidden = !showPair;
+  document.querySelectorAll<HTMLButtonElement>("[data-lod-mode]").forEach((button) => {
+    const isPair = button.dataset.lodMode === "asymmetric";
+    setSelected(button, pair?.enabled === null ? false : isPair === showPair);
+    button.disabled = settingsPending || !pair;
+  });
+  if (!pair) return;
+  for (const [selector, value, range] of [
+    ["#lod-lift-off", pair.liftOff, pair.liftOffRange],
+    ["#lod-landing", pair.landing, pair.landingRange],
+  ] as const) {
+    const input = document.querySelector<HTMLInputElement>(selector);
+    if (!input) continue;
+    input.min = String(range.min);
+    input.max = String(range.max);
+    input.value = String(value);
+    input.disabled = settingsPending;
+  }
+  capLandingToLiftOff();
+}
+
+/**
+ * Landing is bounded by lift-off on the device, and the vendor software caps its
+ * own slider the same way. Enforcing it on the control means an invalid pair is
+ * not expressible, rather than accepted and then quietly altered — the firmware
+ * stores an inverted pair without complaint, so nothing downstream would catch
+ * it. The driver still caps as a backstop.
+ */
+export function capLandingToLiftOff(): void {
+  const liftOff = document.querySelector<HTMLInputElement>("#lod-lift-off");
+  const landing = document.querySelector<HTMLInputElement>("#lod-landing");
+  if (!liftOff || !landing) return;
+  // Clamp the value, never the range. A range input positions its thumb
+  // relative to its own bounds, so narrowing `max` to the ceiling made the
+  // thumb slide across the track whenever lift-off moved even though the
+  // number under it had not changed. Both sliders keep the device's full range,
+  // which also lines the two tracks up: they are the same 24 steps wide, offset
+  // by one, so a landing sitting just below its lift-off reads that way.
+  const ceiling = Math.max(Number(landing.min), Number(liftOff.value) - 1);
+  if (Number(landing.value) > ceiling) landing.value = String(ceiling);
+  setText("#lod-lift-off-value", liftOff.value);
+  setText("#lod-landing-value", landing.value);
+}
+
+/** Both modes are set by writing one, because the mouse honours the last write. */
+function applyLiftOffMode(mode: "single" | "asymmetric"): void {
+  const status = withPendingChanges(latestDeviceStatus ?? ({} as MouseStatus));
+  const pair = status.asymmetricLiftOff;
+  if (!latestDeviceStatus || !pair) return;
+  if (mode === "asymmetric") applyAsymmetricLiftOff(pair.liftOff, pair.landing);
+  else applyLiftOffDistance(status.liftOffDistance ?? "Medium");
+}
+
+function applyAsymmetricLiftOff(liftOff: number, requested: number): void {
+  if (!hasActiveClient()) return;
+  // Capped here too, so the staged label and the preview show what will actually
+  // be written rather than what was asked for.
+  const landing = Math.min(requested, liftOff - 1);
+  stageChange({
+    key: "lift-off-distance",
+    label: `Lift-off ${liftOff} / landing ${landing}`,
+    command: `Set lift-off to ${liftOff} and landing to ${landing}`,
+    progress: `Setting lift-off ${liftOff} and landing ${landing}…`,
+    preview: (status) => {
+      if (!status.asymmetricLiftOff) return;
+      status.asymmetricLiftOff = { ...status.asymmetricLiftOff, enabled: true, liftOff, landing };
+    },
+    apply: async () => {
+      await requireClientMethod("setLiftOff", "the lift-off distance").setLiftOff(liftOff, landing);
+    },
+  });
+}
+
 /**
  * Gaming surface and LightForce are two fields of one 0x8090 byte, so they are
  * staged as a group and written together. Each apply sends the whole group's
diff --git a/src/devices/mouse-types.ts b/src/devices/mouse-types.ts
index ff392a85..97ccfb3a 100644
--- a/src/devices/mouse-types.ts
+++ b/src/devices/mouse-types.ts
@@ -98,6 +98,22 @@ export interface MouseStatus {
   liftOffDistance: "Low" | "Medium" | "High" | null;
   /** Explicit LOD choices when a mouse does not support all three common levels. */
   supportedLiftOffDistances?: Array<NonNullable<MouseStatus["liftOffDistance"]>>;
+  /**
+   * Separate cut-off and re-engage heights, where a mouse offers them instead
+   * of the single three-stop `liftOffDistance`. Only drivers that have verified
+   * it on hardware populate this; everywhere else it stays undefined and the
+   * control does not appear.
+   *
+   * `enabled` is which of the two the mouse is actually using, and may be null
+   * when a driver cannot establish it.
+   */
+  asymmetricLiftOff?: {
+    enabled: boolean | null;
+    liftOff: number;
+    landing: number;
+    liftOffRange: { min: number; max: number };
+    landingRange: { min: number; max: number };
+  } | null;
   /** Logitech onboard profile format (HID++ 0x8100), which selects the layout. */
   onboardProfileFormat?: {
     id: number;
diff --git a/src/devices/razer/TESTING.md b/src/devices/razer/TESTING.md
index a5144a74..96e0353b 100644
--- a/src/devices/razer/TESTING.md
+++ b/src/devices/razer/TESTING.md
@@ -45,8 +45,9 @@ other control is withheld because no command for it has been confirmed.
 5. Change the polling rate on each connection and confirm it persists. The cable
    offers 125/500/1000 and the receiver adds 2000/4000/8000; no other rate
    should appear.
-6. Confirm no lift-off distance buttons, no sensor processing card and no
-   receiver signal card appear.
+6. On the receiver, confirm the lift-off card supports both Single and
+   Asymmetric modes; on the cable, confirm it stays hidden if class `0x0b` is
+   unsupported. Confirm no sensor processing card or receiver signal card appears.
 7. Change the auto sleep timeout **on the cable and again on the receiver**,
    reloading each time to confirm the new value persisted. Unlike polling, both
    transports answer `0x07`/`0x83`, so the card belongs on both.
diff --git a/src/devices/razer/hid.test.ts b/src/devices/razer/hid.test.ts
new file mode 100644
index 00000000..cd53eba7
--- /dev/null
+++ b/src/devices/razer/hid.test.ts
@@ -0,0 +1,247 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+// `hid.ts` schedules its inter-exchange delay through `window`, which node does
+// not provide. The global carries the same `setTimeout`.
+Object.assign(globalThis, { window: globalThis });
+
+const { RazerHidClient } = await import("./hid.ts");
+const {
+  RAZER_PACKET_LENGTH,
+  RAZER_STATUS,
+  RAZER_TRANSACTION_ID,
+  razerChecksum,
+} = await import("./protocol.ts");
+
+interface FakeLiftOff {
+  tracking: number;
+  liftOff: number;
+  landing: number;
+  /** The mouse refuses the pair write unless this is on. */
+  asymmetric: boolean;
+}
+
+interface FakeOptions {
+  /** Answer class 0x0b as unsupported, the way the cable may. */
+  liftOffUnsupported?: boolean;
+  /** Accept the write and keep the old values, as a rejected write does. */
+  ignoreWrites?: boolean;
+}
+
+function replyPacket(commandClass: number, commandId: number, dataSize: number, args: number[], status: number): Uint8Array {
+  const packet = new Uint8Array(RAZER_PACKET_LENGTH);
+  packet[0] = status;
+  packet[1] = RAZER_TRANSACTION_ID;
+  packet[5] = dataSize;
+  packet[6] = commandClass;
+  packet[7] = commandId;
+  packet.set(args, 8);
+  packet[88] = razerChecksum(packet);
+  return packet;
+}
+
+/**
+ * A mouse that answers only the lift-off commands, storing the pair the way the
+ * real one does: the write carries `00 04` before the levels, and each level is
+ * held one below the number the vendor software shows.
+ */
+function fakeMouse(state: FakeLiftOff, options: FakeOptions = {}) {
+  const sent: Uint8Array[] = [];
+  let pending = new Uint8Array(RAZER_PACKET_LENGTH);
+  const device = {
+    vendorId: 0x1532,
+    productId: 0x00c1,
+    productName: "Razer Viper V3 Pro",
+    opened: true,
+    collections: [{ usagePage: 0x01, usage: 0x02, children: [], featureReports: [], inputReports: [], outputReports: [] }],
+    open: async () => {},
+    close: async () => {},
+    sendFeatureReport: async (_reportId: number, data: Uint8Array) => {
+      sent.push(data);
+      const [commandClass, commandId] = [data[6], data[7]];
+      if (options.liftOffUnsupported) {
+        pending = replyPacket(commandClass, commandId, data[5], [], RAZER_STATUS.unsupported);
+        return;
+      }
+      // Matched on class as well as id: polling shares both ids on class 0x00,
+      // so an id-only match would let a later test mutate the pair by accident.
+      const liftOffWrite = commandClass === 0x0b && commandId === 0x05;
+      const liftOffRead = commandClass === 0x0b && commandId === 0x85;
+      const settingWrite = commandClass === 0x0b && commandId === 0x0b;
+      // The real mouse refuses the pair write unless asymmetric mode is on, and
+      // leaves it again whenever a tracking level is written.
+      if (settingWrite && data[10] === 0x04) state.asymmetric = data[11] === 0x01;
+      if (settingWrite && data[10] === 0x01 && !options.ignoreWrites) {
+        state.tracking = data[11];
+        state.asymmetric = false;
+      }
+      if (liftOffWrite && !state.asymmetric) {
+        pending = replyPacket(commandClass, commandId, data[5], [], RAZER_STATUS.failure);
+        return;
+      }
+      if (liftOffWrite && !options.ignoreWrites) {
+        state.liftOff = data[10] + 1;
+        state.landing = data[11] + 1;
+      }
+      pending = liftOffRead
+        ? replyPacket(commandClass, commandId, 0x05, [0, 0, state.tracking, state.liftOff - 1, state.landing - 1], RAZER_STATUS.ok)
+        : replyPacket(commandClass, commandId, data[5], [...data.slice(8, 8 + data[5])], RAZER_STATUS.ok);
+    },
+    receiveFeatureReport: async () => new DataView(pending.buffer.slice(0)),
+  } as unknown as HIDDevice;
+  return { client: new RazerHidClient(device), sent };
+}
+
+test("lift-off reads the tracking level and the asymmetric pair together", async () => {
+  // Arrange
+  const { client } = fakeMouse({ tracking: 1, liftOff: 16, landing: 11, asymmetric: true });
+
+  // Act
+  const liftOff = await client.readLiftOff();
+
+  // Assert
+  assert.deepEqual(liftOff, { tracking: "Medium", liftOff: 16, landing: 11 });
+});
+
+test("a transport that rejects class 0x0b degrades to null instead of throwing", async () => {
+  // A status read that throws takes the whole panel down, and the cable has
+  // never been checked against this command.
+  // Arrange
+  const { client } = fakeMouse({ tracking: 1, liftOff: 16, landing: 11, asymmetric: true }, { liftOffUnsupported: true });
+
+  // Act
+  const liftOff = await client.readLiftOff();
+
+  // Assert
+  assert.equal(liftOff, null);
+});
+
+test("the lift-off write unlocks asymmetric mode first, then uses the captured format", async () => {
+  // Without the unlock the mouse answers 0x03 and still moves what the read
+  // reports, so the omission would look like success from every angle but the
+  // sensor.
+  // Arrange
+  const { client, sent } = fakeMouse({ tracking: 2, liftOff: 26, landing: 25, asymmetric: false });
+
+  // Act
+  const confirmed = await client.setLiftOff(16, 11);
+
+  // Assert
+  const [unlock, write] = sent;
+  assert.deepEqual([unlock[5], unlock[6], unlock[7]], [0x04, 0x0b, 0x0b]);
+  assert.deepEqual([...unlock.slice(8, 12)], [0x00, 0x04, 0x04, 0x01]);
+  assert.deepEqual([write[5], write[6], write[7]], [0x0a, 0x0b, 0x05]);
+  assert.deepEqual([...write.slice(8, 18)], [0x00, 0x04, 0x0f, 0x0a, 0, 0, 0, 0, 0, 0]);
+  assert.deepEqual(confirmed, { tracking: "High", liftOff: 16, landing: 11 });
+});
+
+test("landing is capped below lift-off rather than rejected", async () => {
+  // Lowering lift-off past an already-set landing is ordinary use of a pair of
+  // controls; the protocol layer would throw on the inverted pair.
+  // Arrange
+  const { client, sent } = fakeMouse({ tracking: 0, liftOff: 16, landing: 11, asymmetric: true });
+
+  // Act
+  const confirmed = await client.setLiftOff(5, 11);
+
+  // Assert
+  assert.deepEqual([...sent[1].slice(8, 12)], [0x00, 0x04, 0x04, 0x03]);
+  assert.deepEqual(confirmed, { tracking: "Low", liftOff: 5, landing: 4 });
+});
+
+test("setting a tracking distance returns the mouse to symmetric mode", async () => {
+  // There is no mode flag to clear — the mouse honours whichever store was
+  // written last, so a later pair write must be refused until it re-unlocks.
+  // Arrange
+  const state = { tracking: 0, liftOff: 16, landing: 11, asymmetric: true };
+  const { client, sent } = fakeMouse(state);
+
+  // Act
+  const confirmed = await client.setLiftOffDistance("High");
+
+  // Assert
+  assert.deepEqual([...sent[0].slice(8, 12)], [0x00, 0x04, 0x01, 0x02]);
+  assert.equal(confirmed, "High");
+  assert.equal(state.asymmetric, false);
+});
+
+test("a tracking distance the mouse does not take is reported", async () => {
+  // Arrange
+  const { client } = fakeMouse({ tracking: 0, liftOff: 16, landing: 11, asymmetric: false }, { ignoreWrites: true });
+
+  // Act / Assert
+  await assert.rejects(() => client.setLiftOffDistance("High"), /kept Low tracking distance instead of High/);
+});
+
+test("the mode probe reports asymmetric from the pair write's status", async () => {
+  // Nothing readable carries the mode; the pair write is refused in symmetric
+  // mode and accepted in asymmetric, which is the only signal available.
+  // Arrange
+  const asymmetric = fakeMouse({ tracking: 1, liftOff: 16, landing: 11, asymmetric: true });
+  const symmetric = fakeMouse({ tracking: 1, liftOff: 16, landing: 11, asymmetric: false });
+
+  // Act / Assert
+  assert.equal(await asymmetric.client.probeAsymmetric({ tracking: "Medium", liftOff: 16, landing: 11 }), true);
+  assert.equal(await symmetric.client.probeAsymmetric({ tracking: "Medium", liftOff: 16, landing: 11 }), false);
+});
+
+test("the mode probe leaves the stored pair exactly as it found it", async () => {
+  // It is a write, so it has to be one the mouse cannot act on. Re-sending the
+  // mirror's own values is inert whichever way the status goes.
+  // Arrange
+  const state = { tracking: 1, liftOff: 16, landing: 11, asymmetric: true };
+  const { client } = fakeMouse(state);
+
+  // Act
+  await client.probeAsymmetric({ tracking: "Medium", liftOff: 16, landing: 11 });
+
+  // Assert
+  assert.deepEqual(state, { tracking: 1, liftOff: 16, landing: 11, asymmetric: true });
+});
+
+test("the mode probe reports unknown rather than throwing on an inverted pair", async () => {
+  // The firmware stores lift-off 2 with landing 26 without complaint, and one
+  // session left it there. Probing with that would throw in the command builder.
+  // Arrange
+  const { client, sent } = fakeMouse({ tracking: 1, liftOff: 2, landing: 26, asymmetric: true });
+
+  // Act
+  const mode = await client.probeAsymmetric({ tracking: "Medium", liftOff: 2, landing: 26 });
+
+  // Assert
+  assert.equal(mode, null);
+  assert.equal(sent.length, 0);
+});
+
+test("a level outside the three the slider offers still produces a readable error", async () => {
+  // `decodeLiftOff` reports an unrecognised byte[2] as null rather than guessing,
+  // so the mismatch message has to survive that without printing "null".
+  // Arrange
+  const { client } = fakeMouse({ tracking: 7, liftOff: 16, landing: 11, asymmetric: false }, { ignoreWrites: true });
+
+  // Act / Assert
+  await assert.rejects(
+    () => client.setLiftOffDistance("Medium"),
+    /kept an unknown tracking distance instead of Medium/,
+  );
+});
+
+test("a write the mouse does not honour is reported instead of assumed", async () => {
+  // Arrange
+  const { client } = fakeMouse({ tracking: 0, liftOff: 26, landing: 25, asymmetric: true }, { ignoreWrites: true });
+
+  // Act / Assert
+  await assert.rejects(() => client.setLiftOff(16, 11), /kept lift-off 26 and landing 25/);
+});
+
+test("an out-of-range lift-off reports itself rather than the landing it drags down", async () => {
+  // Arrange
+  const { client, sent } = fakeMouse({ tracking: 0, liftOff: 16, landing: 11, asymmetric: false });
+
+  // Act / Assert
+  await assert.rejects(() => client.setLiftOff(1, 1), /Lift-off must be/);
+  // Nothing reached the device, so a rejected value cannot leave the mouse
+  // switched into asymmetric mode over a write that never happened.
+  assert.equal(sent.length, 0);
+  await assert.rejects(() => client.setLiftOff(27, 25), /Lift-off must be/);
+});
diff --git a/src/devices/razer/hid.ts b/src/devices/razer/hid.ts
index b3dbcb0f..d31f3911 100644
--- a/src/devices/razer/hid.ts
+++ b/src/devices/razer/hid.ts
@@ -1,9 +1,14 @@
 import type { MouseStatus } from "../mouse-types.ts";
 import { VENDOR_ID } from "../vendors.ts";
 import {
+  RAZER_LANDING_MAX,
+  RAZER_LANDING_MIN,
+  RAZER_LIFT_OFF_MAX,
+  RAZER_LIFT_OFF_MIN,
   RAZER_READ,
   RAZER_REPORT_ID,
   RAZER_STATUS,
+  RAZER_TRACKING_DISTANCES,
   RAZER_TRANSACTION_ID,
   RAZER_TRANSACTION_ID_LEGACY,
   RazerProtocolError,
@@ -13,6 +18,7 @@ import {
   decodeExtendedPollingRate,
   decodeFirmwareVersion,
   decodeLegacyPollingRate,
+  decodeLiftOff,
   decodeLowPowerThreshold,
   decodeRazerResponse,
   decodeSerial,
@@ -21,9 +27,15 @@ import {
   razerSetDpiCommand,
   razerSetExtendedPollingCommand,
   razerSetLegacyPollingCommand,
+  razerMaxLanding,
+  razerSetLiftOffCommand,
+  razerSetTrackingDistanceCommand,
+  razerEnableAsymmetricLiftOffCommand,
   razerSetLowPowerThresholdCommand,
   razerSetSleepTimeoutCommand,
   type RazerCommand,
+  type RazerLiftOff,
+  type RazerTrackingDistance,
 } from "./protocol.ts";
 
 interface RazerProduct {
@@ -129,6 +141,11 @@ function hasVendorCollection(device: HIDDevice): boolean {
 export class RazerHidClient {
   private queue: Promise<unknown> = Promise.resolve();
   private readonly staticReads = new Map<string, Promise<Uint8Array | null>>();
+  // The mode probe is a write, so it runs once per connection rather than on
+  // every background refresh. Both setters know which mode they leave behind,
+  // so nothing after the first read needs to ask the mouse again.
+  private asymmetric: boolean | null = null;
+  private asymmetricKnown = false;
 
   readonly device: HIDDevice;
 
@@ -153,6 +170,7 @@ export class RazerHidClient {
 
   async close(): Promise<void> {
     this.staticReads.clear();
+    this.asymmetricKnown = false;
     if (this.device.opened) await this.device.close();
   }
 
@@ -212,6 +230,7 @@ export class RazerHidClient {
     const lowPower = hasBattery ? await this.request(RAZER_READ.lowPowerThreshold).catch(() => null) : null;
     const dpi = decodeDpi(await this.request(RAZER_READ.dpi));
     const pollingRateHz = await this.readPollingRateHz();
+    const liftOff = await this.readLiftOff();
     return {
       brand: "Razer",
       name: this.displayName(),
@@ -220,8 +239,10 @@ export class RazerHidClient {
         settingsReady: true,
         valuesVerified: true,
         hideUnsupportedPollingRates: true,
-        // No lift-off or sensor-processing command is confirmed, so neither
-        // control is offered rather than offered and left inert.
+        // No sensor-processing command is confirmed, so that card is hidden
+        // rather than offered and left inert. Lift-off is confirmed and
+        // readable through `readLiftOff`, but `MouseStatus` cannot carry the
+        // asymmetric pair yet — see the note on `liftOffDistance` below.
         hideProcessingCard: true,
         // Nothing reports link quality on this model, and the section this card
         // shares with sleep is opened below, so it would otherwise appear as a
@@ -246,8 +267,17 @@ export class RazerHidClient {
       sleepTimeout: sleep ? decodeSleepTimeout(sleep) : null,
       lowBatteryWarning: lowPower ? decodeLowPowerThreshold(lowPower) : null,
       unitId: serial ? decodeSerial(serial) : null,
-      liftOffDistance: null,
-      supportedLiftOffDistances: [],
+      liftOffDistance: liftOff?.tracking ?? null,
+      // An empty list hides the control, which is what should happen on a
+      // transport that does not answer class 0x0b at all.
+      supportedLiftOffDistances: liftOff ? [...RAZER_TRACKING_DISTANCES] : [],
+      asymmetricLiftOff: liftOff && {
+        enabled: await this.asymmetricMode(liftOff),
+        liftOff: liftOff.liftOff,
+        landing: liftOff.landing,
+        liftOffRange: { min: RAZER_LIFT_OFF_MIN, max: RAZER_LIFT_OFF_MAX },
+        landingRange: { min: RAZER_LANDING_MIN, max: RAZER_LANDING_MAX },
+      },
       firmware: [`Mouse ${decodeFirmwareVersion(firmware)}`],
     };
   }
@@ -324,6 +354,113 @@ export class RazerHidClient {
     return { percent: decodeBatteryPercent(level), state: charging ? "Charging" : "Discharging" };
   }
 
+  /**
+   * Reads the tracking level and the asymmetric lift-off/landing pair.
+   *
+   * Returns null when the mouse does not answer. Class `0x0b` has only ever
+   * been exercised on the receiver, so the cable may reject it, and a status
+   * read that throws takes the whole panel down rather than one control. The
+   * caller degrades instead.
+   */
+  async readLiftOff(): Promise<RazerLiftOff | null> {
+    const reply = await this.request(RAZER_READ.liftOff).catch(() => null);
+    return reply ? decodeLiftOff(reply) : null;
+  }
+
+  /**
+   * Reports whether the mouse is currently in asymmetric mode, or null when it
+   * cannot be established.
+   *
+   * Nothing readable carries the mode — two 47-command captures differing only
+   * by it were byte-identical, and a full sweep found nothing. What does report
+   * it is the pair write's own status: refused `0x03` in symmetric mode,
+   * accepted `0x02` in asymmetric.
+   *
+   * That makes this a probe rather than a read, so it is written to disturb
+   * nothing. Re-sending the values the mirror already holds is value-preserving
+   * either way, and mode-preserving too: a refusal cannot switch the mode, and
+   * an acceptance re-selects the mode the mouse was already in.
+   *
+   * Call it once per connection, not on every refresh — it is still a write.
+   */
+  async probeAsymmetric(current: RazerLiftOff): Promise<boolean | null> {
+    // The firmware stores an inverted pair without complaint, and one session
+    // left it holding lift-off 2 with landing 26. Probing with that would throw
+    // in the command builder, so report "unknown" rather than guessing.
+    if (current.landing >= current.liftOff) return null;
+    try {
+      await this.request(razerSetLiftOffCommand(current.liftOff, current.landing));
+      return true;
+    } catch (error) {
+      if (error instanceof RazerProtocolError && error.status === RAZER_STATUS.failure) return false;
+      return null;
+    }
+  }
+
+  /** Probes once, then trusts what the setters leave behind. */
+  private async asymmetricMode(current: RazerLiftOff): Promise<boolean | null> {
+    if (!this.asymmetricKnown) {
+      this.asymmetric = await this.probeAsymmetric(current);
+      this.asymmetricKnown = true;
+    }
+    return this.asymmetric;
+  }
+
+  /**
+   * Selects the symmetric tracking distance, which also takes the mouse out of
+   * asymmetric mode — it honours whichever store was written last, and there is
+   * no mode flag to clear.
+   *
+   * Named for the shell's driver contract rather than the vendor's wording; the
+   * vendor calls this the tracking distance.
+   */
+  async setLiftOffDistance(distance: RazerTrackingDistance): Promise<RazerTrackingDistance> {
+    await this.request(razerSetTrackingDistanceCommand(distance));
+    const confirmed = decodeLiftOff(await this.request(RAZER_READ.liftOff));
+    if (confirmed.tracking !== distance) {
+      throw new Error(`The mouse kept ${confirmed.tracking ?? "an unknown"} tracking distance instead of ${distance}.`);
+    }
+    this.asymmetric = false;
+    this.asymmetricKnown = true;
+    return distance;
+  }
+
+  /**
+   * Writes the asymmetric pair, and switches the mouse into asymmetric mode to
+   * do it. The tracking level shares the same reply but not the same write, so
+   * it is left as the mouse holds it.
+   *
+   * Landing is capped just below lift-off rather than rejected, because
+   * lowering lift-off past an already-set landing is ordinary use of a pair of
+   * controls and the vendor software caps its own slider the same way. The
+   * returned values are what the mouse ended up holding, not what was asked
+   * for, so a caller can render the cap rather than guess at it.
+   */
+  async setLiftOff(liftOff: number, landing: number): Promise<RazerLiftOff> {
+    const capped = Math.min(landing, razerMaxLanding(liftOff));
+    // Built before anything is sent, so a rejected value costs no device
+    // traffic and cannot leave the mouse switched into asymmetric mode over a
+    // write that never happened. `razerSetLiftOffCommand` validates lift-off
+    // before landing, so an out-of-range lift-off still reports itself rather
+    // than being masked by the landing it drags out of range here.
+    const command = razerSetLiftOffCommand(liftOff, capped);
+    // The pair write is refused in symmetric mode — and refused while still
+    // moving what the read reports, so skipping this yields a driver that looks
+    // like it works and never reaches the sensor.
+    await this.request(razerEnableAsymmetricLiftOffCommand());
+    await this.request(command);
+    // Rejected writes on this command still disturb the stored pair, so the
+    // read-back is a genuine check, not a formality. Tracking is excluded — it
+    // was never part of the write.
+    const confirmed = decodeLiftOff(await this.request(RAZER_READ.liftOff));
+    if (confirmed.liftOff !== liftOff || confirmed.landing !== capped) {
+      throw new Error(`The mouse kept lift-off ${confirmed.liftOff} and landing ${confirmed.landing} instead of ${liftOff} and ${capped}.`);
+    }
+    this.asymmetric = true;
+    this.asymmetricKnown = true;
+    return confirmed;
+  }
+
   /**
    * Wired answers only the legacy command and the receiver only the extended
    * one, so ask for the expected one first and keep the other as a fallback.
diff --git a/src/devices/razer/protocol.test.ts b/src/devices/razer/protocol.test.ts
index 0c5ac6b2..ee9e3c57 100644
--- a/src/devices/razer/protocol.test.ts
+++ b/src/devices/razer/protocol.test.ts
@@ -2,6 +2,10 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
+  RAZER_LANDING_MAX,
+  RAZER_LANDING_MIN,
+  RAZER_LIFT_OFF_MAX,
+  RAZER_LIFT_OFF_MIN,
   RAZER_PACKET_LENGTH,
   RAZER_READ,
   RAZER_STATUS,
@@ -16,6 +20,7 @@ import {
   decodeExtendedPollingRate,
   decodeFirmwareVersion,
   decodeLegacyPollingRate,
+  decodeLiftOff,
   decodeLowPowerThreshold,
   decodeRazerResponse,
   decodeSerial,
@@ -25,6 +30,10 @@ import {
   razerSetDpiCommand,
   razerSetExtendedPollingCommand,
   razerSetLegacyPollingCommand,
+  razerMaxLanding,
+  razerSetLiftOffCommand,
+  razerSetTrackingDistanceCommand,
+  razerEnableAsymmetricLiftOffCommand,
   razerSetLowPowerThresholdCommand,
   razerSetSleepTimeoutCommand,
 } from "./protocol.ts";
@@ -348,6 +357,150 @@ test("extended polling ignores the echoed request argument", () => {
   assert.equal(decodeExtendedPollingRate(asZero), decodeExtendedPollingRate(asOne));
 });
 
+/*
+ * Lift-off fixtures are receiver captures (PID 0x00c1, firmware 1.12) taken
+ * while reading each Synapse setting back. Checksums are re-derived; the byte
+ * values are what the mouse returned.
+ */
+test("the asymmetric pair decodes one below the numbers Synapse shows", () => {
+  const low = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 00 00 00 04 03"), RAZER_READ.liftOff);
+  const middle = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 00 00 00 0f 0a"), RAZER_READ.liftOff);
+  const high = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 00 00 00 19 18"), RAZER_READ.liftOff);
+
+  assert.deepEqual(decodeLiftOff(low), { tracking: "Low", liftOff: 5, landing: 4 });
+  assert.deepEqual(decodeLiftOff(middle), { tracking: "Low", liftOff: 16, landing: 11 });
+  assert.deepEqual(decodeLiftOff(high), { tracking: "Low", liftOff: 26, landing: 25 });
+});
+
+test("the symmetric level decodes from its own byte, leaving the pair alone", () => {
+  // The same 26/25 pair at each of the three tracking stops. Moving the
+  // symmetric slider never touched bytes 3 and 4, which is what makes these two
+  // controls separate stored settings rather than two views of one.
+  const stops = ["00 00 00 19 18", "00 00 01 19 18", "00 00 02 19 18"];
+  const decoded = stops.map((args) => decodeLiftOff(
+    decodeRazerResponse(reply(`02 1f 00 00 00 05 0b 85 ${args}`), RAZER_READ.liftOff),
+  ));
+
+  assert.deepEqual(decoded.map((value) => value.tracking), ["Low", "Medium", "High"]);
+  assert.deepEqual(decoded.map((value) => value.liftOff), [26, 26, 26]);
+  assert.deepEqual(decoded.map((value) => value.landing), [25, 25, 25]);
+});
+
+test("lift-off ignores the echoed request argument", () => {
+  // Byte[0] came back holding whatever the request carried. Arguments 0x00
+  // through 0x07 all returned the same levels, so it selects nothing.
+  const asZero = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 00 00 00 0f 0a"), RAZER_READ.liftOff);
+  const asThree = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 03 00 00 0f 0a"), RAZER_READ.liftOff);
+
+  assert.deepEqual(decodeLiftOff(asZero), decodeLiftOff(asThree));
+});
+
+test("a tracking level the slider does not offer decodes as null", () => {
+  // Three stops are all Synapse exposes, so a fourth value is a reading this
+  // driver does not understand. Reporting null hides the control instead of
+  // showing a level the mouse is not holding.
+  const unexpected = decodeRazerResponse(reply("02 1f 00 00 00 05 0b 85 00 00 07 19 18"), RAZER_READ.liftOff);
+
+  assert.equal(decodeLiftOff(unexpected).tracking, null);
+});
+
+test("every level the sliders offer stays inside the documented bounds", () => {
+  // The encoding is zero-based, so the extremes are what prove the bounds are
+  // the sliders' and not an artefact of the offset.
+  const lowest = decodeLiftOff(new Uint8Array([0, 0, 0, RAZER_LIFT_OFF_MIN - 1, RAZER_LANDING_MIN - 1]));
+  const highest = decodeLiftOff(new Uint8Array([0, 0, 2, RAZER_LIFT_OFF_MAX - 1, RAZER_LANDING_MAX - 1]));
+
+  assert.deepEqual(lowest, { tracking: "Low", liftOff: 2, landing: 1 });
+  assert.deepEqual(highest, { tracking: "High", liftOff: 26, landing: 25 });
+  assert.ok(lowest.landing < lowest.liftOff);
+  assert.ok(highest.landing < highest.liftOff);
+});
+
+test("a lift-off write matches the packet the vendor software sends", () => {
+  // Transcribed from a capture of Synapse's own traffic: dataSize 0x0a, then
+  // `00 04` before the pair. Not inferred from the read — the read's layout is
+  // different, and assuming otherwise produced three rejected writes.
+  const packet = encodeRazerRequest(razerSetLiftOffCommand(16, 11));
+
+  assert.equal(packet[5], 0x0a);
+  assert.equal(packet[6], 0x0b);
+  assert.equal(packet[7], 0x05);
+  assert.deepEqual([...packet.slice(8, 18)], [0x00, 0x04, 0x0f, 0x0a, 0, 0, 0, 0, 0, 0]);
+  assert.equal(packet[88], razerChecksum(packet));
+});
+
+test("a lift-off write clears the high bit of the matching read", () => {
+  assert.equal(RAZER_WRITE.liftOff.commandClass, RAZER_READ.liftOff.commandClass);
+  assert.equal(RAZER_WRITE.liftOff.commandId, RAZER_READ.liftOff.commandId & 0x7f);
+});
+
+test("lift-off writes round-trip through the decoder at both extremes", () => {
+  // The write payload is offset from the read's, so a round trip is the check
+  // that actually catches a mistranscribed layout.
+  for (const [liftOff, landing] of [[2, 1], [16, 11], [26, 25]] as const) {
+    const request = encodeRazerRequest(razerSetLiftOffCommand(liftOff, landing));
+    // Read byte[n] carries write arg[n-1] — the read has a leading echo byte the
+    // write does not. Arguments start at packet[8], so the pair is [10] and [11].
+    const decoded = decodeLiftOff(new Uint8Array([0, 0, 0, request[10], request[11]]));
+    assert.equal(decoded.liftOff, liftOff);
+    assert.equal(decoded.landing, landing);
+  }
+});
+
+test("an inverted pair is refused before it reaches the mouse", () => {
+  // The firmware stored lift-off 2 with landing 26 without complaint, which the
+  // vendor software cannot even express. The read-back check cannot catch this,
+  // because the mouse reports back exactly the invalid pair it was given.
+  assert.throws(() => razerSetLiftOffCommand(5, 5), RazerProtocolError);
+  assert.throws(() => razerSetLiftOffCommand(2, 26), RazerProtocolError);
+  assert.doesNotThrow(() => razerSetLiftOffCommand(5, 4));
+});
+
+test("lift-off values outside the vendor sliders are refused", () => {
+  assert.throws(() => razerSetLiftOffCommand(1, 0), RazerProtocolError);
+  assert.throws(() => razerSetLiftOffCommand(27, 25), RazerProtocolError);
+  assert.throws(() => razerSetLiftOffCommand(16, 0), RazerProtocolError);
+  assert.throws(() => razerSetLiftOffCommand(16.5, 11), RazerProtocolError);
+});
+
+test("landing is always at least one step below lift-off", () => {
+  // The rule the controls enforce: lift-off 10 permits landing 9, never 10.
+  assert.equal(razerMaxLanding(10), 9);
+  // Every lift-off the sliders offer, checked against the command that would
+  // carry it — the ceiling has to be a pair the mouse will actually accept.
+  for (let liftOff = RAZER_LIFT_OFF_MIN; liftOff <= RAZER_LIFT_OFF_MAX; liftOff += 1) {
+    const ceiling = razerMaxLanding(liftOff);
+    assert.ok(ceiling < liftOff, `landing ${ceiling} is not below lift-off ${liftOff}`);
+    assert.ok(ceiling >= RAZER_LANDING_MIN && ceiling <= RAZER_LANDING_MAX);
+    assert.doesNotThrow(() => razerSetLiftOffCommand(liftOff, ceiling));
+    assert.throws(() => razerSetLiftOffCommand(liftOff, ceiling + 1), RazerProtocolError);
+  }
+});
+
+test("the tracking-distance write encodes the level the read reports", () => {
+  // `0x0b`/`0x0b` carries `00 04` then a setting id and its value. Setting 01 is
+  // the tracking level, and it uses the same 0/1/2 codes as read byte[2] — this
+  // was confirmed on hardware by a Low to High transition, not an identity write.
+  for (const [distance, level] of [["Low", 0], ["Medium", 1], ["High", 2]] as const) {
+    const packet = encodeRazerRequest(razerSetTrackingDistanceCommand(distance));
+
+    assert.deepEqual([packet[5], packet[6], packet[7]], [0x04, 0x0b, 0x0b]);
+    assert.deepEqual([...packet.slice(8, 12)], [0x00, 0x04, 0x01, level]);
+    assert.equal(decodeLiftOff(new Uint8Array([0, 0, packet[11], 1, 0])).tracking, distance);
+    assert.equal(packet[88], razerChecksum(packet));
+  }
+});
+
+test("the asymmetric unlock is the same command with setting 04", () => {
+  // Sent before every pair write. Without it the mouse answers 0x03 and still
+  // moves what the read reports, so its absence is invisible to a read-back.
+  const packet = encodeRazerRequest(razerEnableAsymmetricLiftOffCommand());
+
+  assert.deepEqual([packet[5], packet[6], packet[7]], [0x04, 0x0b, 0x0b]);
+  assert.deepEqual([...packet.slice(8, 12)], [0x00, 0x04, 0x04, 0x01]);
+  assert.equal(packet[88], razerChecksum(packet));
+});
+
 test("serial text stops at the terminator", () => {
   const args = decodeRazerResponse(
     reply("02 1f 00 00 00 16 00 82 50 4d 30 30 30 30 48 30 30 30 30 30 30 30 30 00"),
diff --git a/src/devices/razer/protocol.ts b/src/devices/razer/protocol.ts
index 0ca235bf..147f588c 100644
--- a/src/devices/razer/protocol.ts
+++ b/src/devices/razer/protocol.ts
@@ -62,6 +62,7 @@ export const RAZER_READ = {
   dpiStages: { commandClass: 0x04, commandId: 0x86, dataSize: 0x26, args: [0x00] },
   pollingRate: { commandClass: 0x00, commandId: 0x85, dataSize: 0x01 },
   pollingRateExtended: { commandClass: 0x00, commandId: 0xc0, dataSize: 0x02, args: [0x00] },
+  liftOff: { commandClass: 0x0b, commandId: 0x85, dataSize: 0x05 },
 } as const satisfies Record<string, RazerCommand>;
 
 /**
@@ -76,6 +77,8 @@ export const RAZER_WRITE = {
   dpi: { commandClass: 0x04, commandId: 0x05, dataSize: 0x07 },
   pollingRate: { commandClass: 0x00, commandId: 0x05, dataSize: 0x01 },
   pollingRateExtended: { commandClass: 0x00, commandId: 0x40, dataSize: 0x02 },
+  liftOff: { commandClass: 0x0b, commandId: 0x05, dataSize: 0x0a },
+  sensorSetting: { commandClass: 0x0b, commandId: 0x0b, dataSize: 0x04 },
   sleepTimeout: { commandClass: 0x07, commandId: 0x03, dataSize: 0x02 },
   lowPowerThreshold: { commandClass: 0x07, commandId: 0x01, dataSize: 0x02 },
 } as const satisfies Record<string, Omit<RazerCommand, "args">>;
@@ -251,6 +254,147 @@ export function decodeDpiStages(args: Uint8Array): RazerDpiStages {
   return { active: args[1], stages };
 }
 
+/**
+ * Lift-off distance. The vendor software presents this as two different
+ * controls behind one checkbox, and the mouse stores both independently:
+ *
+ * - Asymmetric off: a single three-stop slider, "Tracking Distance".
+ * - Asymmetric on: two 26-step sliders, lift-off and landing.
+ *
+ * Switching modes leaves the other mode's stored value untouched, so neither
+ * reading destroys the other.
+ */
+export type RazerTrackingDistance = "Low" | "Medium" | "High";
+
+/** Indexed by the byte the mouse reports, so the order is the encoding. */
+export const RAZER_TRACKING_DISTANCES: readonly RazerTrackingDistance[] = ["Low", "Medium", "High"];
+
+/** Synapse's own numbering. Landing must stay strictly below lift-off. */
+export const RAZER_LIFT_OFF_MIN = 2;
+export const RAZER_LIFT_OFF_MAX = 26;
+export const RAZER_LANDING_MIN = 1;
+export const RAZER_LANDING_MAX = 25;
+
+/**
+ * Second argument of every class 0x0b write the vendor software was observed
+ * making. It reads as a feature selector — smart tracking — and the mouse
+ * rejects the packet without it.
+ */
+const RAZER_SENSOR_SELECTOR = 0x04;
+
+/**
+ * Third argument of `0x0b`/`0x0b`, choosing which setting the fourth carries.
+ * Both were read off the vendor software's own traffic and confirmed on
+ * hardware.
+ */
+const RAZER_SENSOR_SETTING = {
+  trackingDistance: 0x01,
+  asymmetric: 0x04,
+} as const;
+
+export interface RazerLiftOff {
+  /** Null when the mouse reports a level outside the three the slider offers. */
+  tracking: RazerTrackingDistance | null;
+  liftOff: number;
+  landing: number;
+}
+
+/**
+ * Both asymmetric levels are stored one below the number Synapse displays, so
+ * lift-off 26 is 0x19 and landing 25 is 0x18. Confirmed at 5/4, 16/11 and 26/25,
+ * with the middle reading predicted before it was measured.
+ *
+ * Byte[0] echoes whatever argument the request carried and byte[1] was zero in
+ * every capture, so neither is read here — arguments 0x00 through 0x07 all
+ * returned the same levels, which rules out a per-profile store.
+ */
+export function decodeLiftOff(args: Uint8Array): RazerLiftOff {
+  return {
+    tracking: RAZER_TRACKING_DISTANCES[args[2]] ?? null,
+    liftOff: args[3] + 1,
+    landing: args[4] + 1,
+  };
+}
+
+/**
+ * The highest landing a given lift-off permits: lift-off 10 allows 9, and so on
+ * down to the floor of 1.
+ *
+ * Landing is bounded by lift-off rather than locked to it — the vendor software
+ * caps its own slider the same way, and 16/11 is a perfectly ordinary pair. The
+ * firmware stores an inverted pair without complaint, and one session left the
+ * mouse holding lift-off 2 with landing 26, which the vendor software cannot
+ * even express. Nothing downstream catches that, so the rule is enforced here.
+ */
+export function razerMaxLanding(liftOff: number): number {
+  return Math.min(RAZER_LANDING_MAX, Math.max(RAZER_LANDING_MIN, liftOff - 1));
+}
+
+/**
+ * Selects the mouse's symmetric tracking distance, and by doing so switches it
+ * out of asymmetric mode.
+ *
+ * The mouse has no readable mode bit and no mode flag to set. It honours
+ * whichever of the two stores was written most recently, so writing a tracking
+ * level *is* the way to return to symmetric — confirmed by the asymmetric pair
+ * write being rejected immediately afterwards.
+ */
+export function razerSetTrackingDistanceCommand(distance: RazerTrackingDistance): RazerCommand {
+  const level = RAZER_TRACKING_DISTANCES.indexOf(distance);
+  if (level < 0) throw new RazerProtocolError(`${distance} is not a tracking distance this mouse offers.`);
+  return {
+    ...RAZER_WRITE.sensorSetting,
+    args: [0x00, RAZER_SENSOR_SELECTOR, RAZER_SENSOR_SETTING.trackingDistance, level],
+  };
+}
+
+/**
+ * Unlocks the asymmetric pair write, which the mouse rejects with status `0x03`
+ * in symmetric mode — and rejects while still moving what the read reports, so
+ * skipping this produces a driver that appears to work and never touches the
+ * sensor.
+ *
+ * There is no matching disable. Sending value `0x00` was accepted and changed
+ * nothing; the vendor software leaves asymmetric mode by writing a tracking
+ * level instead, which is what `razerSetTrackingDistanceCommand` does.
+ */
+export function razerEnableAsymmetricLiftOffCommand(): RazerCommand {
+  return {
+    ...RAZER_WRITE.sensorSetting,
+    args: [0x00, RAZER_SENSOR_SELECTOR, RAZER_SENSOR_SETTING.asymmetric, 0x01],
+  };
+}
+
+/**
+ * Lift-off write, transcribed from the vendor software's own packet rather than
+ * inferred: `dataSize 0x0a`, then `00 04` before the pair. It does NOT mirror
+ * the read's layout, which is what three earlier guesses assumed — each was
+ * answered `0x03` while still disturbing the stored values.
+ *
+ * Must be preceded by `razerEnableAsymmetricLiftOffCommand`.
+ *
+ * Confirmed on hardware: status `0x02`, read-back exact, and the change is
+ * felt at the sensor, which a read-back alone cannot establish.
+ */
+export function razerSetLiftOffCommand(liftOff: number, landing: number): RazerCommand {
+  if (!Number.isInteger(liftOff) || liftOff < RAZER_LIFT_OFF_MIN || liftOff > RAZER_LIFT_OFF_MAX) {
+    throw new RazerProtocolError(`Lift-off must be a whole number between ${RAZER_LIFT_OFF_MIN} and ${RAZER_LIFT_OFF_MAX}.`);
+  }
+  if (!Number.isInteger(landing) || landing < RAZER_LANDING_MIN || landing > RAZER_LANDING_MAX) {
+    throw new RazerProtocolError(`Landing must be a whole number between ${RAZER_LANDING_MIN} and ${RAZER_LANDING_MAX}.`);
+  }
+  // The firmware stores an inverted pair without complaint — a write of
+  // landing 26 against lift-off 2 round-tripped and left the mouse in a state
+  // the vendor software cannot express. Nothing downstream will catch this.
+  if (landing >= liftOff) {
+    throw new RazerProtocolError(`Landing (${landing}) must be below lift-off (${liftOff}).`);
+  }
+  return {
+    ...RAZER_WRITE.liftOff,
+    args: [0x00, RAZER_SENSOR_SELECTOR, liftOff - 1, landing - 1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+  };
+}
+
 /**
  * Legacy polling encodes the rate as a divisor of 1000, so it cannot express
  * the HyperPolling rates. Wireless answers this command as unsupported.